@difflab/pi 0.3.0-rc.202609200047.ac3661a → 0.3.0

package/dist/cli.js

@@ -1,729 +0,0 @@
-#!/usr/bin/env node
-
-// src/cli.ts
-import { pathToFileURL } from "node:url";
-
-// src/cli/plan.ts
-import { resolve as resolve4 } from "node:path";
-
-// src/plan/annotations.ts
-import { spawn as spawn2 } from "node:child_process";
-import { readFile as readFile2, rename, writeFile as writeFile2 } from "node:fs/promises";
-import { basename, dirname, join as join2 } from "node:path";
-
-// src/extensions/processx.ts
-import { spawn } from "node:child_process";
-function run(command, args, options = {}) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      cwd: options.cwd,
-      env: options.env ?? process.env,
-      stdio: [options.input === undefined ? "ignore" : "pipe", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    const unbounded = options.capture === "unbounded";
-    child.stdout?.on("data", (chunk) => {
-      const text = chunk.toString();
-      if (unbounded)
-        stdoutChunks.push(text);
-      else
-        stdout = appendBounded(stdout, text);
-    });
-    child.stderr?.on("data", (chunk) => {
-      const text = chunk.toString();
-      if (unbounded)
-        stderrChunks.push(text);
-      else
-        stderr = appendBounded(stderr, text);
-    });
-    child.on("error", reject);
-    child.on("close", (code) => resolve({
-      code: code ?? 1,
-      stdout: unbounded ? stdoutChunks.join("") : stdout,
-      stderr: unbounded ? stderrChunks.join("") : stderr
-    }));
-    if (options.input !== undefined && child.stdin)
-      child.stdin.end(options.input);
-  });
-}
-async function runChecked(command, args, options = {}) {
-  const result = await run(command, args, options);
-  if (result.code === 0)
-    return result;
-  const detail = result.stderr.trim() || result.stdout.trim() || `exit code ${result.code}`;
-  throw new Error(`${command} ${args.join(" ")} failed: ${detail}`);
-}
-var MAX_CAPTURED_OUTPUT_LENGTH = 65536;
-function appendBounded(current, next) {
-  const combined = current + next;
-  return combined.length <= MAX_CAPTURED_OUTPUT_LENGTH ? combined : combined.slice(-MAX_CAPTURED_OUTPUT_LENGTH);
-}
-
-// src/plan/lock.ts
-import { randomUUID } from "node:crypto";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { hostname } from "node:os";
-import { join } from "node:path";
-async function withPlanLock(planDir, operation, options = {}) {
-  const lockDir = join(planDir, ".lock");
-  const waitMs = options.waitMs ?? 5000;
-  const pollMs = options.pollMs ?? 25;
-  const owner = {
-    token: randomUUID(),
-    pid: process.pid,
-    hostname: hostname(),
-    operation: options.operation ?? "plan mutation",
-    acquiredAt: new Date().toISOString()
-  };
-  const started = Date.now();
-  while (true) {
-    try {
-      await mkdir(lockDir);
-      await writeFile(join(lockDir, "owner.json"), `${JSON.stringify(owner)}
-`, { mode: 384 });
-      break;
-    } catch (error) {
-      if (error.code !== "EEXIST")
-        throw error;
-      if (Date.now() - started >= waitMs) {
-        let existing = "unknown owner";
-        try {
-          existing = (await readFile(join(lockDir, "owner.json"), "utf8")).trim();
-        } catch {}
-        throw new Error(`Timed out waiting for plan lock ${lockDir}; owner: ${existing}. Remove it only after confirming the owner is stale.`);
-      }
-      await new Promise((resolve) => setTimeout(resolve, pollMs));
-    }
-  }
-  try {
-    return await operation();
-  } finally {
-    let current;
-    try {
-      current = JSON.parse(await readFile(join(lockDir, "owner.json"), "utf8"));
-    } catch {}
-    if (current?.token === owner.token)
-      await rm(lockDir, { recursive: true, force: true });
-  }
-}
-
-// src/plan/annotations.ts
-async function annotatePlan(record, runtime = {}) {
-  const execute = runtime.execute ?? executeProcess;
-  const result = await execute("tuicr", ["--file", record.planPath], dirname(record.planPath), true);
-  const sessionSlug = [...result.stderr.matchAll(/^tuicr-session:\s*(\S+)\s*$/gm)].at(-1)?.[1];
-  if (result.code !== 0)
-    throw new Error(result.stderr.trim() || `tuicr exited with status ${result.code}.`);
-  if (!sessionSlug)
-    throw new Error("tuicr did not report a tuicr-session marker.");
-  const state = await withPlanLock(record.dir, async () => {
-    const previous = await readAnnotationState(record).catch(() => {
-      return;
-    });
-    const next = {
-      schemaVersion: 1,
-      sessionSlug,
-      updatedAt: new Date().toISOString(),
-      appliedCommentIds: previous?.appliedCommentIds ?? []
-    };
-    await atomicJson(annotationStatePath(record), next);
-    return next;
-  }, { operation: "save annotation session" });
-  return { sessionSlug, code: result.code, state };
-}
-async function readPlanAnnotations(record, options = {}) {
-  const state = await readAnnotationState(record).catch((error) => {
-    if (error.code === "ENOENT")
-      return;
-    throw error;
-  });
-  if (!state)
-    return { comments: [], pending: [] };
-  const execute = options.runtime?.execute ?? executeProcess;
-  const response = await execute("tuicr", ["review", "comments", "--session", state.sessionSlug], record.dir, false);
-  if (response.code !== 0) {
-    if (/not found|no session|deleted/i.test(response.stderr))
-      return { state, comments: [], pending: [] };
-    throw new Error(response.stderr.trim() || "Cannot read tuicr comments.");
-  }
-  let raw;
-  try {
-    raw = JSON.parse(response.stdout);
-  } catch {
-    throw new Error("tuicr returned malformed comment JSON.");
-  }
-  if (!Array.isArray(raw))
-    throw new Error("tuicr comment output must be a JSON array.");
-  const lines = record.source.split(`
-`);
-  const applied = new Set(state.appliedCommentIds);
-  const comments = raw.map((value, index) => normalizeComment(value, index, lines, applied));
-  const pending = comments.filter((comment) => !comment.applied);
-  return { state, comments: options.includeApplied ? comments : pending, pending };
-}
-function annotationStatePath(record) {
-  return join2(record.dir, "annotations.json");
-}
-async function readAnnotationState(record) {
-  const value = JSON.parse(await readFile2(annotationStatePath(record), "utf8"));
-  if (value.schemaVersion !== 1 || typeof value.sessionSlug !== "string" || !Array.isArray(value.appliedCommentIds)) {
-    throw new Error(`Malformed annotation state: ${annotationStatePath(record)}.`);
-  }
-  return value;
-}
-function normalizeComment(value, index, lines, applied) {
-  if (!value || typeof value !== "object")
-    throw new Error(`Malformed tuicr comment at index ${index}.`);
-  const raw = value;
-  if (typeof raw.id !== "string" || typeof raw.content !== "string")
-    throw new Error(`Malformed tuicr comment at index ${index}.`);
-  const line = integer(raw.start_line) ?? integer(raw.line);
-  const endLine = integer(raw.end_line) ?? line;
-  const targetPath = typeof raw.path === "string" ? raw.path : undefined;
-  const appliesToPlan = !targetPath || basename(targetPath) === basename("PLAN.md");
-  const validAnchor = appliesToPlan && line !== undefined && line > 0 && line <= lines.length;
-  return {
-    id: raw.id,
-    body: raw.content,
-    file: targetPath,
-    line,
-    endLine,
-    context: validAnchor ? lines.slice(line - 1, Math.min(endLine ?? line, lines.length)).join(`
-`) : undefined,
-    stale: line !== undefined && !validAnchor,
-    applied: applied.has(raw.id)
-  };
-}
-async function executeProcess(command, args, cwd, interactive) {
-  if (!interactive) {
-    const result = await run(command, args, { cwd, capture: "unbounded" });
-    return { code: result.code, stdout: result.stdout, stderr: result.stderr };
-  }
-  return new Promise((resolve, reject) => {
-    const child = spawn2(command, args, { cwd, stdio: ["inherit", "inherit", "pipe"] });
-    let stderr = "";
-    child.stderr.on("data", (chunk) => {
-      const text = chunk.toString();
-      stderr += text;
-      process.stderr.write(text);
-    });
-    child.on("error", reject);
-    child.on("close", (code) => resolve({ code: code ?? 1, stdout: "", stderr }));
-  });
-}
-async function atomicJson(path, value) {
-  const temp = join2(dirname(path), `.${basename(path)}.${crypto.randomUUID()}.tmp`);
-  await writeFile2(temp, `${JSON.stringify(value, null, 2)}
-`, { mode: 384, flag: "wx" });
-  await rename(temp, path);
-}
-function integer(value) {
-  return typeof value === "number" && Number.isInteger(value) ? value : undefined;
-}
-// src/plan/escalation.ts
-import { z } from "zod";
-var escalationSchema = z.object({
-  planId: z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
-  executionId: z.string().min(1),
-  phaseId: z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
-  taskId: z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).optional(),
-  blocker: z.string().min(1),
-  attempts: z.array(z.string()),
-  evidence: z.array(z.string()),
-  needsUserDecision: z.boolean()
-}).strict();
-// src/plan/transitions.ts
-var STABLE_ID = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-function isStableId(value) {
-  return STABLE_ID.test(value) && value.length <= 80;
-}
-function assertStableId(value, label = "identifier") {
-  if (!isStableId(value))
-    throw new Error(`${label} must be a lowercase stable slug, not a path: ${value}`);
-}
-function assertUniqueIds(ids, label) {
-  const seen = new Set;
-  for (const id of ids) {
-    assertStableId(id, label);
-    if (seen.has(id))
-      throw new Error(`Duplicate ${label}: ${id}.`);
-    seen.add(id);
-  }
-}
-
-// src/plan/markdown.ts
-var PLAN_MARKER = /<!-- diffpi-plan: (\{[^\n]+\}) -->/;
-var PHASE_MARKER = /<!-- diffpi-phase: (\{[^\n]+\}) -->/g;
-var TASK_MARKER = /<!-- diffpi-task: (\{[^\n]+\}) -->/g;
-var SUPPORTED_SCHEMA = 1;
-function countDesignWords(plan) {
-  return [plan.design.bigIdeas, plan.design.keyApiUpdates, plan.design.consequences].join(" ").trim().split(/\s+/).filter(Boolean).length;
-}
-function validatePlanDocument(plan, options = {}) {
-  const issues = [];
-  const add = (code, severity, message, path) => issues.push({ code, severity, message, path });
-  try {
-    assertStableId(plan.id, "plan id");
-    assertUniqueIds(plan.phases.map((phase) => phase.id), "phase id");
-    assertUniqueIds(plan.phases.flatMap((phase) => phase.tasks.map((task) => task.id)), "task id");
-  } catch (error) {
-    add("invalid-id", "error", error.message);
-  }
-  if (plan.schemaVersion !== SUPPORTED_SCHEMA)
-    add("schema", "error", `Unsupported plan schema: ${plan.schemaVersion}.`);
-  const phaseIds = new Set(plan.phases.map((phase) => phase.id));
-  const taskIds = new Set(plan.phases.flatMap((phase) => phase.tasks.map((task) => task.id)));
-  for (const phase of plan.phases) {
-    for (const dependency of phase.dependencies) {
-      if (!phaseIds.has(dependency))
-        add("dangling-dependency", "error", `Phase ${phase.id} depends on missing ${dependency}.`);
-    }
-    for (const task of phase.tasks) {
-      for (const dependency of task.dependencies) {
-        if (!taskIds.has(dependency))
-          add("dangling-dependency", "error", `Task ${task.id} depends on missing ${dependency}.`);
-      }
-      if (options.strict && task.acceptanceCriteria.length === 0)
-        add("acceptance", "error", `Task ${task.id} has no acceptance criteria.`, task.id);
-    }
-    if (options.strict && phase.tasks.length === 0)
-      add("empty-phase", "error", `Phase ${phase.id} has no tasks.`, phase.id);
-  }
-  for (const cycle of dependencyCycles(plan))
-    add("dependency-cycle", "error", `Dependency cycle: ${cycle.join(" -> ")}.`);
-  const designWords = countDesignWords(plan);
-  if (designWords > 300)
-    add("design-length", "warning", `Design is ${designWords} words; prefer 300 or fewer.`);
-  if (options.strict && designWords > 800)
-    add("design-too-long", "error", `Design is ${designWords} words; finalization allows at most 800.`);
-  if (options.strict && plan.phases.length === 0)
-    add("no-phases", "error", "Finalization requires at least one phase.");
-  if (options.strict && (options.pendingAnnotations ?? 0) > 0)
-    add("pending-annotations", "error", `${options.pendingAnnotations} annotations remain pending.`);
-  return issues;
-}
-function parsePlanDocument(source, ref = "PLAN.md") {
-  const planMatch = source.match(PLAN_MARKER);
-  if (!planMatch)
-    throw new Error(`${ref}: missing or malformed diffpi-plan marker.`);
-  if ((source.match(new RegExp(PLAN_MARKER.source, "g")) ?? []).length !== 1)
-    throw new Error(`${ref}: duplicate diffpi-plan marker.`);
-  const marker = parseMarker(planMatch[1], `${ref} plan`);
-  if (marker.schemaVersion !== SUPPORTED_SCHEMA)
-    throw new Error(`${ref}: unsupported plan schema ${String(marker.schemaVersion)}.`);
-  assertStableId(marker.id, "plan id");
-  const title = source.match(/^# (.+)$/m)?.[1]?.trim();
-  if (!title)
-    throw new Error(`${ref}: missing plan title.`);
-  const phases = parsePhases(section(source, "Implementation"), ref);
-  const document = {
-    ...marker,
-    schemaVersion: 1,
-    title,
-    intent: cleanPlaceholder(section(source, "Intent")),
-    requirements: parseBullets(section(source, "Requirements")),
-    design: {
-      bigIdeas: cleanPlaceholder(subsection(source, "Design", "Big Ideas")),
-      keyApiUpdates: cleanPlaceholder(subsection(source, "Design", "Key API Addition/Updates")),
-      consequences: cleanPlaceholder(subsection(source, "Design", "Consequences"))
-    },
-    phases,
-    references: parseReferences(section(source, "References"))
-  };
-  const errors = validatePlanDocument(document).filter((issue) => issue.severity === "error");
-  if (errors.length)
-    throw new Error(`${ref}: ${errors.map((issue) => issue.message).join(" ")}`);
-  return document;
-}
-function parsePhases(input, ref) {
-  const starts = [...input.matchAll(PHASE_MARKER)];
-  const phases = starts.map((match, index) => {
-    const start = match.index;
-    const end = input.indexOf("<!-- /diffpi-phase -->", start);
-    if (end < 0)
-      throw new Error(`${ref}: phase marker has no closing marker.`);
-    const next = starts[index + 1]?.index;
-    if (next !== undefined && next < end)
-      throw new Error(`${ref}: nested or unclosed phase marker.`);
-    const body = input.slice(start + match[0].length, end);
-    const marker = parseMarker(match[1], `${ref} phase`);
-    assertStableId(marker.id, "phase id");
-    const title = body.match(/^### Phase: (.+)$/m)?.[1]?.trim();
-    const objective = body.match(/^\*\*Objective:\*\*\s*(.*)$/m)?.[1]?.trim();
-    if (!title || !objective)
-      throw new Error(`${ref}: phase ${marker.id} is missing title or objective.`);
-    return {
-      ...marker,
-      title,
-      objective,
-      dependencies: parseCsv(body.match(/^\*\*Dependencies:\*\*\s*(.*)$/m)?.[1]),
-      tasks: parseTasks(body, ref)
-    };
-  });
-  assertUniqueIds(phases.map((phase) => phase.id), "phase id");
-  return phases;
-}
-function parseTasks(input, ref) {
-  const starts = [...input.matchAll(TASK_MARKER)];
-  const tasks = starts.map((match, index) => {
-    const start = match.index;
-    const end = input.indexOf("<!-- /diffpi-task -->", start);
-    if (end < 0)
-      throw new Error(`${ref}: task marker has no closing marker.`);
-    const next = starts[index + 1]?.index;
-    if (next !== undefined && next < end)
-      throw new Error(`${ref}: nested or unclosed task marker.`);
-    const body = input.slice(start + match[0].length, end);
-    const marker = parseMarker(match[1], `${ref} task`);
-    assertStableId(marker.id, "task id");
-    const title = body.match(/^- \[[ xX]\] \*\*(.+)\*\*$/m)?.[1]?.trim();
-    if (!title)
-      throw new Error(`${ref}: task ${marker.id} is missing its checkbox title.`);
-    return {
-      ...marker,
-      title,
-      steps: parseListValue(body, "Steps"),
-      dependencies: parseListValue(body, "Dependencies"),
-      fileScopes: parseListValue(body, "File scopes"),
-      acceptanceCriteria: parseListValue(body, "Acceptance criteria")
-    };
-  });
-  assertUniqueIds(tasks.map((task) => task.id), "task id");
-  return tasks;
-}
-function parseReferences(input) {
-  return [...input.matchAll(/^- <!-- diffpi-reference: (\{[^\n]+\}) -->\s*(.*)$/gm)].map((match) => {
-    const marker = parseMarker(match[1], "reference");
-    assertStableId(marker.id, "reference id");
-    return { id: marker.id, value: match[2].trim() || marker.value };
-  });
-}
-function dependencyCycles(plan) {
-  const graph = new Map;
-  for (const phase of plan.phases)
-    graph.set(phase.id, phase.dependencies);
-  for (const task of plan.phases.flatMap((phase) => phase.tasks))
-    graph.set(task.id, task.dependencies);
-  const cycles = [];
-  const visiting = new Set;
-  const visited = new Set;
-  const walk = (id, path) => {
-    if (visiting.has(id)) {
-      cycles.push([...path.slice(path.indexOf(id)), id]);
-      return;
-    }
-    if (visited.has(id))
-      return;
-    visiting.add(id);
-    for (const dependency of graph.get(id) ?? [])
-      walk(dependency, [...path, id]);
-    visiting.delete(id);
-    visited.add(id);
-  };
-  for (const id of graph.keys())
-    walk(id, []);
-  return cycles;
-}
-function section(source, heading) {
-  const match = source.match(new RegExp(`^## ${escapeRegExp(heading)}\\s*$`, "m"));
-  if (!match?.index) {
-    if (match?.index === 0)
-      return "";
-    throw new Error(`Missing required heading: ${heading}.`);
-  }
-  const start = match.index + match[0].length;
-  const rest = source.slice(start);
-  const end = rest.search(/^## /m);
-  return (end < 0 ? rest : rest.slice(0, end)).trim();
-}
-function subsection(source, parent, heading) {
-  const body = section(source, parent);
-  const match = body.match(new RegExp(`^### ${escapeRegExp(heading)}\\s*$`, "m"));
-  if (match?.index === undefined)
-    throw new Error(`Missing required heading: ${parent}/${heading}.`);
-  const rest = body.slice(match.index + match[0].length);
-  const end = rest.search(/^### /m);
-  return (end < 0 ? rest : rest.slice(0, end)).trim();
-}
-function parseBullets(input) {
-  return [...input.matchAll(/^- (?!<!--)(.+)$/gm)].map((match) => match[1].trim());
-}
-function parseListValue(body, label) {
-  const value = body.match(new RegExp(`^  - ${escapeRegExp(label)}:\\s*(.*)$`, "m"))?.[1];
-  return parseCsv(value);
-}
-function parseCsv(value) {
-  if (!value || value.trim().toLowerCase() === "none")
-    return [];
-  return value.split(",").map((item) => item.trim()).filter(Boolean);
-}
-function cleanPlaceholder(value) {
-  return value.replace(/<!--[^]*?-->/g, "").trim();
-}
-function parseMarker(value, label) {
-  try {
-    return JSON.parse(value);
-  } catch {
-    throw new Error(`Malformed ${label} marker JSON.`);
-  }
-}
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-// src/plan/store.ts
-import { open, mkdir as mkdir3, readdir, readFile as readFile3, realpath as realpath3, rename as rename2, rm as rm2 } from "node:fs/promises";
-import { basename as basename3, dirname as dirname3, join as join5, resolve as resolve3, sep } from "node:path";
-
-// src/store.ts
-import { createHash } from "node:crypto";
-import { lstat, mkdir as mkdir2, readlink, realpath as realpath2, symlink, unlink } from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname as dirname2, isAbsolute as isAbsolute2, join as join4, resolve as resolve2 } from "node:path";
-
-// src/extensions/gitx.ts
-import { realpath } from "node:fs/promises";
-import { basename as basename2, isAbsolute, join as join3, resolve } from "node:path";
-async function gitToplevel(cwd) {
-  const result = await run("git", ["-C", cwd, "rev-parse", "--show-toplevel"]);
-  const top = result.stdout.trim();
-  return result.code === 0 && top ? top : resolve(cwd);
-}
-async function inspectGitRepository(cwd) {
-  const root = await gitToplevel(cwd);
-  const remoteResult = await run("git", ["-C", root, "remote", "get-url", "origin"]);
-  const remote = remoteResult.code === 0 ? remoteResult.stdout.trim() : "";
-  const commonResult = await run("git", ["-C", root, "rev-parse", "--git-common-dir"]);
-  const common = commonResult.stdout.trim();
-  const commonPath = commonResult.code === 0 && common ? resolve(isAbsolute(common) ? common : join3(root, common)) : root;
-  const commonDir = await canonicalPath(commonPath);
-  return {
-    root,
-    commonDir,
-    ...remote ? { remote } : {},
-    name: remote ? repositoryName(remote) : basename2(resolve(commonDir, "..")) || basename2(root),
-    identity: remote ? `remote:${normalizeRemote(remote)}` : `git-common-dir:${commonDir}`
-  };
-}
-function normalizeRemote(remote) {
-  return remote.trim().replace(/\.git\/?$/i, "").replace(/\/+$/, "").toLowerCase();
-}
-function repositoryName(remote) {
-  const normalized = remote.trim().replace(/\.git\/?$/i, "").replace(/\/+$/, "");
-  return normalized.split(/[/\\:]/).filter(Boolean).at(-1) ?? "";
-}
-async function canonicalPath(path) {
-  try {
-    return await realpath(path);
-  } catch {
-    return resolve(path);
-  }
-}
-
-// src/store.ts
-var STORE_LINK = ".diffpi";
-var LEGACY_STORE_LINK = join4(".pi", "diffpi");
-function storeGlobalRoot(homeDir = homedir()) {
-  return join4(homeDir, ".difflab", "diffpi", "projects");
-}
-async function ensureStore(cwd, homeDir = homedir()) {
-  const repository = await inspectGitRepository(cwd);
-  const root = repository.root;
-  const slug = projectSlug(repository);
-  const dest = join4(storeGlobalRoot(homeDir), slug);
-  const link = join4(root, STORE_LINK);
-  await mkdir2(dest, { recursive: true });
-  try {
-    await assertStoreLink(link, dest);
-  } catch (error) {
-    if (error.code !== "ENOENT")
-      throw error;
-    await symlink(dest, link);
-  }
-  await removeLegacyStoreLink(join4(root, LEGACY_STORE_LINK), dest);
-  return { slug, root, dest, link, linked: true };
-}
-async function plansDir(cwd, homeDir = homedir()) {
-  const store = await ensureStore(cwd, homeDir);
-  const dir = join4(store.link, "plan");
-  await mkdir2(dir, { recursive: true });
-  return dir;
-}
-async function assertStoreLink(path, dest) {
-  const entry = await lstat(path);
-  if (!entry.isSymbolicLink())
-    throw new Error(`${path} exists and is not a symlink.`);
-  const target = await symlinkTarget(path);
-  if (target !== await canonicalPath2(dest))
-    throw new Error(`${path} points to ${target}, not ${dest}.`);
-}
-async function removeLegacyStoreLink(path, dest) {
-  try {
-    const entry = await lstat(path);
-    if (!entry.isSymbolicLink())
-      return;
-    const target = await symlinkTarget(path);
-    if (target === await canonicalPath2(dest))
-      await unlink(path);
-  } catch (error) {
-    if (error.code !== "ENOENT")
-      throw error;
-  }
-}
-async function symlinkTarget(path) {
-  const target = await readlink(path);
-  return canonicalPath2(isAbsolute2(target) ? target : resolve2(dirname2(path), target));
-}
-async function canonicalPath2(path) {
-  try {
-    return await realpath2(path);
-  } catch {
-    return resolve2(path);
-  }
-}
-function projectSlug(repository) {
-  const readable = repository.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "unnamed";
-  const digest = createHash("sha256").update(repository.identity).digest("hex").slice(0, 12);
-  return `${readable}-${digest}`;
-}
-
-// src/plan/store.ts
-async function resolvePlan(cwd, query, filters = {}, options = {}) {
-  const root = await plansDir(cwd, options.homeDir);
-  const entries = await readdir(root, { withFileTypes: true });
-  const normalizedQuery = query ? normalizeQuery(query) : undefined;
-  const records = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory() || entry.name === ".tmp" || entry.name === ".lock")
-      continue;
-    if (normalizedQuery && entry.name !== normalizedQuery && stripDate(entry.name) !== normalizedQuery)
-      continue;
-    const dir = join5(root, entry.name);
-    await assertContained(root, dir);
-    try {
-      const record = await readRecord(dir);
-      if (filters.branch && record.document.branch !== filters.branch)
-        continue;
-      if (filters.statuses && !filters.statuses.includes(record.document.status))
-        continue;
-      records.push(record);
-    } catch (error) {
-      if (error.code !== "ENOENT")
-        throw error;
-    }
-  }
-  records.sort((left, right) => left.id.localeCompare(right.id));
-  return { candidates: records, record: records.length === 1 ? records[0] : undefined, ambiguous: records.length > 1 };
-}
-async function readRecord(dir) {
-  const planPath = join5(dir, "PLAN.md");
-  const logPath = join5(dir, "logs.txt");
-  const source = await readFile3(planPath, "utf8");
-  const document = parsePlanDocument(source, planPath);
-  return { id: basename3(dir), dir, planPath, logPath, document, source };
-}
-async function assertContained(root, candidate) {
-  const canonicalRoot = await realpath3(root);
-  let canonicalCandidate;
-  try {
-    canonicalCandidate = await realpath3(candidate);
-  } catch {
-    canonicalCandidate = resolve3(candidate);
-  }
-  if (canonicalCandidate !== canonicalRoot && !canonicalCandidate.startsWith(`${canonicalRoot}${sep}`)) {
-    throw new Error(`Plan path escapes the shared store: ${candidate}.`);
-  }
-}
-function normalizeQuery(value) {
-  if (!value || value.includes("\x00") || value.includes("/") || value.includes("\\") || value.includes("..")) {
-    throw new Error(`Invalid plan query: ${value}.`);
-  }
-  return value.toLowerCase();
-}
-function stripDate(value) {
-  return value.replace(/^\d{6}-/, "");
-}
-// src/cli/plan.ts
-async function runPlanCli(args, io = process) {
-  const verb = args.shift();
-  if (verb === "--help" || verb === "-h" || !verb) {
-    io.stdout.write(planCliHelp());
-    return 0;
-  }
-  if (verb !== "annotate" && verb !== "annotations")
-    throw new Error(`Unknown plan command: ${verb}.
-${planCliHelp()}`);
-  if (args.includes("--help") || args.includes("-h")) {
-    io.stdout.write(`Usage: diffpi plan ${verb} [plan] [--cwd <path>]
-`);
-    return 0;
-  }
-  let cwd = process.cwd();
-  let query;
-  while (args.length) {
-    const token = args.shift();
-    if (token === "--cwd") {
-      const value = args.shift();
-      if (!value || value.startsWith("--"))
-        throw new Error("--cwd requires a path.");
-      cwd = resolve4(value);
-    } else if (token.startsWith("--"))
-      throw new Error(`Unknown option: ${token}.`);
-    else if (query)
-      throw new Error(`Unexpected argument: ${token}.`);
-    else
-      query = token;
-  }
-  const record = await resolveCliPlan(cwd, query);
-  if (verb === "annotate") {
-    const result = await annotatePlan(record);
-    io.stdout.write(`Annotated ${record.id} in tuicr session ${result.sessionSlug}.
-`);
-    return result.code;
-  }
-  io.stdout.write(`${JSON.stringify(await readPlanAnnotations(record, { includeApplied: true }), null, 2)}
-`);
-  return 0;
-}
-function planCliHelp() {
-  return `Usage:
-  diffpi plan annotate [plan] [--cwd <path>]
-  diffpi plan annotations [plan] [--cwd <path>]
-`;
-}
-async function resolveCliPlan(cwd, query) {
-  const branch = (await runChecked("git", ["-C", cwd, "branch", "--show-current"])).stdout.trim();
-  const resolution = await resolvePlan(cwd, query, query ? {} : { branch, statuses: ["draft", "ready", "in_progress", "blocked"] });
-  if (resolution.record)
-    return resolution.record;
-  if (resolution.ambiguous)
-    throw new Error(`Plan selection is ambiguous: ${resolution.candidates.map((candidate) => candidate.id).join(", ")}.`);
-  throw new Error(query ? `Plan "${query}" was not found.` : `No unfinished plan matches branch ${branch}.`);
-}
-
-// src/cli.ts
-async function main(argv = process.argv.slice(2)) {
-  const [command, ...args] = argv;
-  if (command === "--help" || command === "-h" || !command) {
-    process.stdout.write(`Usage: diffpi plan <annotate|annotations> [options]
-`);
-    return 0;
-  }
-  if (command !== "plan")
-    throw new Error(`Unknown command: ${command}.`);
-  return runPlanCli(args);
-}
-if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {
-  main().then((code) => {
-    process.exitCode = code;
-  }, (error) => {
-    process.stderr.write(`diffpi: ${error instanceof Error ? error.message : String(error)}
-`);
-    process.exitCode = 1;
-  });
-}
-export {
-  main
-};