@plosson/agentio 0.1.23 → 0.1.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plosson/agentio",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "description": "CLI for LLM agents to interact with communication and tracking services",
   "type": "module",
   "license": "MIT",
@@ -47,6 +47,7 @@
   },
   "dependencies": {
     "commander": "^14.0.2",
-    "googleapis": "^169.0.0"
+    "googleapis": "^169.0.0",
+    "rss-parser": "^3.13.0"
   }
 }

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/commands/rss.ts

@@ -0,0 +1,68 @@
+import { Command } from 'commander';
+import { RssClient } from '../services/rss/client';
+import { handleError } from '../utils/errors';
+import {
+  printRssArticleList,
+  printRssArticle,
+  printRssFeedInfo,
+} from '../utils/output';
+
+export function registerRssCommands(program: Command): void {
+  const rss = program
+    .command('rss')
+    .description('RSS feed operations');
+
+  // Get articles from a feed
+  rss
+    .command('articles')
+    .description('List articles from a blog')
+    .argument('<url>', 'Blog URL (feed will be auto-discovered)')
+    .option('--limit <n>', 'Number of articles', '20')
+    .option('--since <date>', 'Only articles after this date (YYYY-MM-DD)')
+    .action(async (url, options) => {
+      try {
+        const client = new RssClient();
+        const listOptions = {
+          limit: parseInt(options.limit, 10),
+          since: options.since ? new Date(options.since) : undefined,
+        };
+
+        const info = await client.getInfo(url);
+        const articles = await client.list(url, listOptions);
+        printRssArticleList(articles, info.title);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Get a specific article
+  rss
+    .command('get')
+    .description('Get a specific article')
+    .argument('<url>', 'Blog URL (feed will be auto-discovered)')
+    .argument('<article-id>', 'Article ID or URL')
+    .action(async (url, articleId) => {
+      try {
+        const client = new RssClient();
+        const article = await client.get(url, articleId);
+        printRssArticle(article);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Get feed info
+  rss
+    .command('info')
+    .description('Get feed information')
+    .argument('<url>', 'Blog URL (feed will be auto-discovered)')
+    .action(async (url) => {
+      try {
+        const client = new RssClient();
+        const info = await client.getInfo(url);
+        printRssFeedInfo(info);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}

package/src/config/config-manager.ts

@@ -115,7 +115,7 @@ export async function listProfiles(service?: ServiceName): Promise<{
   default?: string;
 }[]> {
   const config = await loadConfig();
-  const services: ServiceName[] = service ? [service] : ['gmail', 'gchat', 'jira', 'telegram'];
+  const services: ServiceName[] = service ? [service] : ['gmail', 'gchat', 'jira', 'slack', 'telegram'];
 
   return services.map((svc) => ({
     service: svc,

package/src/index.ts

@@ -5,6 +5,7 @@ import { registerTelegramCommands } from './commands/telegram';
 import { registerGChatCommands } from './commands/gchat';
 import { registerJiraCommands } from './commands/jira';
 import { registerSlackCommands } from './commands/slack';
+import { registerRssCommands } from './commands/rss';
 import { registerUpdateCommand } from './commands/update';
 import { registerConfigCommands } from './commands/config';
 import { registerClaudeCommands } from './commands/claude';
@@ -31,6 +32,7 @@ registerTelegramCommands(program);
 registerGChatCommands(program);
 registerJiraCommands(program);
 registerSlackCommands(program);
+registerRssCommands(program);
 registerUpdateCommand(program);
 registerConfigCommands(program);
 registerClaudeCommands(program);

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;
 }