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

package/dist/internal/engine.js

@@ -6,14 +6,27 @@ import { dirname, join, resolve } from "node:path";
 import { Value } from "typebox/value";
 import { NornAgentResponseCollector } from "./agent-response-tool.js";
 import { errorMessage, NornRunStoppedError } from "./errors.js";
-import { clearRunResumeRequest, matchesRunResumeRequest, readOptionalRunResumeRequest, RESUME_START_GRACE_MS } from "./launch-request.js";
+import {
+  clearRunResumeRequest,
+  matchesRunResumeRequest,
+  readOptionalRunResumeRequest,
+  RESUME_START_GRACE_MS
+} from "./launch-request.js";
 import { NornRunLogs } from "./logs.js";
 import { NornRunLease } from "./run-lease.js";
 import { NornRunLogger } from "./run-log.js";
-import { assertRunVersion, getRunInfo, mergeInterruptedWorkflowArgs, NornRunStateStore, resolveRunRoot } from "./run-state.js";
+import {
+  assertRunVersion,
+  getRunInfo,
+  mergeInterruptedWorkflowArgs,
+  NornRunStateStore,
+  resolveRunRoot
+} from "./run-state.js";
 import { NornRunStore, runCurrentRoot } from "./run-store.js";
 import { NornExecutionContext } from "./execution-context.js";
