codecartographer-pi 0.10.0 → 0.11.0

package/dist/extensions/codecarto/dashboard-narrator.js

@@ -155,7 +155,6 @@ async function runNarratorOnce(ctx, prompt) {
         agentDir,
         sessionManager: SessionManager.inMemory(cwd),
         settingsManager: SettingsManager.create(cwd, agentDir),
-        modelRegistry: ctx.modelRegistry,
         model: ctx.model,
         tools: [],
         resourceLoader: loader,

package/dist/extensions/codecarto/index.d.ts

@@ -1,2 +1,2 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 export default function codeCartographerExtension(pi: ExtensionAPI): void;

package/dist/extensions/codecarto/index.js

@@ -6,6 +6,7 @@ import { parseDashboardFlags } from "./dashboard-flags.js";
 import { narrateDashboard } from "./dashboard-narrator.js";
 import { writeDashboard } from "./dashboard-writer.js";
 import { parseNextFlags } from "./next-flags.js";
+import { phaseCompactionExtension } from "./phase-compaction.js";
 import { buildPhasePrompt, buildSkillPrompt, buildValidationSummary, canonicalPath, computePerPhaseTotals, computeTotals, createEmptyStatus, DEFAULT_PIPELINE_PATH, getNextEligiblePhase, getPipelineLabel, getWorkspaceState, isWithinPath, listSkillNames, loadCodecartoConfig, loadUsage, loadYamlFile, normalizeForComparison, packagedWorkspaceDir, pathExists, PACKAGE_VERSION, PIPELINE_ALIASES, resolvePhase, resolvePipelineChoice, stringifySimpleYaml, validatePhaseOutput, } from "../../core/index.js";
 const STATUS_WIDGET_ID = "codecarto-widget";
 const STATUS_LINE_ID = "codecarto-status";
@@ -62,6 +63,7 @@ function setUiState(ctx, state, extraLines = []) {
     ctx.ui.setWidget(STATUS_WIDGET_ID, buildStatusLines(state, extraLines));
 }
 export default function codeCartographerExtension(pi) {
+    phaseCompactionExtension(pi);
     let lastFeedbackLines = [];
     let codecartoModeActive = false;
     const readWorkspaceState = async (ctx, notifyOnError = true) => {
@@ -143,6 +145,28 @@ export default function codeCartographerExtension(pi) {
         }
         return undefined;
     });
+    pi.registerCommand("codecarto-open", {
+        description: "Activate an existing .codecarto workspace without resetting durable state",
+        handler: async (_args, ctx) => {
+            const workspaceDir = join(ctx.cwd, ".codecarto");
+            if (!(await pathExists(join(workspaceDir, "workflow", "status.yaml")))) {
+                ctx.ui.notify("No existing CodeCartographer workspace found. Run /codecarto-init first.", "warning");
+                return;
+            }
+            try {
+                const state = await getWorkspaceState(ctx.cwd);
+                codecartoModeActive = true;
+                lastFeedbackLines = [`Opened existing workspace: ${getPipelineLabel(state.status.pipeline)}`];
+                pi.setActiveTools(SAFE_TOOL_NAMES);
+                await refreshWorkspaceUi(ctx, lastFeedbackLines);
+                ctx.ui.notify("Opened existing CodeCartographer workspace without resetting state.", "info");
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                ctx.ui.notify(`Unable to open CodeCartographer workspace: ${message}`, "error");
+            }
+        },
+    });
     pi.registerCommand("codecarto-init", {
         description: "Initialize .codecarto/ in the current repository",
         getArgumentCompletions: (prefix) => {
@@ -426,11 +450,14 @@ export default function codeCartographerExtension(pi) {
             lines.push(`Total runs: ${totals.runs}`);
             lines.push(`Total tokens: ${formatUsageTokens(totals.tokens.input)} in · ${formatUsageTokens(totals.tokens.output)} out · ${formatUsageTokens(totals.tokens.cache_write)} cache-write`);
             lines.push(`Total duration: ${formatUsageDuration(totals.duration_ms)} · ${totals.tool_uses} tool uses`);
+            lines.push(totals.compaction_runs > 0
+                ? `Compactions: ${totals.compactions.successful} successful · ${totals.compactions.failed} failed · ${totals.compactions.aborted} aborted`
+                : "Compactions: unavailable — historical or host usage records did not report compaction events");
             lines.push("");
             lines.push("Per-phase totals:");
             for (const [phaseId, t] of perPhase) {
                 const tokensTotal = t.tokens.input + t.tokens.output;
-                lines.push(`  ${phaseId}: ${t.runs} run${t.runs === 1 ? "" : "s"} · ${formatUsageTokens(tokensTotal)} tokens · ${t.tool_uses} tool uses · ${formatUsageDuration(t.duration_ms)}`);
+                lines.push(`  ${phaseId}: ${t.runs} run${t.runs === 1 ? "" : "s"} · ${formatUsageTokens(tokensTotal)} tokens · ${t.tool_uses} tool uses · ${t.compaction_runs > 0 ? `${t.compactions.successful + t.compactions.failed + t.compactions.aborted} compactions` : "compactions unavailable"} · ${formatUsageDuration(t.duration_ms)}`);
             }
             lastFeedbackLines = lines;
             setUiState(ctx, state, lastFeedbackLines);

package/dist/extensions/codecarto/phase-compaction.d.ts

@@ -0,0 +1,11 @@
+import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export declare function phaseIdFromSessionName(sessionName: string | undefined): string | null;
+export declare function buildPhaseCompactionInstructions(phaseId: string, primaryOutput?: string): string;
+export declare function writePhaseCheckpoint(cwd: string, phaseId: string, summary: string, tokensBefore: number): Promise<string>;
+/**
+ * Phase-only compaction hooks shared by the parent extension and isolated
+ * child sessions. Keeping this as a standalone inline extension ensures that
+ * children spawned from an explicitly loaded (`pi -e ...`) CodeCartographer
+ * extension receive the same checkpoint behavior as globally installed runs.
+ */
+export declare function phaseCompactionExtension(pi: ExtensionAPI): void;

package/dist/extensions/codecarto/phase-compaction.js

@@ -0,0 +1,115 @@
+import { mkdir, rename, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { compact } from "@earendil-works/pi-coding-agent";
+import { canonicalPath, getWorkspaceState, isWithinPath } from "../../core/index.js";
+const PHASE_SESSION_PREFIX = "CodeCartographer phase: ";
+export function phaseIdFromSessionName(sessionName) {
+    if (!sessionName?.startsWith(PHASE_SESSION_PREFIX))
+        return null;
+    const phaseId = sessionName.slice(PHASE_SESSION_PREFIX.length).trim();
+    return /^[a-z0-9][a-z0-9-]*$/.test(phaseId) ? phaseId : null;
+}
+export function buildPhaseCompactionInstructions(phaseId, primaryOutput) {
+    const output = primaryOutput ? `.codecarto/${primaryOutput}` : "the phase's declared primary output";
+    return [
+        `This is a CodeCartographer phase session for ${phaseId}.`,
+        `Produce a phase-aware continuation summary for ${output}.`,
+        "Preserve these details explicitly:",
+        "- phase goal and constraints",
+        "- evidence-backed conclusions and their evidence levels",
+        "- files inspected and subsystems covered or skipped",
+        "- primary-output sections already written and sections still missing",
+        "- edits already made under .codecarto/",
+        "- open questions and carry-forward candidates",
+        "- validation criteria already satisfied and validation criteria still at risk",
+        "- exact next steps needed to finish and validate the phase.",
+        "Do not turn an inference into an observed fact. Retain file paths, finding IDs, and unresolved gaps verbatim where possible.",
+    ].join("\n");
+}
+export async function writePhaseCheckpoint(cwd, phaseId, summary, tokensBefore) {
+    const dir = join(cwd, ".codecarto", "scratch", "checkpoints");
+    const target = join(dir, `${phaseId}.md`);
+    const temp = `${target}.${process.pid}.${Date.now()}.tmp`;
+    await mkdir(dir, { recursive: true });
+    const content = [
+        "---",
+        `phase: ${phaseId}`,
+        `updated_at: ${new Date().toISOString()}`,
+        `tokens_before: ${tokensBefore}`,
+        "source: pi-compaction",
+        "---",
+        "",
+        "# Phase checkpoint",
+        "",
+        summary.trim(),
+        "",
+    ].join("\n");
+    await writeFile(temp, content, "utf8");
+    await rename(temp, target);
+    return target;
+}
+/**
+ * Phase-only compaction hooks shared by the parent extension and isolated
+ * child sessions. Keeping this as a standalone inline extension ensures that
+ * children spawned from an explicitly loaded (`pi -e ...`) CodeCartographer
+ * extension receive the same checkpoint behavior as globally installed runs.
+ */
+export function phaseCompactionExtension(pi) {
+    pi.on("tool_call", async (event, ctx) => {
+        if (!phaseIdFromSessionName(ctx.sessionManager.getSessionName()))
+            return undefined;
+        if (event.toolName === "bash") {
+            return { block: true, reason: "CodeCartographer phase sessions disable bash to keep source analysis read-only." };
+        }
+        if (event.toolName === "edit" || event.toolName === "write") {
+            const inputPath = typeof event.input.path === "string" ? event.input.path : "";
+            const strippedPath = inputPath.startsWith("@") ? inputPath.slice(1) : inputPath;
+            const targetPath = await canonicalPath(resolve(ctx.cwd, strippedPath));
+            const allowedRoot = await canonicalPath(join(ctx.cwd, ".codecarto"));
+            if (!isWithinPath(targetPath, allowedRoot)) {
+                return {
+                    block: true,
+                    reason: `CodeCartographer phase sessions only allow ${event.toolName} within .codecarto/`,
+                };
+            }
+        }
+        return undefined;
+    });
+    pi.on("session_before_compact", async (event, ctx) => {
+        const phaseId = phaseIdFromSessionName(ctx.sessionManager.getSessionName());
+        if (!phaseId || !ctx.model)
+            return undefined;
+        try {
+            const state = await getWorkspaceState(ctx.cwd);
+            const phase = state.pipeline.phases.find((candidate) => candidate.id === phaseId);
+            const auth = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model);
+            if (!auth.ok || !auth.apiKey)
+                return undefined;
+            const instructions = buildPhaseCompactionInstructions(phaseId, phase?.primary_output);
+            const result = await compact(event.preparation, ctx.model, auth.apiKey, auth.headers, instructions, event.signal);
+            return { compaction: result };
+        }
+        catch (error) {
+            if (ctx.hasUI) {
+                const message = error instanceof Error ? error.message : String(error);
+                ctx.ui.notify(`Phase-aware compaction unavailable (${message}); using host default.`, "warning");
+            }
+            return undefined;
+        }
+    });
+    pi.on("session_compact", async (event, ctx) => {
+        const phaseId = phaseIdFromSessionName(ctx.sessionManager.getSessionName());
+        if (!phaseId)
+            return;
+        try {
+            await writePhaseCheckpoint(ctx.cwd, phaseId, event.compactionEntry.summary, event.compactionEntry.tokensBefore);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (ctx.hasUI)
+                ctx.ui.notify(`Phase checkpoint could not be written: ${message}`, "warning");
+            else
+                console.warn(`[codecarto] Phase checkpoint could not be written: ${message}`);
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codecartographer-pi",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "CodeCartographer packaged for Pi as an extension-driven workflow wrapper.",
   "type": "module",
   "keywords": [
@@ -43,7 +43,7 @@
     "@modelcontextprotocol/sdk": "^1.29.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "~0.74.0",
+    "@earendil-works/pi-coding-agent": "^0.80.10",
     "@sinclair/typebox": "*"
   },
   "pi": {