@codemcp/ade 0.2.0

package/packages/core/src/writers/workflows.spec.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect } from "vitest";
+import { workflowsWriter } from "./workflows.js";
+import type { ResolutionContext } from "../types.js";
+
+describe("workflowsWriter", () => {
+  const context: ResolutionContext = { resolved: {} };
+
+  it("has id 'workflows'", () => {
+    expect(workflowsWriter.id).toBe("workflows");
+  });
+
+  it("returns mcp_servers with correct ref, command, and args for a given package", async () => {
+    const result = await workflowsWriter.write(
+      { package: "@codemcp/workflows-server" },
+      context
+    );
+    expect(result).toEqual({
+      mcp_servers: [
+        {
+          ref: "@codemcp/workflows-server",
+          command: "npx",
+          args: ["@codemcp/workflows-server"],
+          env: {}
+        }
+      ]
+    });
+  });
+
+  it("uses ref override when provided", async () => {
+    const result = await workflowsWriter.write(
+      { package: "@codemcp/workflows-server@latest", ref: "workflows" },
+      context
+    );
+    expect(result.mcp_servers![0].ref).toBe("workflows");
+    expect(result.mcp_servers![0].args).toEqual([
+      "@codemcp/workflows-server@latest"
+    ]);
+  });
+
+  it("includes env in the entry when env is specified", async () => {
+    const result = await workflowsWriter.write(
+      {
+        package: "@codemcp/workflows-server",
+        env: { API_KEY: "secret", NODE_ENV: "production" }
+      },
+      context
+    );
+    expect(result.mcp_servers![0].env).toEqual({
+      API_KEY: "secret",
+      NODE_ENV: "production"
+    });
+  });
+
+  it("defaults env to an empty object when not specified", async () => {
+    const result = await workflowsWriter.write(
+      { package: "@codemcp/workflows-server" },
+      context
+    );
+    expect(result.mcp_servers![0].env).toEqual({});
+  });
+
+  it("only returns mcp_servers, not other LogicalConfig keys", async () => {
+    const result = await workflowsWriter.write(
+      { package: "@codemcp/workflows-server" },
+      context
+    );
+    expect(Object.keys(result)).toEqual(["mcp_servers"]);
+    expect(result).not.toHaveProperty("instructions");
+    expect(result).not.toHaveProperty("cli_actions");
+    expect(result).not.toHaveProperty("knowledge_sources");
+  });
+});

package/packages/core/src/writers/workflows.ts

@@ -0,0 +1,26 @@
+import type { ProvisionWriterDef } from "../types.js";
+
+export const workflowsWriter: ProvisionWriterDef = {
+  id: "workflows",
+  async write(config) {
+    const {
+      package: pkg,
+      ref,
+      env
+    } = config as {
+      package: string;
+      ref?: string;
+      env?: Record<string, string>;
+    };
+    return {
+      mcp_servers: [
+        {
+          ref: ref ?? pkg,
+          command: "npx",
+          args: [pkg],
+          env: env ?? {}
+        }
+      ]
+    };
+  }
+};

package/packages/core/tsconfig.build.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.build.json",
+  "compilerOptions": {
+    "outDir": "dist"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["**/*.spec.ts"]
+}

package/packages/core/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "baseUrl": "."
+  },
+  "include": ["src/**/*"]
+}

package/packages/core/tsconfig.vitest.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "moduleResolution": "bundler"
+  },
+  "include": ["vitest.config.ts"]
+}

package/packages/core/vitest.config.ts

@@ -0,0 +1,5 @@
+// @ts-check
+/** @type {import("vitest.config.ts").defineConfig} */
+
+const baseConfig = await import("../../vitest.config.js");
+export default baseConfig.default;

package/packages/harnesses/.prettierignore

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

package/packages/harnesses/eslint.config.mjs

@@ -0,0 +1,40 @@
+import js from "@eslint/js";
+import { parser, configs } from "typescript-eslint";
+import prettier from "eslint-config-prettier";
+
+export default [
+  js.configs.recommended,
+  ...configs.recommended,
+  prettier,
+  {
+    // Config for TypeScript files
+    files: ["**/*.{ts,tsx}"],
+    languageOptions: {
+      parser,
+      parserOptions: {
+        project: ["./tsconfig.json", "./tsconfig.vitest.json"]
+      }
+    }
+  },
+  {
+    // Config for JavaScript files - no TypeScript parsing
+    files: ["**/*.{js,jsx}"],
+    ...js.configs.recommended
+  },
+  {
+    // Relaxed rules for test files
+    files: ["**/*.test.ts", "**/*.spec.ts"],
+    rules: {
+      "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/no-unused-vars": "off"
+    }
+  },
+  {
+    ignores: [
+      "**/node_modules/**",
+      "**/dist/**",
+      ".pnpm-store/**",
+      "pnpm-lock.yaml"
+    ]
+  }
+];

