@uluops/setup 0.2.0 → 0.6.0

package/dist/harnesses/codex.js

@@ -0,0 +1,54 @@
+/**
+ * Codex Harness Profile (Scaffold)
+ *
+ * Paths and metadata are verified from vendor docs.
+ * Codex uses TOML config with `mcp_servers` key (nested tables).
+ * Agent definitions are TOML, not markdown.
+ * Skills use a different path ($HOME/.agents/skills/) than agents (~/.codex/agents/).
+ *
+ * NOT YET TESTED with UluOps agents. McpConfigStrategy throws
+ * until integration testing is complete.
+ *
+ * Will require `smol-toml` dependency when fully implemented.
+ */
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { HarnessNotTestedError } from "./types.js";
+class CodexMcpConfig {
+    async read() {
+        throw new HarnessNotTestedError("Codex (agent format compatibility under review)");
+    }
+    merge() {
+        throw new HarnessNotTestedError("Codex (agent format compatibility under review)");
+    }
+    remove() {
+        throw new HarnessNotTestedError("Codex (agent format compatibility under review)");
+    }
+    async write() {
+        throw new HarnessNotTestedError("Codex (agent format compatibility under review)");
+    }
+    check() {
+        throw new HarnessNotTestedError("Codex (MCP config check not supported)");
+    }
+}
+const home = join(homedir(), ".codex");
+export const codexProfile = {
+    name: "codex",
+    displayName: "Codex",
+    status: "experimental",
+    homeDir: home,
+    agentFormat: "toml",
+    factoryTarget: "codex",
+    agentExtension: ".toml",
+    paths: {
+        home,
+        globalMcpConfig: join(home, "config.toml"),
+        localMcpConfig: ".codex/config.toml",
+        agentsDir: join(home, "agents"),
+        commandsDir: join(homedir(), ".agents", "skills"),
+        settingsPath: null,
+        toolsDir: null,
+    },
+    mcpConfig: new CodexMcpConfig(),
+    hooks: null,
+};

package/dist/harnesses/gemini-cli.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Gemini CLI Harness Profile
+ *
+ * Paths and metadata are verified from vendor docs.
+ * MCP config uses `mcpServers` key (same shape as Claude Code)
+ * but at a different file path (~/.gemini/settings.json).
+ *
+ * Gemini CLI requires `trust: true` in MCP server config to
+ * allow automatic tool execution without confirmation prompts.
+ */
+import { type HarnessProfile } from "./types.js";
+export declare const geminiCliProfile: HarnessProfile;

package/dist/harnesses/gemini-cli.js

@@ -0,0 +1,80 @@
+/**
+ * Gemini CLI Harness Profile
+ *
+ * Paths and metadata are verified from vendor docs.
+ * MCP config uses `mcpServers` key (same shape as Claude Code)
+ * but at a different file path (~/.gemini/settings.json).
+ *
+ * Gemini CLI requires `trust: true` in MCP server config to
+ * allow automatic tool execution without confirmation prompts.
+ */
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { ULUOPS_SERVERS, } from "./types.js";
+import { readConfig, mergeUluopsMcp, removeUluopsMcp, writeConfig, } from "../lib/config-merger.js";
+import { readSettings, writeSettings, mergeUluopsHook, removeUluopsHook, hasUluopsHook, } from "../lib/settings-merger.js";
+class GeminiMcpConfig {
+    async read(path) {
+        return readConfig(path);
+    }
+    merge(config, apiKey) {
+        // Gemini CLI requires trust: true for a smooth experience
+        return mergeUluopsMcp(config, apiKey, true);
+    }
+    remove(config) {
+        return removeUluopsMcp(config);
+    }
+    async write(path, config) {
+        await writeConfig(path, config);
+    }
+    check(config) {
+        const servers = config["mcpServers"];
+        if (!servers)
+            return false;
+        return ULUOPS_SERVERS.every((name) => name in servers);
+    }
+}
+class GeminiHooks {
+    static HOOK_TYPE = "AfterTool";
+    static MATCHER = "invoke_agent";
+    async install(settingsPath, hookCommand, dryRun) {
+        if (dryRun)
+            return true;
+        const settings = await readSettings(settingsPath);
+        const merged = mergeUluopsHook(settings, hookCommand, GeminiHooks.HOOK_TYPE, GeminiHooks.MATCHER);
+        await writeSettings(settingsPath, merged);
+        return true;
+    }
+    async remove(settingsPath, dryRun) {
+        if (dryRun)
+            return;
+        const settings = await readSettings(settingsPath);
+        const cleaned = removeUluopsHook(settings, GeminiHooks.HOOK_TYPE);
+        await writeSettings(settingsPath, cleaned);
+    }
+    async check(settingsPath) {
+        const settings = await readSettings(settingsPath);
+        return hasUluopsHook(settings, GeminiHooks.HOOK_TYPE);
+    }
+}
+const home = join(homedir(), ".gemini");
+export const geminiCliProfile = {
+    name: "gemini-cli",
+    displayName: "Gemini CLI",
+    status: "stable",
+    homeDir: home,
+    agentFormat: "markdown",
+    factoryTarget: "gemini-cli",
+    agentExtension: ".md",
+    paths: {
+        home,
+        globalMcpConfig: join(home, "settings.json"),
+        localMcpConfig: ".gemini/settings.json",
+        agentsDir: join(home, "agents"),
+        commandsDir: join(home, "commands"),
+        settingsPath: join(home, "settings.json"),
+        toolsDir: join(home, "tools", "agent-metrics"),
+    },
+    mcpConfig: new GeminiMcpConfig(),
+    hooks: new GeminiHooks(),
+};

