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

package/dist/internal/agents.js

@@ -22,12 +22,18 @@ import {
 } from "./agent-response-tool.js";
 import { errorMessage } from "./errors.js";
 import { safeFileName } from "./file-names.js";
-import { agentUsageFromValue, emptyAgentUsage, totalAgentUsage } from "./usage.js";
+import {
+  agentUsageFromValue,
+  emptyAgentUsage,
+  totalAgentUsage
+} from "./usage.js";
 var DEFAULT_AGENT_ATTEMPTS = 3;
 var NornAgentRunner = class {
   constructor(input) {
     this.input = input;
-    this.responseToolFactory = new NornAgentResponseToolFactory(input.responseCollector);
+    this.responseToolFactory = new NornAgentResponseToolFactory(
+      input.responseCollector
+    );
   }
   input;
   responseToolFactory;
@@ -49,7 +55,9 @@ var NornAgentRunner = class {
     const loader = services.resourceLoader;
     const errors = [
       ...services.diagnostics.filter((diagnostic) => diagnostic.type === "error").map((diagnostic) => diagnostic.message),
-      ...loader.getExtensions().errors.map((error) => `Failed to load extension ${error.path}: ${error.error}`)
+      ...loader.getExtensions().errors.map(
+        (error) => `Failed to load extension ${error.path}: ${error.error}`
+      )
     ];
     if (errors.length > 0) throw new Error(errors.join("\n"));
     const customTools = agentInput.customTools ?? [];
@@ -80,7 +88,11 @@ var NornAgentRunner = class {
       }));
       await agentInput.beforeSessionStart?.({ events: eventBus });
       await session.bindExtensions({});
-      await this.input.logger.record({ type: "agent.spawned", label: agentInput.label, cwd });
+      await this.input.logger.record({
+        type: "agent.spawned",
+        label: agentInput.label,
+        cwd
+      });
       return new CreatedNornAgentSession({
         ...this.input,
         label: agentInput.label,
@@ -95,7 +107,8 @@ var NornAgentRunner = class {
       } catch (cleanupError) {
         errors2.push(cleanupError);
       }
-      if (errors2.length > 1) throw new AggregateError(errors2, "Agent creation and cleanup failed");
+      if (errors2.length > 1)
+        throw new AggregateError(errors2, "Agent creation and cleanup failed");
       throw error;
     }
   }
