@thaut/claude-ide 0.0.0-stage → 1.0.0

package/server/session-dirs.ts

@@ -0,0 +1,189 @@
+import fs from "node:fs/promises";
+import { execFile } from "node:child_process";
+import path from "node:path";
+import { db } from "./db.ts";
+import { claudeDir, encodedDir, sessionFileDir } from "./cli-files.ts";
+
+/**
+ * Per-session view state for M4 (kept out of db.ts's migration list so parallel work can add
+ * migrations without renumbering): the working directory of sessions that live in a git
+ * worktree, and the extra directories (/add-dir) a session may access.
+ */
+db.exec(`
+  CREATE TABLE IF NOT EXISTS session_cwd (
+    session_id TEXT PRIMARY KEY,
+    cwd TEXT NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS session_dirs (
+    session_id TEXT NOT NULL,
+    path TEXT NOT NULL,
+    added_at INTEGER NOT NULL,
+    PRIMARY KEY (session_id, path)
+  );
+`);
+
+// ---------- working directory ----------
+
+export function setSessionCwd(sessionId: string, cwd: string) {
+  db.prepare("INSERT INTO session_cwd (session_id, cwd) VALUES (?, ?) ON CONFLICT(session_id) DO UPDATE SET cwd = excluded.cwd").run(sessionId, cwd);
+}
+
+/** The `cwd` the CLI recorded in a session's transcript (first records carry it). */
+async function transcriptCwd(projectPath: string, sessionId: string): Promise<string | undefined> {
+  const dir = await sessionFileDir(projectPath, sessionId);
+  return dir ? fileCwd(path.join(dir, `${sessionId}.jsonl`)) : undefined;
+}
+
+async function fileCwd(file: string): Promise<string | undefined> {
+  let fh: fs.FileHandle | undefined;
+  try {
+    fh = await fs.open(file, "r");
+    const buf = Buffer.alloc(256 * 1024);
+    const { bytesRead } = await fh.read(buf, 0, buf.length, 0);
+    for (const line of buf.subarray(0, bytesRead).toString("utf8").split("\n")) {
+      try {
+        const cwd = (JSON.parse(line) as { cwd?: unknown }).cwd;
+        if (typeof cwd === "string") return cwd;
+      } catch {
+        // partial line
+      }
+    }
+  } catch {
+    // unreadable
+  } finally {
+    await fh?.close();
+  }
+  return undefined;
+}
+
+async function exists(p: string) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+const WT_SEGMENT = `${path.sep}.claude${path.sep}worktrees${path.sep}`;
+
+/**
+ * Is `p` inside one of the project's worktree checkouts? They live under the repository's
+ * `.claude/worktrees/<name>` (the CLI's `--worktree` layout); the repository top is the
+ * project itself or one of its ancestors.
+ */
+export function isWorktreeOf(projectPath: string, p: string) {
+  const idx = p.lastIndexOf(WT_SEGMENT);
+  if (idx <= 0) return false;
+  const top = p.slice(0, idx);
+  return projectPath === top || projectPath.startsWith(top + path.sep);
+}
+
+/** `<top>/.claude/worktrees/<name>/…` → name */
+export function worktreeName(p: string): string | undefined {
+  const idx = p.lastIndexOf(WT_SEGMENT);
+  if (idx <= 0) return undefined;
+  return p.slice(idx + WT_SEGMENT.length).split(path.sep)[0] || undefined;
+}
+
+/**
+ * Where a session runs: the project directory, or a worktree of it. Sessions created in a
+ * worktree from the web are recorded in sqlite; others (CLI `--worktree`, forks) are
+ * recognised by the cwd in their transcript.
+ */
+export async function sessionCwd(projectPath: string, sessionId: string): Promise<string> {
+  const row = db.prepare("SELECT cwd FROM session_cwd WHERE session_id = ?").get(sessionId) as { cwd: string } | undefined;
+  if (row) return row.cwd;
+  const recorded = await transcriptCwd(projectPath, sessionId);
+  if (recorded && recorded !== projectPath && isWorktreeOf(projectPath, recorded) && (await exists(recorded))) {
+    setSessionCwd(sessionId, recorded);
+    return recorded;
+  }
+  return projectPath;
+}
+
+/**
+ * Where a session's transcript lives, for reading history. Unlike sessionCwd this does not
+ * require the directory to still exist: a cleaned-up worktree keeps its transcript.
+ */
+export async function historyCwd(projectPath: string, sessionId: string): Promise<string> {
+  const row = db.prepare("SELECT cwd FROM session_cwd WHERE session_id = ?").get(sessionId) as { cwd: string } | undefined;
+  return row?.cwd ?? (await transcriptCwd(projectPath, sessionId)) ?? projectPath;
+}
+
+/**
+ * Worktree checkouts of this project that have transcripts, including ones already removed
+ * from disk (git no longer lists them, but their sessions are still history).
+ */
+export async function worktreeTranscriptCwds(projectPath: string): Promise<string[]> {
+  const root = path.join(claudeDir(), "projects");
+  const out = new Set<string>();
+  const top = await repoTop(projectPath);
+  if (!top) return [];
+  const wtRoot = path.join(top, ".claude", "worktrees");
+  // Transcript dirs are named after the cwd, so this repo's worktrees share a name prefix.
+  const prefix = encodedDir(wtRoot + path.sep);
+  let names: string[] = [];
+  try {
+    names = (await fs.readdir(root)).filter((n) => n.startsWith(prefix));
+  } catch {
+    return [];
+  }
+  for (const name of names) {
+    let cwd = dirCwdCache.get(name);
+    if (cwd === undefined) {
+      const dir = path.join(root, name);
+      const file = (await fs.readdir(dir)).find((f) => f.endsWith(".jsonl"));
+      if (!file) continue;
+      cwd = (await fileCwd(path.join(dir, file))) ?? "";
+      dirCwdCache.set(name, cwd); // a transcript dir's cwd never changes
+    }
+    // The encoding is lossy: confirm it is exactly <repo top>/.claude/worktrees/<name>.
+    if (cwd && path.dirname(cwd) === wtRoot) out.add(cwd);
+  }
+  return [...out];
+}
+
+const dirCwdCache = new Map<string, string>();
+const topCache = new Map<string, string>();
+
+/** The git top-level of a project (undefined when it is not inside a repository). */
+async function repoTop(projectPath: string): Promise<string | undefined> {
+  const cached = topCache.get(projectPath);
+  if (cached) return cached;
+  let top: string | undefined;
+  try {
+    top = await new Promise<string>((resolve, reject) => {
+      execFile("git", ["rev-parse", "--show-toplevel"], { cwd: projectPath, encoding: "utf8" }, (err, stdout) => (err ? reject(err) : resolve(stdout)));
+    });
+    top = top.trim() || undefined;
+  } catch {
+    top = undefined;
+  }
+  // Only positive answers are cached: a project may be `git init`ed later.
+  if (top) topCache.set(projectPath, top);
+  return top;
+}
+
+export function draftCwds(sessionIds: string[]): Map<string, string> {
+  const out = new Map<string, string>();
+  for (const id of sessionIds) {
+    const row = db.prepare("SELECT cwd FROM session_cwd WHERE session_id = ?").get(id) as { cwd: string } | undefined;
+    if (row) out.set(id, row.cwd);
+  }
+  return out;
+}
+
+// ---------- extra directories (/add-dir) ----------
+
+export function sessionDirs(sessionId: string): string[] {
+  return (db.prepare("SELECT path FROM session_dirs WHERE session_id = ? ORDER BY added_at").all(sessionId) as { path: string }[]).map((r) => r.path);
+}
+
+export function insertSessionDir(sessionId: string, dir: string) {
+  db.prepare("INSERT OR IGNORE INTO session_dirs (session_id, path, added_at) VALUES (?, ?, ?)").run(sessionId, dir, Date.now());
+}
+
+export function deleteSessionDir(sessionId: string, dir: string) {
+  db.prepare("DELETE FROM session_dirs WHERE session_id = ? AND path = ?").run(sessionId, dir);
+}