package/dist/harnesses/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Harness Registry
+ *
+ * Central registry for harness profiles. Resolves names/aliases
+ * and detects installed harnesses.
+ */
+import type { HarnessProfile } from "./types.js";
+export type { HarnessProfile, HarnessPaths, McpConfigStrategy, HookStrategy, } from "./types.js";
+export { ConfigParseError, HarnessNotTestedError, } from "./types.js";
+export declare const ALL_PROFILES: readonly HarnessProfile[];
+/** Resolve a harness name or alias to a canonical name. */
+export declare function resolveHarnessName(input: string): string;
+/** Get a harness profile by name or alias. Throws if not found. */
+export declare function getProfile(name: string): HarnessProfile;
+/**
+ * Detect which harnesses are installed by probing home directories.
+ *
+ * Excludes experimental profiles even when their home dir is present:
+ * auto-detection should never return a profile that will throw
+ * HarnessNotTestedError on use. Users can still opt in with
+ * `--harness <name>`, which goes through getProfile() and surfaces the
+ * explicit error message — the relational promise "in the detected
+ * list = safe to install" is preserved.
+ */
+export declare function detectHarnesses(): HarnessProfile[];
+/** List all available harness names (not aliases). */
+export declare function listHarnesses(): string[];

package/dist/harnesses/index.js

@@ -0,0 +1,54 @@
+/**
+ * Harness Registry
+ *
+ * Central registry for harness profiles. Resolves names/aliases
+ * and detects installed harnesses.
+ */
+import { existsSync } from "node:fs";
+import { claudeCodeProfile } from "./claude-code.js";
+import { opencodeProfile } from "./opencode.js";
+import { geminiCliProfile } from "./gemini-cli.js";
+import { codexProfile } from "./codex.js";
+export { ConfigParseError, HarnessNotTestedError, } from "./types.js";
+export const ALL_PROFILES = [
+    claudeCodeProfile,
+    opencodeProfile,
+    geminiCliProfile,
+    codexProfile,
+];
+const aliases = new Map([
+    ["claude", "claude-code"],
+    ["oc", "opencode"],
+    ["gemini", "gemini-cli"],
+]);
+/** Resolve a harness name or alias to a canonical name. */
+export function resolveHarnessName(input) {
+    return aliases.get(input) ?? input;
+}
+/** Get a harness profile by name or alias. Throws if not found. */
+export function getProfile(name) {
+    const resolved = resolveHarnessName(name);
+    const profile = ALL_PROFILES.find((p) => p.name === resolved);
+    if (!profile) {
+        const available = ALL_PROFILES.map((p) => p.name).join(", ");
+        throw new Error(`Unknown harness "${name}". Available: ${available}`);
+    }
+    return profile;
+}
+/**
+ * Detect which harnesses are installed by probing home directories.
+ *
+ * Excludes experimental profiles even when their home dir is present:
+ * auto-detection should never return a profile that will throw
+ * HarnessNotTestedError on use. Users can still opt in with
+ * `--harness <name>`, which goes through getProfile() and surfaces the
+ * explicit error message — the relational promise "in the detected
+ * list = safe to install" is preserved.
+ */
+export function detectHarnesses() {
+    return ALL_PROFILES.filter((p) => p.status === "stable" && existsSync(p.paths.home));
+}
+/** List all available harness names (not aliases). */
+export function listHarnesses() {
+    return ALL_PROFILES.map((p) => p.name);
+}

