@orderful/droid 0.10.4 → 0.11.0

package/src/lib/skills.ts

@@ -1,67 +1,52 @@
 import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, rmSync } from 'fs';
 import { join, dirname } from 'path';
-import { homedir } from 'os';
 import { fileURLToPath } from 'url';
 import YAML from 'yaml';
 import { loadConfig, saveConfig } from './config.js';
-import { AITool, SkillStatus, type SkillManifest, type InstalledSkill } from './types.js';
+import { Platform, SkillStatus, type SkillManifest, type InstalledSkill, getPlatformTools, setPlatformTools } from './types.js';
 import { getInstalledAgentsDir, installAgentFromPath, uninstallAgent, isAgentInstalled } from './agents.js';
+import { getSkillsPath, getCommandsPath, getConfigPath } from './platforms.js';
 
 // Marker comments for CLAUDE.md skill registration
 const DROID_SKILLS_START = '<!-- droid-skills-start -->';
 const DROID_SKILLS_END = '<!-- droid-skills-end -->';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const BUNDLED_SKILLS_DIR = join(__dirname, '../skills');
+const BUNDLED_SKILLS_DIR = join(__dirname, '../tools');
 
 /**
- * Get the path to bundled skills directory
+ * Get the path to bundled tools directory
  */
 export function getBundledSkillsDir(): string {
   return BUNDLED_SKILLS_DIR;
 }
 
 /**
- * Get the installation path for skills based on AI tool
+ * Get the installation path for skills based on platform
  */
