@thaut/claude-ide 0.0.0-stage → 1.0.0

package/server/git.ts

@@ -0,0 +1,86 @@
+import type { Hono } from "hono";
+import type { ChangeStatus, GitChange, GitDiff, GitStatus } from "../shared/files.ts";
+import { FsHttpError, gitInfo, projectRoot, resolveSafe, route, run } from "./fsutil.ts";
+
+const MAX_DIFF_BYTES = 4 * 1024 * 1024;
+
+export function registerGitRoutes(app: Hono) {
+  app.get("/api/projects/:pid/git/status", route(async (c) => c.json(await gitStatus(projectRoot(c)))));
+  app.get("/api/projects/:pid/git/diff", route(async (c) => c.json(await gitDiff(projectRoot(c), c.req.query("path")))));
+}
+
+type Entry = { xy: string; top: string };
+
+/** `git status` limited to the project directory; paths relative to the repo top. */
+async function statusEntries(root: string, pathspec: string): Promise<{ branch: string | null; entries: Entry[] }> {
+  const r = await run("git", ["-c", "core.quotepath=off", "status", "--porcelain=v1", "-z", "-b", "-uall", "--no-renames", "--", `:(literal)${pathspec}`], root);
+  if (r.code !== 0) throw new FsHttpError(409, r.stderr.trim() || "git status 失败");
+  const recs = r.stdout.split("\0").filter(Boolean);
+  let branch: string | null = null;
+  const entries: Entry[] = [];
+  for (const rec of recs) {
+    if (rec.startsWith("## ")) {
+      const b = rec.slice(3).split("...")[0]!.replace(/^No commits yet on /, "");
+      branch = b.startsWith("HEAD (no branch)") ? null : b;
+      continue;
+    }
+    entries.push({ xy: rec.slice(0, 2), top: rec.slice(3) });
+  }
+  return { branch, entries };
+}
+
+function displayStatus(xy: string): ChangeStatus {
+  const [x, y] = [xy[0]!, xy[1]!];
+  if (xy === "??") return "??";
+  if (x === "U" || y === "U" || xy === "AA" || xy === "DD") return "U";
+  if (x === "A") return "A";
+  if (x === "D" || y === "D") return "D";
+  return "M";
+}
+
+export async function gitStatus(projectRoot: string): Promise<GitStatus> {
+  const root = (await resolveSafe(projectRoot, "")).root;
+  const git = await gitInfo(root);
+  if (!git.isRepo) return { isRepo: false };
+  const { branch, entries } = await statusEntries(root, ".");
+  const changes: GitChange[] = entries
+    .filter((e) => e.top.startsWith(git.prefix))
+    .map((e) => ({
+      path: e.top.slice(git.prefix.length),
+      status: displayStatus(e.xy),
+      staged: e.xy !== "??" && e.xy[0] !== " ",
+      unstaged: e.xy === "??" || e.xy[1] !== " ",
+    }))
+    .sort((a, b) => a.path.localeCompare(b.path));
+  return { isRepo: true, branch, changes };
+}
+
+export async function gitDiff(projectRoot: string, rel: string | undefined): Promise<GitDiff> {
+  if (!rel) throw new FsHttpError(400, "缺少 path");
+  const sp = await resolveSafe(projectRoot, rel, { mustExist: false });
+  if (!sp.rel) throw new FsHttpError(400, "缺少 path");
+  const git = await gitInfo(sp.root);
+  if (!git.isRepo) throw new FsHttpError(409, "不是 git 仓库");
+
+  const { entries } = await statusEntries(sp.root, sp.rel);
+  const entry = entries.find((e) => e.top === git.prefix + sp.rel);
+  const status = entry ? displayStatus(entry.xy) : null;
+
+  let res;
+  if (status === "??") {
+    // Untracked: show the whole file as added. Exit code 1 means "differences found".
+    res = await run("git", ["-c", "core.quotepath=off", "diff", "--no-color", "--no-index", "--", "/dev/null", sp.rel], sp.root, { maxBuffer: MAX_DIFF_BYTES });
+  } else {
+    const head = await run("git", ["rev-parse", "--verify", "-q", "HEAD"], sp.root);
+    let base = "HEAD";
+    if (head.code !== 0) {
+      // No commits yet: diff against the empty tree.
+      const empty = await run("git", ["hash-object", "-t", "tree", "--stdin"], sp.root, { input: "" });
+      base = empty.stdout.trim();
+    }
+    res = await run("git", ["-c", "core.quotepath=off", "diff", "--no-color", "--no-ext-diff", base, "--", `:(literal)${sp.rel}`], sp.root, { maxBuffer: MAX_DIFF_BYTES });
+  }
+  if (res.code > 1) throw new FsHttpError(409, res.stderr.trim() || "git diff 失败");
+  const truncated = res.code === -2;
+  return { path: sp.rel, status, diff: truncated ? res.stdout.slice(0, MAX_DIFF_BYTES) : res.stdout, truncated };
+}

