atomism 0.1.0

package/dist/init-2FINDMYK.js

@@ -0,0 +1,741 @@
+import {
+  withErrorHandling
+} from "./chunk-GU2R4KLP.js";
+import {
+  fileExists,
+  initStorage
+} from "./chunk-YKJO3ZFY.js";
+import {
+  toErrorMessage
+} from "./chunk-PLQJM2KT.js";
+
+// src/commands/init.ts
+import { readFile as readFile3, writeFile as writeFile4, access } from "fs/promises";
+import { join as join4 } from "path";
+import { execSync } from "child_process";
+
+// src/commands/skills-init.ts
+import { mkdir, writeFile, stat } from "fs/promises";
+import { join } from "path";
+function generateSkillContent() {
+  return `---
+name: atomic
+description: Schema-first agent swarm orchestration framework
+---
+
+# Atomic Framework
+
+Schema-first agent swarm orchestration. Use atomic to define, execute, and evolve reusable capabilities.
+
+## Trigger
+
+Use this skill when:
+- User mentions "atomic", "atom", "capability", or "workflow" in context of task orchestration
+- User wants to create reusable, schema-validated tasks
+- User wants to graduate patterns from probabilistic (AI) to deterministic (generator)
+- Project has \`.atomic/\` directory
+- User invokes \`/atomic\`
+
+## Why Atoms?
+
+Atoms solve a fundamental problem: **probabilistic work should become deterministic over time.**
+
+When you write an API route the first time, it's creative work. The tenth time you write a similar route, it should be a template fill. But without tracking, you start from scratch every time.
+
+Atoms provide:
+1. **Schema enforcement** \u2014 Inputs/outputs are Zod-validated, not freeform
+2. **Execution history** \u2014 Every run is recorded with inputs, outputs, success/failure
+3. **Similarity detection** \u2014 AST-level comparison identifies when outputs converge on patterns
+4. **Generator graduation** \u2014 When an atom produces 85%+ similar outputs, it can become a deterministic template
+5. **Trust progression** \u2014 New capabilities require review; proven ones auto-execute
+
+The goal: **Capture patterns once, replay deterministically forever.** Focus human attention on genuinely novel problems.
+
+## When to Use Atoms
+
+| Situation | Use |
+|-----------|-----|
+| One-off task, no verification needed | Direct code |
+| Teaching Claude a capability | Claude Code skill |
+| Repetitive task, same shape each time | **Atom** (extract or create) |
+| Need trust gating / human review | **Atom with trust level** |
+| Task should evolve to template | **Atom** (graduation path) |
+| Always-on validation/enforcement | Hook |
+
+**Proactive extraction**: When you notice doing the same thing 3+ times with the same shape, suggest: "This pattern would benefit from atomization \u2014 want me to extract it?"
+
+Use \`atomic extract\` to create atoms from:
+- Existing Claude Code skills (\`--skill\`)
+- BMAD workflows (\`--bmad\`)
+- MCP tool definitions (\`--mcp\`)
+- Existing code files (\`--code\`)
+
+## Directory Structure
+
+\`\`\`
+project/
+\u251C\u2500\u2500 .atomic/                    # Metadata and storage (auto-created by init)
+\u2502   \u251C\u2500\u2500 registry.json           # Registered atoms and capabilities
+\u2502   \u251C\u2500\u2500 trust.json              # Trust levels for capability stacks
+\u2502   \u2514\u2500\u2500 db/                     # SQLite storage for runs and artifacts
+\u251C\u2500\u2500 .claude/
+\u2502   \u2514\u2500\u2500 skills/
+\u2502       \u2514\u2500\u2500 atomic/
+\u2502           \u2514\u2500\u2500 SKILL.md        # This skill (auto-created by init)
+\u251C\u2500\u2500 atoms/                      # Atom source files (default location)
+\u2502   \u251C\u2500\u2500 my_atom.ts
+\u2502   \u2514\u2500\u2500 my_atom.test.ts
+\u2514\u2500\u2500 generators/                 # Graduated generators (created by graduation)
+    \u2514\u2500\u2500 my_generator.ts
+\`\`\`
+
+## Core Concepts
+
+### Atoms
+The fundamental unit. A schema-validated, idempotent task with defined inputs/outputs.
+
+\`\`\`typescript
+// atoms/create_component.ts
+import { defineAtom, success, executionError, z } from 'atomism';
+
+export default defineAtom({
+  name: 'create_component',
+  description: 'Create a React component with tests',
+  input: z.object({
+    name: z.string().min(1),
+    type: z.enum(['functional', 'class']).default('functional'),
+  }),
+  output: z.object({
+    componentPath: z.string(),
+    testPath: z.string(),
+  }),
+  tests: { path: './create_component.test.ts' },
+  idempotent: true,
+  handler: async ({ name, type }) => {
+    // Implementation here
+    return success({ componentPath: '...', testPath: '...' });
+  },
+});
+\`\`\`
+
+### Capabilities
+Route requests to either an atom (probabilistic) or generator (deterministic).
+
+- **Atom-backed**: AI executes with schema validation
+- **Generator-backed**: Deterministic template execution
+
+### Generators
+Graduated atoms. When an atom produces similar outputs repeatedly, it can graduate to a generator (template-based, deterministic).
+
+### Workflows
+Compositions of capabilities with dependency resolution. Like Make/Terraform - declare dependencies, system resolves execution order.
+
+### Trust Levels
+- **new**: Requires human review
+- **proven**: Track record of success, optional review
+- **trusted**: Auto-execute without review
+
+### Capability Stacks
+Reusable groups of capabilities reviewed once, reused many times.
+
+## Project Initialization
+
+\`\`\`bash
+# Initialize atomic in a project
+atomic init
+
+# Creates:
+# .atomic/
+#   registry.json    # Registered atoms and capabilities
+#   trust.json       # Trust levels for capability stacks
+#   db/              # SQLite storage for runs and artifacts
+\`\`\`
+
+## Common Workflows
+
+### 1. Register an Atom
+
+\`\`\`bash
+# Register a new atom
+atomic register atoms/my_atom.ts
+
+# Register with capability name
+atomic register atoms/my_atom.ts --capability my_capability
+\`\`\`
+
+### 2. Run an Atom or Capability
+
+\`\`\`bash
+# Run by atom name
+atomic run my_atom --input '{"key": "value"}'
+
+# Run by capability name
+atomic run my_capability --capability --input '{"key": "value"}'
+
+# Skip confirmation for non-idempotent atoms
+atomic run my_atom --input '{"key": "value"}' --yes
+\`\`\`
+
+### 3. Work with Workflows
+
+\`\`\`bash
+# List available workflows
+atomic workflow list
+
+# Run a workflow
+atomic workflow run my_workflow
+
+# Resume a failed workflow
+atomic workflow resume my_workflow
+
+# Preview execution plan
+atomic plan my_workflow
+\`\`\`
+
+### 4. Graduate to Generator
+
+When an atom produces consistent patterns:
+
+\`\`\`bash
+# Graduate a capability to generator
+atomic graduate --capability my_capability
+
+# Skip confirmation
+atomic graduate --capability my_capability --yes
+\`\`\`
+
+### 5. Manage Trust
+
+\`\`\`bash
+# List all stacks with trust levels
+atomic trust --list
+
+# View specific stack
+atomic trust my_stack
+
+# Set trust level
+atomic trust my_stack --level proven
+
+# Reset to new
+atomic trust my_stack --reset
+\`\`\`
+
+## Command Reference
+
+| Command | Description |
+|---------|-------------|
+| \`atomic init\` | Initialize .atomic/ directory and skill |
+| \`atomic register <path>\` | Register an atom file |
+| \`atomic list\` | List atoms and capabilities |
+| \`atomic run <target>\` | Execute atom or capability |
+| \`atomic test <atom>\` | Run tests for an atom |
+| \`atomic test-gen <path>\` | Generate structural tests |
+| \`atomic extract\` | Create atom from skill/bmad/mcp/code |
+| \`atomic workflow run <name>\` | Execute a workflow |
+| \`atomic workflow list\` | List available workflows |
+| \`atomic workflow resume <name>\` | Resume failed workflow |
+| \`atomic plan <workflow>\` | Preview execution plan |
+| \`atomic graduate\` | Graduate capability to generator |
+| \`atomic trust [stack]\` | Manage trust levels |
+| \`atomic status\` | Show system state |
+| \`atomic history [runId]\` | Show execution history |
+| \`atomic escalate\` | Create Beads issue for problems |
+| \`atomic skills scan\` | Discover available skills |
+| \`atomic skills suggest <atom>\` | Get skill recommendations |
+| \`atomic skills assign <atom>\` | Assign skill to atom |
+| \`atomic skills list <atom>\` | List atom's assigned skills |
+| \`atomic skills remove <atom>\` | Remove skill from atom |
+| \`atomic scan-generators\` | Detect existing generators |
+| \`atomic import-generator\` | Import from Plop/Hygen/etc |
+| \`atomic validate-generator\` | Validate imported generators |
+
+## Best Practices
+
+### 1. Atoms Should Be
+
+- **Small**: Single responsibility
+- **Idempotent**: Same input = same output (or no adverse effects)
+- **Schema-validated**: Zod schemas for input/output
+- **Tested**: Include test file path in definition
+- **Descriptive**: Clear name and description
+
+### 2. Naming Conventions
+
+- Atom names: \`snake_case\` (e.g., \`create_component\`, \`run_migration\`)
+- Capability names: \`snake_case\`
+- Workflow names: \`snake_case\`
+- Stack names: \`snake_case\`
+
+### 3. Error Handling
+
+Use structured errors:
+
+\`\`\`typescript
+import { failure, validationError, executionError } from 'atomism';
+
+// Validation error (bad input \u2014 recoverable by default)
+return validationError('Name cannot be empty');
+
+// Execution error (runtime failure)
+return executionError('Database connection failed', true /* recoverable */);
+
+// Generic failure (full AtomError object)
+return failure({ type: 'execution', message: 'Something went wrong', recoverable: false });
+\`\`\`
+
+### 4. Trust Progression
+
+1. Start capabilities at \`new\` (human review required)
+2. After successful executions, promote to \`proven\`
+3. Only promote to \`trusted\` for well-tested, stable capabilities
+4. Demote immediately if issues arise
+
+### 5. Generator Graduation
+
+Graduate when:
+- Atom produces 85%+ structurally similar outputs
+- Pattern is well-understood
+- Template can capture the variation
+
+Don't graduate:
+- Spec/planning atoms (inherently variable)
+- Creative/exploratory work
+- Low-frequency capabilities
+
+## Skills Assignment
+
+Atoms can have Claude Code skills assigned to them. When an atom executes, assigned skills are loaded into Claude's context.
+
+\`\`\`bash
+# Scan available skills
+atomic skills scan
+
+# Get skill recommendations for an atom
+atomic skills suggest my_atom
+
+# Assign a skill to an atom
+atomic skills assign my_atom --skill compound-engineering:workflows:review
+
+# List skills assigned to an atom
+atomic skills list my_atom
+
+# Remove a skill from an atom
+atomic skills remove my_atom --skill compound-engineering:workflows:review
+\`\`\`
+
+**Use skills for**:
+- Review workflows (e.g., \`compound-engineering:review:kieran-rails-reviewer\`)
+- Domain expertise (e.g., \`dhh-rails-style\`)
+- Specialized capabilities the atom needs
+
+Skills complement atoms: the skill teaches *how*, the atom enforces *what* (schema) and tracks *whether it worked* (history).
+
+## Work Tracking with Beads
+
+**Beads is THE work tracking system.** All atomic work that needs tracking should flow through Beads.
+
+### Escalation
+
+When an atom fails and you can't resolve it:
+
+\`\`\`bash
+# Create a Beads issue for unresolvable problems
+atomic escalate --message "Cannot connect to database" --capability my_capability
+
+# Link to a specific run
+atomic escalate --run abc123 --reason "Schema validation failing on edge case"
+
+# Include retry attempts
+atomic escalate --capability my_atom --retries 3 --reason "Flaky network"
+\`\`\`
+
+### Workflow Tracking
+
+When running workflows, atomic creates Beads issues automatically:
+- **Parent bead**: Tracks the overall workflow
+- **Child beads**: Track each capability execution
+
+\`\`\`bash
+# Workflow execution creates beads automatically
+atomic workflow run my_workflow
+
+# View workflow progress in Beads
+bd list --label atomic
+\`\`\`
+
+## Integration with Claude Code
+
+When working in a project with atomic:
+
+1. **Check for \`.atomic/\`** - If present, use atomic commands
+2. **Register new atoms** - When creating reusable tasks
+3. **Use capabilities** - Route through registry, not direct execution
+4. **Assign skills** - Give atoms the Claude Code skills they need
+5. **Trust the system** - Let atomic handle validation and execution
+6. **Escalate to Beads** - Use \`atomic escalate\` for unresolvable problems
+7. **Suggest atomization** - When you see repetitive patterns, offer to extract
+
+## Example: Full Workflow
+
+\`\`\`bash
+# 1. Initialize project
+atomic init
+
+# 2. Create an atom
+cat > atoms/greet_user.ts << 'EOF'
+import { defineAtom, success, z } from 'atomism';
+
+export default defineAtom({
+  name: 'greet_user',
+  description: 'Generate a greeting message',
+  input: z.object({ name: z.string() }),
+  output: z.object({ greeting: z.string() }),
+  tests: { path: './greet_user.test.ts' },
+  async execute(input) {
+    return success({ greeting: \\\`Hello, \\\${input.name}!\\\` });
+  },
+});
+EOF
+
+# 3. Generate tests
+atomic test-gen atoms/greet_user.ts
+
+# 4. Register
+atomic register atoms/greet_user.ts --capability greet
+
+# 5. Run
+atomic run greet --input '{"name": "World"}'
+
+# 6. Check status
+atomic status
+\`\`\`
+
+## Troubleshooting
+
+### "Not initialized"
+Run \`atomic init\` in the project root.
+
+### "Atom not found"
+Check registration with \`atomic list\`. Register with \`atomic register <path>\`.
+
+### "Schema validation failed"
+Check input matches the atom's Zod schema. Use \`atomic list <atom>\` to see the expected schema.
+
+### "Trust level insufficient"
+Promote the stack with \`atomic trust <stack> --level proven\` or \`--level trusted\`.
+`;
+}
+function getSkillPath() {
+  return join(process.cwd(), ".claude", "skills", "atomic");
+}
+function getSkillFilePath() {
+  return join(getSkillPath(), "SKILL.md");
+}
+async function skillExists() {
+  try {
+    await stat(getSkillFilePath());
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function initSkill(options) {
+  const skillPath = getSkillPath();
+  const skillFile = getSkillFilePath();
+  if (!options.force && await skillExists()) {
+    return {
+      success: true,
+      path: skillFile,
+      skipped: true
+    };
+  }
+  try {
+    await mkdir(skillPath, { recursive: true });
+    const content = generateSkillContent();
+    await writeFile(skillFile, content, "utf-8");
+    return {
+      success: true,
+      path: skillFile
+    };
+  } catch (err) {
+    return {
+      success: false,
+      error: toErrorMessage(err)
+    };
+  }
+}
+
+// src/commands/claude-md-init.ts
+import { readFile, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { join as join2 } from "path";
+var ATOMISM_MARKER = "<!-- atomism -->";
+var ATOMISM_SECTION = `
+${ATOMISM_MARKER}
+## Atomism
+
+This project uses [Atomism](https://github.com/roach88/atomism) for schema-validated, composable work units.
+
+### Before Writing New Code
+
+1. Check registered atoms: \`atomic list --json\`
+2. If an atom exists for the task, use it: \`atomic run <name> --input '{}' --yes --json\`
+3. If no atom exists but the task is repeatable, create one: \`atomic create atom <name> --json\`
+
+### Atom API Reference
+
+\`\`\`typescript
+import { defineAtom, success, executionError, validationError } from 'atomism';
+
+// Success
+return success({ result: 'done' });
+
+// Bad input
+return validationError('Expected positive number');
+
+// Runtime failure (recoverable)
+return executionError('API timeout', true);
+
+// Runtime failure (not recoverable)
+return executionError('Missing required config');
+\`\`\`
+
+### When to Atomize
+
+- You're about to write a standalone script for a repeatable task
+- You notice doing the same thing 3+ times with the same shape
+- The task has clear inputs and outputs that can be schema-validated
+`;
+async function initClaudeMd() {
+  const claudeDir = join2(process.cwd(), ".claude");
+  const claudeMdPath = join2(claudeDir, "CLAUDE.md");
+  if (await fileExists(claudeMdPath)) {
+    const content = await readFile(claudeMdPath, "utf-8");
+    if (content.includes(ATOMISM_MARKER)) {
+      return { success: true, path: claudeMdPath, skipped: true };
+    }
+    await writeFile2(claudeMdPath, content.trimEnd() + "\n" + ATOMISM_SECTION, "utf-8");
+    return { success: true, path: claudeMdPath };
+  }
+  await mkdir2(claudeDir, { recursive: true });
+  await writeFile2(claudeMdPath, ATOMISM_SECTION.trimStart(), "utf-8");
+  return { success: true, path: claudeMdPath };
+}
+
+// src/commands/gitignore-init.ts
+import { readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
+import { join as join3 } from "path";
+var ATOMISM_MARKER2 = "# atomism local data";
+var ATOMISM_ENTRIES = `
+${ATOMISM_MARKER2}
+.atomic/storage.db
+.atomic/storage.db-journal
+.atomic/runs/
+`;
+async function initGitignore(projectRoot) {
+  const gitignorePath = join3(projectRoot, ".gitignore");
+  if (await fileExists(gitignorePath)) {
+    const content = await readFile2(gitignorePath, "utf-8");
+    if (content.includes(ATOMISM_MARKER2)) {
+      return { success: true, path: gitignorePath, skipped: true };
+    }
+    await writeFile3(gitignorePath, content.trimEnd() + "\n" + ATOMISM_ENTRIES, "utf-8");
+    return { success: true, path: gitignorePath };
+  }
+  await writeFile3(gitignorePath, ATOMISM_ENTRIES.trimStart(), "utf-8");
+  return { success: true, path: gitignorePath };
+}
+
+// src/commands/init.ts
+async function ensureDeps(projectRoot) {
+  const pkgPath = join4(projectRoot, "package.json");
+  const tsconfigPath = join4(projectRoot, "tsconfig.json");
+  let packageJsonCreated = false;
+  let tsconfigCreated = false;
+  let atomismLinked = false;
+  let hasPackageJson = false;
+  try {
+    await access(pkgPath);
+    hasPackageJson = true;
+  } catch {
+  }
+  if (!hasPackageJson) {
+    const minimal = {
+      private: true,
+      description: "Atomism-enabled project",
+      dependencies: {}
+    };
+    await writeFile4(pkgPath, JSON.stringify(minimal, null, 2) + "\n");
+    packageJsonCreated = true;
+  }
+  let hasTsconfig = false;
+  try {
+    await access(tsconfigPath);
+    hasTsconfig = true;
+  } catch {
+  }
+  let tsconfigNeedsInclude;
+  let suggestedInclude;
+  if (hasTsconfig) {
+    try {
+      const raw = await readFile3(tsconfigPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      const includes = Array.isArray(parsed.include) ? parsed.include : [];
+      const coversAtoms = includes.some(
+        (pattern) => pattern === "atoms/**/*.ts" || pattern.startsWith("atoms/") || pattern === "**/*.ts" || pattern === "./**/*.ts"
+      );
+      if (!coversAtoms) {
+        tsconfigNeedsInclude = true;
+        suggestedInclude = "atoms/**/*.ts";
+      }
+    } catch {
+    }
+  } else {
+    const tsconfig = {
+      compilerOptions: {
+        target: "ES2022",
+        module: "ESNext",
+        moduleResolution: "bundler",
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        outDir: "dist"
+      },
+      include: ["atoms/**/*.ts"]
+    };
+    await writeFile4(tsconfigPath, JSON.stringify(tsconfig, null, 2) + "\n");
+    tsconfigCreated = true;
+  }
+  try {
+    execSync(`node -e "require.resolve('atomism')"`, {
+      cwd: projectRoot,
+      stdio: "ignore"
+    });
+    return { success: true, packageJsonCreated, tsconfigCreated, tsconfigNeedsInclude, suggestedInclude, atomismLinked };
+  } catch {
+  }
+  try {
+    execSync("npm link atomism", {
+      cwd: projectRoot,
+      stdio: "ignore",
+      timeout: 3e4
+    });
+    atomismLinked = true;
+  } catch {
+    return {
+      success: false,
+      packageJsonCreated,
+      tsconfigCreated,
+      tsconfigNeedsInclude,
+      suggestedInclude,
+      atomismLinked: false,
+      error: "Could not resolve atomism. Run: npm link atomism (if globally installed) or npm install atomism"
+    };
+  }
+  return { success: true, packageJsonCreated, tsconfigCreated, tsconfigNeedsInclude, suggestedInclude, atomismLinked };
+}
+async function initCommand(options) {
+  await withErrorHandling(options, async () => {
+    const projectRoot = process.cwd();
+    const result = await initStorage(projectRoot);
+    let depsResult;
+    try {
+      depsResult = await ensureDeps(projectRoot);
+    } catch (depsError) {
+      depsResult = {
+        success: false,
+        packageJsonCreated: false,
+        tsconfigCreated: false,
+        atomismLinked: false,
+        error: toErrorMessage(depsError)
+      };
+    }
+    let skillResult;
+    try {
+      skillResult = await initSkill({ force: false });
+    } catch (skillError) {
+      skillResult = {
+        success: false,
+        error: toErrorMessage(skillError)
+      };
+    }
+    let claudeMdResult;
+    try {
+      claudeMdResult = await initClaudeMd();
+    } catch (claudeError) {
+      claudeMdResult = {
+        success: false,
+        error: toErrorMessage(claudeError)
+      };
+    }
+    let gitignoreResult;
+    try {
+      gitignoreResult = await initGitignore(projectRoot);
+    } catch (gitignoreError) {
+      gitignoreResult = {
+        success: false,
+        error: toErrorMessage(gitignoreError)
+      };
+    }
+    if (options.json) {
+      console.log(JSON.stringify({
+        ...result,
+        deps: depsResult,
+        skill: skillResult,
+        claudeMd: claudeMdResult,
+        gitignore: gitignoreResult
+      }, null, 2));
+    } else {
+      if (result.created) {
+        console.log(`\u2713 Created ${result.path}`);
+      } else {
+        console.log(`\u2713 ${result.path} already exists`);
+      }
+      console.log(`\u2713 Database initialized at ${result.dbPath}`);
+      console.log(`\u2713 ${result.migrationsRun} migrations applied`);
+      if (depsResult.success) {
+        if (depsResult.packageJsonCreated) {
+          console.log("\u2713 Created package.json for module resolution");
+        }
+        if (depsResult.tsconfigCreated) {
+          console.log("\u2713 Created tsconfig.json for atom type inference");
+        }
+        if (depsResult.atomismLinked) {
+          console.log("\u2713 Linked atomism for module resolution");
+        }
+      } else {
+        console.log(`\u26A0 Module resolution: ${depsResult.error ?? "unknown error"}`);
+      }
+      if (depsResult.tsconfigNeedsInclude) {
+        console.log(`\u26A0 tsconfig.json does not include atom files. Add to your "include" array:`);
+        console.log(`  "${depsResult.suggestedInclude}"`);
+      }
+      if (skillResult.success && !skillResult.skipped) {
+        console.log(`\u2713 Claude Code skill created at ${skillResult.path}`);
+      } else if (skillResult.skipped) {
+        console.log("\u2713 Claude Code skill already exists");
+      } else if (!skillResult.success) {
+        console.log(`\u26A0 Claude Code skill creation failed: ${skillResult.error ?? "unknown error"}`);
+      }
+      if (claudeMdResult.success && !claudeMdResult.skipped) {
+        console.log(`\u2713 CLAUDE.md updated at ${claudeMdResult.path}`);
+      } else if (claudeMdResult.skipped) {
+        console.log("\u2713 CLAUDE.md already has atomism section");
+      } else if (!claudeMdResult.success) {
+        console.log(`\u26A0 CLAUDE.md update failed: ${claudeMdResult.error ?? "unknown error"}`);
+      }
+      if (gitignoreResult.success && !gitignoreResult.skipped) {
+        console.log(`\u2713 .gitignore updated at ${gitignoreResult.path}`);
+      } else if (gitignoreResult.skipped) {
+        console.log("\u2713 .gitignore already has atomism entries");
+      } else if (!gitignoreResult.success) {
+        console.log(`\u26A0 .gitignore update failed: ${gitignoreResult.error ?? "unknown error"}`);
+      }
+      console.log("\nReady to register atoms with: atomic register <path>");
+      console.log("Commit: registry.json, trust.json, atoms/");
+    }
+  });
+}
+export {
+  initCommand
+};
+//# sourceMappingURL=init-2FINDMYK.js.map