@vimhead.dev/norn-cli 0.1.0-tip.0

package/dist/internal/run-log.d.ts

@@ -0,0 +1,30 @@
+import type { NornFileCoordinator } from "@vimhead.dev/norn/files";
+export type NornRunManifestEvent = {
+    readonly at: string;
+    readonly type: string;
+    readonly [key: string]: unknown;
+};
+export type NornRunManifest = {
+    readonly id: string;
+    readonly name: string;
+    readonly workflowId: string;
+    readonly runRoot: string;
+    readonly workspace: string;
+    readonly initialCwd: string;
+    readonly startedAt: string;
+    readonly events: readonly NornRunManifestEvent[];
+};
+export declare class NornRunLogger {
+    private readonly input;
+    private isInitialized;
+    constructor(input: {
+        readonly manifestPath: string;
+        readonly manifest: Omit<NornRunManifest, "events">;
+        readonly files: NornFileCoordinator;
+    });
+    static load(manifestPath: string, files: NornFileCoordinator): Promise<NornRunLogger>;
+    record(event: {
+        readonly type: string;
+        readonly [key: string]: unknown;
+    }): Promise<void>;
+}

package/dist/internal/run-log.js

@@ -0,0 +1,71 @@
+// src/internal/run-log.ts
+import { readFile } from "node:fs/promises";
+
+// ../core/src/errors.ts
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// ../core/src/atomic-files.ts
+import { randomUUID } from "node:crypto";
+import { chmod, mkdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+async function writeJsonAtomically(path, value) {
+  await writeTextAtomically(path, `${JSON.stringify(value, null, 2)}
+`);
+}
+async function writeTextAtomically(path, content) {
+  await mkdir(dirname(path), { recursive: true });
+  let existingMode;
+  try {
+    existingMode = (await stat(path)).mode & 511;
+  } catch (error) {
+    if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+  }
+  const tmpPath = `${path}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(tmpPath, content, { encoding: "utf8", mode: existingMode });
+    if (existingMode !== void 0) await chmod(tmpPath, existingMode);
+    await rename(tmpPath, path);
+  } catch (error) {
+    await rm(tmpPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+
+// src/internal/run-log.ts
+var NornRunLogger = class _NornRunLogger {
+  constructor(input) {
+    this.input = input;
+  }
+  input;
+  isInitialized = false;
+  static async load(manifestPath, files) {
+    const manifest = parseManifest(await files.readText(manifestPath));
+    const logger = new _NornRunLogger({ manifestPath, manifest, files });
+    logger.isInitialized = true;
+    return logger;
+  }
+  async record(event) {
+    await this.input.files.withExclusiveLock(this.input.manifestPath, async (path) => {
+      let manifest;
+      try {
+        manifest = parseManifest(await readFile(path, "utf8"));
+      } catch (error) {
+        if (this.isInitialized || !isNodeError(error) || error.code !== "ENOENT") throw error;
+        manifest = { ...this.input.manifest, events: [] };
+      }
+      if (manifest.id !== this.input.manifest.id) throw new Error("Run manifest identity changed");
+      await writeJsonAtomically(path, { ...manifest, events: [...manifest.events, { ...event, at: (/* @__PURE__ */ new Date()).toISOString() }] });
+      this.isInitialized = true;
+    });
+  }
+};
+function parseManifest(content) {
+  const manifest = JSON.parse(content);
+  if (!manifest || typeof manifest !== "object" || typeof manifest.id !== "string" || !Array.isArray(manifest.events)) throw new Error("Invalid run manifest");
+  return manifest;
+}
+export {
+  NornRunLogger
+};

package/dist/internal/run-names.d.ts

@@ -0,0 +1 @@
+export declare function generateRunName(existingNames: ReadonlySet<string>): string;

package/dist/internal/run-names.js

@@ -0,0 +1,144 @@
+// src/internal/run-names.ts
+var ADJECTIVES = [
+  "able",
+  "amber",
+  "brave",
+  "bright",
+  "calm",
+  "clever",
+  "crisp",
+  "daring",
+  "eager",
+  "fair",
+  "fast",
+  "fresh",
+  "gentle",
+  "golden",
+  "grand",
+  "happy",
+  "honest",
+  "jolly",
+  "kind",
+  "lively",
+  "lucky",
+  "merry",
+  "nimble",
+  "noble",
+  "patient",
+  "peaceful",
+  "proud",
+  "quiet",
+  "rapid",
+  "ready",
+  "royal",
+  "sharp",
+  "silent",
+  "silver",
+  "simple",
+  "steady",
+  "sunny",
+  "swift",
+  "tidy",
+  "vivid"
+];
+var MODIFIERS = [
+  "anchor",
+  "autumn",
+  "brook",
+  "cedar",
+  "cloud",
+  "copper",
+  "dawn",
+  "ember",
+  "field",
+  "forest",
+  "harbor",
+  "hazel",
+  "hill",
+  "island",
+  "ivory",
+  "jade",
+  "lake",
+  "maple",
+  "meadow",
+  "moon",
+  "north",
+  "ocean",
+  "olive",
+  "pearl",
+  "pine",
+  "rain",
+  "river",
+  "rose",
+  "shadow",
+  "snow",
+  "solar",
+  "spring",
+  "stone",
+  "summer",
+  "thunder",
+  "timber",
+  "valley",
+  "violet",
+  "willow",
+  "winter"
+];
+var NOUNS = [
+  "badger",
+  "beacon",
+  "bison",
+  "canvas",
+  "comet",
+  "falcon",
+  "fjord",
+  "fox",
+  "garden",
+  "glade",
+  "grove",
+  "heron",
+  "lantern",
+  "lynx",
+  "marker",
+  "otter",
+  "panda",
+  "planet",
+  "prairie",
+  "raven",
+  "rocket",
+  "sail",
+  "signal",
+  "sparrow",
+  "summit",
+  "tiger",
+  "trail",
+  "voyage",
+  "whale",
+  "wolf",
+  "zephyr",
+  "orchid",
+  "bridge",
+  "castle",
+  "harvest",
+  "mirror",
+  "needle",
+  "quartz",
+  "ripple",
+  "signal"
+];
+function generateRunName(existingNames) {
+  for (let attempt = 0; attempt < 100; attempt++) {
+    const name = `${pick(ADJECTIVES)}-${pick(MODIFIERS)}-${pick(NOUNS)}`;
+    if (!existingNames.has(name)) return name;
+  }
+  while (true) {
+    const suffix = Math.random().toString(36).slice(2, 6);
+    const name = `${pick(ADJECTIVES)}-${pick(MODIFIERS)}-${pick(NOUNS)}-${suffix}`;
+    if (!existingNames.has(name)) return name;
+  }
+}
+function pick(values) {
+  return values[Math.floor(Math.random() * values.length)] ?? values[0];
+}
+export {
+  generateRunName
+};

package/dist/internal/run-resources.d.ts

@@ -0,0 +1,6 @@
+import { NornRunResources } from "../resources.ts";
+import { NornJsonWorkflowState } from "./state-store.ts";
+export declare function initializeRunResources(runRoot: string): Promise<{
+    readonly resources: NornRunResources;
+    readonly state: NornJsonWorkflowState;
+}>;

package/dist/internal/run-resources.js

@@ -0,0 +1,26 @@
+// src/internal/run-resources.ts
+import { join, resolve } from "node:path";
+import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+import { NornRunResources } from "../resources.js";
+import { NornJsonWorkflowState } from "./state-store.js";
+async function initializeRunResources(runRoot) {
+  const resources = await NornRunResources.initialize(runRoot);
+  const state = await resources.ensure({
+    name: "workflow-state",
+    kind: "norn.state",
+    configuration: { format: 1, path: "state.json" },
+    async initialize({ files, mode }) {
+      const state2 = new NornJsonWorkflowState({
+        stateFile: join(resolve(runRoot), "current", "state.json"),
+        files,
+        coordinateMutation: withFileMutationQueue
+      });
+      await state2.initialize(mode);
+      return state2;
+    }
+  });
+  return { resources, state };
+}
+export {
+  initializeRunResources
+};

package/dist/internal/run-state.d.ts

@@ -0,0 +1,95 @@
+import type { NornRunStatus, NornRunOutcomeMetadata, NornRunInfo } from "@vimhead.dev/norn";
+export declare const RUN_STATE_FILE_NAME = "run-state.json";
+export declare function mergeInterruptedWorkflowParams(currentParams: unknown, params: unknown, fields: readonly string[] | undefined): unknown;
+declare const RUN_STATE_VERSION = 1;
+type NornRunWorkflowStep = {
+    readonly workflowId: string;
+    readonly params: unknown;
+    readonly cwd: string;
+    readonly env: Record<string, string>;
+    readonly interruption?: RuntimeInterruption;
+};
+type RuntimeInterruption = {
+    readonly status: "pending" | "satisfied";
+    readonly description?: string;
+    readonly fields?: readonly string[];
+};
+type NornRunWorkflowCompletion = {
+    readonly workflowId: string;
+    readonly completedAt: string;
+    readonly outcome: {
+        readonly type: "next";
+        readonly workflowId: string;
+    } | {
+        readonly type: "complete";
+    } | {
+        readonly type: "fail";
+    };
+};
+type NornRunWorkflowFailure = {
+    readonly workflowId: string;
+    readonly error: string;
+    readonly metadata?: NornRunOutcomeMetadata;
+    readonly failedAt: string;
+};
+type NornRunWorkflowOutcome = {
+    readonly workflowId: string;
+    readonly completedAt: string;
+    readonly status: "completed" | "failed";
+    readonly metadata?: NornRunOutcomeMetadata;
+};
+export type NornRunState = {
+    readonly version: typeof RUN_STATE_VERSION;
+    readonly id: string;
+    readonly name: string;
+    readonly entrypointWorkflowId: string;
+    readonly workspace: string;
+    readonly configOverride?: unknown;
+    readonly status: NornRunStatus;
+    readonly current: NornRunWorkflowStep | null;
+    readonly lastCompleted: NornRunWorkflowCompletion | null;
+    readonly outcome: NornRunWorkflowOutcome | null;
+    readonly failed: NornRunWorkflowFailure | null;
+    readonly startedAt: string;
+    readonly updatedAt: string;
+};
+type CreateNornRunStateInput = {
+    readonly id: string;
+    readonly name: string;
+    readonly entrypointWorkflowId: string;
+    readonly workspace: string;
+    readonly configOverride?: unknown;
+    readonly current: NornRunWorkflowStep;
+    readonly startedAt: string;
+};
+export declare class NornRunStateStore {
+    private readonly path;
+    private state;
+    private readonly files;
+    private constructor();
+    static create(runRoot: string, input: CreateNornRunStateInput): Promise<NornRunStateStore>;
+    static load(runRoot: string): Promise<NornRunStateStore>;
+    currentState(): NornRunState;
+    startStep(step: NornRunWorkflowStep): Promise<void>;
+    completeWithNext(completedWorkflowId: string, next: NornRunWorkflowStep): Promise<void>;
+    completeRun(workflowId: string, metadata: NornRunOutcomeMetadata | undefined): Promise<void>;
+    failRun(workflowId: string, metadata: NornRunOutcomeMetadata & {
+        readonly summary: string;
+    }): Promise<void>;
+    interruptCurrent(params: unknown, interruption: {
+        readonly description: string;
+        readonly fields?: readonly string[];
+    }): Promise<void>;
+    prepareForResumeAfterRollback(): Promise<void>;
+    stopCurrent(): Promise<void>;
+    replaceCurrentParams(params: unknown): Promise<void>;
+    failCurrent(errorOrMetadata: string | NornRunOutcomeMetadata & {
+        readonly summary: string;
+    }): Promise<void>;
+    private update;
+    private write;
+}
+export declare function listRuns(sessionCwd: string): Promise<NornRunInfo[]>;
+export declare function getRunInfo(runRoot: string): Promise<NornRunInfo>;
+export declare function resolveRunRoot(sessionCwd: string, run: string): Promise<string>;
+export {};