package/dist/harnesses/opencode.d.ts

@@ -0,0 +1,14 @@
+/**
+ * OpenCode Harness Profile
+ *
+ * OpenCode uses JSON/JSONC config with a structurally different MCP shape:
+ * - `mcp` key (not `mcpServers`)
+ * - `type: "local"` required
+ * - `command` as flat array (not separate command/args)
+ * - `environment` (not `env`)
+ * - `enabled: true` and `timeout: 30000` recommended
+ *
+ * Verified working shape from ~/opencode.jsonc (2026-04-30).
+ */
+import { type HarnessProfile } from "./types.js";
+export declare const opencodeProfile: HarnessProfile;

package/dist/harnesses/opencode.js

@@ -0,0 +1,139 @@
+/**
+ * OpenCode Harness Profile
+ *
+ * OpenCode uses JSON/JSONC config with a structurally different MCP shape:
+ * - `mcp` key (not `mcpServers`)
+ * - `type: "local"` required
+ * - `command` as flat array (not separate command/args)
+ * - `environment` (not `env`)
+ * - `enabled: true` and `timeout: 30000` recommended
+ *
+ * Verified working shape from ~/opencode.jsonc (2026-04-30).
+ */
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, isAbsolute } from "node:path";
+import { parse as parseJsonc } from "jsonc-parser";
+import { ULUOPS_SERVERS, ConfigParseError } from "./types.js";
+import { atomicWrite } from "../lib/atomic-write.js";
+class OpenCodeMcpConfig {
+    /** Maps requested path → actual resolved path (for .jsonc fallback). */
+    resolvedPaths = new Map();
+    async read(path) {
+        // Try the given path, then probe for .jsonc variant
+        let raw = null;
+        const candidates = [path, path.replace(/\.json$/, ".jsonc")];
+        for (const p of candidates) {
+            try {
+                raw = await readFile(p, "utf-8");
+                this.resolvedPaths.set(path, p);
+                break;
+            }
+            catch {
+                // Try next
+            }
+        }
+        if (raw === null) {
+            this.resolvedPaths.set(path, path);
+            return {};
+        }
+        try {
+            return parseJsonc(raw);
+        }
+        catch (err) {
+            throw new ConfigParseError(path, err);
+        }
+    }
+    merge(config, apiKey) {
+        const raw = config["mcp"];
+        const existing = (typeof raw === "object" && raw !== null ? raw : {});
+        const tracker = {
+            type: "local",
+            command: ["npx", "-y", "uluops-tracker-mcp-client"],
+            enabled: true,
+            timeout: 30000,
+            environment: {
+                ULUOPS_BASE_URL: "https://api.uluops.ai/api/v1",
+                ULUOPS_API_KEY: apiKey,
+            },
+        };
+        const registry = {
+            type: "local",
+            command: ["npx", "-y", "uluops-registry-mcp-client"],
+            enabled: true,
+            timeout: 30000,
+            environment: {
+                ULUOPS_REGISTRY_URL: "https://api.uluops.ai/api/v1/registry",
+                ULUOPS_API_KEY: apiKey,
+            },
+        };
+        return {
+            ...config,
+            mcp: {
+                ...existing,
+                "uluops-tracker": tracker,
+                "uluops-registry": registry,
+            },
+        };
+    }
+    remove(config) {
+        if (!config["mcp"] || typeof config["mcp"] !== "object")
+            return config;
+        const mcp = { ...config["mcp"] };
+        for (const name of ULUOPS_SERVERS) {
+            delete mcp[name];
+        }
+        const result = { ...config };
+        if (Object.keys(mcp).length === 0) {
+            delete result["mcp"];
+        }
+        else {
+            result["mcp"] = mcp;
+        }
+        return result;
+    }
+    async write(path, config) {
+        // Write back to the path that was actually read (may be .jsonc)
+        const target = this.resolvedPaths.get(path) ?? path;
+        await atomicWrite(target, JSON.stringify(config, null, 2) + "\n", {
+            mode: 0o600,
+        });
+    }
+    check(config) {
+        const mcp = config["mcp"];
+        if (!mcp)
+            return false;
+        return ULUOPS_SERVERS.every((name) => name in mcp);
+    }
+}
+const xdgConfig = (() => {
+    const env = process.env["XDG_CONFIG_HOME"];
+    if (env) {
+        if (!isAbsolute(env) || env.includes("..")) {
+            throw new Error(`XDG_CONFIG_HOME must be an absolute path without traversal: ${env}`);
+        }
+        return env;
+    }
+    return join(homedir(), ".config");
+})();
+const home = join(xdgConfig, "opencode");
+export const opencodeProfile = {
+    name: "opencode",
+    displayName: "OpenCode",
+    status: "stable",
+    homeDir: home,
+    agentFormat: "markdown",
+    factoryTarget: "opencode",
+    agentExtension: ".md",
+    paths: {
+        home,
+        globalMcpConfig: join(home, "opencode.json"),
+        localMcpConfig: "opencode.json",
+        agentsDir: join(home, "agents"),
+        commandsDir: join(home, "commands"),
+        settingsPath: null,
+        toolsDir: null,
+    },
+    mcpConfig: new OpenCodeMcpConfig(),
+    hooks: null,
+};

