@claude-collective/cli 0.2.0 → 0.8.0

package/dist/commands/init.js

@@ -0,0 +1,915 @@
+#!/usr/bin/env node
+import {
+  claudePluginInstall,
+  claudePluginMarketplaceAdd,
+  claudePluginMarketplaceExists,
+  isClaudeCLIAvailable
+} from "../chunk-M7YCPFIX.js";
+import {
+  copySkillsToLocalFlattened
+} from "../chunk-G2FBJOZG.js";
+import {
+  Wizard
+} from "../chunk-ED73HCW2.js";
+import "../chunk-A65SBAAJ.js";
+import "../chunk-HNDT5QRB.js";
+import "../chunk-ALEPJ6YN.js";
+import "../chunk-XKEG3SCV.js";
+import "../chunk-Q6DR5QUH.js";
+import "../chunk-LVKRVFYR.js";
+import "../chunk-UOWHJ6BE.js";
+import "../chunk-Y3V43XCU.js";
+import "../chunk-PPNTD5LO.js";
+import "../chunk-K7PTOVX4.js";
+import {
+  compileAgentForPlugin,
+  compileStackPlugin
+} from "../chunk-Q2LH2DAB.js";
+import "../chunk-LQTST4WY.js";
+import "../chunk-MJSFR562.js";
+import {
+  createLiquidEngine,
+  resolveAgentSkillsFromStack,
+  resolveAgents,
+  resolveStackSkills
+} from "../chunk-SEBPPFUW.js";
+import {
+  getCollectivePluginDir
+} from "../chunk-3HBTELJN.js";
+import {
+  loadSkillsMatrixFromSource
+} from "../chunk-DKGL77IY.js";
+import {
+  loadAllAgents,
+  loadStackById
+} from "../chunk-QGGSLMO3.js";
+import "../chunk-NGBFJJ7Q.js";
+import {
+  formatSourceOrigin
+} from "../chunk-QESUUPOE.js";
+import {
+  LOCAL_SKILLS_PATH,
+  PROJECT_ROOT
+} from "../chunk-A3J6IAXK.js";
+import {
+  BaseCommand,
+  EXIT_CODES
+} from "../chunk-SYQ7R2JO.js";
+import {
+  verbose
+} from "../chunk-TOPAIL5W.js";
+import {
+  directoryExists,
+  ensureDir,
+  fileExists,
+  readFile,
+  remove,
+  writeFile
+} from "../chunk-MMDXNZPF.js";
+import {
+  init_esm_shims
+} from "../chunk-DHET7RCE.js";
+
+// src/cli-v2/commands/init.tsx
+init_esm_shims();
+import { Flags } from "@oclif/core";
+import { render } from "ink";
+import path3 from "path";
+import { stringify as stringifyYaml } from "yaml";
+
+// src/cli-v2/lib/permission-checker.tsx
+init_esm_shims();
+import path from "path";
+import { Text, Box } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+async function checkPermissions(projectRoot) {
+  const settingsPath = path.join(projectRoot, ".claude", "settings.json");
+  const localSettingsPath = path.join(
+    projectRoot,
+    ".claude",
+    "settings.local.json"
+  );
+  let permissions;
+  for (const filePath of [localSettingsPath, settingsPath]) {
+    if (await fileExists(filePath)) {
+      try {
+        const content = await readFile(filePath);
+        const parsed = JSON.parse(content);
+        if (parsed.permissions) {
+          permissions = parsed.permissions;
+          break;
+        }
+      } catch {
+      }
+    }
+  }
+  if (!permissions) {
+    return /* @__PURE__ */ jsxs(
+      Box,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: "yellow",
+        padding: 1,
+        children: [
+          /* @__PURE__ */ jsx(Text, { bold: true, color: "yellow", children: "Permission Notice" }),
+          /* @__PURE__ */ jsx(Text, { children: "No permissions configured in .claude/settings.json" }),
+          /* @__PURE__ */ jsx(Text, { children: "Agents will prompt for approval on each tool use." }),
+          /* @__PURE__ */ jsx(Text, { children: " " }),
+          /* @__PURE__ */ jsx(Text, { children: "For autonomous operation, add to .claude/settings.json:" }),
+          /* @__PURE__ */ jsx(Text, { children: " " }),
+          /* @__PURE__ */ jsx(Text, { color: "dim", children: "{" }),
+          /* @__PURE__ */ jsx(Text, { color: "dim", children: '  "permissions": {' }),
+          /* @__PURE__ */ jsx(Text, { color: "dim", children: '    "allow": [' }),
+          /* @__PURE__ */ jsx(Text, { color: "dim", children: '      "Read(*)",' }),
+          /* @__PURE__ */ jsx(Text, { color: "dim", children: '      "Bash(git *)",' }),
+          /* @__PURE__ */ jsx(Text, { color: "dim", children: '      "Bash(bun *)"' }),
+          /* @__PURE__ */ jsx(Text, { color: "dim", children: "    ]" }),
+          /* @__PURE__ */ jsx(Text, { color: "dim", children: "  }" }),
+          /* @__PURE__ */ jsx(Text, { color: "dim", children: "}" })
+        ]
+      }
+    );
+  }
+  const hasRestrictiveBash = permissions.deny?.some(
+    (rule) => rule === "Bash(*)" || rule === "Bash"
+  );
+  const hasNoAllows = !permissions.allow || permissions.allow.length === 0;
+  if (hasRestrictiveBash || hasNoAllows) {
+    return /* @__PURE__ */ jsxs(
+      Box,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: "yellow",
+        padding: 1,
+        children: [
+          /* @__PURE__ */ jsx(Text, { bold: true, color: "yellow", children: "Permission Warnings" }),
+          hasRestrictiveBash && /* @__PURE__ */ jsx(Text, { children: "\u26A0 Bash is denied in permissions. Some agents require Bash for git, testing, and build commands." }),
+          hasNoAllows && /* @__PURE__ */ jsx(Text, { children: "\u26A0 No allow rules configured. Agents will prompt for each tool use." })
+        ]
+      }
+    );
+  }
+  return null;
+}
+
+// src/cli-v2/lib/stack-installer.ts
+init_esm_shims();
+import os from "os";
+import path2 from "path";
+async function compileStackToTemp(options) {
+  const tempDir = path2.join(os.tmpdir(), `cc-stack-${Date.now()}`);
+  await ensureDir(tempDir);
+  const result = await compileStackPlugin({
+    stackId: options.stackId,
+    outputDir: tempDir,
+    projectRoot: options.projectRoot,
+    agentSourcePath: options.agentSourcePath
+  });
+  return {
+    result,
+    cleanup: async () => {
+      await remove(tempDir);
+    }
+  };
+}
+async function installStackAsPlugin(options) {
+  const { stackId, projectDir, sourcePath, agentSourcePath, marketplace } = options;
+  const claudeAvailable = await isClaudeCLIAvailable();
+  if (!claudeAvailable) {
+    throw new Error(
+      "Claude CLI not found. Please install Claude Code first: https://claude.ai/code"
+    );
+  }
+  if (marketplace) {
+    verbose(`Installing from marketplace: ${stackId}@${marketplace}`);
+    const pluginRef = `${stackId}@${marketplace}`;
+    await claudePluginInstall(pluginRef, "project", projectDir);
+    return {
+      pluginName: stackId,
+      stackName: stackId,
+      agents: [],
+      skills: [],
+      pluginPath: pluginRef,
+      fromMarketplace: true
+    };
+  }
+  verbose(`Compiling stack locally: ${stackId}`);
+  const { result, cleanup } = await compileStackToTemp({
+    stackId,
+    projectRoot: sourcePath,
+    agentSourcePath
+  });
+  try {
+    await claudePluginInstall(result.pluginPath, "project", projectDir);
+    return {
+      pluginName: `stack-${stackId}`,
+      stackName: result.stackName,
+      agents: result.agents,
+      skills: result.skillPlugins,
+      pluginPath: result.pluginPath,
+      fromMarketplace: false
+    };
+  } finally {
+    await cleanup();
+  }
+}
+
+// src/cli-v2/lib/config-generator.ts
+init_esm_shims();
+
+// src/cli-v2/lib/skill-agent-mappings.ts
+init_esm_shims();
+
+// src/cli-v2/lib/defaults-loader.ts
+init_esm_shims();
+import { parse as parseYaml } from "yaml";
+var cachedDefaults = null;
+function getCachedDefaults() {
+  return cachedDefaults;
+}
+
+// src/cli-v2/lib/skill-agent-mappings.ts
+var SKILL_TO_AGENTS = {
+  "frontend/*": [
+    "web-developer",
+    "web-reviewer",
+    "web-researcher",
+    "web-pm",
+    "web-pattern-scout",
+    "web-pattern-critique",
+    "agent-summoner",
+    "skill-summoner",
+    "documentor"
+  ],
+  "backend/*": [
+    "api-developer",
+    "api-reviewer",
+    "api-researcher",
+    "web-architecture",
+    "web-pm",
+    "web-pattern-scout",
+    "web-pattern-critique",
+    "agent-summoner",
+    "skill-summoner",
+    "documentor"
+  ],
+  "mobile/*": [
+    "web-developer",
+    "web-reviewer",
+    "web-researcher",
+    "web-pm",
+    "agent-summoner",
+    "skill-summoner",
+    "documentor"
+  ],
+  "setup/*": [
+    "web-architecture",
+    "web-developer",
+    "api-developer",
+    "agent-summoner",
+    "skill-summoner",
+    "documentor"
+  ],
+  "security/*": [
+    "web-developer",
+    "api-developer",
+    "web-reviewer",
+    "api-reviewer",
+    "web-architecture",
+    "web-pm",
+    "agent-summoner",
+    "skill-summoner",
+    "documentor"
+  ],
+  "reviewing/*": [
+    "web-reviewer",
+    "api-reviewer",
+    "cli-reviewer",
+    "web-pattern-critique",
+    "agent-summoner",
+    "skill-summoner",
+    "documentor"
+  ],
+  "cli/*": [
+    "cli-developer",
+    "cli-reviewer",
+    "api-developer",
+    "api-reviewer",
+    "api-researcher",
+    "web-architecture",
+    "web-pm",
+    "agent-summoner",
+    "skill-summoner",
+    "documentor"
+  ],
+  "research/*": [
+    "web-researcher",
+    "api-researcher",
+    "web-pm",
+    "web-pattern-scout",
+    "web-pattern-critique",
+    "documentor",
+    "agent-summoner",
+    "skill-summoner"
+  ],
+  "methodology/*": [
+    "web-developer",
+    "api-developer",
+    "web-reviewer",
+    "api-reviewer",
+    "web-researcher",
+    "api-researcher",
+    "web-tester",
+    "web-pm",
+    "web-architecture",
+    "web-pattern-scout",
+    "web-pattern-critique",
+    "agent-summoner",
+    "skill-summoner",
+    "documentor"
+  ],
+  "frontend/testing": ["web-tester", "web-developer", "web-reviewer"],
+  "backend/testing": ["web-tester", "api-developer", "api-reviewer"],
+  "frontend/mocks": ["web-tester", "web-developer", "web-reviewer"]
+};
+var PRELOADED_SKILLS = {
+  "web-developer": ["framework", "styling"],
+  "api-developer": ["api", "database", "cli"],
+  "cli-developer": ["cli"],
+  "web-reviewer": ["framework", "styling", "reviewing"],
+  "api-reviewer": ["api", "database", "reviewing"],
+  "cli-reviewer": ["cli", "reviewing", "cli-reviewing"],
+  "web-researcher": ["framework", "research-methodology"],
+  "api-researcher": ["api", "research-methodology"],
+  "web-tester": ["testing", "mocks"],
+  "web-architecture": ["monorepo", "turborepo", "cli"],
+  "web-pm": ["research-methodology"],
+  "web-pattern-scout": ["research-methodology"],
+  "web-pattern-critique": ["research-methodology", "reviewing"],
+  documentor: ["research-methodology"],
+  "agent-summoner": [],
+  "skill-summoner": []
+};
+var SUBCATEGORY_ALIASES = {
+  framework: "frontend/framework",
+  styling: "frontend/styling",
+  api: "backend/api",
+  database: "backend/database",
+  mocks: "frontend/mocks",
+  testing: "testing",
+  reviewing: "reviewing",
+  "research-methodology": "research/research-methodology",
+  monorepo: "setup/monorepo",
+  cli: "cli"
+};
+var DEFAULT_AGENTS = ["agent-summoner", "skill-summoner", "documentor"];
+function getEffectiveSkillToAgents() {
+  const defaults = getCachedDefaults();
+  if (defaults?.skill_to_agents) {
+    return defaults.skill_to_agents;
+  }
+  return SKILL_TO_AGENTS;
+}
+function getEffectivePreloadedSkills(projectConfig) {
+  if (projectConfig?.preload_patterns) {
+    return projectConfig.preload_patterns;
+  }
+  const defaults = getCachedDefaults();
+  if (defaults?.preloaded_skills) {
+    return defaults.preloaded_skills;
+  }
+  return PRELOADED_SKILLS;
+}
+function getEffectiveSubcategoryAliases() {
+  const defaults = getCachedDefaults();
+  if (defaults?.subcategory_aliases) {
+    return defaults.subcategory_aliases;
+  }
+  return SUBCATEGORY_ALIASES;
+}
+function getAgentsForSkill(skillPath, category, projectConfig) {
+  const normalizedPath = skillPath.replace(/^skills\//, "").replace(/\/$/, "");
+  const skillToAgents = getEffectiveSkillToAgents();
+  if (skillToAgents[category]) {
+    return skillToAgents[category];
+  }
+  for (const [pattern, agents] of Object.entries(skillToAgents)) {
+    if (normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`)) {
+      return agents;
+    }
+  }
+  for (const [pattern, agents] of Object.entries(skillToAgents)) {
+    if (pattern.endsWith("/*")) {
+      const prefix = pattern.slice(0, -2);
+      if (normalizedPath.startsWith(prefix)) {
+        return agents;
+      }
+    }
+  }
+  return DEFAULT_AGENTS;
+}
+function shouldPreloadSkill(skillPath, skillId, category, agentId, projectConfig) {
+  const preloadedSkills = getEffectivePreloadedSkills(projectConfig);
+  const preloadedPatterns = preloadedSkills[agentId];
+  if (!preloadedPatterns || preloadedPatterns.length === 0) {
+    return false;
+  }
+  const normalizedPath = skillPath.replace(/^skills\//, "").replace(/\/$/, "");
+  const subcategoryAliases = getEffectiveSubcategoryAliases();
+  for (const pattern of preloadedPatterns) {
+    if (category === pattern) {
+      return true;
+    }
+    if (normalizedPath.includes(pattern)) {
+      return true;
+    }
+    if (skillId.toLowerCase().includes(pattern.toLowerCase())) {
+      return true;
+    }
+    const aliasedPath = subcategoryAliases[pattern];
+    if (aliasedPath && normalizedPath.includes(aliasedPath)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/cli-v2/lib/config-generator.ts
+function generateProjectConfigFromSkills(name, selectedSkillIds, matrix, options) {
+  const neededAgents = /* @__PURE__ */ new Set();
+  for (const skillId of selectedSkillIds) {
+    const skill = matrix.skills[skillId];
+    if (!skill) {
+      continue;
+    }
+    const skillPath = skill.path;
+    const category = skill.category;
+    const agents = getAgentsForSkill(skillPath, category);
+    for (const agentId of agents) {
+      neededAgents.add(agentId);
+    }
+  }
+  const skills = selectedSkillIds.map((id) => {
+    const skill = matrix.skills[id];
+    if (skill?.local && skill?.localPath) {
+      return {
+        id,
+        local: true,
+        path: skill.localPath
+      };
+    }
+    return id;
+  });
+  const config = {
+    name,
+    agents: Array.from(neededAgents).sort()
+  };
+  if (skills.length > 0) {
+    config.skills = skills;
+  }
+  if (options?.description) {
+    config.description = options.description;
+  }
+  if (options?.framework) {
+    config.framework = options.framework;
+  }
+  if (options?.author) {
+    config.author = options.author;
+  }
+  if (options?.includeAgentSkills) {
+    const agentSkills = buildAgentSkills(
+      selectedSkillIds,
+      matrix,
+      neededAgents
+    );
+    if (Object.keys(agentSkills).length > 0) {
+      config.agent_skills = agentSkills;
+    }
+  }
+  return config;
+}
+function buildAgentSkills(selectedSkillIds, matrix, neededAgents) {
+  const agentSkills = {};
+  for (const skillId of selectedSkillIds) {
+    const skill = matrix.skills[skillId];
+    if (!skill) {
+      continue;
+    }
+    const skillPath = skill.path;
+    const category = skill.category;
+    const agents = getAgentsForSkill(skillPath, category);
+    for (const agentId of agents) {
+      if (!neededAgents.has(agentId)) continue;
+      if (!agentSkills[agentId]) {
+        agentSkills[agentId] = [];
+      }
+      const isPreloaded = shouldPreloadSkill(
+        skillPath,
+        skillId,
+        category,
+        agentId
+      );
+      if (isPreloaded) {
+        agentSkills[agentId].push({ id: skillId, preloaded: true });
+      } else {
+        agentSkills[agentId].push(skillId);
+      }
+    }
+  }
+  return agentSkills;
+}
+function buildStackProperty(stack, skillAliases) {
+  const result = {};
+  for (const [agentId, agentConfig] of Object.entries(stack.agents)) {
+    if (!agentConfig || Object.keys(agentConfig).length === 0) {
+      continue;
+    }
+    const resolvedMappings = {};
+    for (const [subcategoryId, alias] of Object.entries(
+      agentConfig
+    )) {
+      const skillId = skillAliases[alias];
+      if (skillId) {
+        resolvedMappings[subcategoryId] = skillId;
+      } else {
+        resolvedMappings[subcategoryId] = alias;
+      }
+    }
+    if (Object.keys(resolvedMappings).length > 0) {
+      result[agentId] = resolvedMappings;
+    }
+  }
+  return result;
+}
+
+// src/cli-v2/commands/init.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var PLUGIN_NAME = "claude-collective";
+var Init = class _Init extends BaseCommand {
+  static summary = "Initialize Claude Collective in this project";
+  static description = "Interactive wizard to set up skills and agents. Supports Plugin Mode (native install) and Local Mode (copy to .claude/).";
+  static flags = {
+    ...BaseCommand.baseFlags,
+    refresh: Flags.boolean({
+      description: "Force refresh from remote source",
+      default: false
+    })
+  };
+  async run() {
+    const { flags } = await this.parse(_Init);
+    const projectDir = process.cwd();
+    this.log("Claude Collective Setup\n");
+    if (flags["dry-run"]) {
+      this.log("[dry-run] Preview mode - no files will be created\n");
+    }
+    const pluginDir = getCollectivePluginDir();
+    const pluginExists = await directoryExists(pluginDir);
+    if (pluginExists) {
+      this.warn(`Claude Collective is already initialized at ${pluginDir}`);
+      this.log(`Use 'cc edit' to modify skills.`);
+      this.log("No changes made.");
+      return;
+    }
+    this.log("Loading skills matrix...");
+    let sourceResult;
+    try {
+      sourceResult = await loadSkillsMatrixFromSource({
+        sourceFlag: flags.source,
+        projectDir,
+        forceRefresh: flags.refresh
+      });
+      const sourceInfo = sourceResult.isLocal ? "local" : formatSourceOrigin(sourceResult.sourceConfig.sourceOrigin);
+      this.log(
+        `Loaded ${Object.keys(sourceResult.matrix.skills).length} skills (${sourceInfo})
+`
+      );
+    } catch (error) {
+      this.error(
+        error instanceof Error ? error.message : "Unknown error occurred",
+        { exit: EXIT_CODES.ERROR }
+      );
+    }
+    let wizardResult = null;
+    const { waitUntilExit } = render(
+      /* @__PURE__ */ jsx2(
+        Wizard,
+        {
+          matrix: sourceResult.matrix,
+          onComplete: (result) => {
+            wizardResult = result;
+          },
+          onCancel: () => {
+            this.log("Setup cancelled");
+          }
+        }
+      )
+    );
+    await waitUntilExit();
+    if (!wizardResult || wizardResult.cancelled) {
+      this.exit(EXIT_CODES.CANCELLED);
+    }
+    if (wizardResult.selectedSkills.length === 0) {
+      this.error("No skills selected", { exit: EXIT_CODES.ERROR });
+    }
+    await this.handleInstallation(wizardResult, sourceResult, flags);
+  }
+  /**
+   * Handle installation based on wizard result.
+   * Supports Plugin Mode (with stack) and Local Mode (copy to .claude/).
+   */
+  async handleInstallation(result, sourceResult, flags) {
+    const projectDir = process.cwd();
+    const matrix = sourceResult.matrix;
+    const dryRun = flags["dry-run"];
+    this.log("\n");
+    this.log(`Selected ${result.selectedSkills.length} skills`);
+    this.log(
+      `Install mode: ${result.installMode === "plugin" ? "Plugin (native install)" : "Local (copy to .claude/skills/)"}`
+    );
+    this.log("\n");
+    if (dryRun) {
+      if (result.installMode === "plugin" && result.selectedStack) {
+        const useMarketplace = !!sourceResult.marketplace;
+        if (useMarketplace) {
+          this.log(
+            `[dry-run] Would install stack "${result.selectedStack.id}" from marketplace "${sourceResult.marketplace}"`
+          );
+          this.log(
+            `[dry-run]   claude plugin install ${result.selectedStack.id}@${sourceResult.marketplace} --scope project`
+          );
+        } else {
+          this.log(
+            `[dry-run] Would compile and install stack "${result.selectedStack.id}" as a native plugin`
+          );
+          this.log(
+            `[dry-run]   claude plugin install ./compiled-stack/${result.selectedStack.id} --scope project`
+          );
+          this.log(
+            `[dry-run] Stack includes ${result.selectedSkills.length} skills and agents bundled together`
+          );
+        }
+      } else {
+        if (result.installMode === "plugin") {
+          this.log(
+            `[dry-run] Individual skill plugin installation not yet supported`
+          );
+          this.log(`[dry-run] Would fall back to Local Mode...`);
+        }
+        const localSkillsDir = path3.join(projectDir, LOCAL_SKILLS_PATH);
+        const localAgentsDir = path3.join(projectDir, ".claude", "agents");
+        this.log(
+          `[dry-run] Would copy ${result.selectedSkills.length} skills to ${localSkillsDir}`
+        );
+        this.log(`[dry-run] Would compile agents to ${localAgentsDir}`);
+        this.log(`[dry-run] Would save config to .claude/config.yaml`);
+      }
+      this.log("\n[dry-run] Preview complete - no files were created");
+      return;
+    }
+    if (result.installMode === "plugin") {
+      if (result.selectedStack) {
+        await this.installPluginMode(result, sourceResult);
+        return;
+      } else {
+        this.warn(
+          "Individual skill plugin installation not yet supported in Plugin Mode."
+        );
+        this.log(`Falling back to Local Mode (copying to .claude/skills/)...`);
+        this.log(
+          "To use Plugin Mode, select a pre-built stack instead of individual skills.\n"
+        );
+      }
+    }
+    await this.installLocalMode(result, sourceResult);
+  }
+  /**
+   * Install in Plugin Mode: install stack as native plugin.
+   */
+  async installPluginMode(result, sourceResult) {
+    if (!result.selectedStack) {
+      throw new Error("No stack selected for plugin mode");
+    }
+    const projectDir = process.cwd();
+    if (sourceResult.marketplace) {
+      const marketplaceExists = await claudePluginMarketplaceExists(
+        sourceResult.marketplace
+      );
+      if (!marketplaceExists) {
+        this.log(`Registering marketplace "${sourceResult.marketplace}"...`);
+        try {
+          await claudePluginMarketplaceAdd(
+            sourceResult.sourceConfig.source,
+            sourceResult.marketplace
+          );
+          this.log(`Registered marketplace: ${sourceResult.marketplace}`);
+        } catch (error) {
+          this.error(error instanceof Error ? error.message : "Unknown error", {
+            exit: EXIT_CODES.ERROR
+          });
+        }
+      }
+    }
+    const installMethod = sourceResult.marketplace ? `Installing from marketplace "${sourceResult.marketplace}"` : "Compiling and installing";
+    this.log(`${installMethod} stack "${result.selectedStack.id}"...`);
+    try {
+      const installResult = await installStackAsPlugin({
+        stackId: result.selectedStack.id,
+        projectDir,
+        sourcePath: sourceResult.sourcePath,
+        agentSourcePath: sourceResult.sourcePath,
+        marketplace: sourceResult.marketplace
+      });
+      const installedFrom = installResult.fromMarketplace ? `from marketplace` : `(compiled locally)`;
+      this.log(
+        `Installed stack plugin: ${installResult.pluginName} ${installedFrom}
+`
+      );
+      this.log("Claude Collective initialized successfully!\n");
+      this.log(`Stack "${installResult.stackName}" installed as plugin`);
+      if (installResult.agents.length > 0) {
+        this.log("\nAgents included:");
+        for (const agentName of installResult.agents) {
+          this.log(`  ${agentName}`);
+        }
+        this.log(`
+Skills bundled: ${installResult.skills.length}`);
+      }
+      this.log("");
+      const permissionWarning = await checkPermissions(projectDir);
+      if (permissionWarning) {
+        const { waitUntilExit } = render(permissionWarning);
+        await waitUntilExit();
+      }
+    } catch (error) {
+      this.error(error instanceof Error ? error.message : "Unknown error", {
+        exit: EXIT_CODES.ERROR
+      });
+    }
+  }
+  /**
+   * Install in Local Mode: copy skills and compile agents to .claude/.
+   */
+  async installLocalMode(result, sourceResult) {
+    const projectDir = process.cwd();
+    const matrix = sourceResult.matrix;
+    const localSkillsDir = path3.join(projectDir, LOCAL_SKILLS_PATH);
+    const localAgentsDir = path3.join(projectDir, ".claude", "agents");
+    const localConfigPath = path3.join(projectDir, ".claude", "config.yaml");
+    this.log("Copying skills to local directory...");
+    try {
+      await ensureDir(localSkillsDir);
+      await ensureDir(localAgentsDir);
+      const copiedSkills = await copySkillsToLocalFlattened(
+        result.selectedSkills,
+        localSkillsDir,
+        matrix,
+        sourceResult
+      );
+      this.log(`Copied ${copiedSkills.length} skills to .claude/skills/
+`);
+      this.log("Generating configuration...");
+      const cliAgents = await loadAllAgents(PROJECT_ROOT);
+      const localAgents = await loadAllAgents(sourceResult.sourcePath);
+      const agents = { ...cliAgents, ...localAgents };
+      const localSkillsForResolution = {};
+      for (const copiedSkill of copiedSkills) {
+        const skill = matrix.skills[copiedSkill.skillId];
+        if (skill) {
+          localSkillsForResolution[copiedSkill.skillId] = {
+            id: copiedSkill.skillId,
+            name: skill.name,
+            description: skill.description || "",
+            canonicalId: copiedSkill.skillId,
+            path: copiedSkill.destPath,
+            content: ""
+            // Content not needed for skill references
+          };
+        }
+      }
+      const skillAliases = matrix.aliases || {};
+      let localConfig;
+      const loadedStack = result.selectedStack ? await loadStackById(result.selectedStack.id, PROJECT_ROOT) : null;
+      if (result.selectedStack) {
+        if (loadedStack) {
+          const agentIds = Object.keys(loadedStack.agents);
+          const stackProperty = buildStackProperty(loadedStack, skillAliases);
+          localConfig = {
+            name: PLUGIN_NAME,
+            installMode: result.installMode,
+            description: loadedStack.description,
+            skills: result.selectedSkills.map((id) => id),
+            agents: agentIds,
+            philosophy: loadedStack.philosophy,
+            stack: stackProperty
+          };
+        } else {
+          throw new Error(
+            `Stack '${result.selectedStack.id}' not found in config/stacks.yaml. Available stacks are defined in the CLI's config/stacks.yaml file.`
+          );
+        }
+      } else {
+        localConfig = generateProjectConfigFromSkills(
+          PLUGIN_NAME,
+          result.selectedSkills,
+          sourceResult.matrix
+        );
+      }
+      localConfig.installMode = result.installMode;
+      const configYaml = stringifyYaml(localConfig, {
+        indent: 2,
+        lineWidth: 120
+      });
+      await writeFile(localConfigPath, configYaml);
+      this.log(`Configuration saved (${localConfig.agents.length} agents)
+`);
+      this.log("Compiling agents...");
+      const compileAgents = {};
+      for (const agentId of localConfig.agents) {
+        if (agents[agentId]) {
+          if (loadedStack) {
+            const skillRefs = resolveAgentSkillsFromStack(
+              agentId,
+              loadedStack,
+              skillAliases
+            );
+            compileAgents[agentId] = { skills: skillRefs };
+          } else if (localConfig.agent_skills?.[agentId]) {
+            const skillRefs = resolveStackSkills(
+              localConfig,
+              agentId,
+              localSkillsForResolution
+            );
+            compileAgents[agentId] = { skills: skillRefs };
+          } else {
+            compileAgents[agentId] = {};
+          }
+        }
+      }
+      const compileConfig = {
+        name: PLUGIN_NAME,
+        description: localConfig.description || `Local setup with ${result.selectedSkills.length} skills`,
+        claude_md: "",
+        agents: compileAgents
+      };
+      const engine = await createLiquidEngine(projectDir);
+      const resolvedAgents = await resolveAgents(
+        agents,
+        localSkillsForResolution,
+        compileConfig,
+        sourceResult.sourcePath
+      );
+      const compiledAgentNames = [];
+      for (const [name, agent] of Object.entries(resolvedAgents)) {
+        const output = await compileAgentForPlugin(
+          name,
+          agent,
+          sourceResult.sourcePath,
+          engine
+        );
+        await writeFile(path3.join(localAgentsDir, `${name}.md`), output);
+        compiledAgentNames.push(name);
+      }
+      this.log(
+        `Compiled ${compiledAgentNames.length} agents to .claude/agents/
+`
+      );
+      this.log("Claude Collective initialized successfully!\n");
+      this.log("Skills copied to:");
+      this.log(`  ${localSkillsDir}`);
+      for (const copiedSkill of copiedSkills) {
+        const skill = matrix.skills[copiedSkill.skillId];
+        const displayName = skill?.alias || copiedSkill.skillId;
+        this.log(`    ${displayName}/`);
+      }
+      this.log("");
+      this.log("Agents compiled to:");
+      this.log(`  ${localAgentsDir}`);
+      for (const agentName of compiledAgentNames) {
+        this.log(`    ${agentName}.md`);
+      }
+      this.log("");
+      this.log("Configuration:");
+      this.log(`  ${localConfigPath}`);
+      this.log("");
+      this.log("To customize agent-skill assignments:");
+      this.log(`  1. Edit .claude/config.yaml`);
+      this.log(`  2. Run 'cc compile' to regenerate agents`);
+      this.log("");
+      const permissionWarning = await checkPermissions(projectDir);
+      if (permissionWarning) {
+        const { waitUntilExit } = render(permissionWarning);
+        await waitUntilExit();
+      }
+    } catch (error) {
+      this.error(error instanceof Error ? error.message : String(error), {
+        exit: EXIT_CODES.ERROR
+      });
+    }
+  }
+};
+export {
+  Init as default
+};
+//# sourceMappingURL=init.js.map