atomism 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,210 @@
+# Atomism
+
+Schema-first agent swarm orchestration framework.
+
+Build verifiable, composable AI workflows with type-safe atoms that graduate to deterministic generators.
+
+## Install
+
+```bash
+npm install -g atomism
+```
+
+## Quick Start
+
+```bash
+atomic init
+atomic create atom hello_world
+atomic register atoms/hello_world.ts
+atomic run hello_world --input '{"name": "World"}' --yes
+```
+
+## What is an Atom?
+
+An atom is a small, testable, reusable unit of work with validated inputs and outputs:
+
+```typescript
+import { z } from 'zod';
+import { defineAtom, success } from 'atomism';
+
+export default defineAtom({
+  name: 'hello_world',
+  description: 'Generates a greeting',
+  input: z.object({
+    name: z.string().describe('Name to greet'),
+  }),
+  output: z.object({
+    greeting: z.string(),
+  }),
+  tests: { path: './hello_world.test.ts' },
+  idempotent: true,
+  handler: async ({ name }) => {
+    return success({ greeting: `Hello, ${name}!` });
+  },
+});
+```
+
+## Features
+
+### Schema-First Design
+
+Every atom has Zod schemas for inputs and outputs. Type safety at compile time, validation at runtime.
+
+### Generator Evolution
+
+When atoms produce similar outputs repeatedly, graduate them to deterministic generators:
+
+```bash
+atomic graduate hello_world    # Creates generators/hello_world.ts
+atomic revert hello_world      # Reverts to handler if needed
+```
+
+### Trust-Based Execution
+
+Atoms earn trust through successful runs. New atoms require confirmation, trusted atoms run automatically:
+
+```bash
+atomic trust --list                        # View trust levels
+atomic trust my_stack --level proven       # Promote trust
+```
+
+Trust levels: `new` → `proven` → `trusted`
+
+### Workflows
+
+Compose atoms into dependency-resolved workflows:
+
+```bash
+atomic workflow run feature_pipeline       # Execute workflow
+atomic workflow resume feature_pipeline    # Resume failed workflow
+atomic plan feature_pipeline               # Preview execution plan
+```
+
+### Generator Import
+
+Import existing generators from other systems:
+
+```bash
+atomic scan-generators                     # Detect Plop, Hygen, Yeoman, etc.
+atomic import-generator --plop component   # Import to atomic format
+atomic import-generator --hygen model/new
+atomic import-generator --cookiecutter ./template
+atomic validate-generator --all            # Verify imports work
+```
+
+### Skills Integration
+
+Connect atoms to Claude Code skills:
+
+```bash
+atomic skills scan                         # Discover available skills
+atomic skills suggest my_atom              # Get recommendations
+atomic skills assign my_atom --skill code-review
+```
+
+### Extraction
+
+Create atoms from existing sources:
+
+```bash
+atomic extract --skill ./skills/refactor.md
+atomic extract --code ./lib/parser.ts
+atomic extract --mcp ./tools/search.json
+```
+
+## CLI Reference
+
+### Core Commands
+
+| Command | Description |
+|---------|-------------|
+| `atomic init` | Initialize `.atomic/` directory |
+| `atomic create atom <name>` | Scaffold new atom |
+| `atomic register <path>` | Register atom file |
+| `atomic run <atom>` | Execute atom or generator |
+| `atomic list` | List registered atoms |
+| `atomic status` | Show system state |
+| `atomic history [runId]` | View execution history |
+
+### Testing
+
+| Command | Description |
+|---------|-------------|
+| `atomic test <atom>` | Run atom tests |
+| `atomic test-gen <path>` | Generate structural tests |
+
+### Graduation
+
+| Command | Description |
+|---------|-------------|
+| `atomic graduate <atom>` | Graduate to generator |
+| `atomic revert <atom>` | Revert to handler |
+
+### Trust
+
+| Command | Description |
+|---------|-------------|
+| `atomic trust --list` | List all trust levels |
+| `atomic trust <stack> --level <level>` | Set trust level |
+| `atomic trust <stack> --reset` | Reset to new |
+
+### Workflows
+
+| Command | Description |
+|---------|-------------|
+| `atomic workflow run <name>` | Execute workflow |
+| `atomic workflow list` | List workflows |
+| `atomic workflow resume <name>` | Resume failed workflow |
+| `atomic plan <workflow>` | Preview execution plan |
+| `atomic escalate` | Create issue for blocked work |
+
+### Generator Import
+
+| Command | Description |
+|---------|-------------|
+| `atomic scan-generators` | Detect existing generators |
+| `atomic import-generator` | Import from Plop/Hygen/Yeoman/etc |
+| `atomic validate-generator` | Validate imported generators |
+
+### Skills
+
+| Command | Description |
+|---------|-------------|
+| `atomic skills scan` | Discover Claude Code skills |
+| `atomic skills suggest <atom>` | Get skill recommendations |
+| `atomic skills assign <atom>` | Assign skill to atom |
+| `atomic skills list <atom>` | List assigned skills |
+| `atomic skills remove <atom>` | Remove skill from atom |
+
+All commands support `--json` for structured output.
+
+## Library API
+
+```typescript
+import {
+  defineAtom,
+  success,
+  failure,
+  validationError,
+  executionError,
+  z,
+} from 'atomism';
+
+// Result helpers
+success({ data: 'value' })           // Success response
+failure('Something went wrong')       // Error response
+validationError('Invalid input')      // Validation error
+executionError('Runtime failure')     // Execution error
+```
+
+## Documentation
+
+Full documentation: https://trust-will.github.io/atomic-explore/
+
+## Requirements
+
+- Node.js 18+
+
+## License
+
+MIT

