@claude-collective/cli 0.1.2 → 0.2.0

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;
@@ -891,9 +900,6 @@ function generateStackPluginManifest(options) {
   if (options.keywords && options.keywords.length > 0) {
     manifest.keywords = options.keywords;
   }
-  if (options.hasAgents) {
-    manifest.agents = "./agents/";
-  }
   if (options.hasHooks) {
     manifest.hooks = "./hooks/hooks.json";
   }
@@ -1011,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(
@@ -1030,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"),
     ""
@@ -1132,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");
@@ -1171,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) {
@@ -2362,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";
@@ -2793,6 +2887,7 @@ function createInitialState(options = {}) {
     lastSelectedCategory: null,
     lastSelectedSubcategory: null,
     lastSelectedSkill: null,
+    lastSelectedApproach: null,
     expertMode: options.hasLocalSkills ?? false,
     installMode: "plugin"
   };
@@ -2942,7 +3037,8 @@ async function stepApproach(state) {
       },
       formatExpertModeOption(state.expertMode),
       formatInstallModeOption(state.installMode)
-    ]
+    ],
+    initialValue: state.lastSelectedApproach || void 0
   });
   return result;
 }
@@ -3138,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";
@@ -3329,12 +3428,97 @@ async function runWizard(matrix, options = {}) {
 // src/cli/lib/source-loader.ts
 import path21 from "path";
 
-// src/cli/lib/matrix-loader.ts
+// src/cli/lib/local-skill-loader.ts
 import { parse as parseYaml7 } from "yaml";
 import path19 from "path";
+var LOCAL_CATEGORY = "local";
+var LOCAL_AUTHOR = "@local";
+var TEST_SKILL_PREFIX = "test-";
+async function discoverLocalSkills(projectDir) {
+  const localSkillsPath = path19.join(projectDir, LOCAL_SKILLS_PATH);
+  if (!await directoryExists(localSkillsPath)) {
+    verbose(`Local skills directory not found: ${localSkillsPath}`);
+    return null;
+  }
+  const skills = [];
+  const skillDirs = await listDirectories(localSkillsPath);
+  for (const skillDirName of skillDirs) {
+    if (!skillDirName.startsWith(TEST_SKILL_PREFIX)) {
+      verbose(
+        `Skipping local skill '${skillDirName}': Does not have test- prefix (temporary filter)`
+      );
+      continue;
+    }
+    const skill = await extractLocalSkill(localSkillsPath, skillDirName);
+    if (skill) {
+      skills.push(skill);
+    }
+  }
+  verbose(`Discovered ${skills.length} local skills from ${localSkillsPath}`);
+  return {
+    skills,
+    localSkillsPath
+  };
+}
+async function extractLocalSkill(localSkillsPath, skillDirName) {
+  const skillDir = path19.join(localSkillsPath, skillDirName);
+  const metadataPath = path19.join(skillDir, "metadata.yaml");
+  const skillMdPath = path19.join(skillDir, "SKILL.md");
+  if (!await fileExists(metadataPath)) {
+    verbose(`Skipping local skill '${skillDirName}': No metadata.yaml found`);
+    return null;
+  }
+  if (!await fileExists(skillMdPath)) {
+    verbose(`Skipping local skill '${skillDirName}': No SKILL.md found`);
+    return null;
+  }
+  const metadataContent = await readFile(metadataPath);
+  const metadata = parseYaml7(metadataContent);
+  if (!metadata.cli_name) {
+    verbose(
+      `Skipping local skill '${skillDirName}': Missing required 'cli_name' in metadata.yaml`
+    );
+    return null;
+  }
+  const skillMdContent = await readFile(skillMdPath);
+  const frontmatter = parseFrontmatter(skillMdContent);
+  if (!frontmatter) {
+    verbose(
+      `Skipping local skill '${skillDirName}': Invalid SKILL.md frontmatter`
+    );
+    return null;
+  }
+  const relativePath = `${LOCAL_SKILLS_PATH}/${skillDirName}/`;
+  const skillId = frontmatter.name;
+  const extracted = {
+    id: skillId,
+    directoryPath: skillDirName,
+    name: `${metadata.cli_name} ${LOCAL_AUTHOR}`,
+    description: metadata.cli_description || frontmatter.description,
+    usageGuidance: void 0,
+    category: LOCAL_CATEGORY,
+    categoryExclusive: false,
+    author: LOCAL_AUTHOR,
+    tags: [],
+    compatibleWith: [],
+    conflictsWith: [],
+    requires: [],
+    requiresSetup: [],
+    providesSetupFor: [],
+    path: relativePath,
+    local: true,
+    localPath: relativePath
+  };
+  verbose(`Extracted local skill: ${skillId}`);
+  return extracted;
+}
+
+// src/cli/lib/matrix-loader.ts
+import { parse as parseYaml8 } from "yaml";
+import path20 from "path";
 async function loadSkillsMatrix(configPath) {
   const content = await readFile(configPath);
-  const config = parseYaml7(content);
+  const config = parseYaml8(content);
   validateMatrixStructure(config, configPath);
   verbose(`Loaded skills matrix: ${configPath}`);
   return config;
@@ -3390,15 +3574,15 @@ async function extractAllSkills(skillsDir) {
   const skills = [];
   const metadataFiles = await glob("**/metadata.yaml", skillsDir);
   for (const metadataFile of metadataFiles) {
-    const skillDir = path19.dirname(metadataFile);
-    const skillMdPath = path19.join(skillsDir, skillDir, "SKILL.md");
-    const metadataPath = path19.join(skillsDir, metadataFile);
+    const skillDir = path20.dirname(metadataFile);
+    const skillMdPath = path20.join(skillsDir, skillDir, "SKILL.md");
+    const metadataPath = path20.join(skillsDir, metadataFile);
     if (!await fileExists(skillMdPath)) {
       verbose(`Skipping ${metadataFile}: No SKILL.md found`);
       continue;
     }
     const metadataContent = await readFile(metadataPath);
-    const metadata = parseYaml7(metadataContent);
+    const metadata = parseYaml8(metadataContent);
     const skillMdContent = await readFile(skillMdPath);
     const frontmatter = parseFrontmatter(skillMdContent);
     if (!frontmatter) {
@@ -3686,91 +3870,6 @@ function resolveSuggestedStacks(matrix, aliases) {
   });
 }
 
-// src/cli/lib/local-skill-loader.ts
-import { parse as parseYaml8 } from "yaml";
-import path20 from "path";
-var LOCAL_CATEGORY = "local";
-var LOCAL_AUTHOR = "@local";
-var TEST_SKILL_PREFIX = "test-";
-async function discoverLocalSkills(projectDir) {
-  const localSkillsPath = path20.join(projectDir, LOCAL_SKILLS_PATH);
-  if (!await directoryExists(localSkillsPath)) {
-    verbose(`Local skills directory not found: ${localSkillsPath}`);
-    return null;
-  }
-  const skills = [];
-  const skillDirs = await listDirectories(localSkillsPath);
-  for (const skillDirName of skillDirs) {
-    if (!skillDirName.startsWith(TEST_SKILL_PREFIX)) {
-      verbose(
-        `Skipping local skill '${skillDirName}': Does not have test- prefix (temporary filter)`
-      );
-      continue;
-    }
-    const skill = await extractLocalSkill(localSkillsPath, skillDirName);
-    if (skill) {
-      skills.push(skill);
-    }
-  }
-  verbose(`Discovered ${skills.length} local skills from ${localSkillsPath}`);
-  return {
-    skills,
-    localSkillsPath
-  };
-}
-async function extractLocalSkill(localSkillsPath, skillDirName) {
-  const skillDir = path20.join(localSkillsPath, skillDirName);
-  const metadataPath = path20.join(skillDir, "metadata.yaml");
-  const skillMdPath = path20.join(skillDir, "SKILL.md");
-  if (!await fileExists(metadataPath)) {
-    verbose(`Skipping local skill '${skillDirName}': No metadata.yaml found`);
-    return null;
-  }
-  if (!await fileExists(skillMdPath)) {
-    verbose(`Skipping local skill '${skillDirName}': No SKILL.md found`);
-    return null;
-  }
-  const metadataContent = await readFile(metadataPath);
-  const metadata = parseYaml8(metadataContent);
-  if (!metadata.cli_name) {
-    verbose(
-      `Skipping local skill '${skillDirName}': Missing required 'cli_name' in metadata.yaml`
-    );
-    return null;
-  }
-  const skillMdContent = await readFile(skillMdPath);
-  const frontmatter = parseFrontmatter(skillMdContent);
-  if (!frontmatter) {
-    verbose(
-      `Skipping local skill '${skillDirName}': Invalid SKILL.md frontmatter`
-    );
-    return null;
-  }
-  const relativePath = `${LOCAL_SKILLS_PATH}/${skillDirName}/`;
-  const skillId = frontmatter.name;
-  const extracted = {
-    id: skillId,
-    directoryPath: skillDirName,
-    name: `${metadata.cli_name} ${LOCAL_AUTHOR}`,
-    description: metadata.cli_description || frontmatter.description,
-    usageGuidance: void 0,
-    category: LOCAL_CATEGORY,
-    categoryExclusive: false,
-    author: LOCAL_AUTHOR,
-    tags: [],
-    compatibleWith: [],
-    conflictsWith: [],
-    requires: [],
-    requiresSetup: [],
-    providesSetupFor: [],
-    path: relativePath,
-    local: true,
-    localPath: relativePath
-  };
-  verbose(`Extracted local skill: ${skillId}`);
-  return extracted;
-}
-
 // src/cli/lib/source-loader.ts
 async function loadSkillsMatrixFromSource(options = {}) {
   const {
@@ -3810,9 +3909,17 @@ async function loadFromLocal(source, sourceConfig) {
     skillsPath = PROJECT_ROOT;
   }
   verbose(`Loading skills from local path: ${skillsPath}`);
-  const matrixPath = path21.join(PROJECT_ROOT, SKILLS_MATRIX_PATH);
+  const sourceMatrixPath = path21.join(skillsPath, SKILLS_MATRIX_PATH);
+  const cliMatrixPath = path21.join(PROJECT_ROOT, SKILLS_MATRIX_PATH);
+  let matrixPath;
+  if (await fileExists(sourceMatrixPath)) {
+    matrixPath = sourceMatrixPath;
+    verbose(`Matrix from source: ${matrixPath}`);
+  } else {
+    matrixPath = cliMatrixPath;
+    verbose(`Matrix from CLI (source has no matrix): ${matrixPath}`);
+  }
   const skillsDir = path21.join(skillsPath, SKILLS_DIR_PATH);
-  verbose(`Matrix from CLI: ${matrixPath}`);
   verbose(`Skills from source: ${skillsDir}`);
   const matrix = await loadSkillsMatrix(matrixPath);
   const skills = await extractAllSkills(skillsDir);
@@ -3821,16 +3928,25 @@ async function loadFromLocal(source, sourceConfig) {
     matrix: mergedMatrix,
     sourceConfig,
     sourcePath: skillsPath,
-    isLocal: true
+    isLocal: true,
+    marketplace: sourceConfig.marketplace
   };
 }
 async function loadFromRemote(source, sourceConfig, forceRefresh) {
   verbose(`Fetching skills from remote source: ${source}`);
   const fetchResult = await fetchFromSource(source, { forceRefresh });
   verbose(`Fetched to: ${fetchResult.path}`);
-  const matrixPath = path21.join(PROJECT_ROOT, SKILLS_MATRIX_PATH);
+  const sourceMatrixPath = path21.join(fetchResult.path, SKILLS_MATRIX_PATH);
+  const cliMatrixPath = path21.join(PROJECT_ROOT, SKILLS_MATRIX_PATH);
+  let matrixPath;
+  if (await fileExists(sourceMatrixPath)) {
+    matrixPath = sourceMatrixPath;
+    verbose(`Matrix from source: ${matrixPath}`);
+  } else {
+    matrixPath = cliMatrixPath;
+    verbose(`Matrix from CLI (source has no matrix): ${matrixPath}`);
+  }
   const skillsDir = path21.join(fetchResult.path, SKILLS_DIR_PATH);
-  verbose(`Matrix from CLI: ${matrixPath}`);
   verbose(`Skills from source: ${skillsDir}`);
   const matrix = await loadSkillsMatrix(matrixPath);
   const skills = await extractAllSkills(skillsDir);
@@ -3839,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 = {
@@ -4085,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);
@@ -4150,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,
@@ -4169,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();
@@ -4507,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(
@@ -4550,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;
@@ -4613,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];
@@ -5182,6 +5310,9 @@ var KEBAB_CASE_REGEX = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 var SEMVER_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
 var schemaCache2 = /* @__PURE__ */ new Map();
 var validatorCache2 = /* @__PURE__ */ new Map();
+var REMOTE_SCHEMAS = {
+  "skill-frontmatter.schema.json": "https://raw.githubusercontent.com/claude-collective/skills/main/src/schemas/skill-frontmatter.schema.json"
+};
 async function loadSchema2(schemaName) {
   if (schemaCache2.has(schemaName)) {
     return schemaCache2.get(schemaName);
@@ -5198,8 +5329,20 @@ async function loadSchema2(schemaName) {
       return schema;
     }
   }
+  const remoteUrl = REMOTE_SCHEMAS[schemaName];
+  if (remoteUrl) {
+    try {
+      const response = await fetch(remoteUrl);
+      if (response.ok) {
+        const schema = await response.json();
+        schemaCache2.set(schemaName, schema);
+        return schema;
+      }
+    } catch {
+    }
+  }
   throw new Error(
-    `Schema not found: ${schemaName}. Searched: ${locations.join(", ")}`
+    `Schema not found: ${schemaName}. Searched: ${locations.join(", ")}${remoteUrl ? ` and ${remoteUrl}` : ""}`
   );
 }
 async function getValidator2(schemaName) {
@@ -5909,7 +6052,8 @@ import { Command as Command10 } from "commander";
 import * as p12 from "@clack/prompts";
 import pc12 from "picocolors";
 import path30 from "path";
-var EJECT_TYPES = ["templates", "skills", "config", "all"];
+import os4 from "os";
+var EJECT_TYPES = ["templates", "config", "all"];
 var DEFAULT_CONFIG_CONTENT = `# Claude Collective Configuration
 # Agent-skill mappings for this project
 
@@ -5935,68 +6079,59 @@ 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).configureOutput({
+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({
   writeErr: (str) => console.error(pc12.red(str))
-}).showHelpAfterError(true).action(async (type, options) => {
-  const projectDir = process.cwd();
-  if (!type) {
-    p12.log.error(
-      "Please specify what to eject: templates, skills, config, or all"
-    );
-    process.exit(EXIT_CODES.INVALID_ARGS);
-  }
-  if (!EJECT_TYPES.includes(type)) {
-    p12.log.error(`Unknown eject type: ${type}`);
-    p12.log.info(`Valid types: ${EJECT_TYPES.join(", ")}`);
-    process.exit(EXIT_CODES.INVALID_ARGS);
-  }
-  p12.intro(pc12.cyan("Claude Collective Eject"));
-  const ejectType = type;
-  switch (ejectType) {
-    case "templates":
-      await ejectTemplates(projectDir, options.force);
-      break;
-    case "skills":
-      await ejectSkills(projectDir, options.force);
-      break;
-    case "config":
-      await ejectConfig(projectDir, options.force);
-      break;
-    case "all":
-      await ejectTemplates(projectDir, options.force);
-      await ejectSkills(projectDir, options.force);
-      await ejectConfig(projectDir, options.force);
-      break;
+}).showHelpAfterError(true).action(
+  async (type, options) => {
+    const projectDir = process.cwd();
+    if (!type) {
+      p12.log.error("Please specify what to eject: templates, config, or all");
+      process.exit(EXIT_CODES.INVALID_ARGS);
+    }
+    if (!EJECT_TYPES.includes(type)) {
+      p12.log.error(`Unknown eject type: ${type}`);
+      p12.log.info(`Valid types: ${EJECT_TYPES.join(", ")}`);
+      process.exit(EXIT_CODES.INVALID_ARGS);
+    }
+    let outputBase;
+    if (options.output) {
+      const expandedPath = options.output.startsWith("~") ? path30.join(os4.homedir(), options.output.slice(1)) : options.output;
+      outputBase = path30.resolve(projectDir, expandedPath);
+      if (await fileExists(outputBase)) {
+        p12.log.error(`Output path exists as a file: ${outputBase}`);
+        p12.log.info("Please specify a directory path, not a file.");
+        process.exit(EXIT_CODES.INVALID_ARGS);
+      }
+    } else {
+      outputBase = path30.join(projectDir, ".claude");
+    }
+    p12.intro(pc12.cyan("Claude Collective Eject"));
+    if (options.output) {
+      p12.log.info(`Output directory: ${pc12.cyan(outputBase)}`);
+    }
+    const ejectType = type;
+    const directOutput = !!options.output;
+    switch (ejectType) {
+      case "templates":
+        await ejectTemplates(outputBase, options.force, directOutput);
+        break;
+      case "config":
+        await ejectConfig(outputBase, options.force, directOutput);
+        break;
+      case "all":
+        await ejectTemplates(outputBase, options.force, directOutput);
+        await ejectConfig(outputBase, options.force, directOutput);
+        break;
+    }
+    p12.outro(pc12.green("Eject complete!"));
   }
-  p12.outro(pc12.green("Eject complete!"));
-});
-async function ejectTemplates(projectDir, force) {
+);
+async function ejectTemplates(outputBase, force, directOutput = false) {
   const sourceDir = path30.join(PROJECT_ROOT, DIRS.templates);
-  const destDir = path30.join(projectDir, ".claude", "templates");
+  const destDir = directOutput ? outputBase : path30.join(outputBase, "templates");
   if (await directoryExists(destDir) && !force) {
     p12.log.warn(
       `Templates already exist at ${destDir}. Use --force to overwrite.`
@@ -6010,30 +6145,8 @@ async function ejectTemplates(projectDir, force) {
     pc12.dim("You can now customize agent.liquid and partials locally.")
   );
 }
-async function ejectSkills(projectDir, force) {
-  const destDir = path30.join(projectDir, ".claude", "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 .claude/skills/ and customize."));
-}
-async function ejectConfig(projectDir, force) {
-  const destPath = path30.join(projectDir, ".claude", "config.yaml");
+async function ejectConfig(outputBase, force, directOutput = false) {
+  const destPath = path30.join(outputBase, "config.yaml");
   if (await fileExists(destPath) && !force) {
     p12.log.warn(
       `Config already exists at ${destPath}. Use --force to overwrite.`