package/server/goal-state.test.ts

@@ -0,0 +1,64 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { goalCommand, projectGoal, type GoalRecord } from "./goal-state.ts";
+
+const set = (condition: string, extra: object = {}): GoalRecord => ({ type: "attachment", attachment: { type: "goal_status", condition, sentinel: true, met: false, ...extra } });
+const command = (text: string): GoalRecord => ({ type: "user", command: text });
+
+test("native goal envelopes preserve literal delimiter tags and multiline arguments", () => {
+  for (const condition of ["支持原样显示 </command-args> 标记", "测试 <command-args>嵌套</command-args>\n再次 </command-args>", "结束于 </command-args>"]) {
+    const envelope = `<command-name>/goal</command-name>\n<command-message>goal</command-message>\n<command-args>${condition}</command-args>`;
+    const native: GoalRecord = { type: "user", message: { content: [{ type: "text", text: envelope }] } };
+    assert.equal(goalCommand(native), condition);
+    for (const cleanup of [[], [set("parent", { met: true })]]) {
+      const records: GoalRecord[] = [{ type: "user", uuid: "own" }, ...cleanup, set(condition), native];
+      assert.deepEqual(projectGoal(records, { fork: true, promptUuid: "own" }), { goal: { condition, status: "active" }, isolated: true });
+    }
+    assert.deepEqual(projectGoal([set(condition), native], { fork: false }).goal, { condition, status: "active" });
+    assert.equal(goalCommand({ type: "user", message: { content: `请检查这个示例：\n${envelope}` } }), undefined);
+  }
+});
+
+test("rejected and pending goal commands never replace the last accepted goal", () => {
+  for (const scope of [{ fork: false }, { fork: true, promptUuid: "own" }]) {
+    const records: GoalRecord[] = [{ type: "user", uuid: "own" }, set("A"), command("A"), command("B".repeat(4001)),
+      { type: "attachment", attachment: { type: "goal_status", condition: "A", met: false, reason: "still working", iterations: 3 } }];
+    assert.deepEqual(projectGoal(records, scope).goal, { condition: "A", status: "active", reason: "still working", iterations: 3 });
+    assert.equal(projectGoal([...records, command("C")], scope).goal?.condition, "A");
+    assert.equal(projectGoal([...records, command("C"), set("C")], scope).goal?.condition, "C");
+  }
+});
+
+test("native clear is a successful effect and takes precedence over sentinel initialization", () => {
+  for (const scope of [{ fork: false }, { fork: true, promptUuid: "own" }]) {
+    const records = [{ type: "user", uuid: "own" }, set("A"), command("A"), set("A", { met: true }), command("OFF")];
+    assert.equal(projectGoal(records, scope).goal?.status, "cleared", "clear aliases do not depend on a text whitelist");
+    assert.equal(projectGoal(records, scope).isolated, true);
+  }
+});
+
+test("explicit fork provenance separates copied goals from new effects on a rewound branch", () => {
+  const inherited = { ...set("parent"), forkedFrom: { sessionId: "parent" } };
+  const scope = { fork: true, promptUuid: "old-branch-question" };
+  assert.deepEqual(projectGoal([inherited], scope), { goal: null, isolated: false });
+  assert.equal(projectGoal([inherited, set("parent", { met: true })], scope).isolated, true, "persisted clear is proof even if its SDK result was lost");
+  assert.deepEqual(projectGoal([inherited, set("own"), command("own")], scope).goal, { condition: "own", status: "active" });
+});
+
+test("a success UUID only proves isolation while its native command is in this branch", () => {
+  const scope = { fork: true, isolationUuid: "clear" };
+  assert.equal(projectGoal([], scope).isolated, false);
+  assert.equal(projectGoal([{ ...command("clear"), uuid: "different" }], scope).isolated, false);
+  assert.equal(projectGoal([{ ...command("clear"), uuid: "clear" }], scope).isolated, true);
+});
+
+test("compaction replay and queued intents cannot claim an inherited goal", () => {
+  const records: GoalRecord[] = [
+    { ...set("parent"), forkedFrom: true }, { ...command("parent"), forkedFrom: true },
+    { type: "user", uuid: "question" }, { type: "system", subtype: "compact_boundary" },
+    { type: "user", isMeta: true }, set("parent"),
+  ];
+  const scope = { fork: true, promptUuid: "question" };
+  assert.deepEqual(projectGoal(records, scope), { goal: null, isolated: false });
+  assert.deepEqual(projectGoal([...records, { type: "attachment", command: "parent", attachment: { type: "queued_command" } }, set("parent")], scope), { goal: null, isolated: false });
+});

package/server/goal-state.ts