package/dist/chunk-34O5KJWR.js

@@ -0,0 +1,81 @@
+import {
+  TrustLevel
+} from "./chunk-YKJO3ZFY.js";
+
+// src/schemas/atom.ts
+import { z } from "zod";
+var ErrorType = z.enum([
+  "validation",
+  "execution",
+  "dependency",
+  "timeout"
+]);
+var AtomError = z.object({
+  type: ErrorType,
+  message: z.string(),
+  recoverable: z.boolean(),
+  suggestion: z.string().optional(),
+  context: z.record(z.string(), z.unknown()).optional()
+});
+var SuccessResponse = (outputSchema) => z.object({
+  success: z.literal(true),
+  data: outputSchema
+});
+var ErrorResponse = z.object({
+  success: z.literal(false),
+  error: AtomError
+});
+var AtomResult = (outputSchema) => z.discriminatedUnion("success", [
+  SuccessResponse(outputSchema),
+  ErrorResponse
+]);
+var TestManifest = z.object({
+  path: z.string(),
+  coverage_threshold: z.number().min(0).max(100).optional()
+});
+var AtomDefinition = z.object({
+  name: z.string().regex(/^[a-z][a-z0-9_]*$/, "Name must be snake_case"),
+  description: z.string().min(1),
+  input: z.instanceof(z.ZodType),
+  output: z.instanceof(z.ZodType),
+  idempotent: z.boolean().default(true),
+  tests: TestManifest,
+  // Optional fields for enhanced execution
+  agent: z.string().optional(),
+  skill: z.string().optional()
+});
+
+// src/schemas/stack.ts
+import { z as z2 } from "zod";
+var StackAtom = z2.object({
+  /** Atom name */
+  name: z2.string().min(1),
+  /** Optional description of this atom's role in the stack */
+  description: z2.string().optional()
+});
+var AtomStack = z2.object({
+  /** Stack name (must be snake_case) */
+  name: z2.string().regex(/^[a-z][a-z0-9_]*$/, "Stack name must be snake_case"),
+  /** Human-readable description */
+  description: z2.string(),
+  /** Ordered list of atoms in this stack */
+  atoms: z2.array(StackAtom),
+  /** Trust level for this stack */
+  trustLevel: TrustLevel.default("new"),
+  /** When the stack was created */
+  createdAt: z2.iso.datetime(),
+  /** When the stack was last updated */
+  updatedAt: z2.iso.datetime()
+});
+
+export {
+  ErrorType,
+  AtomError,
+  SuccessResponse,
+  ErrorResponse,
+  AtomResult,
+  TestManifest,
+  AtomDefinition,
+  AtomStack
+};
+//# sourceMappingURL=chunk-34O5KJWR.js.map

