atomism 0.1.0

package/dist/register-XTRMSH7Y.js

@@ -0,0 +1,91 @@
+import {
+  isAtom,
+  loadAtomFromFile
+} from "./chunk-P6X7T4KA.js";
+import {
+  resolveAtomPath
+} from "./chunk-RS2IEGW3.js";
+import {
+  withErrorHandling
+} from "./chunk-GU2R4KLP.js";
+import {
+  fileExists,
+  getRegistryPath,
+  loadRegistry,
+  saveRegistry
+} from "./chunk-YKJO3ZFY.js";
+import "./chunk-PLQJM2KT.js";
+
+// src/commands/register.ts
+import { dirname } from "path";
+import { readFile } from "fs/promises";
+import { createHash } from "crypto";
+import { zodToJsonSchema } from "zod-to-json-schema";
+function zodToJson(schema) {
+  return zodToJsonSchema(schema, { target: "jsonSchema7" });
+}
+async function registerCommand(atomPath, options) {
+  const projectRoot = process.cwd();
+  const registryPath = getRegistryPath(projectRoot);
+  await withErrorHandling(options, async () => {
+    const absolutePath = resolveAtomPath(atomPath, projectRoot);
+    if (!await fileExists(absolutePath)) {
+      throw new Error(`Atom file not found: ${absolutePath}`);
+    }
+    const atom = await loadAtomFromFile(absolutePath);
+    const atomDir = dirname(absolutePath);
+    const testPath = resolveAtomPath(atom.tests.path, atomDir);
+    if (!await fileExists(testPath)) {
+      throw new Error(
+        `Test file not found: ${testPath}
+Suggestion: Create the test file or update tests.path in your atom definition.`
+      );
+    }
+    const registry = await loadRegistry(registryPath);
+    const existingAtom = registry.atoms[atom.name];
+    const wasRegistered = !!existingAtom;
+    const inputSchema = zodToJson(atom.input);
+    const outputSchema = zodToJson(atom.output);
+    const atomContent = await readFile(absolutePath, "utf-8");
+    const contentHash = createHash("sha256").update(atomContent).digest("hex");
+    registry.atoms[atom.name] = {
+      name: atom.name,
+      description: atom.description,
+      path: absolutePath,
+      idempotent: atom.idempotent,
+      tests: atom.tests,
+      agent: atom.agent,
+      skill: atom.skill,
+      registeredAt: existingAtom?.registeredAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      inputSchema,
+      outputSchema,
+      contentHash,
+      // Preserve graduation info on update
+      graduated: existingAtom?.graduated ?? false,
+      generatorPath: existingAtom?.generatorPath,
+      graduatedAt: existingAtom?.graduatedAt
+    };
+    await saveRegistry(registryPath, registry);
+    const result = {
+      success: true,
+      atomName: atom.name,
+      path: absolutePath,
+      updated: wasRegistered
+    };
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      if (wasRegistered) {
+        console.log(`\u2713 Updated atom: ${atom.name}`);
+      } else {
+        console.log(`\u2713 Registered atom: ${atom.name}`);
+      }
+      console.log(`  Path: ${absolutePath}`);
+    }
+  });
+}
+export {
+  isAtom,
+  registerCommand
+};
+//# sourceMappingURL=register-XTRMSH7Y.js.map

