devtronic 1.0.0

package/dist/chunk-B6Q6YVID.js

@@ -0,0 +1,728 @@
+// src/generators/plugin.ts
+import { join as join2, dirname as dirname2 } from "path";
+
+// src/types.ts
+var ADDONS = {
+  orchestration: {
+    name: "orchestration",
+    label: "Orchestration Workflow",
+    description: "Structured pre-planning alignment, session recaps, and context rotation for long multi-session work.",
+    skills: ["briefing", "recap", "handoff"],
+    agents: []
+  }
+};
+var PRESETS = {
+  "nextjs-clean": {
+    name: "nextjs-clean",
+    description: "Next.js with Clean Architecture",
+    config: {
+      framework: "nextjs",
+      architecture: "clean",
+      layers: ["domain", "application", "infrastructure", "presentation"],
+      stateManagement: ["Zustand"],
+      dataFetching: ["React Query"],
+      ui: ["Tailwind CSS"],
+      validation: ["Zod"]
+    }
+  },
+  "react-clean": {
+    name: "react-clean",
+    description: "React (Vite) with Clean Architecture",
+    config: {
+      framework: "react",
+      architecture: "clean",
+      layers: ["domain", "application", "infrastructure", "presentation"],
+      stateManagement: ["Zustand"],
+      dataFetching: ["React Query"],
+      ui: ["Tailwind CSS"]
+    }
+  },
+  monorepo: {
+    name: "monorepo",
+    description: "Monorepo with Clean Architecture per app",
+    config: {
+      architecture: "clean",
+      layers: ["apps", "packages", "libs"]
+    }
+  },
+  "feature-based": {
+    name: "feature-based",
+    description: "Feature-based architecture (co-located modules)",
+    config: {
+      architecture: "feature-based",
+      layers: ["features", "shared"]
+    }
+  },
+  minimal: {
+    name: "minimal",
+    description: "Quality checks only, no architecture rules",
+    config: {
+      architecture: "none",
+      layers: []
+    }
+  }
+};
+
+// src/utils/files.ts
+import { createHash } from "crypto";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, cpSync, readdirSync } from "fs";
+import { dirname, join, relative } from "path";
+var MANIFEST_DIR = ".ai-template";
+var MANIFEST_FILE = "manifest.json";
+function fileExists(path) {
+  return existsSync(path);
+}
+function readFile(path) {
+  return readFileSync(path, "utf-8");
+}
+function writeFile(path, content) {
+  const dir = dirname(path);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(path, content, "utf-8");
+}
+function ensureDir(path) {
+  if (!existsSync(path)) {
+    mkdirSync(path, { recursive: true });
+  }
+}
+function calculateChecksum(content) {
+  return createHash("md5").update(content).digest("hex");
+}
+function getManifestPath(targetDir) {
+  return join(targetDir, MANIFEST_DIR, MANIFEST_FILE);
+}
+function readManifest(targetDir) {
+  const manifestPath = getManifestPath(targetDir);
+  if (!fileExists(manifestPath)) {
+    return null;
+  }
+  try {
+    const raw = JSON.parse(readFile(manifestPath));
+    return {
+      version: raw.version ?? "unknown",
+      implantedAt: raw.implantedAt ?? "unknown",
+      selectedIDEs: raw.selectedIDEs ?? [],
+      projectConfig: raw.projectConfig,
+      files: raw.files ?? {},
+      installMode: raw.installMode,
+      pluginPath: raw.pluginPath
+    };
+  } catch {
+    return null;
+  }
+}
+function writeManifest(targetDir, manifest) {
+  const manifestPath = getManifestPath(targetDir);
+  ensureDir(dirname(manifestPath));
+  writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+}
+function getAllFilesRecursive(dir, baseDir = dir) {
+  const files = [];
+  if (!existsSync(dir)) {
+    return files;
+  }
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...getAllFilesRecursive(fullPath, baseDir));
+    } else {
+      files.push(relative(baseDir, fullPath));
+    }
+  }
+  return files;
+}
+function createManifestEntry(content) {
+  const checksum = calculateChecksum(content);
+  return {
+    checksum,
+    modified: false,
+    originalChecksum: checksum
+  };
+}
+function getSubdirectories(dir) {
+  if (!existsSync(dir)) {
+    return [];
+  }
+  return readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+}
+
+// src/generators/hooks.ts
+function generateHooks(config, packageManager) {
+  const lintFixCmd = buildLintFixCommand(packageManager, config);
+  const hooksConfig = {
+    description: "r-bart devtronic \u2014 workflow hooks",
+    hooks: {
+      SessionStart: [
+        {
+          matcher: "startup",
+          hooks: [
+            {
+              type: "prompt",
+              prompt: "Quick project orientation: First check if thoughts/STATE.md exists \u2014 if so, read it and summarize the current project state. Then check git status, recent commits, and any in-progress work. Give a 3-line summary prioritizing STATE.md context if available.\n\nContext: $ARGUMENTS",
+              model: "haiku",
+              timeout: 30
+            }
+          ]
+        }
+      ],
+      // Synchronous lint-fix: must complete before Claude reads the file again
+      PostToolUse: [
+        {
+          matcher: "Write|Edit",
+          hooks: [
+            {
+              type: "command",
+              command: `${lintFixCmd} 2>/dev/null || true`,
+              timeout: 30,
+              statusMessage: "Auto-linting..."
+            }
+          ]
+        }
+      ],
+      Stop: [
+        {
+          hooks: [
+            {
+              type: "command",
+              command: "${CLAUDE_PLUGIN_ROOT}/scripts/stop-guard.sh",
+              timeout: 60,
+              statusMessage: "Running quality checks..."
+            },
+            {
+              type: "prompt",
+              prompt: 'If thoughts/plans/ contains a recent plan with a "Done Criteria" section, quickly check: are there unmet criteria? If yes, list them as a brief reminder. Do NOT run a full review. If no plan or all criteria met, say nothing.',
+              model: "haiku",
+              timeout: 15,
+              statusMessage: "Checking done criteria..."
+            }
+          ]
+        }
+      ],
+      SubagentStop: [
+        {
+          hooks: [
+            {
+              type: "prompt",
+              prompt: [
+                "A subagent has finished. Based on the metadata below, assess if it completed successfully.",
+                "Consider the agent type and whether the session ended normally.",
+                'Respond with {"ok": true} if it appears complete, or {"ok": false, "reason": "..."} if something seems off.',
+                "",
+                'IMPORTANT: If stop_hook_active is true, always respond {"ok": true} to prevent infinite loops.',
+                "",
+                "Context: $ARGUMENTS"
+              ].join("\n"),
+              model: "haiku",
+              timeout: 30
+            }
+          ]
+        }
+      ],
+      PreCompact: [
+        {
+          matcher: "auto",
+          hooks: [
+            {
+              type: "command",
+              command: "${CLAUDE_PLUGIN_ROOT}/scripts/checkpoint.sh",
+              timeout: 30,
+              statusMessage: "Auto-checkpoint before compaction..."
+            }
+          ]
+        }
+      ]
+    }
+  };
+  return JSON.stringify(hooksConfig, null, 2);
+}
+function buildLintFixCommand(packageManager, config) {
+  const pm = packageManager || "npm";
+  const run = pm === "npm" ? "npm run" : pm;
+  if (config.qualityCommand.includes("lint")) {
+    return `${run} lint:fix -- --quiet`;
+  }
+  return `${run} lint --fix --quiet`;
+}
+function generateStopGuardScript(config) {
+  const safeCmd = config.qualityCommand.replace(/'/g, "'\\''");
+  return `#!/bin/bash
+# Quality gate: runs checks before allowing Claude to stop
+# Generated by devtronic
+
+INPUT=$(cat)
+
+# Prevent infinite loops: if already triggered by a stop hook, allow stop
+if echo "$INPUT" | grep -q '"stop_hook_active"'; then
+  if echo "$INPUT" | grep -q '"stop_hook_active"[[:space:]]*:[[:space:]]*true'; then
+    exit 0
+  fi
+fi
+
+# Run quality checks
+QUALITY_CMD='${safeCmd}'
+if ! eval "$QUALITY_CMD" > /dev/null 2>&1; then
+  echo "Quality checks failed. Run '$QUALITY_CMD' to see details." >&2
+  exit 2
+fi
+
+exit 0
+`;
+}
+function generateCheckpointScript() {
+  return `#!/bin/bash
+# Auto-checkpoint before context compaction
+# Generated by devtronic
+
+CHECKPOINT_DIR="thoughts/checkpoints"
+TIMESTAMP=$(date +%Y%m%d_%H%M%S)
+
+mkdir -p "$CHECKPOINT_DIR"
+
+{
+  echo "# Auto-checkpoint: $TIMESTAMP"
+  echo ""
+  echo "## Git Status"
+  git diff --stat 2>/dev/null || echo "Not a git repo"
+  echo ""
+  echo "## Recent Commits"
+  git log --oneline -5 2>/dev/null || echo "No commits"
+} > "$CHECKPOINT_DIR/\${TIMESTAMP}_pre-compact.md"
+
+echo "Checkpoint saved: $CHECKPOINT_DIR/\${TIMESTAMP}_pre-compact.md"
+
+# Update persistent state (minimal \u2014 skill-level checkpoint writes richer state)
+STATE_FILE="thoughts/STATE.md"
+mkdir -p "$(dirname "$STATE_FILE")"
+BRANCH=$(git branch --show-current 2>/dev/null || echo "unknown")
+{
+  echo "# Project State"
+  echo ""
+  echo "**Updated**: $(date '+%Y-%m-%d %H:%M') (auto-compact)"
+  echo "**Branch**: $BRANCH"
+  echo ""
+  echo "## Last Auto-Checkpoint"
+  echo ""
+  echo "Context was compacted. See: \\\`$CHECKPOINT_DIR/\${TIMESTAMP}_pre-compact.md\\\`"
+  echo ""
+  echo "## Recent Commits"
+  echo ""
+  git log --oneline -5 2>/dev/null || echo "No commits"
+} > "$STATE_FILE"
+`;
+}
+
+// src/generators/rules.ts
+function getFrameworkDisplayName(framework) {
+  const names = {
+    nextjs: "Next.js",
+    react: "React",
+    vue: "Vue",
+    nuxt: "Nuxt",
+    express: "Express",
+    nestjs: "NestJS",
+    fastify: "Fastify",
+    hono: "Hono",
+    astro: "Astro",
+    svelte: "Svelte",
+    sveltekit: "SvelteKit",
+    remix: "Remix",
+    unknown: "Project"
+  };
+  return names[framework] || "Project";
+}
+function getArchitectureLabel(architecture) {
+  const labels = {
+    clean: "Clean + DDD",
+    layered: "Layered",
+    mvc: "MVC",
+    "feature-based": "Feature-Based",
+    flat: "Flat",
+    none: "None"
+  };
+  return labels[architecture] || architecture;
+}
+function getArchitectureOneLiner(config) {
+  if (config.architecture === "clean") {
+    return "Dependencies point INWARD only: Presentation \u2192 Application \u2192 Domain \u2190 Infrastructure.";
+  }
+  if (config.architecture === "layered") {
+    return "Layered: Routes/Controllers \u2192 Services \u2192 Repositories. Each layer calls only the one below.";
+  }
+  if (config.architecture === "mvc") {
+    return "Model-View-Controller: Models hold data/logic, Views handle UI, Controllers orchestrate.";
+  }
+  if (config.architecture === "feature-based") {
+    return "Each feature is self-contained with its own components, hooks, API calls, and types.";
+  }
+  if (config.architecture === "none") {
+    return "No architecture rules configured. Run `devtronic config set architecture clean` to add rules later.";
+  }
+  return "Document your architecture patterns.";
+}
+function getCodePatternsBullets(config) {
+  const lines = [];
+  if (config.stateManagement.length > 0) {
+    lines.push(`- **UI state**: ${config.stateManagement.join(", ")}`);
+  }
+  if (config.dataFetching.length > 0) {
+    lines.push(`- **Server state**: ${config.dataFetching.join(", ")}`);
+  }
+  if (config.architecture === "clean") {
+    lines.push("- **Domain state**: Use cases");
+  }
+  if (config.architecture === "layered") {
+    lines.push("- **Business logic**: Services layer");
+  }
+  if (config.orm.length > 0) {
+    lines.push(`- **ORM**: ${config.orm.join(", ")}`);
+    if (config.architecture === "clean") {
+      lines.push("- Repository interfaces in `domain/`, implementations in `infrastructure/`");
+    }
+    if (config.architecture === "layered") {
+      lines.push("- Database access only in `repositories/`");
+    }
+  }
+  lines.push("- Never access DB from UI");
+  return lines.join("\n");
+}
+function getCommandsBlock(scripts, packageManager, qualityCommand) {
+  const pm = packageManager || "npm";
+  const run = pm === "npm" ? "npm run" : pm;
+  const devCmd = scripts.dev ? `\`${run} ${scripts.dev}\`` : "`# Add your dev command`";
+  const buildCmd = scripts.build ? `\`${run} ${scripts.build}\`` : "`# Add your build command`";
+  return `- **Dev**: ${devCmd}
+- **Build**: ${buildCmd}
+- **Quality**: \`${qualityCommand}\``;
+}
+function generateQualityCommands(scripts, packageManager) {
+  const pm = packageManager || "npm";
+  const run = pm === "npm" ? "npm run" : pm;
+  const commands = [];
+  if (scripts.typecheck) {
+    commands.push(`${run} ${scripts.typecheck}`);
+  }
+  if (scripts.lint) {
+    commands.push(`${run} ${scripts.lint}`);
+  }
+  if (scripts.test) {
+    commands.push(`${run} ${scripts.test}`);
+  }
+  if (commands.length === 0) {
+    return "# No quality scripts detected - add your commands here";
+  }
+  return commands.join(" && ");
+}
+function generateClaudeMd(config, scripts, packageManager) {
+  const frameworkName = getFrameworkDisplayName(config.framework);
+  const archLabel = getArchitectureLabel(config.architecture);
+  const archOneLiner = getArchitectureOneLiner(config);
+  const codePatterns = getCodePatternsBullets(config);
+  const commands = getCommandsBlock(scripts, packageManager, config.qualityCommand);
+  const skillsSection = generateSkillsSection(config.enabledAddons);
+  const archSection = config.architecture === "none" ? `## Architecture
+
+${archOneLiner}` : `## Architecture
+
+${archOneLiner}
+
+IMPORTANT: See \`docs/ARCHITECTURE.md\` for structure. See \`.claude/rules/\` for enforcement rules.`;
+  const workflowSection = config.enabledAddons?.includes("orchestration") ? `## Workflow
+
+- **New feature**: \`/briefing\` \u2192 \`/spec\` \u2192 \`/create-plan\` \u2192 \`/generate-tests\` \u2192 \`/execute-plan\` \u2192 \`/recap\`
+- **Bug fix**: \`/brief\` \u2192 fix \u2192 test \u2192 \`/summary\` \u2192 \`/post-review\`
+- **Refactor**: \`/brief\` \u2192 \`/create-plan\` \u2192 \`/execute-plan\` \u2192 \`/summary\` \u2192 \`/post-review\`
+- **Session start**: \`/brief\` for orientation
+- **Session end**: \`/handoff\` for clean context rotation
+
+> \`/briefing\` for pre-planning alignment. \`/recap\` for quick summaries. \`/checkpoint\` to save progress.` : `## Workflow
+
+- **New feature**: \`/brief\` \u2192 \`/spec\` \u2192 \`/create-plan\` \u2192 \`/generate-tests\` \u2192 \`/execute-plan\` \u2192 \`/summary\` \u2192 \`/post-review\`
+- **Bug fix**: \`/brief\` \u2192 fix \u2192 test \u2192 \`/summary\` \u2192 \`/post-review\`
+- **Refactor**: \`/brief\` \u2192 \`/create-plan\` \u2192 implement \u2192 \`/summary\` \u2192 \`/post-review\`
+
+> \`/brief\` for session orientation (with pre-flight checks). \`/summary\` to document changes. \`/checkpoint\` to save progress.`;
+  return `# ${frameworkName}
+
+${frameworkName} project${config.architecture !== "none" ? ` with ${archLabel} architecture` : ""}.
+
+## Commands
+
+${commands}
+
+Run quality checks after every change.
+
+## Code Style
+
+- **Files**: PascalCase components, camelCase utils
+- **Code**: camelCase vars/functions, PascalCase types
+- **Unused**: Prefix with \`_\`
+
+## Code Patterns
+
+${codePatterns}
+
+${archSection}
+
+${workflowSection}
+
+## Available Skills
+
+${skillsSection}
+
+## Project Notes
+
+Maintain notes in \`thoughts/notes/\` updated after every PR.
+
+## Gotchas
+
+<!-- Claude fills this section via self-improvement. Do not delete. -->
+
+## Self-Improvement
+
+After every significant correction, update this file:
+
+"Update CLAUDE.md so you don't make that mistake again."
+
+Add learned rules to the **Gotchas** section above. Keep rules:
+- Concise (one line each)
+- Absolute directives (ALWAYS/NEVER)
+- Concrete with actual commands/code
+
+## References
+
+- **docs/ARCHITECTURE.md** \u2014 Folder structure
+- **docs/worktrees.md** \u2014 Parallel sessions with git worktrees
+- **.claude/skills/** \u2014 Available workflows
+- **.claude/agents/** \u2014 Specialized helpers
+`;
+}
+function generateAgentsMdFromConfig(config, scripts, packageManager) {
+  const frameworkName = getFrameworkDisplayName(config.framework);
+  const archLabel = getArchitectureLabel(config.architecture);
+  const archOneLiner = getArchitectureOneLiner(config);
+  const codePatterns = getCodePatternsBullets(config);
+  const commands = getCommandsBlock(scripts, packageManager, config.qualityCommand);
+  const agentsArchSection = config.architecture === "none" ? `## Architecture
+
+${archOneLiner}` : `## Architecture
+
+${archOneLiner} See \`docs/ARCHITECTURE.md\` for detailed structure.`;
+  const skillsSection = generateSkillsSection(config.enabledAddons);
+  const workflowSection = config.enabledAddons?.includes("orchestration") ? `## Workflow
+
+- **New feature**: \`/briefing\` \u2192 \`/spec\` \u2192 \`/create-plan\` \u2192 \`/generate-tests\` \u2192 \`/execute-plan\` \u2192 \`/recap\`
+- **Bug fix**: \`/brief\` \u2192 fix \u2192 test \u2192 \`/summary\`
+- **Session start**: \`/brief\` for orientation
+- **Session end**: \`/handoff\` for clean context rotation` : `## Workflow
+
+- **New feature**: \`/brief\` \u2192 \`/spec\` \u2192 \`/create-plan\` \u2192 \`/generate-tests\` \u2192 \`/execute-plan\` \u2192 \`/summary\` \u2192 \`/post-review\`
+- **Bug fix**: \`/brief\` \u2192 fix \u2192 test \u2192 \`/summary\``;
+  return `# ${frameworkName}
+
+${frameworkName} project${config.architecture !== "none" ? ` with ${archLabel} architecture` : ""}.
+
+## Commands
+
+${commands}
+
+Run quality checks after every change.
+
+## Code Style
+
+- **Files**: PascalCase components, camelCase utils
+- **Code**: camelCase vars/functions, PascalCase types
+- **Unused**: Prefix with \`_\`
+
+## Code Patterns
+
+${codePatterns}
+
+${agentsArchSection}
+
+${workflowSection}
+
+## Available Skills
+
+${skillsSection}
+`;
+}
+var CORE_SKILLS = [
+  { name: "brief", desc: "Session orientation with pre-flight checks" },
+  { name: "spec", desc: "Product specification interview (PRD)" },
+  { name: "research", desc: "Codebase investigation (--deep, --external)" },
+  { name: "create-plan", desc: "Phased implementation plan with task dependencies" },
+  { name: "execute-plan", desc: "Parallel phase execution of plans" },
+  { name: "quick", desc: "Fast ad-hoc tasks: implement, verify, commit" },
+  { name: "generate-tests", desc: "Failing tests from spec (Tests-as-DoD)" },
+  { name: "post-review", desc: "Pre-PR review (architecture, quality, requirements)" },
+  { name: "audit", desc: "Codebase audit (security, complexity, architecture)" },
+  { name: "summary", desc: "Post-change documentation" },
+  { name: "checkpoint", desc: "Save session progress for resumption" },
+  { name: "backlog", desc: "Issue management with BACK-### IDs" },
+  { name: "investigate", desc: "Deep error and bug analysis" },
+  { name: "learn", desc: "Post-task teaching breakdown" },
+  { name: "scaffold", desc: "Create new projects from scratch" },
+  { name: "setup", desc: "Interactive project configuration" },
+  { name: "worktree", desc: "Git worktree management" },
+  { name: "opensrc", desc: "Fetch npm/GitHub source for full context" },
+  { name: "create-skill", desc: "Generate new custom skills" }
+];
+var ADDON_SKILLS = {
+  orchestration: [
+    { name: "briefing", desc: "Pre-planning alignment Q&A" },
+    { name: "recap", desc: "Quick session summary from git activity" },
+    { name: "handoff", desc: "Context rotation for fresh sessions" }
+  ]
+};
+function generateSkillsSection(enabledAddons) {
+  const lines = CORE_SKILLS.map((s) => `- \`/${s.name}\` \u2014 ${s.desc}`);
+  const addons = enabledAddons || [];
+  for (const addon of addons) {
+    const addonSkills = ADDON_SKILLS[addon];
+    if (addonSkills) {
+      for (const s of addonSkills) {
+        lines.push(`- \`/${s.name}\` \u2014 ${s.desc}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/generators/plugin.ts
+var PLUGIN_NAME = "devtronic";
+var MARKETPLACE_NAME = "devtronic-local";
+var PLUGIN_DIR = ".claude-plugins";
+var BASE_SKILL_COUNT = CORE_SKILLS.length;
+function generatePluginJson(cliVersion, addonSkillCount = 0) {
+  const skillLabel = addonSkillCount > 0 ? `${BASE_SKILL_COUNT} + ${addonSkillCount} addon skills` : `${BASE_SKILL_COUNT} skills`;
+  return JSON.stringify(
+    {
+      name: PLUGIN_NAME,
+      version: cliVersion,
+      description: `devtronic \u2014 ${skillLabel}, 8 agents, full workflow hooks`,
+      author: {
+        name: "r-bart",
+        url: "https://github.com/r-bart/devtronic"
+      },
+      repository: "https://github.com/r-bart/devtronic",
+      license: "MIT",
+      keywords: ["agentic", "architecture", "clean-architecture", "ddd", "workflow", "skills"],
+      skills: "./skills/",
+      agents: "./agents/",
+      hooks: "./hooks/hooks.json"
+    },
+    null,
+    2
+  );
+}
+function generateMarketplaceJson(addonSkillCount = 0) {
+  const skillLabel = addonSkillCount > 0 ? `${BASE_SKILL_COUNT} + ${addonSkillCount} addon skills` : `${BASE_SKILL_COUNT} skills`;
+  return JSON.stringify(
+    {
+      name: MARKETPLACE_NAME,
+      owner: {
+        name: "r-bart",
+        url: "https://github.com/r-bart/devtronic"
+      },
+      plugins: [
+        {
+          name: PLUGIN_NAME,
+          source: `./${PLUGIN_NAME}`,
+          description: `devtronic \u2014 ${skillLabel}, 8 agents, full workflow hooks`
+        }
+      ]
+    },
+    null,
+    2
+  );
+}
+function generatePlugin(targetDir, templatesDir, cliVersion, config, packageManager) {
+  const files = {};
+  const pluginRoot = join2(PLUGIN_DIR, PLUGIN_NAME);
+  const addonOnlySkills = new Set(
+    Object.values(ADDONS).flatMap((a) => a.skills)
+  );
+  const enabledAddonSkills = new Set(
+    (config.enabledAddons || []).flatMap((a) => ADDONS[a]?.skills ?? [])
+  );
+  const addonSkillCount = enabledAddonSkills.size;
+  const marketplaceContent = generateMarketplaceJson(addonSkillCount);
+  const marketplaceRelPath = join2(PLUGIN_DIR, ".claude-plugin", "marketplace.json");
+  writeGeneratedFile(targetDir, marketplaceRelPath, marketplaceContent, files);
+  const pluginJsonContent = generatePluginJson(cliVersion, addonSkillCount);
+  const pluginJsonRelPath = join2(pluginRoot, ".claude-plugin", "plugin.json");
+  writeGeneratedFile(targetDir, pluginJsonRelPath, pluginJsonContent, files);
+  const templateClaudeDir = join2(templatesDir, "claude-code", ".claude");
+  const skillsSourceDir = join2(templateClaudeDir, "skills");
+  const skillDirs = getSubdirectories(skillsSourceDir);
+  for (const dir of skillDirs) {
+    const isAddonSkill = addonOnlySkills.has(dir);
+    if (!isAddonSkill || enabledAddonSkills.has(dir)) {
+      copyTemplateDir(
+        targetDir,
+        join2(skillsSourceDir, dir),
+        join2(pluginRoot, "skills", dir),
+        files
+      );
+    }
+  }
+  copyTemplateDir(targetDir, join2(templateClaudeDir, "agents"), join2(pluginRoot, "agents"), files);
+  const hooksContent = generateHooks(config, packageManager);
+  const hooksRelPath = join2(pluginRoot, "hooks", "hooks.json");
+  writeGeneratedFile(targetDir, hooksRelPath, hooksContent, files);
+  const scriptContent = generateCheckpointScript();
+  const scriptRelPath = join2(pluginRoot, "scripts", "checkpoint.sh");
+  writeGeneratedFile(targetDir, scriptRelPath, scriptContent, files);
+  const stopGuardContent = generateStopGuardScript(config);
+  const stopGuardRelPath = join2(pluginRoot, "scripts", "stop-guard.sh");
+  writeGeneratedFile(targetDir, stopGuardRelPath, stopGuardContent, files);
+  return { files, pluginPath: pluginRoot };
+}
+function writeGeneratedFile(targetDir, relPath, content, files) {
+  const absPath = join2(targetDir, relPath);
+  ensureDir(dirname2(absPath));
+  writeFile(absPath, content);
+  files[relPath] = createManifestEntry(content);
+}
+function copyTemplateDir(targetDir, sourceDir, destRelDir, files) {
+  const templateFiles = getAllFilesRecursive(sourceDir);
+  if (templateFiles.length === 0) {
+    throw new Error(`No template files found in ${sourceDir}. The CLI package may be corrupted.`);
+  }
+  for (const file of templateFiles) {
+    const sourceContent = readFile(join2(sourceDir, file));
+    const destRelPath = join2(destRelDir, file);
+    const destAbsPath = join2(targetDir, destRelPath);
+    ensureDir(dirname2(destAbsPath));
+    writeFile(destAbsPath, sourceContent);
+    files[destRelPath] = createManifestEntry(sourceContent);
+  }
+}
+
+export {
+  ADDONS,
+  PRESETS,
+  MANIFEST_DIR,
+  fileExists,
+  readFile,
+  writeFile,
+  ensureDir,
+  calculateChecksum,
+  readManifest,
+  writeManifest,
+  getAllFilesRecursive,
+  createManifestEntry,
+  generateQualityCommands,
+  generateClaudeMd,
+  generateAgentsMdFromConfig,
+  PLUGIN_NAME,
+  MARKETPLACE_NAME,
+  PLUGIN_DIR,
+  BASE_SKILL_COUNT,
+  generatePluginJson,
+  generateMarketplaceJson,
+  generatePlugin
+};