opencode-agents 1.0.7 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-agents",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "CLI for managing AI coding agents",
   "type": "module",
   "bin": {
@@ -27,7 +27,8 @@
     "gray-matter": "^4.0.3",
     "ora": "^5.4.1",
     "chalk": "^5.3.0",
-    "yaml": "^2.3.4"
+    "yaml": "^2.3.4",
+    "inquirer": "^9.2.12"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",

package/src/commands/add.ts

@@ -1,23 +1,135 @@
 import ora from 'ora';
+import inquirer from 'inquirer';
+import { tmpdir } from 'os';
+import { existsSync, rmSync } from 'fs';
 import { installAgent } from '../core/installer.js';
+import { discoverFromDirectory } from '../core/discover.js';
 import { detectPlatforms } from '../utils/filesystem.js';
 import { logger } from '../utils/logger.js';
-import type { AgentPlatform, InstallOptions } from '../types/index.js';
+import type { AgentPlatform, InstallOptions, AgentFile } from '../types/index.js';
+import { basename } from 'path';
 
 interface AddCommandOptions {
-  global: boolean;
+  global: boolean | undefined;
   agent: string[] | undefined;
   agentName: string | undefined;
   yes: boolean;
   copy: boolean;
 }
 
+async function promptInstallLocation(): Promise<boolean> {
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'scope',
+      message: 'Where would you like to install this agent?',
+      choices: [
+        { name: 'Current project (./.opencode/agents/)', value: false },
+        { name: 'Global (~/.config/opencode/agents/)', value: true },
+      ],
+      default: 0,
+    },
+  ]);
+  return answers.scope;
+}
+
+async function promptSelectAgents(agents: AgentFile[]): Promise<AgentFile[]> {
+  const choices = agents.map(agent => ({
+    name: agent.agent.name || basename(agent.path, '.md'),
+    value: agent,
+    checked: false,
+  }));
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'selected',
+      message: 'Select agents to install (space to select, enter to confirm):',
+      choices,
+    },
+  ]);
+
+  return answers.selected;
+}
+
+async function fetchSource(source: string): Promise<string> {
+  const { mkdtempSync, join } = await import('path');
+  const degit = await import('degit');
+
+  const tempDir = mkdtempSync(join(tmpdir(), 'agents-cli-'));
+
+  const parts = source.split('/');
+  let owner = parts[0];
+  let repo = parts[1]?.replace(/#.+$/, '') || '';
+  let ref = '';
+
+  if (source.includes('#')) {
+    const [repoPart, refPart] = source.split('#');
+    repo = repoPart.split('/')[1];
+    ref = refPart;
+  }
+
+  try {
+    const target = ref ? `${owner}/${repo}#${ref}` : `${owner}/${repo}`;
+    await degit.default(target).clone(tempDir);
+    return tempDir;
+  } catch (err) {
+    rmSync(tempDir, { recursive: true, force: true });
+    throw new Error(`Failed to fetch from ${source}: ${err}`);
+  }
+}
+
 export async function addCommand(source: string, options: AddCommandOptions): Promise<void> {
-  const spinner = ora('Installing agent...').start();
+  let isGlobal = options.global;
+
+  if (isGlobal === undefined) {
+    isGlobal = await promptInstallLocation();
+  }
+
+  const fetchSpinner = ora('Fetching source...').start();
+
+  let tempDir: string;
+  try {
+    tempDir = await fetchSource(source);
+    fetchSpinner.succeed('Source fetched');
+  } catch (err) {
+    fetchSpinner.fail(`Failed to fetch source: ${err instanceof Error ? err.message : String(err)}`);
+    logger.error(String(err));
+    process.exit(1);
+  }
+
+  const discoverSpinner = ora('Discovering agents...').start();
+  let agents: AgentFile[];
+  try {
+    agents = await discoverFromDirectory(tempDir);
+    discoverSpinner.succeed(`Found ${agents.length} agent(s)`);
+  } catch (err) {
+    discoverSpinner.fail(`Failed to discover agents: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+
+  if (agents.length === 0) {
+    logger.error('No agents found in the source');
+    process.exit(1);
+  }
+
+  let selectedAgents: AgentFile[];
+  if (options.yes) {
+    selectedAgents = agents;
+  } else {
+    selectedAgents = await promptSelectAgents(agents);
+  }
+
+  if (selectedAgents.length === 0) {
+    logger.warn('No agents selected, aborting');
+    process.exit(0);
+  }
+
+  const installSpinner = ora('Installing agent(s)...').start();
 
   try {
     let platforms: AgentPlatform[];
-    
+
     if (options.agent && options.agent.length > 0) {
       platforms = options.agent as AgentPlatform[];
     } else {
@@ -26,19 +138,25 @@ export async function addCommand(source: string, options: AddCommandOptions): Pr
 
     const installOptions: InstallOptions = {
       source,
-      global: options.global,
+      sourcePath: tempDir,
+      global: isGlobal,
       platforms,
       agentName: options.agentName,
       copy: options.copy,
       yes: options.yes,
+      selectedAgents,
     };
 
     await installAgent(installOptions);
-    
-    spinner.succeed(`Successfully installed agent from ${source}`);
+
+    installSpinner.succeed(`Successfully installed ${selectedAgents.length} agent(s)`);
   } catch (err) {
-    spinner.fail(`Failed to install agent: ${err instanceof Error ? err.message : String(err)}`);
+    installSpinner.fail(`Failed to install agent: ${err instanceof Error ? err.message : String(err)}`);
     logger.error(String(err));
     process.exit(1);
+  } finally {
+    if (existsSync(tempDir) && tempDir.startsWith(tmpdir())) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
   }
 }

package/src/core/installer.ts

@@ -9,29 +9,39 @@ import { logger } from '../utils/logger.js';
 import type { AgentPlatform, AgentFile, InstallOptions } from '../types/index.js';
 
 export async function installAgent(options: InstallOptions): Promise<void> {
-  const { source, global, platforms, agentName, copy } = options;
-  
+  const { source, sourcePath, global, platforms, agentName, copy, selectedAgents } = options;
+
   logger.info(`Installing agent from: ${source}`);
 
-  const tempDir = await fetchSource(source);
-  
-  try {
-    const agents = await discoverFromDirectory(tempDir);
-    
+  let tempDir: string;
+  let agents: AgentFile[];
+
+  if (selectedAgents) {
+    tempDir = sourcePath || source;
+    agents = selectedAgents;
+  } else {
+    tempDir = await fetchSource(source);
+    agents = await discoverFromDirectory(tempDir);
+
     if (agents.length === 0) {
+      if (existsSync(tempDir) && tempDir.startsWith(tmpdir())) {
+        rmSync(tempDir, { recursive: true, force: true });
+      }
       throw new Error('No agents found in the source');
     }
+  }
 
+  try {
     for (const platform of platforms) {
       const targetPaths = getPlatformPaths(platform, global);
-      
+
       for (const targetPath of targetPaths) {
         ensureDir(targetPath);
-        
+
         for (const agentFile of agents) {
           const name = agentName || agentFile.agent.name || basename(agentFile.path, '.md');
           const finalPath = join(targetPath, `${name}.md`);
-          
+
           if (existsSync(finalPath) && !options.yes) {
             logger.warn(`Agent "${name}" already exists at ${finalPath}`);
             continue;
@@ -46,13 +56,14 @@ export async function installAgent(options: InstallOptions): Promise<void> {
             }
             logger.success(`Copied agent "${name}" to ${finalPath}`);
           } else {
-            const sourceDir = tempDir;
+            const sourcePath = agentFile.path;
+            const linkType = isDirectory(sourcePath) ? 'dir' : 'file';
             try {
-              symlinkSync(sourceDir, finalPath, 'dir');
+              symlinkSync(sourcePath, finalPath, linkType);
               logger.success(`Symlinked agent "${name}" to ${finalPath}`);
             } catch (err) {
               logger.warn(`Failed to create symlink, copying instead: ${err}`);
-              copyDirectory(sourceDir, join(targetPath, name));
+              copyDirectory(sourcePath, join(targetPath, name));
               logger.success(`Copied agent "${name}" to ${targetPath}`);
             }
           }
@@ -60,7 +71,7 @@ export async function installAgent(options: InstallOptions): Promise<void> {
       }
     }
   } finally {
-    if (existsSync(tempDir) && tempDir.startsWith(tmpdir())) {
+    if (!selectedAgents && existsSync(tempDir) && tempDir.startsWith(tmpdir())) {
       rmSync(tempDir, { recursive: true, force: true });
     }
   }

package/src/types/index.ts

@@ -70,9 +70,11 @@ export type AgentPlatform =
 
 export interface InstallOptions {
   source: string;
+  sourcePath?: string;
   global: boolean;
   platforms: AgentPlatform[];
   agentName?: string;
   copy: boolean;
   yes: boolean;
+  selectedAgents?: AgentFile[];
 }