@winspan/claude-forge 8.50.6 → 8.51.0

package/tests/unit/daemon/stop-handler-behavior-summary.test.ts

@@ -0,0 +1,202 @@
+/**
+ * H2 Phase 1 safety-net: StopHandler behavior summary.
+ *
+ * Locks the output format and aggregation logic of `generateBehaviorSummary`
+ * before its inline SQL (events GROUP BY tool_name / Agent-Task subagent_type /
+ * COUNT skill_invocations) is migrated into EventOperations / SkillOperations.
+ *
+ * Since `generateBehaviorSummary` is `private`, we exercise it indirectly via
+ * `handle()` and capture the resume content passed to `resume.save`. That is
+ * also the actually-exercised path in production, so this gives a higher-value
+ * baseline than reflection-style private access.
+ *
+ * NOTE on test location: the spec listed `src/tests/...`, but vitest.config.ts
+ * only discovers `tests/unit/**` and `tests/integration/**`, so the file is
+ * placed under `tests/unit/daemon/` to ensure it actually runs. The semantic
+ * intent (a unit test, not an integration test) is preserved.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { StopHandler } from '../../../src/daemon/handlers/stop.js';
+import { SQLiteStorage } from '../../../src/core/storage/sqlite.js';
+import type { HistoryExporter } from '../../../src/daemon/handlers/history-exporter.js';
+import type { StopEvent } from '../../../src/core/types.js';
+
+const SESSION = 'sess-behavior-summary';
+const PROJECT = '/tmp/proj-behavior-summary';
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+function makeEvent(): StopEvent {
+  return {
+    session_id: SESSION,
+    project_path: PROJECT,
+    timestamp: nowIso(),
+    hook_type: 'Stop',
+  };
+}
+
+describe('StopHandler.generateBehaviorSummary (safety-net)', () => {
+  let storage: SQLiteStorage;
+  let exporter: HistoryExporter;
+  let saved: { content: string | null };
+
+  // Build a mock ResumeManager that returns a known stub from generate() and
+  // captures whatever the handler ends up passing to save().
+  function makeResumeMock(): { generate: ReturnType<typeof vi.fn>; save: ReturnType<typeof vi.fn>; load: ReturnType<typeof vi.fn>; clear: ReturnType<typeof vi.fn> } {
+    return {
+      generate: vi.fn().mockReturnValue('STUB_RESUME\n_生成时间: 2026-01-01T00:00:00.000Z_\n'),
+      save: vi.fn((_p: string, c: string) => { saved.content = c; }),
+      load: vi.fn(),
+      clear: vi.fn(),
+    };
+  }
+
+  beforeEach(() => {
+    storage = new SQLiteStorage(':memory:');
+    saved = { content: null };
+    exporter = { export: vi.fn().mockResolvedValue(undefined) } as unknown as HistoryExporter;
+  });
+
+  afterEach(() => {
+    storage.close();
+  });
+
+  it('does not append summary when storage has no events for the session', async () => {
+    const resume = makeResumeMock();
+    const handler = new StopHandler(exporter, resume as any, null, storage, null, null);
+
+    const res = await handler.handle(makeEvent());
+    expect(res.allow).toBe(true);
+    // resume.save should still be called (resume content exists)
+    expect(resume.save).toHaveBeenCalledTimes(1);
+    expect(saved.content).not.toBeNull();
+    // Behavior summary line MUST NOT appear when there are no tool calls
+    expect(saved.content!).not.toContain('会话行为');
+  });
+
+  it('appends a tool-only behavior summary when only tool events exist', async () => {
+    // Seed events: 2 Bash, 1 Edit — no Agent/Task, no skill invocations
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'PreToolUse', tool_name: 'Bash', tool_input: { command: 'ls' },
+    });
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'PreToolUse', tool_name: 'Bash', tool_input: { command: 'pwd' },
+    });
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'PreToolUse', tool_name: 'Edit', tool_input: { file_path: '/x' },
+    });
+
+    const resume = makeResumeMock();
+    const handler = new StopHandler(exporter, resume as any, null, storage, null, null);
+
+    const res = await handler.handle(makeEvent());
+    expect(res.allow).toBe(true);
+    expect(saved.content).not.toBeNull();
+
+    // Must contain a behavior summary line with total tool calls
+    expect(saved.content!).toContain('**会话行为**');
+    expect(saved.content!).toContain('工具调用 3 次');
+    expect(saved.content!).toContain('Agent 委托 0 次');
+    expect(saved.content!).toContain('Skill 调用 0 次');
+  });
+
+  it('includes Agent delegation counts and agent type names', async () => {
+    // 2 normal tools + 2 Task delegations to different subagents
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'PreToolUse', tool_name: 'Bash', tool_input: { command: 'ls' },
+    });
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'PreToolUse', tool_name: 'Read', tool_input: { file_path: '/a' },
+    });
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'PreToolUse', tool_name: 'Task',
+      tool_input: { subagent_type: 'explore', description: 'find x' },
+    });
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'PreToolUse', tool_name: 'Task',
+      tool_input: { subagent_type: 'coder', description: 'fix y' },
+    });
+
+    const resume = makeResumeMock();
+    const handler = new StopHandler(exporter, resume as any, null, storage, null, null);
+
+    await handler.handle(makeEvent());
+    expect(saved.content).not.toBeNull();
+
+    const summary = saved.content!;
+    expect(summary).toContain('工具调用 4 次');
+    expect(summary).toContain('Agent 委托 2 次');
+    // Agent names appear in parenthesised detail
+    expect(summary).toMatch(/explore|coder/);
+  });
+
+  it('includes skill invocation count when skill_invocations rows exist', async () => {
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'PreToolUse', tool_name: 'Bash', tool_input: { command: 'ls' },
+    });
+    storage.writeSkillInvocation({
+      id: 'si-bs-1', route_request_id: null, session_id: SESSION,
+      agent_id: null, skill_id: 'official-tdd',
+      invocation_type: 'dynamic', reason: null,
+      workflow: null, phase: null, feature_slug: null, artifact_path: null,
+      depth: 0, success: 1, error: null, timestamp: Date.now(),
+    });
+    storage.writeSkillInvocation({
+      id: 'si-bs-2', route_request_id: null, session_id: SESSION,
+      agent_id: null, skill_id: 'official-debug',
+      invocation_type: 'dynamic', reason: null,
+      workflow: null, phase: null, feature_slug: null, artifact_path: null,
+      depth: 0, success: 1, error: null, timestamp: Date.now(),
+    });
+
+    const resume = makeResumeMock();
+    const handler = new StopHandler(exporter, resume as any, null, storage, null, null);
+
+    await handler.handle(makeEvent());
+    expect(saved.content).not.toBeNull();
+    expect(saved.content!).toContain('Skill 调用 2 次');
+  });
+
+  it('does not include events from other sessions in the summary', async () => {
+    // Same session — 1 tool call
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: nowIso(),
+      hook_type: 'PreToolUse', tool_name: 'Bash', tool_input: { command: 'ls' },
+    });
+    // Different session — 5 tool calls + 3 skill invocations: MUST be excluded
+    for (let i = 0; i < 5; i++) {
+      storage.writeEvent({
+        session_id: 'other-session', project_path: PROJECT, timestamp: nowIso(),
+        hook_type: 'PreToolUse', tool_name: 'Bash', tool_input: { command: 'noise' },
+      });
+    }
+    for (let i = 0; i < 3; i++) {
+      storage.writeSkillInvocation({
+        id: `si-noise-${i}`, route_request_id: null, session_id: 'other-session',
+        agent_id: null, skill_id: 'official-noise',
+        invocation_type: 'dynamic', reason: null,
+        workflow: null, phase: null, feature_slug: null, artifact_path: null,
+        depth: 0, success: 1, error: null, timestamp: Date.now(),
+      });
+    }
+
+    const resume = makeResumeMock();
+    const handler = new StopHandler(exporter, resume as any, null, storage, null, null);
+
+    await handler.handle(makeEvent());
+    expect(saved.content).not.toBeNull();
+    expect(saved.content!).toContain('工具调用 1 次');
+    expect(saved.content!).toContain('Skill 调用 0 次');
+  });
+});

package/tests/unit/daemon/task-segmenter-recover.test.ts

@@ -0,0 +1,84 @@
+/**
+ * 单测：TaskSegmenter.completeCurrentTask recover fallback
+ *
+ * 覆盖：
+ *   - Map 为空但 DB 有 active task → completeCurrentTask 仍能将其转为 completed
+ *   - Map 不为空的正常路径不退化
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { SQLiteStorage } from '../../../src/core/storage/sqlite.js';
+import { TaskSegmenter } from '../../../src/daemon/services/task-segmenter.js';
+
+const SESSION = 'sess-segmenter-recover';
+
+function openStorage(tmp: string): SQLiteStorage {
+  return new SQLiteStorage(join(tmp, 'data.db'));
+}
+
+describe('TaskSegmenter.completeCurrentTask recover fallback', () => {
+  let tmp: string;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'forge-segmenter-recover-'));
+    storage = openStorage(tmp);
+  });
+
+  afterEach(() => {
+    try { storage.close(); } catch { /* ignore */ }
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('Map 为空但 DB 有 active task → completeCurrentTask 将其转 completed', () => {
+    // 直接写 active task 到 DB（不经过 processPrompt，模拟 daemon 重启后内存丢失）
+    storage.writeTask({
+      id: 'task-in-db',
+      session_id: SESSION,
+      title: 'Persisted active task',
+      start_time: '2026-01-01T10:00:00.000Z',
+    });
+
+    // 确认此刻 DB 中是 active
+    expect(storage.getTask('task-in-db')?.status).toBe('active');
+
+    // 创建新的 TaskSegmenter，Map 为空（模拟重启）
+    const segmenter = new TaskSegmenter(storage);
+
+    // Stop hook 触发 completeCurrentTask，Map 中没有该 session 的 entry
+    segmenter.completeCurrentTask(SESSION, '2026-01-01T10:30:00.000Z');
+
+    // task 应该被 recover 并标记为 completed
+    const task = storage.getTask('task-in-db');
+    expect(task?.status).toBe('completed');
+    expect(task?.end_time).toBe('2026-01-01T10:30:00.000Z');
+  });
+
+  it('DB 中无 active task 时 completeCurrentTask 安全退出（不报错）', () => {
+    // 完全空 DB，completeCurrentTask 不应抛出
+    const segmenter = new TaskSegmenter(storage);
+    expect(() => {
+      segmenter.completeCurrentTask(SESSION, '2026-01-01T10:30:00.000Z');
+    }).not.toThrow();
+  });
+
+  it('Map 有 entry 时（正常路径）completeCurrentTask 正常关闭 task', () => {
+    const segmenter = new TaskSegmenter(storage);
+
+    // 通过 processPrompt 走正常路径，将 task 写入 Map
+    const taskId = segmenter.processPrompt(SESSION, 'implement feature', '2026-01-01T10:00:00.000Z');
+
+    // 确认 DB 中是 active
+    expect(storage.getTask(taskId)?.status).toBe('active');
+
+    // completeCurrentTask 正常关闭
+    segmenter.completeCurrentTask(SESSION, '2026-01-01T10:30:00.000Z');
+
+    const task = storage.getTask(taskId);
+    expect(task?.status).toBe('completed');
+    expect(task?.end_time).toBe('2026-01-01T10:30:00.000Z');
+  });
+});

