opencode-dux 1.0.0

package/src/cli/config-io.ts

@@ -0,0 +1,473 @@
+import {
+  copyFileSync,
+  existsSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
+import { dirname, join } from 'node:path';
+import {
+  ensureConfigDir,
+  ensureOpenCodeConfigDir,
+  ensureTuiConfigDir,
+  getExistingConfigPath,
+  getExistingTuiConfigPath,
+  getLiteConfig,
+} from './paths';
+import { generateLiteConfig } from './providers';
+import type {
+  ConfigMergeResult,
+  DetectedConfig,
+  InstallConfig,
+  OpenCodeConfig,
+} from './types';
+
+const PACKAGE_NAME = 'opencode-dux';
+
+function isString(value: unknown): value is string {
+  return typeof value === 'string';
+}
+
+function getPlugins(config: OpenCodeConfig): unknown[] {
+  return Array.isArray(config.plugin) ? config.plugin : [];
+}
+
+function getPluginEntries(config: OpenCodeConfig): string[] {
+  return getPlugins(config).filter(isString);
+}
+
+function getPluginSpec(entry: unknown): string | undefined {
+  if (isString(entry)) return entry;
+  if (!Array.isArray(entry)) return undefined;
+
+  const spec = entry[0];
+  return isString(spec) ? spec : undefined;
+}
+
+function normalizePathForMatch(path: string): string {
+  return path.replaceAll('\\', '/');
+}
+
+function findPackageRoot(startPath: string): string | null {
+  let currentPath = dirname(startPath);
+
+  while (true) {
+    const packageJsonPath = join(currentPath, 'package.json');
+
+    if (existsSync(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(
+          readFileSync(packageJsonPath, 'utf-8'),
+        ) as {
+          name?: string;
+        };
+
+        if (packageJson.name === PACKAGE_NAME) {
+          return currentPath;
+        }
+      } catch {
+        // Ignore invalid package.json while walking upward.
+      }
+    }
+
+    const parentPath = dirname(currentPath);
+    if (parentPath === currentPath) {
+      return null;
+    }
+    currentPath = parentPath;
+  }
+}
+
+function isPackageManagerInstall(path: string): boolean {
+  const normalizedPath = normalizePathForMatch(path);
+  return normalizedPath.includes(`/node_modules/${PACKAGE_NAME}`);
+}
+
+function isLocalPackageRootEntry(entry: string): boolean {
+  if (!entry || entry.startsWith('file://')) {
+    return false;
+  }
+
+  const packageJsonPath = join(entry, 'package.json');
+  if (!existsSync(packageJsonPath)) {
+    return false;
+  }
+
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8')) as {
+      name?: string;
+    };
+    return packageJson.name === PACKAGE_NAME;
+  } catch {
+    return false;
+  }
+}
+
+function isPluginEntry(entry: string): boolean {
+  return (
+    entry === PACKAGE_NAME ||
+    entry.startsWith(`${PACKAGE_NAME}@`) ||
+    (entry.startsWith('file://') && entry.includes(PACKAGE_NAME)) ||
+    isLocalPackageRootEntry(entry)
+  );
+}
+
+function isMatchingPluginEntry(entry: unknown): boolean {
+  const spec = getPluginSpec(entry);
+  return spec ? isPluginEntry(spec) : false;
+}
+
+function getPluginEntry(): string {
+  const cliEntryPath = process.argv[1];
+
+  if (!cliEntryPath) {
+    return PACKAGE_NAME;
+  }
+
+  try {
+    const packageRoot = findPackageRoot(cliEntryPath);
+
+    if (!packageRoot || isPackageManagerInstall(packageRoot)) {
+      return PACKAGE_NAME;
+    }
+
+    return packageRoot;
+  } catch {
+    return PACKAGE_NAME;
+  }
+}
+
+/**
+ * Strip JSON comments (single-line // and multi-line) and trailing commas for JSONC support.
+ */
+export function stripJsonComments(json: string): string {
+  const commentPattern = /\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g;
+  const trailingCommaPattern = /\\"|"(?:\\"|[^"])*"|(,)(\s*[}\]])/g;
+
+  return json
+    .replace(commentPattern, (match, commentGroup) =>
+      commentGroup ? '' : match,
+    )
+    .replace(trailingCommaPattern, (match, comma, closing) =>
+      comma ? closing : match,
+    );
+}
+
+export function parseConfigFile(path: string): {
+  config: OpenCodeConfig | null;
+  error?: string;
+} {
+  try {
+    if (!existsSync(path)) return { config: null };
+    const stat = statSync(path);
+    if (stat.size === 0) return { config: null };
+    const content = readFileSync(path, 'utf-8');
+    if (content.trim().length === 0) return { config: null };
+    return { config: JSON.parse(stripJsonComments(content)) as OpenCodeConfig };
+  } catch (err) {
+    return { config: null, error: String(err) };
+  }
+}
+
+export function parseConfig(path: string): {
+  config: OpenCodeConfig | null;
+  error?: string;
+} {
+  const result = parseConfigFile(path);
+  if (result.config || result.error) return result;
+
+  if (path.endsWith('.json')) {
+    const jsoncPath = path.replace(/\.json$/, '.jsonc');
+    return parseConfigFile(jsoncPath);
+  }
+  return { config: null };
+}
+
+/**
+ * Write config to file atomically.
+ */
+export function writeConfig(configPath: string, config: OpenCodeConfig): void {
+  if (configPath.endsWith('.jsonc')) {
+    console.warn(
+      '[config-manager] Writing to .jsonc file - comments will not be preserved',
+    );
+  }
+
+  const tmpPath = `${configPath}.tmp`;
+  const bakPath = `${configPath}.bak`;
+  const content = `${JSON.stringify(config, null, 2)}\n`;
+
+  // Backup existing config if it exists
+  if (existsSync(configPath)) {
+    copyFileSync(configPath, bakPath);
+  }
+
+  // Atomic write pattern: write to tmp, then rename
+  writeFileSync(tmpPath, content);
+  renameSync(tmpPath, configPath);
+}
+
+export async function addPluginToOpenCodeConfig(): Promise<ConfigMergeResult> {
+  const configPath = getExistingConfigPath();
+
+  try {
+    ensureOpenCodeConfigDir();
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to create config directory: ${err}`,
+    };
+  }
+
+  try {
+    const { config: parsedConfig, error } = parseConfig(configPath);
+    if (error) {
+      return {
+        success: false,
+        configPath,
+        error: `Failed to parse config: ${error}`,
+      };
+    }
+    const config = parsedConfig ?? {};
+    const plugins = getPlugins(config);
+
+    const pluginEntry = getPluginEntry();
+
+    // Remove existing opencode-dux entries
+    const filteredPlugins = plugins.filter(
+      (plugin) => !isMatchingPluginEntry(plugin),
+    );
+
+    // Add fresh entry
+    filteredPlugins.push(pluginEntry);
+    config.plugin = filteredPlugins;
+
+    writeConfig(configPath, config);
+    return { success: true, configPath };
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to update opencode config: ${err}`,
+    };
+  }
+}
+
+export async function addPluginToOpenCodeTuiConfig(): Promise<ConfigMergeResult> {
+  const configPath = getExistingTuiConfigPath();
+
+  try {
+    ensureTuiConfigDir();
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to create config directory: ${err}`,
+    };
+  }
+
+  try {
+    const { config: parsedConfig, error } = parseConfig(configPath);
+    if (error) {
+      return {
+        success: false,
+        configPath,
+        error: `Failed to parse TUI config: ${error}`,
+      };
+    }
+    const config = parsedConfig ?? {};
+    const plugins = getPlugins(config);
+    const pluginEntry = getPluginEntry();
+    const filteredPlugins = plugins.filter(
+      (plugin) => !isMatchingPluginEntry(plugin),
+    );
+
+    filteredPlugins.push(pluginEntry);
+    config.plugin = filteredPlugins;
+
+    writeConfig(configPath, config);
+    return { success: true, configPath };
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to update opencode TUI config: ${err}`,
+    };
+  }
+}
+
+// Removed: addAuthPlugins - no longer needed with cliproxy
+// Removed: addProviderConfig - default opencode now has kimi provider config
+
+export function writeLiteConfig(
+  installConfig: InstallConfig,
+  targetPath?: string,
+): ConfigMergeResult {
+  const configPath = targetPath ?? getLiteConfig();
+
+  try {
+    ensureConfigDir();
+    const config = generateLiteConfig(installConfig);
+
+    // Atomic write for lite config too
+    const tmpPath = `${configPath}.tmp`;
+    const bakPath = `${configPath}.bak`;
+    const content = `${JSON.stringify(config, null, 2)}\n`;
+
+    // Backup existing config if it exists
+    if (existsSync(configPath)) {
+      copyFileSync(configPath, bakPath);
+    }
+
+    writeFileSync(tmpPath, content);
+    renameSync(tmpPath, configPath);
+
+    return { success: true, configPath };
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to write lite config: ${err}`,
+    };
+  }
+}
+
+export function disableDefaultAgents(): ConfigMergeResult {
+  const configPath = getExistingConfigPath();
+
+  try {
+    ensureOpenCodeConfigDir();
+    const { config: parsedConfig, error } = parseConfig(configPath);
+    if (error) {
+      return {
+        success: false,
+        configPath,
+        error: `Failed to parse config: ${error}`,
+      };
+    }
+    const config = parsedConfig ?? {};
+
+    const agent = (config.agent ?? {}) as Record<string, unknown>;
+    agent.explore = { disable: true };
+    agent.general = { disable: true };
+    config.agent = agent;
+
+    writeConfig(configPath, config);
+    return { success: true, configPath };
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to disable default agents: ${err}`,
+    };
+  }
+}
+
+export function enableLspByDefault(): ConfigMergeResult {
+  const configPath = getExistingConfigPath();
+
+  try {
+    ensureOpenCodeConfigDir();
+    const { config: parsedConfig, error } = parseConfig(configPath);
+    if (error) {
+      return {
+        success: false,
+        configPath,
+        error: `Failed to parse config: ${error}`,
+      };
+    }
+    const config = parsedConfig ?? {};
+
+    if (config.lsp === undefined) {
+      config.lsp = true;
+      writeConfig(configPath, config);
+    }
+
+    return { success: true, configPath };
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to enable LSP: ${err}`,
+    };
+  }
+}
+
+export function canModifyOpenCodeConfig(): boolean {
+  try {
+    const configPath = getExistingConfigPath();
+    if (!existsSync(configPath)) return true; // Will be created
+    const stat = statSync(configPath);
+    // Check if writable - simple check for now
+    return !!(stat.mode & 0o200);
+  } catch {
+    return false;
+  }
+}
+
+// Antigravity, Google provider, and Chutes provider functions removed in simplification refactor.
+
+export function detectCurrentConfig(): DetectedConfig {
+  const result: DetectedConfig = {
+    isInstalled: false,
+    hasKimi: false,
+    hasOpenAI: false,
+    hasAnthropic: false,
+    hasCopilot: false,
+    hasZaiPlan: false,
+    hasAntigravity: false,
+    hasChutes: false,
+    hasOpencodeZen: false,
+  };
+
+  const { config } = parseConfig(getExistingConfigPath());
+  if (!config) return result;
+
+  const plugins = getPluginEntries(config);
+  result.isInstalled = plugins.some((p) => isPluginEntry(p));
+  result.hasAntigravity = plugins.some((p) =>
+    p.startsWith('opencode-antigravity-auth'),
+  );
+
+  // Check for providers
+  const providers = config.provider as Record<string, unknown> | undefined;
+  result.hasKimi = !!providers?.kimi;
+  result.hasAnthropic = !!providers?.anthropic;
+  result.hasCopilot = !!providers?.['github-copilot'];
+  result.hasZaiPlan = !!providers?.['zai-coding-plan'];
+  result.hasChutes = !!providers?.chutes;
+  if (providers?.google) result.hasAntigravity = true;
+
+  // Try to detect from lite config
+  const { config: liteConfig } = parseConfig(getLiteConfig());
+  if (liteConfig && typeof liteConfig === 'object') {
+    const configObj = liteConfig as Record<string, unknown>;
+    const presetName = configObj.preset as string;
+    const presets = configObj.presets as Record<string, unknown>;
+    const agents = presets?.[presetName] as
+      | Record<string, { model?: string }>
+      | undefined;
+
+    if (agents) {
+      const models = Object.values(agents)
+        .map((a) => a?.model)
+        .filter(Boolean);
+      result.hasOpenAI = models.some((m) => m?.startsWith('openai/'));
+      result.hasAnthropic = models.some((m) => m?.startsWith('anthropic/'));
+      result.hasCopilot = models.some((m) => m?.startsWith('github-copilot/'));
+      result.hasZaiPlan = models.some((m) => m?.startsWith('zai-coding-plan/'));
+      result.hasOpencodeZen = models.some((m) => m?.startsWith('opencode/'));
+      if (models.some((m) => m?.startsWith('google/'))) {
+        result.hasAntigravity = true;
+      }
+      if (models.some((m) => m?.startsWith('chutes/'))) {
+        result.hasChutes = true;
+      }
+    }
+
+  }
+
+  return result;
+}

package/src/cli/config-manager.test.ts

@@ -0,0 +1,141 @@
+/// <reference types="bun-types" />
+
+import { describe, expect, test } from 'bun:test';
+import { stripJsonComments } from './config-manager';
+
+describe('config-manager (barrel)', () => {
+  describe('stripJsonComments', () => {
+    test('returns unchanged JSON without comments', () => {
+      const json = '{"key": "value"}';
+      expect(stripJsonComments(json)).toBe(json);
+    });
+
+    test('strips single-line comments', () => {
+      const json = `{
+    "key": "value" // this is a comment
+  }`;
+      expect(JSON.parse(stripJsonComments(json))).toEqual({ key: 'value' });
+    });
+
+    test('strips multi-line comments', () => {
+      const json = `{
+    /* this is a
+       multi-line comment */
+    "key": "value"
+  }`;
+      expect(JSON.parse(stripJsonComments(json))).toEqual({ key: 'value' });
+    });
+
+    test('strips trailing commas', () => {
+      const json = `{
+    "key": "value",
+  }`;
+      expect(JSON.parse(stripJsonComments(json))).toEqual({ key: 'value' });
+    });
+
+    test('strips trailing commas in arrays', () => {
+      const json = `{
+    "arr": [1, 2, 3,]
+  }`;
+      expect(JSON.parse(stripJsonComments(json))).toEqual({ arr: [1, 2, 3] });
+    });
+
+    test('preserves URLs with double slashes', () => {
+      const json = '{"url": "https://example.com"}';
+      expect(JSON.parse(stripJsonComments(json))).toEqual({
+        url: 'https://example.com',
+      });
+    });
+
+    test('preserves strings containing comment-like patterns', () => {
+      const json = '{"code": "// not a comment", "block": "/* also not */"}';
+      expect(JSON.parse(stripJsonComments(json))).toEqual({
+        code: '// not a comment',
+        block: '/* also not */',
+      });
+    });
+
+    test('handles complex JSONC with mixed comments and trailing commas', () => {
+      const json = `{
+    // Configuration for the plugin
+    "plugin": ["opencode-dux"],
+    /* Provider settings
+       with multiple lines */
+    "provider": {
+      "google": {
+        "name": "Google", // inline comment
+      },
+    },
+  }`;
+      const result = JSON.parse(stripJsonComments(json));
+      expect(result).toEqual({
+        plugin: ['opencode-dux'],
+        provider: {
+          google: {
+            name: 'Google',
+          },
+        },
+      });
+    });
+
+    test('handles escaped quotes in strings', () => {
+      const json = '{"message": "He said \\"hello\\""}';
+      expect(JSON.parse(stripJsonComments(json))).toEqual({
+        message: 'He said "hello"',
+      });
+    });
+
+    test('handles empty input', () => {
+      expect(stripJsonComments('')).toBe('');
+    });
+
+    test('handles whitespace-only input', () => {
+      expect(stripJsonComments('   ')).toBe('   ');
+    });
+
+    test('handles single-line comment at start of file', () => {
+      const json = `// comment at start
+  {"key": "value"}`;
+      expect(JSON.parse(stripJsonComments(json))).toEqual({ key: 'value' });
+    });
+
+    test('handles comment-only lines between properties', () => {
+      const json = `{
+    "a": 1,
+    // comment line
+    "b": 2
+  }`;
+      expect(JSON.parse(stripJsonComments(json))).toEqual({ a: 1, b: 2 });
+    });
+
+    test('handles multiple trailing commas in nested structures', () => {
+      const json = `{"nested": {"a": 1,},}`;
+      expect(JSON.parse(stripJsonComments(json))).toEqual({ nested: { a: 1 } });
+    });
+
+    test('handles unclosed string gracefully without throwing', () => {
+      const json = '{"key": "unclosed';
+      expect(() => stripJsonComments(json)).not.toThrow();
+    });
+
+    test('preserves comma-bracket patterns inside strings', () => {
+      const json = '{"script": "test [,]", "json": "{,}"}';
+      const result = JSON.parse(stripJsonComments(json));
+      expect(result.script).toBe('test [,]');
+      expect(result.json).toBe('{,}');
+    });
+
+    test('preserves comma-brace patterns inside strings', () => {
+      const json = '{"glob": "*.{js,ts}", "arr": "[a,]"}';
+      const result = JSON.parse(stripJsonComments(json));
+      expect(result.glob).toBe('*.{js,ts}');
+      expect(result.arr).toBe('[a,]');
+    });
+
+    test('handles Windows CRLF line endings', () => {
+      const json = '{\r\n  "key": "value", // comment\r\n}';
+      const result = JSON.parse(stripJsonComments(json));
+      expect(result).toEqual({ key: 'value' });
+    });
+  });
+});

package/src/cli/config-manager.ts

@@ -0,0 +1,4 @@
+export * from './config-io';
+export * from './paths';
+export * from './providers';
+export * from './system';

package/src/cli/index.ts

@@ -0,0 +1,88 @@
+#!/usr/bin/env bun
+import { install } from './install';
+import { getGeneratedPresetNames, isGeneratedPresetName } from './providers';
+import type { BooleanArg, InstallArgs } from './types';
+
+function parseArgs(args: string[]): InstallArgs {
+  const result: InstallArgs = {
+    tui: true,
+    skills: 'yes',
+  };
+
+  for (const arg of args) {
+    if (arg === '--no-tui') {
+      result.tui = false;
+    } else if (arg.startsWith('--skills=')) {
+      result.skills = arg.split('=')[1] as BooleanArg;
+    } else if (arg.startsWith('--preset=')) {
+      const preset = arg.split('=')[1];
+      if (!isGeneratedPresetName(preset)) {
+        console.error(
+          `Unsupported preset: ${preset}. Available presets: ${getGeneratedPresetNames().join(', ')}`,
+        );
+        process.exit(1);
+      }
+      result.preset = preset;
+    } else if (arg === '--dry-run') {
+      result.dryRun = true;
+    } else if (arg === '--reset') {
+      result.reset = true;
+    } else if (arg === '-h' || arg === '--help') {
+      printHelp();
+      process.exit(0);
+    }
+  }
+
+  return result;
+}
+
+function printHelp(): void {
+  console.log(`
+opencode-dux installer
+
+Usage: bunx opencode-dux install [OPTIONS]
+
+Options:
+  --skills=yes|no        Install recommended and bundled skills (default: yes)
+  --preset=<name>        Active generated config preset (default: openai)
+  --no-tui               Non-interactive mode
+  --dry-run              Simulate install without writing files
+  --reset                Force overwrite of existing configuration
+  -h, --help             Show this help message
+
+Available presets: ${getGeneratedPresetNames().join(', ')}
+
+The installer generates OpenAI and OpenCode Go presets by default.
+OpenAI is active unless --preset selects another generated preset.
+For the full config reference, see docs/configuration.md.
+
+Examples:
+  bunx opencode-dux install
+  bunx opencode-dux install --no-tui --skills=yes
+  bunx opencode-dux install --preset=opencode-go
+  bunx opencode-dux install --reset
+`);
+}
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args[0] === 'install') {
+    const hasSubcommand = args[0] === 'install';
+    const installArgs = parseArgs(args.slice(hasSubcommand ? 1 : 0));
+    const exitCode = await install(installArgs);
+    process.exit(exitCode);
+  } else if (args[0] === '-h' || args[0] === '--help') {
+    printHelp();
+    process.exit(0);
+  } else {
+    console.error(`Unknown command: ${args[0]}`);
+    console.error('Run with --help for usage information');
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});