@codemcp/ade-harnesses 0.0.2

package/.prettierignore

@@ -0,0 +1 @@
+dist

package/.turbo/turbo-build.log

@@ -0,0 +1,4 @@
+
+> @codemcp/ade-harnesses@0.0.2 build /home/runner/work/ade/ade/packages/harnesses
+> tsc -p tsconfig.build.json
+

package/.turbo/turbo-format.log

@@ -0,0 +1,6 @@
+
+> @codemcp/ade-harnesses@0.0.2 format /home/runner/work/ade/ade/packages/harnesses
+> prettier --check .
+
+Checking formatting...
+All matched files use Prettier code style!

package/.turbo/turbo-lint.log

@@ -0,0 +1,4 @@
+
+> @codemcp/ade-harnesses@0.0.2 lint /home/runner/work/ade/ade/packages/harnesses
+> eslint .
+

package/.turbo/turbo-test.log

@@ -0,0 +1,20 @@
+
+> @codemcp/ade-harnesses@0.0.2 test /home/runner/work/ade/ade/packages/harnesses
+> vitest --run
+
+
+ RUN  v3.2.4 /home/runner/work/ade/ade/packages/harnesses
+
+ ✓ src/writers/copilot.spec.ts (4 tests) 55ms
+ ✓ src/writers/cursor.spec.ts (5 tests) 82ms
+ ✓ src/writers/claude-code.spec.ts (6 tests) 107ms
+ ✓ src/writers/roo-code.spec.ts (3 tests) 31ms
+ ✓ src/writers/windsurf.spec.ts (3 tests) 82ms
+ ✓ src/writers/cline.spec.ts (3 tests) 82ms
+ ✓ src/index.spec.ts (4 tests) 9ms
+
+ Test Files  7 passed (7)
+      Tests  28 passed (28)
+   Start at  06:53:29
+   Duration  3.26s (transform 457ms, setup 0ms, collect 1.32s, tests 448ms, environment 4ms, prepare 2.22s)
+

package/.turbo/turbo-typecheck.log

@@ -0,0 +1,4 @@
+
+> @codemcp/ade-harnesses@0.0.2 typecheck /home/runner/work/ade/ade/packages/harnesses
+> tsc
+

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Luke Baker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export type { HarnessWriter } from "./types.js";
+export { installSkills } from "./skills-installer.js";
+export { universalWriter } from "./writers/universal.js";
+export { claudeCodeWriter } from "./writers/claude-code.js";
+export { cursorWriter } from "./writers/cursor.js";
+export { copilotWriter } from "./writers/copilot.js";
+export { windsurfWriter } from "./writers/windsurf.js";
+export { clineWriter } from "./writers/cline.js";
+export { rooCodeWriter } from "./writers/roo-code.js";
+export { kiroWriter } from "./writers/kiro.js";
+export { opencodeWriter } from "./writers/opencode.js";
+import type { HarnessWriter } from "./types.js";
+/** All built-in harness writers, ordered for wizard display. */
+export declare const allHarnessWriters: HarnessWriter[];
+/** Look up a harness writer by id. */
+export declare function getHarnessWriter(id: string): HarnessWriter | undefined;
+/** All valid harness IDs. */
+export declare function getHarnessIds(): string[];

package/dist/index.js

@@ -0,0 +1,39 @@
+export { installSkills } from "./skills-installer.js";
+export { universalWriter } from "./writers/universal.js";
+export { claudeCodeWriter } from "./writers/claude-code.js";
+export { cursorWriter } from "./writers/cursor.js";
+export { copilotWriter } from "./writers/copilot.js";
+export { windsurfWriter } from "./writers/windsurf.js";
+export { clineWriter } from "./writers/cline.js";
+export { rooCodeWriter } from "./writers/roo-code.js";
+export { kiroWriter } from "./writers/kiro.js";
+export { opencodeWriter } from "./writers/opencode.js";
+import { universalWriter } from "./writers/universal.js";
+import { claudeCodeWriter } from "./writers/claude-code.js";
+import { cursorWriter } from "./writers/cursor.js";
+import { copilotWriter } from "./writers/copilot.js";
+import { windsurfWriter } from "./writers/windsurf.js";
+import { clineWriter } from "./writers/cline.js";
+import { rooCodeWriter } from "./writers/roo-code.js";
+import { kiroWriter } from "./writers/kiro.js";
+import { opencodeWriter } from "./writers/opencode.js";
+/** All built-in harness writers, ordered for wizard display. */
+export const allHarnessWriters = [
+    universalWriter,
+    claudeCodeWriter,
+    cursorWriter,
+    copilotWriter,
+    windsurfWriter,
+    clineWriter,
+    rooCodeWriter,
+    kiroWriter,
+    opencodeWriter
+];
+/** Look up a harness writer by id. */
+export function getHarnessWriter(id) {
+    return allHarnessWriters.find((w) => w.id === id);
+}
+/** All valid harness IDs. */
+export function getHarnessIds() {
+    return allHarnessWriters.map((w) => w.id);
+}

