opencode-dux 1.0.0

package/src/cli/paths.ts

@@ -0,0 +1,144 @@
+import { existsSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+function getDefaultOpenCodeConfigDir(): string {
+  const userConfigDir = process.env.XDG_CONFIG_HOME
+    ? process.env.XDG_CONFIG_HOME
+    : join(homedir(), '.config');
+
+  return join(userConfigDir, 'opencode');
+}
+
+function getCustomOpenCodeConfigDir(): string | undefined {
+  const configDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+  return configDir || undefined;
+}
+
+function getCustomTuiConfigPath(): string | undefined {
+  const configPath = process.env.OPENCODE_TUI_CONFIG?.trim();
+  return configPath || undefined;
+}
+
+/**
+ * Get the OpenCode plugin config directory.
+ *
+ * Resolution order:
+ * 1. OPENCODE_CONFIG_DIR (custom OpenCode directory)
+ * 2. XDG_CONFIG_HOME/opencode
+ * 3. ~/.config/opencode
+ */
+export function getConfigDir(): string {
+  const customConfigDir = getCustomOpenCodeConfigDir();
+  if (customConfigDir) {
+    return customConfigDir;
+  }
+
+  return getDefaultOpenCodeConfigDir();
+}
+
+/**
+ * Get OpenCode config directories in read/search order.
+ *
+ * Resolution order:
+ * 1. OPENCODE_CONFIG_DIR (if set)
+ * 2. XDG_CONFIG_HOME/opencode or ~/.config/opencode
+ *
+ * Duplicate entries are removed.
+ */
+export function getConfigSearchDirs(): string[] {
+  const dirs = [getCustomOpenCodeConfigDir(), getDefaultOpenCodeConfigDir()];
+
+  return dirs.filter((dir, index): dir is string => {
+    return Boolean(dir) && dirs.indexOf(dir) === index;
+  });
+}
+
+export function getOpenCodeConfigPaths(): string[] {
+  const configDir = getDefaultOpenCodeConfigDir();
+  return [join(configDir, 'opencode.json'), join(configDir, 'opencode.jsonc')];
+}
+
+export function getConfigJson(): string {
+  return getOpenCodeConfigPaths()[0];
+}
+
+export function getConfigJsonc(): string {
+  return getOpenCodeConfigPaths()[1];
+}
+
+export function getLiteConfig(): string {
+  return join(getConfigDir(), 'opencode-dux.json');
+}
+
+export function getLiteConfigJsonc(): string {
+  return join(getConfigDir(), 'opencode-dux.jsonc');
+}
+
+export function getTuiConfig(): string {
+  const customConfigPath = getCustomTuiConfigPath();
+  if (customConfigPath) return customConfigPath;
+
+  return join(getConfigDir(), 'tui.json');
+}
+
+export function getTuiConfigJsonc(): string {
+  return join(getConfigDir(), 'tui.jsonc');
+}
+
+export function getExistingLiteConfigPath(): string {
+  const jsonPath = getLiteConfig();
+  if (existsSync(jsonPath)) return jsonPath;
+
+  const jsoncPath = getLiteConfigJsonc();
+  if (existsSync(jsoncPath)) return jsoncPath;
+
+  return jsonPath;
+}
+
+export function getExistingTuiConfigPath(): string {
+  const customConfigPath = getCustomTuiConfigPath();
+  if (customConfigPath) return customConfigPath;
+
+  const jsonPath = join(getConfigDir(), 'tui.json');
+  if (existsSync(jsonPath)) return jsonPath;
+
+  const jsoncPath = getTuiConfigJsonc();
+  if (existsSync(jsoncPath)) return jsoncPath;
+
+  return jsonPath;
+}
+
+export function getExistingConfigPath(): string {
+  const jsonPath = getConfigJson();
+  if (existsSync(jsonPath)) return jsonPath;
+
+  const jsoncPath = getConfigJsonc();
+  if (existsSync(jsoncPath)) return jsoncPath;
+
+  return jsonPath;
+}
+
+export function ensureConfigDir(): void {
+  const configDir = getConfigDir();
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+}
+
+export function ensureTuiConfigDir(): void {
+  const configDir = dirname(getTuiConfig());
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+}
+
+/**
+ * Ensure the directory for OpenCode's main config file exists.
+ */
+export function ensureOpenCodeConfigDir(): void {
+  const configDir = dirname(getConfigJson());
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+}

package/src/cli/providers.test.ts

@@ -0,0 +1,118 @@
+/// <reference types="bun-types" />
+
+import { describe, expect, test } from 'bun:test';
+import { generateLiteConfig, MODEL_MAPPINGS } from './providers';
+
+describe('providers', () => {
+  test('MODEL_MAPPINGS includes supported providers', () => {
+    const keys = Object.keys(MODEL_MAPPINGS);
+    expect(keys.sort()).toEqual([
+      'copilot',
+      'kimi',
+      'openai',
+      'opencode-go',
+      'zai-plan',
+    ]);
+  });
+
+  test('generateLiteConfig defaults to openai and includes generated presets', () => {
+    const config = generateLiteConfig({
+      installSkills: false,
+      installCustomSkills: false,
+      reset: false,
+    });
+
+    expect(config.$schema).toBe(
+      'https://unpkg.com/opencode-dux@latest/opencode-dux.schema.json',
+    );
+    expect(config.preset).toBe('openai');
+    expect((config.presets as any)['opencode-go']).toBeDefined();
+    const agents = (config.presets as any).openai;
+    expect(agents).toBeDefined();
+    expect(agents.orchestrator.model).toBe('openai/gpt-5.5');
+    expect(agents.orchestrator.variant).toBeUndefined();
+    expect(agents.fixer.model).toBe('openai/gpt-5.4-mini');
+    expect(agents.fixer.variant).toBe('low');
+  });
+
+  test('generateLiteConfig uses correct OpenAI models', () => {
+    const config = generateLiteConfig({
+      installSkills: false,
+      installCustomSkills: false,
+      reset: false,
+    });
+
+    const agents = (config.presets as any).openai;
+    expect(agents.orchestrator.model).toBe(
+      MODEL_MAPPINGS.openai.orchestrator.model,
+    );
+    expect(agents.oracle.model).toBe('openai/gpt-5.5');
+    expect(agents.oracle.variant).toBe('high');
+    expect(agents.librarian.model).toBe('openai/gpt-5.4-mini');
+    expect(agents.librarian.variant).toBe('low');
+    expect(agents.explorer.model).toBe('openai/gpt-5.4-mini');
+    expect(agents.explorer.variant).toBe('low');
+    expect(agents.designer.model).toBe('openai/gpt-5.4-mini');
+    expect(agents.designer.variant).toBe('medium');
+  });
+
+  test('generateLiteConfig can set opencode-go as active preset', () => {
+    const config = generateLiteConfig({
+      installSkills: false,
+      installCustomSkills: false,
+      preset: 'opencode-go',
+      reset: false,
+    });
+
+    expect(config.preset).toBe('opencode-go');
+    expect((config.presets as any).openai).toBeDefined();
+    const agents = (config.presets as any)['opencode-go'];
+    expect(agents).toBeDefined();
+    expect(agents.orchestrator.model).toBe('neuralwatt/zai-org/GLM-5.1-FP8');
+    expect(agents.orchestrator.variant).toBe('medium');
+    expect(agents.oracle.model).toBe('opencode-go/deepseek-v4-flash');
+    expect(agents.oracle.variant).toBe('medium');
+    expect(agents.librarian.model).toBe('opencode-go/deepseek-v4-flash');
+    expect(agents.librarian.variant).toBe('low');
+    expect(agents.explorer.model).toBe('neuralwatt/qwen3.5-397b-fast');
+    expect(agents.explorer.variant).toBe('low');
+    expect(agents.designer.model).toBe('opencode-go/mimo-v2.5-pro');
+    expect(agents.fixer.model).toBe('opencode-go/deepseek-v4-flash');
+    expect(agents.fixer.variant).toBe('low');
+  });
+
+  test('generateLiteConfig rejects unsupported preset', () => {
+    expect(() =>
+      generateLiteConfig({
+          installSkills: false,
+        installCustomSkills: false,
+        preset: 'not-real',
+        reset: false,
+      }),
+    ).toThrow('Unsupported preset "not-real"');
+  });
+
+  test('generateLiteConfig rejects non-generated model mappings as active presets', () => {
+    expect(() =>
+      generateLiteConfig({
+          installSkills: false,
+        installCustomSkills: false,
+        preset: 'kimi',
+        reset: false,
+      }),
+    ).toThrow('Unsupported preset "kimi"');
+  });
+
+  test('generateLiteConfig rejects inherited property names as presets', () => {
+    expect(() =>
+      generateLiteConfig({
+          installSkills: false,
+        installCustomSkills: false,
+        preset: 'toString',
+        reset: false,
+      }),
+    ).toThrow('Unsupported preset "toString"');
+  });
+
+
+});

package/src/cli/providers.ts

@@ -0,0 +1,141 @@
+import type { InstallConfig } from './types';
+
+const SCHEMA_URL =
+  'https://unpkg.com/opencode-dux@latest/opencode-dux.schema.json';
+
+export const GENERATED_PRESETS = ['openai', 'opencode-go'] as const;
+
+// Model mappings by provider/preset.
+export const MODEL_MAPPINGS = {
+  openai: {
+    orchestrator: { model: 'openai/gpt-5.5' },
+    oracle: { model: 'openai/gpt-5.5', variant: 'high' },
+    librarian: { model: 'openai/gpt-5.4-mini', variant: 'low' },
+    explorer: { model: 'openai/gpt-5.4-mini', variant: 'low' },
+    designer: { model: 'openai/gpt-5.4-mini', variant: 'medium' },
+    fixer: { model: 'openai/gpt-5.4-mini', variant: 'low' },
+  },
+  kimi: {
+    orchestrator: { model: 'kimi-for-coding/k2p5' },
+    oracle: { model: 'kimi-for-coding/k2p5', variant: 'high' },
+    librarian: { model: 'kimi-for-coding/k2p5', variant: 'low' },
+    explorer: { model: 'kimi-for-coding/k2p5', variant: 'low' },
+    designer: { model: 'kimi-for-coding/k2p5', variant: 'medium' },
+    fixer: { model: 'kimi-for-coding/k2p5', variant: 'low' },
+  },
+  copilot: {
+    orchestrator: { model: 'github-copilot/claude-opus-4.6' },
+    oracle: { model: 'github-copilot/claude-opus-4.6', variant: 'high' },
+    librarian: { model: 'github-copilot/grok-code-fast-1', variant: 'low' },
+    explorer: { model: 'github-copilot/grok-code-fast-1', variant: 'low' },
+    designer: {
+      model: 'github-copilot/gemini-3.1-pro-preview',
+      variant: 'medium',
+    },
+    fixer: { model: 'github-copilot/claude-sonnet-4.6', variant: 'low' },
+  },
+  'zai-plan': {
+    orchestrator: { model: 'zai-coding-plan/glm-5' },
+    oracle: { model: 'zai-coding-plan/glm-5', variant: 'high' },
+    librarian: { model: 'zai-coding-plan/glm-5', variant: 'low' },
+    explorer: { model: 'zai-coding-plan/glm-5', variant: 'low' },
+    designer: { model: 'zai-coding-plan/glm-5', variant: 'medium' },
+    fixer: { model: 'zai-coding-plan/glm-5', variant: 'low' },
+  },
+  'opencode-go': {
+    orchestrator: {
+      model: 'neuralwatt/zai-org/GLM-5.1-FP8',
+      variant: 'medium',
+    },
+    oracle: { model: 'opencode-go/deepseek-v4-flash', variant: 'medium' },
+    librarian: { model: 'opencode-go/deepseek-v4-flash', variant: 'low' },
+    explorer: { model: 'neuralwatt/qwen3.5-397b-fast', variant: 'low' },
+    designer: { model: 'opencode-go/mimo-v2.5-pro', variant: 'medium' },
+    fixer: { model: 'opencode-go/deepseek-v4-flash', variant: 'low' },
+  },
+} as const;
+
+export type PresetName = keyof typeof MODEL_MAPPINGS;
+export type GeneratedPresetName = (typeof GENERATED_PRESETS)[number];
+
+export function isPresetName(value: string): value is PresetName {
+  return Object.hasOwn(MODEL_MAPPINGS, value);
+}
+
+export function getPresetNames(): PresetName[] {
+  return Object.keys(MODEL_MAPPINGS) as PresetName[];
+}
+
+export function isGeneratedPresetName(
+  value: string,
+): value is GeneratedPresetName {
+  return GENERATED_PRESETS.includes(value as GeneratedPresetName);
+}
+
+export function getGeneratedPresetNames(): GeneratedPresetName[] {
+  return [...GENERATED_PRESETS];
+}
+
+export function generateLiteConfig(
+  installConfig: InstallConfig,
+): Record<string, unknown> {
+  const preset = installConfig.preset ?? 'openai';
+  if (!isGeneratedPresetName(preset)) {
+    throw new Error(
+      `Unsupported preset "${preset}". Available generated presets: ${getGeneratedPresetNames().join(', ')}`,
+    );
+  }
+
+  const config: Record<string, unknown> = {
+    $schema: SCHEMA_URL,
+    preset,
+    presets: {},
+  };
+
+  const createAgentConfig = (
+    agentName: string,
+    modelInfo: { model: string; variant?: string },
+  ) => {
+    return {
+      model: modelInfo.model,
+      variant: modelInfo.variant,
+    };
+  };
+
+  const buildPreset = (mappingName: PresetName) => {
+    const mapping = MODEL_MAPPINGS[mappingName];
+    return Object.fromEntries(
+      Object.entries(mapping).map(([agentName, modelInfo]) => [
+        agentName,
+        createAgentConfig(agentName, modelInfo),
+      ]),
+    );
+  };
+
+  const presets = config.presets as Record<string, unknown>;
+  for (const presetName of GENERATED_PRESETS) {
+    presets[presetName] = buildPreset(presetName);
+  }
+
+  // Pre-populate skills section so new installs don't hit the fallback path.
+  // Permissions are controlled via always-load + wildcard per agent.
+  config.agents = {
+    orchestrator: {
+      skills: { 'always-load': ['find-skills'], wildcard: true },
+    },
+    designer: {
+      skills: {
+        'always-load': ['agent-browser', 'web-design-guidelines'],
+        wildcard: false,
+      },
+    },
+    oracle: {
+      skills: { 'always-load': ['requesting-code-review'], wildcard: false },
+    },
+    librarian: {
+      skills: { 'always-load': ['find-skills'], wildcard: false },
+    },
+  };
+
+  return config;
+}

package/src/cli/skills.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, it } from 'bun:test';
+import { getSkillPermissionsForAgent, normalizeSkillConfig } from './skills';
+
+describe('skills permissions', () => {
+  it('should deny all skills by default when no config provided', async () => {
+    const permissions = await getSkillPermissionsForAgent('orchestrator');
+    expect(permissions['*']).toBe('deny');
+  });
+
+  it('should deny all skills for other agents by default', async () => {
+    const permissions = await getSkillPermissionsForAgent('designer');
+    expect(permissions['*']).toBe('deny');
+  });
+
+  it('should honor explicit skill list overrides', async () => {
+    // Override with empty list
+    const emptyPerms = await getSkillPermissionsForAgent('orchestrator', []);
+    expect(emptyPerms['*']).toBe('deny');
+    expect(Object.keys(emptyPerms).length).toBe(1);
+
+    // Override with specific list
+    const specificPerms = await getSkillPermissionsForAgent('designer', [
+      'my-skill',
+      '!bad-skill',
+    ]);
+    expect(specificPerms['*']).toBe('deny');
+    expect(specificPerms['my-skill']).toBe('allow');
+    expect(specificPerms['bad-skill']).toBe('deny');
+  });
+
+  it('should honor wildcard in explicit list', async () => {
+    const wildcardPerms = await getSkillPermissionsForAgent('designer', ['*']);
+    expect(wildcardPerms['*']).toBe('allow');
+  });
+});
+
+describe('normalizeSkillConfig', () => {
+  it('should return defaults for undefined input', () => {
+    expect(normalizeSkillConfig(undefined)).toEqual({
+      alwaysLoad: [],
+      wildcard: false,
+      excluded: [],
+    });
+  });
+
+  it('should handle empty array', () => {
+    expect(normalizeSkillConfig([])).toEqual({
+      alwaysLoad: [],
+      wildcard: false,
+      excluded: [],
+    });
+  });
+
+  it('should handle array with wildcard', () => {
+    expect(normalizeSkillConfig(['skill-a', '*'])).toEqual({
+      alwaysLoad: ['skill-a'],
+      wildcard: true,
+      excluded: [],
+    });
+  });
+
+  it('should handle array with exclusion', () => {
+    expect(normalizeSkillConfig(['skill-a', '!bad-skill'])).toEqual({
+      alwaysLoad: ['skill-a'],
+      wildcard: false,
+      excluded: ['bad-skill'],
+    });
+  });
+
+  it('should handle object syntax with always-load', () => {
+    expect(
+      normalizeSkillConfig({ 'always-load': ['a'], wildcard: true }),
+    ).toEqual({
+      alwaysLoad: ['a'],
+      wildcard: true,
+      excluded: [],
+    });
+  });
+
+  it('should handle deprecated mandatory fallback', () => {
+    expect(normalizeSkillConfig({ mandatory: ['a'], wildcard: false })).toEqual(
+      {
+        alwaysLoad: ['a'],
+        wildcard: false,
+        excluded: [],
+      },
+    );
+  });
+
+  it('should prefer always-load over deprecated mandatory', () => {
+    expect(
+      normalizeSkillConfig({
+        'always-load': ['new'],
+        mandatory: ['old'],
+        wildcard: false,
+      }),
+    ).toEqual({
+      alwaysLoad: ['new'],
+      wildcard: false,
+      excluded: [],
+    });
+  });
+
+  it('should handle object syntax with defaults', () => {
+    expect(normalizeSkillConfig({})).toEqual({
+      alwaysLoad: [],
+      wildcard: false,
+      excluded: [],
+    });
+  });
+});

