@orderful/droid 0.26.0 → 0.27.0

package/src/commands/tui/components/Badge.test.tsx

@@ -29,7 +29,9 @@ describe('Badge', () => {
     const types = ['skill', 'command', 'agent'] as const;
     for (const type of types) {
       const { lastFrame } = render(<Badge type={type} />);
-      expect(lastFrame()).toContain(type.charAt(0).toUpperCase() + type.slice(1));
+      expect(lastFrame()).toContain(
+        type.charAt(0).toUpperCase() + type.slice(1),
+      );
     }
   });
 });
@@ -44,7 +46,7 @@ describe('ComponentBadges', () => {
         { name: 'skill1', required: true },
         { name: 'skill2', required: false },
       ],
-      commands: ['cmd1'],
+      commands: [{ name: 'cmd1', is_alias: false }],
       agents: [],
     },
   };
@@ -63,7 +65,11 @@ describe('ComponentBadges', () => {
   it('renders singular form for single item', () => {
     const singleSkillTool: ToolManifest = {
       ...mockTool,
-      includes: { skills: [{ name: 'skill1', required: true }], commands: [], agents: [] },
+      includes: {
+        skills: [{ name: 'skill1', required: true }],
+        commands: [],
+        agents: [],
+      },
     };
     const { lastFrame } = render(<ComponentBadges tool={singleSkillTool} />);
     expect(lastFrame()).toContain('1 skill');
@@ -82,7 +88,7 @@ describe('ComponentBadges', () => {
       ...mockTool,
       includes: {
         skills: [{ name: 's1', required: true }],
-        commands: ['c1'],
+        commands: [{ name: 'c1', is_alias: false }],
         agents: ['a1'],
       },
     };

package/src/commands/tui.tsx

@@ -14,7 +14,7 @@ import {
 import { configExists, loadConfig, getAutoUpdateConfig } from '../lib/config';
 import { Platform, type ConfigOption, type ToolManifest } from '../lib/types';
 import { getVersion } from '../lib/version';
-import { runToolMigrations } from '../lib/migrations';
+import { runPackageMigrations } from '../lib/migrations';
 import { type Tab, type View } from './tui/types';
 import { colors, MAX_VISIBLE_ITEMS } from './tui/constants';
 import { TabBar } from './tui/components/TabBar';
@@ -72,10 +72,10 @@ function App() {
       },
     });
 
-  // Run droid meta-tool migration on startup (sync installed tools across platforms)
+  // Run droid package migrations on startup (sync installed tools across platforms)
   useEffect(() => {
-    const droidVersion = getVersion();
-    runToolMigrations('droid', droidVersion);
+    const packageVersion = getVersion();
+    runPackageMigrations(packageVersion);
   }, []);
 
   // Auto-update app if enabled and update available

package/src/lib/migrations.ts

@@ -153,6 +153,14 @@ function createPlatformSyncMigration(version: string): Migration {
   };
 }
 
+/**
+ * Registry of package-level migrations
+ * These run when the @orderful/droid npm package updates
+ * Triggered by package version from package.json (e.g., 0.26.0)
+ * Run at TUI startup
+ */
+const PACKAGE_MIGRATIONS: Migration[] = [createPlatformSyncMigration('0.25.0')];
+
 /**
  * Registry of all tool migrations
  * Key: tool name (e.g., "brain", "comments")
@@ -169,8 +177,6 @@ const TOOL_MIGRATIONS: Record<string, Migration[]> = {
   comments: [createConfigDirMigration('droid-comments', '0.2.6')],
   project: [createConfigDirMigration('droid-project', '0.1.5')],
   coach: [createConfigDirMigration('droid-coach', '0.1.3')],
-  // Global migration for the droid meta-tool
-  droid: [createPlatformSyncMigration('0.25.0')],
 };
 
 /**
@@ -185,7 +191,18 @@ export function getToolMigrations(toolName: string): Migration[] {
  */
 export function getLastMigratedVersion(toolName: string): string {
   const config = loadConfig();
-  return config.migrations?.[toolName] ?? '0.0.0';
+
+  // Check new location first
+  if (config.migrations?.tools?.[toolName]) {
+    return config.migrations.tools[toolName];
+  }
+
+  // Fall back to old location (backward compatibility)
+  if (config.migrations && typeof config.migrations[toolName] === 'string') {
+    return config.migrations[toolName] as string;
+  }
+
+  return '0.0.0';
 }
 
 /**
@@ -196,10 +213,22 @@ export function setLastMigratedVersion(
   version: string,
 ): void {
   const config = loadConfig();
+
+  // Ensure new structure exists
   if (!config.migrations) {
     config.migrations = {};
   }
-  config.migrations[toolName] = version;
+  if (!config.migrations.tools) {
+    config.migrations.tools = {};
+  }
+
+  config.migrations.tools[toolName] = version;
+
+  // Clean up old location if it exists
+  if (typeof config.migrations[toolName] === 'string') {
+    delete config.migrations[toolName];
+  }
+
   saveConfig(config);
 }
 
@@ -273,3 +302,65 @@ export function runToolMigrations(
 
   return runMigrations(toolName, lastMigrated, installedVersion);
 }
+
+/**
+ * Run package-level migrations
+ * Call this on TUI startup with package version from package.json
+ */
+export function runPackageMigrations(packageVersion: string): {
+  success: boolean;
+  error?: string;
+} {
+  const config = loadConfig();
+  const lastMigrated = config.migrations?.package ?? '0.0.0';
+
+  // Only run if the package version is newer than last migrated
+  if (compareSemver(packageVersion, lastMigrated) <= 0) {
+    return { success: true };
+  }
+
+  // Filter migrations that need to run
+  const pendingMigrations = PACKAGE_MIGRATIONS.filter((m) => {
+    const afterFrom = compareSemver(m.version, lastMigrated) > 0;
+    const beforeOrAtTo = compareSemver(m.version, packageVersion) <= 0;
+    return afterFrom && beforeOrAtTo;
+  });
+
+  if (pendingMigrations.length === 0) {
+    // No migrations to run, but still update the version marker
+    config.migrations = config.migrations || {};
+    config.migrations.package = packageVersion;
+    saveConfig(config);
+    return { success: true };
+  }
+
+  const configDir = getConfigDir();
+
+  for (const migration of pendingMigrations) {
+    try {
+      migration.up(configDir);
+      logMigration('package', lastMigrated, migration.version, 'OK');
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      logMigration(
+        'package',
+        lastMigrated,
+        migration.version,
+        'FAILED',
+        errorMessage,
+      );
+      // Don't update version marker on failure - will retry next time
+      return {
+        success: false,
+        error: `Package migration ${migration.version} failed: ${errorMessage}`,
+      };
+    }
+  }
+
+  // All migrations succeeded, update version marker
+  config.migrations = config.migrations || {};
+  config.migrations.package = packageVersion;
+  saveConfig(config);
+  return { success: true };
+}

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');
+      }
     }
   });
 });