package/packages/harnesses/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@codemcp/ade-harnesses",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "clean:build": "rimraf ./dist",
+    "dev": "nodemon",
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix .",
+    "format": "prettier --check .",
+    "format:fix": "prettier --write .",
+    "test": "vitest --run",
+    "test:watch": "vitest",
+    "typecheck": "tsc"
+  },
+  "dependencies": {
+    "@codemcp/ade-core": "workspace:*",
+    "@codemcp/skills": "^2.3.0"
+  },
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^8.21.0",
+    "@typescript-eslint/parser": "^8.21.0",
+    "eslint": "^9.18.0",
+    "eslint-config-prettier": "^10.0.1",
+    "prettier": "^3.4.2",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.7.3"
+  },
+  "version": "0.2.0"
+}

package/packages/harnesses/src/index.spec.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from "vitest";
+import { allHarnessWriters, getHarnessWriter, getHarnessIds } from "./index.js";
+
+describe("harness registry", () => {
+  it("exports all harness writers", () => {
+    expect(allHarnessWriters).toHaveLength(9);
+    const ids = allHarnessWriters.map((w) => w.id);
+    expect(ids).toContain("universal");
+    expect(ids).toContain("claude-code");
+    expect(ids).toContain("cursor");
+    expect(ids).toContain("copilot");
+    expect(ids).toContain("windsurf");
+    expect(ids).toContain("cline");
+    expect(ids).toContain("roo-code");
+    expect(ids).toContain("kiro");
+    expect(ids).toContain("opencode");
+  });
+
+  it("looks up harness by id", () => {
+    expect(getHarnessWriter("cursor")?.label).toBe("Cursor");
+    expect(getHarnessWriter("nonexistent")).toBeUndefined();
+  });
+
+  it("returns all harness ids", () => {
+    const ids = getHarnessIds();
+    expect(ids).toEqual([
+      "universal",
+      "claude-code",
+      "cursor",
+      "copilot",
+      "windsurf",
+      "cline",
+      "roo-code",
+      "kiro",
+      "opencode"
+    ]);
+  });
+
+  it("all writers have label and description", () => {
+    for (const w of allHarnessWriters) {
+      expect(w.label).toBeTruthy();
+      expect(w.description).toBeTruthy();
+    }
+  });
+});

package/packages/harnesses/src/index.ts

@@ -0,0 +1,47 @@
+export type { HarnessWriter } from "./types.js";
+export { installSkills } from "./skills-installer.js";
+export { writeInlineSkills } from "./util.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";
+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: HarnessWriter[] = [
+  universalWriter,
+  claudeCodeWriter,
+  cursorWriter,
+  copilotWriter,
+  windsurfWriter,
+  clineWriter,
+  rooCodeWriter,
+  kiroWriter,
+  opencodeWriter
+];
+
+/** Look up a harness writer by id. */
+export function getHarnessWriter(id: string): HarnessWriter | undefined {
+  return allHarnessWriters.find((w) => w.id === id);
+}
+
+/** All valid harness IDs. */
+export function getHarnessIds(): string[] {
+  return allHarnessWriters.map((w) => w.id);
+}

package/packages/harnesses/src/permission-policy.ts

