@orderful/droid 0.10.5 → 0.11.0

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