opencode-dux 1.0.0

package/src/skills/registry.ts

@@ -0,0 +1,218 @@
+import type { Stats } from 'node:fs';
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join, relative, resolve } from 'node:path';
+
+/**
+ * Metadata for a discovered skill.
+ */
+export interface SkillMetadata {
+  /** Unique skill name (derived from folder name) */
+  name: string;
+  /** Human-readable description */
+  description: string;
+  /** Absolute path to the SKILL.md file */
+  path: string;
+  /** Tags for categorisation and matching */
+  tags: string[];
+  /** Agents that are recommended to use this skill */
+  recommendedAgents: string[];
+}
+
+// Module-level cache to avoid repeated filesystem scans
+let skillsCache: SkillMetadata[] | null = null;
+let cacheRoot: string | null = null;
+
+/**
+ * Reset the skill discovery cache (for testing).
+ */
+export function resetSkillsCache(): void {
+  skillsCache = null;
+  cacheRoot = null;
+}
+
+/**
+ * Parse YAML frontmatter from a markdown file.
+ * Supports simple key-value pairs and array values (both inline `[a, b]`
+ * and multiline `- item` formats). Returns a partial record of parsed
+ * values, ignoring unknown keys without error.
+ */
+function parseFrontmatter(content: string): Record<string, string | string[]> {
+  const result: Record<string, string | string[]> = {};
+
+  // Match content between leading --- and trailing ---
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!match) return result;
+
+  const block = match[1];
+  const lines = block.split('\n');
+
+  let currentKey: string | null = null;
+  const currentArray: string[] = [];
+
+  for (const raw of lines) {
+    const trimmed = raw.trim();
+
+    // Skip empty lines
+    if (trimmed === '') continue;
+
+    // Array item under a key (- value)
+    if (trimmed.startsWith('- ')) {
+      if (currentKey) {
+        currentArray.push(trimmed.slice(2).trim());
+      }
+      continue;
+    }
+
+    // If we were collecting an array, flush it
+    if (currentKey && currentArray.length > 0) {
+      result[currentKey] = [...currentArray];
+      currentArray.length = 0;
+    }
+
+    // Key: value pair
+    const colonIndex = trimmed.indexOf(':');
+    if (colonIndex === -1) {
+      currentKey = null;
+      continue;
+    }
+
+    const key = trimmed.slice(0, colonIndex).trim();
+    const value = trimmed.slice(colonIndex + 1).trim();
+
+    if (!key) {
+      currentKey = null;
+      continue;
+    }
+
+    if (value === '') {
+      // Multiline array follows
+      currentKey = key;
+      continue;
+    }
+
+    // Inline array: [item1, item2]
+    if (value.startsWith('[') && value.endsWith(']')) {
+      const inner = value.slice(1, -1);
+      result[key] = inner
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+    } else {
+      result[key] = value;
+    }
+
+    currentKey = null;
+  }
+
+  // Flush trailing array if any
+  if (currentKey && currentArray.length > 0) {
+    result[currentKey] = [...currentArray];
+  }
+
+  return result;
+}
+
+/**
+ * Ensure a frontmatter field value is always a string array.
+ */
+function asStringArray(value: string | string[] | undefined): string[] {
+  if (Array.isArray(value)) return value;
+  if (typeof value === 'string') return [value];
+  return [];
+}
+
+/**
+ * Scan the skills directory and return parsed skill metadata.
+ * Results are cached to avoid repeated filesystem scans;
+ * call {@link resetSkillsCache} to invalidate.
+ *
+ * Files with missing or invalid frontmatter are skipped with a warning.
+ *
+ * @param pluginRoot - Absolute path to the plugin root directory.
+ */
+export async function discoverSkills(
+  pluginRoot: string,
+): Promise<SkillMetadata[]> {
+  const normalizedRoot = resolve(pluginRoot);
+
+  // Return cached results for the same root
+  if (skillsCache && cacheRoot === normalizedRoot) {
+    return skillsCache;
+  }
+
+  const skillsDir = join(normalizedRoot, 'src', 'skills');
+  const discovered: SkillMetadata[] = [];
+
+  let entries: string[];
+  try {
+    entries = await readdir(skillsDir);
+  } catch {
+    // Skills directory does not exist - nothing to discover
+    console.warn(`Skills directory not found: ${skillsDir}`);
+    skillsCache = [];
+    cacheRoot = normalizedRoot;
+    return [];
+  }
+
+  for (const entry of entries) {
+    const skillPath = join(skillsDir, entry);
+    let entryStat: Stats;
+    try {
+      entryStat = await stat(skillPath);
+    } catch {
+      continue;
+    }
+
+    if (!entryStat.isDirectory()) continue;
+
+    const skillMdPath = join(skillPath, 'SKILL.md');
+    let skillMdStat: Stats;
+    try {
+      skillMdStat = await stat(skillMdPath);
+    } catch {
+      // No SKILL.md in this directory - skip silently
+      continue;
+    }
+
+    if (!skillMdStat.isFile()) continue;
+
+    let content: string;
+    try {
+      content = await readFile(skillMdPath, 'utf-8');
+    } catch {
+      console.warn(
+        `Could not read skill file: ${relative(normalizedRoot, skillMdPath)}`,
+      );
+      continue;
+    }
+
+    const frontmatter = parseFrontmatter(content);
+    const name =
+      typeof frontmatter.name === 'string' ? frontmatter.name : entry;
+    const description =
+      typeof frontmatter.description === 'string'
+        ? frontmatter.description
+        : '';
+
+    if (typeof name !== 'string') {
+      console.warn(
+        'Invalid frontmatter in ' +
+          relative(normalizedRoot, skillMdPath) +
+          ': name must be a string',
+      );
+      continue;
+    }
+
+    discovered.push({
+      name,
+      description,
+      path: skillMdPath,
+      tags: asStringArray(frontmatter.tags),
+      recommendedAgents: asStringArray(frontmatter.recommendedAgents),
+    });
+  }
+
+  skillsCache = discovered;
+  cacheRoot = normalizedRoot;
+  return discovered;
+}