@@ -132,22 +145,42 @@ var CreatedNornAgentSession = class {
     return (await this.promptWithResult(agentInput)).response;
   }
   async promptWithResult(agentInput) {
-    if (this.isDisposed) throw new Error(`Workflow agent session is disposed: ${this.label}`);
-    const maxAttempts = Math.max(1, Math.floor(agentInput.maxAttempts ?? DEFAULT_AGENT_ATTEMPTS));
+    if (this.isDisposed)
+      throw new Error(`Workflow agent session is disposed: ${this.label}`);
+    const maxAttempts = Math.max(
+      1,
+      Math.floor(agentInput.maxAttempts ?? DEFAULT_AGENT_ATTEMPTS)
+    );
     const attempts = [];
     const startedAtMs = Date.now();
     let isTerminalEventRecorded = false;
-    await this.input.logger.record({ type: "agent.started", label: this.label, cwd: this.cwd, maxAttempts });
+    await this.input.logger.record({
+      type: "agent.started",
+      label: this.label,
+      cwd: this.cwd,
+      maxAttempts
+    });
     try {
       for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-        await this.input.logger.record({ type: "agent.attempt.started", label: this.label, attempt });
-        const raw = await this.runAttempt(agentInput, attempt, attempts.at(-1)?.error);
+        await this.input.logger.record({
+          type: "agent.attempt.started",
+          label: this.label,
+          attempt
+        });
+        const raw = await this.runAttempt(
+          agentInput,
+          attempt,
+          attempts.at(-1)?.error
+        );
         const rawAttempt = { attempt, ...raw };
         attempts.push(rawAttempt);
         try {
-          if (!raw.responseToolCalled) throw new Error(`Agent did not call ${AGENT_RESPONSE_TOOL_NAME}`);
+          if (!raw.responseToolCalled)
+            throw new Error(`Agent did not call ${AGENT_RESPONSE_TOOL_NAME}`);
           const response = raw.toolResponse;
-          const usage = totalAgentUsage(attempts.map((candidate) => candidate.usage));
+          const usage = totalAgentUsage(
+            attempts.map((candidate) => candidate.usage)
+          );
           const result = {
             label: this.label,
             cwd: this.cwd,
@@ -155,22 +188,49 @@ var CreatedNornAgentSession = class {
             usage,
             raw: { ...raw, usage, attempts }
           };
-          await this.input.logs.write(`agents/${safeFileName(this.label)}.json`, JSON.stringify(result, null, 2));
+          await this.input.logs.write(
+            `agents/${safeFileName(this.label)}.json`,
+            JSON.stringify(result, null, 2)
+          );
           isTerminalEventRecorded = true;
-          await this.input.logger.record({ type: "agent.completed", label: this.label, attempts: attempt, durationMs: Date.now() - startedAtMs, usage });
+          await this.input.logger.record({
+            type: "agent.completed",
+            label: this.label,
+            attempts: attempt,
+            durationMs: Date.now() - startedAtMs,
+            usage
+          });
           return result;
         } catch (error) {
           const message = errorMessage(error);
           attempts[attempts.length - 1] = { ...rawAttempt, error: message };
           await this.input.logs.write(
             `agents/${safeFileName(this.label)}.attempt-${attempt}.raw.json`,
-            JSON.stringify({ label: this.label, cwd: this.cwd, raw: attempts.at(-1) }, null, 2)
+            JSON.stringify(
+              { label: this.label, cwd: this.cwd, raw: attempts.at(-1) },
+              null,
+              2
+            )
           );
-          await this.input.logger.record({ type: "agent.attempt.failed", label: this.label, attempt, error: message });
+          await this.input.logger.record({
+            type: "agent.attempt.failed",
+            label: this.label,
+            attempt,
+            error: message
+          });
           if (attempt === maxAttempts) {
-            const usage = totalAgentUsage(attempts.map((candidate) => candidate.usage));
+            const usage = totalAgentUsage(
+              attempts.map((candidate) => candidate.usage)
+            );
             isTerminalEventRecorded = true;
-            await this.input.logger.record({ type: "agent.failed", label: this.label, attempts: attempt, durationMs: Date.now() - startedAtMs, usage, error: message });
+            await this.input.logger.record({
+              type: "agent.failed",
+              label: this.label,
+              attempts: attempt,
+              durationMs: Date.now() - startedAtMs,
+              usage,
+              error: message
+            });
             throw new Error(
               `Agent ${this.label} did not return a valid structured response after ${attempt} attempt(s). Raw output saved to logs/agents/${safeFileName(this.label)}.attempt-${attempt}.raw.json: ${message}`
             );
@@ -206,35 +266,61 @@ var CreatedNornAgentSession = class {
     } catch (error) {
       errors.push(error);
     }
-    if (errors.length) throw new AggregateError(errors, "Agent disposal failed");
-    await this.input.logger.record({ type: "agent.disposed", label: this.label });
+    if (errors.length)
+      throw new AggregateError(errors, "Agent disposal failed");
+    await this.input.logger.record({
+      type: "agent.disposed",
+      label: this.label
+    });
   }
   async runAttempt(agentInput, attempt, previousError) {
     const responseRunId = `${this.input.id}:${attempt}:${randomUUID()}`;
     const messages = [];
     let text = "";
-    const releaseResponseSlot = this.input.responseCollector.begin(responseRunId, this.label, agentInput.response);
+    const releaseResponseSlot = this.input.responseCollector.begin(
+      responseRunId,
+      this.label,
+      agentInput.response
+    );
     const unsubscribe = this.input.session.subscribe((event) => {
       if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
         text += event.assistantMessageEvent.delta;
       }
-      if (event.type === "message_end" && event.message) messages.push(event.message);
+      if (event.type === "message_end" && event.message)
+        messages.push(event.message);
     });
     const abortNestedSession = () => {
       void this.input.session.abort();
     };
-    this.input.signal?.addEventListener("abort", abortNestedSession, { once: true });
+    this.input.signal?.addEventListener("abort", abortNestedSession, {
+      once: true
+    });
     let capturedResponse = { called: false };
     try {
       this.input.signal?.throwIfAborted();
-      await this.input.session.prompt(withResponseToolInstruction(agentInput.prompt, agentInput.response, this.label, responseRunId, attempt, previousError), {
-        ...agentInput.options,
-        source: agentInput.options?.source ?? "extension"
-      });
+      await this.input.session.prompt(
+        withResponseToolInstruction(
+          agentInput.prompt,
+          agentInput.response,
+          this.label,
+          responseRunId,
+          attempt,
+          previousError
+        ),
+        {
+          ...agentInput.options,
+          source: agentInput.options?.source ?? "extension"
+        }
+      );
       this.input.signal?.throwIfAborted();
       capturedResponse = this.input.responseCollector.get(responseRunId);
       if (!capturedResponse.called) {
-        await this.promptForStructuredResponse(agentInput, responseRunId, attempt, previousError);
+        await this.promptForStructuredResponse(
+          agentInput,
+          responseRunId,
+          attempt,
+          previousError
+        );
         this.input.signal?.throwIfAborted();
         capturedResponse = this.input.responseCollector.get(responseRunId);
       }
@@ -254,16 +340,38 @@ var CreatedNornAgentSession = class {
   }
   async promptForStructuredResponse(agentInput, responseRunId, attempt, previousError) {
     const activeToolNames = this.input.session.getActiveToolNames();
-    await this.input.logger.record({ type: "agent.response-finalization.started", label: this.label, attempt });
+    await this.input.logger.record({
+      type: "agent.response-finalization.started",
+      label: this.label,
+      attempt
+    });
     this.input.session.setActiveToolsByName([AGENT_RESPONSE_TOOL_NAME]);
     try {
-      await this.input.session.prompt(withResponseToolFinalizationInstruction(agentInput.response, this.label, responseRunId, attempt, previousError), {
-        ...agentInput.options,
-        source: agentInput.options?.source ?? "extension"
+      await this.input.session.prompt(
+        withResponseToolFinalizationInstruction(
+          agentInput.response,
+          this.label,
+          responseRunId,
+          attempt,
+          previousError
+        ),
+        {
+          ...agentInput.options,
+          source: agentInput.options?.source ?? "extension"
+        }
+      );
+      await this.input.logger.record({
+        type: "agent.response-finalization.completed",
+        label: this.label,
+        attempt
       });
-      await this.input.logger.record({ type: "agent.response-finalization.completed", label: this.label, attempt });
     } catch (error) {
-      await this.input.logger.record({ type: "agent.response-finalization.failed", label: this.label, attempt, error: errorMessage(error) });
+      await this.input.logger.record({
+        type: "agent.response-finalization.failed",
+        label: this.label,
+        attempt,
+        error: errorMessage(error)
+      });
       throw error;
     } finally {
       this.input.session.setActiveToolsByName(activeToolNames);
@@ -271,10 +379,13 @@ var CreatedNornAgentSession = class {
   }
 };
 function usageFromMessages(messages) {
-  return totalAgentUsage(messages.map(usageFromMessage).filter((usage) => usage !== void 0));
+  return totalAgentUsage(
+    messages.map(usageFromMessage).filter((usage) => usage !== void 0)
+  );
 }
 function usageFromMessage(message) {
-  if (!message || typeof message !== "object" || !("usage" in message)) return void 0;
+  if (!message || typeof message !== "object" || !("usage" in message))
+    return void 0;
   return agentUsageFromValue(message.usage) ?? emptyAgentUsage();
 }
 function withResponseToolInstruction(prompt, responseSchema, label, responseRunId, attempt, previousError) {
@@ -311,7 +422,8 @@ function withAgentResponseTool(tools) {
 function assertCustomToolNames(input) {
   const names = new Set(input.reservedNames);
   for (const tool of input.tools) {
-    if (names.has(tool.name)) throw new Error(`Custom tool name collision: ${tool.name}`);
+    if (names.has(tool.name))
+      throw new Error(`Custom tool name collision: ${tool.name}`);
     names.add(tool.name);
   }
 }

package/dist/internal/commands.js

@@ -13,9 +13,25 @@ var NornCommandRunner = class {
     const cwd = requireAbsoluteWorkingDirectory(commandInput.cwd);
     const startedAtMs = Date.now();
     const invocationId = randomUUID();
-    const stdoutRef = commandLog({ label: commandInput.label, invocationId, stream: "stdout" });
-    const stderrRef = commandLog({ label: commandInput.label, invocationId, stream: "stderr" });
-    await this.input.logger.record({ type: "command.started", invocationId, label: commandInput.label, command: commandInput.command, cwd, stdoutLogId: stdoutRef.id, stderrLogId: stderrRef.id });
+    const stdoutRef = commandLog({
+      label: commandInput.label,
+      invocationId,
+      stream: "stdout"
+    });
+    const stderrRef = commandLog({
+      label: commandInput.label,
+      invocationId,
+      stream: "stderr"
+    });
+    await this.input.logger.record({
+      type: "command.started",
+      invocationId,
+      label: commandInput.label,
+      command: commandInput.command,
+      cwd,
+      stdoutLogId: stdoutRef.id,
+      stderrLogId: stderrRef.id
+    });
     let result;
     const stdoutLog = await this.input.logs.createWriteStream(stdoutRef);
     const stderrLog = await this.input.logs.createWriteStream(stderrRef);
@@ -30,7 +46,13 @@ var NornCommandRunner = class {
         stderrStream: stderrLog.stream
       });
     } catch (error) {
-      await this.input.logger.record({ type: "command.failed", invocationId, label: commandInput.label, durationMs: Date.now() - startedAtMs, error: errorMessage(error) });
+      await this.input.logger.record({
+        type: "command.failed",
+        invocationId,
+        label: commandInput.label,
+        durationMs: Date.now() - startedAtMs,
+        error: errorMessage(error)
+      });
       throw error;
     }
     const commandResult = {
@@ -64,7 +86,11 @@ async function spawnCommand(input) {
   const stdout = new BoundedTextBuffer();
   const stderr = new BoundedTextBuffer();
   return new Promise((resolvePromise, reject) => {
-    const child = spawn(command, args, { cwd: input.cwd, env: input.env, shell: false });
+    const child = spawn(command, args, {
+      cwd: input.cwd,
+      env: input.env,
+      shell: false
+    });
     let timeout;
     let escalation;
     let isSettled = false;
@@ -77,24 +103,32 @@ async function spawnCommand(input) {
       if (isSettled) return;
       isSettled = true;
       cleanup();
-      void closeStreams(input.stdoutStream, input.stderrStream).then(() => resolvePromise(result), reject);
+      void closeStreams(input.stdoutStream, input.stderrStream).then(
+        () => resolvePromise(result),
+        reject
+      );
     };
     const fail = (error) => {
       if (isSettled) return;
       isSettled = true;
       cleanup();
-      void closeStreams(input.stdoutStream, input.stderrStream).then(() => reject(error), reject);
+      void closeStreams(input.stdoutStream, input.stderrStream).then(
+        () => reject(error),
+        reject
+      );
     };
     const killChild = () => {
       if (isSettled || killed) return;
       killed = true;
       child.kill("SIGTERM");
       escalation = setTimeout(() => {
-        if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+        if (child.exitCode === null && child.signalCode === null)
+          child.kill("SIGKILL");
       }, 5e3);
       escalation.unref?.();
     };
-    if (input.timeoutMs !== void 0) timeout = setTimeout(killChild, input.timeoutMs);
+    if (input.timeoutMs !== void 0)
+      timeout = setTimeout(killChild, input.timeoutMs);
     if (input.signal?.aborted) killChild();
     input.signal?.addEventListener("abort", killChild, { once: true });
     child.stdout?.on("data", (chunk) => {
@@ -108,11 +142,21 @@ async function spawnCommand(input) {
       input.stderrStream.write(text);
     });
     child.on("error", fail);
-    child.on("close", (code) => finish({ exitCode: code, stdoutTail: stdout.value(), stderrTail: stderr.value(), killed }));
+    child.on(
+      "close",
+      (code) => finish({
+        exitCode: code,
+        stdoutTail: stdout.value(),
+        stderrTail: stderr.value(),
+        killed
+      })
+    );
   });
 }
 function commandLog(input) {
-  return { id: `commands/${safeFileName(input.label)}-${input.invocationId}.${input.stream}` };
+  return {
+    id: `commands/${safeFileName(input.label)}-${input.invocationId}.${input.stream}`
+  };
 }
 var BoundedTextBuffer = class {
   constructor(maxChars = 128e3) {
@@ -122,17 +166,22 @@ var BoundedTextBuffer = class {
   text = "";
   append(value) {
     this.text += value;
-    if (this.text.length > this.maxChars) this.text = this.text.slice(this.text.length - this.maxChars);
+    if (this.text.length > this.maxChars)
+      this.text = this.text.slice(this.text.length - this.maxChars);
   }
   value() {
     return this.text;
   }
 };
 async function closeStreams(...streams) {
-  await Promise.all(streams.map((stream) => new Promise((resolvePromise, reject) => {
-    stream.on("error", reject);
-    stream.end(resolvePromise);
-  })));
+  await Promise.all(
+    streams.map(
+      (stream) => new Promise((resolvePromise, reject) => {
+        stream.on("error", reject);
+        stream.end(resolvePromise);
+      })
+    )
+  );
 }
 export {
   NornCommandRunner

package/dist/internal/documentation-bundle.js

@@ -7,33 +7,45 @@ var DOCUMENTATION_PATHS = {
   examples: "examples"
 };
 function validateDocumentationBundle(bundle) {
-  if (typeof bundle.version !== "string" || bundle.version.length === 0) throw new Error("Documentation bundle version must not be empty");
+  if (typeof bundle.version !== "string" || bundle.version.length === 0)
+    throw new Error("Documentation bundle version must not be empty");
   const paths = /* @__PURE__ */ new Set();
   for (const file of bundle.files) {
-    if (typeof file.content !== "string") throw new Error(`Documentation asset must contain text: ${file.path}`);
-    if (typeof file.path !== "string" || !/^[a-zA-Z0-9._/-]+$/.test(file.path) || file.path.split("/").some((part) => part === "" || part === "." || part === ".." || part.endsWith(".") || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(part))) {
+    if (typeof file.content !== "string")
+      throw new Error(`Documentation asset must contain text: ${file.path}`);
+    if (typeof file.path !== "string" || !/^[a-zA-Z0-9._/-]+$/.test(file.path) || file.path.split("/").some(
+      (part) => part === "" || part === "." || part === ".." || part.endsWith(".") || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(part)
+    )) {
       throw new Error(`Invalid documentation asset path: ${file.path}`);
     }
     const portablePath = file.path.toLowerCase();
-    if (paths.has(portablePath)) throw new Error(`Duplicate documentation asset path: ${file.path}`);
+    if (paths.has(portablePath))
+      throw new Error(`Duplicate documentation asset path: ${file.path}`);
     paths.add(portablePath);
   }
   for (const path of paths) {
     const parts = path.split("/");
     while (parts.pop() && parts.length > 0) {
-      if (paths.has(parts.join("/"))) throw new Error(`Documentation file/directory collision: ${path}`);
+      if (paths.has(parts.join("/")))
+        throw new Error(`Documentation file/directory collision: ${path}`);
     }
   }
   for (const path of [DOCUMENTATION_PATHS.readme, DOCUMENTATION_PATHS.index]) {
-    if (!bundle.files.some((file) => file.path === path)) throw new Error(`Missing documentation asset: ${path}`);
+    if (!bundle.files.some((file) => file.path === path))
+      throw new Error(`Missing documentation asset: ${path}`);
   }
-  if (!bundle.files.some((file) => file.path.startsWith("examples/"))) throw new Error("Missing documentation examples");
+  if (!bundle.files.some((file) => file.path.startsWith("examples/")))
+    throw new Error("Missing documentation examples");
 }
 function hashDocumentationBundle(bundle) {
-  return createHash("sha256").update(JSON.stringify({
-    version: bundle.version,
-    files: bundle.files.map((file) => ({ path: file.path, content: file.content })).sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0)
-  })).digest("hex");
+  return createHash("sha256").update(
+    JSON.stringify({
+      version: bundle.version,
+      files: bundle.files.map((file) => ({ path: file.path, content: file.content })).sort(
+        (left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0
+      )
+    })
+  ).digest("hex");
 }
 export {
   DOCUMENTATION_PATHS,