@orderful/droid 0.26.0 → 0.27.1

package/src/lib/skills.test.ts

@@ -1,10 +1,17 @@
-import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
-import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync, readdirSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { homedir } from 'os';
-import YAML from 'yaml';
-import { Platform, SkillStatus } from './types';
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import {
+  existsSync,
+  mkdirSync,
+  rmSync,
+  writeFileSync,
+  readFileSync,
+  readdirSync,
+} from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { homedir } from "os";
+import YAML from "yaml";
+import { Platform, SkillStatus } from "./types";
 import {
   getSkillsInstallPath,
   getCommandsInstallPath,
@@ -12,7 +19,9 @@ import {
   getSkillStatusDisplay,
   getBundledSkillsDir,
   loadSkillManifest,
-} from './skills';
+  installSkill,
+} from "./skills";
+import { loadConfig, saveConfig } from "./config";
 
 /**
  * Parse YAML frontmatter from markdown content
@@ -27,73 +36,73 @@ function parseFrontmatter(content: string): Record<string, unknown> | null {
   }
 }
 
-describe('getSkillsInstallPath', () => {
-  it('should return Claude Code path', () => {
+describe("getSkillsInstallPath", () => {
+  it("should return Claude Code path", () => {
     const path = getSkillsInstallPath(Platform.ClaudeCode);
-    expect(path).toBe(join(homedir(), '.claude', 'skills'));
+    expect(path).toBe(join(homedir(), ".claude", "skills"));
   });
 
-  it('should return OpenCode path', () => {
+  it("should return OpenCode path", () => {
     const path = getSkillsInstallPath(Platform.OpenCode);
-    expect(path).toBe(join(homedir(), '.config', 'opencode', 'skills'));
+    expect(path).toBe(join(homedir(), ".config", "opencode", "skills"));
   });
 });
 
-describe('getCommandsInstallPath', () => {
-  it('should return Claude Code commands path', () => {
+describe("getCommandsInstallPath", () => {
+  it("should return Claude Code commands path", () => {
     const path = getCommandsInstallPath(Platform.ClaudeCode);
-    expect(path).toBe(join(homedir(), '.claude', 'commands'));
+    expect(path).toBe(join(homedir(), ".claude", "commands"));
   });
 
-  it('should return OpenCode commands path', () => {
+  it("should return OpenCode commands path", () => {
     const path = getCommandsInstallPath(Platform.OpenCode);
-    expect(path).toBe(join(homedir(), '.config', 'opencode', 'command'));
+    expect(path).toBe(join(homedir(), ".config", "opencode", "command"));
   });
 });
 
-describe('getPlatformConfigPath', () => {
-  it('should return Claude Code CLAUDE.md path', () => {
+describe("getPlatformConfigPath", () => {
+  it("should return Claude Code CLAUDE.md path", () => {
     const path = getPlatformConfigPath(Platform.ClaudeCode);
-    expect(path).toBe(join(homedir(), '.claude', 'CLAUDE.md'));
+    expect(path).toBe(join(homedir(), ".claude", "CLAUDE.md"));
   });
 
-  it('should return OpenCode AGENTS.md path', () => {
+  it("should return OpenCode AGENTS.md path", () => {
     const path = getPlatformConfigPath(Platform.OpenCode);
-    expect(path).toBe(join(homedir(), '.config', 'opencode', 'AGENTS.md'));
+    expect(path).toBe(join(homedir(), ".config", "opencode", "AGENTS.md"));
   });
 });
 
-describe('getBundledSkillsDir', () => {
-  it('should return a path ending in tools', () => {
+describe("getBundledSkillsDir", () => {
+  it("should return a path ending in tools", () => {
     const dir = getBundledSkillsDir();
-    expect(dir.endsWith('tools')).toBe(true);
+    expect(dir.endsWith("tools")).toBe(true);
   });
 
-  it('should return an existing directory', () => {
+  it("should return an existing directory", () => {
     const dir = getBundledSkillsDir();
     expect(existsSync(dir)).toBe(true);
   });
 });
 
-describe('getSkillStatusDisplay', () => {
-  it('should return [alpha] for alpha status', () => {
-    expect(getSkillStatusDisplay(SkillStatus.Alpha)).toBe('[alpha]');
+describe("getSkillStatusDisplay", () => {
+  it("should return [alpha] for alpha status", () => {
+    expect(getSkillStatusDisplay(SkillStatus.Alpha)).toBe("[alpha]");
   });
 
-  it('should return [beta] for beta status', () => {
-    expect(getSkillStatusDisplay(SkillStatus.Beta)).toBe('[beta]');
+  it("should return [beta] for beta status", () => {
+    expect(getSkillStatusDisplay(SkillStatus.Beta)).toBe("[beta]");
   });
 
-  it('should return empty string for stable status', () => {
-    expect(getSkillStatusDisplay(SkillStatus.Stable)).toBe('');
+  it("should return empty string for stable status", () => {
+    expect(getSkillStatusDisplay(SkillStatus.Stable)).toBe("");
   });
 
-  it('should return empty string for undefined status', () => {
-    expect(getSkillStatusDisplay(undefined)).toBe('');
+  it("should return empty string for undefined status", () => {
+    expect(getSkillStatusDisplay(undefined)).toBe("");
   });
 });
 
-describe('skill manifest parsing', () => {
+describe("skill manifest parsing", () => {
   let testDir: string;
 
   beforeEach(() => {
@@ -107,44 +116,44 @@ describe('skill manifest parsing', () => {
     }
   });
 
-  it('should parse valid skill manifest', () => {
+  it("should parse valid skill manifest", () => {
     const manifest = {
-      name: 'test-skill',
-      description: 'A test skill',
-      version: '1.0.0',
-      status: 'beta',
-      dependencies: ['comments'],
+      name: "test-skill",
+      description: "A test skill",
+      version: "1.0.0",
+      status: "beta",
+      dependencies: ["comments"],
       provides_output: true,
     };
 
-    const manifestPath = join(testDir, 'SKILL.yaml');
-    writeFileSync(manifestPath, YAML.stringify(manifest), 'utf-8');
+    const manifestPath = join(testDir, "SKILL.yaml");
+    writeFileSync(manifestPath, YAML.stringify(manifest), "utf-8");
 
-    const content = require('fs').readFileSync(manifestPath, 'utf-8');
+    const content = require("fs").readFileSync(manifestPath, "utf-8");
     const parsed = YAML.parse(content);
 
-    expect(parsed.name).toBe('test-skill');
-    expect(parsed.description).toBe('A test skill');
-    expect(parsed.version).toBe('1.0.0');
-    expect(parsed.status).toBe('beta');
-    expect(parsed.dependencies).toEqual(['comments']);
+    expect(parsed.name).toBe("test-skill");
+    expect(parsed.description).toBe("A test skill");
+    expect(parsed.version).toBe("1.0.0");
+    expect(parsed.status).toBe("beta");
+    expect(parsed.dependencies).toEqual(["comments"]);
     expect(parsed.provides_output).toBe(true);
   });
 
-  it('should handle manifest without optional fields', () => {
+  it("should handle manifest without optional fields", () => {
     const manifest = {
-      name: 'minimal-skill',
-      description: 'Minimal',
-      version: '0.1.0',
+      name: "minimal-skill",
+      description: "Minimal",
+      version: "0.1.0",
     };
 
-    const manifestPath = join(testDir, 'SKILL.yaml');
-    writeFileSync(manifestPath, YAML.stringify(manifest), 'utf-8');
+    const manifestPath = join(testDir, "SKILL.yaml");
+    writeFileSync(manifestPath, YAML.stringify(manifest), "utf-8");
 
-    const content = require('fs').readFileSync(manifestPath, 'utf-8');
+    const content = require("fs").readFileSync(manifestPath, "utf-8");
     const parsed = YAML.parse(content);
 
-    expect(parsed.name).toBe('minimal-skill');
+    expect(parsed.name).toBe("minimal-skill");
     expect(parsed.status).toBeUndefined();
     expect(parsed.dependencies).toBeUndefined();
     expect(parsed.provides_output).toBeUndefined();
@@ -154,7 +163,9 @@ describe('skill manifest parsing', () => {
 /**
  * Helper to get all skill directories in the new tools/{tool}/skills/{skill} structure
  */
