chatccc 0.2.6 → 0.2.7

package/src/__tests__/cursor-session-meta-store.test.ts

@@ -0,0 +1,212 @@
+// =============================================================================
+// cursor-session-meta-store.test.ts — sessionId→{cwd,model} 持久化的护栏单测
+// =============================================================================
+// 行为契约（与 cursor-adapter.getSessionInfo 配合，决定 /git、/status、/sessions
+// 在 Cursor 会话上是否显示正确）：
+//   - 文件不存在 / 损坏 / 非法 schema 时 get 返回 undefined，不抛异常
+//   - set 部分合并：只覆盖非空字段，已有字段保持不变
+//   - 同实例 set→get 立即可读（内存缓存）
+//   - 跨实例（同 filePath）get 仍能读到（落盘验证）
+//   - cwd 缺失的记录视为不完整（get 返回 undefined）
+//   - 历史 schema（值为字符串）兼容读取，被视作 { cwd: <string> }
+//   - 多 sessionId 互不影响
+// =============================================================================
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, rm, writeFile, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { createCursorSessionMetaStore } from "../adapters/cursor-session-meta-store.ts";
+
+let tmpDir: string;
+let storePath: string;
+
+beforeEach(async () => {
+  tmpDir = await mkdtemp(join(tmpdir(), "chatccc-metastore-"));
+  storePath = join(tmpDir, "cursor-session-meta.json");
+});
+
+afterEach(async () => {
+  await rm(tmpDir, { recursive: true, force: true });
+});
+
+describe("createCursorSessionMetaStore — 文件不存在 / 损坏的鲁棒性", () => {
+  it("文件不存在时 get 返回 undefined（不抛）", async () => {
+    const store = createCursorSessionMetaStore(storePath);
+    await expect(store.get("any-sid")).resolves.toBeUndefined();
+  });
+
+  it("JSON 损坏时 get 返回 undefined，且后续 set 仍可正常写入", async () => {
+    await writeFile(storePath, "{not valid json", "utf-8");
+    const store = createCursorSessionMetaStore(storePath);
+
+    await expect(store.get("sid-1")).resolves.toBeUndefined();
+    await store.set("sid-1", { cwd: "/tmp/recovered" });
+    await expect(store.get("sid-1")).resolves.toEqual({ cwd: "/tmp/recovered" });
+  });
+
+  it("文件根是数组而非对象时视作空映射（防御非法 schema）", async () => {
+    await writeFile(storePath, JSON.stringify(["sid-1", "/tmp"]), "utf-8");
+    const store = createCursorSessionMetaStore(storePath);
+    await expect(store.get("sid-1")).resolves.toBeUndefined();
+  });
+
+  it("条目为非对象/非字符串时被忽略（防御非法 schema）", async () => {
+    await writeFile(
+      storePath,
+      JSON.stringify({
+        "sid-ok": { cwd: "/tmp/ok" },
+        "sid-num": 123,
+        "sid-null": null,
+        "sid-arr": ["x"],
+      }),
+      "utf-8",
+    );
+    const store = createCursorSessionMetaStore(storePath);
+    await expect(store.get("sid-ok")).resolves.toEqual({ cwd: "/tmp/ok" });
+    await expect(store.get("sid-num")).resolves.toBeUndefined();
+    await expect(store.get("sid-null")).resolves.toBeUndefined();
+    await expect(store.get("sid-arr")).resolves.toBeUndefined();
+  });
+
+  it("条目对象内 cwd 缺失或非字符串 → get 返回 undefined（视为不完整）", async () => {
+    await writeFile(
+      storePath,
+      JSON.stringify({
+        "sid-no-cwd": { model: "Composer 2 Fast" },
+        "sid-cwd-num": { cwd: 123, model: "X" },
+        "sid-good": { cwd: "/tmp", model: "Composer 2 Fast" },
+      }),
+      "utf-8",
+    );
+    const store = createCursorSessionMetaStore(storePath);
+    await expect(store.get("sid-no-cwd")).resolves.toBeUndefined();
+    await expect(store.get("sid-cwd-num")).resolves.toBeUndefined();
+    await expect(store.get("sid-good")).resolves.toEqual({
+      cwd: "/tmp",
+      model: "Composer 2 Fast",
+    });
+  });
+});
+
+describe("createCursorSessionMetaStore — 历史 schema 兼容（值为字符串）", () => {
+  it("v1 schema：value 为字符串视作 { cwd: <string> }", async () => {
+    await writeFile(
+      storePath,
+      JSON.stringify({ "sid-v1": "/legacy/path" }),
+      "utf-8",
+    );
+    const store = createCursorSessionMetaStore(storePath);
+    await expect(store.get("sid-v1")).resolves.toEqual({ cwd: "/legacy/path" });
+  });
+
+  it("空字符串值不被视为合法 v1 记录", async () => {
+    await writeFile(storePath, JSON.stringify({ "sid-empty": "" }), "utf-8");
+    const store = createCursorSessionMetaStore(storePath);
+    await expect(store.get("sid-empty")).resolves.toBeUndefined();
+  });
+});
+
+describe("createCursorSessionMetaStore — 读写循环", () => {
+  it("set { cwd } 后 get 返回相同 cwd（无 model 字段）", async () => {
+    const store = createCursorSessionMetaStore(storePath);
+    await store.set("sid-1", { cwd: "F:/proj" });
+    await expect(store.get("sid-1")).resolves.toEqual({ cwd: "F:/proj" });
+  });
+
+  it("set { cwd, model } 后 get 返回完整 meta", async () => {
+    const store = createCursorSessionMetaStore(storePath);
+    await store.set("sid-1", { cwd: "F:/proj", model: "Composer 2 Fast" });
+    await expect(store.get("sid-1")).resolves.toEqual({
+      cwd: "F:/proj",
+      model: "Composer 2 Fast",
+    });
+  });
+
+  it("set 后跨实例（同 filePath）get 仍能读到（落盘验证）", async () => {
+    const writer = createCursorSessionMetaStore(storePath);
+    await writer.set("sid-1", { cwd: "/home/u/code", model: "Sonnet 4.7" });
+
+    const reader = createCursorSessionMetaStore(storePath);
+    await expect(reader.get("sid-1")).resolves.toEqual({
+      cwd: "/home/u/code",
+      model: "Sonnet 4.7",
+    });
+  });
+
+  it("set 部分合并：只更新 cwd 不会清空已有 model", async () => {
+    const store = createCursorSessionMetaStore(storePath);
+    await store.set("sid-1", { cwd: "/old", model: "Composer 2 Fast" });
+    await store.set("sid-1", { cwd: "/new" });
+    await expect(store.get("sid-1")).resolves.toEqual({
+      cwd: "/new",
+      model: "Composer 2 Fast",
+    });
+  });
+
+  it("set 部分合并：只更新 model 不会清空已有 cwd", async () => {
+    const store = createCursorSessionMetaStore(storePath);
+    await store.set("sid-1", { cwd: "/keep", model: "v1" });
+    await store.set("sid-1", { model: "v2" });
+    await expect(store.get("sid-1")).resolves.toEqual({
+      cwd: "/keep",
+      model: "v2",
+    });
+  });
+
+  it("set 时 partial 中的空字符串 / undefined 字段不会覆盖已有值", async () => {
+    const store = createCursorSessionMetaStore(storePath);
+    await store.set("sid-1", { cwd: "/keep", model: "v1" });
+    await store.set("sid-1", { cwd: "", model: undefined });
+    await expect(store.get("sid-1")).resolves.toEqual({
+      cwd: "/keep",
+      model: "v1",
+    });
+  });
+
+  it("第一次 set 不含 cwd → 记录不完整 → get 返回 undefined", async () => {
+    const store = createCursorSessionMetaStore(storePath);
+    await store.set("sid-1", { model: "Composer 2 Fast" });
+    await expect(store.get("sid-1")).resolves.toBeUndefined();
+  });
+
+  it("多 sessionId 互不影响", async () => {
+    const store = createCursorSessionMetaStore(storePath);
+    await store.set("sid-A", { cwd: "/a", model: "mA" });
+    await store.set("sid-B", { cwd: "/b" });
+    await store.set("sid-C", { cwd: "/c", model: "mC" });
+
+    await expect(store.get("sid-A")).resolves.toEqual({ cwd: "/a", model: "mA" });
+    await expect(store.get("sid-B")).resolves.toEqual({ cwd: "/b" });
+    await expect(store.get("sid-C")).resolves.toEqual({ cwd: "/c", model: "mC" });
+    await expect(store.get("sid-missing")).resolves.toBeUndefined();
+  });
+
+  it("set 完全相同的 partial 不会重复写盘（性能优化，行为不变）", async () => {
+    const store = createCursorSessionMetaStore(storePath);
+    await store.set("sid-1", { cwd: "/same", model: "mSame" });
+
+    // 先把文件覆盖为非法内容；如果跳过 IO 则文件保持非法内容
+    await writeFile(storePath, "MARKER_NOT_JSON", "utf-8");
+    await store.set("sid-1", { cwd: "/same", model: "mSame" });
+
+    const raw = await readFile(storePath, "utf-8");
+    expect(raw).toBe("MARKER_NOT_JSON");
+  });
+
+  it("父目录不存在时 set 会自动创建", async () => {
+    const nestedPath = join(tmpDir, "a", "b", "c", "meta.json");
+    const store = createCursorSessionMetaStore(nestedPath);
+    await store.set("sid-1", { cwd: "/deep", model: "deepModel" });
+    await expect(store.get("sid-1")).resolves.toEqual({
+      cwd: "/deep",
+      model: "deepModel",
+    });
+
+    const raw = await readFile(nestedPath, "utf-8");
+    expect(JSON.parse(raw)).toEqual({
+      "sid-1": { cwd: "/deep", model: "deepModel" },
+    });
+  });
+});