package/dist/chunk-34O5KJWR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schemas/atom.ts","../src/schemas/stack.ts"],"sourcesContent":["import { z } from 'zod';\n\n// Error types for atom execution\nexport const ErrorType = z.enum([\n  'validation',\n  'execution',\n  'dependency',\n  'timeout',\n]);\nexport type ErrorType = z.infer<typeof ErrorType>;\n\n// Structured error with actionable information\nexport const AtomError = z.object({\n  type: ErrorType,\n  message: z.string(),\n  recoverable: z.boolean(),\n  suggestion: z.string().optional(),\n  context: z.record(z.string(), z.unknown()).optional(),\n});\nexport type AtomError = z.infer<typeof AtomError>;\n\n// Success response\nexport const SuccessResponse = <T extends z.ZodType>(outputSchema: T) =>\n  z.object({\n    success: z.literal(true),\n    data: outputSchema,\n  });\n\n// Error response\nexport const ErrorResponse = z.object({\n  success: z.literal(false),\n  error: AtomError,\n});\nexport type ErrorResponse = z.infer<typeof ErrorResponse>;\n\n// Union result type - parameterized by output schema\nexport const AtomResult = <T extends z.ZodType>(outputSchema: T) =>\n  z.discriminatedUnion('success', [\n    SuccessResponse(outputSchema),\n    ErrorResponse,\n  ]);\n\n// Helper type for AtomResult inference\nexport type AtomResult<T> =\n  | { success: true; data: T }\n  | { success: false; error: AtomError };\n\n// Test manifest for atom registration\nexport const TestManifest = z.object({\n  path: z.string(),\n  coverage_threshold: z.number().min(0).max(100).optional(),\n});\nexport type TestManifest = z.infer<typeof TestManifest>;\n\n// Atom definition schema\nexport const AtomDefinition = z.object({\n  name: z\n    .string()\n    .regex(/^[a-z][a-z0-9_]*$/, 'Name must be snake_case'),\n  description: z.string().min(1),\n  input: z.instanceof(z.ZodType),\n  output: z.instanceof(z.ZodType),\n  idempotent: z.boolean().default(true),\n  tests: TestManifest,\n  // Optional fields for enhanced execution\n  agent: z.string().optional(),\n  skill: z.string().optional(),\n});\nexport type AtomDefinition = z.infer<typeof AtomDefinition>;\n","/**\n * Stack schemas for the atomic framework.\n *\n * Stacks are reusable compositions of atoms that can be reviewed once\n * and reused. They enable pattern-based trust management.\n *\n * @module schemas/stack\n */\n\nimport { z } from 'zod';\nimport { TrustLevel } from './trust.js';\n\n/**\n * An atom reference within a stack.\n */\nexport const StackAtom = z.object({\n  /** Atom name */\n  name: z.string().min(1),\n  /** Optional description of this atom's role in the stack */\n  description: z.string().optional(),\n});\nexport type StackAtom = z.infer<typeof StackAtom>;\n\n/**\n * An atom stack definition.\n */\nexport const AtomStack = z.object({\n  /** Stack name (must be snake_case) */\n  name: z.string().regex(/^[a-z][a-z0-9_]*$/, 'Stack name must be snake_case'),\n  /** Human-readable description */\n  description: z.string(),\n  /** Ordered list of atoms in this stack */\n  atoms: z.array(StackAtom),\n  /** Trust level for this stack */\n  trustLevel: TrustLevel.default('new'),\n  /** When the stack was created */\n  createdAt: z.iso.datetime(),\n  /** When the stack was last updated */\n  updatedAt: z.iso.datetime(),\n});\nexport type AtomStack = z.infer<typeof AtomStack>;\n\n/**\n * Create a new atom stack with defaults.\n */\nexport function createStack(name: string, description: string = ''): AtomStack {\n  const now = new Date().toISOString();\n  return AtomStack.parse({\n    name,\n    description,\n    atoms: [],\n    trustLevel: 'new',\n    createdAt: now,\n    updatedAt: now,\n  });\n}\n\n/**\n * Add an atom to a stack.\n * Returns a new stack with the atom added (immutable).\n */\nexport function addAtomToStack(\n  stack: AtomStack,\n  atomName: string,\n  atomDescription?: string\n): AtomStack {\n  // Validate atom first for clearer error messages\n  const stackAtom = StackAtom.parse({\n    name: atomName,\n    ...(atomDescription && { description: atomDescription }),\n  });\n\n  return AtomStack.parse({\n    ...stack,\n    atoms: [...stack.atoms, stackAtom],\n    updatedAt: new Date().toISOString(),\n  });\n}\n\n/**\n * Remove an atom from a stack by name.\n * Returns a new stack with the atom removed (immutable).\n */\nexport function removeAtomFromStack(\n  stack: AtomStack,\n  atomName: string\n): AtomStack {\n  return AtomStack.parse({\n    ...stack,\n    atoms: stack.atoms.filter((a) => a.name !== atomName),\n    updatedAt: new Date().toISOString(),\n  });\n}\n\n"],"mappings":";;;;;AAAA,SAAS,SAAS;AAGX,IAAM,YAAY,EAAE,KAAK;AAAA,EAC9B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAIM,IAAM,YAAY,EAAE,OAAO;AAAA,EAChC,MAAM;AAAA,EACN,SAAS,EAAE,OAAO;AAAA,EAClB,aAAa,EAAE,QAAQ;AAAA,EACvB,YAAY,EAAE,OAAO,EAAE,SAAS;AAAA,EAChC,SAAS,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,QAAQ,CAAC,EAAE,SAAS;AACtD,CAAC;AAIM,IAAM,kBAAkB,CAAsB,iBACnD,EAAE,OAAO;AAAA,EACP,SAAS,EAAE,QAAQ,IAAI;AAAA,EACvB,MAAM;AACR,CAAC;AAGI,IAAM,gBAAgB,EAAE,OAAO;AAAA,EACpC,SAAS,EAAE,QAAQ,KAAK;AAAA,EACxB,OAAO;AACT,CAAC;AAIM,IAAM,aAAa,CAAsB,iBAC9C,EAAE,mBAAmB,WAAW;AAAA,EAC9B,gBAAgB,YAAY;AAAA,EAC5B;AACF,CAAC;AAQI,IAAM,eAAe,EAAE,OAAO;AAAA,EACnC,MAAM,EAAE,OAAO;AAAA,EACf,oBAAoB,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG,EAAE,SAAS;AAC1D,CAAC;AAIM,IAAM,iBAAiB,EAAE,OAAO;AAAA,EACrC,MAAM,EACH,OAAO,EACP,MAAM,qBAAqB,yBAAyB;AAAA,EACvD,aAAa,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EAC7B,OAAO,EAAE,WAAW,EAAE,OAAO;AAAA,EAC7B,QAAQ,EAAE,WAAW,EAAE,OAAO;AAAA,EAC9B,YAAY,EAAE,QAAQ,EAAE,QAAQ,IAAI;AAAA,EACpC,OAAO;AAAA;AAAA,EAEP,OAAO,EAAE,OAAO,EAAE,SAAS;AAAA,EAC3B,OAAO,EAAE,OAAO,EAAE,SAAS;AAC7B,CAAC;;;AC1DD,SAAS,KAAAA,UAAS;AAMX,IAAM,YAAYC,GAAE,OAAO;AAAA;AAAA,EAEhC,MAAMA,GAAE,OAAO,EAAE,IAAI,CAAC;AAAA;AAAA,EAEtB,aAAaA,GAAE,OAAO,EAAE,SAAS;AACnC,CAAC;AAMM,IAAM,YAAYA,GAAE,OAAO;AAAA;AAAA,EAEhC,MAAMA,GAAE,OAAO,EAAE,MAAM,qBAAqB,+BAA+B;AAAA;AAAA,EAE3E,aAAaA,GAAE,OAAO;AAAA;AAAA,EAEtB,OAAOA,GAAE,MAAM,SAAS;AAAA;AAAA,EAExB,YAAY,WAAW,QAAQ,KAAK;AAAA;AAAA,EAEpC,WAAWA,GAAE,IAAI,SAAS;AAAA;AAAA,EAE1B,WAAWA,GAAE,IAAI,SAAS;AAC5B,CAAC;","names":["z","z"]}

package/dist/chunk-55AP34JO.js

