opencode-dux 1.0.0

package/src/cli/install.ts

@@ -0,0 +1,282 @@
+import { existsSync } from 'node:fs';
+import { createInterface } from 'node:readline/promises';
+import {
+  addPluginToOpenCodeConfig,
+  addPluginToOpenCodeTuiConfig,
+  detectCurrentConfig,
+  disableDefaultAgents,
+  enableLspByDefault,
+  generateLiteConfig,
+  getOpenCodePath,
+  getOpenCodeVersion,
+  isOpenCodeInstalled,
+  writeLiteConfig,
+} from './config-manager';
+import { getExistingLiteConfigPath } from './paths';
+import type { ConfigMergeResult, InstallArgs, InstallConfig } from './types';
+
+// Colors
+const GREEN = '\x1b[32m';
+const BLUE = '\x1b[34m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const RESET = '\x1b[0m';
+
+const SYMBOLS = {
+  check: `${GREEN}[ok]${RESET}`,
+  cross: `${RED}[x]${RESET}`,
+  arrow: `${BLUE}->${RESET}`,
+  bullet: `${DIM}-${RESET}`,
+  info: `${BLUE}[i]${RESET}`,
+  warn: `${YELLOW}[!]${RESET}`,
+  star: `${YELLOW}★${RESET}`,
+};
+
+const GITHUB_REPO = 'bakhtiar-personal-work/opencode-dux';
+const GITHUB_URL = `https://github.com/${GITHUB_REPO}`;
+
+function printHeader(isUpdate: boolean): void {
+  console.log();
+  console.log(
+    `${BOLD}opencode-dux ${isUpdate ? 'Update' : 'Install'}${RESET}`,
+  );
+  console.log('='.repeat(30));
+  console.log();
+}
+
+function printStep(step: number, total: number, message: string): void {
+  console.log(`${DIM}[${step}/${total}]${RESET} ${message}`);
+}
+
+function printSuccess(message: string): void {
+  console.log(`${SYMBOLS.check} ${message}`);
+}
+
+function printError(message: string): void {
+  console.log(`${SYMBOLS.cross} ${RED}${message}${RESET}`);
+}
+
+function printInfo(message: string): void {
+  console.log(`${SYMBOLS.info} ${message}`);
+}
+
+async function confirm(message: string, defaultYes = true): Promise<boolean> {
+  const suffix = defaultYes ? ' (Y/n) ' : ' (y/N) ';
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  try {
+    const answer = (await rl.question(`${message}${suffix}`))
+      .trim()
+      .toLowerCase();
+    if (!answer) return defaultYes;
+    return answer === 'y' || answer === 'yes';
+  } finally {
+    rl.close();
+  }
+}
+
+async function askToStarRepo(config: InstallConfig): Promise<void> {
+  if (!config.promptForStar || config.dryRun || !process.stdin.isTTY) return;
+
+  console.log();
+  const shouldStar = await confirm(
+    `${SYMBOLS.star} Star the repo on GitHub?`,
+    true,
+  );
+  if (!shouldStar) return;
+
+  try {
+    const { execFileSync } = await import('node:child_process');
+    execFileSync(
+      'gh',
+      ['api', '--silent', '--method', 'PUT', `/user/starred/${GITHUB_REPO}`],
+      { stdio: 'ignore', timeout: 10_000 },
+    );
+    printSuccess('Thanks for starring! ★');
+  } catch {
+    printInfo(
+      `Couldn't star automatically. You can star manually:\n  ${BLUE}${GITHUB_URL}${RESET}`,
+    );
+  }
+}
+
+async function checkOpenCodeInstalled(): Promise<{
+  ok: boolean;
+  version?: string;
+  path?: string;
+}> {
+  const installed = await isOpenCodeInstalled();
+  if (!installed) {
+    printError('OpenCode is not installed on this system.');
+    printInfo('Install it with:');
+    console.log(
+      `     ${BLUE}curl -fsSL https://opencode.ai/install | bash${RESET}`,
+    );
+    console.log();
+    printInfo('Or if already installed, add it to your PATH:');
+    console.log(`     ${BLUE}export PATH="$HOME/.local/bin:$PATH"${RESET}`);
+    console.log(`     ${BLUE}export PATH="$HOME/.opencode/bin:$PATH"${RESET}`);
+    return { ok: false };
+  }
+  const version = await getOpenCodeVersion();
+  const path = getOpenCodePath();
+  const detectedVersion = version ?? '';
+  const pathInfo = path ? ` (${DIM}${path}${RESET})` : '';
+  printSuccess(`OpenCode ${detectedVersion} detected${pathInfo}`);
+  return { ok: true, version: version ?? undefined, path: path ?? undefined };
+}
+
+function handleStepResult(
+  result: ConfigMergeResult,
+  successMsg: string,
+): boolean {
+  if (!result.success) {
+    printError(`Failed: ${result.error}`);
+    return false;
+  }
+  printSuccess(
+    `${successMsg} ${SYMBOLS.arrow} ${DIM}${result.configPath}${RESET}`,
+  );
+  return true;
+}
+
+async function runInstall(config: InstallConfig): Promise<number> {
+  const detected = detectCurrentConfig();
+  const isUpdate = detected.isInstalled;
+
+  printHeader(isUpdate);
+
+  const totalSteps = 6;
+
+  let step = 1;
+
+  printStep(step++, totalSteps, 'Checking OpenCode installation...');
+  if (config.dryRun) {
+    printInfo('Dry run mode - skipping OpenCode check');
+  } else {
+    const { ok } = await checkOpenCodeInstalled();
+    if (!ok) return 1;
+  }
+  printStep(step++, totalSteps, 'Adding opencode-dux plugin...');
+  if (config.dryRun) {
+    printInfo('Dry run mode - skipping plugin installation');
+  } else {
+    const pluginResult = await addPluginToOpenCodeConfig();
+    if (!handleStepResult(pluginResult, 'Plugin added')) return 1;
+  }
+
+  printStep(step++, totalSteps, 'Adding TUI version badge...');
+  if (config.dryRun) {
+    printInfo('Dry run mode - skipping TUI plugin installation');
+  } else {
+    const tuiResult = await addPluginToOpenCodeTuiConfig();
+    if (!tuiResult.success) {
+      printInfo(`Skipped TUI badge: ${tuiResult.error}`);
+    } else {
+      handleStepResult(tuiResult, 'TUI badge added');
+    }
+  }
+
+  printStep(step++, totalSteps, 'Disabling OpenCode default agents...');
+  if (config.dryRun) {
+    printInfo('Dry run mode - skipping agent disabling');
+  } else {
+    const agentResult = disableDefaultAgents();
+    if (!handleStepResult(agentResult, 'Default agents disabled')) return 1;
+  }
+
+  printStep(step++, totalSteps, 'Enabling OpenCode LSP integration...');
+  if (config.dryRun) {
+    printInfo('Dry run mode - skipping LSP configuration');
+  } else {
+    const lspResult = enableLspByDefault();
+    if (!handleStepResult(lspResult, 'LSP enabled')) return 1;
+  }
+
+  printStep(step++, totalSteps, 'Writing opencode-dux configuration...');
+  if (config.dryRun) {
+    const liteConfig = generateLiteConfig(config);
+    printInfo('Dry run mode - configuration that would be written:');
+    console.log(`\n${JSON.stringify(liteConfig, null, 2)}\n`);
+  } else {
+    const configPath = getExistingLiteConfigPath();
+    const configExists = existsSync(configPath);
+
+    if (configExists && !config.reset) {
+      printInfo(
+        `Configuration already exists at ${configPath}. ` +
+          'Use --reset to overwrite.',
+      );
+    } else {
+      const liteResult = writeLiteConfig(
+        config,
+        configExists ? configPath : undefined,
+      );
+      if (
+        !handleStepResult(
+          liteResult,
+          configExists ? 'Config reset' : 'Config written',
+        )
+      )
+        return 1;
+    }
+  }
+
+  const statusMsg = isUpdate
+    ? 'Configuration updated!'
+    : 'Installation complete!';
+  console.log(`${SYMBOLS.star} ${BOLD}${GREEN}${statusMsg}${RESET}`);
+  console.log();
+  console.log(`${BOLD}Next steps:${RESET}`);
+  console.log();
+
+  const configPath = getExistingLiteConfigPath();
+
+  console.log('  1. Log in to the provider(s) you want to use:');
+  console.log(`     ${BLUE}$ opencode auth login${RESET}`);
+  console.log();
+  console.log('  2. Refresh the models OpenCode can see:');
+  console.log(`     ${BLUE}$ opencode models --refresh${RESET}`);
+  console.log();
+  console.log('  3. Review your generated config:');
+  console.log(`     ${BLUE}${configPath}${RESET}`);
+  console.log();
+  console.log('  4. Start OpenCode:');
+  console.log(`     ${BLUE}$ opencode${RESET}`);
+  console.log();
+  console.log('  5. Verify the agents are responding:');
+  console.log(`     ${BLUE}> ping all agents${RESET}`);
+  console.log();
+
+  const modelsInfo =
+    config.preset && config.preset !== 'openai'
+      ? `Generated OpenAI and OpenCode Go presets; ${config.preset} is active.`
+      : 'Generated OpenAI and OpenCode Go presets; OpenAI is active by default.';
+  console.log(`${modelsInfo}`);
+  const altProviders = 'For the full configuration reference, see:';
+  console.log(altProviders);
+  const docsUrl =
+    'https://github.com/bakhtiar-personal-work/opencode-dux/' +
+    'blob/master/docs/configuration.md';
+  console.log(`  ${BLUE}${docsUrl}${RESET}`);
+  console.log();
+
+  await askToStarRepo(config);
+
+  return 0;
+}
+
+export async function install(args: InstallArgs): Promise<number> {
+  const config: InstallConfig = {
+    installSkills: false,
+    installCustomSkills: false,
+    preset: args.preset,
+    promptForStar: args.tui,
+    dryRun: args.dryRun,
+    reset: args.reset ?? false,
+  };
+
+  return runInstall(config);
+}

package/src/cli/mcps.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from 'bun:test';
+import { getMcpPermissionsForAgent } from './mcps';
+
+describe('MCP permissions', () => {
+  it('should allow all MCPs by default', async () => {
+    const permissions = await getMcpPermissionsForAgent('oracle');
+    expect(permissions['*']).toBe('allow');
+  });
+
+  it('should handle empty array', async () => {
+    const permissions = await getMcpPermissionsForAgent('oracle', []);
+    expect(permissions['*']).toBe('deny');
+  });
+
+  it('should handle explicit MCP list', async () => {
+    const permissions = await getMcpPermissionsForAgent('oracle', [
+      'websearch',
+      'context7',
+    ]);
+    expect(permissions['*']).toBe('deny');
+    expect(permissions.websearch).toBe('allow');
+    expect(permissions.context7).toBe('allow');
+    expect(permissions.grep_app).toBeUndefined();
+  });
+
+  it('should handle wildcard in array', async () => {
+    const permissions = await getMcpPermissionsForAgent('oracle', ['*']);
+    expect(permissions['*']).toBe('allow');
+  });
+
+  it('should handle exclusion in array', async () => {
+    const permissions = await getMcpPermissionsForAgent('oracle', [
+      '*',
+      '!grep_app',
+    ]);
+    expect(permissions['*']).toBe('allow');
+    expect(permissions.grep_app).toBe('deny');
+  });
+
+  it('should handle object syntax with always-load', async () => {
+    const permissions = await getMcpPermissionsForAgent('oracle', {
+      'always-load': ['websearch'],
+    });
+    expect(permissions['*']).toBe('deny');
+    expect(permissions.websearch).toBe('allow');
+  });
+
+  it('should handle deprecated mandatory fallback', async () => {
+    const permissions = await getMcpPermissionsForAgent('oracle', {
+      mandatory: ['websearch'],
+    });
+    expect(permissions['*']).toBe('deny');
+    expect(permissions.websearch).toBe('allow');
+  });
+
+  it('should handle object syntax with wildcard', async () => {
+    const permissions = await getMcpPermissionsForAgent('oracle', {
+      wildcard: true,
+    });
+    expect(permissions['*']).toBe('allow');
+  });
+});

package/src/cli/mcps.ts

@@ -0,0 +1,39 @@
+import type { SkillOrMcpConfig } from '../config';
+import { type NormalizedSkillConfig, normalizeSkillConfig } from './skills';
+
+export type { NormalizedSkillConfig as NormalizedMcpConfig };
+// Reuse normalizeSkillConfig for McpConfig since it has the same shape
+export { normalizeSkillConfig as normalizeMcpConfig };
+
+/**
+ * Get MCP permissions for a specific agent.
+ * MCP permission rules use 'allow'/'deny' per MCP name.
+ *
+ * @param agentName - The agent name
+ * @param mcpList - Optional MCP config (object or array syntax)
+ * @returns Permission rules keyed by MCP name
+ */
+export async function getMcpPermissionsForAgent(
+  _agentName: string,
+  mcpList?: SkillOrMcpConfig,
+): Promise<Record<string, 'allow' | 'ask' | 'deny'>> {
+  const permissions: Record<string, 'allow' | 'ask' | 'deny'> = {};
+
+  if (mcpList === undefined) {
+    // Default: all builtin MCPs allowed for all agents
+    permissions['*'] = 'allow';
+    return permissions;
+  }
+
+  const normalized = normalizeSkillConfig(mcpList);
+  permissions['*'] = normalized.wildcard ? 'allow' : 'deny';
+
+  for (const name of normalized.alwaysLoad) {
+    permissions[name] = 'allow';
+  }
+  for (const name of normalized.excluded) {
+    permissions[name] = 'deny';
+  }
+
+  return permissions;
+}

package/src/cli/model-key-normalization.test.ts

@@ -0,0 +1,21 @@
+/// <reference types="bun-types" />
+
+import { describe, expect, test } from 'bun:test';
+import { buildModelKeyAliases } from './model-key-normalization';
+
+describe('model key normalization', () => {
+  test('normalizes multi-segment chutes model ids', () => {
+    const aliases = buildModelKeyAliases(
+      'chutes/Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8-TEE',
+    );
+
+    expect(aliases).toContain('qwen/qwen3-coder-480b-a35b-instruct');
+    expect(aliases).toContain('qwen3-coder-480b-a35b-instruct');
+    expect(aliases).not.toContain('qwen3-coder-480b-a35b-instruct-fp8-tee');
+  });
+
+  test('treats spaces and hyphens as equivalent aliases', () => {
+    const aliases = buildModelKeyAliases('Qwen3 Coder 480B A35B Instruct');
+    expect(aliases).toContain('qwen3-coder-480b-a35b-instruct');
+  });
+});

package/src/cli/model-key-normalization.ts

@@ -0,0 +1,60 @@
+function cleanupAlias(input: string, preserveSlash: boolean): string {
+  let value = input.toLowerCase().trim();
+  value = value.replace(/\bfp[a-z0-9.-]*\b/g, ' ');
+  value = value.replace(/\btee\b/g, ' ');
+
+  if (preserveSlash) {
+    value = value.replace(/[_\s]+/g, '-');
+    value = value.replace(/-+/g, '-');
+    value = value.replace(/\/+/g, '/');
+    value = value.replace(/\/-+/g, '/');
+    value = value.replace(/-+\//g, '/');
+    value = value.replace(/^\/+|\/+$/g, '');
+    value = value.replace(/^-+|-+$/g, '');
+    return value;
+  }
+
+  value = value.replace(/[/_\s]+/g, '-');
+  value = value.replace(/-+/g, '-');
+  value = value.replace(/^-+|-+$/g, '');
+  return value;
+}
+
+function addDerivedAliases(seed: string, aliases: Set<string>): void {
+  const slashAlias = cleanupAlias(seed, true);
+  const flatAlias = cleanupAlias(seed, false);
+
+  if (slashAlias) aliases.add(slashAlias);
+  if (flatAlias) aliases.add(flatAlias);
+
+  if (slashAlias) {
+    aliases.add(slashAlias.replace(/-(free|flash)$/i, ''));
+  }
+  if (flatAlias) {
+    aliases.add(flatAlias.replace(/-(free|flash)$/i, ''));
+  }
+
+  if (slashAlias.includes('/')) {
+    aliases.add(cleanupAlias(slashAlias.replace(/\//g, ' '), false));
+    aliases.add(cleanupAlias(slashAlias.replace(/\//g, '-'), false));
+    const lastPart = slashAlias.split('/').at(-1);
+    if (lastPart) {
+      addDerivedAliases(lastPart, aliases);
+    }
+  }
+}
+
+export function buildModelKeyAliases(input: string): string[] {
+  const normalized = input.trim().toLowerCase();
+  if (!normalized) return [];
+
+  const aliases = new Set<string>();
+  const slashIndex = normalized.indexOf('/');
+  const afterProvider =
+    slashIndex >= 0 ? normalized.slice(slashIndex + 1) : normalized;
+
+  addDerivedAliases(normalized, aliases);
+  addDerivedAliases(afterProvider, aliases);
+
+  return [...aliases].filter((alias) => alias.length > 0);
+}

package/src/cli/paths.test.ts

@@ -0,0 +1,167 @@
+/// <reference types="bun-types" />
+
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
+import { join, normalize } from 'node:path';
+import { platform } from 'node:os';
+import {
+  ensureConfigDir,
+  getConfigDir,
+  getConfigJson,
+  getConfigJsonc,
+  getConfigSearchDirs,
+  getExistingConfigPath,
+  getLiteConfig,
+  getOpenCodeConfigPaths,
+} from './paths';
+
+function p(path: string): string {
+  return normalize(path);
+}
+
+describe('paths', () => {
+  const originalEnv = { ...process.env };
+
+  beforeEach(() => {
+    delete process.env.OPENCODE_CONFIG_DIR;
+  });
+
+  afterEach(() => {
+    process.env = { ...originalEnv };
+  });
+
+  test('getConfigDir() uses OPENCODE_CONFIG_DIR when set', () => {
+    process.env.OPENCODE_CONFIG_DIR = '/custom/directory';
+    delete process.env.XDG_CONFIG_HOME;
+    expect(getConfigDir()).toBe('/custom/directory');
+  });
+
+  test('getConfigDir() uses XDG_CONFIG_HOME when set', () => {
+    delete process.env.OPENCODE_CONFIG_DIR;
+    process.env.XDG_CONFIG_HOME = '/tmp/xdg-config';
+    expect(getConfigDir()).toBe(p('/tmp/xdg-config/opencode'));
+  });
+
+  test('getConfigDir() falls back to ~/.config when XDG_CONFIG_HOME is unset', () => {
+    delete process.env.OPENCODE_CONFIG_DIR;
+    delete process.env.XDG_CONFIG_HOME;
+    const expected = join(homedir(), '.config', 'opencode');
+    expect(getConfigDir()).toBe(expected);
+  });
+
+  test('getConfigSearchDirs() returns custom dir first, then default dir', () => {
+    process.env.OPENCODE_CONFIG_DIR = '/custom/directory';
+    process.env.XDG_CONFIG_HOME = '/tmp/xdg-config';
+
+    expect(getConfigSearchDirs()).toEqual([
+      '/custom/directory',
+      p('/tmp/xdg-config/opencode'),
+    ]);
+  });
+
+  const testDedup = platform() === 'win32' ? test.skip : test;
+  testDedup('getConfigSearchDirs() de-duplicates identical dirs', () => {
+    process.env.OPENCODE_CONFIG_DIR = '/tmp/xdg-config/opencode';
+    process.env.XDG_CONFIG_HOME = '/tmp/xdg-config';
+
+    expect(getConfigSearchDirs()).toEqual([p('/tmp/xdg-config/opencode')]);
+  });
+
+  test('getOpenCodeConfigPaths() returns both json and jsonc paths', () => {
+    process.env.XDG_CONFIG_HOME = '/tmp/xdg-config';
+    expect(getOpenCodeConfigPaths()).toEqual([
+      p('/tmp/xdg-config/opencode/opencode.json'),
+      p('/tmp/xdg-config/opencode/opencode.jsonc'),
+    ]);
+  });
+
+  test('getOpenCodeConfigPaths() ignores OPENCODE_CONFIG_DIR', () => {
+    process.env.OPENCODE_CONFIG_DIR = '/custom/directory';
+    process.env.XDG_CONFIG_HOME = '/tmp/xdg-config';
+    expect(getOpenCodeConfigPaths()).toEqual([
+      p('/tmp/xdg-config/opencode/opencode.json'),
+      p('/tmp/xdg-config/opencode/opencode.jsonc'),
+    ]);
+  });
+
+  test('getConfigJson() returns correct path', () => {
+    process.env.XDG_CONFIG_HOME = '/tmp/xdg-config';
+    expect(getConfigJson()).toBe(p('/tmp/xdg-config/opencode/opencode.json'));
+  });
+
+  test('getConfigJsonc() returns correct path', () => {
+    process.env.XDG_CONFIG_HOME = '/tmp/xdg-config';
+    expect(getConfigJsonc()).toBe(p('/tmp/xdg-config/opencode/opencode.jsonc'));
+  });
+
+  test('getLiteConfig() returns correct path', () => {
+    process.env.XDG_CONFIG_HOME = '/tmp/xdg-config';
+    expect(getLiteConfig()).toBe(
+      p('/tmp/xdg-config/opencode/opencode-dux.json'),
+    );
+  });
+
+  test('getLiteConfig() respects OPENCODE_CONFIG_DIR', () => {
+    process.env.OPENCODE_CONFIG_DIR = '/custom/directory';
+    expect(getLiteConfig()).toBe(
+      p('/custom/directory/opencode-dux.json'),
+    );
+  });
+
+  describe('getExistingConfigPath()', () => {
+    let tmpDir: string;
+
+    afterEach(() => {
+      if (tmpDir && existsSync(tmpDir)) {
+        rmSync(tmpDir, { recursive: true, force: true });
+      }
+    });
+
+    test('returns .json if it exists', () => {
+      tmpDir = mkdtempSync(join(tmpdir(), 'opencode-test-'));
+      process.env.XDG_CONFIG_HOME = tmpDir;
+
+      const configDir = join(tmpDir, 'opencode');
+      ensureConfigDir();
+
+      const jsonPath = join(configDir, 'opencode.json');
+      writeFileSync(jsonPath, '{}');
+
+      expect(getExistingConfigPath()).toBe(jsonPath);
+    });
+
+    test("returns .jsonc if .json doesn't exist but .jsonc does", () => {
+      tmpDir = mkdtempSync(join(tmpdir(), 'opencode-test-'));
+      process.env.XDG_CONFIG_HOME = tmpDir;
+
+      const configDir = join(tmpDir, 'opencode');
+      ensureConfigDir();
+
+      const jsoncPath = join(configDir, 'opencode.jsonc');
+      writeFileSync(jsoncPath, '{}');
+
+      expect(getExistingConfigPath()).toBe(jsoncPath);
+    });
+
+    test('returns default .json if neither exists', () => {
+      tmpDir = mkdtempSync(join(tmpdir(), 'opencode-test-'));
+      process.env.XDG_CONFIG_HOME = tmpDir;
+
+      const jsonPath = join(tmpDir, 'opencode', 'opencode.json');
+      expect(getExistingConfigPath()).toBe(jsonPath);
+    });
+  });
+
+  test("ensureConfigDir() creates directory if it doesn't exist", () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), 'opencode-test-'));
+    process.env.XDG_CONFIG_HOME = tmpDir;
+    const configDir = join(tmpDir, 'opencode');
+
+    expect(existsSync(configDir)).toBe(false);
+    ensureConfigDir();
+    expect(existsSync(configDir)).toBe(true);
+
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+});