-function getAllSkillPaths(toolsDir: string): Array<{ skillName: string; skillDir: string }> {
+function getAllSkillPaths(
+  toolsDir: string,
+): Array<{ skillName: string; skillDir: string }> {
   const skillPaths: Array<{ skillName: string; skillDir: string }> = [];
 
   const toolDirs = readdirSync(toolsDir, { withFileTypes: true })
@@ -162,7 +173,7 @@ function getAllSkillPaths(toolsDir: string): Array<{ skillName: string; skillDir
     .map((d) => d.name);
 
   for (const toolName of toolDirs) {
-    const skillsDir = join(toolsDir, toolName, 'skills');
+    const skillsDir = join(toolsDir, toolName, "skills");
     if (!existsSync(skillsDir)) continue;
 
     const skillDirs = readdirSync(skillsDir, { withFileTypes: true })
@@ -180,43 +191,43 @@ function getAllSkillPaths(toolsDir: string): Array<{ skillName: string; skillDir
   return skillPaths;
 }
 
-describe('bundled skills validation', () => {
-  it('all skills should have SKILL.md', () => {
+describe("bundled skills validation", () => {
+  it("all skills should have SKILL.md", () => {
     const toolsDir = getBundledSkillsDir();
     const skillPaths = getAllSkillPaths(toolsDir);
 
     expect(skillPaths.length).toBeGreaterThan(0);
 
     for (const { skillDir } of skillPaths) {
-      const skillMdPath = join(skillDir, 'SKILL.md');
+      const skillMdPath = join(skillDir, "SKILL.md");
       expect(existsSync(skillMdPath)).toBe(true);
     }
   });
 
-  it('all skills should have metadata in TOOL.yaml', () => {
+  it("all skills should have metadata in TOOL.yaml", () => {
     const toolsDir = getBundledSkillsDir();
     const skillPaths = getAllSkillPaths(toolsDir);
 
     for (const { skillName, skillDir } of skillPaths) {
       // Get the parent tool directory
-      const toolDir = join(skillDir, '..', '..');
-      const toolYamlPath = join(toolDir, 'TOOL.yaml');
+      const toolDir = join(skillDir, "..", "..");
+      const toolYamlPath = join(toolDir, "TOOL.yaml");
       expect(existsSync(toolYamlPath)).toBe(true);
 
-      const toolContent = readFileSync(toolYamlPath, 'utf-8');
+      const toolContent = readFileSync(toolYamlPath, "utf-8");
       const toolManifest = YAML.parse(toolContent);
 
       // Find the skill in includes.skills
       const skillInclude = toolManifest.includes?.skills?.find(
-        (s: { name: string }) => s.name === skillName
+        (s: { name: string }) => s.name === skillName,
       );
       expect(skillInclude).toBeDefined();
-      expect(typeof toolManifest.description).toBe('string');
-      expect(typeof toolManifest.version).toBe('string');
+      expect(typeof toolManifest.description).toBe("string");
+      expect(typeof toolManifest.version).toBe("string");
     }
   });
 
-  it('loadSkillManifest should return valid manifest from TOOL.yaml', () => {
+  it("loadSkillManifest should return valid manifest from TOOL.yaml", () => {
     const toolsDir = getBundledSkillsDir();
     const skillPaths = getAllSkillPaths(toolsDir);
 
@@ -225,8 +236,122 @@ describe('bundled skills validation', () => {
 
       expect(manifest).not.toBeNull();
       expect(manifest?.name).toBe(skillName);
-      expect(typeof manifest?.description).toBe('string');
-      expect(typeof manifest?.version).toBe('string');
+      expect(typeof manifest?.description).toBe("string");
+      expect(typeof manifest?.version).toBe("string");
+    }
+  });
+});
+describe('platform-specific command installation', () => {
+  let testConfigDir: string;
+  let testSkillsDir: string;
+  let testCommandsDir: string;
+  let originalConfig: any;
+
+  beforeEach(() => {
+    // Save original config
+    originalConfig = loadConfig();
+    
+    // Create temporary directories for testing
+    testConfigDir = join(tmpdir(), `droid-test-config-${Date.now()}`);
+    testSkillsDir = join(tmpdir(), `droid-test-skills-${Date.now()}`);
+    testCommandsDir = join(tmpdir(), `droid-test-commands-${Date.now()}`);
+    
+    mkdirSync(testConfigDir, { recursive: true });
+    mkdirSync(testSkillsDir, { recursive: true });
+    mkdirSync(testCommandsDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    // Restore original config
+    saveConfig(originalConfig);
+    
+    // Cleanup test directories
+    if (existsSync(testConfigDir)) {
+      rmSync(testConfigDir, { recursive: true });
+    }
+    if (existsSync(testSkillsDir)) {
+      rmSync(testSkillsDir, { recursive: true });
+    }
+    if (existsSync(testCommandsDir)) {
+      rmSync(testCommandsDir, { recursive: true });
+    }
+  });
+
+  it('should install all commands on OpenCode platform', () => {
+    // This is an integration test that would require mocking the install paths
+    // For now, we verify the logic exists by checking tool manifests
+    const toolsDir = getBundledSkillsDir();
+    
+    // Find brain tool which has both primary and alias commands
+    const brainToolDir = join(toolsDir, 'brain');
+    const toolYamlPath = join(brainToolDir, 'TOOL.yaml');
+    
+    if (!existsSync(toolYamlPath)) {
+      // Skip test if brain tool doesn't exist
+      return;
+    }
+    
+    const toolContent = readFileSync(toolYamlPath, 'utf-8');
+    const toolManifest = YAML.parse(toolContent);
+    
+    // Verify brain has both primary and alias commands
+    const commands = toolManifest.includes?.commands || [];
+    const brainCommand = commands.find((c: any) => c.name === 'brain');
+    const scratchpadCommand = commands.find((c: any) => c.name === 'scratchpad');
+    
+    expect(brainCommand).toBeDefined();
+    expect(brainCommand.is_alias).toBe(false);
+    
+    expect(scratchpadCommand).toBeDefined();
+    expect(scratchpadCommand.is_alias).toBe(true);
+  });
+
+  it('should identify alias commands correctly', () => {
+    const toolsDir = getBundledSkillsDir();
+    const brainToolDir = join(toolsDir, 'brain');
+    const toolYamlPath = join(brainToolDir, 'TOOL.yaml');
+    
+    if (!existsSync(toolYamlPath)) {
+      return;
+    }
+    
+    const toolContent = readFileSync(toolYamlPath, 'utf-8');
+    const toolManifest = YAML.parse(toolContent);
+    const commands = toolManifest.includes?.commands || [];
+    
+    // All alias commands should have is_alias: true
+    const aliasCommands = commands.filter((c: any) => c.is_alias === true);
+    const primaryCommands = commands.filter((c: any) => c.is_alias === false);
+    
+    // Should have at least one of each type in brain tool
+    expect(aliasCommands.length).toBeGreaterThan(0);
+    expect(primaryCommands.length).toBeGreaterThan(0);
+    
+    // Verify scratchpad is marked as alias
+    const scratchpad = commands.find((c: any) => c.name === 'scratchpad');
+    if (scratchpad) {
+      expect(scratchpad.is_alias).toBe(true);
+    }
+  });
+
+  it('should have is_alias property on all command objects', () => {
+    const toolsDir = getBundledSkillsDir();
+    const toolDirs = readdirSync(toolsDir, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => join(toolsDir, d.name));
+    
+    for (const toolDir of toolDirs) {
+      const toolYamlPath = join(toolDir, 'TOOL.yaml');
+      if (!existsSync(toolYamlPath)) continue;
+      
+      const toolContent = readFileSync(toolYamlPath, 'utf-8');
+      const toolManifest = YAML.parse(toolContent);
+      const commands = toolManifest.includes?.commands || [];
+      
+      // All commands should have is_alias property (boolean)
+      for (const cmd of commands) {
+        expect(typeof cmd.is_alias).toBe('boolean');
+      }
     }
   });
 });

package/src/lib/skills.ts

@@ -411,6 +411,15 @@ export function installSkill(skillName: string): {
     };
   }
 
+  // Load tool manifest to get command metadata (for is_alias flag)
+  const toolManifest = loadToolManifest(toolDir);
+  if (!toolManifest) {
+    return {
+      success: false,
+      message: `Invalid tool manifest for tool containing '${skillName}'`,
+    };
+  }
+
   // Check dependencies
   if (manifest.dependencies) {
     for (const dep of manifest.dependencies) {
@@ -428,49 +437,39 @@ export function installSkill(skillName: string): {
   const commandsPath = getCommandsInstallPath(config.platform);
   const tools = getPlatformTools(config);
 
-  // Clean up old skill directory if this is a renamed skill (v0.18.0 workaround for Claude Code bug)
-  // Renamed skills have 'droid-' prefix, so check for old directory without prefix
-  // Bug: https://github.com/anthropics/claude-code/issues/14945
-  //
-  // TO REVERSE WHEN BUG IS FIXED:
-  // 1. Rename directories: droid-comments/ → comments/, droid-brain/ → brain/, etc.
-  // 2. Update TOOL.yaml manifests back to original skill names
-  // 3. Update SKILL.md frontmatter back to original names
-  // 4. Replace this cleanup logic with inverse:
-  //    const renamedSkills = ['comments', 'brain', 'project', 'coach', 'code-review', 'brain-obsidian'];
-  //    if (renamedSkills.includes(skillName)) {
-  //      const droidPrefixedName = `droid-${skillName}`;
-  //      const droidPrefixedDir = join(skillsPath, droidPrefixedName);
-  //      if (existsSync(droidPrefixedDir)) {
-  //        rmSync(droidPrefixedDir, { recursive: true });
-  //      }
-  //      if (tools[droidPrefixedName]) {
-  //        delete tools[droidPrefixedName];
-  //      }
-  //    }
-  // 5. Bump tool versions and create changeset
-  // Migration logic: Handle skills renamed from {name} to droid-{name} (v0.18.0 workaround)
-  // This handles both fresh installs and updates where old directory/config entries exist
-  if (skillName.startsWith('droid-')) {
-    const oldSkillName = skillName.replace(/^droid-/, '');
-    const oldSkillDir = join(skillsPath, oldSkillName);
-
-    // Remove or migrate old skill directory
-    if (existsSync(oldSkillDir)) {
+  // Clean up old droid- prefixed directories from v0.18.x (Claude Code bug workaround)
+  // CLEANUP: Remove after v0.22.0 or 2026-04-01 (3 months post-v0.21.0 release)
+  // Migration for droid- prefix removal (v0.18.x → v0.21.0)
+  // These skills were temporarily renamed with droid- prefix, now back to original names
+  const renamedSkills = [
+    'comments',
+    'brain',
+    'project',
+    'coach',
+    'code-review',
+    'codex',
+    'tech-design',
+    'brain-obsidian',
+  ];
+  if (renamedSkills.includes(skillName)) {
+    const droidPrefixedName = `droid-${skillName}`;
+    const droidPrefixedDir = join(skillsPath, droidPrefixedName);
+
+    // Remove old droid- prefixed directory
+    if (existsSync(droidPrefixedDir)) {
       try {
-        rmSync(oldSkillDir, { recursive: true });
+        rmSync(droidPrefixedDir, { recursive: true });
       } catch (error) {
         // Non-fatal: Log warning but continue installation
         console.warn(
-          `Warning: Could not remove old skill directory ${oldSkillDir}: ${error}`,
+          `Warning: Could not remove old skill directory ${droidPrefixedDir}: ${error}`,
         );
       }
     }
 
     // Migrate old config entry if it exists
-    // This allows tools to show as "update available" rather than "not installed"
-    if (tools[oldSkillName]) {
-      delete tools[oldSkillName];
+    if (tools[droidPrefixedName]) {
+      delete tools[droidPrefixedName];
       // Save immediately to ensure cleanup is persisted (matches pattern in tools.ts)
       setPlatformTools(config, tools);
       saveConfig(config);
@@ -484,23 +483,10 @@ export function installSkill(skillName: string): {
   // 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.
-  //
-  // Special handling for droid- prefix migration (temporary workaround for Claude Code bug #14945):
-  // If installing droid-comments, check if 'comments' is in config (old naming)
-  const oldSkillName = skillName.startsWith('droid-')
-    ? skillName.replace(/^droid-/, '')
-    : null;
-  const isAlreadyInstalled =
-    tools[skillName] || (oldSkillName && tools[oldSkillName]);
+  const isAlreadyInstalled = tools[skillName];
 
   if (!isAlreadyInstalled) {
-    // For collision detection, also check if this is the same tool (with/without droid- prefix)
-    // E.g., installing droid-comments should be allowed to overwrite existing comments.md
-    //
-    // TO REVERSE WHEN BUG #14945 IS FIXED:
-    // Remove the normalizedToolName logic - tools will have original names without droid- prefix
     const toolName = basename(toolDir);
-    const normalizedToolName = toolName.replace(/^droid-/, '');
 
     // Check command file collisions (these could conflict with other skills)
     if (existsSync(commandsSource)) {
@@ -512,9 +498,9 @@ export function installSkill(skillName: string): {
         if (existsSync(targetCommandPath)) {
           const commandName = file.replace('.md', '');
 
-          // Allow overwrite if the command name matches the tool name (with/without prefix)
+          // Allow overwrite if the command name matches the tool name
           // E.g., installing 'comments' tool can overwrite 'comments.md'
-          if (commandName === toolName || commandName === normalizedToolName) {
+          if (commandName === toolName) {
             continue; // Same tool, allow overwrite
           }
 
@@ -595,6 +581,7 @@ export function installSkill(skillName: string): {
   }
 
   // Copy commands if present (from tool level)
+  // Platform-specific: Only install primary commands on OpenCode, always install aliases
   if (existsSync(commandsSource)) {
     if (!existsSync(commandsPath)) {
       mkdirSync(commandsPath, { recursive: true });
@@ -602,11 +589,25 @@ export function installSkill(skillName: string): {
     const commandFiles = readdirSync(commandsSource).filter(
       (f) => f.endsWith('.md') && f.toLowerCase() !== 'readme.md',
     );
+
     for (const file of commandFiles) {
-      const sourcePath = join(commandsSource, file);
-      const targetPath = join(commandsPath, file);
-      const content = readFileSync(sourcePath, 'utf-8');
-      writeFileSync(targetPath, content);
+      const commandName = file.replace('.md', '');
+
+      // Find this command in the tool manifest to check if it's an alias
+      const commandMeta = toolManifest.includes.commands.find(
+        (cmd) => (typeof cmd === 'string' ? cmd : cmd.name) === commandName,
+      );
+      const isAlias = typeof commandMeta === 'object' && commandMeta.is_alias;
+
+      // Install if: OpenCode (all commands) OR alias (both platforms)
+      const shouldInstall = config.platform === Platform.OpenCode || isAlias;
+
+      if (shouldInstall) {
+        const sourcePath = join(commandsSource, file);
+        const targetPath = join(commandsPath, file);
+        const content = readFileSync(sourcePath, 'utf-8');
+        writeFileSync(targetPath, content);
+      }
     }
   }
 

package/src/lib/tools.ts

@@ -3,7 +3,12 @@ import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import YAML from 'yaml';
 import { loadConfig, saveConfig } from './config';
-import { type ToolManifest, type ToolIncludes, getPlatformTools, setPlatformTools } from './types';
+import {
+  type ToolManifest,
+  type ToolIncludes,
+  getPlatformTools,
+  setPlatformTools,
+} from './types';
 import { compareSemver } from './version';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -78,15 +83,15 @@ export function isToolInstalled(toolName: string): boolean {
   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);
+  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);
+    .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);
+  return requiredSkills.some((skillName) => skillName in installedTools);
 }
 
 /**
@@ -96,13 +101,13 @@ export function getInstalledToolVersion(toolName: string): string | null {
   const config = loadConfig();
   const installedTools = getPlatformTools(config);
 
-  const tool = getBundledTools().find(t => t.name === toolName);
+  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);
+    .filter((s) => s.required)
+    .map((s) => s.name);
 
   for (const skillName of requiredSkills) {
     if (installedTools[skillName]) {
@@ -139,7 +144,7 @@ export interface ToolUpdateInfo {
  */
 export function getToolUpdateStatus(toolName: string): ToolUpdateInfo {
   const installedVersion = getInstalledToolVersion(toolName);
-  const tool = getBundledTools().find(t => t.name === toolName);
+  const tool = getBundledTools().find((t) => t.name === toolName);
   const bundledVersion = tool?.version || null;
 
   if (!installedVersion || !bundledVersion) {
@@ -176,10 +181,12 @@ export function getToolsWithUpdates(): ToolUpdateInfo[] {
   for (const tool of bundledTools) {
     // Find if any of the tool's required skills are installed
     const requiredSkills = tool.includes.skills
-      .filter(s => s.required)
-      .map(s => s.name);
+      .filter((s) => s.required)
+      .map((s) => s.name);
 
-    const isInstalled = requiredSkills.some(skillName => skillName in installedTools);
+    const isInstalled = requiredSkills.some(
+      (skillName) => skillName in installedTools,
+    );
 
     if (isInstalled) {
       const updateStatus = getToolUpdateStatus(tool.name);