@plosson/agentio 0.1.20 → 0.1.22

package/README.md

@@ -192,44 +192,49 @@ agentio gmail list --profile work
 
 ## Claude Code Integration
 
-agentio provides a plugin for [Claude Code](https://claude.com/claude-code) with skills for Gmail, Telegram, and Google Chat operations.
+agentio provides plugins for [Claude Code](https://claude.ai/download) with skills for Gmail, Telegram, and Google Chat operations.
 
-### Add the Marketplace
+### Install the Plugin
 
 ```bash
-/plugin marketplace add plosson/agentio
-```
+# Install from GitHub
+agentio claude plugin install plosson/agentio
 
-### Install the Plugin
+# Or install from a full GitHub URL
+agentio claude plugin install https://github.com/plosson/agentio
 
-```bash
-/plugin install agentio@agentio
+# Install to a specific directory
+agentio claude plugin install plosson/agentio -d ~/myproject
+
+# Install only skills (skip commands and hooks)
+agentio claude plugin install plosson/agentio --skills
+
+# Force reinstall if already exists
+agentio claude plugin install plosson/agentio -f
 ```
 
 Once installed, Claude Code can use the agentio CLI skills to help you manage emails, send Telegram messages, and more.
 
-### Install Skills Directly
-
-You can also install skills directly without the plugin system:
+### Manage Plugins
 
 ```bash
-# List available skills
-agentio skill list
+# List installed plugins
+agentio claude plugin list
 
-# Install all skills to current directory
-agentio skill install
+# Remove a plugin
+agentio claude plugin remove agentio
+```
 
-# Install a specific skill
-agentio skill install agentio-gmail
+### Install from agentio.json
 
-# Install to a specific directory
-agentio skill install -d ~/myproject
+If your project has an `agentio.json` file listing plugins, you can install all of them at once:
 
-# Skip confirmation prompts
-agentio skill install -y
+```bash
+# Install all plugins from agentio.json in current directory
+agentio claude plugin install
 ```
 
-Skills are installed to `.claude/skills/` in the target directory.
+Plugins are installed to `.claude/` in the target directory (skills, commands, and hooks subdirectories).
 
 ## Design
 

package/package.json

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

package/src/commands/claude.ts

@@ -29,8 +29,10 @@ export function registerClaudeCommands(program: Command): void {
     .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) => {
       try {
         const targetDir = options.dir ? path.resolve(options.dir) : process.cwd();
@@ -48,8 +50,10 @@ export function registerClaudeCommands(program: Command): void {
             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}`);
@@ -91,8 +95,10 @@ export function registerClaudeCommands(program: Command): void {
               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 {

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

@@ -101,9 +101,10 @@ function discoverComponents(
     skills: [],
     commands: [],
     hooks: [],
+    agents: [],
   };
 
-  const componentTypes: ComponentType[] = ['skills', 'commands', 'hooks'];
+  const componentTypes: ComponentType[] = ['skills', 'commands', 'hooks', 'agents'];
 
   for (const type of componentTypes) {
     const typePath = path.join(basePath, type);
@@ -144,12 +145,13 @@ function determineComponentsToInstall(
   discovered: DiscoveredComponents
 ): DiscoveredComponents {
   // If no specific flags, install all
-  const installAll = !options.skills && !options.commands && !options.hooks;
+  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 : [],
   };
 }
 
@@ -159,13 +161,14 @@ function determineComponentsToInstall(
 function getInstalledComponentTypes(
   options: PluginInstallOptions
 ): ComponentType[] | undefined {
-  const installAll = !options.skills && !options.commands && !options.hooks;
+  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;
 }
 
@@ -177,23 +180,86 @@ export async function installPlugin(
   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);
@@ -201,14 +267,23 @@ export async function installPlugin(
       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: destPath });
       console.error(`  Installed skill: ${skillName}`);
+      if (verbose) {
+        console.error(`    [verbose] Path: ${destPath}`);
+      }
     }
 
     // Install commands
@@ -218,14 +293,23 @@ export async function installPlugin(
       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: destPath });
       console.error(`  Installed command: ${cmdName}`);
+      if (verbose) {
+        console.error(`    [verbose] Path: ${destPath}`);
+      }
     }
 
     // Install hooks
@@ -235,17 +319,55 @@ export async function installPlugin(
       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: destPath });
       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: destPath });
+      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,
@@ -260,6 +382,9 @@ export async function installPlugin(
     };
   } finally {
     // Always cleanup temp directory
+    if (verbose) {
+      console.error(`\n[verbose] Cleaning up temp directory: ${repoDir}`);
+    }
     cleanupTempDir(repoDir);
   }
 }

package/src/types/claude-plugin.ts

@@ -14,13 +14,14 @@ export interface PluginManifest {
 }
 
 // Component types that can be installed
-export type ComponentType = 'skills' | 'commands' | 'hooks';
+export type ComponentType = 'skills' | 'commands' | 'hooks' | 'agents';
 
 // Discovered components from filesystem
 export interface DiscoveredComponents {
   skills: string[];
   commands: string[];
   hooks: string[];
+  agents: string[];
 }
 
 // Installation options
@@ -28,8 +29,10 @@ export interface PluginInstallOptions {
   skills?: boolean;
   commands?: boolean;
   hooks?: boolean;
+  agents?: boolean;
   force?: boolean;
   targetDir?: string;
+  verbose?: boolean;
 }
 
 // Single installed component record