@@ -0,0 +1,78 @@
+/** SDK goal effects are facts; submitted commands only establish attribution. */
+export type GoalState = { condition: string; status: "active" | "met" | "failed" | "cleared"; reason?: string; iterations?: number };
+export type GoalRecord = { type: string; subtype?: string; uuid?: string; isMeta?: boolean; localCommandCaveat?: boolean; forkedFrom?: unknown; command?: string;
+  message?: { content?: unknown }; attachment?: { type?: string; [key: string]: unknown } };
+export type GoalScope = { fork: boolean; promptUuid?: string | null; question?: string | null; isolationUuid?: string | null };
+
+export function recordText(r: GoalRecord): string {
+  const content = r.message?.content ?? (r.attachment?.type === "queued_command" ? r.attachment.prompt : undefined);
+  return typeof content === "string" ? content : Array.isArray(content)
+    ? content.filter((block) => block?.type === "text").map((block) => block.text).join("\n") : "";
+}
+
+export function goalCommand(r: GoalRecord): string | undefined {
+  if (r.command !== undefined) return r.command;
+  if (r.type !== "user" && !(r.type === "attachment" && r.attachment?.type === "queued_command")) return;
+  const text = recordText(r);
+  // Native command envelopes do not escape embedded command-args tags. Only
+  // their final closing tag delimits the argument; inner tags are literal text.
+  if (/^\s*<command-name>\/goal<\/command-name>/.test(text)) return /<command-args>([\s\S]*)<\/command-args>\s*$/.exec(text)?.[1]?.trim() ?? "";
+  return /^\/goal(?:\s+([\s\S]*))?$/.exec(text)?.[1]?.trim();
+}
+
+/** Replays a SELECTED native branch, including its trailing effect attachments.
+ * A failed/pending set never replaces the last accepted goal. Both native
+ * attachment-before-command and queued command-before-attachment are supported. */
+export function projectGoal(records: readonly GoalRecord[], scope: GoalScope): { goal: GoalState | null; isolated: boolean } {
+  const nativeFork = records.some((record) => !!record.forkedFrom);
+  const commits = new Map<number, { clear: boolean; condition: string }>();
+  let own = !scope.fork;
+  const barrier = (r: GoalRecord) => r.type === "assistant" || r.subtype === "compact_boundary" || (r.type === "user" && !r.isMeta && !r.localCommandCaveat
+    && !recordText(r).startsWith("<local-command-caveat>")) || r.attachment?.type === "queued_command";
+  for (const [index, r] of records.entries()) {
+    if (scope.promptUuid && (r.uuid === scope.promptUuid || r.attachment?.source_uuid === scope.promptUuid)) own = true;
+    if (!scope.promptUuid && scope.question && recordText(r) === scope.question) own = true;
+    if (nativeFork && !r.forkedFrom && (r.type === "user" || r.attachment?.type === "goal_status")) own = true;
+    const effect = r.attachment;
+    if (scope.fork && !r.forkedFrom && own && effect?.type === "goal_status" && effect.sentinel) {
+      if (effect.met) commits.set(index, { clear: true, condition: String(effect.condition ?? "") });
+    }
+    const command = goalCommand(r);
+    const acknowledged = r.uuid === scope.isolationUuid && command === "clear";
+    if (acknowledged) { own = true; commits.set(index, { clear: true, condition: "" }); }
+    if (!own || r.forkedFrom || !command || r.attachment?.type === "queued_command") continue;
+    // The successful status and command share a local-command span. An older
+    // goal with the same text, or a queued-but-never-executed command, is not proof.
+    for (const direction of [-1, 1]) {
+      for (let at = index + direction; at >= 0 && at < records.length; at += direction) {
+        const candidate = records[at]!;
+        const a = candidate.attachment;
+        if (a?.type === "goal_status" && a.sentinel
+          && (command === "clear" ? a.met === true : !a.met && !a.failed && a.condition === command)) {
+          commits.set(Math.max(index, at), { clear: command === "clear", condition: String(a.condition ?? "") });
+          break;
+        }
+        if (barrier(candidate)) break;
+      }
+    }
+  }
+  let goal = null as GoalState | null;
+  let isolated = !scope.fork;
+  for (const [index, r] of records.entries()) {
+    const commit = commits.get(index);
+    if (commit) {
+      goal = { condition: commit.condition || goal?.condition || "", status: commit.clear ? "cleared" : "active" };
+      isolated = true;
+    }
+    const a = r.attachment;
+    if (a?.type !== "goal_status") continue;
+    const condition = String(a.condition ?? "");
+    if (scope.fork && (a.sentinel || !goal || goal.condition !== condition || goal.status !== "active")) continue;
+    // Native clear is sentinel+met. Check the terminal outcome before sentinel.
+    if (a.met) goal = { condition, status: a.sentinel ? "cleared" : "met", reason: a.reason as string | undefined, iterations: a.iterations as number | undefined };
+    else if (a.failed) goal = { condition, status: "failed", reason: a.reason as string | undefined };
+    else if (a.sentinel) goal = { condition, status: "active" };
+    else if (goal) goal = { ...goal, condition, reason: a.reason as string | undefined, iterations: a.iterations as number | undefined };
+  }
+  return { goal, isolated };
+}