package/dist/harnesses/types.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Harness Type System
+ *
+ * Defines the abstraction layer for multi-harness support.
+ * Each harness (Claude Code, OpenCode, Codex, Gemini CLI) implements
+ * these interfaces to encapsulate its config format, paths, and capabilities.
+ */
+/**
+ * Maturity status of a harness profile.
+ *
+ * - `"stable"` — implementation is tested end-to-end and safe to auto-detect.
+ *   detectHarnesses() returns these.
+ * - `"experimental"` — scaffold only; throws HarnessNotTestedError on most
+ *   operations. getProfile() still resolves these (so `--harness <name>`
+ *   surfaces the explicit error), but detectHarnesses() filters them out so
+ *   automatic install never picks an unusable profile.
+ */
+export type HarnessStatus = "stable" | "experimental";
+/** Static definition of a harness — no runtime state. */
+export interface HarnessProfile {
+    /** Canonical name (e.g., 'claude-code', 'opencode', 'codex', 'gemini-cli') */
+    readonly name: string;
+    /** Display name for CLI output (e.g., 'Claude Code', 'OpenCode') */
+    readonly displayName: string;
+    /**
+     * Maturity status. Experimental profiles are excluded from auto-detection
+     * but still accept an explicit `--harness` flag so users can opt in to
+     * the not-yet-tested error surface.
+     */
+    readonly status: HarnessStatus;
+    /** Home directory for this harness */
+    readonly homeDir: string;
+    /** Agent definition format */
+    readonly agentFormat: "markdown" | "toml";
+    /** Target name for definition-factory rendering */
+    readonly factoryTarget: string;
+    /** File extension for agent definitions */
+    readonly agentExtension: ".md" | ".toml";
+    /** Paths for this harness */
+    readonly paths: HarnessPaths;
+    /** MCP config strategy for this harness's config format */
+    readonly mcpConfig: McpConfigStrategy;
+    /** Hook operations (null if harness doesn't support post-agent hooks) */
+    readonly hooks: HookStrategy | null;
+}
+export interface HarnessPaths {
+    /** Home dir (e.g., ~/.claude/) */
+    readonly home: string;
+    /** Global MCP config (e.g., ~/.claude.json, ~/.config/opencode/opencode.json) */
+    readonly globalMcpConfig: string;
+    /** Project-scoped MCP config filename (e.g., .mcp.json, opencode.json) — resolved relative to project root */
+    readonly localMcpConfig: string;
+    /** Global agent definitions dir */
+    readonly agentsDir: string;
+    /** Global commands/skills dir */
+    readonly commandsDir: string;
+    /** Settings file path, or null if harness has no settings file */
+    readonly settingsPath: string | null;
+    /** Tool installation dir, or null if harness has no tool installation */
+    readonly toolsDir: string | null;
+}
+/**
+ * Encapsulates format-specific MCP config read/merge/write.
+ * Claude Code/Gemini use JSON with `mcpServers` key.
+ * OpenCode uses JSON/JSONC with `mcp` key and different entry shape.
+ * Codex uses TOML with `mcp_servers` key.
+ */
+export interface McpConfigStrategy {
+    /** Read existing config from disk. Returns parsed object. Returns {} if file missing. Throws ConfigParseError if malformed. */
+    read(path: string): Promise<Record<string, unknown>>;
+    /** Merge UluOps MCP servers into the parsed config. Format-aware. */
+    merge(config: Record<string, unknown>, apiKey: string): Record<string, unknown>;
+    /** Remove UluOps MCP servers from the parsed config. */
+    remove(config: Record<string, unknown>): Record<string, unknown>;
+    /** Write config back to disk in the harness's native format. Uses atomic write. */
+    write(path: string, config: Record<string, unknown>): Promise<void>;
+    /** Check if UluOps MCP servers are present in the parsed config. */
+    check(config: Record<string, unknown>): boolean;
+}
+/**
+ * Hook strategy for harnesses that support post-agent execution hooks.
+ * Currently only Claude Code supports this (SubagentStop event).
+ */
+export interface HookStrategy {
+    /**
+     * Install the agent-metrics post-execution hook.
+     * @returns true if hook was installed or updated, false if already current (no-op).
+     * In dry-run mode, returns true (would install) without writing.
+     */
+    install(settingsPath: string, hookCommand: string, dryRun: boolean): Promise<boolean>;
+    /** Remove the hook. No-op if not installed. */
+    remove(settingsPath: string, dryRun: boolean): Promise<void>;
+    /** Check if hook is currently installed. */
+    check(settingsPath: string): Promise<boolean>;
+}
+/** MCP server names installed by UluOps setup. Shared across all harnesses. */
+export declare const ULUOPS_SERVERS: readonly ["uluops-tracker", "uluops-registry"];
+/** Thrown when a harness config file cannot be parsed. */
+export declare class ConfigParseError extends Error {
+    readonly path: string;
+    constructor(path: string, cause: unknown);
+}
+/** Thrown when a harness is scaffolded but not yet tested/implemented. */
+export declare class HarnessNotTestedError extends Error {
+    constructor(harnessName: string);
+}