package/src/__tests__/fixtures/cursor_partial_only.jsonl

@@ -0,0 +1,5 @@
+{"type":"system","subtype":"init","apiKeySource":"login","cwd":"F:\\Users\\weizhangjian\\feishuclauderprivate","session_id":"abc-only-partial","model":"Composer 2 Fast","permissionMode":"default"}
+{"type":"user","message":{"role":"user","content":[{"type":"text","text":"'hi'"}]},"session_id":"abc-only-partial"}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"hello"}]},"session_id":"abc-only-partial","timestamp_ms":1778411927583}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":" world"}]},"session_id":"abc-only-partial","timestamp_ms":1778411927587}
+{"type":"result","subtype":"success","duration_ms":1000,"duration_api_ms":1000,"is_error":false,"result":"hello world","session_id":"abc-only-partial","request_id":"req-only-partial","usage":{"inputTokens":1,"outputTokens":2}}

package/src/__tests__/fixtures/cursor_partial_with_final.jsonl

@@ -0,0 +1,13 @@
+{"type":"system","subtype":"init","apiKeySource":"login","cwd":"F:\\Users\\weizhangjian\\feishuclauderprivate","session_id":"b60ebd57-33cb-4364-b6fa-bb69657be6e8","model":"Composer 2 Fast","permissionMode":"default"}
+{"type":"user","message":{"role":"user","content":[{"type":"text","text":"'刚才你算的是什么题?'"}]},"session_id":"b60ebd57-33cb-4364-b6fa-bb69657be6e8"}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"你"}]},"session_id":"b60ebd57-33cb-4364-b6fa-bb69657be6e8","timestamp_ms":1778411927583}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"上一题问"}]},"session_id":"b60ebd57-33cb-4364-b6fa-bb69657be6e8","timestamp_ms":1778411927587}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"的是 **1"}]},"session_id":"b60ebd57-33cb-4364-b6fa-bb69657be6e8","timestamp_ms":1778411927587}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"+"}]},"session_id":"b60ebd57-33cb-4364-b6fa-bb69657be6e8","timestamp_ms":1778411927588}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"2=?"}]},"session_id":"b60ebd57-33cb-4364-b6fa-bb69657be6e8","timestamp_ms":1778411927588}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"**(一加"}]},"session_id":"b60ebd57-33cb-4364-b6fa-bb69657be6e8","timestamp_ms":1778411927588}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"二"}]},"session_id":"b60ebd57-33cb-4364-b6fa-bb69657be6e8","timestamp_ms":1778411927589}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"等于几"}]},"session_id":"b60ebd57-33cb-4364-b6fa-bb69657be6e8","timestamp_ms":1778411927589}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":")。"}]},"session_id":"b60ebd57-33cb-4364-b6fa-bb69657be6e8","timestamp_ms":1778411927589}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"你上一题问的是 **1+2=?**(一加二等于几)。"}]},"session_id":"b60ebd57-33cb-4364-b6fa-bb69657be6e8"}
+{"type":"result","subtype":"success","duration_ms":5811,"duration_api_ms":5811,"is_error":false,"result":"你上一题问的是 **1+2=?**(一加二等于几)。","session_id":"b60ebd57-33cb-4364-b6fa-bb69657be6e8","request_id":"ab6f7855-8c3d-414e-b749-ce8ecc062a00","usage":{"inputTokens":34,"outputTokens":92,"cacheReadTokens":10208,"cacheWriteTokens":0}}