package/src/skills/simplify/README.md

@@ -0,0 +1,19 @@
+# Simplify Skill
+
+Behavior-preserving code simplification and readability-focused refactoring.
+
+## Overview
+
+This bundled skill helps the `oracle` agent review and simplify code without
+changing behavior. It focuses on readability, maintainability, and reducing
+unnecessary complexity.
+
+## Source
+
+Adapted from Addy Osmani's
+[`code-simplification` skill](https://github.com/addyosmani/agent-skills/blob/main/skills/code-simplification/SKILL.md).
+
+## Installation
+
+Bundled with `opencode-dux` and auto-scanned on plugin init. The plugin
+registers it automatically; no manual installation needed.

package/src/skills/simplify/SKILL.md

@@ -0,0 +1,138 @@
+---
+name: simplify
+description: Simplifies code for clarity without changing behavior. Use for readability, maintainability, and complexity reduction after behavior is understood.
+---
+
+# Code Simplification
+
+## Overview
+
+Simplify code by reducing complexity while preserving exact behavior. The goal is not fewer lines - it's code that is easier to read, understand, modify, and debug. Every simplification must pass a simple test: "Would a new team member understand this faster than the original?"
+
+## When to Use
+
+- After a feature is working and tests pass, but the implementation feels heavier than it needs to be
+- During code review when readability or complexity issues are flagged
+- When you encounter deeply nested logic, long functions, or unclear names
+- When refactoring code written under time pressure
+- When consolidating related logic scattered across files
+- After merging changes that introduced duplication or inconsistency
+
+**When NOT to use:**
+
+- Code is already clean and readable - don't simplify for the sake of it
+- You don't understand what the code does yet - comprehend before you simplify
+- The code is performance-critical and the "simpler" version would be measurably slower
+- You're about to rewrite the module entirely - simplifying throwaway code wastes effort
+
+## The Five Principles
+
+### 1. Preserve Behavior Exactly
+
+Don't change what the code does - only how it expresses it. All inputs, outputs, side effects, error behavior, and edge cases must remain identical. If you're not sure a simplification preserves behavior, don't make it.
+
+Before every change, ask:
+
+- Does this produce the same output for every input?
+- Does this maintain the same error behavior?
+- Does this preserve the same side effects and ordering?
+- Do all existing tests still pass without modification?
+
+### 2. Follow Project Conventions
+
+Simplification means making code more consistent with the codebase, not imposing external preferences.
+
+Before simplifying:
+
+1. Read `AGENTS.md` / project conventions
+2. Study how neighboring code handles similar patterns
+3. Match the project's style for imports, naming, function style, error handling, and type annotations
+
+Simplification that breaks project consistency is not simplification - it's churn.
+
+### 3. Prefer Clarity Over Cleverness
+
+Explicit code is better than compact code when the compact version requires a mental pause to parse.
+
+- Replace nested ternaries with readable control flow
+- Replace dense inline transforms with named intermediate steps when they clarify intent
+- Keep helpful names even if they cost a few extra lines
+
+### 4. Maintain Balance
+
+Watch for over-simplification:
+
+- Don't inline away names that carry meaning
+- Don't merge unrelated logic into one larger function
+- Don't remove abstractions that serve testability or extensibility
+- Don't optimize for line count over comprehension
+
+### 5. Scope to What Changed
+
+Default to simplifying recently modified code. Avoid unrelated drive-by refactors unless explicitly asked.
+
+## Process
+
+### Step 1: Understand Before Touching
+
+Before changing or removing anything, understand why it exists.
+
+Answer:
+
+- What is this code's responsibility?
+- What calls it? What does it call?
+- What are the edge cases and error paths?
+- Are there tests that define expected behavior?
+- Why might it have been written this way?
+
+If you can't answer these, read more context first.
+
+### Step 2: Look for Simplification Opportunities
+
+Signals:
+
+- Deep nesting
+- Long functions with mixed responsibilities
+- Nested ternaries
+- Boolean flag arguments
+- Repeated conditionals
+- Generic or misleading names
+- Duplicated logic
+- Dead code
+- Wrappers or abstractions that add no value
+
+### Step 3: Apply Changes Incrementally
+
+Make one simplification at a time.
+
+For each simplification:
+
+1. Make the change
+2. Run relevant tests
+3. Keep it only if behavior is preserved
+
+Separate refactoring from feature work whenever possible.
+
+### Step 4: Verify the Result
+
+After simplifying, confirm:
+
+- The code is genuinely easier to understand
+- The diff is clean and reviewable
+- Project conventions still match
+- No behavior, error handling, or side effects changed
+
+## Guidance for This Repository
+
+- Prefer straightforward TypeScript over clever compression
+- Preserve existing runtime behavior, tests, and hooks
+- Favor explicit names and smaller focused helpers when they improve readability
+- Keep refactors tightly scoped to the task or review feedback
+
+## Verification Checklist
+
+- [ ] Existing tests pass without modification
+- [ ] Build/typecheck/lint still pass
+- [ ] No unrelated files were refactored
+- [ ] No error handling was weakened or removed
+- [ ] The result is simpler to review than the original

package/src/subscriptions/accounts-store.test.ts

@@ -0,0 +1,236 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import {
+  getAccount,
+  getAccountsByProvider,
+  loadAccounts,
+  loadAccountsResult,
+  removeAccount,
+  saveAccount,
+  setAccountKey,
+} from './accounts-store';
+
+let previousXdgDataHome: string | undefined;
+let tempDir: string;
+
+beforeEach(() => {
+  previousXdgDataHome = process.env.XDG_DATA_HOME;
+  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'omos-subscriptions-store-'));
+  process.env.XDG_DATA_HOME = tempDir;
+});
+
+afterEach(() => {
+  if (previousXdgDataHome === undefined) {
+    delete process.env.XDG_DATA_HOME;
+  } else {
+    process.env.XDG_DATA_HOME = previousXdgDataHome;
+  }
+  fs.rmSync(tempDir, { recursive: true, force: true });
+});
+
+describe('accounts-store (subscriptions)', () => {
+  test('saveAccount and loadAccounts for opencode-go', () => {
+    saveAccount({
+      provider: 'opencode-go',
+      name: 'personal',
+      workspaceId: 'wrk_123',
+      authCookie: 'cookie-abc',
+    });
+
+    const accounts = loadAccounts();
+    expect(accounts).toHaveLength(1);
+    const acct = accounts[0];
+    expect(acct.provider).toBe('opencode-go');
+    expect(acct.name).toBe('personal');
+    if (acct.provider === 'opencode-go') {
+      expect(acct.workspaceId).toBe('wrk_123');
+      expect(acct.authCookie).toBe('cookie-abc');
+    }
+  });
+
+  test('saveAccount and loadAccounts for neuralwatt', () => {
+    saveAccount({
+      provider: 'neuralwatt',
+      name: 'my-neuralwatt',
+      apiKey: 'sk-test-key',
+    });
+
+    const accounts = loadAccounts();
+    expect(accounts).toHaveLength(1);
+    expect(accounts[0].provider).toBe('neuralwatt');
+    expect(accounts[0].name).toBe('my-neuralwatt');
+    expect(accounts[0].apiKey).toBe('sk-test-key');
+  });
+
+  test('saveAccount overwrites existing account by name', () => {
+    saveAccount({
+      provider: 'opencode-go',
+      name: 'personal',
+      workspaceId: 'wrk_123',
+      authCookie: 'cookie-old',
+    });
+    saveAccount({
+      provider: 'opencode-go',
+      name: 'personal',
+      workspaceId: 'wrk_456',
+      authCookie: 'cookie-new',
+    });
+
+    const accounts = loadAccounts();
+    expect(accounts).toHaveLength(1);
+    const acct = accounts[0];
+    if (acct.provider === 'opencode-go') {
+      expect(acct.workspaceId).toBe('wrk_456');
+      expect(acct.authCookie).toBe('cookie-new');
+    }
+  });
+
+  test('saveAccount can change provider type for same name', () => {
+    saveAccount({
+      provider: 'opencode-go',
+      name: 'personal',
+      workspaceId: 'wrk_123',
+      authCookie: 'cookie-abc',
+    });
+    saveAccount({
+      provider: 'neuralwatt',
+      name: 'personal',
+      apiKey: 'sk-new-key',
+    });
+
+    const accounts = loadAccounts();
+    expect(accounts).toHaveLength(1);
+    expect(accounts[0].provider).toBe('neuralwatt');
+  });
+
+  test('removeAccount removes by name', () => {
+    saveAccount({
+      provider: 'opencode-go',
+      name: 'personal',
+      workspaceId: 'wrk_123',
+      authCookie: 'cookie-abc',
+    });
+    const removed = removeAccount('personal');
+    expect(removed).toBe(true);
+    expect(loadAccounts()).toHaveLength(0);
+  });
+
+  test('removeAccount returns false for unknown name', () => {
+    const removed = removeAccount('nonexistent');
+    expect(removed).toBe(false);
+  });
+
+  test('getAccount finds by name', () => {
+    saveAccount({
+      provider: 'opencode-go',
+      name: 'personal',
+      workspaceId: 'wrk_123',
+      authCookie: 'cookie-abc',
+    });
+    const account = getAccount('personal');
+    expect(account).toBeDefined();
+    expect(account?.provider).toBe('opencode-go');
+  });
+
+  test('getAccount returns undefined for unknown name', () => {
+    const account = getAccount('nonexistent');
+    expect(account).toBeUndefined();
+  });
+
+  test('setAccountKey sets provider and apiKey', () => {
+    saveAccount({
+      provider: 'opencode-go',
+      name: 'personal',
+      workspaceId: 'wrk_123',
+      authCookie: 'cookie-abc',
+    });
+    const updated = setAccountKey('personal', 'opencode-go', 'sk-test-key');
+    expect(updated).toBe(true);
+
+    const account = getAccount('personal');
+    expect(account?.provider).toBe('opencode-go');
+    expect(account?.apiKey).toBe('sk-test-key');
+  });
+
+  test('setAccountKey returns false for unknown name', () => {
+    const updated = setAccountKey('nonexistent', 'opencode-go', 'sk-test-key');
+    expect(updated).toBe(false);
+  });
+
+  test('getAccountsByProvider filters by provider', () => {
+    saveAccount({
+      provider: 'opencode-go',
+      name: 'personal',
+      workspaceId: 'wrk_123',
+      authCookie: 'cookie-abc',
+    });
+    saveAccount({
+      provider: 'neuralwatt',
+      name: 'my-neuralwatt',
+      apiKey: 'sk-test-key',
+    });
+    saveAccount({
+      provider: 'opencode-go',
+      name: 'work',
+      workspaceId: 'wrk_456',
+      authCookie: 'cookie-def',
+    });
+
+    const goAccounts = getAccountsByProvider('opencode-go');
+    expect(goAccounts).toHaveLength(2);
+    expect(goAccounts.every((a) => a.provider === 'opencode-go')).toBe(true);
+
+    const nwAccounts = getAccountsByProvider('neuralwatt');
+    expect(nwAccounts).toHaveLength(1);
+    expect(nwAccounts[0].name).toBe('my-neuralwatt');
+  });
+
+  test('loadAccountsResult reports parse failures', () => {
+    const storageDir = path.join(
+      tempDir,
+      'opencode',
+      'storage',
+      'opencode-dux',
+    );
+    fs.mkdirSync(storageDir, { recursive: true });
+    const subscriptionsPath = path.join(storageDir, 'subscriptions.json');
+    fs.writeFileSync(subscriptionsPath, '{ malformed json');
+
+    const result = loadAccountsResult();
+    expect(result.ok).toBe(false);
+    expect(result.accounts).toEqual([]);
+  });
+
+  test('loadAccountsResult accepts current version schema', () => {
+    const storageDir = path.join(
+      tempDir,
+      'opencode',
+      'storage',
+      'opencode-dux',
+    );
+    fs.mkdirSync(storageDir, { recursive: true });
+
+    const newPath = path.join(storageDir, 'subscriptions.json');
+    fs.writeFileSync(
+      newPath,
+      JSON.stringify({
+        version: 2,
+        accounts: [
+          {
+            provider: 'neuralwatt',
+            name: 'new-account',
+            apiKey: 'sk-new',
+          },
+        ],
+      }),
+    );
+
+    const result = loadAccountsResult();
+    expect(result.ok).toBe(true);
+    expect(result.accounts).toHaveLength(1);
+    expect(result.accounts[0].name).toBe('new-account');
+    expect(result.accounts[0].provider).toBe('neuralwatt');
+  });
+});