package/tests/unit/event-fields.test.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect } from 'vitest';
+import {
+  getCommand,
+  getFilePath,
+  getUserPrompt,
+  getSubagentType,
+} from '../../src/core/event-fields.js';
+import type { ForgeEvent } from '../../src/core/types.js';
+
+function makeEvent(overrides: Partial<ForgeEvent> = {}): ForgeEvent {
+  return {
+    session_id: 's',
+    project_path: '/p',
+    timestamp: '2026-05-18T00:00:00Z',
+    hook_type: 'PreToolUse',
+    ...overrides,
+  };
+}
+
+describe('event-fields getters', () => {
+  describe('getCommand', () => {
+    it('returns undefined when tool_input is missing', () => {
+      expect(getCommand(makeEvent())).toBeUndefined();
+    });
+
+    it('returns undefined when command is not a string', () => {
+      expect(getCommand(makeEvent({ tool_input: { command: 42 as unknown as string } }))).toBeUndefined();
+    });
+
+    it('returns the command string when present', () => {
+      expect(getCommand(makeEvent({ tool_input: { command: 'ls -la' } }))).toBe('ls -la');
+    });
+  });
+
+  describe('getFilePath', () => {
+    it('returns undefined when tool_input is missing', () => {
+      expect(getFilePath(makeEvent())).toBeUndefined();
+    });
+
+    it('returns undefined when file_path is wrong type', () => {
+      expect(getFilePath(makeEvent({ tool_input: { file_path: 123 as unknown as string } }))).toBeUndefined();
+    });
+
+    it('returns file_path when present', () => {
+      expect(getFilePath(makeEvent({ tool_input: { file_path: '/foo/bar.ts' } }))).toBe('/foo/bar.ts');
+    });
+
+    it('falls back to notebook_path when file_path is missing', () => {
+      expect(getFilePath(makeEvent({ tool_input: { notebook_path: '/x.ipynb' } }))).toBe('/x.ipynb');
+    });
+
+    it('returns undefined for empty string', () => {
+      expect(getFilePath(makeEvent({ tool_input: { file_path: '' } }))).toBeUndefined();
+    });
+  });
+
+  describe('getUserPrompt', () => {
+    it('returns undefined when neither field set', () => {
+      expect(getUserPrompt(makeEvent())).toBeUndefined();
+    });
+
+    it('returns top-level user_prompt when set', () => {
+      expect(getUserPrompt(makeEvent({ user_prompt: 'hi' }))).toBe('hi');
+    });
+
+    it('falls back to tool_input.user_prompt envelope', () => {
+      expect(getUserPrompt(makeEvent({ tool_input: { user_prompt: 'envelope' } }))).toBe('envelope');
+    });
+
+    it('returns undefined when fallback is wrong type', () => {
+      expect(getUserPrompt(makeEvent({ tool_input: { user_prompt: 7 as unknown as string } }))).toBeUndefined();
+    });
+  });
+
+  describe('getSubagentType', () => {
+    it('returns undefined when missing', () => {
+      expect(getSubagentType(makeEvent())).toBeUndefined();
+    });
+
+    it('returns undefined when wrong type', () => {
+      expect(getSubagentType(makeEvent({ tool_input: { subagent_type: {} as unknown as string } }))).toBeUndefined();
+    });
+
+    it('returns the subagent_type string', () => {
+      expect(getSubagentType(makeEvent({ tool_input: { subagent_type: 'planner' } }))).toBe('planner');
+    });
+  });
+});