-export function getSkillsInstallPath(aiTool: AITool): string {
-  switch (aiTool) {
-    case AITool.ClaudeCode:
-      return join(homedir(), '.claude', 'skills');
-    case AITool.OpenCode:
-      return join(homedir(), '.config', 'opencode', 'skills');
-  }
+export function getSkillsInstallPath(platform: Platform): string {
+  return getSkillsPath(platform);
 }
 
 /**
- * Get the commands installation path based on AI tool
+ * Get the commands installation path based on platform
  */
-export function getCommandsInstallPath(aiTool: AITool): string {
-  switch (aiTool) {
-    case AITool.ClaudeCode:
-      return join(homedir(), '.claude', 'commands');
-    case AITool.OpenCode:
-      return join(homedir(), '.config', 'opencode', 'command');
-  }
+export function getCommandsInstallPath(platform: Platform): string {
+  return getCommandsPath(platform);
 }
 
 /**
- * Get the path to the AI tool's main config markdown file
+ * Get the path to the platform's main config markdown file
  */
-export function getAIConfigPath(aiTool: AITool): string {
-  switch (aiTool) {
-    case AITool.ClaudeCode:
-      return join(homedir(), '.claude', 'CLAUDE.md');
-    case AITool.OpenCode:
-      return join(homedir(), '.config', 'opencode', 'AGENTS.md');
-  }
+export function getPlatformConfigPath(platform: Platform): string {
+  return getConfigPath(platform);
 }
 
 /**
- * Update the AI tool's config file with skill registrations
+ * Update the platform's config file with skill registrations
  */
-export function updateAIConfigSkills(aiTool: AITool, installedSkills: string[]): void {
-  const configPath = getAIConfigPath(aiTool);
+export function updatePlatformConfigSkills(platform: Platform, installedSkills: string[]): void {
+  const configPath = getPlatformConfigPath(platform);
 
   let content = '';
   if (existsSync(configPath)) {
@@ -118,23 +103,61 @@ export function loadSkillManifest(skillDir: string): SkillManifest | null {
 }
 
 /**
- * Get all bundled skills
+ * Find the path to a skill within the tools directory structure
+ * Returns { toolDir, skillDir } or null if not found
+ */
+export function findSkillPath(skillName: string): { toolDir: string; skillDir: string } | null {
+  if (!existsSync(BUNDLED_SKILLS_DIR)) {
+    return null;
+  }
+
+  const toolDirs = readdirSync(BUNDLED_SKILLS_DIR, { withFileTypes: true })
+    .filter((dirent) => dirent.isDirectory())
+    .map((dirent) => dirent.name);
+
+  for (const toolName of toolDirs) {
+    const skillsDir = join(BUNDLED_SKILLS_DIR, toolName, 'skills');
+    if (!existsSync(skillsDir)) continue;
+
+    const skillDir = join(skillsDir, skillName);
+    if (existsSync(skillDir) && existsSync(join(skillDir, 'SKILL.yaml'))) {
+      return {
+        toolDir: join(BUNDLED_SKILLS_DIR, toolName),
+        skillDir,
+      };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Get all bundled skills from all tools
  */
 export function getBundledSkills(): SkillManifest[] {
   if (!existsSync(BUNDLED_SKILLS_DIR)) {
     return [];
   }
 
-  const skillDirs = readdirSync(BUNDLED_SKILLS_DIR, { withFileTypes: true })
+  const toolDirs = readdirSync(BUNDLED_SKILLS_DIR, { withFileTypes: true })
     .filter((dirent) => dirent.isDirectory())
     .map((dirent) => dirent.name);
 
   const skills: SkillManifest[] = [];
 
-  for (const skillDir of skillDirs) {
-    const manifest = loadSkillManifest(join(BUNDLED_SKILLS_DIR, skillDir));
-    if (manifest) {
-      skills.push(manifest);
+  for (const toolName of toolDirs) {
+    const skillsDir = join(BUNDLED_SKILLS_DIR, toolName, 'skills');
+    if (!existsSync(skillsDir)) continue;
+
+    const skillSubdirs = readdirSync(skillsDir, { withFileTypes: true })
+      .filter((dirent) => dirent.isDirectory())
+      .map((dirent) => dirent.name);
+
+    for (const skillName of skillSubdirs) {
+      const manifest = loadSkillManifest(join(skillsDir, skillName));
+      if (manifest) {
+        skills.push(manifest);
+      }
     }
   }
 
@@ -146,7 +169,8 @@ export function getBundledSkills(): SkillManifest[] {
  */
 export function isSkillInstalled(skillName: string): boolean {
   const config = loadConfig();
-  return skillName in config.skills;
+  const tools = getPlatformTools(config);
+  return skillName in tools;
 }
 
 /**
@@ -154,7 +178,8 @@ export function isSkillInstalled(skillName: string): boolean {
  */
 export function getInstalledSkill(skillName: string): InstalledSkill | null {
   const config = loadConfig();
-  return config.skills[skillName] || null;
+  const tools = getPlatformTools(config);
+  return tools[skillName] || null;
 }
 
 /**
@@ -166,8 +191,8 @@ export function getSkillUpdateStatus(skillName: string): {
   bundledVersion: string | null;
 } {
   const installed = getInstalledSkill(skillName);
-  const bundledSkillDir = join(BUNDLED_SKILLS_DIR, skillName);
-  const manifest = existsSync(bundledSkillDir) ? loadSkillManifest(bundledSkillDir) : null;
+  const skillPath = findSkillPath(skillName);
+  const manifest = skillPath ? loadSkillManifest(skillPath.skillDir) : null;
 
   if (!installed || !manifest) {
     return {
@@ -193,9 +218,10 @@ export function getSkillsWithUpdates(): Array<{
   bundledVersion: string;
 }> {
   const config = loadConfig();
+  const tools = getPlatformTools(config);
   const updates: Array<{ name: string; installedVersion: string; bundledVersion: string }> = [];
 
-  for (const skillName of Object.keys(config.skills)) {
+  for (const skillName of Object.keys(tools)) {
     const status = getSkillUpdateStatus(skillName);
     if (status.hasUpdate && status.installedVersion && status.bundledVersion) {
       updates.push({
@@ -248,13 +274,14 @@ export function updateAllSkills(): {
   upToDate: number;
 } {
   const config = loadConfig();
+  const tools = getPlatformTools(config);
   const result = {
     updated: [] as Array<{ name: string; from: string; to: string }>,
     failed: [] as Array<{ name: string; error: string }>,
     upToDate: 0,
   };
 
-  for (const skillName of Object.keys(config.skills)) {
+  for (const skillName of Object.keys(tools)) {
     const status = getSkillUpdateStatus(skillName);
 
     if (!status.hasUpdate) {
@@ -285,13 +312,14 @@ export function updateAllSkills(): {
  */
 export function installSkill(skillName: string): { success: boolean; message: string } {
   const config = loadConfig();
-  const bundledSkillDir = join(BUNDLED_SKILLS_DIR, skillName);
+  const skillPath = findSkillPath(skillName);
 
-  if (!existsSync(bundledSkillDir)) {
+  if (!skillPath) {
     return { success: false, message: `Skill '${skillName}' not found` };
   }
 
-  const manifest = loadSkillManifest(bundledSkillDir);
+  const { toolDir, skillDir } = skillPath;
+  const manifest = loadSkillManifest(skillDir);
   if (!manifest) {
     return { success: false, message: `Invalid skill manifest for '${skillName}'` };
   }
@@ -308,22 +336,20 @@ export function installSkill(skillName: string): { success: boolean; message: st
     }
   }
 
-  const skillsPath = getSkillsInstallPath(config.ai_tool);
+  const skillsPath = getSkillsInstallPath(config.platform);
   const targetSkillDir = join(skillsPath, skillName);
-  const commandsPath = getCommandsInstallPath(config.ai_tool);
+  const commandsPath = getCommandsInstallPath(config.platform);
+  const tools = getPlatformTools(config);
 
-  // Check for collisions BEFORE installing (only if not already installed by droid)
-  if (!config.skills[skillName]) {
-    // Check skill folder collision
-    if (existsSync(targetSkillDir)) {
-      return {
-        success: false,
-        message: `Cannot install: skill folder '${skillName}' already exists at ${targetSkillDir}`,
-      };
-    }
+  // Commands and agents are at the tool level, not skill level
+  const commandsSource = join(toolDir, 'commands');
+  const agentsSource = join(toolDir, 'agents');
 
-    // Check command file collisions
-    const commandsSource = join(bundledSkillDir, 'commands');
+  // Check for collisions BEFORE installing (only if not already installed by droid)
+  // Note: If skill folder exists but skill isn't in config, we allow overwriting (stale state
+  // from platform switch or manual cleanup). Command/agent collisions still checked.
+  if (!tools[skillName]) {
+    // Check command file collisions (these could conflict with other skills)
     if (existsSync(commandsSource)) {
       const commandFiles = readdirSync(commandsSource).filter(f => f.endsWith('.md') && f.toLowerCase() !== 'readme.md');
       for (const file of commandFiles) {
@@ -339,7 +365,6 @@ export function installSkill(skillName: string): { success: boolean; message: st
     }
 
     // Check bundled agent collisions
-    const agentsSource = join(bundledSkillDir, 'agents');
     if (existsSync(agentsSource)) {
       const agentDirs = readdirSync(agentsSource, { withFileTypes: true })
         .filter(dirent => dirent.isDirectory())
@@ -361,7 +386,7 @@ export function installSkill(skillName: string): { success: boolean; message: st
   }
 
   // Copy SKILL.md (the actual skill file for Claude Code / OpenCode)
-  const skillMdSource = join(bundledSkillDir, 'SKILL.md');
+  const skillMdSource = join(skillDir, 'SKILL.md');
   if (existsSync(skillMdSource)) {
     if (!existsSync(targetSkillDir)) {
       mkdirSync(targetSkillDir, { recursive: true });
@@ -372,7 +397,7 @@ export function installSkill(skillName: string): { success: boolean; message: st
   }
 
   // Copy references if present (skill documentation files)
-  const referencesSource = join(bundledSkillDir, 'references');
+  const referencesSource = join(skillDir, 'references');
   if (existsSync(referencesSource)) {
     const targetReferencesDir = join(targetSkillDir, 'references');
     if (!existsSync(targetReferencesDir)) {
@@ -387,8 +412,7 @@ export function installSkill(skillName: string): { success: boolean; message: st
     }
   }
 
-  // Copy commands if present
-  const commandsSource = join(bundledSkillDir, 'commands');
+  // Copy commands if present (from tool level)
   if (existsSync(commandsSource)) {
     if (!existsSync(commandsPath)) {
       mkdirSync(commandsPath, { recursive: true });
@@ -402,16 +426,14 @@ export function installSkill(skillName: string): { success: boolean; message: st
     }
   }
 
-  // Install bundled agents if present
+  // Install bundled agents if present (from tool level)
   const installedAgents: string[] = [];
-  const agentsSource = join(bundledSkillDir, 'agents');
   if (existsSync(agentsSource)) {
     const agentDirs = readdirSync(agentsSource, { withFileTypes: true })
       .filter(dirent => dirent.isDirectory())
       .map(dirent => dirent.name);
 
     for (const agentName of agentDirs) {
-      // Use the skill's bundled agent path instead of global agents
       const agentDir = join(agentsSource, agentName);
       const result = installAgentFromPath(agentDir, agentName);
       if (result.success) {
@@ -421,16 +443,20 @@ export function installSkill(skillName: string): { success: boolean; message: st
   }
 
   // Update config
-  config.skills[skillName] = {
-    version: manifest.version,
-    installed_at: new Date().toISOString(),
-    ...(installedAgents.length > 0 && { bundled_agents: installedAgents }),
+  const updatedTools = {
+    ...tools,
+    [skillName]: {
+      version: manifest.version,
+      installed_at: new Date().toISOString(),
+      ...(installedAgents.length > 0 && { bundled_agents: installedAgents }),
+    },
   };
+  setPlatformTools(config, updatedTools);
   saveConfig(config);
 
-  // Update AI tool's config file with skill reference
-  const installedSkillNames = Object.keys(config.skills);
-  updateAIConfigSkills(config.ai_tool, installedSkillNames);
+  // Update platform's config file with skill reference
+  const installedSkillNames = Object.keys(updatedTools);
+  updatePlatformConfigSkills(config.platform, installedSkillNames);
 
   return { success: true, message: `Installed ${skillName} v${manifest.version}` };
 }
@@ -440,23 +466,24 @@ export function installSkill(skillName: string): { success: boolean; message: st
  */
 export function uninstallSkill(skillName: string): { success: boolean; message: string } {
   const config = loadConfig();
+  const tools = getPlatformTools(config);
 
   if (!isSkillInstalled(skillName)) {
     return { success: false, message: `Skill '${skillName}' is not installed` };
   }
 
-  // Remove skill files from AI tool location
-  const skillsPath = getSkillsInstallPath(config.ai_tool);
+  // Remove skill files from platform location
+  const skillsPath = getSkillsInstallPath(config.platform);
   const skillDir = join(skillsPath, skillName);
   if (existsSync(skillDir)) {
     rmSync(skillDir, { recursive: true });
   }
 
-  // Remove command files if they exist
-  const bundledSkillDir = join(BUNDLED_SKILLS_DIR, skillName);
-  const commandsSource = join(bundledSkillDir, 'commands');
-  const commandsPath = getCommandsInstallPath(config.ai_tool);
-  if (existsSync(commandsSource)) {
+  // Remove command files if they exist (commands are at tool level)
+  const skillPath = findSkillPath(skillName);
+  const commandsPath = getCommandsInstallPath(config.platform);
+  const commandsSource = skillPath ? join(skillPath.toolDir, 'commands') : null;
+  if (commandsSource && existsSync(commandsSource)) {
     const commandFiles = readdirSync(commandsSource).filter(f => f.endsWith('.md') && f.toLowerCase() !== 'readme.md');
     for (const file of commandFiles) {
       const commandPath = join(commandsPath, file);
@@ -467,20 +494,22 @@ export function uninstallSkill(skillName: string): { success: boolean; message:
   }
 
   // Remove bundled agents if they were installed with this skill
-  const installedSkillInfo = config.skills[skillName];
+  const installedSkillInfo = tools[skillName];
   if (installedSkillInfo?.bundled_agents) {
     for (const agentName of installedSkillInfo.bundled_agents) {
       uninstallAgent(agentName);
     }
   }
 
-  // Remove from config
-  delete config.skills[skillName];
+  // Remove from config (destructure to omit the skill being removed)
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const { [skillName]: removed, ...remainingTools } = tools;
+  setPlatformTools(config, remainingTools);
   saveConfig(config);
 
-  // Update AI tool's config file to remove skill reference
-  const installedSkillNames = Object.keys(config.skills);
-  updateAIConfigSkills(config.ai_tool, installedSkillNames);
+  // Update platform's config file to remove skill reference
+  const installedSkillNames = Object.keys(remainingTools);
+  updatePlatformConfigSkills(config.platform, installedSkillNames);
 
   return { success: true, message: `Uninstalled ${skillName}` };
 }
@@ -513,7 +542,7 @@ export function isCommandInstalled(commandName: string, skillName: string): bool
 
   // Otherwise check if command was installed standalone
   const config = loadConfig();
-  const commandsPath = getCommandsInstallPath(config.ai_tool);
+  const commandsPath = getCommandsInstallPath(config.platform);
 
   // Command filename is derived from the command name after the skill prefix
   // e.g., "comments check" from skill "comments" → "check.md"
@@ -534,31 +563,23 @@ export function installCommand(
 ): { success: boolean; message: string } {
   const config = loadConfig();
 
+  // Find the skill to get its tool directory (commands are at tool level)
+  const skillPath = findSkillPath(skillName);
+  if (!skillPath) {
+    return { success: false, message: `Skill '${skillName}' not found` };
+  }
+
+  const commandsDir = join(skillPath.toolDir, 'commands');
+  if (!existsSync(commandsDir)) {
+    return { success: false, message: `No commands found for skill '${skillName}'` };
+  }
+
   // Find the source command file
   const cmdPart = commandName.startsWith(skillName + ' ')
     ? commandName.slice(skillName.length + 1)
     : commandName;
-  const filename = cmdPart.replace(/\s+/g, '-') + '.md';
-  const sourcePath = join(BUNDLED_SKILLS_DIR, skillName, 'commands', filename);
-
-  if (!existsSync(sourcePath)) {
-    // Try without hyphen conversion (original filename)
-    const altFilename = cmdPart + '.md';
-    const altSourcePath = join(BUNDLED_SKILLS_DIR, skillName, 'commands', altFilename);
-    if (!existsSync(altSourcePath)) {
-      return { success: false, message: `Command file not found: ${filename}` };
-    }
-  }
-
-  // Ensure commands directory exists
-  const commandsPath = getCommandsInstallPath(config.ai_tool);
-  if (!existsSync(commandsPath)) {
-    mkdirSync(commandsPath, { recursive: true });
-  }
 
-  // Find the actual source file
-  const commandsDir = join(BUNDLED_SKILLS_DIR, skillName, 'commands');
-  const files = readdirSync(commandsDir);
+  const files = readdirSync(commandsDir).filter(f => f.endsWith('.md') && f.toLowerCase() !== 'readme.md');
   const sourceFile = files.find(f => {
     const base = f.replace('.md', '');
     return base === cmdPart || base === cmdPart.replace(/\s+/g, '-');
@@ -568,6 +589,12 @@ export function installCommand(
     return { success: false, message: `Command file not found for: ${commandName}` };
   }
 
+  // Ensure commands directory exists
+  const commandsPath = getCommandsInstallPath(config.platform);
+  if (!existsSync(commandsPath)) {
+    mkdirSync(commandsPath, { recursive: true });
+  }
+
   const actualSourcePath = join(commandsDir, sourceFile);
   const targetPath = join(commandsPath, sourceFile);
 
@@ -597,7 +624,7 @@ export function uninstallCommand(
     };
   }
 
-  const commandsPath = getCommandsInstallPath(config.ai_tool);
+  const commandsPath = getCommandsInstallPath(config.platform);
 
   // Find the installed command file
   const cmdPart = commandName.startsWith(skillName + ' ')

package/src/lib/tools.ts

@@ -0,0 +1,140 @@
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import YAML from 'yaml';
+import { loadConfig } from './config.js';
+import { type ToolManifest, type ToolIncludes, getPlatformTools } from './types.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const BUNDLED_TOOLS_DIR = join(__dirname, '../tools');
+
+/**
+ * Get the path to bundled tools directory
+ */
+export function getBundledToolsDir(): string {
+  return BUNDLED_TOOLS_DIR;
+}
+
+/**
+ * Load a tool manifest from a tool directory
+ */
+export function loadToolManifest(toolDir: string): ToolManifest | null {
+  const manifestPath = join(toolDir, 'TOOL.yaml');
+
+  if (!existsSync(manifestPath)) {
+    return null;
+  }
+
+  try {
+    const content = readFileSync(manifestPath, 'utf-8');
+    const parsed = YAML.parse(content);
+
+    // Normalize includes structure
+    const includes: ToolIncludes = {
+      skills: parsed.includes?.skills || [],
+      commands: parsed.includes?.commands || [],
+      agents: parsed.includes?.agents || [],
+    };
+
+    return {
+      ...parsed,
+      includes,
+    } as ToolManifest;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get all bundled tools
+ */
+export function getBundledTools(): ToolManifest[] {
+  if (!existsSync(BUNDLED_TOOLS_DIR)) {
+    return [];
+  }
+
+  const toolDirs = readdirSync(BUNDLED_TOOLS_DIR, { withFileTypes: true })
+    .filter((dirent) => dirent.isDirectory())
+    .map((dirent) => dirent.name);
+
+  const tools: ToolManifest[] = [];
+
+  for (const toolName of toolDirs) {
+    const manifest = loadToolManifest(join(BUNDLED_TOOLS_DIR, toolName));
+    if (manifest) {
+      tools.push(manifest);
+    }
+  }
+
+  return tools;
+}
+
+/**
+ * Check if a tool is installed (any of its required skills are installed)
+ */
+export function isToolInstalled(toolName: string): boolean {
+  const config = loadConfig();
+  const installedTools = getPlatformTools(config);
+
+  // A tool is installed if any of its required skills are in the installed tools
+  const tool = getBundledTools().find(t => t.name === toolName);
+  if (!tool) return false;
+
+  const requiredSkills = tool.includes.skills
+    .filter(s => s.required)
+    .map(s => s.name);
+
+  // Tool is installed if at least one required skill is installed
+  return requiredSkills.some(skillName => skillName in installedTools);
+}
+
+/**
+ * Get the installed version of a tool (from its primary skill)
+ */
+export function getInstalledToolVersion(toolName: string): string | null {
+  const config = loadConfig();
+  const installedTools = getPlatformTools(config);
+
+  const tool = getBundledTools().find(t => t.name === toolName);
+  if (!tool) return null;
+
+  // Get version from the first installed required skill
+  const requiredSkills = tool.includes.skills
+    .filter(s => s.required)
+    .map(s => s.name);
+
+  for (const skillName of requiredSkills) {
+    if (installedTools[skillName]) {
+      return installedTools[skillName].version;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Check if a tool has an update available
+ */
+export function getToolUpdateStatus(toolName: string): {
+  hasUpdate: boolean;
+  installedVersion: string | null;
+  bundledVersion: string | null;
+} {
+  const installedVersion = getInstalledToolVersion(toolName);
+  const tool = getBundledTools().find(t => t.name === toolName);
+  const bundledVersion = tool?.version || null;
+
+  if (!installedVersion || !bundledVersion) {
+    return {
+      hasUpdate: false,
+      installedVersion,
+      bundledVersion,
+    };
+  }
+
+  return {
+    hasUpdate: bundledVersion !== installedVersion,
+    installedVersion,
+    bundledVersion,
+  };
+}

package/src/lib/types.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'bun:test';
 import {
+  Platform,
   AITool,
   BuiltInOutput,
   SkillStatus,
@@ -7,21 +8,21 @@ import {
   getAITag,
 } from './types.js';
 
-describe('AITool enum', () => {
+describe('Platform enum', () => {
   it('should have correct values', () => {
-    expect(AITool.ClaudeCode).toBe('claude-code');
-    expect(AITool.OpenCode).toBe('opencode');
+    expect(Platform.ClaudeCode).toBe('claude-code');
+    expect(Platform.OpenCode).toBe('opencode');
   });
 
   it('should be usable in switch statements', () => {
-    const tool = AITool.ClaudeCode;
+    const platform = Platform.ClaudeCode;
     let result = '';
 
-    switch (tool) {
-      case AITool.ClaudeCode:
+    switch (platform) {
+      case Platform.ClaudeCode:
         result = 'claude';
         break;
-      case AITool.OpenCode:
+      case Platform.OpenCode:
         result = 'opencode';
         break;
     }
@@ -30,6 +31,13 @@ describe('AITool enum', () => {
   });
 });
 
+describe('AITool backward compatibility', () => {
+  it('should be an alias for Platform', () => {
+    expect(AITool.ClaudeCode).toBe(Platform.ClaudeCode);
+    expect(AITool.OpenCode).toBe(Platform.OpenCode);
+  });
+});
+
 describe('BuiltInOutput enum', () => {
   it('should have correct values', () => {
     expect(BuiltInOutput.Terminal).toBe('terminal');