@orderful/droid 0.10.4 → 0.11.0

package/src/commands/setup.ts

@@ -6,7 +6,7 @@ import { join } from 'path';
 import { homedir } from 'os';
 import { loadConfig, saveConfig, configExists } from '../lib/config.js';
 import { getBundledSkills } from '../lib/skills.js';
-import { AITool, BuiltInOutput, type DroidConfig, type OutputPreference } from '../lib/types.js';
+import { Platform, BuiltInOutput, type DroidConfig, type OutputPreference } from '../lib/types.js';
 
 /**
  * Permissions droid needs to operate without constant prompts
@@ -20,19 +20,19 @@ const DROID_PERMISSIONS = [
 ];
 
 /**
- * Detect which AI tool is installed
+ * Detect which platform is installed
  */
-function detectAITool(): AITool | null {
+function detectPlatform(): Platform | null {
   try {
     execSync('claude --version', { stdio: 'ignore' });
-    return AITool.ClaudeCode;
+    return Platform.ClaudeCode;
   } catch {
     // Claude Code not found
   }
 
   try {
     execSync('opencode --version', { stdio: 'ignore' });
-    return AITool.OpenCode;
+    return Platform.OpenCode;
   } catch {
     // OpenCode not found
   }
@@ -59,12 +59,12 @@ function detectGitUsername(): string {
 const OPENCODE_SKILLS_PLUGIN = 'opencode-skills';
 
 /**
- * Configure AI tool permissions for droid
+ * Configure platform permissions for droid
  */
-export function configureAIToolPermissions(aiTool: AITool): { added: string[]; alreadyPresent: boolean; error?: string } {
+export function configurePlatformPermissions(platform: Platform): { added: string[]; alreadyPresent: boolean; error?: string } {
   const added: string[] = [];
 
-  if (aiTool === AITool.ClaudeCode) {
+  if (platform === Platform.ClaudeCode) {
     const settingsPath = join(homedir(), '.claude', 'settings.json');
 
     // Ensure .claude directory exists
@@ -113,7 +113,7 @@ export function configureAIToolPermissions(aiTool: AITool): { added: string[]; a
     return { added, alreadyPresent: added.length === 0 };
   }
 
-  if (aiTool === AITool.OpenCode) {
+  if (platform === Platform.OpenCode) {
     // OpenCode uses opencode.json for config
     // Check global config location: ~/.config/opencode/opencode.json
     const globalConfigDir = join(homedir(), '.config', 'opencode');
@@ -188,8 +188,8 @@ function getOutputOptions(): Array<{ name: string; value: OutputPreference }> {
 export async function setupCommand(): Promise<void> {
   console.log(chalk.bold('\n🤖 Droid Setup\n'));
 
-  const existingConfig = configExists();
-  if (existingConfig) {
+  const hasExistingConfig = configExists();
+  if (hasExistingConfig) {
     const { overwrite } = await inquirer.prompt<{ overwrite: boolean }>([
       {
         type: 'confirm',
@@ -205,12 +205,12 @@ export async function setupCommand(): Promise<void> {
     }
   }
 
-  // Detect AI tool
-  const detectedTool = detectAITool();
-  if (detectedTool) {
-    console.log(chalk.green(`✓ Detected ${detectedTool}\n`));
+  // Detect platform
+  const detectedPlatform = detectPlatform();
+  if (detectedPlatform) {
+    console.log(chalk.green(`✓ Detected ${detectedPlatform}\n`));
   } else {
-    console.log(chalk.yellow('⚠ No AI tool detected (Claude Code or OpenCode)\n'));
+    console.log(chalk.yellow('⚠ No platform detected (Claude Code or OpenCode)\n'));
   }
 
   // Detect git username
@@ -220,20 +220,20 @@ export async function setupCommand(): Promise<void> {
   const outputOptions = getOutputOptions();
 
   const answers = await inquirer.prompt<{
-    ai_tool: AITool;
+    platform: Platform;
     user_mention: string;
     output_preference: OutputPreference;
     git_username: string;
   }>([
     {
       type: 'list',
-      name: 'ai_tool',
-      message: 'Which AI tool are you using?',
+      name: 'platform',
+      message: 'Which platform are you using?',
       choices: [
-        { name: 'Claude Code', value: AITool.ClaudeCode },
-        { name: 'OpenCode', value: AITool.OpenCode },
+        { name: 'Claude Code', value: Platform.ClaudeCode },
+        { name: 'OpenCode', value: Platform.OpenCode },
       ],
-      default: detectedTool || AITool.ClaudeCode,
+      default: detectedPlatform || Platform.ClaudeCode,
     },
     {
       type: 'input',
@@ -260,27 +260,31 @@ export async function setupCommand(): Promise<void> {
     },
   ]);
 
+  const existingConfig = loadConfig();
   const config: DroidConfig = {
-    ...loadConfig(),
-    ...answers,
+    ...existingConfig,
+    platform: answers.platform,
+    user_mention: answers.user_mention,
+    output_preference: answers.output_preference,
+    git_username: answers.git_username,
   };
 
   saveConfig(config);
 
   console.log(chalk.green('\n✓ Config saved to ~/.droid/config.yaml'));
 
-  // Configure AI tool permissions/plugins
-  const { added, alreadyPresent, error } = configureAIToolPermissions(answers.ai_tool);
+  // Configure platform permissions/plugins
+  const { added, alreadyPresent, error } = configurePlatformPermissions(answers.platform);
   if (error) {
     console.log(chalk.red(`✗ ${error}`));
-    console.log(chalk.yellow('  You may need to manually configure your AI tool'));
-  } else if (answers.ai_tool === AITool.ClaudeCode) {
+    console.log(chalk.yellow('  You may need to manually configure your platform'));
+  } else if (answers.platform === Platform.ClaudeCode) {
     if (added.length > 0) {
       console.log(chalk.green(`✓ Added droid permissions to Claude Code settings`));
     } else if (alreadyPresent) {
       console.log(chalk.gray(`  Droid permissions already configured in Claude Code`));
     }
-  } else if (answers.ai_tool === AITool.OpenCode) {
+  } else if (answers.platform === Platform.OpenCode) {
     if (added.length > 0) {
       console.log(chalk.green(`✓ Added opencode-skills plugin to OpenCode config`));
       console.log(chalk.gray(`  This enables Claude Code-style skills in OpenCode`));

package/src/commands/skills.ts

@@ -1,59 +1,49 @@
 import inquirer from 'inquirer';
 import chalk from 'chalk';
-import { join } from 'path';
-import {
-  getBundledSkills,
-  getBundledSkillsDir,
-  isSkillInstalled,
-  getInstalledSkill,
-  getSkillStatusDisplay,
-  installSkill,
-  uninstallSkill,
-  loadSkillManifest,
-} from '../lib/skills.js';
+import { installSkill, uninstallSkill } from '../lib/skills.js';
+import { getBundledTools, isToolInstalled, getInstalledToolVersion } from '../lib/tools.js';
 import { promptForSkillConfig } from '../lib/skill-config.js';
-import { SkillStatus, type SkillManifest } from '../lib/types.js';
+import { SkillStatus, type ToolManifest } from '../lib/types.js';
 
-function formatSkillChoice(skill: SkillManifest): string {
-  const installed = isSkillInstalled(skill.name);
-  const installedInfo = getInstalledSkill(skill.name);
-  const statusDisplay = getSkillStatusDisplay(skill.status);
+function formatToolChoice(tool: ToolManifest): string {
+  const installed = isToolInstalled(tool.name);
+  const installedVersion = getInstalledToolVersion(tool.name);
 
-  let line = `${skill.name}`;
+  let line = `${tool.name}`;
 
-  if (installed && installedInfo) {
-    line += chalk.green(` [installed] v${installedInfo.version}`);
+  if (installed && installedVersion) {
+    line += chalk.green(` [installed] v${installedVersion}`);
   } else {
-    line += chalk.gray(` v${skill.version}`);
+    line += chalk.gray(` v${tool.version}`);
   }
 
-  if (statusDisplay) {
-    const color =
-      skill.status === SkillStatus.Alpha
+  if (tool.status) {
+    const statusColor =
+      tool.status === SkillStatus.Alpha
         ? chalk.red
-        : skill.status === SkillStatus.Beta
+        : tool.status === SkillStatus.Beta
           ? chalk.yellow
           : chalk.white;
-    line += ` ${color(statusDisplay)}`;
+    line += statusColor(` [${tool.status}]`);
   }
 
   return line;
 }
 
 export async function skillsCommand(): Promise<void> {
-  const skills = getBundledSkills();
+  const tools = getBundledTools();
 
-  if (skills.length === 0) {
-    console.log(chalk.yellow('\nNo skills available yet.'));
+  if (tools.length === 0) {
+    console.log(chalk.yellow('\nNo tools available yet.'));
     return;
   }
 
-  console.log(chalk.bold('\n🤖 Available Skills\n'));
+  console.log(chalk.bold('\n🤖 Available Tools\n'));
 
-  const skillChoices = skills.map((skill) => ({
-    name: formatSkillChoice(skill),
-    value: skill.name,
-    short: skill.name,
+  const toolChoices = tools.map((tool) => ({
+    name: formatToolChoice(tool),
+    value: tool.name,
+    short: tool.name,
   }));
 
   const choices = [
@@ -62,42 +52,54 @@ export async function skillsCommand(): Promise<void> {
       value: '__exit__',
       short: 'Exit',
     },
-    ...skillChoices,
+    ...toolChoices,
   ];
 
-  const { selectedSkill } = await inquirer.prompt<{ selectedSkill: string }>([
+  const { selectedTool } = await inquirer.prompt<{ selectedTool: string }>([
     {
       type: 'list',
-      name: 'selectedSkill',
-      message: 'Select a skill to view details or install:',
+      name: 'selectedTool',
+      message: 'Select a tool to view details or install:',
       choices,
       pageSize: 15,
     },
   ]);
 
-  if (selectedSkill === '__exit__') {
+  if (selectedTool === '__exit__') {
     return;
   }
 
-  const skill = skills.find((s) => s.name === selectedSkill);
-  if (!skill) {
-    console.error(chalk.red('Skill not found'));
+  const tool = tools.find((t) => t.name === selectedTool);
+  if (!tool) {
+    console.error(chalk.red('Tool not found'));
     return;
   }
 
-  // Show skill details
-  console.log(chalk.bold(`\n📦 ${skill.name}`));
-  console.log(chalk.gray(`Version: ${skill.version}`));
-  if (skill.status) {
-    console.log(chalk.gray(`Status: ${skill.status}`));
+  // Show tool details
+  console.log(chalk.bold(`\n📦 ${tool.name}`));
+  console.log(chalk.gray(`Version: ${tool.version}`));
+  if (tool.status) {
+    console.log(chalk.gray(`Status: ${tool.status}`));
   }
-  console.log(`\n${skill.description}`);
+  console.log(`\n${tool.description}`);
 
-  if (skill.dependencies && skill.dependencies.length > 0) {
-    console.log(chalk.gray(`\nDependencies: ${skill.dependencies.join(', ')}`));
+  // Show what the tool includes
+  const skillNames = tool.includes.skills.map(s => s.name);
+  const commandNames = tool.includes.commands.map(c => `/${c}`);
+  const agentNames = tool.includes.agents;
+
+  if (skillNames.length > 0) {
+    console.log(chalk.gray(`\nSkills: ${skillNames.join(', ')}`));
+  }
+  if (commandNames.length > 0) {
+    console.log(chalk.gray(`Commands: ${commandNames.join(', ')}`));
+  }
+  if (agentNames.length > 0) {
+    console.log(chalk.gray(`Agents: ${agentNames.join(', ')}`));
   }
 
-  const installed = isSkillInstalled(skill.name);
+  const installed = isToolInstalled(tool.name);
+  const primarySkill = tool.includes.skills.find(s => s.required)?.name || tool.name;
 
   const actions = installed
     ? [
@@ -121,17 +123,15 @@ export async function skillsCommand(): Promise<void> {
 
   switch (action) {
     case 'install': {
-      const result = installSkill(skill.name);
+      const result = installSkill(primarySkill);
       if (result.success) {
-        console.log(chalk.green(`\n✓ ${result.message}`));
-        // Prompt for config if skill has options
-        const manifest = loadSkillManifest(join(getBundledSkillsDir(), skill.name));
-        if (manifest?.config_schema && Object.keys(manifest.config_schema).length > 0) {
-          // If any config option lacks a default, go straight to config (it's required)
-          const hasRequiredConfig = Object.values(manifest.config_schema).some(
+        console.log(chalk.green(`\n✓ Installed ${tool.name}`));
+        // Prompt for config if tool has options
+        if (tool.config_schema && Object.keys(tool.config_schema).length > 0) {
+          const hasRequiredConfig = Object.values(tool.config_schema).some(
             (option) => option.default === undefined
           );
-          await promptForSkillConfig(skill.name, manifest.config_schema, !hasRequiredConfig);
+          await promptForSkillConfig(primarySkill, tool.config_schema, !hasRequiredConfig);
         }
       } else {
         console.log(chalk.red(`\n✗ ${result.message}`));
@@ -139,18 +139,17 @@ export async function skillsCommand(): Promise<void> {
       break;
     }
     case 'configure': {
-      const manifest = loadSkillManifest(join(getBundledSkillsDir(), skill.name));
-      if (manifest?.config_schema && Object.keys(manifest.config_schema).length > 0) {
-        await promptForSkillConfig(skill.name, manifest.config_schema, false);
+      if (tool.config_schema && Object.keys(tool.config_schema).length > 0) {
+        await promptForSkillConfig(primarySkill, tool.config_schema, false);
       } else {
-        console.log(chalk.gray('\nThis skill has no configuration options.'));
+        console.log(chalk.gray('\nThis tool has no configuration options.'));
       }
       break;
     }
     case 'uninstall': {
-      const result = uninstallSkill(skill.name);
+      const result = uninstallSkill(primarySkill);
       if (result.success) {
-        console.log(chalk.green(`\n✓ ${result.message}`));
+        console.log(chalk.green(`\n✓ Uninstalled ${tool.name}`));
       } else {
         console.log(chalk.red(`\n✗ ${result.message}`));
       }