package/dist/register-XTRMSH7Y.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/register.ts"],"sourcesContent":["import { dirname } from 'node:path';\nimport { readFile } from 'node:fs/promises';\nimport { createHash } from 'node:crypto';\nimport { z } from 'zod';\nimport { zodToJsonSchema } from 'zod-to-json-schema';\nimport { fileExists, loadRegistry, saveRegistry, getRegistryPath } from '../storage/index.js';\nimport { loadAtomFromFile } from '../atom/loader.js';\nimport { withErrorHandling } from './helpers.js';\nimport { resolveAtomPath } from '../utils/paths.js';\n\nexport interface RegisterOptions {\n  json?: boolean;\n}\n\nexport interface RegisterResult {\n  success: boolean;\n  atomName: string;\n  path: string;\n  updated: boolean;\n}\n\n/**\n * Convert a Zod schema to JSON Schema for storage.\n * Note: Cast through 'any' for Zod 4 compatibility with zod-to-json-schema.\n */\nfunction zodToJson(schema: z.ZodType): Record<string, unknown> {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return zodToJsonSchema(schema as any, { target: 'jsonSchema7' }) as Record<string, unknown>;\n}\n\n// Re-export isAtom from canonical location for backwards compatibility\nexport { isAtom } from '../atom/define.js';\n\n/**\n * Register an atom file into the project registry.\n */\nexport async function registerCommand(\n  atomPath: string,\n  options: RegisterOptions\n): Promise<void> {\n  const projectRoot = process.cwd();\n  const registryPath = getRegistryPath(projectRoot);\n\n  await withErrorHandling(options, async () => {\n    // Resolve atom path\n    const absolutePath = resolveAtomPath(atomPath, projectRoot);\n\n    // Check if atom file exists\n    if (!(await fileExists(absolutePath))) {\n      throw new Error(`Atom file not found: ${absolutePath}`);\n    }\n\n    // Load the atom from the file\n    const atom = await loadAtomFromFile(absolutePath);\n\n    // Validate test manifest - check if test file exists\n    const atomDir = dirname(absolutePath);\n    const testPath = resolveAtomPath(atom.tests.path, atomDir);\n\n    if (!(await fileExists(testPath))) {\n      throw new Error(\n        `Test file not found: ${testPath}\\n` +\n        `Suggestion: Create the test file or update tests.path in your atom definition.`\n      );\n    }\n\n    // Load registry\n    const registry = await loadRegistry(registryPath);\n\n    // Check if already registered\n    const existingAtom = registry.atoms[atom.name];\n    const wasRegistered = !!existingAtom;\n\n    // Convert Zod schemas to JSON Schema for storage\n    const inputSchema = zodToJson(atom.input);\n    const outputSchema = zodToJson(atom.output);\n\n    // Compute content hash of atom file for integrity verification\n    const atomContent = await readFile(absolutePath, 'utf-8');\n    const contentHash = createHash('sha256').update(atomContent).digest('hex');\n\n    // Add/update atom in registry (preserve graduation info if updating)\n    registry.atoms[atom.name] = {\n      name: atom.name,\n      description: atom.description,\n      path: absolutePath,\n      idempotent: atom.idempotent,\n      tests: atom.tests,\n      agent: atom.agent,\n      skill: atom.skill,\n      registeredAt: existingAtom?.registeredAt ?? new Date().toISOString(),\n      inputSchema,\n      outputSchema,\n      contentHash,\n      // Preserve graduation info on update\n      graduated: existingAtom?.graduated ?? false,\n      generatorPath: existingAtom?.generatorPath,\n      graduatedAt: existingAtom?.graduatedAt,\n    };\n\n    // Save registry\n    await saveRegistry(registryPath, registry);\n\n    // Output result\n    const result: RegisterResult = {\n      success: true,\n      atomName: atom.name,\n      path: absolutePath,\n      updated: wasRegistered,\n    };\n\n    if (options.json) {\n      console.log(JSON.stringify(result, null, 2));\n    } else {\n      if (wasRegistered) {\n        console.log(`✓ Updated atom: ${atom.name}`);\n      } else {\n        console.log(`✓ Registered atom: ${atom.name}`);\n      }\n      console.log(`  Path: ${absolutePath}`);\n    }\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA,SAAS,eAAe;AACxB,SAAS,gBAAgB;AACzB,SAAS,kBAAkB;AAE3B,SAAS,uBAAuB;AAqBhC,SAAS,UAAU,QAA4C;AAE7D,SAAO,gBAAgB,QAAe,EAAE,QAAQ,cAAc,CAAC;AACjE;AAQA,eAAsB,gBACpB,UACA,SACe;AACf,QAAM,cAAc,QAAQ,IAAI;AAChC,QAAM,eAAe,gBAAgB,WAAW;AAEhD,QAAM,kBAAkB,SAAS,YAAY;AAE3C,UAAM,eAAe,gBAAgB,UAAU,WAAW;AAG1D,QAAI,CAAE,MAAM,WAAW,YAAY,GAAI;AACrC,YAAM,IAAI,MAAM,wBAAwB,YAAY,EAAE;AAAA,IACxD;AAGA,UAAM,OAAO,MAAM,iBAAiB,YAAY;AAGhD,UAAM,UAAU,QAAQ,YAAY;AACpC,UAAM,WAAW,gBAAgB,KAAK,MAAM,MAAM,OAAO;AAEzD,QAAI,CAAE,MAAM,WAAW,QAAQ,GAAI;AACjC,YAAM,IAAI;AAAA,QACR,wBAAwB,QAAQ;AAAA;AAAA,MAElC;AAAA,IACF;AAGA,UAAM,WAAW,MAAM,aAAa,YAAY;AAGhD,UAAM,eAAe,SAAS,MAAM,KAAK,IAAI;AAC7C,UAAM,gBAAgB,CAAC,CAAC;AAGxB,UAAM,cAAc,UAAU,KAAK,KAAK;AACxC,UAAM,eAAe,UAAU,KAAK,MAAM;AAG1C,UAAM,cAAc,MAAM,SAAS,cAAc,OAAO;AACxD,UAAM,cAAc,WAAW,QAAQ,EAAE,OAAO,WAAW,EAAE,OAAO,KAAK;AAGzE,aAAS,MAAM,KAAK,IAAI,IAAI;AAAA,MAC1B,MAAM,KAAK;AAAA,MACX,aAAa,KAAK;AAAA,MAClB,MAAM;AAAA,MACN,YAAY,KAAK;AAAA,MACjB,OAAO,KAAK;AAAA,MACZ,OAAO,KAAK;AAAA,MACZ,OAAO,KAAK;AAAA,MACZ,cAAc,cAAc,iBAAgB,oBAAI,KAAK,GAAE,YAAY;AAAA,MACnE;AAAA,MACA;AAAA,MACA;AAAA;AAAA,MAEA,WAAW,cAAc,aAAa;AAAA,MACtC,eAAe,cAAc;AAAA,MAC7B,aAAa,cAAc;AAAA,IAC7B;AAGA,UAAM,aAAa,cAAc,QAAQ;AAGzC,UAAM,SAAyB;AAAA,MAC7B,SAAS;AAAA,MACT,UAAU,KAAK;AAAA,MACf,MAAM;AAAA,MACN,SAAS;AAAA,IACX;AAEA,QAAI,QAAQ,MAAM;AAChB,cAAQ,IAAI,KAAK,UAAU,QAAQ,MAAM,CAAC,CAAC;AAAA,IAC7C,OAAO;AACL,UAAI,eAAe;AACjB,gBAAQ,IAAI,wBAAmB,KAAK,IAAI,EAAE;AAAA,MAC5C,OAAO;AACL,gBAAQ,IAAI,2BAAsB,KAAK,IAAI,EAAE;AAAA,MAC/C;AACA,cAAQ,IAAI,WAAW,YAAY,EAAE;AAAA,IACvC;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/revert-J4CRDE2K.js