@@ -0,0 +1,116 @@
+import {
+  getGlobalSkillsPath,
+  getProjectSkillsPath,
+  parseFrontmatter,
+  scanSkillEntry
+} from "./chunk-UVUDQ4XP.js";
+import {
+  fmt
+} from "./chunk-S6Z5G5DB.js";
+import {
+  toErrorMessage
+} from "./chunk-PLQJM2KT.js";
+
+// src/commands/skills-load.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+async function findSkillInDirectory(skillName, dirPath, source) {
+  const directPath = join(dirPath, `${skillName}.md`);
+  const directSkill = await scanSkillEntry(directPath, source);
+  if (directSkill) {
+    return directSkill;
+  }
+  const dirSkillPath = join(dirPath, skillName);
+  const dirSkill = await scanSkillEntry(dirSkillPath, source);
+  if (dirSkill) {
+    return dirSkill;
+  }
+  return null;
+}
+async function findSkillByName(skillName) {
+  const projectSkill = await findSkillInDirectory(skillName, getProjectSkillsPath(), "project");
+  if (projectSkill) {
+    return projectSkill;
+  }
+  const globalSkill = await findSkillInDirectory(skillName, getGlobalSkillsPath(), "global");
+  if (globalSkill) {
+    return globalSkill;
+  }
+  return null;
+}
+async function loadSkillContent(skillInfo) {
+  let skillPath = skillInfo.resolvedPath ?? skillInfo.location;
+  if (!skillPath.endsWith(".md")) {
+    skillPath = join(skillPath, "SKILL.md");
+  }
+  return await readFile(skillPath, "utf-8");
+}
+function extractSkillInstructions(content) {
+  const normalized = content.replace(/\r\n/g, "\n");
+  const frontmatterMatch = normalized.match(/^---\n[\s\S]*?\n---\n?/);
+  if (frontmatterMatch) {
+    return normalized.slice(frontmatterMatch[0].length).trim();
+  }
+  return normalized.trim();
+}
+async function loadSkill(skillName) {
+  const skillInfo = await findSkillByName(skillName);
+  if (!skillInfo) {
+    return { skill: null };
+  }
+  try {
+    const fullContent = await loadSkillContent(skillInfo);
+    const { name, description } = parseFrontmatter(fullContent);
+    const instructions = extractSkillInstructions(fullContent);
+    return {
+      skill: {
+        name: name || skillName,
+        description: description || "",
+        content: instructions,
+        location: skillInfo.location,
+        source: skillInfo.source
+      }
+    };
+  } catch (error) {
+    const message = toErrorMessage(error);
+    return { skill: null, error: `Failed to load skill "${skillName}": ${message}` };
+  }
+}
+async function loadSkillsForAtom(skillNames) {
+  const warnings = [];
+  const results = await Promise.all(
+    skillNames.map(async (skillName) => {
+      const result = await loadSkill(skillName);
+      return { skillName, ...result };
+    })
+  );
+  const loaded = [];
+  for (const { skillName, skill, error } of results) {
+    if (skill) {
+      loaded.push(skill);
+    } else if (error) {
+      warnings.push(error);
+    } else {
+      warnings.push(`Skill "${skillName}" not found - execution will continue without it`);
+    }
+  }
+  return { loaded, warnings };
+}
+function formatLoadedSkills(result) {
+  const lines = [];
+  for (const skill of result.loaded) {
+    lines.push(fmt.dim(`Loaded skill: ${fmt.cyan(skill.name)} (${skill.source})`));
+  }
+  for (const warning of result.warnings) {
+    lines.push(fmt.yellow(`Warning: ${warning}`));
+  }
+  return lines;
+}
+
+export {
+  extractSkillInstructions,
+  loadSkill,
+  loadSkillsForAtom,
+  formatLoadedSkills
+};
+//# sourceMappingURL=chunk-55AP34JO.js.map

