@vimhead.dev/norn-cli 0.1.0-tip.35390859630.1 → 0.1.0-tip.35568631545.1

package/dist/internal/run.js

@@ -1,103 +0,0 @@
-// src/internal/run.ts
-import { isAbsolute, relative, resolve, sep } from "node:path";
-
-// ../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");
-  return { type: "next", workflowId: input.workflowId, args: input.args };
-}
-
-// src/internal/run.ts
-import { NornAgentRunner } from "./agents.js";
-import { NornCommandRunner } from "./commands.js";
-var NornRunContext = class _NornRunContext {
-  constructor(input) {
-    this.input = input;
-    this.id = input.id;
-    this.workspace = input.workspace;
-    this.projectRoot = input.projectRoot;
-    this.cwd = input.cwd;
-    this.resources = input.resources;
-    this.artifacts = input.artifacts;
-    this.logs = {
-      read: (log) => this.input.logs.read(log)
-    };
-    this.commands = {
-      run: (commandInput) => new NornCommandRunner({
-        boundaryRoot: this.boundaryRoot,
-        boundaryName: this.input.isolationMode,
-        cwd: this.cwd,
-        signal: this.input.signal,
-        logs: this.input.logs,
-        logger: this.input.logger
-      }).run(commandInput)
-    };
-    this.agents = {
-      createSession: (agentInput) => this.createAgentRunner().createSession(agentInput),
-      prompt: (agentInput) => this.createAgentRunner().prompt(agentInput)
-    };
-  }
-  input;
-  resources;
-  artifacts;
-  logs;
-  commands;
-  agents;
-  id;
-  workspace;
-  projectRoot;
-  cwd;
-  forWorkflow(workflow) {
-    const isolationMode = workflow.isolation.mode;
-    return new _NornRunContext({
-      ...this.input,
-      isolationMode,
-      cwd: isolationMode === "project" ? this.projectRoot : this.workspace
-    });
-  }
-  get boundaryRoot() {
-    return this.input.isolationMode === "project" ? this.projectRoot : this.workspace;
-  }
-  createAgentRunner() {
-    return new NornAgentRunner({
-      id: this.id,
-      runRoot: this.input.runRoot,
-      boundaryRoot: this.boundaryRoot,
-      boundaryName: this.input.isolationMode,
-      cwd: this.cwd,
-      signal: this.input.signal,
-      model: this.input.model,
-      thinkingLevel: this.input.thinkingLevel,
-      agentDir: this.input.agentDir,
-      logs: this.input.logs,
-      logger: this.input.logger,
-      responseCollector: this.input.responseCollector
-    });
-  }
-  path(relativePath) {
-    return this.resolveFromRoot(this.cwd, this.boundaryRoot, relativePath);
-  }
-  projectPath(relativePath) {
-    return this.resolveFromRoot(this.projectRoot, this.projectRoot, relativePath);
-  }
-  next(workflowId, args) {
-    return createWorkflowTransition({ workflowId, args });
-  }
-  complete(metadata) {
-    return { type: "complete", metadata };
-  }
-  fail(metadata) {
-    return { type: "fail", metadata };
-  }
-  resolveFromRoot(root, boundaryRoot, path) {
-    const resolvedPath = isAbsolute(path) ? path : resolve(root, path);
-    const pathFromBoundary = relative(boundaryRoot, resolvedPath);
-    if (pathFromBoundary === ".." || pathFromBoundary.startsWith(`..${sep}`) || isAbsolute(pathFromBoundary)) {
-      throw new Error(`Workflow path escapes ${this.input.isolationMode} isolation: ${path}`);
-    }
-    return resolvedPath;
-  }
-};
-export {
-  NornRunContext
-};

package/dist/resources.d.ts

@@ -1,11 +0,0 @@
-import type { NornResourceDefinition, NornResources } from "@vimhead.dev/norn";
-import { type NornFileCoordinator } from "@vimhead.dev/norn/files";
-export declare class NornRunResources implements NornResources {
-    private readonly runRoot;
-    readonly files: NornFileCoordinator;
-    private readonly entries;
-    private constructor();
-    static initialize(runRoot: string): Promise<NornRunResources>;
-    ensure<T>(definition: NornResourceDefinition<T>): Promise<T>;
-    private initializeResource;
-}

package/dist/resources.js

@@ -1,100 +0,0 @@
-// ../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";
-
-// ../core/src/errors.ts
-function isNodeError(error) {
-  return error instanceof Error && "code" in error;
-}
-
-// ../core/src/atomic-files.ts
-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/resources.ts
-import { createRunFileCoordinator } from "@vimhead.dev/norn/files";
-import { jsonValueSchema } from "@vimhead.dev/norn/schema";
-import { mkdir as mkdir2, readFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
-import { isDeepStrictEqual } from "node:util";
-import { Type } from "typebox";
-import { Value } from "typebox/value";
-var definitionSchema = Type.Object({ name: Type.String(), kind: Type.String({ minLength: 1 }), configuration: jsonValueSchema }, { additionalProperties: false });
-var recordSchema = Type.Object({ ...definitionSchema.properties, isInitialized: Type.Boolean() }, { additionalProperties: false });
-var NornRunResources = class _NornRunResources {
-  constructor(runRoot) {
-    this.runRoot = runRoot;
-    this.files = createRunFileCoordinator(runRoot);
-  }
-  runRoot;
-  files;
-  entries = /* @__PURE__ */ new Map();
-  static async initialize(runRoot) {
-    const resources = new _NornRunResources(resolve(runRoot));
-    await mkdir2(join(resources.runRoot, "current", "resources"), { recursive: true });
-    return resources;
-  }
-  async ensure(definition) {
-    if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(definition.name)) throw new Error(`Invalid resource name: ${definition.name}`);
-    const identity = structuredClone(Value.Parse(definitionSchema, { name: definition.name, kind: definition.kind, configuration: definition.configuration }));
-    const existing = this.entries.get(definition.name);
-    if (existing) {
-      if (!isDeepStrictEqual(existing.definition, identity)) throw new Error(`Incompatible resource definition: ${definition.name}`);
-      return existing.value;
-    }
-    const value = this.initializeResource(definition, identity);
-    const entry = { definition: identity, value };
-    this.entries.set(definition.name, entry);
-    try {
-      return await value;
-    } catch (error) {
-      if (this.entries.get(definition.name) === entry) this.entries.delete(definition.name);
-      throw error;
-    }
-  }
-  async initializeResource(definition, identity) {
-    const directory = join(this.runRoot, "current", "resources", definition.name);
-    await mkdir2(directory, { recursive: true });
-    return this.files.withExclusiveLock(join(directory, "definition.json"), async (path) => {
-      let stored;
-      try {
-        stored = Value.Parse(recordSchema, JSON.parse(await readFile(path, "utf8")));
-      } catch (error) {
-        if (!isNodeError(error) || error.code !== "ENOENT") throw error;
-      }
-      if (stored) {
-        const { isInitialized: _isInitialized, ...storedIdentity } = stored;
-        if (!isDeepStrictEqual(storedIdentity, identity)) throw new Error(`Incompatible resource definition: ${definition.name}`);
-      } else {
-        await writeJsonAtomically(path, { ...identity, isInitialized: false });
-      }
-      const value = await definition.initialize({ directory, files: this.files, mode: stored?.isInitialized ? "open" : "create" });
-      if (!stored?.isInitialized) await writeJsonAtomically(path, { ...identity, isInitialized: true });
-      return value;
-    });
-  }
-};
-export {
-  NornRunResources
-};