opencode-dux 1.0.0

package/src/cli/system.test.ts

@@ -0,0 +1,91 @@
+/// <reference types="bun-types" />
+
+import { describe, expect, mock, test } from 'bun:test';
+import {
+  chmodSync,
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  fetchLatestVersion,
+  getOpenCodeVersion,
+  isOpenCodeInstalled,
+} from './system';
+
+describe('system', () => {
+  test('isOpenCodeInstalled detects opencode in ~/.opencode/bin', async () => {
+    const dir = mkdtempSync(join(tmpdir(), 'opencode-system-test-'));
+    const originalPath = process.env.PATH;
+    const originalHome = process.env.HOME;
+
+    try {
+      const opencodePath = join(dir, '.opencode', 'bin', 'opencode');
+      mkdirSync(join(dir, '.opencode', 'bin'), { recursive: true });
+      writeFileSync(opencodePath, '#!/bin/sh\necho 1.2.3\n');
+      chmodSync(opencodePath, 0o755);
+      process.env.HOME = dir;
+      process.env.PATH = '/usr/bin:/bin:/usr/sbin:/sbin';
+
+      const system = await import(`./system?test=home-detect-${Date.now()}`);
+      expect(await system.isOpenCodeInstalled()).toBe(true);
+    } finally {
+      process.env.PATH = originalPath;
+      process.env.HOME = originalHome;
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test('isOpenCodeInstalled returns boolean', async () => {
+    // We don't necessarily want to depend on the host system
+    // but for a basic test we can just check it returns a boolean
+    const result = await isOpenCodeInstalled();
+    expect(typeof result).toBe('boolean');
+  });
+
+  test('fetchLatestVersion returns version string or null', async () => {
+    // Mock global fetch
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = mock(async () => {
+      return {
+        ok: true,
+        json: async () => ({ version: '1.2.3' }),
+      };
+    }) as any;
+
+    try {
+      const version = await fetchLatestVersion('any-package');
+      expect(version).toBe('1.2.3');
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  test('fetchLatestVersion returns null on error', async () => {
+    const originalFetch = globalThis.fetch;
+    try {
+      globalThis.fetch = mock(async () => {
+        return {
+          ok: false,
+        };
+      }) as any;
+
+      const version = await fetchLatestVersion('any-package');
+      expect(version).toBeNull();
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  test('getOpenCodeVersion returns string or null', async () => {
+    const version = await getOpenCodeVersion();
+    if (version !== null) {
+      expect(typeof version).toBe('string');
+    } else {
+      expect(version).toBeNull();
+    }
+  });
+});

package/src/cli/system.ts

@@ -0,0 +1,180 @@
+import { spawnSync } from 'node:child_process';
+import { statSync } from 'node:fs';
+import { crossSpawn } from '../utils/compat';
+
+let cachedOpenCodePath: string | null = null;
+
+function resolvePathCommand(command: string): string | null {
+  try {
+    const resolver = process.platform === 'win32' ? 'where' : 'which';
+    const result = spawnSync(resolver, [command], {
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+
+    if (result.status !== 0) {
+      return null;
+    }
+
+    const resolved = result.stdout
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .find(Boolean);
+
+    return resolved ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function canExecute(command: string, args: string[]): boolean {
+  try {
+    const result = spawnSync(command, args, {
+      stdio: 'ignore',
+    });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+
+function getOpenCodePaths(): string[] {
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+
+  return [
+    // PATH (try this first)
+    'opencode',
+    // User local installations (Linux & macOS)
+    `${home}/.local/bin/opencode`,
+    `${home}/.opencode/bin/opencode`,
+    `${home}/bin/opencode`,
+    // System-wide installations
+    '/usr/local/bin/opencode',
+    '/opt/opencode/bin/opencode',
+    '/usr/bin/opencode',
+    '/bin/opencode',
+    // macOS specific
+    '/Applications/OpenCode.app/Contents/MacOS/opencode',
+    `${home}/Applications/OpenCode.app/Contents/MacOS/opencode`,
+    // Homebrew (macOS & Linux)
+    '/opt/homebrew/bin/opencode',
+    '/home/linuxbrew/.linuxbrew/bin/opencode',
+    `${home}/homebrew/bin/opencode`,
+    // macOS user Library
+    `${home}/Library/Application Support/opencode/bin/opencode`,
+    // Snap (Linux)
+    '/snap/bin/opencode',
+    '/var/snap/opencode/current/bin/opencode',
+    // Flatpak (Linux)
+    '/var/lib/flatpak/exports/bin/ai.opencode.OpenCode',
+    `${home}/.local/share/flatpak/exports/bin/ai.opencode.OpenCode`,
+    // Nix (Linux/macOS)
+    '/nix/store/opencode/bin/opencode',
+    `${home}/.nix-profile/bin/opencode`,
+    '/run/current-system/sw/bin/opencode',
+    // Cargo (Rust toolchain)
+    `${home}/.cargo/bin/opencode`,
+    // npm/npx global
+    `${home}/.npm-global/bin/opencode`,
+    '/usr/local/lib/node_modules/opencode/bin/opencode',
+    // Yarn global
+    `${home}/.yarn/bin/opencode`,
+    // PNPM
+    `${home}/.pnpm-global/bin/opencode`,
+  ];
+}
+
+export function resolveOpenCodePath(): string {
+  if (cachedOpenCodePath) {
+    return cachedOpenCodePath;
+  }
+
+  const pathOpenCodePath = resolvePathCommand('opencode');
+  if (pathOpenCodePath) {
+    cachedOpenCodePath = pathOpenCodePath;
+    return pathOpenCodePath;
+  }
+
+  const paths = getOpenCodePaths();
+
+  for (const opencodePath of paths) {
+    if (opencodePath === 'opencode') continue;
+    try {
+      const stat = statSync(opencodePath);
+      if (stat.isFile()) {
+        cachedOpenCodePath = opencodePath;
+        return opencodePath;
+      }
+    } catch {
+      // Try next path
+    }
+  }
+
+  // Fallback to 'opencode' and hope it's in PATH
+  return 'opencode';
+}
+
+export async function isOpenCodeInstalled(): Promise<boolean> {
+  const pathOpenCodePath = resolvePathCommand('opencode');
+
+  if (pathOpenCodePath && canExecute(pathOpenCodePath, ['--version'])) {
+    cachedOpenCodePath = pathOpenCodePath;
+    return true;
+  }
+
+  const paths = getOpenCodePaths();
+
+  for (const opencodePath of paths) {
+    if (opencodePath === 'opencode') continue;
+    try {
+      const proc = crossSpawn([opencodePath, '--version'], {
+        stdout: 'pipe',
+        stderr: 'pipe',
+      });
+      await proc.exited;
+      if (proc.exitCode === 0) {
+        cachedOpenCodePath = opencodePath;
+        return true;
+      }
+    } catch {
+      // Try next path
+    }
+  }
+  return false;
+}
+
+export async function getOpenCodeVersion(): Promise<string | null> {
+  const opencodePath = resolveOpenCodePath();
+  try {
+    const proc = crossSpawn([opencodePath, '--version'], {
+      stdout: 'pipe',
+      stderr: 'pipe',
+    });
+    const outputPromise = proc.stdout();
+    await proc.exited;
+    if (proc.exitCode === 0) {
+      return (await outputPromise).trim();
+    }
+  } catch {
+    // Failed
+  }
+  return null;
+}
+
+export function getOpenCodePath(): string | null {
+  const path = resolveOpenCodePath();
+  return path === 'opencode' ? null : path;
+}
+
+export async function fetchLatestVersion(
+  packageName: string,
+): Promise<string | null> {
+  try {
+    const res = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
+    if (!res.ok) return null;
+    const data = (await res.json()) as { version: string };
+    return data.version;
+  } catch {
+    return null;
+  }
+}

package/src/cli/types.ts

@@ -0,0 +1,43 @@
+export type BooleanArg = 'yes' | 'no';
+
+export interface InstallArgs {
+  tui: boolean;
+  skills?: BooleanArg;
+  preset?: string;
+  dryRun?: boolean;
+  reset?: boolean;
+}
+
+export interface OpenCodeConfig {
+  plugin?: unknown[];
+  provider?: Record<string, unknown>;
+  agent?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+export interface InstallConfig {
+  installSkills: boolean;
+  installCustomSkills: boolean;
+  preset?: string;
+  promptForStar?: boolean;
+  dryRun?: boolean;
+  reset: boolean;
+}
+
+export interface ConfigMergeResult {
+  success: boolean;
+  configPath: string;
+  error?: string;
+}
+
+export interface DetectedConfig {
+  isInstalled: boolean;
+  hasKimi: boolean;
+  hasOpenAI: boolean;
+  hasAnthropic?: boolean;
+  hasCopilot?: boolean;
+  hasZaiPlan?: boolean;
+  hasAntigravity: boolean;
+  hasChutes?: boolean;
+  hasOpencodeZen: boolean;
+}

package/src/config/constants.ts

@@ -0,0 +1,58 @@
+// Agent names
+export const AGENT_ALIASES: Record<string, string> = {
+  explore: 'explorer',
+  'frontend-ui-ux-engineer': 'designer',
+};
+
+export const SUBAGENT_NAMES = [
+  'explorer',
+  'librarian',
+  'oracle',
+  'designer',
+  'fixer',
+  'steward',
+  'interpreter',
+] as const;
+
+export const ORCHESTRATOR_NAME = 'orchestrator' as const;
+
+export const ALL_AGENT_NAMES = [ORCHESTRATOR_NAME, ...SUBAGENT_NAMES] as const;
+
+// Agent name type (for use in DEFAULT_MODELS)
+export type AgentName = (typeof ALL_AGENT_NAMES)[number];
+
+// Default models for each agent
+// Hybrid NeuralWatt + OpenCode-Go strategy:
+// - Orchestrator on NeuralWatt GLM-5.1 (energy-efficient, strong routing)
+// - Explorer on NeuralWatt Qwen3.5-397B-Fast (cheap MoE, tool-calling, no reasoning overhead)
+// - Oracle, Librarian, Designer, Fixer on OpenCode-Go (proven reliability)
+export const DEFAULT_MODELS: Record<AgentName, string | undefined> = {
+  orchestrator: 'neuralwatt/zai-org/GLM-5.1-FP8',
+  oracle: 'opencode-go/deepseek-v4-flash',
+  librarian: 'opencode-go/deepseek-v4-flash',
+  explorer: 'neuralwatt/qwen3.5-397b-fast',
+  designer: 'opencode-go/mimo-v2.5-pro',
+  fixer: 'opencode-go/deepseek-v4-flash',
+  steward: 'opencode-go/deepseek-v4-flash',
+  interpreter: 'opencode-go/mimo-v2.5-pro',
+};
+
+// Polling configuration
+export const POLL_INTERVAL_MS = 500;
+
+// Timeouts
+export const MAX_POLL_TIME_MS = 5 * 60 * 1000; // 5 minutes
+
+// Subagent depth limits
+export const DEFAULT_MAX_SUBAGENT_DEPTH = 10;
+
+// Workflow reminders
+export const PHASE_REMINDER_TEXT = `!IMPORTANT! Follow <first_gate> order in system prompt; delegate_subagent in the same turn you name the agent. !END!`;
+
+// Polling stability
+export const STABLE_POLLS_THRESHOLD = 3;
+
+// SDK discovery timeout for local MCP/skill scans (milliseconds).
+// Prevents plugin init from hanging when the SDK is not ready.
+// Adjustable via config override at build/runtime.
+export const SDK_DISCOVERY_TIMEOUT_MS = 10_000; // 10 seconds

package/src/config/index.ts

@@ -0,0 +1,4 @@
+export * from './constants';
+export { deepMerge, loadAgentPrompt, loadPluginConfig } from './loader';
+export * from './schema';
+export { getAgentOverride } from './utils';