@vimhead.dev/norn-cli 0.1.0-tip.35614826665.1 → 0.1.0-tip.35724621678.1

package/dist/client.js

@@ -13,23 +13,78 @@ function createNornClient(input = {}) {
       inspect: async () => processRunner.readJson(["project", "inspect"])
     },
     workflows: {
-      list: async (options) => processRunner.readJson(["workflows", "list", ...options?.all ? ["--all"] : []]),
-      inspect: async (workflowId) => processRunner.readJson(["workflows", "inspect", workflowId]),
+      list: async (options) => processRunner.readJson([
+        "workflows",
+        "list",
+        ...options?.all ? ["--all"] : []
+      ]),
+      inspect: async (workflowId) => processRunner.readJson([
+        "workflows",
+        "inspect",
+        workflowId
+      ]),
       entries: async () => (await catalog.load()).workflows
     },
     runs: {
-      start: async (startInput) => (await processRunner.readJson(["runs", "start", startInput.workflowId], JSON.stringify(runStartInput(startInput)))).run,
-      resume: async (resumeInput) => (await processRunner.readJson(["runs", "resume", resumeInput.run], runResumeStdin(resumeInput))).run,
-      wait: async (run) => (await processRunner.readJson(["runs", "wait", run])).run,
-      list: async () => (await processRunner.readJson(["runs", "list"])).runs,
-      inspect: async (run) => (await processRunner.readJson(["runs", "inspect", run])).run,
-      checkpoints: async (run) => (await processRunner.readJson(["runs", "checkpoints", run])).checkpoints,
-      metrics: async (run) => (await processRunner.readJson(["runs", "metrics", run])).metrics,
-      rollback: async (run, checkpointId) => (await processRunner.readJson(["runs", "rollback", run, checkpointId])).run,
-      stop: async (run) => (await processRunner.readJson(["runs", "stop", run])).run,
-      kill: async (run) => (await processRunner.readJson(["runs", "kill", run])).run,
-      delete: async (run) => (await processRunner.readJson(["runs", "delete", run])).deleted,
-      logs: (run, options) => processRunner.readJsonLines(["runs", "logs", run, ...options?.follow ? ["--follow"] : []])
+      start: async (startInput) => (await processRunner.readJson(
+        ["runs", "start", startInput.workflowId],
+        JSON.stringify(runStartInput(startInput))
+      )).run,
+      resume: async (resumeInput) => (await processRunner.readJson(
+        ["runs", "resume", resumeInput.run],
+        runResumeStdin(resumeInput)
+      )).run,
+      wait: async (run) => (await processRunner.readJson([
+        "runs",
+        "wait",
+        run
+      ])).run,
+      list: async () => (await processRunner.readJson([
+        "runs",
+        "list"
+      ])).runs,
+      inspect: async (run) => (await processRunner.readJson([
+        "runs",
+        "inspect",
+        run
+      ])).run,
+      checkpoints: async (run) => (await processRunner.readJson([
+        "runs",
+        "checkpoints",
+        run
+      ])).checkpoints,
+      metrics: async (run) => (await processRunner.readJson([
+        "runs",
+        "metrics",
+        run
+      ])).metrics,
+      rollback: async (run, checkpointId) => (await processRunner.readJson([
+        "runs",
+        "rollback",
+        run,
+        checkpointId
+      ])).run,
+      stop: async (run) => (await processRunner.readJson([
+        "runs",
+        "stop",
+        run
+      ])).run,
+      kill: async (run) => (await processRunner.readJson([
+        "runs",
+        "kill",
+        run
+      ])).run,
+      delete: async (run) => (await processRunner.readJson([
+        "runs",
+        "delete",
+        run
+      ])).deleted,
+      logs: (run, options) => processRunner.readJsonLines([
+        "runs",
+        "logs",
+        run,
+        ...options?.follow ? ["--follow"] : []
+      ])
     }
   };
   return client;