package/tests/unit/event-parser.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import { EventParser } from '../../src/daemon/event-parser.js';
+
+const parser = new EventParser();
+
+function makeRaw(overrides: Record<string, unknown> = {}) {
+  return JSON.stringify({
+    hook_type: 'PreToolUse',
+    timestamp: '2026-05-18T00:00:00Z',
+    session_id: 's1',
+    project_path: '/p',
+    tool_name: 'Bash',
+    ...overrides,
+  });
+}
+
+describe('EventParser', () => {
+  it('generates a UUID event_id when none is provided', () => {
+    const evt = parser.parse(makeRaw());
+    expect(evt.event_id).toMatch(/^[0-9a-f-]{36}$/i);
+  });
+
+  it('passes through a valid externally-supplied event_id', () => {
+    const id = '11111111-2222-4333-8444-555555555555';
+    const evt = parser.parse(makeRaw({ event_id: id }));
+    expect(evt.event_id).toBe(id);
+  });
+
+  it('rejects a malformed event_id via schema', () => {
+    expect(() => parser.parse(makeRaw({ event_id: 'not-a-uuid' }))).toThrow();
+  });
+
+  it('lands tool_input fields into ToolInputFields shape', () => {
+    const evt = parser.parse(
+      makeRaw({ tool_input: { command: 'ls', file_path: '/a/b.ts', extra: 1 } })
+    );
+    expect(evt.tool_input?.command).toBe('ls');
+    expect(evt.tool_input?.file_path).toBe('/a/b.ts');
+    expect(evt.tool_input?.extra).toBe(1);
+  });
+
+  it('handles UserPromptSubmit hook with user_prompt at top level', () => {
+    const evt = parser.parse(
+      JSON.stringify({
+        hook_type: 'UserPromptSubmit',
+        timestamp: '2026-05-18T00:00:00Z',
+        session_id: 's1',
+        project_path: '/p',
+        user_prompt: 'hi there',
+      })
+    );
+    expect(evt.user_prompt).toBe('hi there');
+    expect(evt.event_id).toMatch(/^[0-9a-f-]{36}$/i);
+  });
+});

