@plosson/agentio 0.1.23 → 0.1.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plosson/agentio",
-  "version": "0.1.23",
+  "version": "0.1.24",
   "description": "CLI for LLM agents to interact with communication and tracking services",
   "type": "module",
   "license": "MIT",

package/src/commands/claude.ts

@@ -1,183 +1,267 @@
 import { Command } from 'commander';
 import * as path from 'path';
-import * as fs from 'fs';
+import { spawn } from 'child_process';
 import { CliError, handleError } from '../utils/errors';
 import {
   loadAgentioJson,
-  agentioJsonExists,
-  listPlugins,
+  addMarketplace,
+  addPlugin,
+  removeMarketplace,
   removePlugin,
-  getPlugin,
 } from '../services/claude-plugin/agentio-json';
-import {
-  installPlugin,
-  removePluginFiles,
-} from '../services/claude-plugin/installer';
-import type { InstalledComponent } from '../types/claude-plugin';
+
+/**
+ * Execute a claude CLI command and return the result.
+ */
+async function execClaude(
+  args: string[]
+): Promise<{ success: boolean; stdout: string; stderr: string }> {
+  return new Promise((resolve) => {
+    const proc = spawn('claude', args, {
+      stdio: ['inherit', '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({
+        success: code === 0,
+        stdout,
+        stderr,
+      });
+    });
+
+    proc.on('error', (err) => {
+      resolve({
+        success: false,
+        stdout: '',
+        stderr: err.message,
+      });
+    });
+  });
+}
+
+/**
+ * Install a marketplace by calling claude plugin marketplace add.
+ * Silently skips if already installed.
+ */
+async function installMarketplace(url: string): Promise<boolean> {
+  console.error(`Adding marketplace: ${url}`);
+  const result = await execClaude(['plugin', 'marketplace', 'add', url]);
+
+  if (result.success) {
+    console.log(`  Added: ${url}`);
+    return true;
+  }
+
+  // Check if already installed (skip silently)
+  const errLower = result.stderr.toLowerCase();
+  if (errLower.includes('already') || errLower.includes('exists')) {
+    console.log(`  Skipped (already added): ${url}`);
+    return true;
+  }
+
+  console.error(`  Failed: ${result.stderr.trim()}`);
+  return false;
+}
+
+/**
+ * Install a plugin by calling claude plugin install --scope project.
+ */
+async function installPluginCmd(name: string): Promise<boolean> {
+  console.error(`Installing plugin: ${name}`);
+  const result = await execClaude(['plugin', 'install', name, '--scope', 'project']);
+
+  if (result.success) {
+    console.log(`  Installed: ${name}`);
+    return true;
+  }
+
+  console.error(`  Failed: ${result.stderr.trim()}`);
+  return false;
+}
+
+/**
+ * Uninstall a plugin by calling claude plugin uninstall --scope project.
+ */
+async function uninstallPluginCmd(name: string): Promise<boolean> {
+  console.error(`Uninstalling plugin: ${name}`);
+  const result = await execClaude(['plugin', 'uninstall', name, '--scope', 'project']);
+
+  if (result.success) {
+    console.log(`  Uninstalled: ${name}`);
+    return true;
+  }
+
+  // Check if not installed (skip silently)
+  const errLower = result.stderr.toLowerCase();
+  if (errLower.includes('not installed') || errLower.includes('not found')) {
+    console.log(`  Skipped (not installed): ${name}`);
+    return true;
+  }
+
+  console.error(`  Failed: ${result.stderr.trim()}`);
+  return false;
+}
 
 export function registerClaudeCommands(program: Command): void {
   const claude = program
     .command('claude')
     .description('Claude Code plugin operations');
 
-  const plugin = claude.command('plugin').description('Manage Claude Code plugins');
-
-  plugin
-    .command('install')
-    .description('Install plugin(s) from GitHub or agentio.json')
-    .argument('[source]', 'GitHub URL or owner/repo (omit to install from agentio.json)')
-    .option('--skills', 'Install only skills')
-    .option('--commands', 'Install only commands')
-    .option('--hooks', 'Install only hooks')
-    .option('--agents', 'Install only agents')
-    .option('-f, --force', 'Force reinstall if already exists')
-    .option('-d, --dir <path>', 'Target directory (default: current directory)')
-    .option('-v, --verbose', 'Show detailed installation logs')
-    .action(async (source, options) => {
+  // install command group
+  const install = claude.command('install').description('Install marketplaces and plugins');
+
+  install
+    .command('marketplace')
+    .description('Add a plugin marketplace')
+    .argument('<url>', 'Marketplace GitHub URL')
+    .option('-d, --dir <path>', 'Directory with agentio.json (default: current directory)')
+    .action(async (url, options) => {
       try {
         const targetDir = options.dir ? path.resolve(options.dir) : process.cwd();
 
-        if (!fs.existsSync(targetDir)) {
-          throw new CliError('INVALID_PARAMS', `Directory does not exist: ${targetDir}`);
+        const success = await installMarketplace(url);
+        if (success) {
+          addMarketplace(targetDir, url);
         }
+      } catch (error) {
+        handleError(error);
+      }
+    });
 
-        if (source) {
-          // Install specific plugin from source
-          console.error(`Installing plugin from: ${source}`);
-          console.error(`Target: ${path.join(targetDir, '.claude')}`);
-
-          const result = await installPlugin(source, {
-            skills: options.skills,
-            commands: options.commands,
-            hooks: options.hooks,
-            agents: options.agents,
-            force: options.force,
-            targetDir,
-            verbose: options.verbose,
-          });
-
-          console.log(`\nInstalled: ${result.manifest.name} v${result.manifest.version}`);
-          if (result.installed.length > 0) {
-            console.log(`Components: ${result.installed.length}`);
-            for (const comp of result.installed) {
-              console.log(`  ${comp.type}/${comp.name}`);
-            }
-          }
-        } else {
-          // Install all plugins from agentio.json
-          if (!agentioJsonExists(targetDir)) {
-            throw new CliError(
-              'NOT_FOUND',
-              'No agentio.json found',
-              'Run: agentio claude plugin install <source> to install a plugin'
-            );
-          }
-
-          const agentioJson = loadAgentioJson(targetDir);
-          const plugins = Object.entries(agentioJson.plugins);
-
-          if (plugins.length === 0) {
-            console.log('No plugins defined in agentio.json');
-            return;
-          }
-
-          console.error(`Installing ${plugins.length} plugin(s) from agentio.json...`);
-          console.error(`Target: ${path.join(targetDir, '.claude')}`);
-
-          let installed = 0;
-          for (const [name, entry] of plugins) {
-            console.error(`\nInstalling ${name}...`);
-
-            // Determine component flags based on entry.components
-            const installOptions = {
-              skills:
-                !entry.components || entry.components.includes('skills'),
-              commands:
-                !entry.components || entry.components.includes('commands'),
-              hooks: !entry.components || entry.components.includes('hooks'),
-              agents: !entry.components || entry.components.includes('agents'),
-              force: options.force,
-              targetDir,
-              verbose: options.verbose,
-            };
-
-            try {
-              const result = await installPlugin(entry.source, installOptions);
-              console.log(`  Installed: ${result.manifest.name} v${result.manifest.version}`);
-              installed++;
-            } catch (error) {
-              console.error(`  Failed to install ${name}: ${error}`);
-            }
-          }
+  install
+    .command('plugin')
+    .description('Install a plugin')
+    .argument('<name>', 'Plugin name (e.g., plugin-name@marketplace)')
+    .option('-d, --dir <path>', 'Directory with agentio.json (default: current directory)')
+    .action(async (name, options) => {
+      try {
+        const targetDir = options.dir ? path.resolve(options.dir) : process.cwd();
 
-          console.log(`\nInstalled ${installed} of ${plugins.length} plugin(s)`);
+        const success = await installPluginCmd(name);
+        if (success) {
+          addPlugin(targetDir, name);
         }
       } catch (error) {
         handleError(error);
       }
     });
 
-  plugin
+  // install with no subcommand - install all from agentio.json
+  install.action(async (options) => {
+    try {
+      const targetDir = options.dir ? path.resolve(options.dir) : process.cwd();
+      const config = loadAgentioJson(targetDir);
+
+      if (config.marketplaces.length === 0 && config.plugins.length === 0) {
+        console.log('No marketplaces or plugins defined in agentio.json');
+        return;
+      }
+
+      console.error(`Installing from agentio.json...`);
+
+      // Install marketplaces first
+      if (config.marketplaces.length > 0) {
+        console.error(`\nMarketplaces (${config.marketplaces.length}):`);
+        for (const url of config.marketplaces) {
+          await installMarketplace(url);
+        }
+      }
+
+      // Then install plugins
+      if (config.plugins.length > 0) {
+        console.error(`\nPlugins (${config.plugins.length}):`);
+        for (const name of config.plugins) {
+          await installPluginCmd(name);
+        }
+      }
+
+      console.log('\nDone.');
+    } catch (error) {
+      handleError(error);
+    }
+  });
+
+  // list command
+  claude
     .command('list')
-    .description('List plugins from agentio.json')
+    .description('List marketplaces and plugins from agentio.json')
     .option('-d, --dir <path>', 'Directory with agentio.json (default: current directory)')
     .action(async (options) => {
       try {
         const targetDir = options.dir ? path.resolve(options.dir) : process.cwd();
+        const config = loadAgentioJson(targetDir);
 
-        const plugins = listPlugins(targetDir);
-
-        if (plugins.length === 0) {
-          console.log('No plugins in agentio.json');
+        if (config.marketplaces.length === 0 && config.plugins.length === 0) {
+          console.log('No marketplaces or plugins defined in agentio.json');
           return;
         }
 
-        console.log(`Plugins (${plugins.length}):\n`);
-        for (const { name, entry } of plugins) {
-          console.log(`${name} v${entry.version}`);
-          console.log(`  Source: ${entry.source}`);
-          if (entry.components) {
-            console.log(`  Components: ${entry.components.join(', ')}`);
+        if (config.marketplaces.length > 0) {
+          console.log(`Marketplaces (${config.marketplaces.length}):`);
+          for (const url of config.marketplaces) {
+            console.log(`  ${url}`);
+          }
+        }
+
+        if (config.plugins.length > 0) {
+          if (config.marketplaces.length > 0) {
+            console.log('');
+          }
+          console.log(`Plugins (${config.plugins.length}):`);
+          for (const name of config.plugins) {
+            console.log(`  ${name}`);
           }
-          console.log('');
         }
       } catch (error) {
         handleError(error);
       }
     });
 
-  plugin
-    .command('remove')
-    .description('Remove an installed plugin')
-    .argument('<name>', 'Plugin name')
+  // remove command group
+  const remove = claude.command('remove').description('Remove marketplaces and plugins');
+
+  remove
+    .command('marketplace')
+    .description('Remove a marketplace from agentio.json')
+    .argument('<url>', 'Marketplace URL to remove')
     .option('-d, --dir <path>', 'Directory with agentio.json (default: current directory)')
-    .action(async (name, options) => {
+    .action(async (url, options) => {
       try {
         const targetDir = options.dir ? path.resolve(options.dir) : process.cwd();
 
-        const entry = getPlugin(targetDir, name);
-        if (!entry) {
-          throw new CliError('NOT_FOUND', `Plugin '${name}' not found in agentio.json`);
+        const removed = removeMarketplace(targetDir, url);
+        if (removed) {
+          console.log(`Removed marketplace: ${url}`);
+        } else {
+          throw new CliError('NOT_FOUND', `Marketplace not found: ${url}`);
         }
+      } catch (error) {
+        handleError(error);
+      }
+    });
 
-        console.error(`Removing plugin: ${name}...`);
-
-        // Use stored installed components (no network calls needed)
-        const components: InstalledComponent[] = entry.installedComponents || [];
-
-        // Remove files
-        removePluginFiles(targetDir, components);
+  remove
+    .command('plugin')
+    .description('Uninstall a plugin and remove from agentio.json')
+    .argument('<name>', 'Plugin name to remove')
+    .option('-d, --dir <path>', 'Directory with agentio.json (default: current directory)')
+    .action(async (name, options) => {
+      try {
+        const targetDir = options.dir ? path.resolve(options.dir) : process.cwd();
 
-        // Update agentio.json
+        await uninstallPluginCmd(name);
         removePlugin(targetDir, name);
-
-        console.log(`Removed: ${name}`);
-        if (components.length > 0) {
-          console.log(`Removed components: ${components.length}`);
-          for (const comp of components) {
-            console.log(`  ${comp.type}/${comp.name}`);
-          }
-        }
       } catch (error) {
         handleError(error);
       }

package/src/services/claude-plugin/agentio-json.ts

@@ -1,6 +1,6 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import type { AgentioJson, AgentioPluginEntry } from '../../types/claude-plugin';
+import type { AgentioJson } from '../../types/claude-plugin';
 
 const AGENTIO_JSON_FILE = 'agentio.json';
 
@@ -19,15 +19,18 @@ export function loadAgentioJson(dir: string): AgentioJson {
   const filePath = getAgentioJsonPath(dir);
 
   if (!fs.existsSync(filePath)) {
-    return { plugins: {} };
+    return { marketplaces: [], plugins: [] };
   }
 
   const content = fs.readFileSync(filePath, 'utf-8');
   const data = JSON.parse(content) as AgentioJson;
 
-  // Ensure plugins object exists
+  // Ensure arrays exist
+  if (!data.marketplaces) {
+    data.marketplaces = [];
+  }
   if (!data.plugins) {
-    data.plugins = {};
+    data.plugins = [];
   }
 
   return data;
@@ -43,61 +46,53 @@ export function saveAgentioJson(dir: string, data: AgentioJson): void {
 }
 
 /**
- * Check if agentio.json exists in the given directory.
+ * Add a marketplace URL if not already present.
  */
-export function agentioJsonExists(dir: string): boolean {
-  return fs.existsSync(getAgentioJsonPath(dir));
+export function addMarketplace(dir: string, url: string): void {
+  const data = loadAgentioJson(dir);
+  if (!data.marketplaces.includes(url)) {
+    data.marketplaces.push(url);
+    saveAgentioJson(dir, data);
+  }
 }
 
 /**
- * Add or update a plugin entry in agentio.json.
+ * Add a plugin name if not already present.
  */
-export function addPlugin(
-  dir: string,
-  name: string,
-  entry: AgentioPluginEntry
-): void {
+export function addPlugin(dir: string, name: string): void {
   const data = loadAgentioJson(dir);
-  data.plugins[name] = entry;
-  saveAgentioJson(dir, data);
+  if (!data.plugins.includes(name)) {
+    data.plugins.push(name);
+    saveAgentioJson(dir, data);
+  }
 }
 
 /**
- * Remove a plugin entry from agentio.json.
- * Returns true if plugin was found and removed.
+ * Remove a marketplace URL.
+ * Returns true if found and removed.
  */
-export function removePlugin(dir: string, name: string): boolean {
+export function removeMarketplace(dir: string, url: string): boolean {
   const data = loadAgentioJson(dir);
-
-  if (!data.plugins[name]) {
+  const index = data.marketplaces.indexOf(url);
+  if (index === -1) {
     return false;
   }
-
-  delete data.plugins[name];
+  data.marketplaces.splice(index, 1);
   saveAgentioJson(dir, data);
   return true;
 }
 
 /**
- * Get a plugin entry from agentio.json.
- */
-export function getPlugin(
-  dir: string,
-  name: string
-): AgentioPluginEntry | undefined {
-  const data = loadAgentioJson(dir);
-  return data.plugins[name];
-}
-
-/**
- * List all plugins in agentio.json.
+ * Remove a plugin name.
+ * Returns true if found and removed.
  */
-export function listPlugins(
-  dir: string
-): Array<{ name: string; entry: AgentioPluginEntry }> {
+export function removePlugin(dir: string, name: string): boolean {
   const data = loadAgentioJson(dir);
-  return Object.entries(data.plugins).map(([name, entry]) => ({
-    name,
-    entry,
-  }));
+  const index = data.plugins.indexOf(name);
+  if (index === -1) {
+    return false;
+  }
+  data.plugins.splice(index, 1);
+  saveAgentioJson(dir, data);
+  return true;
 }

package/src/types/claude-plugin.ts

@@ -1,65 +1,5 @@
-// Source URL parsing result
-export interface ParsedSource {
-  owner: string;
-  repo: string;
-  branch?: string; // undefined = default branch
-  path?: string; // path within repo to plugin root
-}
-
-// Plugin manifest (.claude-plugin/plugin.json)
-export interface PluginManifest {
-  name: string;
-  version: string;
-  description?: string;
-}
-
-// Component types that can be installed
-export type ComponentType = 'skills' | 'commands' | 'hooks' | 'agents';
-
-// Discovered components from filesystem
-export interface DiscoveredComponents {
-  skills: string[];
-  commands: string[];
-  hooks: string[];
-  agents: string[];
-}
-
-// Installation options
-export interface PluginInstallOptions {
-  skills?: boolean;
-  commands?: boolean;
-  hooks?: boolean;
-  agents?: boolean;
-  force?: boolean;
-  targetDir?: string;
-  verbose?: boolean;
-}
-
-// Single installed component record
-export interface InstalledComponent {
-  name: string;
-  type: ComponentType;
-  path: string; // Relative to agentio.json
-}
-
-// Plugin entry in agentio.json
-export interface AgentioPluginEntry {
-  source: string;
-  version: string;
-  components?: ComponentType[];
-  installedComponents: InstalledComponent[];
-}
-
-// agentio.json structure
+// agentio.json structure for Claude plugin installation
 export interface AgentioJson {
-  plugins: {
-    [pluginName: string]: AgentioPluginEntry;
-  };
-}
-
-// Installation result
-export interface InstallResult {
-  success: boolean;
-  manifest: PluginManifest;
-  installed: InstalledComponent[];
+  marketplaces: string[];
+  plugins: string[];
 }

package/src/services/claude-plugin/installer.ts

@@ -1,405 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { execSync } from 'child_process';
-import { tmpdir } from 'os';
-import { CliError } from '../../utils/errors';
-import type {
-  ParsedSource,
-  PluginManifest,
-  DiscoveredComponents,
-  PluginInstallOptions,
-  InstalledComponent,
-  InstallResult,
-  ComponentType,
-} from '../../types/claude-plugin';
-import { parseSource, buildGitCloneUrl } from './source-parser';
-import { addPlugin } from './agentio-json';
-
-/**
- * Clone a repository to a temporary directory.
- */
-function cloneRepo(parsed: ParsedSource): string {
-  const tempDir = fs.mkdtempSync(path.join(tmpdir(), 'agentio-plugin-'));
-  const cloneUrl = buildGitCloneUrl(parsed);
-
-  let cmd = `git clone --depth 1`;
-  if (parsed.branch) {
-    cmd += ` -b ${parsed.branch}`;
-  }
-  cmd += ` "${cloneUrl}" "${tempDir}"`;
-
-  try {
-    execSync(cmd, { stdio: 'pipe' });
-  } catch {
-    // Clean up temp dir on clone failure
-    fs.rmSync(tempDir, { recursive: true, force: true });
-    throw new CliError(
-      'API_ERROR',
-      `Failed to clone repository: ${parsed.owner}/${parsed.repo}`,
-      'Check the repository URL and your network connection'
-    );
-  }
-
-  return tempDir;
-}
-
-/**
- * Clean up a temporary directory.
- */
-function cleanupTempDir(tempDir: string): void {
-  fs.rmSync(tempDir, { recursive: true, force: true });
-}
-
-/**
- * Read the plugin manifest from a cloned repository.
- */
-function readPluginManifest(
-  repoDir: string,
-  parsed: ParsedSource
-): PluginManifest {
-  const basePath = parsed.path ? path.join(repoDir, parsed.path) : repoDir;
-  const manifestPath = path.join(basePath, '.claude-plugin', 'plugin.json');
-
-  if (!fs.existsSync(manifestPath)) {
-    throw new CliError(
-      'NOT_FOUND',
-      'Plugin manifest not found',
-      'Ensure .claude-plugin/plugin.json exists in the plugin root'
-    );
-  }
-
-  try {
-    const content = fs.readFileSync(manifestPath, 'utf-8');
-    const manifest = JSON.parse(content) as PluginManifest;
-
-    if (!manifest.name || !manifest.version) {
-      throw new CliError(
-        'INVALID_PARAMS',
-        'Invalid plugin manifest: missing name or version'
-      );
-    }
-
-    return manifest;
-  } catch (error) {
-    if (error instanceof CliError) throw error;
-    if (error instanceof SyntaxError) {
-      throw new CliError('INVALID_PARAMS', 'Invalid plugin manifest JSON');
-    }
-    throw error;
-  }
-}
-
-/**
- * Discover available components in a cloned repository.
- */
-function discoverComponents(
-  repoDir: string,
-  parsed: ParsedSource
-): DiscoveredComponents {
-  const basePath = parsed.path ? path.join(repoDir, parsed.path) : repoDir;
-  const result: DiscoveredComponents = {
-    skills: [],
-    commands: [],
-    hooks: [],
-    agents: [],
-  };
-
-  const componentTypes: ComponentType[] = ['skills', 'commands', 'hooks', 'agents'];
-
-  for (const type of componentTypes) {
-    const typePath = path.join(basePath, type);
-    if (fs.existsSync(typePath)) {
-      const entries = fs.readdirSync(typePath, { withFileTypes: true });
-      result[type] = entries
-        .filter((e) => e.isDirectory())
-        .map((e) => e.name);
-    }
-  }
-
-  return result;
-}
-
-/**
- * Copy a component from the cloned repository to the target directory.
- */
-function copyComponent(
-  repoDir: string,
-  parsed: ParsedSource,
-  componentType: ComponentType,
-  componentName: string,
-  targetDir: string
-): void {
-  const basePath = parsed.path ? path.join(repoDir, parsed.path) : repoDir;
-  const srcPath = path.join(basePath, componentType, componentName);
-  const destPath = path.join(targetDir, '.claude', componentType, componentName);
-
-  fs.mkdirSync(path.dirname(destPath), { recursive: true });
-  fs.cpSync(srcPath, destPath, { recursive: true });
-}
-
-/**
- * Determine which components to install based on options.
- */
-function determineComponentsToInstall(
-  options: PluginInstallOptions,
-  discovered: DiscoveredComponents
-): DiscoveredComponents {
-  // If no specific flags, install all
-  const installAll = !options.skills && !options.commands && !options.hooks && !options.agents;
-
-  return {
-    skills: installAll || options.skills ? discovered.skills : [],
-    commands: installAll || options.commands ? discovered.commands : [],
-    hooks: installAll || options.hooks ? discovered.hooks : [],
-    agents: installAll || options.agents ? discovered.agents : [],
-  };
-}
-
-/**
- * Get the component types array for agentio.json based on what was installed.
- */
-function getInstalledComponentTypes(
-  options: PluginInstallOptions
-): ComponentType[] | undefined {
-  const installAll = !options.skills && !options.commands && !options.hooks && !options.agents;
-  if (installAll) return undefined; // Default: all
-
-  const types: ComponentType[] = [];
-  if (options.skills) types.push('skills');
-  if (options.commands) types.push('commands');
-  if (options.hooks) types.push('hooks');
-  if (options.agents) types.push('agents');
-  return types;
-}
-
-/**
- * Install a plugin from a source.
- */
-export async function installPlugin(
-  source: string,
-  options: PluginInstallOptions
-): Promise<InstallResult> {
-  const parsed = parseSource(source);
-  const verbose = options.verbose ?? false;
-
-  if (verbose) {
-    console.error(`\n[verbose] Parsed source:`);
-    console.error(`  Owner: ${parsed.owner}`);
-    console.error(`  Repo: ${parsed.repo}`);
-    console.error(`  Branch: ${parsed.branch ?? '(default)'}`);
-    console.error(`  Path: ${parsed.path ?? '(root)'}`);
-    console.error(`  Clone URL: ${buildGitCloneUrl(parsed)}`);
-  }
-
-  // Clone repo to temp directory
-  if (verbose) {
-    console.error(`\n[verbose] Cloning repository...`);
-  }
-  const repoDir = cloneRepo(parsed);
-  if (verbose) {
-    console.error(`[verbose] Cloned to: ${repoDir}`);
-  }
-
-  try {
-    // Read manifest from cloned repo
-    const manifest = readPluginManifest(repoDir, parsed);
-
-    if (verbose) {
-      console.error(`\n[verbose] Plugin manifest:`);
-      console.error(`  Name: ${manifest.name}`);
-      console.error(`  Version: ${manifest.version}`);
-      if (manifest.description) {
-        console.error(`  Description: ${manifest.description}`);
-      }
-    }
-
-    // Discover available components
-    const discovered = discoverComponents(repoDir, parsed);
-
-    if (verbose) {
-      const totalDiscovered = discovered.skills.length + discovered.commands.length + discovered.hooks.length + discovered.agents.length;
-      console.error(`\n[verbose] Discovered ${totalDiscovered} component(s):`);
-      if (discovered.skills.length > 0) {
-        console.error(`  Skills (${discovered.skills.length}): ${discovered.skills.join(', ')}`);
-      }
-      if (discovered.commands.length > 0) {
-        console.error(`  Commands (${discovered.commands.length}): ${discovered.commands.join(', ')}`);
-      }
-      if (discovered.hooks.length > 0) {
-        console.error(`  Hooks (${discovered.hooks.length}): ${discovered.hooks.join(', ')}`);
-      }
-      if (discovered.agents.length > 0) {
-        console.error(`  Agents (${discovered.agents.length}): ${discovered.agents.join(', ')}`);
-      }
-    }
-
-    // Determine what to install
-    const toInstall = determineComponentsToInstall(options, discovered);
-
-    if (verbose) {
-      const totalToInstall = toInstall.skills.length + toInstall.commands.length + toInstall.hooks.length + toInstall.agents.length;
-      console.error(`\n[verbose] Installing ${totalToInstall} component(s):`);
-      if (toInstall.skills.length > 0) {
-        console.error(`  Skills: ${toInstall.skills.join(', ')}`);
-      }
-      if (toInstall.commands.length > 0) {
-        console.error(`  Commands: ${toInstall.commands.join(', ')}`);
-      }
-      if (toInstall.hooks.length > 0) {
-        console.error(`  Hooks: ${toInstall.hooks.join(', ')}`);
-      }
-      if (toInstall.agents.length > 0) {
-        console.error(`  Agents: ${toInstall.agents.join(', ')}`);
-      }
-    }
-
-    const targetDir = options.targetDir || process.cwd();
-    const installed: InstalledComponent[] = [];
-
-    if (verbose) {
-      console.error(`\n[verbose] Target directory: ${targetDir}`);
-    }
-
-    // Install skills
-    for (const skillName of toInstall.skills) {
-      const destPath = path.join(targetDir, '.claude', 'skills', skillName);
-
-      if (fs.existsSync(destPath)) {
-        if (!options.force) {
-          console.error(`  Skipping existing skill: ${skillName}`);
-          if (verbose) {
-            console.error(`    [verbose] Path: ${destPath}`);
-          }
-          continue;
-        }
-        if (verbose) {
-          console.error(`  [verbose] Removing existing: ${destPath}`);
-        }
-        fs.rmSync(destPath, { recursive: true });
-      }
-
-      copyComponent(repoDir, parsed, 'skills', skillName, targetDir);
-      installed.push({ name: skillName, type: 'skills', path: `.claude/skills/${skillName}` });
-      console.error(`  Installed skill: ${skillName}`);
-      if (verbose) {
-        console.error(`    [verbose] Path: ${destPath}`);
-      }
-    }
-
-    // Install commands
-    for (const cmdName of toInstall.commands) {
-      const destPath = path.join(targetDir, '.claude', 'commands', cmdName);
-
-      if (fs.existsSync(destPath)) {
-        if (!options.force) {
-          console.error(`  Skipping existing command: ${cmdName}`);
-          if (verbose) {
-            console.error(`    [verbose] Path: ${destPath}`);
-          }
-          continue;
-        }
-        if (verbose) {
-          console.error(`  [verbose] Removing existing: ${destPath}`);
-        }
-        fs.rmSync(destPath, { recursive: true });
-      }
-
-      copyComponent(repoDir, parsed, 'commands', cmdName, targetDir);
-      installed.push({ name: cmdName, type: 'commands', path: `.claude/commands/${cmdName}` });
-      console.error(`  Installed command: ${cmdName}`);
-      if (verbose) {
-        console.error(`    [verbose] Path: ${destPath}`);
-      }
-    }
-
-    // Install hooks
-    for (const hookName of toInstall.hooks) {
-      const destPath = path.join(targetDir, '.claude', 'hooks', hookName);
-
-      if (fs.existsSync(destPath)) {
-        if (!options.force) {
-          console.error(`  Skipping existing hook: ${hookName}`);
-          if (verbose) {
-            console.error(`    [verbose] Path: ${destPath}`);
-          }
-          continue;
-        }
-        if (verbose) {
-          console.error(`  [verbose] Removing existing: ${destPath}`);
-        }
-        fs.rmSync(destPath, { recursive: true });
-      }
-
-      copyComponent(repoDir, parsed, 'hooks', hookName, targetDir);
-      installed.push({ name: hookName, type: 'hooks', path: `.claude/hooks/${hookName}` });
-      console.error(`  Installed hook: ${hookName}`);
-      if (verbose) {
-        console.error(`    [verbose] Path: ${destPath}`);
-      }
-    }
-
-    // Install agents
-    for (const agentName of toInstall.agents) {
-      const destPath = path.join(targetDir, '.claude', 'agents', agentName);
-
-      if (fs.existsSync(destPath)) {
-        if (!options.force) {
-          console.error(`  Skipping existing agent: ${agentName}`);
-          if (verbose) {
-            console.error(`    [verbose] Path: ${destPath}`);
-          }
-          continue;
-        }
-        if (verbose) {
-          console.error(`  [verbose] Removing existing: ${destPath}`);
-        }
-        fs.rmSync(destPath, { recursive: true });
-      }
-
-      copyComponent(repoDir, parsed, 'agents', agentName, targetDir);
-      installed.push({ name: agentName, type: 'agents', path: `.claude/agents/${agentName}` });
-      console.error(`  Installed agent: ${agentName}`);
-      if (verbose) {
-        console.error(`    [verbose] Path: ${destPath}`);
-      }
-    }
-
-    // Update agentio.json
-    if (verbose) {
-      console.error(`\n[verbose] Updating agentio.json`);
-    }
-    addPlugin(targetDir, manifest.name, {
-      source: source,
-      version: manifest.version,
-      components: getInstalledComponentTypes(options),
-      installedComponents: installed,
-    });
-
-    return {
-      success: true,
-      manifest,
-      installed,
-    };
-  } finally {
-    // Always cleanup temp directory
-    if (verbose) {
-      console.error(`\n[verbose] Cleaning up temp directory: ${repoDir}`);
-    }
-    cleanupTempDir(repoDir);
-  }
-}
-
-/**
- * Remove installed components for a plugin.
- */
-export function removePluginFiles(
-  targetDir: string,
-  components: InstalledComponent[]
-): void {
-  for (const comp of components) {
-    const compPath = path.join(targetDir, comp.path);
-    if (fs.existsSync(compPath)) {
-      fs.rmSync(compPath, { recursive: true });
-    }
-  }
-}

package/src/services/claude-plugin/source-parser.ts

@@ -1,114 +0,0 @@
-import { CliError } from '../../utils/errors';
-import type { ParsedSource } from '../../types/claude-plugin';
-
-/**
- * Parse various GitHub source formats into a normalized ParsedSource.
- *
- * Supported formats:
- * - https://github.com/owner/repo/tree/branch/path
- * - git@github.com:owner/repo.git
- * - https://github.com/owner/repo.git
- * - owner/repo
- * - owner/repo/path/to/plugin
- */
-export function parseSource(source: string): ParsedSource {
-  // Full GitHub tree URL: https://github.com/owner/repo/tree/branch/path
-  if (source.includes('github.com') && source.includes('/tree/')) {
-    return parseGitHubTreeUrl(source);
-  }
-
-  // SSH URL: git@github.com:owner/repo.git
-  if (source.startsWith('git@')) {
-    return parseSshUrl(source);
-  }
-
-  // HTTPS clone URL: https://github.com/owner/repo.git
-  if (source.includes('github.com') && source.endsWith('.git')) {
-    return parseHttpsCloneUrl(source);
-  }
-
-  // Plain GitHub URL without tree: https://github.com/owner/repo or https://github.com/owner/repo/path
-  if (source.includes('github.com')) {
-    return parseGitHubUrl(source);
-  }
-
-  // Short form: owner/repo or owner/repo/path
-  return parseShortForm(source);
-}
-
-function parseGitHubTreeUrl(url: string): ParsedSource {
-  // https://github.com/owner/repo/tree/branch/path/to/plugin
-  const match = url.match(
-    /github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)(?:\/(.+))?/
-  );
-  if (!match) {
-    throw new CliError('INVALID_PARAMS', `Invalid GitHub tree URL: ${url}`);
-  }
-  return {
-    owner: match[1],
-    repo: match[2],
-    branch: match[3],
-    path: match[4] || undefined,
-  };
-}
-
-function parseSshUrl(url: string): ParsedSource {
-  // git@github.com:owner/repo.git
-  const match = url.match(/git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/);
-  if (!match) {
-    throw new CliError('INVALID_PARAMS', `Invalid SSH URL: ${url}`);
-  }
-  return {
-    owner: match[1],
-    repo: match[2],
-  };
-}
-
-function parseHttpsCloneUrl(url: string): ParsedSource {
-  // https://github.com/owner/repo.git
-  const match = url.match(/github\.com\/([^/]+)\/([^/]+?)\.git$/);
-  if (!match) {
-    throw new CliError('INVALID_PARAMS', `Invalid HTTPS clone URL: ${url}`);
-  }
-  return {
-    owner: match[1],
-    repo: match[2],
-  };
-}
-
-function parseGitHubUrl(url: string): ParsedSource {
-  // https://github.com/owner/repo or https://github.com/owner/repo/path
-  const match = url.match(/github\.com\/([^/]+)\/([^/]+?)(?:\/(.+))?$/);
-  if (!match) {
-    throw new CliError('INVALID_PARAMS', `Invalid GitHub URL: ${url}`);
-  }
-  return {
-    owner: match[1],
-    repo: match[2],
-    path: match[3] || undefined,
-  };
-}
-
-function parseShortForm(source: string): ParsedSource {
-  // owner/repo or owner/repo/path/to/plugin
-  const parts = source.split('/');
-  if (parts.length < 2) {
-    throw new CliError(
-      'INVALID_PARAMS',
-      `Invalid source format: ${source}`,
-      'Use owner/repo or a GitHub URL'
-    );
-  }
-  return {
-    owner: parts[0],
-    repo: parts[1],
-    path: parts.length > 2 ? parts.slice(2).join('/') : undefined,
-  };
-}
-
-/**
- * Build a git clone URL from parsed source.
- */
-export function buildGitCloneUrl(parsed: ParsedSource): string {
-  return `https://github.com/${parsed.owner}/${parsed.repo}.git`;
-}