package/dist/harnesses/types.js

@@ -0,0 +1,26 @@
+/**
+ * Harness Type System
+ *
+ * Defines the abstraction layer for multi-harness support.
+ * Each harness (Claude Code, OpenCode, Codex, Gemini CLI) implements
+ * these interfaces to encapsulate its config format, paths, and capabilities.
+ */
+/** MCP server names installed by UluOps setup. Shared across all harnesses. */
+export const ULUOPS_SERVERS = ["uluops-tracker", "uluops-registry"];
+/** Thrown when a harness config file cannot be parsed. */
+export class ConfigParseError extends Error {
+    path;
+    constructor(path, cause) {
+        const msg = cause instanceof Error ? cause.message : String(cause);
+        super(`Failed to parse config at ${path}: ${msg}`);
+        this.path = path;
+        this.name = "ConfigParseError";
+    }
+}
+/** Thrown when a harness is scaffolded but not yet tested/implemented. */
+export class HarnessNotTestedError extends Error {
+    constructor(harnessName) {
+        super(`${harnessName} harness is not yet tested. Use --harness claude-code or --harness opencode.`);
+        this.name = "HarnessNotTestedError";
+    }
+}

package/dist/lib/agent-transform.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Agent Transform
+ *
+ * Transforms Claude Code agent markdown to other harness formats at install time.
+ * Single source of truth: assets/agents/ contains Claude Code format only.
+ * Each harness gets its frontmatter rewritten; the body is identical across all targets.
+ */
+/**
+ * Transform a Claude Code agent markdown file to a target harness format.
+ * Returns the original content for claude-code; rewrites frontmatter for others.
+ */
+export declare function transformAgent(markdown: string, harnessName: string): string;

package/dist/lib/agent-transform.js