-import { NornWorkflowRegistry } from "./workflow-registry.js";
+import {
+  NornWorkflowRegistry
+} from "./workflow-registry.js";
 var RUNS_DIR_NAME = ".norn";
 var MANIFEST_FILE_NAME = "manifest.json";
 var NornEngine = class {
@@ -28,7 +41,14 @@ var NornEngine = class {
   registerWorkflows(workflows) {
     const disposers = [];
     try {
-      for (const workflow of workflows) disposers.push(this.registry.register({ workflow, config: this.input.config ?? {}, source: void 0 }));
+      for (const workflow of workflows)
+        disposers.push(
+          this.registry.register({
+            workflow,
+            config: this.input.config ?? {},
+            source: void 0
+          })
+        );
     } catch (error) {
       for (const dispose of disposers.reverse()) dispose();
       throw error;
@@ -46,7 +66,8 @@ var NornEngine = class {
   async runWorkflow(workflow, args, options) {
     const session = await this.createRunSession(workflow, args, options);
     const current = session.state.currentState().current;
-    if (!current) throw new Error("New run is missing its initial workflow step");
+    if (!current)
+      throw new Error("New run is missing its initial workflow step");
     return this.runScheduler(session, toWorkflowStep(workflow, current));
   }
   async listRunCheckpoints(path) {
@@ -59,56 +80,98 @@ var NornEngine = class {
     const lease = await NornRunLease.acquire(runRoot);
     try {
       const pendingRequest = await readOptionalRunResumeRequest(runRoot);
-      if (pendingRequest && Date.now() - Date.parse(pendingRequest.createdAt) < RESUME_START_GRACE_MS) throw new Error(`Resume request is still pending: ${runRoot}`);
+      if (pendingRequest && Date.now() - Date.parse(pendingRequest.createdAt) < RESUME_START_GRACE_MS)
+        throw new Error(`Resume request is still pending: ${runRoot}`);
       const runStore = await NornRunStore.open(runRoot);
       await runStore.restoreSnapshot(checkpointId, async (stagedRunRoot) => {
         const state = await NornRunStateStore.load(stagedRunRoot);
         await state.prepareForResumeAfterRollback();
       });
-      if (pendingRequest) await clearRunResumeRequest({ runRoot, request: pendingRequest, lease });
+      if (pendingRequest)
+        await clearRunResumeRequest({
+          runRoot,
+          request: pendingRequest,
+          lease
+        });
       return getRunInfo(runRoot);
     } finally {
       await lease.release();
     }
   }
   async resumeWorkflow(path, args) {
-    return this.resumeWorkflowExecution({ path, args, expectedRequest: void 0 });
+    return this.resumeWorkflowExecution({
+      path,
+      args,
+      expectedRequest: void 0
+    });
   }
   async resumeRequestedWorkflow(input) {
-    return this.resumeWorkflowExecution({ path: input.runRoot, args: input.request.args, expectedRequest: input.request });
+    return this.resumeWorkflowExecution({
+      path: input.runRoot,
+      args: input.request.args,
+      expectedRequest: input.request
+    });
   }
   async resumeWorkflowExecution(input) {
     const { args, expectedRequest } = input;
     const runRoot = await resolveRunRoot(this.input.cwd, input.path);
     const initialStateStore = await NornRunStateStore.load(runRoot);
     const initialState = initialStateStore.currentState();
-    if (initialState.status === "interrupted" && args === void 0) throw new Error(`Interrupted workflow resume requires args: ${runRoot}`);
-    if (initialState.status === "pendingResume" && args !== void 0) throw new Error(`Pending-resume workflows do not accept args: ${runRoot}`);
-    if (initialState.status !== "interrupted" && initialState.status !== "pendingResume") throw new Error(`Run must be rolled back before resuming: ${runRoot}`);
+    if (initialState.status === "interrupted" && args === void 0)
+      throw new Error(`Interrupted workflow resume requires args: ${runRoot}`);
+    if (initialState.status === "pendingResume" && args !== void 0)
+      throw new Error(
+        `Pending-resume workflows do not accept args: ${runRoot}`
+      );
+    if (initialState.status !== "interrupted" && initialState.status !== "pendingResume")
+      throw new Error(`Run must be rolled back before resuming: ${runRoot}`);
     const lease = await NornRunLease.acquire(runRoot);
     let isLeaseOwnedByScheduler = false;
     let session;
     try {
       const pendingRequest = await readOptionalRunResumeRequest(runRoot);
-      if (expectedRequest ? !matchesRunResumeRequest(pendingRequest, expectedRequest) : pendingRequest !== void 0) throw new Error(`Resume request changed or belongs to another executor: ${runRoot}`);
+      if (expectedRequest ? !matchesRunResumeRequest(pendingRequest, expectedRequest) : pendingRequest !== void 0)
+        throw new Error(
+          `Resume request changed or belongs to another executor: ${runRoot}`
+        );
       session = await this.openRunSession(runRoot, lease);
       const state = session.state.currentState();
       const current = state.current;
       if (!current) throw new Error(`Run is not resumable: ${runRoot}`);
       const workflow = this.registry.workflowById(current.workflowId);
-      if (!workflow) throw new Error(`Unknown workflow for resumed run: ${current.workflowId}`);
+      if (!workflow)
+        throw new Error(
+          `Unknown workflow for resumed run: ${current.workflowId}`
+        );
       if (state.status === "interrupted") {
-        const rawArgs = mergeInterruptedWorkflowArgs(current.args, args, current.interruption?.fields);
+        const rawArgs = mergeInterruptedWorkflowArgs(
+          current.args,
+          args,
+          current.interruption?.fields
+        );
         Value.Decode(workflow.args, rawArgs);
         await session.state.replaceCurrentArgs(rawArgs);
-        await recordRunEvent(session, { type: "run.resumed", workflowId: workflow.id, cwd: session.cwd });
+        await recordRunEvent(session, {
+          type: "run.resumed",
+          workflowId: workflow.id,
+          cwd: session.cwd
+        });
         const resumedCurrent = session.state.currentState().current;
-        if (!resumedCurrent) throw new Error(`Run is not resumable: ${runRoot}`);
+        if (!resumedCurrent)
+          throw new Error(`Run is not resumable: ${runRoot}`);
         isLeaseOwnedByScheduler = true;
-        return this.runScheduler(session, toWorkflowStep(workflow, resumedCurrent));
+        return this.runScheduler(
+          session,
+          toWorkflowStep(workflow, resumedCurrent)
+        );
       }
-      if (state.status !== "pendingResume") throw new Error(`Run must be rolled back before resuming: ${runRoot}`);
-      await recordRunEvent(session, { type: "run.resumed", workflowId: workflow.id, cwd: session.cwd });
+      if (state.status !== "pendingResume")
+        throw new Error(`Run must be rolled back before resuming: ${runRoot}`);
+      await recordRunEvent(session, {
+        type: "run.resumed",
+        workflowId: workflow.id,
+        cwd: session.cwd
+      });
       isLeaseOwnedByScheduler = true;
       return this.runScheduler(session, toWorkflowStep(workflow, current));
     } finally {
@@ -127,42 +190,124 @@ var NornEngine = class {
       for (let step = 1; step <= 1e3; step++) {
         throwIfRunAborted(session.activeRun);
         if (shouldPauseForGate(currentStep)) {
-          const description = await this.registry.describeGate({ workflow: currentStep.workflow, execution: session.execution, paths: session.paths, args: currentStep.args, configOverride: session.state.currentState().configOverride });
-          const interruption = { description, fields: currentStep.workflow.gate?.fields };
+          const description = await this.registry.describeGate({
+            workflow: currentStep.workflow,
+            execution: session.execution,
+            paths: session.paths,
+            args: currentStep.args,
+            configOverride: session.state.currentState().configOverride
+          });
+          const interruption = {
+            description,
+            fields: currentStep.workflow.gate?.fields
+          };
           await session.state.interruptCurrent(currentStep.args, interruption);
-          await recordRunEvent(session, { type: "run.interrupted", workflowId: currentStep.workflow.id });
-          await commitRunBoundary(session, `run interrupted: ${currentStep.workflow.id}`);
-          return interruptedLaunchResult({ id: session.execution.run.id, name: session.state.currentState().name, workspace: session.paths.workspace, cwd: session.cwd }, currentStep.workflow, currentStep.args, interruption);
+          await recordRunEvent(session, {
+            type: "run.interrupted",
+            workflowId: currentStep.workflow.id
+          });
+          await commitRunBoundary(
+            session,
+            `run interrupted: ${currentStep.workflow.id}`
+          );
+          return interruptedLaunchResult(
+            {
+              id: session.execution.run.id,
+              name: session.state.currentState().name,
+              workspace: session.paths.workspace,
+              cwd: session.cwd
+            },
+            currentStep.workflow,
+            currentStep.args,
+            interruption
+          );
         }
         await session.state.startStep(toRunStateStep(currentStep));
         const stepResult = await this.executeWorkflowStep(session, currentStep);
         throwIfRunAborted(session.activeRun);
         if (stepResult.type === "complete") {
-          await session.state.completeRun(stepResult.workflow.id, stepResult.metadata);
-          await recordRunEvent(session, { type: "run.completed", workflowId: stepResult.workflow.id, metadata: stepResult.metadata });
-          await commitRunBoundary(session, `run completed: ${stepResult.workflow.id}`);
-          return { status: "completed", id: session.execution.run.id, name: session.state.currentState().name, workspace: session.paths.workspace, cwd: session.cwd, workflowId: stepResult.workflow.id, metadata: stepResult.metadata };
+          await session.state.completeRun(
+            stepResult.workflow.id,
+            stepResult.metadata
+          );
+          await recordRunEvent(session, {
+            type: "run.completed",
+            workflowId: stepResult.workflow.id,
+            metadata: stepResult.metadata
+          });
+          await commitRunBoundary(
+            session,
+            `run completed: ${stepResult.workflow.id}`
+          );
+          return {
+            status: "completed",
+            id: session.execution.run.id,
+            name: session.state.currentState().name,
+            workspace: session.paths.workspace,
+            cwd: session.cwd,
+            workflowId: stepResult.workflow.id,
+            metadata: stepResult.metadata
+          };
         }
         if (stepResult.type === "fail") {
-          await session.state.failRun(stepResult.workflow.id, stepResult.metadata);
-          await recordRunEvent(session, { type: "run.failed", workflowId: stepResult.workflow.id, metadata: stepResult.metadata });
-          return { status: "failed", id: session.execution.run.id, name: session.state.currentState().name, workspace: session.paths.workspace, cwd: session.cwd, workflowId: stepResult.workflow.id, metadata: stepResult.metadata };
+          await session.state.failRun(
+            stepResult.workflow.id,
+            stepResult.metadata
+          );
+          await recordRunEvent(session, {
+            type: "run.failed",
+            workflowId: stepResult.workflow.id,
+            metadata: stepResult.metadata
+          });
+          return {
+            status: "failed",
+            id: session.execution.run.id,
+            name: session.state.currentState().name,
+            workspace: session.paths.workspace,
+            cwd: session.cwd,
+            workflowId: stepResult.workflow.id,
+            metadata: stepResult.metadata
+          };
         }
         const nextStep = this.nextWorkflowStep(stepResult);
-        await session.state.completeWithNext(currentStep.workflow.id, toRunStateStep(nextStep));
-        await recordRunEvent(session, { type: "run.transitioned", fromWorkflowId: currentStep.workflow.id, toWorkflowId: nextStep.workflow.id });
-        await commitRunBoundary(session, `transition: ${currentStep.workflow.id} -> ${nextStep.workflow.id}`);
+        await session.state.completeWithNext(
+          currentStep.workflow.id,
+          toRunStateStep(nextStep)
+        );
+        await recordRunEvent(session, {
+          type: "run.transitioned",
+          fromWorkflowId: currentStep.workflow.id,
+          toWorkflowId: nextStep.workflow.id
+        });
+        await commitRunBoundary(
+          session,
+          `transition: ${currentStep.workflow.id} -> ${nextStep.workflow.id}`
+        );
         currentStep = nextStep;
       }
       throw new Error("Run exceeded 1000 scheduler steps");
     } catch (error) {
       if (isRunStopped(session, error)) {
         await session.state.stopCurrent();
-        await recordRunEvent(session, { type: "run.stopped", workflowId: currentStep.workflow.id });
-        return { status: "stopped", id: session.execution.run.id, name: session.state.currentState().name, workspace: session.paths.workspace, cwd: session.cwd, workflowId: currentStep.workflow.id };
+        await recordRunEvent(session, {
+          type: "run.stopped",
+          workflowId: currentStep.workflow.id
+        });
+        return {
+          status: "stopped",
+          id: session.execution.run.id,
+          name: session.state.currentState().name,
+          workspace: session.paths.workspace,
+          cwd: session.cwd,
+          workflowId: currentStep.workflow.id
+        };
       }
       await session.state.failCurrent(errorMessage(error));
-      await recordRunEvent(session, { type: "run.failed", workflowId: currentStep.workflow.id, error: errorMessage(error) });
+      await recordRunEvent(session, {
+        type: "run.failed",
+        workflowId: currentStep.workflow.id,
+        error: errorMessage(error)
+      });
       throw error;
     } finally {
       await session.lease.release();
@@ -173,13 +318,40 @@ var NornEngine = class {
     const startedAtMs = Date.now();
     try {
       await assertWorkspaceBoundary(session, session.paths.workspace);
-      await recordRunEvent(session, { type: "workflow.started", workflowId: step.workflow.id });
-      const result = await this.registry.execute({ workflow: step.workflow, execution: session.execution, paths: session.paths, args: step.args, configOverride: session.state.currentState().configOverride });
+      await recordRunEvent(session, {
+        type: "workflow.started",
+        workflowId: step.workflow.id
+      });
+      const result = await this.registry.execute({
+        workflow: step.workflow,
+        execution: session.execution,
+        paths: session.paths,
+        args: step.args,
+        configOverride: session.state.currentState().configOverride
+      });
       await assertWorkspaceBoundary(session, session.paths.workspace);
       const durationMs = Date.now() - startedAtMs;
-      if (result.type === "complete") await recordRunEvent(session, { type: "workflow.completed", workflowId: result.workflow.id, durationMs, metadata: result.metadata });
-      else if (result.type === "fail") await recordRunEvent(session, { type: "workflow.failed", workflowId: result.workflow.id, durationMs, metadata: result.metadata });
-      else await recordRunEvent(session, { type: "workflow.transitioned", fromWorkflowId: step.workflow.id, toWorkflowId: result.workflowId, durationMs });
+      if (result.type === "complete")
+        await recordRunEvent(session, {
+          type: "workflow.completed",
+          workflowId: result.workflow.id,
+          durationMs,
+          metadata: result.metadata
+        });
+      else if (result.type === "fail")
+        await recordRunEvent(session, {
+          type: "workflow.failed",
+          workflowId: result.workflow.id,
+          durationMs,
+          metadata: result.metadata
+        });
+      else
+        await recordRunEvent(session, {
+          type: "workflow.transitioned",
+          fromWorkflowId: step.workflow.id,
+          toWorkflowId: result.workflowId,
+          durationMs
+        });
       return result;
     } catch (error) {
       await recordRunEvent(session, {
@@ -206,7 +378,10 @@ var NornEngine = class {
     const runRoot = defaultRunRoot(this.input.cwd, id);
     const currentRoot = runCurrentRoot(runRoot);
     const workspace = join(currentRoot, "workspace");
-    const paths = { project: resolve(this.input.cwd), workspace };
+    const paths = {
+      project: resolve(this.input.cwd),
+      workspace
+    };
     const cwd = process.cwd();
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     await mkdir(runRoot, { recursive: true });
@@ -215,16 +390,26 @@ var NornEngine = class {
     try {
       const runStore = await NornRunStore.initialize(runRoot);
       await mkdir(workspace, { recursive: true });
-      const logger = new NornRunLogger({ manifestPath: join(currentRoot, MANIFEST_FILE_NAME), files: createRunFileCoordinator(runRoot), manifest: {
+      const logger = new NornRunLogger({
+        manifestPath: join(currentRoot, MANIFEST_FILE_NAME),
+        files: createRunFileCoordinator(runRoot),
+        manifest: {
+          id,
+          name,
+          workflowId: workflow.id,
+          runRoot,
+          workspace,
+          initialCwd: cwd,
+          startedAt
+        }
+      });
+      const execution = await this.buildExecutionContext({
         id,
-        name,
-        workflowId: workflow.id,
-        runRoot,
-        workspace,
-        initialCwd: cwd,
-        startedAt
-      } });
-      const execution = await this.buildExecutionContext({ id, currentRoot, paths, signal: activeRun.controller.signal, logger });
+        currentRoot,
+        paths,
+        signal: activeRun.controller.signal,
+        logger
+      });
       const state = await NornRunStateStore.create(runRoot, {
         projectRoot: paths.project,
         id,
@@ -241,8 +426,23 @@ var NornEngine = class {
         },
         startedAt
       });
-      const session = { runRoot, cwd, execution, paths, state, lease, runStore, logger, activeRun };
-      await logger.record({ type: "run.started", workflowId: workflow.id, cwd, workspace });
+      const session = {
+        runRoot,
+        cwd,
+        execution,
+        paths,
+        state,
+        lease,
+        runStore,
+        logger,
+        activeRun
+      };
+      await logger.record({
+        type: "run.started",
+        workflowId: workflow.id,
+        cwd,
+        workspace
+      });
       await commitRunBoundary(session, `run started: ${workflow.id}`);
       return session;
     } catch (error) {
@@ -256,13 +456,36 @@ var NornEngine = class {
     try {
       const state = await NornRunStateStore.load(runRoot);
       const currentState = state.currentState();
-      if (currentState.status === "completed") throw new Error(`Run is already completed: ${runRoot}`);
+      if (currentState.status === "completed")
+        throw new Error(`Run is already completed: ${runRoot}`);
       const runStore = await NornRunStore.open(runRoot);
       const currentRoot = runCurrentRoot(runRoot);
-      const logger = await NornRunLogger.load(join(currentRoot, MANIFEST_FILE_NAME), createRunFileCoordinator(runRoot));
-      const paths = { project: currentState.projectRoot ?? resolve(runRoot, "../../.."), workspace: currentState.workspace };
-      const execution = await this.buildExecutionContext({ id: currentState.id, currentRoot, paths, signal: activeRun.controller.signal, logger });
-      return { runRoot, cwd: process.cwd(), execution, paths, state, lease, runStore, logger, activeRun };
+      const logger = await NornRunLogger.load(
+        join(currentRoot, MANIFEST_FILE_NAME),
+        createRunFileCoordinator(runRoot)
+      );
+      const paths = {
+        project: currentState.projectRoot ?? resolve(runRoot, "../../.."),
+        workspace: currentState.workspace
+      };
+      const execution = await this.buildExecutionContext({
+        id: currentState.id,
+        currentRoot,
+        paths,
+        signal: activeRun.controller.signal,
+        logger
+      });
+      return {
+        runRoot,
+        cwd: process.cwd(),
+        execution,
+        paths,
+        state,
+        lease,
+        runStore,
+        logger,
+        activeRun
+      };
     } catch (error) {
       this.failActiveRun(runRoot, activeRun);
       throw error;
@@ -284,7 +507,8 @@ var NornEngine = class {
     });
   }
   startActiveRun(runRoot) {
-    if (this.activeRuns.has(runRoot)) throw new Error(`Run is already active in this engine: ${runRoot}`);
+    if (this.activeRuns.has(runRoot))
+      throw new Error(`Run is already active in this engine: ${runRoot}`);
     const controller = new AbortController();
     let finish;
     const finished = new Promise((resolvePromise) => {
@@ -292,7 +516,10 @@ var NornEngine = class {
     });
     const abortFromParent = () => controller.abort(this.input.signal?.reason);
     if (this.input.signal?.aborted) abortFromParent();
-    else this.input.signal?.addEventListener("abort", abortFromParent, { once: true });
+    else
+      this.input.signal?.addEventListener("abort", abortFromParent, {
+        once: true
+      });
     const activeRun = {
       controller,
       finished,
@@ -309,7 +536,8 @@ var NornEngine = class {
     activeRun.finish();
   }
   failActiveRun(runRoot, activeRun) {
-    if (this.activeRuns.get(runRoot) === activeRun) this.activeRuns.delete(runRoot);
+    if (this.activeRuns.get(runRoot) === activeRun)
+      this.activeRuns.delete(runRoot);
     activeRun.dispose();
     activeRun.finish();
   }
@@ -340,14 +568,19 @@ function throwIfRunAborted(activeRun) {
   if (!activeRun.controller.signal.aborted) return;
   const reason = activeRun.controller.signal.reason;
   if (reason instanceof Error) throw reason;
-  throw new Error(typeof reason === "string" && reason.length > 0 ? reason : "Run aborted");
+  throw new Error(
+    typeof reason === "string" && reason.length > 0 ? reason : "Run aborted"
+  );
 }
 function isRunStopped(session, error) {
   return error instanceof NornRunStoppedError || session.activeRun.controller.signal.reason instanceof NornRunStoppedError;
 }
 function interruptedLaunchResult(run, workflow, args, interruption) {
   if (!workflow.gate) throw new Error(`Workflow is not gated: ${workflow.id}`);
-  if (!interruption.description) throw new Error(`Interrupted workflow is missing description: ${workflow.id}`);
+  if (!interruption.description)
+    throw new Error(
+      `Interrupted workflow is missing description: ${workflow.id}`
+    );
   return {
     status: "interrupted",
     id: run.id,
@@ -355,7 +588,12 @@ function interruptedLaunchResult(run, workflow, args, interruption) {
     workspace: run.workspace,
     cwd: run.cwd,
     workflowId: workflow.id,
-    interruption: { workflowId: workflow.id, args, description: interruption.description, fields: interruption.fields }
+    interruption: {
+      workflowId: workflow.id,
+      args,
+      description: interruption.description,
+      fields: interruption.fields
+    }
   };
 }
 async function recordRunEvent(session, event) {

package/dist/internal/errors.js

@@ -8,8 +8,10 @@ var NornProjectLoadError = class extends Error {
     const details = input.diagnostics.map(
       (diagnostic) => `${diagnostic.stage}: ${diagnostic.modulePath} (declared in ${diagnostic.configPath}${diagnostic.workflowId ? `; workflow ${diagnostic.workflowId}` : ""}): ${diagnostic.message}`
     );
-    super(`Norn project is incomplete (${input.diagnostics.length} diagnostics); execution is blocked.
-${details.join("\n")}`);
+    super(
+      `Norn project is incomplete (${input.diagnostics.length} diagnostics); execution is blocked.
+${details.join("\n")}`
+    );
     this.name = "NornProjectLoadError";
     this.diagnostics = input.diagnostics;
   }

package/dist/internal/execution-context.js

@@ -1,6 +1,7 @@
 // ../core/src/workflow-transition.ts
 function createWorkflowTransition(input) {
-  if (typeof input.workflowId !== "string" || input.workflowId.trim().length === 0) throw new Error("Workflow transition requires a nonempty workflow ID");
+  if (typeof input.workflowId !== "string" || input.workflowId.trim().length === 0)
+    throw new Error("Workflow transition requires a nonempty workflow ID");
   return { type: "next", workflowId: input.workflowId, args: input.args };
 }