@agentoryhq/adapter-claude-code 0.1.1

package/dist/align.d.ts

@@ -0,0 +1,8 @@
+import type { ApplyAlignOpts, ApplyAlignResult } from "@agentoryhq/runtime-contract";
+/**
+ * Write confirmed align patch to Claude Code project files.
+ * - MCP → project root `.mcp.json`
+ * - Skills name list → `.claude/agentory-skills.json` (tracking; does not install skill bodies)
+ * Snapshots prior `.mcp.json` under `.claude/agentory-snapshots/`.
+ */
+export declare function applyAlignPatch(opts: ApplyAlignOpts): ApplyAlignResult;

package/dist/align.js

@@ -0,0 +1,69 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Write confirmed align patch to Claude Code project files.
+ * - MCP → project root `.mcp.json`
+ * - Skills name list → `.claude/agentory-skills.json` (tracking; does not install skill bodies)
+ * Snapshots prior `.mcp.json` under `.claude/agentory-snapshots/`.
+ */
+export function applyAlignPatch(opts) {
+    const mcpPath = path.join(opts.projectRoot, ".mcp.json");
+    const skillsPath = path.join(opts.projectRoot, ".claude", "agentory-skills.json");
+    if (!opts.confirmed) {
+        return {
+            ok: false,
+            error: "refusing write: align not confirmed",
+            mcpPath,
+            skillsPath,
+        };
+    }
+    const claudeDir = path.join(opts.projectRoot, ".claude");
+    fs.mkdirSync(claudeDir, { recursive: true });
+    let snapshotPath;
+    let priorMcp;
+    try {
+        if (fs.existsSync(mcpPath)) {
+            priorMcp = fs.readFileSync(mcpPath, "utf8");
+            const snapDir = path.join(claudeDir, "agentory-snapshots");
+            fs.mkdirSync(snapDir, { recursive: true });
+            snapshotPath = path.join(snapDir, `mcp-${Date.now()}.json`);
+            fs.writeFileSync(snapshotPath, priorMcp, "utf8");
+        }
+        const mcpServers = {};
+        for (const item of opts.patch.mcp) {
+            const command = item.command?.trim() || "echo";
+            if (/^https?:\/\//i.test(command)) {
+                mcpServers[item.name] = { type: "http", url: command };
+                continue;
+            }
+            const parts = command.split(/\s+/);
+            mcpServers[item.name] = {
+                command: parts[0] ?? "echo",
+                args: parts.length > 1 ? parts.slice(1) : undefined,
+            };
+        }
+        const mcpBody = JSON.stringify({ mcpServers }, null, 2);
+        const skillsBody = JSON.stringify({ skills: opts.patch.skills }, null, 2);
+        fs.writeFileSync(mcpPath, `${mcpBody}\n`, "utf8");
+        try {
+            fs.writeFileSync(skillsPath, `${skillsBody}\n`, "utf8");
+        }
+        catch (err) {
+            if (priorMcp !== undefined)
+                fs.writeFileSync(mcpPath, priorMcp, "utf8");
+            else if (fs.existsSync(mcpPath))
+                fs.unlinkSync(mcpPath);
+            throw err;
+        }
+        return { ok: true, mcpPath, skillsPath, snapshotPath };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+            mcpPath,
+            skillsPath,
+            snapshotPath,
+        };
+    }
+}

package/dist/discover.d.ts

@@ -0,0 +1,9 @@
+import type { AdapterContext } from "@agentoryhq/runtime-contract";
+import type { DiscoveredAgent, LiveMcpBinding } from "@agentoryhq/shared";
+/** Parse mcpServers map (project `.mcp.json` or user `~/.claude.json`). */
+export declare function mcpFromClaudeConfig(raw: unknown): LiveMcpBinding[];
+export declare function detectClaudeCode(ctx: AdapterContext): boolean;
+/**
+ * Prefer project `.mcp.json`; else user-scope `mcpServers` in `~/.claude.json`.
+ */
+export declare function discoverClaudeCodeConfig(ctx: AdapterContext): DiscoveredAgent | null;