@@ -0,0 +1,87 @@
+import {
+  withErrorHandling
+} from "./chunk-GU2R4KLP.js";
+import {
+  getRegistryPath,
+  loadRegistry,
+  revertAtom,
+  saveRegistry
+} from "./chunk-YKJO3ZFY.js";
+import "./chunk-PLQJM2KT.js";
+
+// src/commands/revert.ts
+async function revertCommand(options) {
+  const projectRoot = process.cwd();
+  const registryPath = getRegistryPath(projectRoot);
+  await withErrorHandling(options, async () => {
+    if (!/^[a-z][a-z0-9_]*$/.test(options.atom)) {
+      throw new Error(
+        `Invalid atom name: ${options.atom}
+Atom names must be snake_case`
+      );
+    }
+    const registry = await loadRegistry(registryPath);
+    const atom = registry.atoms[options.atom];
+    if (!atom) {
+      const availableAtoms = Object.keys(registry.atoms);
+      if (availableAtoms.length === 0) {
+        throw new Error(
+          `Atom '${options.atom}' not found. No atoms are registered.
+Register an atom with: atomic register`
+        );
+      }
+      throw new Error(
+        `Atom '${options.atom}' not found.
+Available atoms: ${availableAtoms.join(", ")}`
+      );
+    }
+    if (!atom.graduated) {
+      throw new Error(
+        `Atom '${options.atom}' is not graduated.
+Only graduated atoms can be reverted.`
+      );
+    }
+    if (!options.json) {
+      console.log(`
+Reverting atom: ${options.atom}`);
+      console.log(`\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+      console.log(`Generator: ${atom.generatorPath}`);
+      console.log(`Reverting to: handler-based execution`);
+      if (options.reason) {
+        console.log(`Reason: ${options.reason}`);
+      }
+      console.log("");
+      console.log("Note: Generator file will be preserved (not deleted).");
+      console.log("");
+      if (!options.yes) {
+        console.log("Use --yes to confirm reversion.");
+        console.log("");
+        return;
+      }
+    }
+    registry.atoms[options.atom] = revertAtom(atom);
+    await saveRegistry(registryPath, registry);
+    const result = {
+      success: true,
+      atom: options.atom,
+      reason: options.reason
+    };
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(`\u2713 Atom '${options.atom}' reverted to handler`);
+      console.log(`  Path: ${atom.path}`);
+      if (options.reason) {
+        console.log(`  Reason: ${options.reason}`);
+      }
+      console.log("");
+      console.log("Next steps:");
+      console.log("  1. Test the atom with: atomic run " + options.atom);
+      console.log("  2. Re-graduate later with: atomic graduate " + options.atom);
+    }
+  });
+}
+export {
+  revertCommand
+};
+//# sourceMappingURL=revert-J4CRDE2K.js.map

package/dist/revert-J4CRDE2K.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/revert.ts"],"sourcesContent":["/**\n * Revert command for the atomic CLI.\n *\n * This module implements the `atomic revert` command which reverts\n * an atom from generator-based (deterministic) back to handler-based\n * (probabilistic) execution.\n *\n * @module revert\n */\n\nimport { loadRegistry, saveRegistry, getRegistryPath } from '../storage/index.js';\nimport { revertAtom } from '../schemas/registry.js';\nimport { withErrorHandling } from './helpers.js';\n\n/**\n * Options for the revert command.\n */\nexport interface RevertOptions {\n  atom: string;\n  reason?: string;\n  json?: boolean;\n  yes?: boolean;\n}\n\n/**\n * Result of reversion.\n */\nexport interface RevertResult {\n  success: boolean;\n  atom: string;\n  reason?: string;\n  error?: string;\n}\n\n/**\n * Revert an atom from generator back to handler.\n *\n * @param options - Command options\n */\nexport async function revertCommand(options: RevertOptions): Promise<void> {\n  const projectRoot = process.cwd();\n  const registryPath = getRegistryPath(projectRoot);\n\n  await withErrorHandling(options, async () => {\n    // Validate atom name\n    if (!/^[a-z][a-z0-9_]*$/.test(options.atom)) {\n      throw new Error(\n        `Invalid atom name: ${options.atom}\\n` +\n          'Atom names must be snake_case'\n      );\n    }\n\n    // Load registry\n    const registry = await loadRegistry(registryPath);\n\n    // Check if atom exists\n    const atom = registry.atoms[options.atom];\n    if (!atom) {\n      const availableAtoms = Object.keys(registry.atoms);\n      if (availableAtoms.length === 0) {\n        throw new Error(\n          `Atom '${options.atom}' not found. No atoms are registered.\\n` +\n            'Register an atom with: atomic register'\n        );\n      }\n      throw new Error(\n        `Atom '${options.atom}' not found.\\n` +\n          `Available atoms: ${availableAtoms.join(', ')}`\n      );\n    }\n\n    // Check if it's graduated\n    if (!atom.graduated) {\n      throw new Error(\n        `Atom '${options.atom}' is not graduated.\\n` +\n          'Only graduated atoms can be reverted.'\n      );\n    }\n\n    // Show what we're about to do\n    if (!options.json) {\n      console.log(`\\nReverting atom: ${options.atom}`);\n      console.log(`─────────────────────────────────────────────`);\n      console.log(`Generator: ${atom.generatorPath}`);\n      console.log(`Reverting to: handler-based execution`);\n      if (options.reason) {\n        console.log(`Reason: ${options.reason}`);\n      }\n      console.log('');\n      console.log('Note: Generator file will be preserved (not deleted).');\n      console.log('');\n\n      if (!options.yes) {\n        console.log('Use --yes to confirm reversion.');\n        console.log('');\n        return;\n      }\n    }\n\n    // Revert the atom\n    registry.atoms[options.atom] = revertAtom(atom);\n\n    // Save the registry\n    await saveRegistry(registryPath, registry);\n\n    const result: RevertResult = {\n      success: true,\n      atom: options.atom,\n      reason: options.reason,\n    };\n\n    if (options.json) {\n      console.log(JSON.stringify(result, null, 2));\n    } else {\n      console.log(`✓ Atom '${options.atom}' reverted to handler`);\n      console.log(`  Path: ${atom.path}`);\n      if (options.reason) {\n        console.log(`  Reason: ${options.reason}`);\n      }\n      console.log('');\n      console.log('Next steps:');\n      console.log('  1. Test the atom with: atomic run ' + options.atom);\n      console.log('  2. Re-graduate later with: atomic graduate ' + options.atom);\n    }\n  });\n}\n"],"mappings":";;;;;;;;;;;;AAuCA,eAAsB,cAAc,SAAuC;AACzE,QAAM,cAAc,QAAQ,IAAI;AAChC,QAAM,eAAe,gBAAgB,WAAW;AAEhD,QAAM,kBAAkB,SAAS,YAAY;AAE3C,QAAI,CAAC,oBAAoB,KAAK,QAAQ,IAAI,GAAG;AAC3C,YAAM,IAAI;AAAA,QACR,sBAAsB,QAAQ,IAAI;AAAA;AAAA,MAEpC;AAAA,IACF;AAGA,UAAM,WAAW,MAAM,aAAa,YAAY;AAGhD,UAAM,OAAO,SAAS,MAAM,QAAQ,IAAI;AACxC,QAAI,CAAC,MAAM;AACT,YAAM,iBAAiB,OAAO,KAAK,SAAS,KAAK;AACjD,UAAI,eAAe,WAAW,GAAG;AAC/B,cAAM,IAAI;AAAA,UACR,SAAS,QAAQ,IAAI;AAAA;AAAA,QAEvB;AAAA,MACF;AACA,YAAM,IAAI;AAAA,QACR,SAAS,QAAQ,IAAI;AAAA,mBACC,eAAe,KAAK,IAAI,CAAC;AAAA,MACjD;AAAA,IACF;AAGA,QAAI,CAAC,KAAK,WAAW;AACnB,YAAM,IAAI;AAAA,QACR,SAAS,QAAQ,IAAI;AAAA;AAAA,MAEvB;AAAA,IACF;AAGA,QAAI,CAAC,QAAQ,MAAM;AACjB,cAAQ,IAAI;AAAA,kBAAqB,QAAQ,IAAI,EAAE;AAC/C,cAAQ,IAAI,gRAA+C;AAC3D,cAAQ,IAAI,cAAc,KAAK,aAAa,EAAE;AAC9C,cAAQ,IAAI,uCAAuC;AACnD,UAAI,QAAQ,QAAQ;AAClB,gBAAQ,IAAI,WAAW,QAAQ,MAAM,EAAE;AAAA,MACzC;AACA,cAAQ,IAAI,EAAE;AACd,cAAQ,IAAI,uDAAuD;AACnE,cAAQ,IAAI,EAAE;AAEd,UAAI,CAAC,QAAQ,KAAK;AAChB,gBAAQ,IAAI,iCAAiC;AAC7C,gBAAQ,IAAI,EAAE;AACd;AAAA,MACF;AAAA,IACF;AAGA,aAAS,MAAM,QAAQ,IAAI,IAAI,WAAW,IAAI;AAG9C,UAAM,aAAa,cAAc,QAAQ;AAEzC,UAAM,SAAuB;AAAA,MAC3B,SAAS;AAAA,MACT,MAAM,QAAQ;AAAA,MACd,QAAQ,QAAQ;AAAA,IAClB;AAEA,QAAI,QAAQ,MAAM;AAChB,cAAQ,IAAI,KAAK,UAAU,QAAQ,MAAM,CAAC,CAAC;AAAA,IAC7C,OAAO;AACL,cAAQ,IAAI,gBAAW,QAAQ,IAAI,uBAAuB;AAC1D,cAAQ,IAAI,WAAW,KAAK,IAAI,EAAE;AAClC,UAAI,QAAQ,QAAQ;AAClB,gBAAQ,IAAI,aAAa,QAAQ,MAAM,EAAE;AAAA,MAC3C;AACA,cAAQ,IAAI,EAAE;AACd,cAAQ,IAAI,aAAa;AACzB,cAAQ,IAAI,yCAAyC,QAAQ,IAAI;AACjE,cAAQ,IAAI,kDAAkD,QAAQ,IAAI;AAAA,IAC5E;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/run-3GI3SBYL.js

@@ -0,0 +1,188 @@
+import {
+  executeAtom,
+  getAtomSkillNames
+} from "./chunk-P33CQFMY.js";
+import "./chunk-P6X7T4KA.js";
+import {
+  resolveAtomPath
+} from "./chunk-RS2IEGW3.js";
+import {
+  getRegistryPath,
+  loadRegistry
+} from "./chunk-YKJO3ZFY.js";
+import {
+  formatLoadedSkills,
+  loadSkillsForAtom
+} from "./chunk-55AP34JO.js";
+import "./chunk-6MDHM2B4.js";
+import "./chunk-UVUDQ4XP.js";
+import {
+  fmt,
+  formatAtomError,
+  formatFailure,
+  formatSuccess
+} from "./chunk-S6Z5G5DB.js";
+import {
+  toErrorMessage
+} from "./chunk-PLQJM2KT.js";
+
+// src/commands/run.ts
+import { readFile } from "fs/promises";
+import { createHash } from "crypto";
+async function runCommand(target, options) {
+  const projectRoot = process.cwd();
+  const registryPath = getRegistryPath(projectRoot);
+  const startTime = Date.now();
+  try {
+    const registry = await loadRegistry(registryPath);
+    let inputData = {};
+    if (options.input !== void 0) {
+      try {
+        inputData = JSON.parse(options.input);
+      } catch {
+        throw new Error(
+          `Invalid JSON input: ${options.input}
+Provide valid JSON, e.g., --input '{"key": "value"}'`
+        );
+      }
+    }
+    const atomEntry = registry.atoms[target];
+    if (!atomEntry) {
+      const availableAtoms = Object.keys(registry.atoms);
+      if (availableAtoms.length === 0) {
+        throw new Error(
+          `Atom '${target}' not found. No atoms are registered.
+Register an atom with: atomic register <path>`
+        );
+      }
+      throw new Error(
+        `Atom '${target}' not found.
+Available atoms: ${availableAtoms.join(", ")}`
+      );
+    }
+    if (atomEntry.contentHash) {
+      const atomFilePath = resolveAtomPath(atomEntry.path, projectRoot);
+      try {
+        const currentContent = await readFile(atomFilePath, "utf-8");
+        const currentHash = createHash("sha256").update(currentContent).digest("hex");
+        if (currentHash !== atomEntry.contentHash) {
+          console.warn(
+            `Warning: Atom '${target}' has been modified since registration.
+  Re-register with: atomic register ${atomEntry.path}`
+          );
+        }
+      } catch {
+      }
+    }
+    if (options.cache && !atomEntry.idempotent) {
+      throw new Error(
+        `Cannot use --cache with non-idempotent atom '${target}'.
+Only idempotent atoms can be cached.`
+      );
+    }
+    if (!atomEntry.graduated && !atomEntry.idempotent && !options.yes) {
+      throw new Error(
+        `Atom '${target}' is not idempotent.
+Re-running may have side effects. Use --yes to confirm execution.`
+      );
+    }
+    let preloadedSkillResult;
+    if (!atomEntry.graduated) {
+      const skillNames = getAtomSkillNames(atomEntry);
+      preloadedSkillResult = await loadSkillsForAtom(skillNames);
+      if (!options.json) {
+        for (const line of formatLoadedSkills(preloadedSkillResult)) {
+          console.log(line);
+        }
+      }
+    }
+    const skillLoader = preloadedSkillResult ? async () => preloadedSkillResult : void 0;
+    const execResult = await executeAtom(
+      target,
+      inputData,
+      projectRoot,
+      skillLoader
+    );
+    const duration = Date.now() - startTime;
+    formatAndOutputResult(execResult, target, inputData, duration, options, atomEntry.graduated);
+  } catch (err) {
+    const duration = Date.now() - startTime;
+    outputCatchError(err, target, options, duration);
+  }
+}
+function formatAndOutputResult(execResult, target, inputData, duration, options, graduated) {
+  const runResult = {
+    success: execResult.success,
+    atomName: execResult.atomName,
+    input: inputData,
+    duration
+  };
+  if (execResult.success) {
+    runResult.output = execResult.output;
+  } else {
+    runResult.error = {
+      type: "execution",
+      message: execResult.error || "Unknown error",
+      recoverable: false
+    };
+  }
+  if (options.json) {
+    console.log(JSON.stringify(runResult, null, 2));
+    if (!execResult.success) {
+      process.exit(1);
+    }
+    return;
+  }
+  const displayName = graduated ? `${target} (generator)` : execResult.atomName;
+  if (execResult.success) {
+    console.log(formatSuccess(displayName, duration));
+    if (execResult.output != null) {
+      console.log(`  ${fmt.gray("Output:")}`);
+      const outputStr = typeof execResult.output === "string" ? execResult.output : JSON.stringify(execResult.output, null, 2);
+      console.log(outputStr.split("\n").map((l) => `    ${l}`).join("\n"));
+    }
+  } else {
+    console.error(formatFailure(displayName));
+    console.error(formatAtomError({
+      type: "execution",
+      message: execResult.error || "Execution failed",
+      recoverable: false
+    }));
+    process.exit(1);
+  }
+}
+function outputCatchError(err, target, options, duration) {
+  if (options.json) {
+    let parsedInput = {};
+    try {
+      parsedInput = options.input ? JSON.parse(options.input) : {};
+    } catch {
+      parsedInput = options.input ?? {};
+    }
+    console.log(
+      JSON.stringify({
+        success: false,
+        atomName: target,
+        input: parsedInput,
+        error: {
+          type: "execution",
+          message: toErrorMessage(err),
+          recoverable: false
+        },
+        duration
+      })
+    );
+    process.exit(1);
+  } else {
+    console.error(formatAtomError({
+      type: "execution",
+      message: toErrorMessage(err),
+      recoverable: false
+    }));
+    process.exit(1);
+  }
+}
+export {
+  runCommand
+};
+//# sourceMappingURL=run-3GI3SBYL.js.map

package/dist/run-3GI3SBYL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/run.ts"],"sourcesContent":["/**\n * Run command implementation for the atomic CLI.\n *\n * This is a thin CLI wrapper around `executeAtom()` from `atom/execute.ts`.\n * It adds CLI-only concerns:\n * - Content-hash verification (drift detection)\n * - Non-idempotent confirmation gating (--yes flag)\n * - Skill loading progress output\n * - Human-readable and JSON output formatting\n *\n * All core execution logic (loading atoms/generators, input/output validation,\n * handler/generator execution, run recording) is delegated to `executeAtom()`.\n *\n * @module run\n */\n\nimport { readFile } from 'node:fs/promises';\nimport { createHash } from 'node:crypto';\nimport { loadRegistry, getRegistryPath } from '../storage/index.js';\nimport { formatAtomError, formatSuccess, formatFailure, fmt } from '../cli/format.js';\nimport { executeAtom, getAtomSkillNames, type AtomExecutionResult } from '../atom/execute.js';\nimport { loadSkillsForAtom, formatLoadedSkills } from './skills-load.js';\nimport type { SkillLoadResult } from '../atom/skills-load.js';\nimport { toErrorMessage } from '../utils/errors.js';\nimport { resolveAtomPath } from '../utils/paths.js';\n\n/**\n * Options for the run command.\n */\nexport interface RunOptions {\n  json?: boolean;\n  input?: string;\n  cache?: boolean;\n  yes?: boolean;\n}\n\n\n/**\n * Result of running an atom or capability.\n */\nexport interface RunResult<T = unknown> {\n  success: boolean;\n  atomName: string;\n  input: unknown;\n  output?: T;\n  error?: {\n    type: string;\n    message: string;\n    recoverable: boolean;\n    suggestion?: string;\n  };\n  duration: number;\n}\n\n/**\n * Execute an atom by name.\n *\n * This is the CLI entry point. It performs CLI-only pre-flight checks\n * (content hash verification, idempotency gating, cache validation),\n * then delegates actual execution to `executeAtom()`, and formats the\n * result for human or JSON output.\n *\n * @param target - Atom name to execute\n * @param options - Command options including input, output format, etc.\n */\nexport async function runCommand(\n  target: string,\n  options: RunOptions\n): Promise<void> {\n  const projectRoot = process.cwd();\n  const registryPath = getRegistryPath(projectRoot);\n  const startTime = Date.now();\n\n  try {\n    // Load registry (also validates storage is initialized)\n    const registry = await loadRegistry(registryPath);\n\n    // Parse input JSON (CLI concern — executeAtom receives parsed data)\n    let inputData: unknown = {};\n    if (options.input !== undefined) {\n      try {\n        inputData = JSON.parse(options.input);\n      } catch {\n        throw new Error(\n          `Invalid JSON input: ${options.input}\\n` +\n          `Provide valid JSON, e.g., --input '{\"key\": \"value\"}'`\n        );\n      }\n    }\n\n    // Look up atom (CLI provides detailed error with available atoms list)\n    const atomEntry = registry.atoms[target];\n    if (!atomEntry) {\n      const availableAtoms = Object.keys(registry.atoms);\n      if (availableAtoms.length === 0) {\n        throw new Error(\n          `Atom '${target}' not found. No atoms are registered.\\n` +\n          `Register an atom with: atomic register <path>`\n        );\n      }\n      throw new Error(\n        `Atom '${target}' not found.\\n` +\n        `Available atoms: ${availableAtoms.join(', ')}`\n      );\n    }\n\n    // CLI-only: Verify atom file integrity via content hash (drift detection)\n    if (atomEntry.contentHash) {\n      const atomFilePath = resolveAtomPath(atomEntry.path, projectRoot);\n      try {\n        const currentContent = await readFile(atomFilePath, 'utf-8');\n        const currentHash = createHash('sha256').update(currentContent).digest('hex');\n        if (currentHash !== atomEntry.contentHash) {\n          console.warn(\n            `Warning: Atom '${target}' has been modified since registration.\\n` +\n            `  Re-register with: atomic register ${atomEntry.path}`\n          );\n        }\n      } catch {\n        // File not found or unreadable — will be caught during execution\n      }\n    }\n\n    // CLI-only: Check for cache flag with non-idempotent atom\n    if (options.cache && !atomEntry.idempotent) {\n      throw new Error(\n        `Cannot use --cache with non-idempotent atom '${target}'.\\n` +\n        `Only idempotent atoms can be cached.`\n      );\n    }\n\n    // CLI-only: Non-idempotent confirmation gate (skip for graduated/generator atoms)\n    if (!atomEntry.graduated && !atomEntry.idempotent && !options.yes) {\n      throw new Error(\n        `Atom '${target}' is not idempotent.\\n` +\n        `Re-running may have side effects. Use --yes to confirm execution.`\n      );\n    }\n\n    // CLI-only: Load skills and display progress before execution (handler atoms only)\n    let preloadedSkillResult: SkillLoadResult | undefined;\n    if (!atomEntry.graduated) {\n      const skillNames = getAtomSkillNames(atomEntry);\n      preloadedSkillResult = await loadSkillsForAtom(skillNames);\n\n      if (!options.json) {\n        for (const line of formatLoadedSkills(preloadedSkillResult)) {\n          console.log(line);\n        }\n      }\n    }\n\n    // Delegate actual execution to executeAtom.\n    // Pass a pre-loaded skill loader to avoid redundant skill loading.\n    const skillLoader = preloadedSkillResult\n      ? async () => preloadedSkillResult!\n      : undefined;\n\n    const execResult: AtomExecutionResult = await executeAtom(\n      target,\n      inputData,\n      projectRoot,\n      skillLoader\n    );\n\n    const duration = Date.now() - startTime;\n\n    // Format and display result\n    formatAndOutputResult(execResult, target, inputData, duration, options, atomEntry.graduated);\n  } catch (err) {\n    const duration = Date.now() - startTime;\n    outputCatchError(err, target, options, duration);\n  }\n}\n\n/**\n * Format an AtomExecutionResult for CLI output and display it.\n * Handles both JSON and human-readable output modes.\n */\nfunction formatAndOutputResult(\n  execResult: AtomExecutionResult,\n  target: string,\n  inputData: unknown,\n  duration: number,\n  options: RunOptions,\n  graduated?: boolean\n): void {\n  // Build RunResult for JSON output\n  const runResult: RunResult = {\n    success: execResult.success,\n    atomName: execResult.atomName,\n    input: inputData,\n    duration,\n  };\n\n  if (execResult.success) {\n    runResult.output = execResult.output;\n  } else {\n    runResult.error = {\n      type: 'execution',\n      message: execResult.error || 'Unknown error',\n      recoverable: false,\n    };\n  }\n\n  if (options.json) {\n    console.log(JSON.stringify(runResult, null, 2));\n    if (!execResult.success) {\n      process.exit(1);\n    }\n    return;\n  }\n\n  // Human-readable output\n  const displayName = graduated\n    ? `${target} (generator)`\n    : execResult.atomName;\n\n  if (execResult.success) {\n    console.log(formatSuccess(displayName, duration));\n    if (execResult.output != null) {\n      console.log(`  ${fmt.gray('Output:')}`);\n      const outputStr = typeof execResult.output === 'string'\n        ? execResult.output\n        : JSON.stringify(execResult.output, null, 2);\n      console.log(outputStr.split('\\n').map((l: string) => `    ${l}`).join('\\n'));\n    }\n  } else {\n    console.error(formatFailure(displayName));\n    console.error(formatAtomError({\n      type: 'execution',\n      message: execResult.error || 'Execution failed',\n      recoverable: false,\n    }));\n    process.exit(1);\n  }\n}\n\n/**\n * Handle errors caught by the outer try/catch (pre-flight failures).\n * Formats the error for JSON or human-readable output.\n */\nfunction outputCatchError(\n  err: unknown,\n  target: string,\n  options: RunOptions,\n  duration: number\n): void {\n  if (options.json) {\n    // Safely parse input — may fail if original error was caused by invalid JSON\n    let parsedInput: unknown = {};\n    try {\n      parsedInput = options.input ? JSON.parse(options.input) : {};\n    } catch {\n      parsedInput = options.input ?? {};\n    }\n\n    console.log(\n      JSON.stringify({\n        success: false,\n        atomName: target,\n        input: parsedInput,\n        error: {\n          type: 'execution',\n          message: toErrorMessage(err),\n          recoverable: false,\n        },\n        duration,\n      } satisfies RunResult)\n    );\n    process.exit(1);\n  } else {\n    console.error(formatAtomError({\n      type: 'execution',\n      message: toErrorMessage(err),\n      recoverable: false,\n    }));\n    process.exit(1);\n  }\n}\n"],"mappings":"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","names":[]}