@claude-collective/cli 0.1.3 → 0.2.0

package/CHANGELOG.md

@@ -5,6 +5,26 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.0] - 2026-01-30
+
+### Added
+
+- **Marketplace support** - install stack plugins directly from configured marketplaces
+- Marketplace field in project and global config for plugin installation
+- CLI utilities for marketplace management (`marketplace list`, `exists`, `add`)
+- Multi-source agent loading - agents can now be loaded from both CLI and custom sources
+- `sourceRoot` tracking for correct template resolution with multi-source agents
+
+### Changed
+
+- Removed skills eject functionality (use marketplace plugins instead)
+
+### Fixed
+
+- Wizard now preserves approach selection state when toggling Expert Mode or Install Mode
+
+[0.2.0]: https://github.com/claude-collective/cli/releases/tag/v0.2.0
+
 ## [0.1.3] - 2026-01-30
 
 ### Added

package/dist/cli/index.js

@@ -209,6 +209,8 @@ function isValidGlobalConfig(obj) {
     return false;
   if (config.author !== void 0 && typeof config.author !== "string")
     return false;
+  if (config.marketplace !== void 0 && typeof config.marketplace !== "string")
+    return false;
   return true;
 }
 function isValidProjectConfig(obj) {
@@ -216,6 +218,8 @@ function isValidProjectConfig(obj) {
   const config = obj;
   if (config.source !== void 0 && typeof config.source !== "string")
     return false;
+  if (config.marketplace !== void 0 && typeof config.marketplace !== "string")
+    return false;
   return true;
 }
 function getGlobalConfigPath() {
@@ -279,32 +283,35 @@ async function saveProjectConfig(projectDir, config) {
   verbose(`Saved project config to ${configPath}`);
 }
 async function resolveSource(flagValue, projectDir) {
+  const projectConfig = projectDir ? await loadProjectConfig(projectDir) : null;
+  const globalConfig = await loadGlobalConfig();
+  const marketplace = projectConfig?.marketplace || globalConfig?.marketplace;
   if (flagValue !== void 0) {
     if (flagValue === "" || flagValue.trim() === "") {
       throw new Error("--source flag cannot be empty");
     }
     verbose(`Source from --source flag: ${flagValue}`);
-    return { source: flagValue, sourceOrigin: "flag" };
+    return { source: flagValue, sourceOrigin: "flag", marketplace };
   }
   const envValue = process.env[SOURCE_ENV_VAR];
   if (envValue) {
     verbose(`Source from ${SOURCE_ENV_VAR} env var: ${envValue}`);
-    return { source: envValue, sourceOrigin: "env" };
+    return { source: envValue, sourceOrigin: "env", marketplace };
   }
-  if (projectDir) {
-    const projectConfig = await loadProjectConfig(projectDir);
-    if (projectConfig?.source) {
-      verbose(`Source from project config: ${projectConfig.source}`);
-      return { source: projectConfig.source, sourceOrigin: "project" };
-    }
+  if (projectConfig?.source) {
+    verbose(`Source from project config: ${projectConfig.source}`);
+    return {
+      source: projectConfig.source,
+      sourceOrigin: "project",
+      marketplace
+    };
   }
-  const globalConfig = await loadGlobalConfig();
   if (globalConfig?.source) {
     verbose(`Source from global config: ${globalConfig.source}`);
-    return { source: globalConfig.source, sourceOrigin: "global" };
+    return { source: globalConfig.source, sourceOrigin: "global", marketplace };
   }
   verbose(`Using default source: ${DEFAULT_SOURCE}`);
-  return { source: DEFAULT_SOURCE, sourceOrigin: "default" };
+  return { source: DEFAULT_SOURCE, sourceOrigin: "default", marketplace };
 }
 function formatSourceOrigin(origin) {
   switch (origin) {
@@ -529,7 +536,8 @@ async function loadAllAgents(projectRoot) {
       description: config.description,
       model: config.model,
       tools: config.tools,
-      path: agentPath
+      path: agentPath,
+      sourceRoot: projectRoot
     };
     verbose(`Loaded agent: ${config.id} from ${file}`);
   }
@@ -794,7 +802,8 @@ async function resolveAgents(agents, skills, compileConfig, projectRoot) {
       model: definition.model,
       tools: definition.tools,
       skills: resolvedSkills,
-      path: definition.path
+      path: definition.path,
+      sourceRoot: definition.sourceRoot
     };
   }
   return resolved;
@@ -1008,9 +1017,10 @@ async function determineStackVersion(stack, pluginDir) {
     contentHash: newHash
   };
 }
-async function compileAgentForPlugin(name, agent, projectRoot, engine) {
+async function compileAgentForPlugin(name, agent, fallbackRoot, engine) {
   verbose(`Compiling agent: ${name}`);
-  const agentDir = path11.join(projectRoot, DIRS.agents, agent.path || name);
+  const agentSourceRoot = agent.sourceRoot || fallbackRoot;
+  const agentDir = path11.join(agentSourceRoot, DIRS.agents, agent.path || name);
   const intro4 = await readFile(path11.join(agentDir, "intro.md"));
   const workflow = await readFile(path11.join(agentDir, "workflow.md"));
   const examples = await readFileOptional(
@@ -1027,7 +1037,7 @@ async function compileAgentForPlugin(name, agent, projectRoot, engine) {
   );
   const agentPath = agent.path || name;
   const category = agentPath.split("/")[0];
-  const categoryDir = path11.join(projectRoot, DIRS.agents, category);
+  const categoryDir = path11.join(agentSourceRoot, DIRS.agents, category);
   let outputFormat = await readFileOptional(
     path11.join(agentDir, "output-format.md"),
     ""
@@ -1129,19 +1139,25 @@ function generateHooksJson(hooks) {
 }
 async function compileStackPlugin(options) {
   const { stackId, outputDir, projectRoot, agentSourcePath } = options;
-  const agentRoot = agentSourcePath || projectRoot;
+  const localAgentRoot = agentSourcePath || projectRoot;
   verbose(`Compiling stack plugin: ${stackId}`);
   verbose(`  Stack/skills source: ${projectRoot}`);
-  verbose(`  Agent partials source: ${agentRoot}`);
+  verbose(`  Local agent source: ${localAgentRoot}`);
+  verbose(`  CLI agent source: ${PROJECT_ROOT}`);
   const stack = await loadStack(stackId, projectRoot, "dev");
-  const agents = await loadAllAgents(agentRoot);
+  const cliAgents = await loadAllAgents(PROJECT_ROOT);
+  const localAgents = await loadAllAgents(localAgentRoot);
+  const agents = { ...cliAgents, ...localAgents };
+  verbose(
+    `  Loaded ${Object.keys(localAgents).length} local agents, ${Object.keys(cliAgents).length} CLI agents`
+  );
   const skills = await loadSkillsByIds(stack.skills || [], projectRoot);
   const compileConfig = stackToCompileConfig(stackId, stack);
   const resolvedAgents = await resolveAgents(
     agents,
     skills,
     compileConfig,
-    agentRoot
+    projectRoot
   );
   const pluginDir = path11.join(outputDir, stackId);
   const agentsDir = path11.join(pluginDir, "agents");
@@ -1168,7 +1184,12 @@ async function compileStackPlugin(options) {
   const compiledAgentNames = [];
   const allSkillPlugins = [];
   for (const [name, agent] of Object.entries(resolvedAgents)) {
-    const output = await compileAgentForPlugin(name, agent, agentRoot, engine);
+    const output = await compileAgentForPlugin(
+      name,
+      agent,
+      PROJECT_ROOT,
+      engine
+    );
     await writeFile(path11.join(agentsDir, `${name}.md`), output);
     compiledAgentNames.push(name);
     for (const skill of agent.skills) {
@@ -2359,6 +2380,82 @@ import pc7 from "picocolors";
 import path25 from "path";
 import { stringify as stringifyYaml4 } from "yaml";
 
+// src/cli/utils/exec.ts
+import { spawn } from "child_process";
+async function execCommand(command, args, options) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, args, {
+      cwd: options?.cwd,
+      env: { ...process.env, ...options?.env },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      resolve({
+        stdout,
+        stderr,
+        exitCode: code ?? 1
+      });
+    });
+    proc.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+async function claudePluginInstall(pluginPath, scope, projectDir) {
+  const args = ["plugin", "install", pluginPath, "--scope", scope];
+  const result = await execCommand("claude", args, { cwd: projectDir });
+  if (result.exitCode !== 0) {
+    const errorMessage = result.stderr || result.stdout || "Unknown error";
+    throw new Error(`Plugin installation failed: ${errorMessage.trim()}`);
+  }
+}
+async function isClaudeCLIAvailable() {
+  try {
+    const result = await execCommand("claude", ["--version"], {});
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function claudePluginMarketplaceList() {
+  const result = await execCommand(
+    "claude",
+    ["plugin", "marketplace", "list", "--json"],
+    {}
+  );
+  if (result.exitCode !== 0) {
+    return [];
+  }
+  try {
+    return JSON.parse(result.stdout);
+  } catch {
+    return [];
+  }
+}
+async function claudePluginMarketplaceExists(name) {
+  const marketplaces = await claudePluginMarketplaceList();
+  return marketplaces.some((m) => m.name === name);
+}
+async function claudePluginMarketplaceAdd(githubRepo, name) {
+  const args = ["plugin", "marketplace", "add", githubRepo, "--name", name];
+  const result = await execCommand("claude", args, {});
+  if (result.exitCode !== 0) {
+    const errorMessage = result.stderr || result.stdout || "Unknown error";
+    if (errorMessage.includes("already installed")) {
+      return;
+    }
+    throw new Error(`Failed to add marketplace: ${errorMessage.trim()}`);
+  }
+}
+
 // src/cli/lib/wizard.ts
 import * as p5 from "@clack/prompts";
 import pc6 from "picocolors";
@@ -2790,6 +2887,7 @@ function createInitialState(options = {}) {
     lastSelectedCategory: null,
     lastSelectedSubcategory: null,
     lastSelectedSkill: null,
+    lastSelectedApproach: null,
     expertMode: options.hasLocalSkills ?? false,
     installMode: "plugin"
   };
@@ -2939,7 +3037,8 @@ async function stepApproach(state) {
       },
       formatExpertModeOption(state.expertMode),
       formatInstallModeOption(state.installMode)
-    ]
+    ],
+    initialValue: state.lastSelectedApproach || void 0
   });
   return result;
 }
@@ -3135,13 +3234,16 @@ async function runWizard(matrix, options = {}) {
           return null;
         }
         if (result === EXPERT_MODE_VALUE) {
+          state.lastSelectedApproach = EXPERT_MODE_VALUE;
           state.expertMode = !state.expertMode;
           break;
         }
         if (result === INSTALL_MODE_VALUE) {
+          state.lastSelectedApproach = INSTALL_MODE_VALUE;
           state.installMode = state.installMode === "plugin" ? "local" : "plugin";
           break;
         }
+        state.lastSelectedApproach = null;
         if (result === "stack") {
           pushHistory(state);
           state.currentStep = "stack";
@@ -3826,7 +3928,8 @@ async function loadFromLocal(source, sourceConfig) {
     matrix: mergedMatrix,
     sourceConfig,
     sourcePath: skillsPath,
-    isLocal: true
+    isLocal: true,
+    marketplace: sourceConfig.marketplace
   };
 }
 async function loadFromRemote(source, sourceConfig, forceRefresh) {
@@ -3852,7 +3955,8 @@ async function loadFromRemote(source, sourceConfig, forceRefresh) {
     matrix: mergedMatrix,
     sourceConfig,
     sourcePath: fetchResult.path,
-    isLocal: false
+    isLocal: false,
+    marketplace: sourceConfig.marketplace
   };
 }
 var LOCAL_CATEGORY_TOP = {
@@ -4098,54 +4202,6 @@ For autonomous operation, add to .claude/settings.json:
 // src/cli/lib/stack-installer.ts
 import os3 from "os";
 import path24 from "path";
-
-// src/cli/utils/exec.ts
-import { spawn } from "child_process";
-async function execCommand(command, args, options) {
-  return new Promise((resolve, reject) => {
-    const proc = spawn(command, args, {
-      cwd: options?.cwd,
-      env: { ...process.env, ...options?.env },
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    proc.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    proc.stderr.on("data", (data) => {
-      stderr += data.toString();
-    });
-    proc.on("close", (code) => {
-      resolve({
-        stdout,
-        stderr,
-        exitCode: code ?? 1
-      });
-    });
-    proc.on("error", (err) => {
-      reject(err);
-    });
-  });
-}
-async function claudePluginInstall(pluginPath, scope, projectDir) {
-  const args = ["plugin", "install", pluginPath, "--scope", scope];
-  const result = await execCommand("claude", args, { cwd: projectDir });
-  if (result.exitCode !== 0) {
-    const errorMessage = result.stderr || result.stdout || "Unknown error";
-    throw new Error(`Plugin installation failed: ${errorMessage.trim()}`);
-  }
-}
-async function isClaudeCLIAvailable() {
-  try {
-    const result = await execCommand("claude", ["--version"], {});
-    return result.exitCode === 0;
-  } catch {
-    return false;
-  }
-}
-
-// src/cli/lib/stack-installer.ts
 async function compileStackToTemp(options) {
   const tempDir = path24.join(os3.tmpdir(), `cc-stack-${Date.now()}`);
   await ensureDir(tempDir);
@@ -4163,13 +4219,27 @@ async function compileStackToTemp(options) {
   };
 }
 async function installStackAsPlugin(options) {
-  const { stackId, projectDir, sourcePath, agentSourcePath } = 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,
@@ -4182,7 +4252,8 @@ async function installStackAsPlugin(options) {
       stackName: result.stackName,
       agents: result.agents,
       skills: result.skillPlugins,
-      pluginPath: result.pluginPath
+      pluginPath: result.pluginPath,
+      fromMarketplace: false
     };
   } finally {
     await cleanup();
@@ -4520,21 +4591,35 @@ var initCommand = new Command5("init").description("Initialize Claude Collective
   );
   if (dryRun) {
     if (result.installMode === "plugin" && result.selectedStack) {
-      p7.log.info(
-        pc7.yellow(
-          `[dry-run] Would install stack "${result.selectedStack.id}" as a native plugin`
-        )
-      );
-      p7.log.info(
-        pc7.yellow(
-          `[dry-run]   claude plugin install ./compiled-stack/${result.selectedStack.id} --scope project`
-        )
-      );
-      p7.log.info(
-        pc7.yellow(
-          `[dry-run] Stack includes ${result.selectedSkills.length} skills and agents bundled together`
-        )
-      );
+      const useMarketplace = !!sourceResult.marketplace;
+      if (useMarketplace) {
+        p7.log.info(
+          pc7.yellow(
+            `[dry-run] Would install stack "${result.selectedStack.id}" from marketplace "${sourceResult.marketplace}"`
+          )
+        );
+        p7.log.info(
+          pc7.yellow(
+            `[dry-run]   claude plugin install ${result.selectedStack.id}@${sourceResult.marketplace} --scope project`
+          )
+        );
+      } else {
+        p7.log.info(
+          pc7.yellow(
+            `[dry-run] Would compile and install stack "${result.selectedStack.id}" as a native plugin`
+          )
+        );
+        p7.log.info(
+          pc7.yellow(
+            `[dry-run]   claude plugin install ./compiled-stack/${result.selectedStack.id} --scope project`
+          )
+        );
+        p7.log.info(
+          pc7.yellow(
+            `[dry-run] Stack includes ${result.selectedSkills.length} skills and agents bundled together`
+          )
+        );
+      }
     } else {
       if (result.installMode === "plugin") {
         p7.log.info(
@@ -4563,31 +4648,59 @@ var initCommand = new Command5("init").description("Initialize Claude Collective
   }
   if (result.installMode === "plugin") {
     if (result.selectedStack) {
-      s.start(
-        `Compiling and installing stack "${result.selectedStack.id}"...`
-      );
+      if (sourceResult.marketplace) {
+        const marketplaceExists = await claudePluginMarketplaceExists(
+          sourceResult.marketplace
+        );
+        if (!marketplaceExists) {
+          s.start(`Registering marketplace "${sourceResult.marketplace}"...`);
+          try {
+            await claudePluginMarketplaceAdd(
+              sourceResult.sourceConfig.source,
+              sourceResult.marketplace
+            );
+            s.stop(`Registered marketplace: ${sourceResult.marketplace}`);
+          } catch (error) {
+            s.stop("Failed to register marketplace");
+            p7.log.error(
+              error instanceof Error ? error.message : "Unknown error"
+            );
+            process.exit(EXIT_CODES.ERROR);
+          }
+        }
+      }
+      const installMethod = sourceResult.marketplace ? `Installing from marketplace "${sourceResult.marketplace}"` : "Compiling and installing";
+      s.start(`${installMethod} stack "${result.selectedStack.id}"...`);
       try {
         const installResult = await installStackAsPlugin({
           stackId: result.selectedStack.id,
           projectDir,
           sourcePath: sourceResult.sourcePath,
-          agentSourcePath: sourceResult.sourcePath
+          agentSourcePath: sourceResult.sourcePath,
+          marketplace: sourceResult.marketplace
         });
-        s.stop(`Installed stack plugin: ${installResult.pluginName}`);
+        const installedFrom = installResult.fromMarketplace ? `from marketplace` : `(compiled locally)`;
+        s.stop(
+          `Installed stack plugin: ${installResult.pluginName} ${installedFrom}`
+        );
         console.log("");
         console.log(pc7.green("Claude Collective initialized successfully!"));
         console.log("");
         console.log(
           `Stack ${pc7.cyan(`"${installResult.stackName}"`)} installed as plugin`
         );
-        console.log("");
-        console.log(pc7.dim("Agents included:"));
-        for (const agentName of installResult.agents) {
-          console.log(`  ${pc7.cyan(agentName)}`);
+        if (installResult.agents.length > 0) {
+          console.log("");
+          console.log(pc7.dim("Agents included:"));
+          for (const agentName of installResult.agents) {
+            console.log(`  ${pc7.cyan(agentName)}`);
+          }
+          console.log("");
+          console.log(
+            pc7.dim(`Skills bundled: ${installResult.skills.length}`)
+          );
         }
         console.log("");
-        console.log(pc7.dim(`Skills bundled: ${installResult.skills.length}`));
-        console.log("");
         p7.outro(pc7.green("Claude Collective is ready to use!"));
         await checkPermissions(projectDir);
         return;
@@ -4626,7 +4739,9 @@ var initCommand = new Command5("init").description("Initialize Claude Collective
     );
     s.stop(`Copied ${copiedSkills.length} skills to .claude/skills/`);
     s.start("Generating configuration...");
-    const agents = await loadAllAgents(sourceResult.sourcePath);
+    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];
@@ -5938,7 +6053,7 @@ import * as p12 from "@clack/prompts";
 import pc12 from "picocolors";
 import path30 from "path";
 import os4 from "os";
-var EJECT_TYPES = ["templates", "skills", "config", "all"];
+var EJECT_TYPES = ["templates", "config", "all"];
 var DEFAULT_CONFIG_CONTENT = `# Claude Collective Configuration
 # Agent-skill mappings for this project
 
@@ -5964,31 +6079,7 @@ agent_skills:
     - drizzle
     - better-auth
 `;
-var DEFAULT_SKILL_MD_CONTENT = `---
-name: example-skill
-description: Short description of the skill
----
-
-# Example Skill
-
-## Overview
-Describe what this skill teaches the agent.
-
-## Instructions
-Specific instructions for the agent.
-
-## Examples
-\`\`\`typescript
-// Example code
-\`\`\`
-`;
-var DEFAULT_METADATA_CONTENT = `# yaml-language-server: $schema=../../schemas/metadata.schema.json
-category: custom
-author: "@local"
-cli_name: Example Skill
-cli_description: Short description for CLI
-`;
-var ejectCommand = new Command10("eject").description("Eject bundled content for local customization").argument("[type]", "What to eject: templates, skills, config, all").option("-f, --force", "Overwrite existing files", false).option(
+var ejectCommand = new Command10("eject").description("Eject bundled content for local customization").argument("[type]", "What to eject: templates, config, all").option("-f, --force", "Overwrite existing files", false).option(
   "-o, --output <dir>",
   "Output directory (default: .claude/ in current directory)"
 ).configureOutput({
@@ -5997,9 +6088,7 @@ var ejectCommand = new Command10("eject").description("Eject bundled content for
   async (type, options) => {
     const projectDir = process.cwd();
     if (!type) {
-      p12.log.error(
-        "Please specify what to eject: templates, skills, config, or all"
-      );
+      p12.log.error("Please specify what to eject: templates, config, or all");
       process.exit(EXIT_CODES.INVALID_ARGS);
     }
     if (!EJECT_TYPES.includes(type)) {
@@ -6029,15 +6118,11 @@ var ejectCommand = new Command10("eject").description("Eject bundled content for
       case "templates":
         await ejectTemplates(outputBase, options.force, directOutput);
         break;
-      case "skills":
-        await ejectSkills(outputBase, options.force, directOutput);
-        break;
       case "config":
         await ejectConfig(outputBase, options.force, directOutput);
         break;
       case "all":
         await ejectTemplates(outputBase, options.force, directOutput);
-        await ejectSkills(outputBase, options.force, directOutput);
         await ejectConfig(outputBase, options.force, directOutput);
         break;
     }
@@ -6060,30 +6145,6 @@ async function ejectTemplates(outputBase, force, directOutput = false) {
     pc12.dim("You can now customize agent.liquid and partials locally.")
   );
 }
-async function ejectSkills(outputBase, force, directOutput = false) {
-  const destDir = directOutput ? outputBase : path30.join(outputBase, "skill-templates");
-  if (await directoryExists(destDir) && !force) {
-    p12.log.warn(
-      `Skill templates already exist at ${destDir}. Use --force to overwrite.`
-    );
-    return;
-  }
-  await ensureDir(destDir);
-  const exampleSkillDir = path30.join(destDir, "example-skill");
-  await ensureDir(exampleSkillDir);
-  await writeFile(
-    path30.join(exampleSkillDir, "SKILL.md"),
-    DEFAULT_SKILL_MD_CONTENT
-  );
-  await writeFile(
-    path30.join(exampleSkillDir, "metadata.yaml"),
-    DEFAULT_METADATA_CONTENT
-  );
-  p12.log.success(`Skill templates ejected to ${pc12.cyan(destDir)}`);
-  p12.log.info(
-    pc12.dim("Copy example-skill/ to your skills/ directory and customize.")
-  );
-}
 async function ejectConfig(outputBase, force, directOutput = false) {
   const destPath = path30.join(outputBase, "config.yaml");
   if (await fileExists(destPath) && !force) {