package/src/cli/skills.ts

@@ -0,0 +1,103 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { SkillOrMcpConfig } from '../config';
+import { getLocalDiscovery } from '../discovery/local';
+
+export interface NormalizedSkillConfig {
+  alwaysLoad: string[];
+  wildcard: boolean;
+  excluded: string[];
+}
+
+export function normalizeSkillConfig(
+  raw: SkillOrMcpConfig | undefined,
+): NormalizedSkillConfig {
+  if (!raw) {
+    return { alwaysLoad: [], wildcard: false, excluded: [] };
+  }
+
+  if (Array.isArray(raw)) {
+    const alwaysLoad: string[] = [];
+    const excluded: string[] = [];
+    let wildcard = false;
+
+    for (const item of raw) {
+      if (item === '*') {
+        wildcard = true;
+      } else if (item.startsWith('!')) {
+        excluded.push(item.slice(1));
+      } else {
+        alwaysLoad.push(item);
+      }
+    }
+
+    return { alwaysLoad, wildcard, excluded };
+  }
+
+  // Object syntax - read always-load first, fall back to deprecated mandatory
+  return {
+    alwaysLoad: raw['always-load'] ?? raw.mandatory ?? [],
+    wildcard: raw.wildcard ?? false,
+    excluded: [],
+  };
+}
+
+/**
+ * Get permission presets for a specific agent based on recommended skills.
+ * @param agentName - The name of the agent
+ * @param skillList - Optional explicit list of skills to allow (overrides recommendations)
+ * @param ctx - Plugin input context for SDK discovery when wildcard=true
+ * @returns Permission rules for the skill permission type
+ */
+export async function getSkillPermissionsForAgent(
+  _agentName: string,
+  skillList?: SkillOrMcpConfig,
+  ctx?: PluginInput,
+): Promise<Record<string, 'allow' | 'ask' | 'deny'>> {
+  const permissions: Record<string, 'allow' | 'ask' | 'deny'> = {
+    '*': 'deny', // Default: deny all
+  };
+
+  if (skillList !== undefined) {
+    const normalized = normalizeSkillConfig(skillList);
+    permissions['*'] = normalized.wildcard ? 'allow' : 'deny';
+
+    // Always-load skills always allowed
+    for (const name of normalized.alwaysLoad) {
+      permissions[name] = 'allow';
+    }
+    for (const name of normalized.excluded) {
+      permissions[name] = 'deny';
+    }
+
+    // Wildcard: allow all installed skills (from SDK)
+    if (normalized.wildcard && ctx) {
+      try {
+        const local = await getLocalDiscovery(ctx);
+        for (const skill of local.skills) {
+          permissions[skill.name] = 'allow';
+        }
+      } catch {
+        // wildcard with no SDK access = only always-load
+      }
+    }
+
+    return permissions;
+  }
+
+  // No config provided - fallback to deny all
+  return permissions;
+}
+
+/**
+ * Scan installed skills from the filesystem via SDK discovery.
+ * @param ctx - Plugin input context for SDK discovery
+ * @returns Array of skill names that are installed
+ */
+export async function scanInstalledSkills(ctx: PluginInput): Promise<string[]> {
+  try {
+    const local = await getLocalDiscovery(ctx);
+    return local.skills.map((skill) => skill.name);
+  } catch {
+    return [];
+  }
+}