package/dist/skills-installer.d.ts

@@ -0,0 +1,13 @@
+import type { SkillDefinition } from "@codemcp/ade-core";
+/**
+ * Install skills using the @codemcp/skills programmatic API.
+ *
+ * Inline skills are expected to already exist as SKILL.md files under
+ * `<projectRoot>/.ade/skills/<name>/` (written by the agent writer).
+ * This function calls `runAdd` with the local path for inline skills
+ * and the remote source for external skills.
+ *
+ * Note: `runAdd` uses `process.cwd()` to determine the install destination.
+ * This function changes cwd to `projectRoot` before calling `runAdd`.
+ */
+export declare function installSkills(skills: SkillDefinition[], projectRoot: string): Promise<void>;

package/dist/skills-installer.js

@@ -0,0 +1,46 @@
+import { join } from "node:path";
+import { runAdd } from "@codemcp/skills/api";
+function isInlineSkill(skill) {
+    return "body" in skill;
+}
+/**
+ * Install skills using the @codemcp/skills programmatic API.
+ *
+ * Inline skills are expected to already exist as SKILL.md files under
+ * `<projectRoot>/.ade/skills/<name>/` (written by the agent writer).
+ * This function calls `runAdd` with the local path for inline skills
+ * and the remote source for external skills.
+ *
+ * Note: `runAdd` uses `process.cwd()` to determine the install destination.
+ * This function changes cwd to `projectRoot` before calling `runAdd`.
+ */
+export async function installSkills(skills, projectRoot) {
+    if (skills.length === 0)
+        return;
+    const originalCwd = process.cwd();
+    process.chdir(projectRoot);
+    try {
+        for (const skill of skills) {
+            const source = isInlineSkill(skill)
+                ? join(projectRoot, ".ade", "skills", skill.name)
+                : skill.source;
+            try {
+                await runAdd([source], { yes: true, all: true });
+            }
+            catch (err) {
+                // runAdd may throw on network errors for external skills.
+                // Log and continue — inline skills should always succeed.
+                console.warn(`Warning: failed to install skill "${skill.name}" from ${source}:`, err instanceof Error ? err.message : err);
+            }
+        }
+    }
+    finally {
+        // Restore cwd only if the original directory still exists
+        try {
+            process.chdir(originalCwd);
+        }
+        catch {
+            // Original cwd may have been removed (e.g. in tests)
+        }
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,11 @@
+import type { AgentWriterDef } from "@codemcp/ade-core";
+/**
+ * A harness writer extends AgentWriterDef with metadata for display in the
+ * setup wizard and CLI help.
+ */
+export interface HarnessWriter extends AgentWriterDef {
+    /** Human-readable label for the wizard (e.g. "Claude Code") */
+    label: string;
+    /** Short description shown as hint in the wizard */
+    description: string;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/util.d.ts

@@ -0,0 +1,53 @@
+import type { GitHook, LogicalConfig, McpServerEntry } from "@codemcp/ade-core";
+/** Read a JSON file, returning `{}` if missing or unparseable. */
+export declare function readJsonOrEmpty(path: string): Promise<Record<string, unknown>>;
+/** Write a JSON object with trailing newline. Creates parent dirs. */
+export declare function writeJson(path: string, data: unknown): Promise<void>;
+export type ServerTransform = (server: McpServerEntry) => Record<string, unknown>;
+/** Standard mcpServers entry (cursor, universal, claude-code). */
+export declare const standardEntry: ServerTransform;
+/** Adds `type: "stdio"` (copilot). */
+export declare const stdioEntry: ServerTransform;
+/** Adds `alwaysAllow` (cline, roo-code, windsurf). */
+export declare const alwaysAllowEntry: ServerTransform;
+interface WriteMcpServersOpts {
+    /** Full path to the JSON file. */
+    path: string;
+    /** Key in the JSON that holds the server map. Default: `"mcpServers"`. */
+    key?: string;
+    /** Transform each McpServerEntry into the harness-specific shape. */
+    transform?: ServerTransform;
+    /** Extra top-level fields to merge (e.g. `$schema`). */
+    defaults?: Record<string, unknown>;
+}
+/**
+ * Merge MCP server entries into an existing JSON config file.
+ * Creates the file (and parent dirs) if missing.
+ */
+export declare function writeMcpServers(servers: McpServerEntry[], opts: WriteMcpServersOpts): Promise<void>;
+/**
+ * Write instructions as a plain text rules file.
+ * Skips if no instructions.
+ */
+export declare function writeRulesFile(instructions: string[], path: string): Promise<void>;
+interface AgentMdOpts {
+    /** Full path to the .md file. */
+    path: string;
+    /** Extra YAML frontmatter lines (after name/description, before `---`). */
+    extraFrontmatter?: string[];
+    /** Fallback body when instructions are empty. */
+    fallbackBody?: string;
+}
+/**
+ * Write an agent markdown file with YAML frontmatter.
+ * Shared by claude-code, copilot, and opencode.
+ */
+export declare function writeAgentMd(config: LogicalConfig, opts: AgentMdOpts): Promise<void>;
+/**
+ * Write git hook scripts to `.git/hooks/<phase>`.
+ * Files are created with executable permissions (0o755).
+ * No-op when the hooks array is empty.
+ */
+export declare function writeGitHooks(hooks: GitHook[] | undefined, projectRoot: string): Promise<void>;
+export declare function writeInlineSkills(config: LogicalConfig, projectRoot: string): Promise<void>;
+export {};

package/dist/util.js

@@ -0,0 +1,130 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+// ---------------------------------------------------------------------------
+// JSON helpers
+// ---------------------------------------------------------------------------
+/** Read a JSON file, returning `{}` if missing or unparseable. */
+export async function readJsonOrEmpty(path) {
+    try {
+        return JSON.parse(await readFile(path, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+/** Write a JSON object with trailing newline. Creates parent dirs. */
+export async function writeJson(path, data) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+// ---------------------------------------------------------------------------
+// Server entry transform — each harness overrides only what differs
+// ---------------------------------------------------------------------------
+/** Minimal MCP entry: command + args + optional env. */
+function baseEntry(server) {
+    return {
+        command: server.command,
+        args: server.args,
+        ...(Object.keys(server.env).length > 0 ? { env: server.env } : {})
+    };
+}
+/** Standard mcpServers entry (cursor, universal, claude-code). */
+export const standardEntry = baseEntry;
+/** Adds `type: "stdio"` (copilot). */
+export const stdioEntry = (s) => ({
+    type: "stdio",
+    ...baseEntry(s)
+});
+/** Adds `alwaysAllow` (cline, roo-code, windsurf). */
+export const alwaysAllowEntry = (s) => ({
+    ...baseEntry(s),
+    alwaysAllow: s.allowedTools ?? ["*"]
+});
+/**
+ * Merge MCP server entries into an existing JSON config file.
+ * Creates the file (and parent dirs) if missing.
+ */
+export async function writeMcpServers(servers, opts) {
+    if (servers.length === 0)
+        return;
+    const key = opts.key ?? "mcpServers";
+    const transform = opts.transform ?? standardEntry;
+    const existing = await readJsonOrEmpty(opts.path);
+    const map = existing[key] ?? {};
+    for (const server of servers) {
+        map[server.ref] = transform(server);
+    }
+    const result = { ...(opts.defaults ?? {}), ...existing, [key]: map };
+    await writeJson(opts.path, result);
+}
+// ---------------------------------------------------------------------------
+// Instructions → flat rules file (windsurf, cline, roo-code)
+// ---------------------------------------------------------------------------
+/**
+ * Write instructions as a plain text rules file.
+ * Skips if no instructions.
+ */
+export async function writeRulesFile(instructions, path) {
+    if (instructions.length === 0)
+        return;
+    const lines = instructions.flatMap((i) => [i, ""]);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, lines.join("\n"), "utf-8");
+}
+/**
+ * Write an agent markdown file with YAML frontmatter.
+ * Shared by claude-code, copilot, and opencode.
+ */
+export async function writeAgentMd(config, opts) {
+    if (config.instructions.length === 0 && config.mcp_servers.length === 0)
+        return;
+    const fm = [
+        "---",
+        "name: ade",
+        "description: ADE — Agentic Development Environment agent with project conventions and tools"
+    ];
+    if (opts.extraFrontmatter) {
+        fm.push(...opts.extraFrontmatter);
+    }
+    fm.push("---");
+    const body = config.instructions.length > 0
+        ? config.instructions.join("\n\n")
+        : (opts.fallbackBody ?? "");
+    const content = fm.join("\n") + "\n\n" + body + "\n";
+    await mkdir(dirname(opts.path), { recursive: true });
+    await writeFile(opts.path, content, "utf-8");
+}
+// ---------------------------------------------------------------------------
+// Inline skill SKILL.md writer (used by claude-code)
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Git hook installer
+// ---------------------------------------------------------------------------
+/**
+ * Write git hook scripts to `.git/hooks/<phase>`.
+ * Files are created with executable permissions (0o755).
+ * No-op when the hooks array is empty.
+ */
+export async function writeGitHooks(hooks, projectRoot) {
+    if (!hooks)
+        return;
+    for (const hook of hooks) {
+        const hookPath = join(projectRoot, ".git", "hooks", hook.phase);
+        await writeFile(hookPath, hook.script, { mode: 0o755 });
+    }
+}
+export async function writeInlineSkills(config, projectRoot) {
+    for (const skill of config.skills) {
+        if (!("body" in skill))
+            continue;
+        const skillDir = join(projectRoot, ".ade", "skills", skill.name);
+        await mkdir(skillDir, { recursive: true });
+        const frontmatter = [
+            "---",
+            `name: ${skill.name}`,
+            `description: ${skill.description}`,
+            "---"
+        ].join("\n");
+        await writeFile(join(skillDir, "SKILL.md"), `${frontmatter}\n\n${skill.body}\n`, "utf-8");
+    }
+}

package/dist/writers/claude-code.d.ts

@@ -0,0 +1,2 @@
+import type { HarnessWriter } from "../types.js";
+export declare const claudeCodeWriter: HarnessWriter;

package/dist/writers/claude-code.js

@@ -0,0 +1,45 @@
+import { join } from "node:path";
+import { readJsonOrEmpty, writeJson, writeMcpServers, writeAgentMd, writeInlineSkills, writeGitHooks } from "../util.js";
+export const claudeCodeWriter = {
+    id: "claude-code",
+    label: "Claude Code",
+    description: "Anthropic's CLI agent — .claude/agents/ade.md + .mcp.json + .claude/settings.json",
+    async install(config, projectRoot) {
+        await writeAgentMd(config, {
+            path: join(projectRoot, ".claude", "agents", "ade.md"),
+            fallbackBody: "ADE — Agentic Development Environment agent."
+        });
+        await writeMcpServers(config.mcp_servers, {
+            path: join(projectRoot, ".mcp.json")
+        });
+        await writeClaudeSettings(config, projectRoot);
+        await writeInlineSkills(config, projectRoot);
+        await writeGitHooks(config.git_hooks, projectRoot);
+    }
+};
+async function writeClaudeSettings(config, projectRoot) {
+    const servers = config.mcp_servers;
+    if (servers.length === 0)
+        return;
+    const settingsPath = join(projectRoot, ".claude", "settings.json");
+    const existing = await readJsonOrEmpty(settingsPath);
+    const allowRules = [];
+    for (const server of servers) {
+        const allowed = server.allowedTools ?? ["*"];
+        if (allowed.includes("*")) {
+            allowRules.push(`MCP(${server.ref}:*)`);
+        }
+        else {
+            for (const tool of allowed) {
+                allowRules.push(`MCP(${server.ref}:${tool})`);
+            }
+        }
+    }
+    const existingPerms = existing.permissions ?? {};
+    const existingAllow = existingPerms.allow ?? [];
+    const mergedAllow = [...new Set([...existingAllow, ...allowRules])];
+    await writeJson(settingsPath, {
+        ...existing,
+        permissions: { ...existingPerms, allow: mergedAllow }
+    });
+}

package/dist/writers/cline.d.ts

@@ -0,0 +1,2 @@
+import type { HarnessWriter } from "../types.js";
+export declare const clineWriter: HarnessWriter;

package/dist/writers/cline.js

@@ -0,0 +1,15 @@
+import { join } from "node:path";
+import { writeMcpServers, alwaysAllowEntry, writeRulesFile, writeGitHooks } from "../util.js";
+export const clineWriter = {
+    id: "cline",
+    label: "Cline",
+    description: "VS Code AI agent — .cline/mcp.json + .clinerules",
+    async install(config, projectRoot) {
+        await writeMcpServers(config.mcp_servers, {
+            path: join(projectRoot, ".cline", "mcp.json"),
+            transform: alwaysAllowEntry
+        });
+        await writeRulesFile(config.instructions, join(projectRoot, ".clinerules"));
+        await writeGitHooks(config.git_hooks, projectRoot);
+    }
+};

package/dist/writers/copilot.d.ts

@@ -0,0 +1,2 @@
+import type { HarnessWriter } from "../types.js";
+export declare const copilotWriter: HarnessWriter;

package/dist/writers/copilot.js

@@ -0,0 +1,28 @@
+import { join } from "node:path";
+import { writeMcpServers, stdioEntry, writeAgentMd, writeGitHooks } from "../util.js";
+export const copilotWriter = {
+    id: "copilot",
+    label: "GitHub Copilot",
+    description: "VS Code + CLI — .vscode/mcp.json + .github/agents/ade.agent.md",
+    async install(config, projectRoot) {
+        await writeMcpServers(config.mcp_servers, {
+            path: join(projectRoot, ".vscode", "mcp.json"),
+            key: "servers",
+            transform: stdioEntry
+        });
+        const tools = [
+            "edit",
+            "search",
+            "runCommands",
+            "runTasks",
+            "fetch",
+            "githubRepo",
+            ...config.mcp_servers.map((s) => `${s.ref}/*`)
+        ];
+        await writeAgentMd(config, {
+            path: join(projectRoot, ".github", "agents", "ade.agent.md"),
+            extraFrontmatter: ["tools:", ...tools.map((t) => `  - ${t}`)]
+        });
+        await writeGitHooks(config.git_hooks, projectRoot);
+    }
+};

package/dist/writers/cursor.d.ts

@@ -0,0 +1,2 @@
+import type { HarnessWriter } from "../types.js";
+export declare const cursorWriter: HarnessWriter;

package/dist/writers/cursor.js

@@ -0,0 +1,27 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { writeMcpServers, writeGitHooks } from "../util.js";
+export const cursorWriter = {
+    id: "cursor",
+    label: "Cursor",
+    description: "AI code editor — .cursor/mcp.json + .cursor/rules/",
+    async install(config, projectRoot) {
+        await writeMcpServers(config.mcp_servers, {
+            path: join(projectRoot, ".cursor", "mcp.json")
+        });
+        if (config.instructions.length > 0) {
+            const rulesDir = join(projectRoot, ".cursor", "rules");
+            await mkdir(rulesDir, { recursive: true });
+            const content = [
+                "---",
+                "description: ADE project conventions",
+                "globs: *",
+                "---",
+                "",
+                ...config.instructions.flatMap((i) => [i, ""])
+            ].join("\n");
+            await writeFile(join(rulesDir, "ade.mdc"), content, "utf-8");
+        }
+        await writeGitHooks(config.git_hooks, projectRoot);
+    }
+};

package/dist/writers/kiro.d.ts

@@ -0,0 +1,2 @@
+import type { HarnessWriter } from "../types.js";
+export declare const kiroWriter: HarnessWriter;

package/dist/writers/kiro.js

@@ -0,0 +1,46 @@
+import { join } from "node:path";
+import { standardEntry, writeJson, writeGitHooks } from "../util.js";
+export const kiroWriter = {
+    id: "kiro",
+    label: "Kiro",
+    description: "AWS AI IDE — .kiro/agents/ade.json",
+    async install(config, projectRoot) {
+        const servers = config.mcp_servers;
+        if (servers.length > 0 || config.instructions.length > 0) {
+            const mcpServers = {};
+            for (const s of servers) {
+                mcpServers[s.ref] = standardEntry(s);
+            }
+            const tools = [
+                "execute_bash",
+                "fs_read",
+                "fs_write",
+                "knowledge",
+                "thinking",
+                ...Object.keys(mcpServers).map((n) => `@${n}`)
+            ];
+            const allowedTools = [];
+            for (const s of servers) {
+                const explicit = s.allowedTools;
+                if (explicit && !explicit.includes("*")) {
+                    for (const tool of explicit) {
+                        allowedTools.push(`@${s.ref}/${tool}`);
+                    }
+                }
+                else {
+                    allowedTools.push(`@${s.ref}/*`);
+                }
+            }
+            await writeJson(join(projectRoot, ".kiro", "agents", "ade.json"), {
+                name: "ade",
+                prompt: config.instructions.length > 0
+                    ? config.instructions.join("\n\n")
+                    : "ADE — Agentic Development Environment agent",
+                mcpServers,
+                tools,
+                allowedTools
+            });
+        }
+        await writeGitHooks(config.git_hooks, projectRoot);
+    }
+};

package/dist/writers/opencode.d.ts

@@ -0,0 +1,2 @@
+import type { HarnessWriter } from "../types.js";
+export declare const opencodeWriter: HarnessWriter;

package/dist/writers/opencode.js

@@ -0,0 +1,45 @@
+import { join } from "node:path";
+import { writeMcpServers, writeAgentMd, writeGitHooks } from "../util.js";
+export const opencodeWriter = {
+    id: "opencode",
+    label: "OpenCode",
+    description: "Terminal AI agent — opencode.json + .opencode/agents/",
+    async install(config, projectRoot) {
+        await writeMcpServers(config.mcp_servers, {
+            path: join(projectRoot, "opencode.json"),
+            key: "mcp",
+            transform: (s) => ({
+                type: "local",
+                command: [s.command, ...s.args],
+                ...(Object.keys(s.env).length > 0 ? { env: s.env } : {})
+            }),
+            defaults: { $schema: "https://opencode.ai/config.json" }
+        });
+        const servers = config.mcp_servers;
+        const extraFm = [
+            "tools:",
+            "  read: true",
+            "  edit: approve",
+            "  bash: approve"
+        ];
+        if (servers.length > 0) {
+            extraFm.push("mcp_servers:");
+            for (const s of servers) {
+                extraFm.push(`  ${s.ref}:`);
+                extraFm.push(`    command: [${[s.command, ...s.args].map((a) => `"${a}"`).join(", ")}]`);
+                if (Object.keys(s.env).length > 0) {
+                    extraFm.push("    env:");
+                    for (const [k, v] of Object.entries(s.env)) {
+                        extraFm.push(`      ${k}: "${v}"`);
+                    }
+                }
+            }
+        }
+        await writeAgentMd(config, {
+            path: join(projectRoot, ".opencode", "agents", "ade.md"),
+            extraFrontmatter: extraFm,
+            fallbackBody: "ADE — Agentic Development Environment agent with project conventions and tools."
+        });
+        await writeGitHooks(config.git_hooks, projectRoot);
+    }
+};

package/dist/writers/roo-code.d.ts

@@ -0,0 +1,2 @@
+import type { HarnessWriter } from "../types.js";
+export declare const rooCodeWriter: HarnessWriter;

package/dist/writers/roo-code.js

@@ -0,0 +1,15 @@
+import { join } from "node:path";
+import { writeMcpServers, alwaysAllowEntry, writeRulesFile, writeGitHooks } from "../util.js";
+export const rooCodeWriter = {
+    id: "roo-code",
+    label: "Roo Code",
+    description: "AI coding agent — .roo/mcp.json + .roorules",
+    async install(config, projectRoot) {
+        await writeMcpServers(config.mcp_servers, {
+            path: join(projectRoot, ".roo", "mcp.json"),
+            transform: alwaysAllowEntry
+        });
+        await writeRulesFile(config.instructions, join(projectRoot, ".roorules"));
+        await writeGitHooks(config.git_hooks, projectRoot);
+    }
+};

package/dist/writers/universal.d.ts

@@ -0,0 +1,2 @@
+import type { HarnessWriter } from "../types.js";
+export declare const universalWriter: HarnessWriter;