@orderful/droid 0.10.5 → 0.11.1

package/src/commands/uninstall.ts

@@ -1,16 +1,27 @@
 import chalk from 'chalk';
-import { uninstallSkill, isSkillInstalled } from '../lib/skills.js';
+import { uninstallSkill } from '../lib/skills.js';
+import { getBundledTools, isToolInstalled } from '../lib/tools.js';
 
-export async function uninstallCommand(skillName: string): Promise<void> {
-  if (!isSkillInstalled(skillName)) {
-    console.error(chalk.red(`\n✗ Skill '${skillName}' is not installed`));
+export async function uninstallCommand(toolName: string): Promise<void> {
+  const tools = getBundledTools();
+  const tool = tools.find((t) => t.name === toolName);
+
+  if (!tool) {
+    console.error(chalk.red(`\n✗ Tool '${toolName}' not found`));
+    process.exit(1);
+  }
+
+  if (!isToolInstalled(toolName)) {
+    console.error(chalk.red(`\n✗ Tool '${toolName}' is not installed`));
     process.exit(1);
   }
 
-  const result = uninstallSkill(skillName);
+  // Uninstall via primary skill
+  const primarySkill = tool.includes.skills.find(s => s.required)?.name || toolName;
+  const result = uninstallSkill(primarySkill);
 
   if (result.success) {
-    console.log(chalk.green(`\n✓ ${result.message}`));
+    console.log(chalk.green(`\n✓ Uninstalled ${toolName}`));
   } else {
     console.error(chalk.red(`\n✗ ${result.message}`));
     process.exit(1);

package/src/commands/update.ts

@@ -3,22 +3,22 @@ import { execSync } from 'child_process';
 import { getVersion } from '../lib/version.js';
 
 interface UpdateOptions {
-  skills?: boolean;
+  tools?: boolean;
   cli?: boolean;
 }
 
-export async function updateCommand(skill?: string, options?: UpdateOptions): Promise<void> {
-  // If specific skill specified, update just that skill
-  if (skill) {
-    console.log(chalk.yellow('\n⚠ Per-skill updates not implemented yet'));
-    console.log(chalk.gray('Skills are bundled with the CLI - run `droid update` to update all.'));
+export async function updateCommand(tool?: string, options?: UpdateOptions): Promise<void> {
+  // If specific tool specified, update just that tool
+  if (tool) {
+    console.log(chalk.yellow('\n⚠ Per-tool updates not implemented yet'));
+    console.log(chalk.gray('Tools are bundled with the CLI - run `droid update` to update all.'));
     return;
   }
 
-  // If --skills flag, update skills only
-  if (options?.skills) {
-    console.log(chalk.yellow('\n⚠ Skill-only updates not implemented yet'));
-    console.log(chalk.gray('Skills are bundled with the CLI - run `droid update` to update all.'));
+  // If --tools flag, update tools only
+  if (options?.tools) {
+    console.log(chalk.yellow('\n⚠ Tool-only updates not implemented yet'));
+    console.log(chalk.gray('Tools are bundled with the CLI - run `droid update` to update all.'));
     return;
   }
 

package/src/lib/agents.ts

@@ -1,24 +1,19 @@
 import { existsSync, readdirSync, readFileSync, writeFileSync, unlinkSync, mkdirSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import { homedir } from 'os';
 import YAML from 'yaml';
 import { loadConfig } from './config.js';
-import { AITool } from './types.js';
+import { Platform } from './types.js';
+import { getAgentsPath } from './platforms.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const BUNDLED_AGENTS_DIR = join(__dirname, '../agents');
+const BUNDLED_TOOLS_DIR = join(__dirname, '../tools');
 
 /**
- * Get the installation path for agents based on AI tool
+ * Get the installation path for agents based on platform
  */
-export function getAgentsInstallPath(aiTool: AITool): string {
-  switch (aiTool) {
-    case AITool.ClaudeCode:
-      return join(homedir(), '.claude', 'agents');
-    case AITool.OpenCode:
-      return join(homedir(), '.config', 'opencode', 'agent');
-  }
+export function getAgentsInstallPath(platform: Platform): string {
+  return getAgentsPath(platform);
 }
 
 /**
@@ -37,13 +32,6 @@ export interface AgentManifest {
   persona?: string;
 }
 
-/**
- * Get the path to bundled agents directory
- */
-export function getBundledAgentsDir(): string {
-  return BUNDLED_AGENTS_DIR;
-}
-
 /**
  * Load an agent manifest from an agent directory
  */
@@ -63,20 +51,31 @@ export function loadAgentManifest(agentDir: string): AgentManifest | null {
 }
 
 /**
- * Get all bundled agents (standalone + skill-bundled)
+ * Get all bundled agents from tools
  */
 export function getBundledAgents(): AgentManifest[] {
   const agents: AgentManifest[] = [];
   const seenNames = new Set<string>();
 
-  // Get standalone agents from src/agents/
-  if (existsSync(BUNDLED_AGENTS_DIR)) {
-    const agentDirs = readdirSync(BUNDLED_AGENTS_DIR, { withFileTypes: true })
+  if (!existsSync(BUNDLED_TOOLS_DIR)) {
+    return agents;
+  }
+
+  // Get agents from tools/*/agents/
+  const toolDirs = readdirSync(BUNDLED_TOOLS_DIR, { withFileTypes: true })
+    .filter((dirent) => dirent.isDirectory())
+    .map((dirent) => dirent.name);
+
+  for (const toolName of toolDirs) {
+    const toolAgentsDir = join(BUNDLED_TOOLS_DIR, toolName, 'agents');
+    if (!existsSync(toolAgentsDir)) continue;
+
+    const agentDirs = readdirSync(toolAgentsDir, { withFileTypes: true })
       .filter((dirent) => dirent.isDirectory())
       .map((dirent) => dirent.name);
 
     for (const agentDir of agentDirs) {
-      const manifest = loadAgentManifest(join(BUNDLED_AGENTS_DIR, agentDir));
+      const manifest = loadAgentManifest(join(toolAgentsDir, agentDir));
       if (manifest && !seenNames.has(manifest.name)) {
         agents.push(manifest);
         seenNames.add(manifest.name);
@@ -84,36 +83,12 @@ export function getBundledAgents(): AgentManifest[] {
     }
   }
 
-  // Get skill-bundled agents from src/skills/*/agents/
-  const skillsDir = join(__dirname, '../skills');
-  if (existsSync(skillsDir)) {
-    const skillDirs = readdirSync(skillsDir, { withFileTypes: true })
-      .filter((dirent) => dirent.isDirectory())
-      .map((dirent) => dirent.name);
-
-    for (const skillName of skillDirs) {
-      const skillAgentsDir = join(skillsDir, skillName, 'agents');
-      if (!existsSync(skillAgentsDir)) continue;
-
-      const agentDirs = readdirSync(skillAgentsDir, { withFileTypes: true })
-        .filter((dirent) => dirent.isDirectory())
-        .map((dirent) => dirent.name);
-
-      for (const agentDir of agentDirs) {
-        const manifest = loadAgentManifest(join(skillAgentsDir, agentDir));
-        if (manifest && !seenNames.has(manifest.name)) {
-          agents.push(manifest);
-          seenNames.add(manifest.name);
-        }
-      }
-    }
-  }
-
   return agents;
 }
 
 /**
  * Get agent status display string
+ * Note: Not currently used, kept for future TUI agent status display
  */
 export function getAgentStatusDisplay(status?: string): string {
   switch (status) {
@@ -128,11 +103,11 @@ export function getAgentStatusDisplay(status?: string): string {
 }
 
 /**
- * Get installed agents directory for the configured AI tool
+ * Get installed agents directory for the configured platform
  */
 export function getInstalledAgentsDir(): string {
   const config = loadConfig();
-  return getAgentsInstallPath(config.ai_tool);
+  return getAgentsInstallPath(config.platform);
 }
 
 /**
@@ -140,7 +115,7 @@ export function getInstalledAgentsDir(): string {
  */
 export function isAgentInstalled(agentName: string): boolean {
   const config = loadConfig();
-  const agentsDir = getAgentsInstallPath(config.ai_tool);
+  const agentsDir = getAgentsInstallPath(config.platform);
   const agentPath = join(agentsDir, `${agentName}.md`);
   return existsSync(agentPath);
 }
@@ -221,13 +196,13 @@ export function installAgentFromPath(agentDir: string, agentName: string): { suc
       agentContent = manifest.persona;
     }
 
-    // Generate format based on AI tool
-    const installedContent = config.ai_tool === AITool.ClaudeCode
+    // Generate format based on platform
+    const installedContent = config.platform === Platform.ClaudeCode
       ? generateClaudeCodeAgent(manifest, agentContent)
       : generateOpenCodeAgent(manifest, agentContent);
 
     // Ensure agents directory exists
-    const agentsDir = getAgentsInstallPath(config.ai_tool);
+    const agentsDir = getAgentsInstallPath(config.platform);
     if (!existsSync(agentsDir)) {
       mkdirSync(agentsDir, { recursive: true });
     }
@@ -236,7 +211,7 @@ export function installAgentFromPath(agentDir: string, agentName: string): { suc
     const outputPath = join(agentsDir, `${agentName}.md`);
     writeFileSync(outputPath, installedContent);
 
-    const targetDir = config.ai_tool === AITool.ClaudeCode
+    const targetDir = config.platform === Platform.ClaudeCode
       ? '~/.claude/agents/'
       : '~/.config/opencode/agent/';
 
@@ -247,11 +222,36 @@ export function installAgentFromPath(agentDir: string, agentName: string): { suc
 }
 
 /**
- * Install an agent from the bundled agents directory
+ * Find the path to an agent within the tools directory structure
+ */
+export function findAgentPath(agentName: string): string | null {
+  if (!existsSync(BUNDLED_TOOLS_DIR)) {
+    return null;
+  }
+
+  const toolDirs = readdirSync(BUNDLED_TOOLS_DIR, { withFileTypes: true })
+    .filter((dirent) => dirent.isDirectory())
+    .map((dirent) => dirent.name);
+
+  for (const toolName of toolDirs) {
+    const agentDir = join(BUNDLED_TOOLS_DIR, toolName, 'agents', agentName);
+    if (existsSync(agentDir) && existsSync(join(agentDir, 'AGENT.yaml'))) {
+      return agentDir;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Install an agent from the tools directory
  * Combines AGENT.yaml metadata with AGENT.md content into a single .md file
  */
 export function installAgent(agentName: string): { success: boolean; message: string } {
-  const agentDir = join(BUNDLED_AGENTS_DIR, agentName);
+  const agentDir = findAgentPath(agentName);
+  if (!agentDir) {
+    return { success: false, message: `Agent '${agentName}' not found` };
+  }
   return installAgentFromPath(agentDir, agentName);
 }
 
@@ -260,7 +260,7 @@ export function installAgent(agentName: string): { success: boolean; message: st
  */
 export function uninstallAgent(agentName: string): { success: boolean; message: string } {
   const config = loadConfig();
-  const agentsDir = getAgentsInstallPath(config.ai_tool);
+  const agentsDir = getAgentsInstallPath(config.platform);
   const agentPath = join(agentsDir, `${agentName}.md`);
 
   if (!existsSync(agentPath)) {

package/src/lib/config.test.ts

@@ -3,16 +3,6 @@ import { existsSync, mkdirSync, rmSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';
 import YAML from 'yaml';
-import { AITool, BuiltInOutput } from './types.js';
-
-describe('config types', () => {
-  it('should have correct enum values', () => {
-    expect(AITool.ClaudeCode).toBe('claude-code');
-    expect(AITool.OpenCode).toBe('opencode');
-    expect(BuiltInOutput.Terminal).toBe('terminal');
-    expect(BuiltInOutput.Editor).toBe('editor');
-  });
-});
 
 describe('config value parsing', () => {
   it('should parse dot notation keys correctly', () => {

package/src/lib/config.ts

@@ -2,19 +2,49 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
 import YAML from 'yaml';
-import { AITool, BuiltInOutput, type DroidConfig, type SkillOverrides } from './types.js';
+import { Platform, BuiltInOutput, type DroidConfig, type LegacyDroidConfig, type SkillOverrides } from './types.js';
 
 const CONFIG_DIR = join(homedir(), '.droid');
 const CONFIG_FILE = join(CONFIG_DIR, 'config.yaml');
 
 const DEFAULT_CONFIG: DroidConfig = {
-  ai_tool: AITool.ClaudeCode,
+  platform: Platform.ClaudeCode,
   user_mention: '@user',
   output_preference: BuiltInOutput.Terminal,
   git_username: '',
-  skills: {},
+  platforms: {},
 };
 
+/**
+ * Migrate legacy config (v1) to new config format (v2)
+ * v1: ai_tool + skills flat
+ * v2: platform + platforms map with per-platform tools
+ */
+function migrateConfig(config: Partial<DroidConfig> & Partial<LegacyDroidConfig>): DroidConfig {
+  // Check if this is a legacy config (has ai_tool, no platform)
+  if ('ai_tool' in config && !('platform' in config)) {
+    const legacyConfig = config as LegacyDroidConfig;
+    return {
+      platform: legacyConfig.ai_tool,
+      user_mention: legacyConfig.user_mention ?? DEFAULT_CONFIG.user_mention,
+      output_preference: legacyConfig.output_preference ?? DEFAULT_CONFIG.output_preference,
+      git_username: legacyConfig.git_username ?? DEFAULT_CONFIG.git_username,
+      platforms: {
+        [legacyConfig.ai_tool]: {
+          tools: legacyConfig.skills ?? {},
+        },
+      },
+    };
+  }
+
+  // Already new format, just ensure defaults
+  return {
+    ...DEFAULT_CONFIG,
+    ...config,
+    platforms: config.platforms ?? {},
+  };
+}
+
 /**
  * Ensure the config directory exists
  */
@@ -33,6 +63,7 @@ export function configExists(): boolean {
 
 /**
  * Load the global config, or return defaults if none exists
+ * Automatically migrates legacy config format to new format
  */
 export function loadConfig(): DroidConfig {
   ensureConfigDir();
@@ -43,8 +74,19 @@ export function loadConfig(): DroidConfig {
 
   try {
     const content = readFileSync(CONFIG_FILE, 'utf-8');
-    const config = YAML.parse(content) as Partial<DroidConfig>;
-    return { ...DEFAULT_CONFIG, ...config };
+    const rawConfig = YAML.parse(content) as Partial<DroidConfig> & Partial<LegacyDroidConfig>;
+
+    // Check if migration is needed
+    // TODO: Remove after v0.14.0 (target: late Jan 2025)
+    const needsMigration = 'ai_tool' in rawConfig && !('platform' in rawConfig);
+    const config = migrateConfig(rawConfig);
+
+    // Save migrated config if it was migrated
+    if (needsMigration) {
+      saveConfig(config);
+    }
+
+    return config;
   } catch (error) {
     const message = error instanceof Error ? error.message : 'Unknown error';
     console.error(`Error reading config: ${message}`);

package/src/lib/platforms.ts

@@ -0,0 +1,59 @@
+import { join } from 'path';
+import { homedir } from 'os';
+import { Platform } from './types.js';
+
+/**
+ * Platform-specific paths configuration
+ * Single source of truth for all platform-specific directories
+ */
+export const PLATFORM_PATHS = {
+  [Platform.ClaudeCode]: {
+    skills: join(homedir(), '.claude', 'skills'),
+    commands: join(homedir(), '.claude', 'commands'),
+    agents: join(homedir(), '.claude', 'agents'),
+    config: join(homedir(), '.claude', 'CLAUDE.md'),
+  },
+  [Platform.OpenCode]: {
+    skills: join(homedir(), '.config', 'opencode', 'skills'),
+    commands: join(homedir(), '.config', 'opencode', 'command'),
+    agents: join(homedir(), '.config', 'opencode', 'agent'),
+    config: join(homedir(), '.config', 'opencode', 'AGENTS.md'),
+  },
+} as const;
+
+export type PlatformPaths = typeof PLATFORM_PATHS[Platform];
+
+/**
+ * Get all paths for a platform
+ */
+export function getPlatformPaths(platform: Platform): PlatformPaths {
+  return PLATFORM_PATHS[platform];
+}
+
+/**
+ * Get skills install path for a platform
+ */
+export function getSkillsPath(platform: Platform): string {
+  return PLATFORM_PATHS[platform].skills;
+}
+
+/**
+ * Get commands install path for a platform
+ */
+export function getCommandsPath(platform: Platform): string {
+  return PLATFORM_PATHS[platform].commands;
+}
+
+/**
+ * Get agents install path for a platform
+ */
+export function getAgentsPath(platform: Platform): string {
+  return PLATFORM_PATHS[platform].agents;
+}
+
+/**
+ * Get platform config file path (CLAUDE.md or AGENTS.md)
+ */
+export function getConfigPath(platform: Platform): string {
+  return PLATFORM_PATHS[platform].config;
+}

package/src/lib/skills.test.ts

@@ -4,11 +4,11 @@ import { join } from 'path';
 import { tmpdir } from 'os';
 import { homedir } from 'os';
 import YAML from 'yaml';
-import { AITool, SkillStatus } from './types.js';
+import { Platform, SkillStatus } from './types.js';
 import {
   getSkillsInstallPath,
   getCommandsInstallPath,
-  getAIConfigPath,
+  getPlatformConfigPath,
   getSkillStatusDisplay,
   getBundledSkillsDir,
 } from './skills.js';
@@ -28,44 +28,44 @@ function parseFrontmatter(content: string): Record<string, unknown> | null {
 
 describe('getSkillsInstallPath', () => {
   it('should return Claude Code path', () => {
-    const path = getSkillsInstallPath(AITool.ClaudeCode);
+    const path = getSkillsInstallPath(Platform.ClaudeCode);
     expect(path).toBe(join(homedir(), '.claude', 'skills'));
   });
 
   it('should return OpenCode path', () => {
-    const path = getSkillsInstallPath(AITool.OpenCode);
+    const path = getSkillsInstallPath(Platform.OpenCode);
     expect(path).toBe(join(homedir(), '.config', 'opencode', 'skills'));
   });
 });
 
 describe('getCommandsInstallPath', () => {
   it('should return Claude Code commands path', () => {
-    const path = getCommandsInstallPath(AITool.ClaudeCode);
+    const path = getCommandsInstallPath(Platform.ClaudeCode);
     expect(path).toBe(join(homedir(), '.claude', 'commands'));
   });
 
   it('should return OpenCode commands path', () => {
-    const path = getCommandsInstallPath(AITool.OpenCode);
+    const path = getCommandsInstallPath(Platform.OpenCode);
     expect(path).toBe(join(homedir(), '.config', 'opencode', 'command'));
   });
 });
 
-describe('getAIConfigPath', () => {
+describe('getPlatformConfigPath', () => {
   it('should return Claude Code CLAUDE.md path', () => {
-    const path = getAIConfigPath(AITool.ClaudeCode);
+    const path = getPlatformConfigPath(Platform.ClaudeCode);
     expect(path).toBe(join(homedir(), '.claude', 'CLAUDE.md'));
   });
 
   it('should return OpenCode AGENTS.md path', () => {
-    const path = getAIConfigPath(AITool.OpenCode);
+    const path = getPlatformConfigPath(Platform.OpenCode);
     expect(path).toBe(join(homedir(), '.config', 'opencode', 'AGENTS.md'));
   });
 });
 
 describe('getBundledSkillsDir', () => {
-  it('should return a path ending in skills', () => {
+  it('should return a path ending in tools', () => {
     const dir = getBundledSkillsDir();
-    expect(dir.endsWith('skills')).toBe(true);
+    expect(dir.endsWith('tools')).toBe(true);
   });
 
   it('should return an existing directory', () => {
@@ -150,15 +150,44 @@ describe('skill manifest parsing', () => {
   });
 });
 
-describe('bundled skills validation', () => {
-  it('all skills should have SKILL.md with valid frontmatter', () => {
-    const skillsDir = getBundledSkillsDir();
+/**
+ * Helper to get all skill directories in the new tools/{tool}/skills/{skill} structure
+ */
+function getAllSkillPaths(toolsDir: string): Array<{ skillName: string; skillDir: string }> {
+  const skillPaths: Array<{ skillName: string; skillDir: string }> = [];
+
+  const toolDirs = readdirSync(toolsDir, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name);
+
+  for (const toolName of toolDirs) {
+    const skillsDir = join(toolsDir, toolName, 'skills');
+    if (!existsSync(skillsDir)) continue;
+
     const skillDirs = readdirSync(skillsDir, { withFileTypes: true })
       .filter((d) => d.isDirectory())
       .map((d) => d.name);
 
     for (const skillName of skillDirs) {
-      const skillMdPath = join(skillsDir, skillName, 'SKILL.md');
+      skillPaths.push({
+        skillName,
+        skillDir: join(skillsDir, skillName),
+      });
+    }
+  }
+
+  return skillPaths;
+}
+
+describe('bundled skills validation', () => {
+  it('all skills should have SKILL.md with valid frontmatter', () => {
+    const toolsDir = getBundledSkillsDir();
+    const skillPaths = getAllSkillPaths(toolsDir);
+
+    expect(skillPaths.length).toBeGreaterThan(0);
+
+    for (const { skillName, skillDir } of skillPaths) {
+      const skillMdPath = join(skillDir, 'SKILL.md');
       expect(existsSync(skillMdPath)).toBe(true);
 
       const content = readFileSync(skillMdPath, 'utf-8');
@@ -171,13 +200,11 @@ describe('bundled skills validation', () => {
   });
 
   it('all skills should have SKILL.yaml manifest', () => {
-    const skillsDir = getBundledSkillsDir();
-    const skillDirs = readdirSync(skillsDir, { withFileTypes: true })
-      .filter((d) => d.isDirectory())
-      .map((d) => d.name);
+    const toolsDir = getBundledSkillsDir();
+    const skillPaths = getAllSkillPaths(toolsDir);
 
-    for (const skillName of skillDirs) {
-      const yamlPath = join(skillsDir, skillName, 'SKILL.yaml');
+    for (const { skillName, skillDir } of skillPaths) {
+      const yamlPath = join(skillDir, 'SKILL.yaml');
       expect(existsSync(yamlPath)).toBe(true);
 
       const content = readFileSync(yamlPath, 'utf-8');
@@ -190,14 +217,12 @@ describe('bundled skills validation', () => {
   });
 
   it('SKILL.md frontmatter should match SKILL.yaml', () => {
-    const skillsDir = getBundledSkillsDir();
-    const skillDirs = readdirSync(skillsDir, { withFileTypes: true })
-      .filter((d) => d.isDirectory())
-      .map((d) => d.name);
+    const toolsDir = getBundledSkillsDir();
+    const skillPaths = getAllSkillPaths(toolsDir);
 
-    for (const skillName of skillDirs) {
-      const mdPath = join(skillsDir, skillName, 'SKILL.md');
-      const yamlPath = join(skillsDir, skillName, 'SKILL.yaml');
+    for (const { skillDir } of skillPaths) {
+      const mdPath = join(skillDir, 'SKILL.md');
+      const yamlPath = join(skillDir, 'SKILL.yaml');
 
       const mdContent = readFileSync(mdPath, 'utf-8');
       const yamlContent = readFileSync(yamlPath, 'utf-8');