@orderful/droid 0.6.0 → 0.8.0

package/src/commands/setup.test.ts

@@ -0,0 +1,276 @@
+import { describe, it, expect, beforeEach, afterEach, mock, spyOn } from 'bun:test';
+import { existsSync, mkdirSync, rmSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { AITool } from '../lib/types.js';
+
+// We need to mock homedir() before importing the module
+// Create a test directory that will act as our fake home
+let testHomeDir: string;
+
+// Mock the os module's homedir function
+const originalHomedir = await import('os').then(m => m.homedir);
+
+describe('configureAIToolPermissions', () => {
+  beforeEach(() => {
+    testHomeDir = join(tmpdir(), `droid-setup-test-${Date.now()}`);
+    mkdirSync(testHomeDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(testHomeDir)) {
+      rmSync(testHomeDir, { recursive: true });
+    }
+  });
+
+  describe('OpenCode plugin configuration', () => {
+    it('should add opencode-skills plugin to empty config', () => {
+      const configDir = join(testHomeDir, '.config', 'opencode');
+      const configPath = join(configDir, 'opencode.json');
+
+      mkdirSync(configDir, { recursive: true });
+
+      const config: { plugin?: string[] } = {};
+      if (!Array.isArray(config.plugin)) {
+        config.plugin = [];
+      }
+      config.plugin.push('opencode-skills');
+
+      writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+
+      const read = JSON.parse(readFileSync(configPath, 'utf-8'));
+      expect(read.plugin).toContain('opencode-skills');
+    });
+
+    it('should add opencode-skills plugin to config with existing plugins', () => {
+      const configDir = join(testHomeDir, '.config', 'opencode');
+      const configPath = join(configDir, 'opencode.json');
+
+      mkdirSync(configDir, { recursive: true });
+
+      const existingConfig = {
+        plugin: ['some-other-plugin'],
+        theme: 'dark',
+      };
+      writeFileSync(configPath, JSON.stringify(existingConfig, null, 2), 'utf-8');
+
+      // Read and modify (simulating what the function does)
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      if (!config.plugin.includes('opencode-skills')) {
+        config.plugin.push('opencode-skills');
+      }
+      writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+
+      const read = JSON.parse(readFileSync(configPath, 'utf-8'));
+      expect(read.plugin).toContain('opencode-skills');
+      expect(read.plugin).toContain('some-other-plugin');
+      expect(read.theme).toBe('dark');
+    });
+
+    it('should not duplicate opencode-skills if already present', () => {
+      const configDir = join(testHomeDir, '.config', 'opencode');
+      const configPath = join(configDir, 'opencode.json');
+
+      mkdirSync(configDir, { recursive: true });
+
+      const existingConfig = {
+        plugin: ['opencode-skills'],
+      };
+      writeFileSync(configPath, JSON.stringify(existingConfig, null, 2), 'utf-8');
+
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      const alreadyPresent = config.plugin.includes('opencode-skills');
+
+      expect(alreadyPresent).toBe(true);
+      expect(config.plugin.length).toBe(1);
+    });
+
+    it('should handle config without plugin key', () => {
+      const configDir = join(testHomeDir, '.config', 'opencode');
+      const configPath = join(configDir, 'opencode.json');
+
+      mkdirSync(configDir, { recursive: true });
+
+      const existingConfig = {
+        theme: 'dark',
+        model: 'claude-sonnet',
+      };
+      writeFileSync(configPath, JSON.stringify(existingConfig, null, 2), 'utf-8');
+
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      if (!Array.isArray(config.plugin)) {
+        config.plugin = [];
+      }
+      config.plugin.push('opencode-skills');
+      writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+
+      const read = JSON.parse(readFileSync(configPath, 'utf-8'));
+      expect(read.plugin).toContain('opencode-skills');
+      expect(read.theme).toBe('dark');
+      expect(read.model).toBe('claude-sonnet');
+    });
+
+    it('should create config directory if it does not exist', () => {
+      const nestedDir = join(testHomeDir, '.config', 'opencode');
+      expect(existsSync(nestedDir)).toBe(false);
+
+      mkdirSync(nestedDir, { recursive: true });
+      expect(existsSync(nestedDir)).toBe(true);
+
+      const configPath = join(nestedDir, 'opencode.json');
+      const config = { plugin: ['opencode-skills'] };
+      writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+
+      expect(existsSync(configPath)).toBe(true);
+    });
+
+    it('should handle corrupted JSON gracefully', () => {
+      const configDir = join(testHomeDir, '.config', 'opencode');
+      const configPath = join(configDir, 'opencode.json');
+
+      mkdirSync(configDir, { recursive: true });
+      writeFileSync(configPath, '{ invalid json }}}', 'utf-8');
+
+      let config: { plugin?: string[] } = {};
+      try {
+        config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      } catch {
+        // Invalid JSON, start fresh
+        config = {};
+      }
+
+      if (!Array.isArray(config.plugin)) {
+        config.plugin = [];
+      }
+      config.plugin.push('opencode-skills');
+
+      expect(config.plugin).toContain('opencode-skills');
+    });
+  });
+
+  describe('Claude Code permissions configuration', () => {
+    it('should add permissions to empty settings', () => {
+      const claudeDir = join(testHomeDir, '.claude');
+      const settingsPath = join(claudeDir, 'settings.json');
+
+      mkdirSync(claudeDir, { recursive: true });
+
+      const settings: { permissions?: { allow?: string[] } } = {};
+      if (!settings.permissions) {
+        settings.permissions = {};
+      }
+      if (!Array.isArray(settings.permissions.allow)) {
+        settings.permissions.allow = [];
+      }
+
+      const permissions = ['Read(~/.droid/**)', 'Write(~/.droid/**)'];
+      for (const perm of permissions) {
+        if (!settings.permissions.allow.includes(perm)) {
+          settings.permissions.allow.push(perm);
+        }
+      }
+
+      writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+
+      const read = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+      expect(read.permissions.allow).toContain('Read(~/.droid/**)');
+      expect(read.permissions.allow).toContain('Write(~/.droid/**)');
+    });
+
+    it('should preserve existing settings when adding permissions', () => {
+      const claudeDir = join(testHomeDir, '.claude');
+      const settingsPath = join(claudeDir, 'settings.json');
+
+      mkdirSync(claudeDir, { recursive: true });
+
+      const existingSettings = {
+        permissions: {
+          allow: ['Bash(git:*)'],
+          deny: ['Bash(rm -rf /*)'],
+        },
+        other_setting: true,
+      };
+      writeFileSync(settingsPath, JSON.stringify(existingSettings, null, 2), 'utf-8');
+
+      const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+      settings.permissions.allow.push('Read(~/.droid/**)');
+      writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+
+      const read = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+      expect(read.permissions.allow).toContain('Bash(git:*)');
+      expect(read.permissions.allow).toContain('Read(~/.droid/**)');
+      expect(read.permissions.deny).toContain('Bash(rm -rf /*)');
+      expect(read.other_setting).toBe(true);
+    });
+
+    it('should handle corrupted JSON gracefully', () => {
+      const claudeDir = join(testHomeDir, '.claude');
+      const settingsPath = join(claudeDir, 'settings.json');
+
+      mkdirSync(claudeDir, { recursive: true });
+      writeFileSync(settingsPath, '{ not valid json {{{{', 'utf-8');
+
+      let settings: { permissions?: { allow?: string[] } } = {};
+      try {
+        settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+      } catch {
+        // Invalid JSON, start fresh
+        settings = {};
+      }
+
+      if (!settings.permissions) {
+        settings.permissions = {};
+      }
+      if (!Array.isArray(settings.permissions.allow)) {
+        settings.permissions.allow = [];
+      }
+      settings.permissions.allow.push('Read(~/.droid/**)');
+
+      expect(settings.permissions.allow).toContain('Read(~/.droid/**)');
+    });
+  });
+
+  describe('Return value validation', () => {
+    it('should return added items when new permissions are added', () => {
+      const added: string[] = [];
+      const permissions = ['Read(~/.droid/**)', 'Write(~/.droid/**)'];
+      const existingAllow: string[] = [];
+
+      for (const perm of permissions) {
+        if (!existingAllow.includes(perm)) {
+          existingAllow.push(perm);
+          added.push(perm);
+        }
+      }
+
+      expect(added).toHaveLength(2);
+      expect(added).toContain('Read(~/.droid/**)');
+      expect(added).toContain('Write(~/.droid/**)');
+    });
+
+    it('should return alreadyPresent=true when no new permissions needed', () => {
+      const added: string[] = [];
+      const permissions = ['Read(~/.droid/**)'];
+      const existingAllow = ['Read(~/.droid/**)', 'Write(~/.droid/**)'];
+
+      for (const perm of permissions) {
+        if (!existingAllow.includes(perm)) {
+          existingAllow.push(perm);
+          added.push(perm);
+        }
+      }
+
+      const alreadyPresent = added.length === 0;
+      expect(alreadyPresent).toBe(true);
+    });
+
+    it('should return error when write fails', () => {
+      // Simulate what the function returns on write error
+      const result = { added: [], alreadyPresent: false, error: 'Failed to update OpenCode config: EACCES' };
+
+      expect(result.error).toBeDefined();
+      expect(result.error).toContain('Failed to update');
+      expect(result.added).toHaveLength(0);
+    });
+  });
+});

package/src/commands/setup.ts

@@ -51,10 +51,17 @@ function detectGitUsername(): string {
   }
 }
 
