codecartographer-pi 0.19.4 → 0.19.6

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

@@ -0,0 +1,16 @@
+import type { ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+export type NotifyLevel = "info" | "warning" | "error";
+/** Whether `ctx` still belongs to the live session. See the module comment. */
+export declare function isCtxLive(ctx: ExtensionContext | ExtensionCommandContext): boolean;
+/**
+ * Format a notification for a stream. Exported so tests pin the shape a script
+ * would parse: one line, prefixed, level visible.
+ */
+export declare function formatStreamNotification(message: string, level: NotifyLevel): string;
+/**
+ * Notify through `ctx`: the TUI when there is one, stderr when there is not,
+ * nothing when the ctx is stale.
+ */
+export declare function notifyCtx(ctx: ExtensionContext | ExtensionCommandContext, message: string, level: NotifyLevel, stream?: {
+    write(chunk: string): unknown;
+}): void;

package/dist/extensions/codecarto/notify.js

@@ -0,0 +1,53 @@
+// User-facing notifications from the orchestrator side of the Pi extension.
+//
+// Two things go wrong with a bare `ctx.ui.notify(...)`, and this module is the
+// one place that handles both.
+//
+// A stale ctx throws. Pi invalidates an extension ctx when the session is
+// replaced, and from then on *every* property access on it throws — `ctx.cwd`
+// and `ctx.hasUI` included. A phase runs as a sub-agent, so by the time
+// post-phase work fires, the ctx captured when the command started may already
+// be dead. That is an ordinary outcome, not an error: the UI it would have
+// refreshed is gone with the session, so the message is dropped.
+//
+// A non-interactive session shows nothing. Under `pi -p`, `ctx.hasUI` is false
+// and `ctx.ui.notify` is a silent no-op. Commands whose only output is a notify
+// — /codecarto-status, /codecarto-usage, /codecarto-list-skills — then exit 0
+// having printed nothing, which is byte-for-byte what a silent refusal looks
+// like (#219). So when there is no UI, the message goes to stderr instead:
+// stderr rather than stdout because `--mode json` owns stdout for its event
+// stream and prose there would corrupt it.
+//
+// This is for the orchestrator's ctx only. Code that runs inside the phase
+// sub-agent (phase-compaction.ts) also sees `hasUI === false`, but there the
+// parent TUI may be on screen, and writing to stderr would put text into a live
+// terminal. That code keeps its own `if (ctx.hasUI)` guards.
+/** Whether `ctx` still belongs to the live session. See the module comment. */
+export function isCtxLive(ctx) {
+    try {
+        return typeof ctx.cwd === "string";
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Format a notification for a stream. Exported so tests pin the shape a script
+ * would parse: one line, prefixed, level visible.
+ */
+export function formatStreamNotification(message, level) {
+    return `[codecarto] ${level}: ${message}\n`;
+}
+/**
+ * Notify through `ctx`: the TUI when there is one, stderr when there is not,
+ * nothing when the ctx is stale.
+ */
+export function notifyCtx(ctx, message, level, stream = process.stderr) {
+    if (!isCtxLive(ctx))
+        return;
+    if (ctx.hasUI) {
+        ctx.ui.notify(message, level);
+        return;
+    }
+    stream.write(formatStreamNotification(message, level));
+}

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

@@ -1,7 +1,7 @@
-import { mkdir, rename, writeFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
 import { compact } from "@earendil-works/pi-coding-agent";
-import { canonicalPath, getWorkspaceState, isWithinPath } from "../../core/index.js";
+import { atomicWriteFile, canonicalPath, getWorkspaceState, isWithinPath, resolveExistingPrefix } from "../../core/index.js";
 const PHASE_SESSION_PREFIX = "CodeCartographer phase: ";
 export function phaseIdFromSessionName(sessionName) {
     if (!sessionName?.startsWith(PHASE_SESSION_PREFIX))
@@ -29,7 +29,6 @@ export function buildPhaseCompactionInstructions(phaseId, primaryOutput) {
 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 = [
         "---",
@@ -44,8 +43,7 @@ export async function writePhaseCheckpoint(cwd, phaseId, summary, tokensBefore)
         summary.trim(),
         "",
     ].join("\n");
-    await writeFile(temp, content, "utf8");
-    await rename(temp, target);
+    await atomicWriteFile(target, content);
     return target;
 }
 /**
@@ -64,7 +62,9 @@ export function phaseCompactionExtension(pi) {
         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));
+            // Same containment as the parent extension's hook (#223): follow the
+            // existing prefix through symlinks, then append the unborn tail.
+            const targetPath = await resolveExistingPrefix(strippedPath, ctx.cwd);
             const allowedRoot = await canonicalPath(join(ctx.cwd, ".codecarto"));
             if (!isWithinPath(targetPath, allowedRoot)) {
                 return {

package/dist/mcp-server/server.js

@@ -125,8 +125,11 @@ export async function handleInit(args) {
         // broadside state and results already on disk.
         await copyPackagedWorkspace(targetWorkspaceDir);
     }
+    // The template no longer carries a status.yaml (it is this repository's
+    // own project state); one is only present when init is re-run over an
+    // existing workspace, where its pipeline stays the default.
     const statusPath = join(targetWorkspaceDir, "workflow", "status.yaml");
-    const rawStatus = (await loadYamlFile(statusPath)) ?? {};
+    const rawStatus = (await pathExists(statusPath)) ? ((await loadYamlFile(statusPath)) ?? {}) : {};
     const selectedPipelinePath = pipelineChoice ?? rawStatus.pipeline?.trim() ?? DEFAULT_PIPELINE_PATH;
     const resolvedPipelinePath = join(targetWorkspaceDir, selectedPipelinePath);
     if (!(await pathExists(resolvedPipelinePath))) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codecartographer-pi",
-  "version": "0.19.4",
+  "version": "0.19.6",
   "mcpName": "io.github.HuginnIndustries/codecartographer",
   "description": "Turn an unfamiliar codebase into a validated reimplementation spec, then synthesize confirmed specs and a product vision into a traceable plan.",
   "type": "module",