package/dist/discover.js

@@ -0,0 +1,87 @@
+import fs from "node:fs";
+import path from "node:path";
+function readJsonFile(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Parse mcpServers map (project `.mcp.json` or user `~/.claude.json`). */
+export function mcpFromClaudeConfig(raw) {
+    if (typeof raw !== "object" || raw === null)
+        return [];
+    const servers = raw.mcpServers;
+    if (typeof servers !== "object" || servers === null)
+        return [];
+    const out = [];
+    for (const [name, cfg] of Object.entries(servers)) {
+        if (!name)
+            continue;
+        let command;
+        if (typeof cfg === "object" && cfg !== null) {
+            const c = cfg;
+            if (typeof c.command === "string") {
+                const args = Array.isArray(c.args) ? c.args.map(String).join(" ") : "";
+                command = args ? `${c.command} ${args}` : c.command;
+            }
+            else if (typeof c.url === "string") {
+                command = c.url;
+            }
+        }
+        out.push({ name, command, status: "unknown" });
+    }
+    return out;
+}
+function skillsFromSkillsRoot(dir) {
+    try {
+        return fs
+            .readdirSync(dir, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => d.name);
+    }
+    catch {
+        return [];
+    }
+}
+export function detectClaudeCode(ctx) {
+    const markers = [
+        path.join(ctx.cwd, ".claude"),
+        path.join(ctx.homeDir, ".claude"),
+        path.join(ctx.cwd, ".mcp.json"),
+        path.join(ctx.homeDir, ".claude.json"),
+    ];
+    return markers.some((p) => fs.existsSync(p));
+}
+/**
+ * Prefer project `.mcp.json`; else user-scope `mcpServers` in `~/.claude.json`.
+ */
+export function discoverClaudeCodeConfig(ctx) {
+    if (!detectClaudeCode(ctx))
+        return null;
+    const projectMcp = path.join(ctx.cwd, ".mcp.json");
+    const userClaudeJson = path.join(ctx.homeDir, ".claude.json");
+    let mcp = [];
+    if (fs.existsSync(projectMcp)) {
+        mcp = mcpFromClaudeConfig(readJsonFile(projectMcp));
+    }
+    else if (fs.existsSync(userClaudeJson)) {
+        mcp = mcpFromClaudeConfig(readJsonFile(userClaudeJson));
+    }
+    const skillNames = new Set();
+    for (const d of [
+        path.join(ctx.cwd, ".claude", "skills"),
+        path.join(ctx.homeDir, ".claude", "skills"),
+    ]) {
+        for (const name of skillsFromSkillsRoot(d))
+            skillNames.add(name);
+    }
+    return {
+        runtime: "claude-code",
+        supported: true,
+        displayName: `Claude Code · ${path.basename(ctx.cwd) || "workspace"}`,
+        mcp,
+        skills: [...skillNames],
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeAdapter } from "@agentoryhq/runtime-contract";
+export { applyAlignPatch } from "./align.js";
+export { detectClaudeCode, discoverClaudeCodeConfig, mcpFromClaudeConfig } from "./discover.js";
+export declare const claudeCodeAdapter: RuntimeAdapter;

package/dist/index.js

@@ -0,0 +1,16 @@
+import { ADAPTER_API_VERSION } from "@agentoryhq/runtime-contract";
+import { applyAlignPatch } from "./align.js";
+import { detectClaudeCode, discoverClaudeCodeConfig } from "./discover.js";
+export { applyAlignPatch } from "./align.js";
+export { detectClaudeCode, discoverClaudeCodeConfig, mcpFromClaudeConfig } from "./discover.js";
+export const claudeCodeAdapter = {
+    manifest: {
+        runtime: "claude-code",
+        adapterApi: ADAPTER_API_VERSION,
+        displayName: "Claude Code",
+        capabilities: ["detect", "discoverConfig", "applyAlign"],
+    },
+    detect: detectClaudeCode,
+    discoverConfig: discoverClaudeCodeConfig,
+    applyAlign: applyAlignPatch,
+};

package/dist/index.test.d.ts

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

package/dist/index.test.js

@@ -0,0 +1,60 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { test } from "node:test";
+import { applyAlignPatch, discoverClaudeCodeConfig } from "./index.js";
+test("discoverClaudeCodeConfig reads project .mcp.json and skills", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "agy-claude-d-"));
+    const home = path.join(root, "home");
+    const cwd = path.join(root, "proj");
+    fs.mkdirSync(cwd, { recursive: true });
+    fs.mkdirSync(home, { recursive: true });
+    fs.writeFileSync(path.join(cwd, ".mcp.json"), JSON.stringify({
+        mcpServers: {
+            docs: { type: "http", url: "https://example.com/mcp" },
+            local: { command: "npx", args: ["-y", "svc"] },
+        },
+    }));
+    fs.mkdirSync(path.join(cwd, ".claude", "skills", "brief"), { recursive: true });
+    fs.writeFileSync(path.join(cwd, ".claude", "skills", "brief", "SKILL.md"), "# x\n");
+    const agent = discoverClaudeCodeConfig({ homeDir: home, cwd });
+    assert.ok(agent);
+    assert.equal(agent.supported, true);
+    assert.equal(agent.runtime, "claude-code");
+    assert.equal(agent.mcp.length, 2);
+    assert.ok(agent.mcp.find((m) => m.name === "docs" && m.command === "https://example.com/mcp"));
+    assert.ok(agent.mcp.find((m) => m.name === "local" && m.command?.includes("npx")));
+    assert.ok(agent.skills.includes("brief"));
+});
+test("applyAlignPatch Claude refuses unconfirmed; writes .mcp.json on confirm", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "agy-claude-a-"));
+    fs.writeFileSync(path.join(root, ".mcp.json"), JSON.stringify({ mcpServers: { a: { command: "old" } } }));
+    const denied = applyAlignPatch({
+        projectRoot: root,
+        patch: { mcp: [{ name: "a", command: "npx new" }], skills: ["s1"] },
+        confirmed: false,
+    });
+    assert.equal(denied.ok, false);
+    assert.match(fs.readFileSync(path.join(root, ".mcp.json"), "utf8"), /old/);
+    const ok = applyAlignPatch({
+        projectRoot: root,
+        patch: {
+            mcp: [
+                { name: "a", command: "npx new" },
+                { name: "remote", command: "https://mcp.example/x" },
+            ],
+            skills: ["s1"],
+        },
+        confirmed: true,
+    });
+    assert.equal(ok.ok, true);
+    assert.ok(ok.snapshotPath && fs.existsSync(ok.snapshotPath));
+    const after = JSON.parse(fs.readFileSync(path.join(root, ".mcp.json"), "utf8"));
+    assert.equal(after.mcpServers.a.command, "npx");
+    assert.deepEqual(after.mcpServers.a.args, ["new"]);
+    assert.equal(after.mcpServers.remote.type, "http");
+    assert.equal(after.mcpServers.remote.url, "https://mcp.example/x");
+    const skills = JSON.parse(fs.readFileSync(path.join(root, ".claude", "agentory-skills.json"), "utf8"));
+    assert.deepEqual(skills.skills, ["s1"]);
+});

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@agentoryhq/adapter-claude-code",
+  "version": "0.1.1",
+  "description": "Agentory RuntimeAdapter for Claude Code",
+  "license": "Apache-2.0",
+  "type": "module",
+  "files": ["dist"],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@agentoryhq/runtime-contract": "*",
+    "@agentoryhq/shared": "*"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tunsuy/agentory-node.git",
+    "directory": "adapters/claude-code"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}