+/**
+ * The opencode-skills plugin name for OpenCode
+ * This plugin enables Claude Code-style skills in OpenCode
+ * @see https://github.com/malhashemi/opencode-skills
+ */
+const OPENCODE_SKILLS_PLUGIN = 'opencode-skills';
+
 /**
  * Configure AI tool permissions for droid
  */
-export function configureAIToolPermissions(aiTool: AITool): { added: string[]; alreadyPresent: boolean } {
+export function configureAIToolPermissions(aiTool: AITool): { added: string[]; alreadyPresent: boolean; error?: string } {
   const added: string[] = [];
 
   if (aiTool === AITool.ClaudeCode) {
@@ -72,7 +79,7 @@ export function configureAIToolPermissions(aiTool: AITool): { added: string[]; a
       try {
         settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
       } catch {
-        // Invalid JSON, start fresh
+        console.warn(chalk.yellow('⚠ Claude Code settings.json appears corrupted, resetting permissions'));
         settings = {};
       }
     }
@@ -95,13 +102,63 @@ export function configureAIToolPermissions(aiTool: AITool): { added: string[]; a
 
     // Save if we added anything
     if (added.length > 0) {
-      writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+      try {
+        writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+      } catch (e) {
+        const message = e instanceof Error ? e.message : 'Unknown error';
+        return { added: [], alreadyPresent: false, error: `Failed to update Claude Code settings: ${message}` };
+      }
+    }
+
+    return { added, alreadyPresent: added.length === 0 };
+  }
+
+  if (aiTool === AITool.OpenCode) {
+    // OpenCode uses opencode.json for config
+    // Check global config location: ~/.config/opencode/opencode.json
+    const globalConfigDir = join(homedir(), '.config', 'opencode');
+    const globalConfigPath = join(globalConfigDir, 'opencode.json');
+
+    // Ensure config directory exists
+    if (!existsSync(globalConfigDir)) {
+      mkdirSync(globalConfigDir, { recursive: true });
+    }
+
+    // Load or create config
+    let config: { plugin?: string[] } = {};
+    if (existsSync(globalConfigPath)) {
+      try {
+        config = JSON.parse(readFileSync(globalConfigPath, 'utf-8'));
+      } catch {
+        console.warn(chalk.yellow('⚠ OpenCode config appears corrupted, resetting'));
+        config = {};
+      }
+    }
+
+    // Ensure plugin array exists
+    if (!Array.isArray(config.plugin)) {
+      config.plugin = [];
+    }
+
+    // Add opencode-skills plugin if not present
+    if (!config.plugin.includes(OPENCODE_SKILLS_PLUGIN)) {
+      config.plugin.push(OPENCODE_SKILLS_PLUGIN);
+      added.push(OPENCODE_SKILLS_PLUGIN);
+    }
+
+    // Save if we added anything
+    if (added.length > 0) {
+      try {
+        writeFileSync(globalConfigPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+      } catch (e) {
+        const message = e instanceof Error ? e.message : 'Unknown error';
+        return { added: [], alreadyPresent: false, error: `Failed to update OpenCode config: ${message}` };
+      }
     }
 
     return { added, alreadyPresent: added.length === 0 };
   }
 
-  // OpenCode - TODO: implement when we know the settings path
   return { added: [], alreadyPresent: true };
 }
 
@@ -214,12 +271,25 @@ export async function setupCommand(): Promise<void> {
 
   console.log(chalk.green('\n✓ Config saved to ~/.droid/config.yaml'));
 
-  // Configure AI tool permissions
-  const { added, alreadyPresent } = configureAIToolPermissions(answers.ai_tool);
-  if (added.length > 0) {
-    console.log(chalk.green(`✓ Added droid permissions to ${answers.ai_tool} settings`));
-  } else if (alreadyPresent) {
-    console.log(chalk.gray(`  Droid permissions already configured in ${answers.ai_tool}`));
+  // Configure AI tool permissions/plugins
+  const { added, alreadyPresent, error } = configureAIToolPermissions(answers.ai_tool);
+  if (error) {
+    console.log(chalk.red(`✗ ${error}`));
+    console.log(chalk.yellow('  You may need to manually configure your AI tool'));
+  } else if (answers.ai_tool === AITool.ClaudeCode) {
+    if (added.length > 0) {
+      console.log(chalk.green(`✓ Added droid permissions to Claude Code settings`));
+    } else if (alreadyPresent) {
+      console.log(chalk.gray(`  Droid permissions already configured in Claude Code`));
+    }
+  } else if (answers.ai_tool === AITool.OpenCode) {
+    if (added.length > 0) {
+      console.log(chalk.green(`✓ Added opencode-skills plugin to OpenCode config`));
+      console.log(chalk.gray(`  This enables Claude Code-style skills in OpenCode`));
+      console.log(chalk.gray(`  Restart OpenCode to activate the plugin`));
+    } else if (alreadyPresent) {
+      console.log(chalk.gray(`  opencode-skills plugin already configured in OpenCode`));
+    }
   }
 
   console.log(chalk.gray('\nRun `droid skills` to browse and install skills.'));