package/src/__tests__/fixtures/cursor_with_tool_call.jsonl

@@ -0,0 +1,12 @@
+{"type":"system","subtype":"init","apiKeySource":"login","cwd":"/tmp","session_id":"sid-tool","model":"Composer 2 Fast","permissionMode":"default"}
+{"type":"user","message":{"role":"user","content":[{"type":"text","text":"列出当前目录"}]},"session_id":"sid-tool"}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"我"}]},"session_id":"sid-tool","timestamp_ms":1}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"看下"}]},"session_id":"sid-tool","timestamp_ms":2}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"。"}]},"session_id":"sid-tool","timestamp_ms":3}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"我看下。"},{"type":"tool_use","name":"ls","input":{"path":"."}}]},"session_id":"sid-tool","timestamp_ms":4,"model_call_id":"mc-1"}
+{"type":"user","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tool-1","content":"file1\nfile2","is_error":false}]},"session_id":"sid-tool"}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"两"}]},"session_id":"sid-tool","timestamp_ms":5}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"个文件"}]},"session_id":"sid-tool","timestamp_ms":6}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"。"}]},"session_id":"sid-tool","timestamp_ms":7}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"两个文件。"}]},"session_id":"sid-tool"}
+{"type":"result","subtype":"success","duration_ms":1000,"is_error":false,"result":"我看下。两个文件。","session_id":"sid-tool","request_id":"req-tool","usage":{"inputTokens":1,"outputTokens":2}}