@@ -0,0 +1,129 @@
+/**
+ * Agent Transform
+ *
+ * Transforms Claude Code agent markdown to other harness formats at install time.
+ * Single source of truth: assets/agents/ contains Claude Code format only.
+ * Each harness gets its frontmatter rewritten; the body is identical across all targets.
+ */
+function parseAgentMarkdown(markdown) {
+    const first = markdown.indexOf("---");
+    if (first === -1)
+        return { frontmatter: {}, body: markdown };
+    const second = markdown.indexOf("---", first + 3);
+    if (second === -1)
+        return { frontmatter: {}, body: markdown };
+    const fmBlock = markdown.substring(first + 3, second).trim();
+    const body = markdown.substring(second + 3);
+    const frontmatter = {};
+    for (const line of fmBlock.split("\n")) {
+        const colonIdx = line.indexOf(":");
+        if (colonIdx === -1)
+            continue;
+        const key = line.substring(0, colonIdx).trim();
+        const value = line.substring(colonIdx + 1).trim();
+        if (key)
+            frontmatter[key] = value;
+    }
+    return { frontmatter, body };
+}
+// --- Tool mapping ---
+const GEMINI_TOOL_MAP = {
+    Read: "read_file",
+    Grep: "grep_search",
+    Glob: "glob",
+    Bash: "run_shell_command",
+};
+const OPENCODE_PERMISSION_MAP = {
+    Read: { key: "read", level: "allow" },
+    Grep: { key: "grep", level: "allow" },
+    Glob: { key: "glob", level: "allow" },
+    Bash: { key: "bash", level: "ask" },
+};
+function parseToolsList(toolsStr) {
+    // Handle both "Read, Grep, Glob" and "[Read, Grep, Glob]" formats
+    return toolsStr
+        .replace(/^\[|\]$/g, "")
+        .split(",")
+        .map((t) => t.trim())
+        .filter(Boolean);
+}
+// --- Harness-specific frontmatter builders ---
+function buildGeminiFrontmatter(fm) {
+    const lines = [];
+    lines.push(`name: ${fm["name"] ?? "unknown"}`);
+    const desc = fm["description"] ?? "";
+    // Quote description if it contains YAML-special chars
+    if (/[:#{}[\],&*?|>!%@`"']/.test(desc) || desc === "") {
+        lines.push(`description: "${desc.replace(/"/g, '\\"')}"`);
+    }
+    else {
+        lines.push(`description: ${desc}`);
+    }
+    lines.push("kind: local");
+    // Map tools
+    const tools = parseToolsList(fm["tools"] ?? "");
+    const geminiTools = tools
+        .map((t) => GEMINI_TOOL_MAP[t])
+        .filter(Boolean);
+    if (geminiTools.length > 0) {
+        lines.push("tools:");
+        for (const t of geminiTools) {
+            lines.push(`  - ${t}`);
+        }
+    }
+    lines.push("model: gemini-3-preview");
+    lines.push("temperature: 0.2");
+    lines.push("max_turns: 30");
+    lines.push("timeout_mins: 10");
+    return lines.join("\n");
+}
+function buildOpenCodeFrontmatter(fm) {
+    const lines = [];
+    lines.push(`name: ${fm["name"] ?? "unknown"}`);
+    const desc = fm["description"] ?? "";
+    if (/[:#{}[\],&*?|>!%@`"']/.test(desc) || desc === "") {
+        lines.push(`description: "${desc.replace(/"/g, '\\"')}"`);
+    }
+    else {
+        lines.push(`description: ${desc}`);
+    }
+    lines.push("mode: subagent");
+    // Map tools to permissions
+    const tools = parseToolsList(fm["tools"] ?? "");
+    const permissions = {};
+    for (const t of tools) {
+        const mapping = OPENCODE_PERMISSION_MAP[t];
+        if (mapping)
+            permissions[mapping.key] = mapping.level;
+    }
+    if (Object.keys(permissions).length > 0) {
+        permissions["list"] = "allow";
+        lines.push("permission:");
+        for (const [key, level] of Object.entries(permissions)) {
+            lines.push(`  ${key}: ${level}`);
+        }
+    }
+    lines.push("model: openai/gpt-5");
+    return lines.join("\n");
+}
+// --- Public API ---
+/**
+ * Transform a Claude Code agent markdown file to a target harness format.
+ * Returns the original content for claude-code; rewrites frontmatter for others.
+ */
+export function transformAgent(markdown, harnessName) {
+    if (harnessName === "claude-code")
+        return markdown;
+    const { frontmatter, body } = parseAgentMarkdown(markdown);
+    let newFrontmatter;
+    if (harnessName === "gemini-cli") {
+        newFrontmatter = buildGeminiFrontmatter(frontmatter);
+    }
+    else if (harnessName === "opencode") {
+        newFrontmatter = buildOpenCodeFrontmatter(frontmatter);
+    }
+    else {
+        return markdown; // Unknown harness — pass through unchanged
+    }
+    return `---\n${newFrontmatter}\n---${body}`;
+}

package/dist/lib/asset-catalog.d.ts

@@ -0,0 +1,9 @@
+export interface CommandEntry {
+    name: string;
+    description: string;
+    model: string;
+}
+/** Get all agent command entries from assets. */
+export declare function getAgentCommands(): Promise<CommandEntry[]>;
+/** Get all workflow command entries from assets. */
+export declare function getWorkflowCommands(): Promise<CommandEntry[]>;