@@ -59,14 +114,23 @@ var NornProcessRunner = class {
     const result = await this.spawn(args, stdin);
     const parsed = JSON.parse(result.stdout);
     if (parsed && typeof parsed === "object" && "error" in parsed) {
-      if (parsed.error?.code === "NORN_PROJECT_INVALID" && Array.isArray(parsed.error.diagnostics)) throw new NornProjectLoadError({ diagnostics: parsed.error.diagnostics });
+      if (parsed.error?.code === "NORN_PROJECT_INVALID" && Array.isArray(parsed.error.diagnostics))
+        throw new NornProjectLoadError({
+          diagnostics: parsed.error.diagnostics
+        });
       throw new Error(parsed.error?.message ?? "Norn command failed");
     }
-    if (result.exitCode !== 0) throw new Error(result.stderr || `Norn exited with code ${result.exitCode}`);
+    if (result.exitCode !== 0)
+      throw new Error(
+        result.stderr || `Norn exited with code ${result.exitCode}`
+      );
     return parsed;
   }
   async *readJsonLines(args) {
-    const child = spawn(process.execPath, [this.executablePath, ...args], { cwd: this.input.spawnCwd, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn(process.execPath, [this.executablePath, ...args], {
+      cwd: this.input.spawnCwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
     let stderr = "";
     child.stderr?.on("data", (chunk) => {
       stderr += chunk.toString();
@@ -75,15 +139,26 @@ var NornProcessRunner = class {
     for await (const line of lines) {
       if (line.trim().length === 0) continue;
       const parsed = JSON.parse(line);
-      if (parsed.error) throw new Error(String(parsed.error.message ?? "Norn stream failed"));
+      if (parsed.error)
+        throw new Error(
+          String(
+            parsed.error.message ?? "Norn stream failed"
+          )
+        );
       yield parsed;
     }
-    const exitCode = await new Promise((resolvePromise) => child.on("close", resolvePromise));
-    if (exitCode !== 0) throw new Error(stderr || `Norn exited with code ${exitCode}`);
+    const exitCode = await new Promise(
+      (resolvePromise) => child.on("close", resolvePromise)
+    );
+    if (exitCode !== 0)
+      throw new Error(stderr || `Norn exited with code ${exitCode}`);
   }
   async spawn(args, stdin) {
     return new Promise((resolvePromise, reject) => {
-      const child = spawn(process.execPath, [this.executablePath, ...args], { cwd: this.input.spawnCwd, stdio: [stdin === void 0 ? "ignore" : "pipe", "pipe", "pipe"] });
+      const child = spawn(process.execPath, [this.executablePath, ...args], {
+        cwd: this.input.spawnCwd,
+        stdio: [stdin === void 0 ? "ignore" : "pipe", "pipe", "pipe"]
+      });
       let stdout = "";
       let stderr = "";
       child.stdout?.on("data", (chunk) => {
@@ -94,7 +169,10 @@ var NornProcessRunner = class {
       });
       child.on("error", reject);
       if (stdin !== void 0) child.stdin?.end(stdin);
-      child.on("close", (exitCode) => resolvePromise({ stdout, stderr, exitCode }));
+      child.on(
+        "close",
+        (exitCode) => resolvePromise({ stdout, stderr, exitCode })
+      );
     });
   }
 };

package/dist/documentation.js

@@ -1,8 +1,21 @@
 // src/documentation.ts
 import { createHash } from "node:crypto";
-import { lstat, mkdir, mkdtemp, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import {
+  lstat,
+  mkdir,
+  mkdtemp,
+  readFile,
+  readdir,
+  rename,
+  rm,
+  writeFile
+} from "node:fs/promises";
 import { join, resolve } from "node:path";
-import { DOCUMENTATION_PATHS, hashDocumentationBundle, validateDocumentationBundle } from "./internal/documentation-bundle.js";
+import {
+  DOCUMENTATION_PATHS,
+  hashDocumentationBundle,
+  validateDocumentationBundle
+} from "./internal/documentation-bundle.js";
 
 // ../core/src/errors.ts
 function isNodeError(error) {
@@ -14,10 +27,20 @@ import { renderNornDocumentationIntro } from "./documentation-intro.js";
 function resolveDocumentationCacheRoot(input) {
   const override = input.environment.NORN_DOCS_CACHE_DIR;
   if (override) return resolve(override);
-  if (input.platform === "win32") return join(input.environment.LOCALAPPDATA || join(input.home, "AppData", "Local"), "norn", "docs");
-  if (input.platform === "darwin") return join(input.home, "Library", "Caches", "norn", "docs");
+  if (input.platform === "win32")
+    return join(
+      input.environment.LOCALAPPDATA || join(input.home, "AppData", "Local"),
+      "norn",
+      "docs"
+    );
+  if (input.platform === "darwin")
+    return join(input.home, "Library", "Caches", "norn", "docs");
   const xdgCache = input.environment.XDG_CACHE_HOME;
-  return join(xdgCache?.startsWith("/") ? xdgCache : join(input.home, ".cache"), "norn", "docs");
+  return join(
+    xdgCache?.startsWith("/") ? xdgCache : join(input.home, ".cache"),
+    "norn",
+    "docs"
+  );
 }
 async function resolveNornDocumentation(input) {
   let root;
@@ -25,18 +48,38 @@ async function resolveNornDocumentation(input) {
   let assetDigest = null;
   if (input.source.kind === "local") {
     root = resolve(input.source.root);
-    const packageInfo = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
-    if (typeof packageInfo.version !== "string" || packageInfo.version.length === 0) throw new Error("Invalid documentation package version");
+    const packageInfo = JSON.parse(
+      await readFile(join(root, "package.json"), "utf8")
+    );
+    if (typeof packageInfo.version !== "string" || packageInfo.version.length === 0)
+      throw new Error("Invalid documentation package version");
     version = packageInfo.version;
-    if (version !== input.build.version) throw new Error("Local documentation version does not match the runtime; rebuild or reinstall this CLI package");
+    if (version !== input.build.version)
+      throw new Error(
+        "Local documentation version does not match the runtime; rebuild or reinstall this CLI package"
+      );
     await validateLocalDocumentation(root);
   } else {
     validateDocumentationBundle(input.source.bundle);
     version = input.source.bundle.version;
-    if (version !== input.build.version) throw new Error("Embedded documentation version does not match the binary build");
+    if (version !== input.build.version)
+      throw new Error(
+        "Embedded documentation version does not match the binary build"
+      );
     assetDigest = hashDocumentationBundle(input.source.bundle);
-    const cacheKey = createHash("sha256").update(JSON.stringify({ format: 1, assetDigest, version, commit: input.build.commit })).digest("hex");
-    root = await new NornDocumentationCache({ cacheRoot: resolve(input.cacheRoot), cacheKey, bundle: input.source.bundle }).materialize();
+    const cacheKey = createHash("sha256").update(
+      JSON.stringify({
+        format: 1,
+        assetDigest,
+        version,
+        commit: input.build.commit
+      })
+    ).digest("hex");
+    root = await new NornDocumentationCache({
+      cacheRoot: resolve(input.cacheRoot),
+      cacheKey,
+      bundle: input.source.bundle
+    }).materialize();
   }
   return {
     storage: input.source.kind === "local" ? "installation" : "cache",
@@ -56,14 +99,17 @@ async function validateLocalDocumentation(root) {
   for (const [key, path] of Object.entries(DOCUMENTATION_PATHS)) {
     const stat = await lstat(join(root, path));
     const isExpectedType = key === "docs" || key === "examples" ? stat.isDirectory() : stat.isFile();
-    if (!isExpectedType) throw new Error(`Invalid local documentation path: ${join(root, path)}`);
+    if (!isExpectedType)
+      throw new Error(`Invalid local documentation path: ${join(root, path)}`);
   }
 }
 var NornDocumentationCache = class {
   constructor(input) {
     this.input = input;
     this.root = join(input.cacheRoot, `v1-${input.cacheKey}`);
-    this.files = new Map(input.bundle.files.map((file) => [file.path, file.content]));
+    this.files = new Map(
+      input.bundle.files.map((file) => [file.path, file.content])
+    );
   }
   input;
   root;
@@ -71,22 +117,36 @@ var NornDocumentationCache = class {
   async materialize() {
     await mkdir(this.input.cacheRoot, { recursive: true, mode: 448 });
     const cacheStat = await lstat(this.input.cacheRoot);
-    if (!cacheStat.isDirectory() || cacheStat.isSymbolicLink()) throw new Error(`Documentation cache root must be a real directory: ${this.input.cacheRoot}`);
+    if (!cacheStat.isDirectory() || cacheStat.isSymbolicLink())
+      throw new Error(
+        `Documentation cache root must be a real directory: ${this.input.cacheRoot}`
+      );
     if (await this.validateExistingCache()) return this.root;
     const staging = await mkdtemp(join(this.input.cacheRoot, ".extract-"));
     try {
       for (const file of this.input.bundle.files) {
         const parts = file.path.split("/");
-        await mkdir(join(staging, ...parts.slice(0, -1)), { recursive: true, mode: 448 });
-        await writeFile(join(staging, ...parts), file.content, { encoding: "utf8", flag: "wx", mode: 384 });
+        await mkdir(join(staging, ...parts.slice(0, -1)), {
+          recursive: true,
+          mode: 448
+        });
+        await writeFile(join(staging, ...parts), file.content, {
+          encoding: "utf8",
+          flag: "wx",
+          mode: 384
+        });
       }
       try {
         await rename(staging, this.root);
       } catch (error) {
-        if (!isNodeError(error) || !["EEXIST", "ENOTEMPTY", "EPERM", "EACCES"].includes(error.code ?? "")) throw error;
+        if (!isNodeError(error) || !["EEXIST", "ENOTEMPTY", "EPERM", "EACCES"].includes(error.code ?? ""))
+          throw error;
         if (!await this.validateExistingCache()) throw error;
       }
-      if (!await this.validateExistingCache()) throw new Error(`Documentation cache disappeared after extraction: ${this.root}`);
+      if (!await this.validateExistingCache())
+        throw new Error(
+          `Documentation cache disappeared after extraction: ${this.root}`
+        );
       return this.root;
     } finally {
       await rm(staging, { recursive: true, force: true });
@@ -100,21 +160,36 @@ var NornDocumentationCache = class {
       if (isNodeError(error) && error.code === "ENOENT") return false;
       throw error;
     }
-    if (!stat.isDirectory() || stat.isSymbolicLink()) throw this.invalidCacheError();
+    if (!stat.isDirectory() || stat.isSymbolicLink())
+      throw this.invalidCacheError();
     const seenFiles = /* @__PURE__ */ new Set();
-    await this.validateDirectory({ directory: this.root, prefix: "", seenFiles });
+    await this.validateDirectory({
+      directory: this.root,
+      prefix: "",
+      seenFiles
+    });
     if (seenFiles.size !== this.files.size) throw this.invalidCacheError();
     return true;
   }
   async validateDirectory(input) {
-    for (const entry of await readdir(input.directory, { withFileTypes: true })) {
+    for (const entry of await readdir(input.directory, {
+      withFileTypes: true
+    })) {
       const path = input.prefix ? `${input.prefix}/${entry.name}` : entry.name;
       const absolutePath = join(input.directory, entry.name);
       if (entry.isDirectory()) {
-        if (![...this.files.keys()].some((file) => file.startsWith(`${path}/`))) throw this.invalidCacheError();
-        await this.validateDirectory({ directory: absolutePath, prefix: path, seenFiles: input.seenFiles });
+        if (![...this.files.keys()].some((file) => file.startsWith(`${path}/`)))
+          throw this.invalidCacheError();
+        await this.validateDirectory({
+          directory: absolutePath,
+          prefix: path,
+          seenFiles: input.seenFiles
+        });
       } else if (entry.isFile() && this.files.has(path)) {
-        if (!(await readFile(absolutePath)).equals(Buffer.from(this.files.get(path), "utf8"))) throw this.invalidCacheError();
+        if (!(await readFile(absolutePath)).equals(
+          Buffer.from(this.files.get(path), "utf8")
+        ))
+          throw this.invalidCacheError();
         input.seenFiles.add(path);
       } else {
         throw this.invalidCacheError();
@@ -122,7 +197,9 @@ var NornDocumentationCache = class {
     }
   }
   invalidCacheError() {
-    return new Error(`Documentation cache is incomplete or modified: ${this.root}. Remove this cache entry and retry; copy examples elsewhere before editing them.`);
+    return new Error(
+      `Documentation cache is incomplete or modified: ${this.root}. Remove this cache entry and retry; copy examples elsewhere before editing them.`
+    );
   }
 };
 export {

package/dist/generated-build-info.d.ts

@@ -1,7 +1,7 @@
 export declare const NORN_GENERATED_BUILD_INFO: {
     readonly kind: "npm-registry";
-    readonly version: "0.1.0-tip.35614826665.1";
-    readonly commit: "286e68533b1d26b5afbb0cba9d75f857fb85dc53";
+    readonly version: "0.1.0-tip.35724621678.1";
+    readonly commit: "51ea925604755506d4cde05b9224eacb48189ffd";
     readonly packageSpec: "@vimhead.dev/norn-cli@tip";
     readonly upgrade: {
         readonly supported: false;

package/dist/generated-build-info.js

@@ -1,8 +1,8 @@
 // src/generated-build-info.ts
 var NORN_GENERATED_BUILD_INFO = {
   "kind": "npm-registry",
-  "version": "0.1.0-tip.35614826665.1",
-  "commit": "286e68533b1d26b5afbb0cba9d75f857fb85dc53",
+  "version": "0.1.0-tip.35724621678.1",
+  "commit": "51ea925604755506d4cde05b9224eacb48189ffd",
   "packageSpec": "@vimhead.dev/norn-cli@tip",
   "upgrade": {
     "supported": false,

package/dist/internal/agent-directory.js

@@ -1,7 +1,9 @@
 // src/internal/agent-directory.ts
 import { join, resolve } from "node:path";
 function resolveNornAgentDirectory(input) {
-  return resolve(input.environment.NORN_AGENT_DIR || join(input.home, ".norn", "agent"));
+  return resolve(
+    input.environment.NORN_AGENT_DIR || join(input.home, ".norn", "agent")
+  );
 }
 export {
   resolveNornAgentDirectory

package/dist/internal/agent-response-tool.js

@@ -1,5 +1,7 @@
 // src/internal/agent-response-tool.ts
-import { defineTool } from "@earendil-works/pi-coding-agent";
+import {
+  defineTool
+} from "@earendil-works/pi-coding-agent";
 
 // ../core/src/agent-protocol.ts
 var AGENT_RESPONSE_TOOL_NAME = "pi_workflows_agent_response";
@@ -16,11 +18,15 @@ var NornAgentResponseCollector = class {
   }
   capture(runId, label, response) {
     const pending = this.pending.get(runId);
-    if (!pending) throw new Error(`No active workflow agent response slot: ${runId}`);
+    if (!pending)
+      throw new Error(`No active workflow agent response slot: ${runId}`);
     if (pending.label !== label) {
-      throw new Error(`Workflow agent response label mismatch: expected ${pending.label}, received ${label}`);
+      throw new Error(
+        `Workflow agent response label mismatch: expected ${pending.label}, received ${label}`
+      );
     }
-    if (pending.called) throw new Error(`Workflow agent response already recorded for ${runId}`);
+    if (pending.called)
+      throw new Error(`Workflow agent response already recorded for ${runId}`);
     const decoded = Value.Decode(pending.responseSchema, response);
     pending.called = true;
     pending.response = decoded;
@@ -48,16 +54,36 @@ var NornAgentResponseToolFactory = class {
         `After calling ${AGENT_RESPONSE_TOOL_NAME}, do not emit another assistant response in the same turn.`
       ],
       parameters: Type.Object({
-        runId: Type.String({ description: "The exact workflow response runId provided in the prompt." }),
-        label: Type.String({ description: "The exact workflow agent label provided in the prompt." }),
-        response: Type.Unknown({ description: "The structured response object requested by the workflow." })
+        runId: Type.String({
+          description: "The exact workflow response runId provided in the prompt."
+        }),
+        label: Type.String({
+          description: "The exact workflow agent label provided in the prompt."
+        }),
+        response: Type.Unknown({
+          description: "The structured response object requested by the workflow."
+        })
       }),
       async execute(_toolCallId, args) {
         try {
-          const captured = responseCollector.capture(args.runId, args.label, args.response);
+          const captured = responseCollector.capture(
+            args.runId,
+            args.label,
+            args.response
+          );
           return {
-            content: [{ type: "text", text: `Recorded workflow agent response for ${captured.label}.` }],
-            details: { valid: true, runId: args.runId, label: captured.label, response: captured.response },
+            content: [
+              {
+                type: "text",
+                text: `Recorded workflow agent response for ${captured.label}.`
+              }
+            ],
+            details: {
+              valid: true,
+              runId: args.runId,
+              label: captured.label,
+              response: captured.response
+            },
             terminate: true
           };
         } catch (error) {
@@ -69,7 +95,12 @@ var NornAgentResponseToolFactory = class {
 };
 function invalidAgentResponseToolResult(error) {
   return {
-    content: [{ type: "text", text: `Invalid workflow agent response: ${error}. Call the tool again with a corrected response.` }],
+    content: [
+      {
+        type: "text",
+        text: `Invalid workflow agent response: ${error}. Call the tool again with a corrected response.`
+      }
+    ],
     details: { valid: false, error }
   };
 }