@@ -0,0 +1,173 @@
+import type {
+  AutonomyCapability,
+  LogicalConfig,
+  PermissionDecision,
+  PermissionRule
+} from "@codemcp/ade-core";
+
+const SENSIBLE_DEFAULTS_RULES: Record<string, PermissionRule> = {
+  read: {
+    "*": "allow",
+    "*.env": "deny",
+    "*.env.*": "deny",
+    "*.env.example": "allow"
+  },
+  edit: "allow",
+  glob: "allow",
+  grep: "allow",
+  list: "allow",
+  lsp: "allow",
+  task: "allow",
+  todoread: "deny",
+  todowrite: "deny",
+  skill: "deny",
+  webfetch: "ask",
+  websearch: "ask",
+  codesearch: "ask",
+  bash: {
+    "*": "deny",
+    "grep *": "allow",
+    "rg *": "allow",
+    "find *": "allow",
+    "fd *": "allow",
+    ls: "allow",
+    "ls *": "allow",
+    "cat *": "allow",
+    "head *": "allow",
+    "tail *": "allow",
+    "wc *": "allow",
+    "sort *": "allow",
+    "uniq *": "allow",
+    "diff *": "allow",
+    "echo *": "allow",
+    "printf *": "allow",
+    pwd: "allow",
+    "which *": "allow",
+    "type *": "allow",
+    whoami: "allow",
+    date: "allow",
+    "date *": "allow",
+    env: "allow",
+    "tree *": "allow",
+    "file *": "allow",
+    "stat *": "allow",
+    "readlink *": "allow",
+    "realpath *": "allow",
+    "dirname *": "allow",
+    "basename *": "allow",
+    "sed *": "allow",
+    "awk *": "allow",
+    "cut *": "allow",
+    "tr *": "allow",
+    "tee *": "allow",
+    "xargs *": "allow",
+    "jq *": "allow",
+    "yq *": "allow",
+    "mkdir *": "allow",
+    "touch *": "allow",
+    "cp *": "ask",
+    "mv *": "ask",
+    "ln *": "ask",
+    "npm *": "ask",
+    "node *": "ask",
+    "pip *": "ask",
+    "python *": "ask",
+    "python3 *": "ask",
+    "rm *": "deny",
+    "rmdir *": "deny",
+    "curl *": "deny",
+    "wget *": "deny",
+    "chmod *": "deny",
+    "chown *": "deny",
+    "sudo *": "deny",
+    "su *": "deny",
+    "sh *": "deny",
+    "bash *": "deny",
+    "zsh *": "deny",
+    "eval *": "deny",
+    "exec *": "deny",
+    "source *": "deny",
+    ". *": "deny",
+    "nohup *": "deny",
+    "dd *": "deny",
+    "mkfs *": "deny",
+    "mount *": "deny",
+    "umount *": "deny",
+    "kill *": "deny",
+    "killall *": "deny",
+    "pkill *": "deny",
+    "nc *": "deny",
+    "ncat *": "deny",
+    "ssh *": "deny",
+    "scp *": "deny",
+    "rsync *": "deny",
+    "docker *": "deny",
+    "kubectl *": "deny",
+    "systemctl *": "deny",
+    "service *": "deny",
+    "crontab *": "deny",
+    reboot: "deny",
+    "shutdown *": "deny",
+    "passwd *": "deny",
+    "useradd *": "deny",
+    "userdel *": "deny",
+    "iptables *": "deny"
+  },
+  external_directory: "deny",
+  doom_loop: "deny"
+};
+
+export function getAutonomyProfile(config: LogicalConfig) {
+  return config.permission_policy?.profile;
+}
+
+export function hasPermissionPolicy(config: LogicalConfig): boolean {
+  return config.permission_policy !== undefined;
+}
+
+export function getCapabilityDecision(
+  config: LogicalConfig,
+  capability: AutonomyCapability
+): PermissionDecision | undefined {
+  return config.permission_policy?.capabilities?.[capability];
+}
+
+export function allowsCapability(
+  config: LogicalConfig,
+  capability: AutonomyCapability
+): boolean {
+  return getCapabilityDecision(config, capability) === "allow";
+}
+
+export function keepsWebOnAsk(config: LogicalConfig): boolean {
+  return getCapabilityDecision(config, "web") === "ask";
+}
+
+export function getHarnessPermissionRules(
+  config: LogicalConfig
+): Record<string, PermissionRule> | undefined {
+  switch (config.permission_policy?.profile) {
+    case "rigid":
+      return {
+        "*": "ask",
+        webfetch: "ask",
+        websearch: "ask",
+        codesearch: "ask",
+        external_directory: "deny",
+        doom_loop: "deny"
+      };
+    case "sensible-defaults":
+      return SENSIBLE_DEFAULTS_RULES;
+    case "max-autonomy":
+      return {
+        "*": "allow",
+        webfetch: "ask",
+        websearch: "ask",
+        codesearch: "ask",
+        external_directory: "deny",
+        doom_loop: "deny"
+      };
+    default:
+      return undefined;
+  }
+}

package/packages/harnesses/src/skills-installer.ts

@@ -0,0 +1,54 @@
+import { join } from "node:path";
+import type { SkillDefinition, InlineSkill } from "@codemcp/ade-core";
+import { runAdd } from "@codemcp/skills/api";
+
+function isInlineSkill(skill: SkillDefinition): skill is InlineSkill {
+  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: SkillDefinition[],
+  projectRoot: string
+): Promise<void> {
+  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/packages/harnesses/src/types.ts

@@ -0,0 +1,12 @@
+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;
+}