@codemcp/ade-harnesses 0.0.2

package/src/writers/claude-code.ts

@@ -0,0 +1,64 @@
+import { join } from "node:path";
+import type { LogicalConfig } from "@codemcp/ade-core";
+import type { HarnessWriter } from "../types.js";
+import {
+  readJsonOrEmpty,
+  writeJson,
+  writeMcpServers,
+  writeAgentMd,
+  writeInlineSkills,
+  writeGitHooks
+} from "../util.js";
+
+export const claudeCodeWriter: HarnessWriter = {
+  id: "claude-code",
+  label: "Claude Code",
+  description:
+    "Anthropic's CLI agent — .claude/agents/ade.md + .mcp.json + .claude/settings.json",
+  async install(config: LogicalConfig, projectRoot: string) {
+    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: LogicalConfig,
+  projectRoot: string
+): Promise<void> {
+  const servers = config.mcp_servers;
+  if (servers.length === 0) return;
+
+  const settingsPath = join(projectRoot, ".claude", "settings.json");
+  const existing = await readJsonOrEmpty(settingsPath);
+
+  const allowRules: string[] = [];
+  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 as Record<string, unknown>) ?? {};
+  const existingAllow = (existingPerms.allow as string[]) ?? [];
+  const mergedAllow = [...new Set([...existingAllow, ...allowRules])];
+
+  await writeJson(settingsPath, {
+    ...existing,
+    permissions: { ...existingPerms, allow: mergedAllow }
+  });
+}