package/server/session-file.test.ts

@@ -0,0 +1,134 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+
+const temporary = fs.mkdtempSync(path.join(os.tmpdir(), "ide-goal-"));
+process.env.CLAUDE_IDE_DATA_DIR = path.join(temporary, "data");
+process.env.CLAUDE_CONFIG_DIR = path.join(temporary, "claude");
+const { db } = await import("./db.ts");
+const { goalState } = await import("./session-file.ts");
+const cwd = path.join(temporary, "project");
+const files = path.join(process.env.CLAUDE_CONFIG_DIR, "projects", cwd.replace(/[^a-zA-Z0-9]/g, "-"));
+fs.mkdirSync(files, { recursive: true });
+const goal = (condition: string) => ({ type: "attachment", attachment: { type: "goal_status", condition, sentinel: true } });
+const command = (args: string) => ({ type: "user", message: { content: [{ type: "text", text: `<command-name>/goal</command-name><command-args>${args}</command-args>` }] } });
+
+function save(file: string, records: unknown[]) {
+  let parent: string | null = null;
+  const lines = records.map((record) => {
+    const r = record as Record<string, unknown>;
+    const uuid = typeof r.uuid === "string" ? r.uuid : crypto.randomUUID();
+    const result = { ...r, uuid, parentUuid: r.parentUuid === undefined ? parent : r.parentUuid };
+    parent = uuid;
+    return JSON.stringify(result);
+  });
+  fs.writeFileSync(file, lines.join("\n") + "\n");
+}
+const cleared = (condition: string) => ({ type: "attachment", attachment: { type: "goal_status", sentinel: true, met: true, condition } });
+
+test("btw ignores inherited goals and their continuations but can set its own goal", async () => {
+  const parent = crypto.randomUUID(), child = crypto.randomUUID(), prompt = crypto.randomUUID();
+  const inherited = [command("parent goal"), goal("parent goal")];
+  const parentFile = path.join(files, `${parent}.jsonl`), childFile = path.join(files, `${child}.jsonl`);
+  const write = (records: unknown[]) => save(childFile, records);
+  save(parentFile, inherited);
+  const original = fs.readFileSync(parentFile, "utf8");
+  db.prepare("INSERT INTO session_view (session_id, project_path, btw_parent, btw_prompt_uuid, write_enabled) VALUES (?, ?, ?, ?, 0)").run(child, cwd, parent, prompt);
+  write(inherited);
+  assert.equal((await goalState(cwd, child)), null);
+  const own = [...inherited, { type: "user", uuid: prompt, message: { content: "side question" } }, goal("parent goal")];
+  write(own);
+  assert.equal((await goalState(cwd, child)), null, "an old goal's later status cannot assign it to the child");
+  write([...own, { type: "user", message: { content: "请检查这个示例：\n<command-name>/goal</command-name><command-args>parent goal</command-args>" } }, goal("parent goal")]);
+  assert.equal((await goalState(cwd, child)), null, "quoted command examples cannot adopt the inherited goal");
+  write([...own, command("child goal"), goal("child goal")]);
+  assert.equal((await goalState(cwd, child))?.condition, "child goal");
+  write([...own, goal("native child goal"), command("native child goal")]);
+  assert.deepEqual((await goalState(cwd, child)), { condition: "native child goal", status: "active" }, "native SDK persists the initialization before its command");
+  write([...own, goal("with caveat"), { type: "user", message: { content: "<local-command-caveat>Local command, not model input.</local-command-caveat>" } }, command("with caveat")]);
+  assert.equal((await goalState(cwd, child))?.condition, "with caveat", "the small native caveat classification survives projection without loading ordinary bodies");
+  write([...own, goal("parent goal"), command(""), { type: "attachment", attachment: { type: "goal_status", condition: "parent goal", met: true } }]);
+  assert.equal((await goalState(cwd, child)), null, "inspecting /goal does not adopt an inherited goal");
+  write([...own, command("child goal"), goal("child goal"), cleared("child goal"), command("clear")]);
+  assert.equal((await goalState(cwd, child))?.status, "cleared");
+  write([...inherited, { type: "attachment", uuid: "queue", attachment: { type: "queued_command", source_uuid: prompt, prompt: "side question" } }, command("queued child goal"), goal("queued child goal")]);
+  assert.equal((await goalState(cwd, child))?.condition, "queued child goal", "queued delivery preserves the supplied prompt boundary");
+  db.prepare("UPDATE session_view SET btw_parent=NULL WHERE session_id=?").run(child);
+  write(own);
+  assert.equal((await goalState(cwd, child)), null, "promotion cannot revive the inherited goal");
+  assert.equal((await goalState(cwd, parent))?.condition, "parent goal");
+  assert.equal(fs.readFileSync(parentFile, "utf8"), original);
+});
+
+test("goal commands at the own prompt boundary and after clear survive either native ordering", async () => {
+  const child = crypto.randomUUID(), prompt = crypto.randomUUID();
+  db.prepare("INSERT INTO session_view (session_id, project_path, btw_parent, btw_prompt_uuid) VALUES (?, ?, ?, ?)").run(child, cwd, crypto.randomUUID(), prompt);
+  const file = path.join(files, `${child}.jsonl`);
+  const write = (records: unknown[]) => save(file, records);
+  const own = { ...command("own goal"), uuid: prompt };
+  write([goal("parent"), goal("own goal"), own]);
+  assert.equal((await goalState(cwd, child))?.condition, "own goal");
+  for (const init of [[goal("new"), command("new")], [command("new"), goal("new")]]) {
+    write([goal("parent"), goal("own goal"), own, cleared("own goal"), command("clear"), ...init]);
+    assert.equal((await goalState(cwd, child))?.condition, "new");
+    assert.equal((await goalState(cwd, child))?.status, "active");
+  }
+});
+
+test("a legacy promoted fork keeps its exact question boundary without a prompt UUID", async () => {
+  const child = crypto.randomUUID();
+  db.prepare("INSERT INTO session_view (session_id, project_path, btw_question) VALUES (?, ?, ?)").run(child, cwd, "legacy question");
+  const file = path.join(files, `${child}.jsonl`);
+  const records = [goal("parent"), command("parent"), { type: "user", message: { content: "legacy question" } }, goal("own"), command("own")];
+  save(file, records);
+  assert.equal((await goalState(cwd, child))?.condition, "own");
+});
+
+test("a promoted btw retains a literal goal delimiter through indexing and startup policy", async () => {
+  const child = crypto.randomUUID(), prompt = crypto.randomUUID();
+  const condition = "完整保留 </command-args>\n以及 <command-args>嵌套</command-args>";
+  db.prepare("INSERT INTO session_view (session_id, project_path, btw_prompt_uuid) VALUES (?, ?, ?)").run(child, cwd, prompt);
+  save(path.join(files, `${child}.jsonl`), [
+    { ...goal("parent"), forkedFrom: true }, { ...command("parent"), forkedFrom: true },
+    { type: "user", uuid: prompt, message: { content: "side question" } }, goal(condition), command(condition),
+  ]);
+  assert.deepEqual(await goalState(cwd, child), { condition, status: "active" });
+  const { needsInheritedGoalCleanup } = await import("./btw-policy.ts");
+  assert.equal(await needsInheritedGoalCleanup(cwd, child), false, "a successful own goal needs no inherited cleanup even without an earlier cleanup receipt");
+});
+
+test("goal projection uses the selected native branch including trailing status effects", async () => {
+  const id = crypto.randomUUID(), file = path.join(files, `${id}.jsonl`);
+  const initial = { ...goal("A"), uuid: "goal-A", parentUuid: null };
+  const accepted = { ...command("A"), uuid: "accepted", parentUuid: "goal-A" };
+  const failed = { ...command("B".repeat(4001)), uuid: "rejected", parentUuid: "accepted" };
+  const progress = { type: "attachment", uuid: "progress", parentUuid: "rejected", attachment: { type: "goal_status", condition: "A", met: false, reason: "working", iterations: 2 } };
+  const met = { type: "attachment", uuid: "met", parentUuid: "progress", attachment: { type: "goal_status", condition: "A", met: true, reason: "done" } };
+  save(file, [initial, accepted, failed, progress, met]);
+  assert.equal((await goalState(cwd, id))?.status, "met", "the terminal metadata tail is not a page's last user/assistant message");
+  db.prepare("INSERT INTO session_view (session_id, project_path, rewind_anchor) VALUES (?, ?, ?)").run(id, cwd, "progress");
+  assert.deepEqual(await goalState(cwd, id), { condition: "A", status: "active", reason: "working", iterations: 2 });
+  // A later physical branch cannot replace the state selected by its parent chain.
+  save(file, [initial, accepted, failed, progress, met, { ...goal("C"), uuid: "goal-C", parentUuid: "accepted" }, { ...command("C"), uuid: "cmd-C", parentUuid: "goal-C" }]);
+  assert.equal((await goalState(cwd, id))?.condition, "A");
+  db.prepare("UPDATE session_view SET rewind_anchor=NULL WHERE session_id=?").run(id);
+  assert.equal((await goalState(cwd, id))?.condition, "C");
+});
+
+test("a compacted inherited goal is still inherited, even when its sentinel was re-emitted locally", async () => {
+  const id = crypto.randomUUID(), prompt = crypto.randomUUID(), file = path.join(files, `${id}.jsonl`);
+  const { sessionGoalProjection } = await import("./session-file.ts");
+  db.prepare("INSERT INTO session_view (session_id, project_path, btw_prompt_uuid, btw_goal_isolated) VALUES (?, ?, ?, 1)").run(id, cwd, prompt);
+  save(file, [
+    { ...goal("parent"), uuid: "parent-init", parentUuid: null, forkedFrom: true },
+    { ...command("parent"), uuid: "parent-cmd", parentUuid: "parent-init", forkedFrom: true },
+    { type: "user", uuid: prompt, parentUuid: "parent-cmd", message: { content: "side question" } },
+    { type: "system", subtype: "compact_boundary", uuid: "compact", parentUuid: null, logicalParentUuid: prompt },
+    { type: "user", uuid: "summary", parentUuid: "compact", isCompactSummary: true, message: { content: "Summary" } },
+    { ...goal("parent"), uuid: "restored-goal", parentUuid: "summary" },
+  ]);
+  assert.deepEqual(await sessionGoalProjection(cwd, id), { goal: null, isolated: false });
+});