package/tests/unit/hooks/resolve-project-path.test.ts

@@ -0,0 +1,122 @@
+/**
+ * Safety-net unit tests for the bash function `resolve_project_path` in
+ * `src/hooks/hook-lib.sh`.
+ *
+ * We invoke bash directly through `child_process.execSync`, sourcing the lib
+ * and calling the function with various inputs. Each fixture is created under
+ * a per-test scratch directory in $TMPDIR (or /tmp) and cleaned up afterwards.
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const HOOK_LIB = path.resolve(__dirname, '../../../src/hooks/hook-lib.sh');
+
+/**
+ * Invoke `resolve_project_path` and return its stdout (the resolved path).
+ * Throws if the bash invocation itself fails.
+ */
+function callResolve(input: string, options: { cwd?: string } = {}): string {
+  // Use a single-quoted bash command body to avoid shell quoting hell;
+  // pass the input as $1 to the inner function so we don't need to escape it.
+  const cmd = `bash -c 'source "$1" && resolve_project_path "$2"' _ "${HOOK_LIB}" "${input}"`;
+  return execSync(cmd, {
+    cwd: options.cwd ?? process.cwd(),
+    encoding: 'utf-8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  }).toString();
+}
+
+describe('hook-lib.sh :: resolve_project_path', () => {
+  let scratch: string;
+  let repoRoot: string;
+  let nestedDir: string;
+  let worktreeRoot: string;
+  let nonGitDir: string;
+
+  beforeAll(() => {
+    scratch = fs.mkdtempSync(path.join(os.tmpdir(), 'forge-resolve-'));
+
+    // Fixture 1: standard git repo with .git as a directory
+    repoRoot = path.join(scratch, 'repo');
+    nestedDir = path.join(repoRoot, 'a', 'b', 'c');
+    fs.mkdirSync(nestedDir, { recursive: true });
+    fs.mkdirSync(path.join(repoRoot, '.git'));
+
+    // Fixture 2: git worktree where .git is a regular file
+    worktreeRoot = path.join(scratch, 'worktree');
+    fs.mkdirSync(path.join(worktreeRoot, 'src'), { recursive: true });
+    fs.writeFileSync(
+      path.join(worktreeRoot, '.git'),
+      'gitdir: /tmp/somewhere/else\n',
+    );
+
+    // Fixture 3: a plain directory with no git ancestor anywhere up to scratch
+    nonGitDir = path.join(scratch, 'plain', 'x', 'y');
+    fs.mkdirSync(nonGitDir, { recursive: true });
+  });
+
+  afterAll(() => {
+    fs.rmSync(scratch, { recursive: true, force: true });
+  });
+
+  it('case 1: resolves a deeply nested git child dir to repo root', () => {
+    const out = callResolve(nestedDir);
+    expect(out).toBe(repoRoot);
+  });
+
+  it('case 2: returns input cwd unchanged when no .git is found upstream', () => {
+    // To make this test robust we point HOME-ish ancestor away from any real
+    // repo by passing the fixture directly. Even if /tmp ancestors had .git
+    // somewhere, the guard caps at 64 levels. Here scratch lives in /tmp and
+    // has no .git, so the function should fall back to the input.
+    const out = callResolve(nonGitDir);
+    expect(out).toBe(nonGitDir);
+  });
+
+  it('case 3: empty input falls back to $PWD of the invoking shell', () => {
+    // We invoke bash with cwd=repoRoot/a so $PWD is that path and there IS a
+    // git ancestor — it should still resolve to repoRoot because empty input
+    // triggers `dir=$PWD` and then upstream search succeeds.
+    // Note: on macOS /tmp and /var are symlinked to /private/tmp /private/var,
+    // and bash's $PWD reflects the resolved path. We compare against realpath
+    // so the test is portable.
+    const startCwd = path.join(repoRoot, 'a');
+    const out = callResolve('', { cwd: startCwd });
+    expect(out).toBe(fs.realpathSync(repoRoot));
+  });
+
+  it('case 4: recognises git worktree (.git is a file, not a directory)', () => {
+    const sub = path.join(worktreeRoot, 'src');
+    const out = callResolve(sub);
+    expect(out).toBe(worktreeRoot);
+  });
+
+  it('case 5: walking all the way up without finding .git returns the original input', () => {
+    // /nonexistent/deeply/nested has no .git anywhere up to /
+    const out = callResolve('/nonexistent/deeply/nested');
+    expect(out).toBe('/nonexistent/deeply/nested');
+  });
+
+  it('case 6: simulates hook INPUT JSON with cwd pointing to nested dir', () => {
+    // Mirrors what a real hook does:
+    //   RAW_CWD=$(echo "$INPUT" | jq -r '.cwd // ""')
+    //   PROJECT_PATH=$(resolve_project_path "${RAW_CWD:-$PWD}")
+    // We just test resolve_project_path with the cwd extracted from such JSON.
+    const extractedCwd = nestedDir; // simulates jq result for cwd in fixture repo
+    const out = callResolve(extractedCwd);
+    expect(out).toBe(repoRoot);
+  });
+
+  it('case 7: hook INPUT with empty cwd field falls back to shell $PWD (repoRoot)', () => {
+    // When jq returns "" for .cwd, bash sets RAW_CWD="" and calls
+    // resolve_project_path "${RAW_CWD:-$PWD}" — effectively resolve_project_path ""
+    // with bash cwd=repoRoot/a, so $PWD-based lookup should find repoRoot.
+    const startCwd = path.join(repoRoot, 'a');
+    const out = callResolve('', { cwd: startCwd });
+    expect(out).toBe(fs.realpathSync(repoRoot));
+  });
+});