package/src/writers/cline.spec.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, rm, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { LogicalConfig } from "@codemcp/ade-core";
+import { clineWriter } from "./cline.js";
+
+describe("clineWriter", () => {
+  let dir: string;
+
+  beforeEach(async () => {
+    dir = await mkdtemp(join(tmpdir(), "ade-harness-cline-"));
+  });
+
+  afterEach(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  it("has correct metadata", () => {
+    expect(clineWriter.id).toBe("cline");
+    expect(clineWriter.label).toBe("Cline");
+  });
+
+  it("writes .cline/mcp.json with MCP servers", async () => {
+    const config: LogicalConfig = {
+      mcp_servers: [
+        {
+          ref: "workflows",
+          command: "npx",
+          args: ["-y", "@codemcp/workflows"],
+          env: {}
+        }
+      ],
+      instructions: [],
+      cli_actions: [],
+      knowledge_sources: [],
+      skills: [],
+      git_hooks: [],
+      setup_notes: []
+    };
+
+    await clineWriter.install(config, dir);
+
+    const raw = await readFile(join(dir, ".cline", "mcp.json"), "utf-8");
+    const parsed = JSON.parse(raw);
+    expect(parsed.mcpServers["workflows"]).toEqual({
+      command: "npx",
+      args: ["-y", "@codemcp/workflows"],
+      alwaysAllow: ["*"]
+    });
+  });
+
+  it("writes .clinerules with instructions", async () => {
+    const config: LogicalConfig = {
+      mcp_servers: [],
+      instructions: ["Follow TDD."],
+      cli_actions: [],
+      knowledge_sources: [],
+      skills: [],
+      git_hooks: [],
+      setup_notes: []
+    };
+
+    await clineWriter.install(config, dir);
+
+    const content = await readFile(join(dir, ".clinerules"), "utf-8");
+    expect(content).toContain("Follow TDD.");
+  });
+});

package/src/writers/cline.ts

@@ -0,0 +1,24 @@
+import { join } from "node:path";
+import type { LogicalConfig } from "@codemcp/ade-core";
+import type { HarnessWriter } from "../types.js";
+import {
+  writeMcpServers,
+  alwaysAllowEntry,
+  writeRulesFile,
+  writeGitHooks
+} from "../util.js";
+
+export const clineWriter: HarnessWriter = {
+  id: "cline",
+  label: "Cline",
+  description: "VS Code AI agent — .cline/mcp.json + .clinerules",
+  async install(config: LogicalConfig, projectRoot: string) {
+    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/src/writers/copilot.spec.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, rm, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { LogicalConfig } from "@codemcp/ade-core";
+import { copilotWriter } from "./copilot.js";
+
+describe("copilotWriter", () => {
+  let dir: string;
+
+  beforeEach(async () => {
+    dir = await mkdtemp(join(tmpdir(), "ade-harness-copilot-"));
+  });
+
+  afterEach(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  it("has correct metadata", () => {
+    expect(copilotWriter.id).toBe("copilot");
+    expect(copilotWriter.label).toBe("GitHub Copilot");
+  });
+
+  it("writes .vscode/mcp.json with 'servers' key and type field", async () => {
+    const config: LogicalConfig = {
+      mcp_servers: [
+        {
+          ref: "workflows",
+          command: "npx",
+          args: ["-y", "@codemcp/workflows"],
+          env: {}
+        }
+      ],
+      instructions: [],
+      cli_actions: [],
+      knowledge_sources: [],
+      skills: [],
+      git_hooks: [],
+      setup_notes: []
+    };
+
+    await copilotWriter.install(config, dir);
+
+    const raw = await readFile(join(dir, ".vscode", "mcp.json"), "utf-8");
+    const parsed = JSON.parse(raw);
+    // Copilot uses "servers", not "mcpServers"
+    expect(parsed.servers["workflows"]).toEqual({
+      type: "stdio",
+      command: "npx",
+      args: ["-y", "@codemcp/workflows"]
+    });
+  });
+
+  it("does not write copilot-instructions.md (prefers agent definition)", async () => {
+    const config: LogicalConfig = {
+      mcp_servers: [],
+      instructions: ["Follow TDD."],
+      cli_actions: [],
+      knowledge_sources: [],
+      skills: [],
+      git_hooks: [],
+      setup_notes: []
+    };
+
+    await copilotWriter.install(config, dir);
+
+    await expect(
+      readFile(join(dir, ".github", "copilot-instructions.md"), "utf-8")
+    ).rejects.toThrow();
+  });
+
+  it("writes dedicated .github/agents/ade.agent.md with agent definition", async () => {
+    const config: LogicalConfig = {
+      mcp_servers: [
+        {
+          ref: "workflows",
+          command: "npx",
+          args: ["-y", "@codemcp/workflows"],
+          env: {}
+        }
+      ],
+      instructions: ["Follow TDD."],
+      cli_actions: [],
+      knowledge_sources: [],
+      skills: [],
+      git_hooks: [],
+      setup_notes: []
+    };
+
+    await copilotWriter.install(config, dir);
+
+    const content = await readFile(
+      join(dir, ".github", "agents", "ade.agent.md"),
+      "utf-8"
+    );
+    expect(content).toContain("name: ade");
+    expect(content).toContain("tools:");
+    expect(content).toContain("  - workflows/*");
+    expect(content).toContain("  - edit");
+    expect(content).toContain("Follow TDD.");
+  });
+});

package/src/writers/copilot.ts

@@ -0,0 +1,38 @@
+import { join } from "node:path";
+import type { LogicalConfig } from "@codemcp/ade-core";
+import type { HarnessWriter } from "../types.js";
+import {
+  writeMcpServers,
+  stdioEntry,
+  writeAgentMd,
+  writeGitHooks
+} from "../util.js";
+
+export const copilotWriter: HarnessWriter = {
+  id: "copilot",
+  label: "GitHub Copilot",
+  description: "VS Code + CLI — .vscode/mcp.json + .github/agents/ade.agent.md",
+  async install(config: LogicalConfig, projectRoot: string) {
+    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/src/writers/cursor.spec.ts

@@ -0,0 +1,116 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, rm, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { LogicalConfig } from "@codemcp/ade-core";
+import { cursorWriter } from "./cursor.js";
+
+describe("cursorWriter", () => {
+  let dir: string;
+
+  beforeEach(async () => {
+    dir = await mkdtemp(join(tmpdir(), "ade-harness-cursor-"));
+  });
+
+  afterEach(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  it("has correct metadata", () => {
+    expect(cursorWriter.id).toBe("cursor");
+    expect(cursorWriter.label).toBe("Cursor");
+  });
+
+  it("writes .cursor/mcp.json with MCP servers", async () => {
+    const config: LogicalConfig = {
+      mcp_servers: [
+        {
+          ref: "workflows",
+          command: "npx",
+          args: ["-y", "@codemcp/workflows"],
+          env: {}
+        }
+      ],
+      instructions: [],
+      cli_actions: [],
+      knowledge_sources: [],
+      skills: [],
+      git_hooks: [],
+      setup_notes: []
+    };
+
+    await cursorWriter.install(config, dir);
+
+    const raw = await readFile(join(dir, ".cursor", "mcp.json"), "utf-8");
+    const parsed = JSON.parse(raw);
+    expect(parsed.mcpServers["workflows"]).toEqual({
+      command: "npx",
+      args: ["-y", "@codemcp/workflows"]
+    });
+  });
+
+  it("writes .cursor/rules/ade.mdc with instructions", async () => {
+    const config: LogicalConfig = {
+      mcp_servers: [],
+      instructions: ["Follow TDD.", "Use conventional commits."],
+      cli_actions: [],
+      knowledge_sources: [],
+      skills: [],
+      git_hooks: [],
+      setup_notes: []
+    };
+
+    await cursorWriter.install(config, dir);
+
+    const content = await readFile(
+      join(dir, ".cursor", "rules", "ade.mdc"),
+      "utf-8"
+    );
+    expect(content).toContain("description: ADE project conventions");
+    expect(content).toContain("Follow TDD.");
+    expect(content).toContain("Use conventional commits.");
+  });
+
+  it("includes agentskills server from mcp_servers", async () => {
+    const config: LogicalConfig = {
+      mcp_servers: [
+        {
+          ref: "agentskills",
+          command: "npx",
+          args: ["-y", "@codemcp/skills-server"],
+          env: {}
+        }
+      ],
+      instructions: [],
+      cli_actions: [],
+      knowledge_sources: [],
+      skills: [{ name: "my-skill", description: "A skill", body: "content" }],
+      git_hooks: [],
+      setup_notes: []
+    };
+
+    await cursorWriter.install(config, dir);
+
+    const raw = await readFile(join(dir, ".cursor", "mcp.json"), "utf-8");
+    const parsed = JSON.parse(raw);
+    expect(parsed.mcpServers["agentskills"]).toBeDefined();
+  });
+
+  it("skips mcp.json when no servers and no skills", async () => {
+    const config: LogicalConfig = {
+      mcp_servers: [],
+      instructions: ["hello"],
+      cli_actions: [],
+      knowledge_sources: [],
+      skills: [],
+      git_hooks: [],
+      setup_notes: []
+    };
+
+    await cursorWriter.install(config, dir);
+
+    await expect(
+      readFile(join(dir, ".cursor", "mcp.json"), "utf-8")
+    ).rejects.toThrow();
+  });
+});

package/src/writers/cursor.ts

@@ -0,0 +1,33 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { LogicalConfig } from "@codemcp/ade-core";
+import type { HarnessWriter } from "../types.js";
+import { writeMcpServers, writeGitHooks } from "../util.js";
+
+export const cursorWriter: HarnessWriter = {
+  id: "cursor",
+  label: "Cursor",
+  description: "AI code editor — .cursor/mcp.json + .cursor/rules/",
+  async install(config: LogicalConfig, projectRoot: string) {
+    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/src/writers/kiro.ts

@@ -0,0 +1,52 @@
+import { join } from "node:path";
+import type { LogicalConfig } from "@codemcp/ade-core";
+import type { HarnessWriter } from "../types.js";
+import { standardEntry, writeJson, writeGitHooks } from "../util.js";
+
+export const kiroWriter: HarnessWriter = {
+  id: "kiro",
+  label: "Kiro",
+  description: "AWS AI IDE — .kiro/agents/ade.json",
+  async install(config: LogicalConfig, projectRoot: string) {
+    const servers = config.mcp_servers;
+    if (servers.length > 0 || config.instructions.length > 0) {
+      const mcpServers: Record<string, unknown> = {};
+      for (const s of servers) {
+        mcpServers[s.ref] = standardEntry(s);
+      }
+
+      const tools: string[] = [
+        "execute_bash",
+        "fs_read",
+        "fs_write",
+        "knowledge",
+        "thinking",
+        ...Object.keys(mcpServers).map((n) => `@${n}`)
+      ];
+
+      const allowedTools: string[] = [];
+      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/src/writers/opencode.ts

@@ -0,0 +1,54 @@
+import { join } from "node:path";
+import type { LogicalConfig } from "@codemcp/ade-core";
+import type { HarnessWriter } from "../types.js";
+import { writeMcpServers, writeAgentMd, writeGitHooks } from "../util.js";
+
+export const opencodeWriter: HarnessWriter = {
+  id: "opencode",
+  label: "OpenCode",
+  description: "Terminal AI agent — opencode.json + .opencode/agents/",
+  async install(config: LogicalConfig, projectRoot: string) {
+    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: string[] = [
+      "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/src/writers/roo-code.spec.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, rm, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { LogicalConfig } from "@codemcp/ade-core";
+import { rooCodeWriter } from "./roo-code.js";
+
+describe("rooCodeWriter", () => {
+  let dir: string;
+
+  beforeEach(async () => {
+    dir = await mkdtemp(join(tmpdir(), "ade-harness-roo-"));
+  });
+
+  afterEach(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  it("has correct metadata", () => {
+    expect(rooCodeWriter.id).toBe("roo-code");
+    expect(rooCodeWriter.label).toBe("Roo Code");
+  });
+
+  it("writes .roo/mcp.json with MCP servers", async () => {
+    const config: LogicalConfig = {
+      mcp_servers: [
+        {
+          ref: "workflows",
+          command: "npx",
+          args: ["-y", "@codemcp/workflows"],
+          env: {}
+        }
+      ],
+      instructions: [],
+      cli_actions: [],
+      knowledge_sources: [],
+      skills: [],
+      git_hooks: [],
+      setup_notes: []
+    };
+
+    await rooCodeWriter.install(config, dir);
+
+    const raw = await readFile(join(dir, ".roo", "mcp.json"), "utf-8");
+    const parsed = JSON.parse(raw);
+    expect(parsed.mcpServers["workflows"]).toEqual({
+      command: "npx",
+      args: ["-y", "@codemcp/workflows"],
+      alwaysAllow: ["*"]
+    });
+  });
+
+  it("writes .roorules with instructions", async () => {
+    const config: LogicalConfig = {
+      mcp_servers: [],
+      instructions: ["Follow TDD."],
+      cli_actions: [],
+      knowledge_sources: [],
+      skills: [],
+      git_hooks: [],
+      setup_notes: []
+    };
+
+    await rooCodeWriter.install(config, dir);
+
+    const content = await readFile(join(dir, ".roorules"), "utf-8");
+    expect(content).toContain("Follow TDD.");
+  });
+});

package/src/writers/roo-code.ts

@@ -0,0 +1,24 @@
+import { join } from "node:path";
+import type { LogicalConfig } from "@codemcp/ade-core";
+import type { HarnessWriter } from "../types.js";
+import {
+  writeMcpServers,
+  alwaysAllowEntry,
+  writeRulesFile,
+  writeGitHooks
+} from "../util.js";
+
+export const rooCodeWriter: HarnessWriter = {
+  id: "roo-code",
+  label: "Roo Code",
+  description: "AI coding agent — .roo/mcp.json + .roorules",
+  async install(config: LogicalConfig, projectRoot: string) {
+    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/src/writers/universal.ts

@@ -0,0 +1,31 @@
+import { join } from "node:path";
+import { writeFile } from "node:fs/promises";
+import type { LogicalConfig } from "@codemcp/ade-core";
+import type { HarnessWriter } from "../types.js";
+import { writeMcpServers, writeGitHooks } from "../util.js";
+
+export const universalWriter: HarnessWriter = {
+  id: "universal",
+  label: "Universal (AGENTS.md + .mcp.json)",
+  description:
+    "Cross-tool standard — AGENTS.md + .mcp.json (works with any agent)",
+  async install(config: LogicalConfig, projectRoot: string) {
+    if (config.instructions.length > 0) {
+      const lines = [
+        "# AGENTS",
+        "",
+        ...config.instructions.flatMap((i) => [i, ""])
+      ];
+      await writeFile(
+        join(projectRoot, "AGENTS.md"),
+        lines.join("\n"),
+        "utf-8"
+      );
+    }
+
+    await writeMcpServers(config.mcp_servers, {
+      path: join(projectRoot, ".mcp.json")
+    });
+    await writeGitHooks(config.git_hooks, projectRoot);
+  }
+};