Merge pull request #1330 from wakatime/develop

Release v2.2.3

Author: alanhamlett

pkg/ai/ai.go

@@ -141,7 +141,7 @@ func WithAISync(config Config) heartbeat.HandleOption {
 				return next(ctx, hh)
 			}
 
-			heartbeats = preserveAttributes(heartbeats, hh)
+			heartbeats, firstHumanEdit := preserveAttributes(heartbeats, hh)
 
 			heartbeats = applyProject(heartbeats, config)
 
@@ -176,7 +176,19 @@ func WithAISync(config Config) heartbeat.HandleOption {
 					continue // remove this human heartbeat, it's actually AI
 				}
 
-				if h.Time > minHeartbeatTime-1 && h.Time < maxHeartbeatTime+1 {
+				inRange := func(windowMinutes float64) bool {
+					const secondsPerMinute = 60.0
+
+					windowSeconds := windowMinutes * secondsPerMinute
+
+					return h.Time > minHeartbeatTime-windowSeconds && h.Time < maxHeartbeatTime+windowSeconds
+				}
+
+				if inRange(2) {
+					h.Category = "ai coding"
+				}
+
+				if (firstHumanEdit == nil || *firstHumanEdit > h.Time) && inRange(30) {
 					h.Category = "ai coding"
 				}
 
@@ -302,15 +314,21 @@ func getLastParsedAt(ctx context.Context, v *viper.Viper) (time.Time, error) {
 // preserveAttributes mutates aiHeartbeats pulling in the attributes from
 // humanHeartbeats, which should normally have more details already populated
 // from the IDE than available on aiHeartbeats.
-func preserveAttributes(aiHeartbeats []heartbeat.Heartbeat, humanHeartbeats []heartbeat.Heartbeat) Heartbeats {
+func preserveAttributes(aiHeartbeats []heartbeat.Heartbeat, humanHeartbeats []heartbeat.Heartbeat) (Heartbeats, *float64) {
 	if len(humanHeartbeats) == 0 {
-		return aiHeartbeats
+		return aiHeartbeats, nil
 	}
 
 	originals := make(map[string][]heartbeat.Heartbeat, len(humanHeartbeats))
 	fallbackProjectFolder := ""
 
+	var firstHumanEdit *float64
+
 	for _, h := range humanHeartbeats {
+		if (firstHumanEdit == nil || h.Time < *firstHumanEdit) && h.HumanLineChanges != nil && *h.HumanLineChanges != 0 {
+			firstHumanEdit = &h.Time
+		}
+
 		originals[h.Entity] = append(originals[h.Entity], h)
 
 		if fallbackProjectFolder == "" {
@@ -333,7 +351,7 @@ func preserveAttributes(aiHeartbeats []heartbeat.Heartbeat, humanHeartbeats []he
 		}
 	}
 
-	return aiHeartbeats
+	return aiHeartbeats, firstHumanEdit
 }
 
 func preserveAttributesFromHumanHeartbeat(aiHeartbeat *heartbeat.Heartbeat, human heartbeat.Heartbeat) {

pkg/ai/ai_test.go

@@ -432,6 +432,117 @@ func TestSendHeartbeats_WithAIParsingBatchAppliedOnce(t *testing.T) {
 	assert.Eventually(t, func() bool { return numCalls == 1 }, time.Second, 50*time.Millisecond)
 }
 
+func TestWithAISyncMarksHumanHeartbeatsAsAICoding(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	t.Setenv("USERPROFILE", home)
+
+	entity, err := filepath.Abs("testdata/main.go")
+	require.NoError(t, err)
+
+	entity = strings.ReplaceAll(entity, "\\", "/")
+
+	local, err := filepath.Abs("testdata/localfile.go")
+	require.NoError(t, err)
+
+	local = strings.ReplaceAll(local, "\\", "/")
+
+	transcriptDir := filepath.Join(home, ".claude", "projects", "sample-project")
+	require.NoError(t, os.MkdirAll(transcriptDir, 0o755))
+
+	transcriptPath := filepath.Join(transcriptDir, "session.jsonl")
+	transcript := strings.Join([]string{
+		"{\"timestamp\":\"2026-03-18T12:00:00Z\",\"version\":\"2.1.45\"," +
+			"\"toolUseResult\":{\"filePath\":\"" + entity + "\"," +
+			"\"structuredPatch\":[{\"oldLines\":3,\"newLines\":5}]}}",
+		"{\"timestamp\":\"2026-03-18T12:30:00Z\",\"toolUseResult\":{" +
+			"\"filePath\":\"" + local + "\",\"content\":\"first\\nsecond\\nthird\"}}",
+	}, "\n") + "\n"
+	require.NoError(t, os.WriteFile(transcriptPath, []byte(transcript), 0o644))
+
+	tmpInternal, err := os.CreateTemp(t.TempDir(), "wakatime-internal")
+	require.NoError(t, err)
+
+	defer tmpInternal.Close()
+
+	v := viper.New()
+	v.Set("internal-config", tmpInternal.Name())
+	v.Set("internal.ai_heartbeats_last_parsed_at", time.Date(2026, 3, 18, 11, 0, 0, 0, time.UTC).Format(ini.DateFormat))
+
+	handle := ai.WithAISync(ai.Config{
+		Plugin: "plugin/0.0.1",
+		V:      v,
+	})(func(_ context.Context, hh []heartbeat.Heartbeat) ([]heartbeat.Result, error) {
+		results := make([]heartbeat.Result, len(hh))
+		for i := range hh {
+			results[i] = heartbeat.Result{Heartbeat: hh[i]}
+		}
+
+		return results, nil
+	})
+
+	humanWithinTwoMinutes := "/tmp/human-within-two-minutes.go"
+	humanWithinThirtyMinutesNoChangesBeforeEdit := "/tmp/human-within-thirty-minutes-no-changes-before-edit.go"
+	humanWithinThirtyMinutesWithChanges := "/tmp/human-within-thirty-minutes-with-changes.go"
+	humanWithinThirtyMinutesNoChangesAfterEdit := "/tmp/human-within-thirty-minutes-no-changes-after-edit.go"
+	humanOutsideThirtyMinutes := "/tmp/human-outside-thirty-minutes.go"
+
+	got, err := handle(t.Context(), []heartbeat.Heartbeat{
+		{
+			Entity:           humanWithinTwoMinutes,
+			EntityType:       heartbeat.FileType,
+			Category:         "debugging",
+			HumanLineChanges: heartbeat.PointerTo(3),
+			Time:             1773835260.1,
+			UserAgent:        "editor/1.2.3",
+		},
+		{
+			Entity:           humanWithinThirtyMinutesNoChangesBeforeEdit,
+			EntityType:       heartbeat.FileType,
+			Category:         "debugging",
+			HumanLineChanges: heartbeat.PointerTo(0),
+			Time:             1773836999.1,
+			UserAgent:        "editor/1.2.3",
+		},
+		{
+			Entity:           humanWithinThirtyMinutesWithChanges,
+			EntityType:       heartbeat.FileType,
+			Category:         "debugging",
+			HumanLineChanges: heartbeat.PointerTo(1),
+			Time:             1773838500.2,
+			UserAgent:        "editor/1.2.3",
+		},
+		{
+			Entity:           humanWithinThirtyMinutesNoChangesAfterEdit,
+			EntityType:       heartbeat.FileType,
+			Category:         "debugging",
+			HumanLineChanges: heartbeat.PointerTo(0),
+			Time:             1773838500.1,
+			UserAgent:        "editor/1.2.3",
+		},
+		{
+			Entity:           humanOutsideThirtyMinutes,
+			EntityType:       heartbeat.FileType,
+			Category:         "debugging",
+			HumanLineChanges: heartbeat.PointerTo(0),
+			Time:             1773839100.1,
+			UserAgent:        "editor/1.2.3",
+		},
+	})
+	require.NoError(t, err)
+
+	categoriesByEntity := make(map[string]string, len(got))
+	for _, result := range got {
+		categoriesByEntity[result.Heartbeat.Entity] = result.Heartbeat.Category
+	}
+
+	assert.Equal(t, "ai coding", categoriesByEntity[humanWithinTwoMinutes])
+	assert.Equal(t, "ai coding", categoriesByEntity[humanWithinThirtyMinutesNoChangesBeforeEdit])
+	assert.Equal(t, "debugging", categoriesByEntity[humanWithinThirtyMinutesWithChanges])
+	assert.Equal(t, "debugging", categoriesByEntity[humanWithinThirtyMinutesNoChangesAfterEdit])
+	assert.Equal(t, "debugging", categoriesByEntity[humanOutsideThirtyMinutes])
+}
+
 func resetSingleton(t *testing.T) {
 	t.Helper()
 

pkg/ai/copilot.go

@@ -149,6 +149,33 @@ type (
 	}
 )
 
+func (v *copilotVariable) UnmarshalJSON(data []byte) error {
+	type alias struct {
+		Kind  string          `json:"kind"`
+		ID    string          `json:"id"`
+		Value json.RawMessage `json:"value"`
+	}
+
+	var decoded alias
+	if err := json.Unmarshal(data, &decoded); err != nil {
+		return err
+	}
+
+	v.Kind = decoded.Kind
+	v.ID = decoded.ID
+
+	if len(decoded.Value) == 0 || string(decoded.Value) == "null" {
+		return nil
+	}
+
+	var pathValue copilotPathValue
+	if err := json.Unmarshal(decoded.Value, &pathValue); err == nil {
+		v.Value = &pathValue
+	}
+
+	return nil
+}
+
 func (m *copilotMessageWithURIs) UnmarshalJSON(data []byte) error {
 	if data == nil || string(data) == "null" {
 		return nil

pkg/ai/copilot_test.go

@@ -221,3 +221,40 @@ func TestCopilotParseJSONLSession(t *testing.T) {
 	assert.Equal(t, "Copilot session-2", got[2].Entity)
 	assert.Equal(t, heartbeat.AppType, got[2].EntityType)
 }
+
+func TestCopilotParseJSONLSession_IgnoresStringVariableValues(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	t.Setenv("USERPROFILE", home)
+
+	workspaceDir := filepath.Join(home, "Library", "Application Support", "Code", "User", "workspaceStorage", "workspace-3")
+	require.NoError(t, os.MkdirAll(filepath.Join(workspaceDir, "chatSessions"), 0o755))
+
+	sessionPath := filepath.Join(workspaceDir, "chatSessions", "session-3.jsonl")
+	lines := []string{
+		strings.Join([]string{
+			`{"kind":0,"v":{"version":3,"creationDate":1771000000000,`,
+			`"sessionId":"session-3","requests":[{"requestId":"request-b",`,
+			`"timestamp":1771000005000,`,
+			`"agent":{"extensionVersion":"0.43.0"},`,
+			`"message":{"text":"Find bugs in this repo"},`,
+			`"variableData":{"variables":[{"id":"vscode.customizations.index",`,
+			`"kind":"promptText","value":"<skills>...</skills>"}]},`,
+			`"response":[]}]}}`,
+		}, ""),
+		`{"kind":1,"k":["requests",0,"modelState"],"v":{"value":1,"completedAt":1771000009000}}`,
+	}
+	require.NoError(t, os.WriteFile(sessionPath, []byte(strings.Join(lines, "\n")+"\n"), 0o644))
+
+	got, err := ai.Copilot{
+		After:             time.Unix(1771000000, 0),
+		FallbackUserAgent: "editor/1.0.0",
+	}.Parse(t.Context())
+	require.NoError(t, err)
+	require.Len(t, got, 2)
+
+	assert.Equal(t, "Copilot session-3", got[0].Entity)
+	assert.Equal(t, heartbeat.AppType, got[0].EntityType)
+	assert.Equal(t, "Copilot session-3", got[1].Entity)
+	assert.Equal(t, heartbeat.AppType, got[1].EntityType)
+}

pkg/ai/helpers_internal_test.go

@@ -449,7 +449,7 @@ func TestPreserveAttributesMutatesAIHeartbeats(t *testing.T) {
 		},
 	}
 
-	got := preserveAttributes(aiHeartbeats, humanHeartbeats)
+	got, _ := preserveAttributes(aiHeartbeats, humanHeartbeats)
 
 	require.Len(t, got, 1)
 	assert.Same(t, &aiHeartbeats[0], &got[0])
@@ -490,7 +490,7 @@ func TestPreserveAttributes_AppHeartbeatFallsBackToHumanProjectFolder(t *testing
 		},
 	}
 
-	got := preserveAttributes(aiHeartbeats, humanHeartbeats)
+	got, _ := preserveAttributes(aiHeartbeats, humanHeartbeats)
 
 	require.Len(t, got, 1)
 	assert.Equal(t, "/tmp/project-override", got[0].ProjectPathOverride)