package/server/session-file.ts

@@ -0,0 +1,113 @@
+import { nativeGoalBranch } from "./history-pages.ts";
+import { projectGoal } from "./goal-state.ts";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { sessionFileDir } from "./cli-files.ts";
+import { db } from "./db.ts";
+
+/**
+ * Direct reads of a session's jsonl for records the SDK's readers do not return
+ * (cost-state, local command output). See NOTES.md "SDK：会话文件结构".
+ */
+
+function projectsRoot() {
+  return path.join(process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude"), "projects");
+}
+
+const SESSION_ID = /^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$/;
+
+/** Session ids are UUIDs; anything else must not reach a filesystem path. */
+export function isSessionId(id: string): boolean {
+  return SESSION_ID.test(id);
+}
+
+async function exists(p: string, strict = false) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch (err) {
+    if (strict && (err as NodeJS.ErrnoException).code !== "ENOENT") throw err;
+    return false;
+  }
+}
+
+export async function sessionFile(cwd: string, sessionId: string, strict = false): Promise<string | undefined> {
+  if (!isSessionId(sessionId)) return undefined;
+  const encoded = cwd.replace(/[^a-zA-Z0-9]/g, "-");
+  const root = projectsRoot();
+  if (encoded.length <= 200) {
+    const f = path.join(root, encoded, `${sessionId}.jsonl`);
+    if (await exists(f, strict)) return f;
+    // Sessions of a worktree of the project live under the worktree's own directory.
+    const dir = await sessionFileDir(cwd, sessionId, strict);
+    return dir ? path.join(dir, `${sessionId}.jsonl`) : undefined;
+  }
+  // Long paths are truncated and get a hash suffix: look the directory up by prefix.
+  try {
+    for (const d of await fs.readdir(root)) {
+      if (!d.startsWith(encoded.slice(0, 200))) continue;
+      const f = path.join(root, d, `${sessionId}.jsonl`);
+      if (await exists(f, strict)) return f;
+    }
+  } catch (err) {
+    if (strict && (err as NodeJS.ErrnoException).code !== "ENOENT") throw err;
+    // no projects dir yet
+  }
+  return undefined;
+}
+
+type Rec = { type?: string; subtype?: string; uuid?: string; parentUuid?: string | null; content?: unknown; totalCostUSD?: number };
+
+async function readRecords(cwd: string, sessionId: string): Promise<Rec[]> {
+  const f = await sessionFile(cwd, sessionId);
+  if (!f) return [];
+  const out: Rec[] = [];
+  for (const line of (await fs.readFile(f, "utf8")).split("\n")) {
+    if (!line) continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+      // partial last line while the CLI is writing
+    }
+  }
+  return out;
+}
+
+/** The cumulative cost the CLI restores on resume. */
+export async function lastCostState(cwd: string, sessionId: string): Promise<number | undefined> {
+  const recs = await readRecords(cwd, sessionId);
+  for (let i = recs.length - 1; i >= 0; i--) {
+    const r = recs[i]!;
+    if (r.type === "cost-state" && typeof r.totalCostUSD === "number") return r.totalCostUSD;
+  }
+  return undefined;
+}
+
+/** `system/local_command` records (the output of /cost, /context…), keyed by their parent uuid. */
+export async function localCommandOutputs(cwd: string, sessionId: string): Promise<Map<string, { uuid: string; content: string }[]>> {
+  const byParent = new Map<string, { uuid: string; content: string }[]>();
+  for (const r of await readRecords(cwd, sessionId)) {
+    if (r.type !== "system" || r.subtype !== "local_command" || !r.parentUuid || typeof r.content !== "string") continue;
+    const list = byParent.get(r.parentUuid) ?? [];
+    list.push({ uuid: r.uuid ?? `${r.parentUuid}-out`, content: r.content });
+    byParent.set(r.parentUuid, list);
+  }
+  return byParent;
+}
+
+export type { GoalState } from "./goal-state.ts";
+
+/** Both the UI and startup isolation inspect the branch the SDK will resume. */
+export async function sessionGoalProjection(cwd: string, sessionId: string) {
+  const view = db.prepare("SELECT btw_parent, btw_prompt_uuid, btw_question, btw_goal_isolation_uuid, rewind_anchor FROM session_view WHERE session_id=?").get(sessionId) as {
+    btw_parent?: string | null; btw_prompt_uuid?: string | null; btw_question?: string | null; btw_goal_isolation_uuid?: string | null; rewind_anchor?: string | null;
+  } | undefined;
+  const records = await nativeGoalBranch(await sessionFile(cwd, sessionId), view?.rewind_anchor, !view?.btw_prompt_uuid ? view?.btw_question : undefined);
+  return projectGoal(records, { fork: !!(view?.btw_parent || view?.btw_prompt_uuid || view?.btw_question),
+    promptUuid: view?.btw_prompt_uuid, question: view?.btw_question, isolationUuid: view?.btw_goal_isolation_uuid });
+}
+
+export async function goalState(cwd: string, sessionId: string) {
+  return (await sessionGoalProjection(cwd, sessionId)).goal;
+}