package/dist/chunk-55AP34JO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/skills-load.ts"],"sourcesContent":["/**\n * Skill Loading - Load skill content for atom execution.\n *\n * Story 6.9: AOP-1260\n *\n * Acceptance Criteria:\n * - Skill loaded into Claude's context during execution\n * - Skill's instructions/prompts available to handler\n * - Execution log shows: 'Loaded skill: testing'\n * - Missing skill file shows warning but execution continues\n */\n\nimport { readFile } from 'node:fs/promises';\nimport { join } from 'node:path';\nimport { fmt } from '../cli/format.js';\nimport { toErrorMessage } from '../utils/errors.js';\nimport {\n  scanSkillEntry,\n  parseFrontmatter,\n  SkillInfo,\n  getProjectSkillsPath,\n  getGlobalSkillsPath,\n} from './skills-scan.js';\n\nexport type { LoadedSkill, SkillLoadResult } from '../atom/skills-load.js';\nimport type { LoadedSkill, SkillLoadResult } from '../atom/skills-load.js';\n\n/**\n * Try to find a skill file by name in the given directory.\n * Looks for:\n * - <name>.md directly in the directory\n * - <name>/SKILL.md for directory-based skills\n */\nasync function findSkillInDirectory(\n  skillName: string,\n  dirPath: string,\n  source: 'project' | 'global'\n): Promise<SkillInfo | null> {\n  // Try direct file: <name>.md\n  const directPath = join(dirPath, `${skillName}.md`);\n  const directSkill = await scanSkillEntry(directPath, source);\n  if (directSkill) {\n    return directSkill;\n  }\n\n  // Try directory: <name>/SKILL.md\n  const dirSkillPath = join(dirPath, skillName);\n  const dirSkill = await scanSkillEntry(dirSkillPath, source);\n  if (dirSkill) {\n    return dirSkill;\n  }\n\n  return null;\n}\n\n/**\n * Find a skill by name across all skill locations.\n * Search order: project -> global -> mcp\n */\nasync function findSkillByName(skillName: string): Promise<SkillInfo | null> {\n  // Try project skills first\n  const projectSkill = await findSkillInDirectory(skillName, getProjectSkillsPath(), 'project');\n  if (projectSkill) {\n    return projectSkill;\n  }\n\n  // Try global skills\n  const globalSkill = await findSkillInDirectory(skillName, getGlobalSkillsPath(), 'global');\n  if (globalSkill) {\n    return globalSkill;\n  }\n\n  // MCP skills are runtime-provided and don't have loadable content\n  // They're discovered through config but content comes from MCP servers\n  return null;\n}\n\n/**\n * Load the full content of a skill file.\n */\nasync function loadSkillContent(skillInfo: SkillInfo): Promise<string> {\n  // Use resolved path if available (for symlinks), otherwise use location\n  let skillPath = skillInfo.resolvedPath ?? skillInfo.location;\n\n  // If path is a directory, look for SKILL.md inside\n  if (!skillPath.endsWith('.md')) {\n    skillPath = join(skillPath, 'SKILL.md');\n  }\n\n  return await readFile(skillPath, 'utf-8');\n}\n\n/**\n * Extract the instructions/body content from a skill file.\n * Strips frontmatter and returns the main content.\n */\nexport function extractSkillInstructions(content: string): string {\n  // Normalize line endings\n  const normalized = content.replace(/\\r\\n/g, '\\n');\n\n  // Remove frontmatter if present\n  const frontmatterMatch = normalized.match(/^---\\n[\\s\\S]*?\\n---\\n?/);\n  if (frontmatterMatch) {\n    return normalized.slice(frontmatterMatch[0].length).trim();\n  }\n\n  return normalized.trim();\n}\n\n/**\n * Result of attempting to load a skill.\n */\ninterface SkillLoadAttempt {\n  skill: LoadedSkill | null;\n  error?: string;\n}\n\n/**\n * Load a single skill by name.\n * Returns the skill and any error message for diagnostics.\n */\nexport async function loadSkill(skillName: string): Promise<SkillLoadAttempt> {\n  const skillInfo = await findSkillByName(skillName);\n  if (!skillInfo) {\n    return { skill: null };\n  }\n\n  try {\n    const fullContent = await loadSkillContent(skillInfo);\n    const { name, description } = parseFrontmatter(fullContent);\n    const instructions = extractSkillInstructions(fullContent);\n\n    return {\n      skill: {\n        name: name || skillName,\n        description: description || '',\n        content: instructions,\n        location: skillInfo.location,\n        source: skillInfo.source,\n      },\n    };\n  } catch (error) {\n    // Return error context for diagnostics\n    const message = toErrorMessage(error);\n    return { skill: null, error: `Failed to load skill \"${skillName}\": ${message}` };\n  }\n}\n\n/**\n * Load multiple skills for an atom execution.\n * Returns loaded skills and warnings for any that couldn't be found.\n * Skills are loaded in parallel for improved performance.\n */\nexport async function loadSkillsForAtom(skillNames: string[]): Promise<SkillLoadResult> {\n  const warnings: string[] = [];\n\n  // Load all skills in parallel\n  const results = await Promise.all(\n    skillNames.map(async (skillName) => {\n      const result = await loadSkill(skillName);\n      return { skillName, ...result };\n    })\n  );\n\n  const loaded: LoadedSkill[] = [];\n  for (const { skillName, skill, error } of results) {\n    if (skill) {\n      loaded.push(skill);\n    } else if (error) {\n      // Include error details for diagnostics\n      warnings.push(error);\n    } else {\n      warnings.push(`Skill \"${skillName}\" not found - execution will continue without it`);\n    }\n  }\n\n  return { loaded, warnings };\n}\n\n/**\n * Format loaded skills for logging/display.\n */\nexport function formatLoadedSkills(result: SkillLoadResult): string[] {\n  const lines: string[] = [];\n\n  for (const skill of result.loaded) {\n    lines.push(fmt.dim(`Loaded skill: ${fmt.cyan(skill.name)} (${skill.source})`));\n  }\n\n  for (const warning of result.warnings) {\n    lines.push(fmt.yellow(`Warning: ${warning}`));\n  }\n\n  return lines;\n}\n\n// Re-export from canonical location (atom/skill-context.ts)\nexport { buildSkillContext, type SkillWithContent } from '../atom/skill-context.js';\n"],"mappings":"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","names":[]}

package/dist/chunk-6MDHM2B4.js

@@ -0,0 +1,17 @@
+// src/atom/skill-context.ts
+function buildSkillContext(skills) {
+  if (skills.length === 0) {
+    return "";
+  }
+  const sections = skills.map((skill) => {
+    return `## Skill: ${skill.name}
+
+${skill.content}`;
+  });
+  return sections.join("\n\n---\n\n");
+}
+
+export {
+  buildSkillContext
+};
+//# sourceMappingURL=chunk-6MDHM2B4.js.map

package/dist/chunk-6MDHM2B4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/atom/skill-context.ts"],"sourcesContent":["/**\n * Skill context building for atom execution.\n *\n * Extracted from commands/skills-load.ts to fix inverted dependency\n * (atom/ should not import from commands/).\n *\n * @module atom/skill-context\n */\n\n/**\n * Minimal interface for building skill context.\n * Allows both LoadedSkill and SkillContext to be used.\n */\nexport interface SkillWithContent {\n  name: string;\n  content: string;\n}\n\n/**\n * Build execution context from skills.\n * Combines skill instructions into a single context string.\n */\nexport function buildSkillContext(skills: SkillWithContent[]): string {\n  if (skills.length === 0) {\n    return '';\n  }\n\n  const sections = skills.map((skill) => {\n    return `## Skill: ${skill.name}\\n\\n${skill.content}`;\n  });\n\n  return sections.join('\\n\\n---\\n\\n');\n}\n"],"mappings":";AAsBO,SAAS,kBAAkB,QAAoC;AACpE,MAAI,OAAO,WAAW,GAAG;AACvB,WAAO;AAAA,EACT;AAEA,QAAM,WAAW,OAAO,IAAI,CAAC,UAAU;AACrC,WAAO,aAAa,MAAM,IAAI;AAAA;AAAA,EAAO,MAAM,OAAO;AAAA,EACpD,CAAC;AAED,SAAO,SAAS,KAAK,aAAa;AACpC;","names":[]}

package/dist/chunk-GU2R4KLP.js

@@ -0,0 +1,43 @@
+import {
+  StorageNotInitializedError
+} from "./chunk-YKJO3ZFY.js";
+import {
+  toErrorMessage
+} from "./chunk-PLQJM2KT.js";
+
+// src/commands/helpers.ts
+function deriveErrorCode(error) {
+  if (error instanceof StorageNotInitializedError) return "STORAGE_NOT_INITIALIZED";
+  if (error instanceof SyntaxError) return "INVALID_JSON";
+  if (error instanceof TypeError) return "TYPE_ERROR";
+  const msg = toErrorMessage(error);
+  if (msg.includes("not found")) return "NOT_FOUND";
+  if (msg.includes("already exists")) return "ALREADY_EXISTS";
+  if (msg.includes("permission")) return "PERMISSION_DENIED";
+  return "UNKNOWN_ERROR";
+}
+async function withErrorHandling(options, fn) {
+  try {
+    await fn();
+  } catch (error) {
+    const message = toErrorMessage(error);
+    if (options.json) {
+      console.log(
+        JSON.stringify({
+          success: false,
+          error: message,
+          errorCode: deriveErrorCode(error)
+        })
+      );
+    } else {
+      console.error(`Error: ${message}`);
+    }
+    process.exit(1);
+  }
+}
+
+export {
+  deriveErrorCode,
+  withErrorHandling
+};
+//# sourceMappingURL=chunk-GU2R4KLP.js.map

package/dist/chunk-GU2R4KLP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/helpers.ts"],"sourcesContent":["/**\n * Shared command helpers for the atomic CLI.\n *\n * Provides error-handling wrappers to reduce boilerplate across commands.\n *\n * @module commands/helpers\n */\n\nimport { toErrorMessage } from '../utils/errors.js';\nimport { StorageNotInitializedError } from '../storage/index.js';\n\n/**\n * Options that all commands with error handling share.\n */\nexport interface CommandOptions {\n  json?: boolean;\n}\n\n/**\n * Derive a machine-readable error code from an error instance.\n * Agents can use this to distinguish error types programmatically.\n */\nexport function deriveErrorCode(error: unknown): string {\n  if (error instanceof StorageNotInitializedError) return 'STORAGE_NOT_INITIALIZED';\n  if (error instanceof SyntaxError) return 'INVALID_JSON';\n  if (error instanceof TypeError) return 'TYPE_ERROR';\n  const msg = toErrorMessage(error);\n  if (msg.includes('not found')) return 'NOT_FOUND';\n  if (msg.includes('already exists')) return 'ALREADY_EXISTS';\n  if (msg.includes('permission')) return 'PERMISSION_DENIED';\n  return 'UNKNOWN_ERROR';\n}\n\n/**\n * Wrap a command function with standard error handling.\n *\n * The wrapped function (`fn`) is responsible for ALL success output (both JSON\n * and human-readable). This wrapper only handles the error/catch path:\n *\n * - JSON mode: prints `{ success: false, error: \"...\", errorCode: \"...\" }` and calls process.exit(1)\n * - Human mode: prints `Error: ...` to stderr and calls process.exit(1)\n *\n * Commands with non-standard error output (extra fields, custom formatting)\n * should continue using their own try/catch.\n *\n * @param options - Must include at least `{ json?: boolean }`\n * @param fn - The command's main logic. Handles its own success output.\n */\nexport async function withErrorHandling(\n  options: CommandOptions,\n  fn: () => Promise<void>\n): Promise<void> {\n  try {\n    await fn();\n  } catch (error) {\n    const message = toErrorMessage(error);\n    if (options.json) {\n      console.log(\n        JSON.stringify({\n          success: false,\n          error: message,\n          errorCode: deriveErrorCode(error),\n        })\n      );\n    } else {\n      console.error(`Error: ${message}`);\n    }\n    process.exit(1);\n  }\n}\n"],"mappings":";;;;;;;;AAsBO,SAAS,gBAAgB,OAAwB;AACtD,MAAI,iBAAiB,2BAA4B,QAAO;AACxD,MAAI,iBAAiB,YAAa,QAAO;AACzC,MAAI,iBAAiB,UAAW,QAAO;AACvC,QAAM,MAAM,eAAe,KAAK;AAChC,MAAI,IAAI,SAAS,WAAW,EAAG,QAAO;AACtC,MAAI,IAAI,SAAS,gBAAgB,EAAG,QAAO;AAC3C,MAAI,IAAI,SAAS,YAAY,EAAG,QAAO;AACvC,SAAO;AACT;AAiBA,eAAsB,kBACpB,SACA,IACe;AACf,MAAI;AACF,UAAM,GAAG;AAAA,EACX,SAAS,OAAO;AACd,UAAM,UAAU,eAAe,KAAK;AACpC,QAAI,QAAQ,MAAM;AAChB,cAAQ;AAAA,QACN,KAAK,UAAU;AAAA,UACb,SAAS;AAAA,UACT,OAAO;AAAA,UACP,WAAW,gBAAgB,KAAK;AAAA,QAClC,CAAC;AAAA,MACH;AAAA,IACF,OAAO;AACL,cAAQ,MAAM,UAAU,OAAO,EAAE;AAAA,IACnC;AACA,YAAQ,KAAK,CAAC;AAAA,EAChB;AACF;","names":[]}

package/dist/chunk-H7WC3NXZ.js

@@ -0,0 +1,39 @@
+// src/schemas/workflow.ts
+import { z } from "zod";
+var WorkflowAtom = z.object({
+  /** Atom name (must match a registered atom) */
+  atom: z.string().min(1),
+  /** Atoms this depends on (must complete before this runs) */
+  dependsOn: z.array(z.string()).default([]),
+  /** Optional alias for this atom instance in the workflow */
+  alias: z.string().optional(),
+  /** Optional description of this atom's role in the workflow */
+  description: z.string().optional()
+});
+var WorkflowOutput = z.object({
+  /** Output artifact name */
+  name: z.string().min(1),
+  /** Which atom produces this output */
+  from: z.string().min(1),
+  /** Optional description of the output */
+  description: z.string().optional()
+});
+var WorkflowDefinition = z.object({
+  /** Workflow name (must be snake_case) */
+  name: z.string().regex(/^[a-z][a-z0-9_]*$/, "Workflow name must be snake_case"),
+  /** Human-readable description */
+  description: z.string(),
+  /** Atoms with dependency declarations */
+  atoms: z.array(WorkflowAtom),
+  /** Output artifact declarations */
+  outputs: z.array(WorkflowOutput).default([]),
+  /** When the workflow was created */
+  createdAt: z.iso.datetime(),
+  /** When the workflow was last updated */
+  updatedAt: z.iso.datetime()
+});
+
+export {
+  WorkflowDefinition
+};
+//# sourceMappingURL=chunk-H7WC3NXZ.js.map

package/dist/chunk-H7WC3NXZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schemas/workflow.ts"],"sourcesContent":["/**\n * Workflow definition schemas for the atomic framework.\n *\n * Workflows are atom graphs with artifact dependencies that compose\n * multi-step tasks. Unlike stacks (which are ordered lists for trust),\n * workflows define execution order through explicit dependencies.\n *\n * @module schemas/workflow\n */\n\nimport { z } from 'zod';\n\n/**\n * An atom reference within a workflow with dependency declarations.\n */\nexport const WorkflowAtom = z.object({\n  /** Atom name (must match a registered atom) */\n  atom: z.string().min(1),\n  /** Atoms this depends on (must complete before this runs) */\n  dependsOn: z.array(z.string()).default([]),\n  /** Optional alias for this atom instance in the workflow */\n  alias: z.string().optional(),\n  /** Optional description of this atom's role in the workflow */\n  description: z.string().optional(),\n});\nexport type WorkflowAtom = z.infer<typeof WorkflowAtom>;\n\n/**\n * Output artifact declaration.\n */\nexport const WorkflowOutput = z.object({\n  /** Output artifact name */\n  name: z.string().min(1),\n  /** Which atom produces this output */\n  from: z.string().min(1),\n  /** Optional description of the output */\n  description: z.string().optional(),\n});\nexport type WorkflowOutput = z.infer<typeof WorkflowOutput>;\n\n/**\n * A workflow definition.\n */\nexport const WorkflowDefinition = z.object({\n  /** Workflow name (must be snake_case) */\n  name: z.string().regex(/^[a-z][a-z0-9_]*$/, 'Workflow name must be snake_case'),\n  /** Human-readable description */\n  description: z.string(),\n  /** Atoms with dependency declarations */\n  atoms: z.array(WorkflowAtom),\n  /** Output artifact declarations */\n  outputs: z.array(WorkflowOutput).default([]),\n  /** When the workflow was created */\n  createdAt: z.iso.datetime(),\n  /** When the workflow was last updated */\n  updatedAt: z.iso.datetime(),\n});\nexport type WorkflowDefinition = z.infer<typeof WorkflowDefinition>;\n\n/**\n * Result of cycle detection.\n */\nexport interface CycleDetectionResult {\n  hasCycle: boolean;\n  cycle?: string[];\n}\n\n/**\n * Detect cycles in a workflow's dependency graph using DFS.\n *\n * @param workflow - The workflow to check\n * @returns CycleDetectionResult with hasCycle flag and cycle path if found\n */\nexport function detectCycles(workflow: WorkflowDefinition): CycleDetectionResult {\n  // Build adjacency list from atoms\n  const nodes = new Set<string>();\n  const edges = new Map<string, string[]>();\n\n  for (const wfAtom of workflow.atoms) {\n    const nodeId = wfAtom.alias ?? wfAtom.atom;\n    nodes.add(nodeId);\n    edges.set(nodeId, wfAtom.dependsOn);\n  }\n\n  // Track visited state: 0 = unvisited, 1 = visiting (in stack), 2 = visited\n  const state = new Map<string, number>();\n  const path: string[] = [];\n\n  function dfs(node: string): string[] | null {\n    const currentState = state.get(node) ?? 0;\n\n    if (currentState === 1) {\n      // Found cycle - return the cycle path\n      const cycleStart = path.indexOf(node);\n      return [...path.slice(cycleStart), node];\n    }\n\n    if (currentState === 2) {\n      // Already fully visited, no cycle through this node\n      return null;\n    }\n\n    // Mark as visiting\n    state.set(node, 1);\n    path.push(node);\n\n    // Visit dependencies\n    const deps = edges.get(node) ?? [];\n    for (const dep of deps) {\n      const cycle = dfs(dep);\n      if (cycle) {\n        return cycle;\n      }\n    }\n\n    // Mark as visited\n    path.pop();\n    state.set(node, 2);\n    return null;\n  }\n\n  // Check all nodes (handles disconnected graphs)\n  for (const node of nodes) {\n    const cycle = dfs(node);\n    if (cycle) {\n      return { hasCycle: true, cycle };\n    }\n  }\n\n  return { hasCycle: false };\n}\n\n/**\n * Validate a workflow definition, including cycle detection.\n *\n * @param workflow - The workflow to validate\n * @throws Error if validation fails\n */\nexport function validateWorkflow(workflow: WorkflowDefinition): void {\n  // Schema validation (throws on failure)\n  const parsed = WorkflowDefinition.parse(workflow);\n\n  // Cycle detection\n  const cycleResult = detectCycles(parsed);\n  if (cycleResult.hasCycle) {\n    throw new Error(\n      `Cycle detected in workflow dependencies: ${cycleResult.cycle?.join(' → ')}`\n    );\n  }\n\n  // Validate that all dependencies reference existing atoms\n  // Also check for duplicate atom identifiers\n  const atomIds = new Set<string>();\n  for (const wfAtom of parsed.atoms) {\n    const id = wfAtom.alias ?? wfAtom.atom;\n    if (atomIds.has(id)) {\n      throw new Error(`Duplicate atom identifier \"${id}\"`);\n    }\n    atomIds.add(id);\n  }\n  for (const wfAtom of parsed.atoms) {\n    for (const dep of wfAtom.dependsOn) {\n      if (!atomIds.has(dep)) {\n        throw new Error(\n          `Atom \"${wfAtom.alias ?? wfAtom.atom}\" depends on unknown atom \"${dep}\"`\n        );\n      }\n    }\n  }\n\n  // Validate that outputs reference existing atoms\n  for (const output of parsed.outputs) {\n    if (!atomIds.has(output.from)) {\n      throw new Error(\n        `Output \"${output.name}\" references unknown atom \"${output.from}\"`\n      );\n    }\n  }\n}\n\n/**\n * Create a new workflow with defaults.\n */\nexport function createWorkflow(\n  name: string,\n  description: string = ''\n): WorkflowDefinition {\n  const now = new Date().toISOString();\n  return WorkflowDefinition.parse({\n    name,\n    description,\n    atoms: [],\n    outputs: [],\n    createdAt: now,\n    updatedAt: now,\n  });\n}\n\n/**\n * Add an atom to a workflow.\n * Returns a new workflow with the atom added (immutable).\n *\n * @param workflow - The workflow to add to\n * @param atomName - Atom name\n * @param dependsOn - Array of atom names this depends on\n * @param options - Optional alias and description\n */\nexport function addAtomToWorkflow(\n  workflow: WorkflowDefinition,\n  atomName: string,\n  dependsOn: string[] = [],\n  options?: { alias?: string; description?: string }\n): WorkflowDefinition {\n  const newAtom = WorkflowAtom.parse({\n    atom: atomName,\n    dependsOn,\n    ...options,\n  });\n\n  const updated = WorkflowDefinition.parse({\n    ...workflow,\n    atoms: [...workflow.atoms, newAtom],\n    updatedAt: new Date().toISOString(),\n  });\n\n  // Validate the updated workflow (including cycle detection)\n  validateWorkflow(updated);\n\n  return updated;\n}\n\n/**\n * Add an output declaration to a workflow.\n * Returns a new workflow with the output added (immutable).\n */\nexport function addOutputToWorkflow(\n  workflow: WorkflowDefinition,\n  name: string,\n  from: string,\n  description?: string\n): WorkflowDefinition {\n  const newOutput = WorkflowOutput.parse({\n    name,\n    from,\n    ...(description && { description }),\n  });\n\n  const updated = WorkflowDefinition.parse({\n    ...workflow,\n    outputs: [...workflow.outputs, newOutput],\n    updatedAt: new Date().toISOString(),\n  });\n\n  // Validate the updated workflow\n  validateWorkflow(updated);\n\n  return updated;\n}\n\n"],"mappings":";AAUA,SAAS,SAAS;AAKX,IAAM,eAAe,EAAE,OAAO;AAAA;AAAA,EAEnC,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA;AAAA,EAEtB,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,QAAQ,CAAC,CAAC;AAAA;AAAA,EAEzC,OAAO,EAAE,OAAO,EAAE,SAAS;AAAA;AAAA,EAE3B,aAAa,EAAE,OAAO,EAAE,SAAS;AACnC,CAAC;AAMM,IAAM,iBAAiB,EAAE,OAAO;AAAA;AAAA,EAErC,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA;AAAA,EAEtB,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA;AAAA,EAEtB,aAAa,EAAE,OAAO,EAAE,SAAS;AACnC,CAAC;AAMM,IAAM,qBAAqB,EAAE,OAAO;AAAA;AAAA,EAEzC,MAAM,EAAE,OAAO,EAAE,MAAM,qBAAqB,kCAAkC;AAAA;AAAA,EAE9E,aAAa,EAAE,OAAO;AAAA;AAAA,EAEtB,OAAO,EAAE,MAAM,YAAY;AAAA;AAAA,EAE3B,SAAS,EAAE,MAAM,cAAc,EAAE,QAAQ,CAAC,CAAC;AAAA;AAAA,EAE3C,WAAW,EAAE,IAAI,SAAS;AAAA;AAAA,EAE1B,WAAW,EAAE,IAAI,SAAS;AAC5B,CAAC;","names":[]}