package/src/__tests__/git-command.test.ts

@@ -0,0 +1,288 @@
+import { describe, it, expect } from "vitest";
+import { EventEmitter } from "node:events";
+import { Readable } from "node:stream";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  runGitCommand,
+  formatGitResult,
+  gitResultHeaderTemplate,
+  type GitCommandResult,
+} from "../git-command.ts";
+
+// ---------------------------------------------------------------------------
+// 通过自定义 spawn 桩测试纯逻辑（流处理 / 超时 / 截断 / 退出码）
+// ---------------------------------------------------------------------------
+
+interface StubSpawnOptions {
+  stdout?: string[];
+  stderr?: string[];
+  exitCode?: number | null;
+  /** 数据推送 / close 事件相对于 spawn 的延迟（ms） */
+  emitDelayMs?: number;
+  /** 模拟 spawn 同步抛出（如可执行文件不存在） */
+  throwOnStart?: Error;
+  /** 模拟 child.on("error") 异步触发（如 ENOENT） */
+  emitErrorAfterMs?: number;
+  emitErrorMessage?: string;
+  /** 是否永远不结束（用来测超时） */
+  hang?: boolean;
+}
+
+function makeStubSpawn(opts: StubSpawnOptions): any {
+  return ((..._args: unknown[]) => {
+    if (opts.throwOnStart) throw opts.throwOnStart;
+
+    const child = new EventEmitter() as EventEmitter & {
+      stdout: Readable;
+      stderr: Readable;
+      kill: (sig?: string) => void;
+    };
+    child.stdout = new Readable({ read() {} });
+    child.stderr = new Readable({ read() {} });
+
+    let killed = false;
+    child.kill = (_sig?: string) => {
+      killed = true;
+      child.stdout.push(null);
+      child.stderr.push(null);
+      setImmediate(() => child.emit("close", null));
+    };
+
+    const delay = opts.emitDelayMs ?? 5;
+    setTimeout(() => {
+      if (killed) return;
+      for (const c of opts.stdout ?? []) child.stdout.push(Buffer.from(c));
+      child.stdout.push(null);
+      for (const c of opts.stderr ?? []) child.stderr.push(Buffer.from(c));
+      child.stderr.push(null);
+      if (opts.emitErrorAfterMs !== undefined) {
+        setTimeout(
+          () => child.emit("error", new Error(opts.emitErrorMessage ?? "stub error")),
+          opts.emitErrorAfterMs,
+        );
+      }
+      if (!opts.hang) {
+        setTimeout(() => {
+          if (!killed) child.emit("close", opts.exitCode ?? 0);
+        }, 2);
+      }
+    }, delay);
+
+    return child;
+  }) as any;
+}
+
+describe("runGitCommand (with stub spawn)", () => {
+  it("collects stdout and reports exit code 0", async () => {
+    const result = await runGitCommand("status", "/some/dir", {
+      spawnImpl: makeStubSpawn({ stdout: ["On branch main\n", "nothing to commit\n"], exitCode: 0 }),
+    });
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toBe("On branch main\nnothing to commit\n");
+    expect(result.stderr).toBe("");
+    expect(result.timedOut).toBe(false);
+    expect(result.truncated).toBe(false);
+    expect(result.spawnError).toBeUndefined();
+  });
+
+  it("collects stderr and non-zero exit code", async () => {
+    const result = await runGitCommand("notacommand", "/some/dir", {
+      spawnImpl: makeStubSpawn({
+        stderr: ["git: 'notacommand' is not a git command\n"],
+        exitCode: 1,
+      }),
+    });
+    expect(result.exitCode).toBe(1);
+    expect(result.stdout).toBe("");
+    expect(result.stderr).toContain("not a git command");
+  });
+
+  it("truncates stdout when exceeding maxBytes", async () => {
+    const big = "x".repeat(5000);
+    const result = await runGitCommand("log", "/some/dir", {
+      maxBytes: 1024,
+      spawnImpl: makeStubSpawn({ stdout: [big], exitCode: 0 }),
+    });
+    expect(result.truncated).toBe(true);
+    // 截断后 stdout 长度 ≤ 1024
+    expect(Buffer.byteLength(result.stdout, "utf-8")).toBeLessThanOrEqual(1024);
+  });
+
+  it("truncates stderr when exceeding maxBytes", async () => {
+    const big = "e".repeat(3000);
+    const result = await runGitCommand("log", "/some/dir", {
+      maxBytes: 512,
+      spawnImpl: makeStubSpawn({ stderr: [big], exitCode: 1 }),
+    });
+    expect(result.truncated).toBe(true);
+    expect(Buffer.byteLength(result.stderr, "utf-8")).toBeLessThanOrEqual(512);
+  });
+
+  it("times out hung command and sets timedOut=true with exitCode=null", async () => {
+    const result = await runGitCommand("log", "/some/dir", {
+      timeoutMs: 30,
+      spawnImpl: makeStubSpawn({ hang: true, stdout: ["partial output\n"] }),
+    });
+    expect(result.timedOut).toBe(true);
+    expect(result.exitCode).toBeNull();
+    // 超时前已收集的 partial output 应保留
+    expect(result.stdout).toContain("partial output");
+  });
+
+  it("captures spawn synchronous throw as spawnError", async () => {
+    const result = await runGitCommand("status", "/some/dir", {
+      spawnImpl: makeStubSpawn({ throwOnStart: new Error("ENOENT git") }),
+    });
+    expect(result.spawnError).toBe("ENOENT git");
+    expect(result.exitCode).toBeNull();
+  });
+
+  it("records durationMs as a non-negative number", async () => {
+    const result = await runGitCommand("status", "/some/dir", {
+      spawnImpl: makeStubSpawn({ stdout: ["ok\n"], exitCode: 0, emitDelayMs: 10 }),
+    });
+    expect(typeof result.durationMs).toBe("number");
+    expect(result.durationMs).toBeGreaterThanOrEqual(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// formatGitResult —— 渲染逻辑
+// ---------------------------------------------------------------------------
+
+describe("formatGitResult", () => {
+  const baseResult = (overrides: Partial<GitCommandResult> = {}): GitCommandResult => ({
+    exitCode: 0,
+    stdout: "",
+    stderr: "",
+    durationMs: 12,
+    truncated: false,
+    timedOut: false,
+    ...overrides,
+  });
+
+  it("includes the rendered command, cwd and exit code header", () => {
+    const out = formatGitResult("status", "/repo", baseResult({ stdout: "ok\n" }));
+    expect(out).toContain("git status");
+    expect(out).toContain("/repo");
+    expect(out).toContain("退出码: `0`");
+  });
+
+  it("renders stdout in a fenced block when present", () => {
+    const out = formatGitResult("status", "/repo", baseResult({ stdout: "On branch dev" }));
+    expect(out).toContain("**stdout:**");
+    expect(out).toContain("On branch dev");
+    expect(out.match(/```/g)?.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it("renders stderr block when present", () => {
+    const out = formatGitResult(
+      "push",
+      "/repo",
+      baseResult({ exitCode: 1, stderr: "fatal: remote rejected" }),
+    );
+    expect(out).toContain("**stderr:**");
+    expect(out).toContain("fatal: remote rejected");
+    expect(out).toContain("退出码: `1`");
+  });
+
+  it("hints empty output when both streams are blank", () => {
+    const out = formatGitResult("status", "/repo", baseResult({ stdout: "", stderr: "" }));
+    expect(out).toContain("(命令无输出)");
+  });
+
+  it("annotates timedOut, truncated and spawnError flags", () => {
+    const out = formatGitResult(
+      "log",
+      "/repo",
+      baseResult({ exitCode: null, timedOut: true, truncated: true, spawnError: "ENOENT" }),
+    );
+    expect(out).toContain("超时");
+    expect(out).toContain("截断");
+    expect(out).toContain("ENOENT");
+    expect(out).toContain("退出码: `(无)`");
+  });
+
+  it("truncates very long stdout via truncateContent", () => {
+    const long = Array.from({ length: 500 }, (_, i) => `line${i + 1}`).join("\n");
+    const out = formatGitResult("log", "/repo", baseResult({ stdout: long }), {
+      maxLines: 5,
+      maxChars: 1000,
+    });
+    expect(out).toContain("...");
+    // 只保留前 1 行 + "..." + 后 4 行
+    expect(out).toContain("line1");
+    expect(out).toContain("line500");
+    expect(out).not.toContain("line250");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// gitResultHeaderTemplate
+// ---------------------------------------------------------------------------
+
+describe("gitResultHeaderTemplate", () => {
+  const r = (overrides: Partial<GitCommandResult>): GitCommandResult => ({
+    exitCode: 0,
+    stdout: "",
+    stderr: "",
+    durationMs: 0,
+    truncated: false,
+    timedOut: false,
+    ...overrides,
+  });
+
+  it("returns green when exitCode=0", () => {
+    expect(gitResultHeaderTemplate(r({ exitCode: 0 }))).toBe("green");
+  });
+
+  it("returns red when exitCode≠0", () => {
+    expect(gitResultHeaderTemplate(r({ exitCode: 1 }))).toBe("red");
+    expect(gitResultHeaderTemplate(r({ exitCode: 128 }))).toBe("red");
+  });
+
+  it("returns yellow when timedOut", () => {
+    expect(gitResultHeaderTemplate(r({ exitCode: null, timedOut: true }))).toBe("yellow");
+  });
+
+  it("returns yellow when spawnError set", () => {
+    expect(gitResultHeaderTemplate(r({ exitCode: null, spawnError: "x" }))).toBe("yellow");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 集成 smoke test：真正调起 `git --version` 在临时目录
+// （前置条件：开发机已安装 git）
+// ---------------------------------------------------------------------------
+
+describe("runGitCommand integration (real git)", () => {
+  it("`git --version` runs successfully in a tmp dir", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-git-test-"));
+    try {
+      const result = await runGitCommand("--version", dir, { timeoutMs: 15_000 });
+      // git 不在 PATH 时会得到 spawnError 或非 0 退出，这里整体期望成功
+      expect(result.spawnError).toBeUndefined();
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout.toLowerCase()).toContain("git version");
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("`git status` outside repo reports non-zero exit code with helpful stderr", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-git-test-"));
+    try {
+      const result = await runGitCommand("status", dir, { timeoutMs: 15_000 });
+      expect(result.spawnError).toBeUndefined();
+      // not a git repo → exitCode ≠ 0
+      expect(result.exitCode).not.toBe(0);
+      const combined = (result.stdout + result.stderr).toLowerCase();
+      expect(combined).toMatch(/not a git repository|fatal/);
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+});