@difflab/pi 0.7.0-rc.202609271854.6af8600 → 0.7.0

package/dist/extensions/index.js

@@ -15049,7 +15049,7 @@ function sanitize(value) {
 }
 
 // src/tools/plan.ts
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 import { pathToFileURL } from "node:url";
 import { defineTool as defineTool5 } from "@earendil-works/pi-coding-agent";
 import { z as z8 } from "zod";
@@ -20993,8 +20993,8 @@ function isPlanReviewDump(value) {
 
 // src/plan/store.ts
 import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
-import { mkdir as mkdir6, readdir as readdir3, readFile as readFile9, realpath as realpath3, rename as rename2, rm as rm2 } from "node:fs/promises";
-import { basename as basename6, dirname as dirname8, join as join17, resolve as resolve4, sep } from "node:path";
+import { mkdir as mkdir6, readdir as readdir3, readFile as readFile10, realpath as realpath3, rename as rename2, rm as rm2 } from "node:fs/promises";
+import { basename as basename6, dirname as dirname8, join as join18, resolve as resolve4, sep } from "node:path";
 
 // src/extensions/fsx.ts
 import { mkdir as mkdir5, rename, rm, writeFile as writeFile4 } from "node:fs/promises";
@@ -21030,6 +21030,42 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// src/templates.ts
+import { readFile as readFile9 } from "node:fs/promises";
+import { homedir as homedir7 } from "node:os";
+import { join as join17, normalize } from "node:path";
+async function loadTemplate(name, options = {}) {
+  const relative = templateRelativePath(name);
+  const userPath = join17(options.homeDir ?? homedir7(), ".difflab", "diffpi", "templates", relative);
+  const bundledPath = join17(options.bundledDir ?? resolveBundledTemplatesDir(), relative);
+  const user = await readOptionalFile(userPath);
+  if (user !== undefined)
+    return { name, path: userPath, source: "user", content: user };
+  const bundled = await readOptionalFile(bundledPath);
+  if (bundled !== undefined)
+    return { name, path: bundledPath, source: "bundled", content: bundled };
+  throw new Error(`Template "${name}" was not found at ${userPath} or ${bundledPath}.`);
+}
+function renderTemplate(content, variables) {
+  return content.replace(/\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g, (match, key) => variables[key] ?? match);
+}
+function templateRelativePath(name) {
+  const normalized = normalize(name.replaceAll("\\", "/")).replace(/^\.\//, "");
+  if (!normalized || normalized.startsWith("../") || normalized.includes("/../") || normalized.startsWith("/")) {
+    throw new Error(`Invalid template name: ${name}`);
+  }
+  return normalized.endsWith(".md") ? normalized : `${normalized}.md`;
+}
+async function readOptionalFile(path) {
+  try {
+    return await readFile9(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+
 // src/plan/store.ts
 function planRecordName(shortSlug, date = new Date) {
   const slug = normalizeSlug(shortSlug);
@@ -21045,7 +21081,7 @@ async function resolvePlan(cwd, query, filters = {}, options = {}) {
       continue;
     if (normalizedQuery && entry.name !== normalizedQuery && stripDate(entry.name) !== normalizedQuery)
       continue;
-    const dir = join17(root, entry.name);
+    const dir = join18(root, entry.name);
     await assertContained(root, dir);
     try {
       const record = await readRecord(dir);
@@ -21080,30 +21116,26 @@ function createPlanStore(options = {}) {
     async init(input) {
       const root = await plansDir(input.cwd, options.homeDir);
       const id = planRecordName(input.shortSlug, now());
-      const dir = join17(root, id);
+      const dir = join18(root, id);
       await createPlanDirectory(root, dir, id);
       try {
         const timestamp = now().toISOString();
+        const template = await loadTemplate("plan/PLAN", {
+          homeDir: options.homeDir,
+          bundledDir: options.bundledTemplatesDir
+        });
         const title = input.title?.trim() || titleFromSlug(input.shortSlug);
-        const document = {
-          schemaVersion: 1,
+        const source = renderTemplate(template.content, {
           id,
-          revision: 0,
-          title,
           branch: input.branch,
-          ...input.issueId?.trim() ? { issueId: input.issueId.trim() } : {},
-          ...input.issueUrl?.trim() ? { issueUrl: input.issueUrl.trim() } : {},
+          title,
           intent: input.intent?.trim() || "<!-- Describe the intended outcome. -->",
-          requirements: [],
-          design: { bigIdeas: "", keyApiUpdates: "", consequences: "" },
-          phases: [],
-          references: [],
-          status: "draft",
-          createdAt: timestamp,
-          updatedAt: timestamp
-        };
-        const source = renderPlanDocument(document);
-        parsePlanDocument(source, join17(dir, "PLAN.md"));
+          issue_id: input.issueId?.trim() || "",
+          issue_url: input.issueUrl?.trim() || "",
+          created_at: timestamp,
+          updated_at: timestamp
+        });
+        const document = parsePlanDocument(source, join18(dir, "PLAN.md"));
         const authoringRequest = input.request ?? { kind: "user", text: input.intent?.trim() || `Initialize phase-less plan ${title}.` };
         await writeRevisionSnapshot(dir, document, source, authoringRequest, []);
         await writeLatestView(dir, document, source, []);
@@ -21118,14 +21150,14 @@ function createPlanStore(options = {}) {
       if (request.mode === "create") {
         const root = await plansDir(cwd, options.homeDir);
         const id = planRecordName(request.shortSlug, now());
-        const dir = join17(root, id);
+        const dir = join18(root, id);
         await createPlanDirectory(root, dir, id);
         try {
           const timestamp = now().toISOString();
           const document = normalizeRevision(undefined, request, id, 0, timestamp);
           assertCompleteRevision(document, request.briefs);
           const source = renderPlanDocument(document);
-          parsePlanDocument(source, join17(dir, "PLAN.md"));
+          parsePlanDocument(source, join18(dir, "PLAN.md"));
           await writeRevisionSnapshot(dir, document, source, request.request, request.briefs);
           await writeLatestView(dir, document, source, request.briefs);
           return await readRecord(dir);
@@ -21135,7 +21167,7 @@ function createPlanStore(options = {}) {
         }
       }
       const initial = await read(cwd, request.plan);
-      return withDirectoryLock(join17(initial.dir, ".lock"), async () => {
+      return withDirectoryLock(join18(initial.dir, ".lock"), async () => {
         const current = await readRecord(initial.dir);
         if (current.document.revision !== request.expectedPlanRevision)
           throw new Error(`Expected plan revision ${request.expectedPlanRevision}, found ${current.document.revision}.`);
@@ -21148,7 +21180,7 @@ function createPlanStore(options = {}) {
         try {
           await writeLatestView(current.dir, document, source, request.briefs);
         } catch (error) {
-          await rm2(join17(current.dir, "revisions", String(revision)), { recursive: true, force: true });
+          await rm2(join18(current.dir, "revisions", String(revision)), { recursive: true, force: true });
           throw error;
         }
         return await readRecord(current.dir);
@@ -21156,7 +21188,7 @@ function createPlanStore(options = {}) {
     },
     async mutate(cwd, query, operation, update) {
       const initial = await read(cwd, query);
-      return withDirectoryLock(join17(initial.dir, ".lock"), async () => {
+      return withDirectoryLock(join18(initial.dir, ".lock"), async () => {
         const current = await readRecord(initial.dir);
         const next = await update(structuredClone(current.document));
         if (next.id !== current.id)
@@ -21179,16 +21211,16 @@ function createPlanStore(options = {}) {
   };
 }
 async function readRecord(dir) {
-  const planPath = join17(dir, "PLAN.md");
-  const logPath = join17(dir, "logs.txt");
-  const source = await readFile9(planPath, "utf8");
+  const planPath = join18(dir, "PLAN.md");
+  const logPath = join18(dir, "logs.txt");
+  const source = await readFile10(planPath, "utf8");
   const document = parsePlanDocument(source, planPath);
   return {
     id: basename6(dir),
     dir,
     planPath,
     logPath,
-    implementationDir: join17(dir, "implementation"),
+    implementationDir: join18(dir, "implementation"),
     document,
     source
   };
@@ -21208,17 +21240,17 @@ async function writeRevisionSnapshot(planDir, document, source, request, briefs)
     throw new Error("An exact non-empty authoring request is required.");
   if (request.kind === "annotation" && !request.response?.trim())
     throw new Error("Annotation requests require a non-empty response.");
-  const revisionsDir = join17(planDir, "revisions");
+  const revisionsDir = join18(planDir, "revisions");
   await mkdir6(revisionsDir, { recursive: true });
-  const target = join17(revisionsDir, String(document.revision));
+  const target = join18(revisionsDir, String(document.revision));
   try {
-    await readFile9(join17(target, "metadata.json"), "utf8");
+    await readFile10(join18(target, "metadata.json"), "utf8");
     throw new Error(`Revision ${document.revision} already exists and is immutable.`);
   } catch (error) {
     if (error.code !== "ENOENT")
       throw error;
   }
-  const staging = join17(revisionsDir, `.tmp-${document.revision}-${randomUUID2()}`);
+  const staging = join18(revisionsDir, `.tmp-${document.revision}-${randomUUID2()}`);
   await mkdir6(staging);
   try {
     const requestSource = request.kind === "annotation" ? `## Original annotation
@@ -21226,8 +21258,8 @@ ${request.text}
 
 ## LLM response
 ${request.response}` : request.text;
-    await atomicWrite(join17(staging, "request.md"), requestSource);
-    await atomicWrite(join17(staging, "metadata.json"), `${JSON.stringify({
+    await atomicWrite(join18(staging, "request.md"), requestSource);
+    await atomicWrite(join18(staging, "metadata.json"), `${JSON.stringify({
       schemaVersion: 1,
       id: document.id,
       revision: document.revision,
@@ -21237,7 +21269,7 @@ ${request.response}` : request.text;
       createdAt: document.updatedAt
     }, null, 2)}
 `);
-    await atomicWrite(join17(staging, "PLAN.md"), source);
+    await atomicWrite(join18(staging, "PLAN.md"), source);
     await writeImplementationDirectory(staging, document, briefs);
     await rename2(staging, target);
   } catch (error) {
@@ -21246,10 +21278,10 @@ ${request.response}` : request.text;
   }
 }
 async function writeLatestView(planDir, document, source, briefs) {
-  const current = join17(planDir, "implementation");
-  const stagingRoot = join17(planDir, `.latest-${randomUUID2()}`);
-  const stagedImplementation = join17(stagingRoot, "implementation");
-  const backup = join17(planDir, `.implementation-backup-${randomUUID2()}`);
+  const current = join18(planDir, "implementation");
+  const stagingRoot = join18(planDir, `.latest-${randomUUID2()}`);
+  const stagedImplementation = join18(stagingRoot, "implementation");
+  const backup = join18(planDir, `.implementation-backup-${randomUUID2()}`);
   await mkdir6(stagingRoot);
   await writeImplementationDirectory(stagingRoot, document, briefs);
   let backedUp = false;
@@ -21262,7 +21294,7 @@ async function writeLatestView(planDir, document, source, briefs) {
         throw error;
     }
     await rename2(stagedImplementation, current);
-    await atomicWrite(join17(planDir, "PLAN.md"), source);
+    await atomicWrite(join18(planDir, "PLAN.md"), source);
     if (backedUp)
       await rm2(backup, { recursive: true, force: true });
   } catch (error) {
@@ -21275,13 +21307,13 @@ async function writeLatestView(planDir, document, source, briefs) {
   }
 }
 async function writeImplementationDirectory(baseDir, document, briefs) {
-  const implementationDir = join17(baseDir, "implementation");
+  const implementationDir = join18(baseDir, "implementation");
   await mkdir6(implementationDir, { recursive: true });
   for (const [index, phase] of document.phases.entries()) {
     const brief = briefs[index];
     if (!brief)
       throw new Error(`Missing implementation brief for phase ${phase.id}.`);
-    await atomicWrite(join17(implementationDir, `phase-${index + 1}.md`), renderImplementationBrief(document.revision, index + 1, phase, brief));
+    await atomicWrite(join18(implementationDir, `phase-${index + 1}.md`), renderImplementationBrief(document.revision, index + 1, phase, brief));
   }
 }
 function normalizeRevision(current, request, id, revision, updatedAt) {
@@ -21767,7 +21799,7 @@ function createPlanTools(_pi, _modes, store = createPlanStore()) {
         const resolution = await store.context(workingDirectory, params.plan);
         if (!resolution.record)
           throw new Error(resolution.ambiguous ? `Plan is ambiguous: ${resolution.candidates.map((item) => item.id).join(", ")}.` : "No matching plan.");
-        const cliPath = join18(resolveBundledAgentsDir(), "..", "dist", "cli.js");
+        const cliPath = join19(resolveBundledAgentsDir(), "..", "dist", "cli.js");
         const command = [
           process.execPath,
           cliPath,
@@ -22567,10 +22599,10 @@ function hasGitlabDraftNotes(input) {
 }
 
 // src/review/local-review-backend.ts
-import { readFile as readFile11, writeFile as writeFile5 } from "node:fs/promises";
+import { readFile as readFile12, writeFile as writeFile5 } from "node:fs/promises";
 
 // src/extensions/tuicrx.ts
-import { readFile as readFile10, realpath as realpath4 } from "node:fs/promises";
+import { readFile as readFile11, realpath as realpath4 } from "node:fs/promises";
 import { resolve as resolve5 } from "node:path";
 async function tuicrAvailable() {
   return Boolean(await findExecutable("tuicr"));
@@ -22667,7 +22699,7 @@ async function findMatchingSession(sessions, cwd, branch) {
   return;
 }
 async function readSession(path) {
-  const content = await readFile10(path, "utf8");
+  const content = await readFile11(path, "utf8");
   try {
     return JSON.parse(content);
   } catch {
@@ -22788,7 +22820,7 @@ function LocalReviewBackend(options) {
     },
     async listThreads() {
       try {
-        return parseThreadArtifact(await readFile11(options.artifactPath, "utf8"));
+        return parseThreadArtifact(await readFile12(options.artifactPath, "utf8"));
       } catch (error) {
         if (error.code === "ENOENT")
           return [];
@@ -22796,7 +22828,7 @@ function LocalReviewBackend(options) {
       }
     },
     async reply(input) {
-      const content = await readFile11(options.artifactPath, "utf8");
+      const content = await readFile12(options.artifactPath, "utf8");
       await writeFile5(options.artifactPath, upsertThreadReply(content, input.threadId, input.body, input.question, input.resolve), "utf8");
     },
     async publish() {
@@ -22818,8 +22850,8 @@ function createLocalReviewBackend(options) {
 }
 // src/review/review-state.ts
 import { createHash as createHash4 } from "node:crypto";
-import { readFile as readFile12, rename as rename3, writeFile as writeFile6 } from "node:fs/promises";
-import { join as join19 } from "node:path";
+import { readFile as readFile13, rename as rename3, writeFile as writeFile6 } from "node:fs/promises";
+import { join as join20 } from "node:path";
 import { z as z11 } from "zod";
 var reviewPublicationStateSchema = z11.object({
   target: z11.string().optional(),
@@ -22843,9 +22875,9 @@ function unpublishedReviewComments(comments, knownFingerprints) {
 }
 async function loadReviewPublicationState(cwd, vcs, number, homeDir) {
   const target = `${vcs.provider}:${vcs.owner}/${vcs.repo}#${number}`;
-  const path = join19(await sessionsDir(cwd, homeDir), `review-publish-${digest(target).slice(0, 16)}.json`);
+  const path = join20(await sessionsDir(cwd, homeDir), `review-publish-${digest(target).slice(0, 16)}.json`);
   try {
-    const parsed = reviewPublicationStateSchema.parse(JSON.parse(await readFile12(path, "utf8")));
+    const parsed = reviewPublicationStateSchema.parse(JSON.parse(await readFile13(path, "utf8")));
     return { path, state: { ...parsed, target } };
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -22866,42 +22898,6 @@ async function saveReviewPublicationState(path, state) {
 function digest(value) {
   return createHash4("sha256").update(value).digest("hex");
 }
-// src/templates.ts
-import { readFile as readFile13 } from "node:fs/promises";
-import { homedir as homedir7 } from "node:os";
-import { join as join20, normalize } from "node:path";
-async function loadTemplate(name, options = {}) {
-  const relative = templateRelativePath(name);
-  const userPath = join20(options.homeDir ?? homedir7(), ".difflab", "diffpi", "templates", relative);
-  const bundledPath = join20(options.bundledDir ?? resolveBundledTemplatesDir(), relative);
-  const user = await readOptionalFile(userPath);
-  if (user !== undefined)
-    return { name, path: userPath, source: "user", content: user };
-  const bundled = await readOptionalFile(bundledPath);
-  if (bundled !== undefined)
-    return { name, path: bundledPath, source: "bundled", content: bundled };
-  throw new Error(`Template "${name}" was not found at ${userPath} or ${bundledPath}.`);
-}
-function renderTemplate(content, variables) {
-  return content.replace(/\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g, (match, key) => variables[key] ?? match);
-}
-function templateRelativePath(name) {
-  const normalized = normalize(name.replaceAll("\\", "/")).replace(/^\.\//, "");
-  if (!normalized || normalized.startsWith("../") || normalized.includes("/../") || normalized.startsWith("/")) {
-    throw new Error(`Invalid template name: ${name}`);
-  }
-  return normalized.endsWith(".md") ? normalized : `${normalized}.md`;
-}
-async function readOptionalFile(path) {
-  try {
-    return await readFile13(path, "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return;
-    throw error;
-  }
-}
-
 // src/tools/review.ts
 var contextSchema = z12.object({
   cwd: z12.string().optional(),