@felixdotgo/aidlc-kit 0.0.1

package/dist/src/installer.js

@@ -0,0 +1,173 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { adapters, findAdapter, installableAdapters, resolvedAdapters } from "./adapters.js";
+import { loadProjectConfig } from "./profiles.js";
+import { loadState } from "./state.js";
+import { planProjectLayoutMigration } from "./project-migration.js";
+import { managedBlock, mergeManagedBlock } from "./managed-content.js";
+import { resolveProjectPathWithoutSymlinks } from "./project-path.js";
+import { contentHash, coreWorkflowFiles, initialProjectFiles, manifestSpec, packageVersion } from "./workflow.js";
+const shortHash = (content) => contentHash(content).slice(0, 12);
+const safeTarget = (root, path) => resolveProjectPathWithoutSymlinks(root, path, "Managed path escapes the project", "Managed path crosses a symlink");
+export const managedContentHash = (spec, content) => {
+    const managed = managedBlock(spec, content);
+    return managed === undefined ? undefined : contentHash(managed);
+};
+export const readManifest = (root) => {
+    const path = join(resolve(root), ".agents/aidlc/manifest.json");
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const value = JSON.parse(readFileSync(path, "utf8"));
+        const validFiles = value.files && typeof value.files === "object" && !Array.isArray(value.files) && Object.values(value.files).every((item) => item && typeof item.hash === "string" && typeof item.owner === "string" && ["replace", "managed-block"].includes(item.strategy));
+        return value.schemaVersion === 2 && typeof value.packageVersion === "string" && value.workflow === "AI-DLC" && value.source === "local-package-assets" && value.remoteUpdates === false && value.managedBy === "aidlc-workflow" && Array.isArray(value.adapters) && validFiles ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+export const detectedAgents = (root) => installableAdapters().filter((adapter) => adapter.detect(root)).map((adapter) => adapter.id);
+export const selectAgents = (options) => {
+    if (options.all)
+        return adapters.map((adapter) => adapter.id);
+    return [...new Set(options.agents)];
+};
+const planFile = (root, spec, force, installed) => {
+    const target = safeTarget(root, spec.path);
+    if (spec.ownershipClass === "project" || spec.ownershipClass === "state") {
+        return existsSync(target)
+            ? { ...spec, content: readFileSync(target, "utf8"), action: "preserve", reason: `${spec.ownershipClass}-owned file` }
+            : { ...spec, action: "create", reason: `new ${spec.ownershipClass}-owned file` };
+    }
+    if (spec.strategy === "managed-block") {
+        const current = existsSync(target) ? readFileSync(target, "utf8") : "";
+        const next = mergeManagedBlock(spec, current);
+        return { ...spec, content: next, action: existsSync(target) ? (next === current ? "skip" : "update") : "create", reason: existsSync(target) ? "managed prompt block" : "new managed prompt" };
+    }
+    if (!existsSync(target))
+        return { ...spec, action: "create", reason: "new managed file" };
+    const current = readFileSync(target, "utf8");
+    if (current === spec.content)
+        return { ...spec, action: "skip", reason: "already current" };
+    if (spec.path === ".agents/aidlc/manifest.json" && installed)
+        return { ...spec, action: "update", reason: "refresh manifest inventory" };
+    const installedHash = installed?.files[spec.path]?.hash;
+    if (installedHash && contentHash(current) === installedHash)
+        return { ...spec, action: "update", reason: "unchanged managed file" };
+    if (force)
+        return { ...spec, action: "update", reason: "--force permits replacement of an unmanaged file" };
+    return { ...spec, action: "conflict", reason: "managed ownership cannot be proven; use upgrade or review --force" };
+};
+export const planInit = (options) => {
+    const root = resolve(options.root);
+    const installed = readManifest(root);
+    if (installed && installed.packageVersion !== packageVersion())
+        throw new Error(`AI-DLC ${installed.packageVersion} is already installed. Only a human may upgrade it through the documented npm/npx upgrade command.`);
+    const selected = [...new Set([...(installed?.adapters ?? []), ...selectAgents(options)])];
+    const unknown = selected.filter((id) => !findAdapter(id));
+    if (unknown.length)
+        throw new Error(`Unsupported adapter: ${unknown.join(", ")}`);
+    const agentFiles = selected.flatMap((id) => findAdapter(id)?.files() ?? []).map((file) => ({ ...file, ownershipClass: "managed" }));
+    const managedFiles = [...coreWorkflowFiles(), ...agentFiles];
+    const files = [...managedFiles, manifestSpec(managedFiles, selected), ...initialProjectFiles()];
+    const plan = files.map((spec) => planFile(root, spec, options.force, installed));
+    planProjectLayoutMigration(root, plan);
+    return plan;
+};
+export const applyPlan = (root, plan) => {
+    for (const write of plan.filter((item) => item.action === "delete"))
+        rmSync(safeTarget(root, write.path), { force: true });
+    for (const write of plan.filter((item) => ["create", "update", "migrate"].includes(item.action))) {
+        const target = safeTarget(root, write.path);
+        mkdirSync(dirname(target), { recursive: true });
+        writeFileSync(target, write.content, "utf8");
+    }
+};
+export const formatPlan = (plan) => plan.map((item) => `${item.action.padEnd(8)} ${item.path} (${item.reason}; sha=${shortHash(item.contentEncoding === "base64" ? Buffer.from(item.content, "base64") : item.content)})`).join("\n");
+const hasOwnedManifest = (root) => {
+    const path = join(resolve(root), ".agents/aidlc/manifest.json");
+    if (!existsSync(path))
+        return false;
+    try {
+        return JSON.parse(readFileSync(path, "utf8")).managedBy === "aidlc-workflow";
+    }
+    catch {
+        return false;
+    }
+};
+export const planUninstall = (root) => {
+    const project = resolve(root);
+    if (!hasOwnedManifest(project))
+        throw new Error("No aidlc-workflow ownership manifest found; refusing to remove files.");
+    const installed = readManifest(project);
+    const currentSpecs = [...coreWorkflowFiles(), ...resolvedAdapters().flatMap((adapter) => adapter.files()).map((file) => ({ ...file, ownershipClass: "managed" }))];
+    const specs = installed ? Object.entries(installed.files).map(([path, item]) => currentSpecs.find((spec) => spec.path === path) ?? ({ path, owner: item.owner, strategy: item.strategy, content: "", ownershipClass: "managed" })) : currentSpecs;
+    const plan = specs.map((spec) => {
+        const target = safeTarget(project, spec.path);
+        if (!existsSync(target))
+            return { ...spec, action: "skip", reason: "not installed" };
+        const current = readFileSync(target, "utf8");
+        if (spec.strategy === "managed-block") {
+            const block = managedBlock(spec, current);
+            if (!block)
+                return { ...spec, action: "skip", reason: "owned block not found" };
+            const installedHash = installed?.files[spec.path]?.hash ?? contentHash(spec.content.trimEnd());
+            if (contentHash(block) !== installedHash)
+                return { ...spec, action: "preserve", reason: "managed block was modified" };
+            const start = `<!-- aidlc-installer:${spec.owner}:start -->`;
+            const end = `<!-- aidlc-installer:${spec.owner}:end -->`;
+            const next = current.replace(new RegExp(`${start}[\\s\\S]*?${end}\\n?`, "g"), "").replace(/\n{3,}/g, "\n\n").trimEnd();
+            return next ? { ...spec, content: `${next}\n`, action: "update", reason: "remove owned prompt block" } : { ...spec, content: "", action: "delete", reason: "remove owned prompt file" };
+        }
+        const installedHash = installed?.files[spec.path]?.hash ?? contentHash(spec.content);
+        return contentHash(current) === installedHash ? { ...spec, action: "delete", reason: "remove unchanged managed file" } : { ...spec, action: "preserve", reason: "managed file was modified" };
+    });
+    plan.push({ path: ".agents/aidlc/manifest.json", owner: "aidlc-core", content: "", ownershipClass: "managed", action: plan.some((item) => item.action === "preserve") ? "preserve" : "delete", reason: plan.some((item) => item.action === "preserve") ? "retained while modified managed files remain" : "remove ownership manifest" });
+    return plan;
+};
+export const status = (root) => {
+    const manifest = readManifest(root);
+    const legacyPath = join(resolve(root), ".agents/aidlc/manifest.json");
+    return [
+        `workflow: ${manifest || existsSync(legacyPath) ? "installed" : "not installed"}`,
+        `installed version: ${manifest?.packageVersion ?? (existsSync(legacyPath) ? "legacy/unknown" : "none")}`,
+        `schema: ${manifest?.schemaVersion ?? (existsSync(legacyPath) ? "legacy" : "none")}`,
+        `detected agents: ${detectedAgents(root).join(", ") || "none"}`
+    ].join("\n");
+};
+export const doctor = (root, strict = false) => {
+    const manifestPath = join(resolve(root), ".agents/aidlc/manifest.json");
+    if (!existsSync(manifestPath))
+        return "ERROR: .agents/aidlc/manifest.json is missing. Run npx @felixdotgo/aidlc-kit init --yes.";
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
+    }
+    catch {
+        return "ERROR: workflow manifest is invalid JSON.";
+    }
+    if (parsed.remoteUpdates || parsed.source !== "local-package-assets" || parsed.managedBy !== "aidlc-workflow")
+        return "ERROR: workflow manifest violates local-only asset policy.";
+    if (typeof parsed.schemaVersion === "number" && parsed.schemaVersion > 2)
+        return `ERROR: installed manifest schema ${parsed.schemaVersion} is newer than this CLI supports.`;
+    const manifest = readManifest(root);
+    if (!manifest)
+        return strict ? "ERROR: legacy manifest requires an explicit user-run npm/npx upgrade." : "WARN: legacy manifest detected; no registry check was performed.";
+    try {
+        loadProjectConfig(root);
+        loadState(root);
+    }
+    catch (error) {
+        return `ERROR: local config/state is invalid: ${error instanceof Error ? error.message : String(error)}`;
+    }
+    const modified = Object.entries(manifest.files).filter(([path, item]) => {
+        const target = safeTarget(root, path);
+        if (!existsSync(target))
+            return true;
+        const spec = { owner: item.owner, strategy: item.strategy };
+        return managedContentHash(spec, readFileSync(target, "utf8")) !== item.hash;
+    }).map(([path]) => path);
+    if (modified.length)
+        return `${strict ? "ERROR" : "WARN"}: managed integrity differs: ${modified.join(", ")}`;
+    return `OK: local workflow ${manifest.packageVersion} is valid; remote updates are disabled.`;
+};

package/dist/src/ledger.d.ts

@@ -0,0 +1,22 @@
+import type { TaskState, WorkflowState } from "./model.js";
+export declare const trackedTasksPath: (root: string) => string;
+export declare const taskEventsPath: (root: string, taskId: string) => string;
+export interface TaskLedgerEvent {
+    schemaVersion: 1;
+    id: string;
+    taskId: string;
+    parentDigest: string | null;
+    actor: string;
+    recordedAt: string;
+    snapshot: TaskState;
+    digest: string;
+}
+export declare const validateLedgerEvent: (value: unknown) => TaskLedgerEvent;
+export declare const createLedgerEvent: (task: TaskState, parentDigest: string | null, actor: string, recordedAt?: string, id?: string) => TaskLedgerEvent;
+export declare const loadTaskLedger: (root: string, taskId: string) => TaskLedgerEvent[];
+export declare const reduceTaskLedger: (events: readonly TaskLedgerEvent[]) => {
+    task: TaskState;
+    headDigest: string;
+} | undefined;
+export declare const loadTrackedState: (root: string) => WorkflowState | undefined;
+export declare const appendTaskLedgerEvent: (root: string, task: TaskState, actor: string) => TaskLedgerEvent;

package/dist/src/ledger.js

@@ -0,0 +1,119 @@
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { validateState } from "./state.js";
+export const trackedTasksPath = (root) => join(resolve(root), ".agents/workflow/tasks");
+export const taskEventsPath = (root, taskId) => join(trackedTasksPath(root), taskId, "events");
+const digest = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+const eventContent = (event) => `${JSON.stringify(event, null, 2)}\n`;
+const eventPath = (root, event) => join(taskEventsPath(root, event.taskId), `${event.id}.json`);
+const taskIdPattern = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+const iso = (value) => typeof value === "string" && Number.isFinite(Date.parse(value)) && new Date(Date.parse(value)).toISOString() === value;
+const assertSafeTaskId = (taskId) => {
+    if (!taskIdPattern.test(taskId))
+        throw new Error(`Invalid ledger task id: ${taskId}`);
+};
+const atomicWrite = (path, content) => {
+    mkdirSync(dirname(path), { recursive: true });
+    const temporary = `${path}.tmp-${process.pid}-${Date.now()}`;
+    writeFileSync(temporary, content, "utf8");
+    renameSync(temporary, path);
+};
+export const validateLedgerEvent = (value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Ledger event must be an object");
+    const event = value;
+    if (event.schemaVersion !== 1 || typeof event.id !== "string" || !taskIdPattern.test(event.id) || typeof event.taskId !== "string" || !taskIdPattern.test(event.taskId) || (event.parentDigest !== null && !/^[a-f0-9]{64}$/.test(event.parentDigest ?? "")) || typeof event.actor !== "string" || !event.actor.trim() || !iso(event.recordedAt) || !event.snapshot || typeof event.digest !== "string" || !/^[a-f0-9]{64}$/.test(event.digest))
+        throw new Error("Invalid ledger event fields");
+    if (event.snapshot.id !== event.taskId)
+        throw new Error(`Ledger event task mismatch: ${event.id}`);
+    validateState({ schemaVersion: 4, tasks: { [event.taskId]: event.snapshot }, archive: {} });
+    const { digest: supplied, ...unsigned } = event;
+    if (digest(unsigned) !== supplied)
+        throw new Error(`Ledger event digest mismatch: ${event.id}`);
+    return event;
+};
+export const createLedgerEvent = (task, parentDigest, actor, recordedAt = new Date().toISOString(), id = randomUUID()) => {
+    assertSafeTaskId(task.id);
+    if (!actor.trim() || !iso(recordedAt) || !taskIdPattern.test(id))
+        throw new Error("Invalid ledger event metadata");
+    validateState({ schemaVersion: 4, tasks: { [task.id]: task }, archive: {} });
+    const unsigned = { schemaVersion: 1, id, taskId: task.id, parentDigest, actor, recordedAt, snapshot: task };
+    return { ...unsigned, digest: digest(unsigned) };
+};
+export const loadTaskLedger = (root, taskId) => {
+    assertSafeTaskId(taskId);
+    const directory = taskEventsPath(root, taskId);
+    if (!existsSync(directory))
+        return [];
+    if (lstatSync(directory).isSymbolicLink())
+        throw new Error(`Ledger path crosses a symlink: ${taskId}`);
+    const events = readdirSync(directory, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+        .map((entry) => validateLedgerEvent(JSON.parse(readFileSync(join(directory, entry.name), "utf8"))))
+        .sort((left, right) => left.id.localeCompare(right.id));
+    if (events.some((event) => event.taskId !== taskId))
+        throw new Error(`Ledger event is in the wrong task directory: ${taskId}`);
+    return events;
+};
+export const reduceTaskLedger = (events) => {
+    if (!events.length)
+        return undefined;
+    const byDigest = new Map(events.map((event) => [event.digest, event]));
+    if (byDigest.size !== events.length)
+        throw new Error("Duplicate ledger event digest");
+    const roots = events.filter((event) => event.parentDigest === null);
+    if (roots.length !== 1)
+        throw new Error("Ledger must have exactly one root event");
+    const children = new Map();
+    for (const event of events)
+        if (event.parentDigest) {
+            if (!byDigest.has(event.parentDigest))
+                throw new Error(`Ledger event has unknown parent: ${event.id}`);
+            const siblings = children.get(event.parentDigest) ?? [];
+            siblings.push(event);
+            children.set(event.parentDigest, siblings);
+        }
+    const sibling = [...children.values()].find((items) => items.length > 1);
+    if (sibling)
+        throw new Error(`Concurrent ledger events require resolution: ${sibling.map((event) => event.id).join(", ")}`);
+    const visited = new Set();
+    let current = roots[0];
+    while (true) {
+        if (visited.has(current.digest))
+            throw new Error("Ledger event cycle");
+        visited.add(current.digest);
+        const next = children.get(current.digest) ?? [];
+        if (!next.length)
+            break;
+        current = next[0];
+    }
+    if (visited.size !== events.length)
+        throw new Error("Ledger contains disconnected events");
+    return { task: current.snapshot, headDigest: current.digest };
+};
+export const loadTrackedState = (root) => {
+    const directory = trackedTasksPath(root);
+    if (!existsSync(directory))
+        return undefined;
+    if (lstatSync(directory).isSymbolicLink())
+        throw new Error("Tracked ledger path crosses a symlink");
+    const tasks = {};
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+        if (!entry.isDirectory() || !taskIdPattern.test(entry.name))
+            continue;
+        const reduced = reduceTaskLedger(loadTaskLedger(root, entry.name));
+        if (reduced)
+            tasks[entry.name] = reduced.task;
+    }
+    return validateState({ schemaVersion: 4, tasks, archive: {} });
+};
+export const appendTaskLedgerEvent = (root, task, actor) => {
+    const current = reduceTaskLedger(loadTaskLedger(root, task.id));
+    const event = createLedgerEvent(task, current?.headDigest ?? null, actor);
+    const path = eventPath(root, event);
+    if (existsSync(path))
+        throw new Error(`Ledger event already exists: ${event.id}`);
+    atomicWrite(path, eventContent(event));
+    return event;
+};

package/dist/src/legacy.d.ts

@@ -0,0 +1,2 @@
+export declare const legacyV021Hashes: Readonly<Record<string, string>>;
+export declare const legacyV021AdapterContents: Readonly<Record<string, string>>;

package/dist/src/legacy.js

@@ -0,0 +1,37 @@
+export const legacyV021Hashes = Object.freeze({
+    ".agents/aidlc/conventions.md": "fa807e4430fcd1a0d21621c783becda61f8e61e9df9ab2e164e3ce0decc380db",
+    ".agents/aidlc/orchestrator.md": "b5d38c1a4031f2a1cb5b58f2fdf2965a34c5ff86699f6af103cd0d97587b9f44",
+    ".agents/aidlc/phase-build.md": "8384d67747acebfa87b06f0e11c58a0f2c661584d7d584ab8c382b6308263e29",
+    ".agents/aidlc/phase-clarify.md": "a31e69c68a924c689933f5dff69cd94ee09b587171f838458ee7dbb6dd4eacf6",
+    ".agents/aidlc/phase-index.md": "7473192914e44b39ce02a60ed79051a1827656305556ffa684ca7e3388827373",
+    ".agents/aidlc/phase-plan.md": "242da8e20e099889c7f05ac7c582902515b86ea62c159e02202231051f7ac5f9",
+    ".agents/aidlc/phase-wrap.md": "e2d108aa80a9fcee2e4a43b6ac53e451f18d4b26aee42728ca4788bba8883ef8",
+    ".agents/aidlc/rules/gate-check.md": "b542365d1698f179f12128d3932743e4799378a1475d89400c294f30b2cecd1d",
+    ".agents/aidlc/rules/stack-runtime.md": "023900a35372668fd69d23e11332ecc78f43df9ef9e75a86bdda2e7c442a0731",
+    ".agents/aidlc/templates/board.md": "caedf04fa8b19790549ec53238fce4f5a96492d12f367dff930ed9d9f6a8c593",
+    ".agents/aidlc/templates/design.md": "35849fb13083942eb32f201f86520961fe1c9971bc7e8d4ee9dd6921b32fcfaa",
+    ".agents/aidlc/templates/intent.md": "a55c97b3babebd18b07ce50fdba5326bbb11ca7cf4cf2e5b8eae7f84304cce78",
+    ".agents/aidlc/templates/lesson.md": "1ac7b7f5f2ed937084cb42d069d0a0f764ee7a71868f6d4fb3437231a81789ac",
+    ".agents/aidlc/templates/workplan.md": "2ad82fecd04cc87a211d5e8b2a813d1c1243180ee13544b0a5db58d2755c2b7b",
+    ".agents/skills/aidlc-build/SKILL.md": "4f9221a5a80a561406b1ae54cd7731c6543fb509bb9b38b1a2a4639e2842f552",
+    ".agents/skills/aidlc-clarify/SKILL.md": "6b481d5bf87d476d2bd09c1d627d85203da87e3bbb640851e34d32cf086f80f1",
+    ".agents/skills/aidlc-index/SKILL.md": "dedb6b91f666bc32f39a51e6f378760d0718ccfd8edbe01a667898e6e18599be",
+    ".agents/skills/aidlc-plan/SKILL.md": "141b3abd065562f95f249fcf2509ceb095d554a8ccc62fd45de214ab82a4b387",
+    ".agents/skills/aidlc-wrap/SKILL.md": "51e06614d074c8ed008575bb099fe97f0d402633c37225f4874b5408a5382be8"
+});
+const instruction = (agent) => [
+    `# AI-DLC for ${agent}`,
+    "",
+    "Read `.agents/aidlc/orchestrator.md` and `.agents/data/state/BOARD.md` before starting non-trivial work. Use phase skills under `.agents/skills/`; do not fetch remote workflow content. Respect more-specific instructions already present in this repository.",
+    ""
+].join("\n");
+const block = (owner, body) => `<!-- aidlc-installer:${owner} -->\n${body}`;
+export const legacyV021AdapterContents = Object.freeze({
+    "CLAUDE.md": block("claude", instruction("Claude Code")),
+    ".claude/skills/aidlc/SKILL.md": block("claude", instruction("Claude Code")),
+    "AGENTS.md": block("codex", instruction("Codex")),
+    ".cursor/rules/aidlc.mdc": block("cursor", `---\ndescription: AI-DLC workflow\nalwaysApply: true\n---\n\n${instruction("Cursor")}`),
+    ".agents/rules/aidlc.md": block("antigravity", instruction("Google Antigravity")),
+    ".kiro/steering/aidlc.md": block("kiro", instruction("Kiro")),
+    ".agents/aidlc/adapters/generic-instructions.md": block("generic", instruction("compatible agent"))
+});

package/dist/src/managed-content.d.ts

@@ -0,0 +1,3 @@
+import type { FileSpec } from "./model.js";
+export declare const managedBlock: (spec: Pick<FileSpec, "owner" | "strategy">, content: string) => string | undefined;
+export declare const mergeManagedBlock: (spec: FileSpec, current: string) => string;

package/dist/src/managed-content.js

@@ -0,0 +1,16 @@
+export const managedBlock = (spec, content) => {
+    if (spec.strategy !== "managed-block")
+        return content;
+    const start = `<!-- aidlc-installer:${spec.owner}:start -->`;
+    const end = `<!-- aidlc-installer:${spec.owner}:end -->`;
+    return content.match(new RegExp(`${start}[\\s\\S]*?${end}`))?.[0];
+};
+export const mergeManagedBlock = (spec, current) => {
+    const start = `<!-- aidlc-installer:${spec.owner}:start -->`;
+    const end = `<!-- aidlc-installer:${spec.owner}:end -->`;
+    const block = spec.content.trimEnd();
+    const matches = new RegExp(`${start}[\\s\\S]*?${end}\\n?`, "g");
+    const withoutOwnedBlocks = current.replace(matches, "").replace(/\n{3,}/g, "\n\n").trimEnd();
+    const next = `${withoutOwnedBlocks}${withoutOwnedBlocks ? "\n\n" : ""}${block}`;
+    return `${next.trimEnd()}\n`;
+};

package/dist/src/mcp-setup.d.ts

@@ -0,0 +1,20 @@
+export interface McpSetupOptions {
+    root: string;
+    template: string;
+    dryRun: boolean;
+    deployment: "docker" | "remote";
+    storage: "sqlite" | "postgres";
+    bind: "localhost" | "network";
+    workspace: string;
+    pollMs: number;
+    tokenEnv: string;
+    providers: string[];
+    enable: boolean;
+}
+export interface McpSetupPlan {
+    target: string;
+    files: string[];
+    config: Record<string, unknown>;
+}
+export declare const planMcpSetup: (options: McpSetupOptions) => McpSetupPlan;
+export declare const applyMcpSetup: (options: McpSetupOptions) => McpSetupPlan;

package/dist/src/mcp-setup.js

@@ -0,0 +1,31 @@
+import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+export const planMcpSetup = (options) => {
+    const target = join(resolve(options.root), ".agents/aidlc-coordination");
+    const endpoint = options.deployment === "docker" ? "http://127.0.0.1:8787/mcp" : "https://replace-with-service.example/mcp";
+    return {
+        target,
+        files: options.deployment === "docker" ? ["Dockerfile", "compose.yaml", "package.json", "package-lock.json", "src/", "test/", ".env.example"] : [".env.example"],
+        config: { enabled: options.enable, ...(options.enable ? { endpoint, workspace: options.workspace, tokenEnv: options.tokenEnv, pollMs: options.pollMs, providers: options.providers } : {}) }
+    };
+};
+export const applyMcpSetup = (options) => {
+    const plan = planMcpSetup(options);
+    if (options.dryRun)
+        return plan;
+    mkdirSync(plan.target, { recursive: true });
+    if (options.deployment === "docker")
+        cpSync(options.template, plan.target, { recursive: true, force: true });
+    const env = [
+        `MCP_STATE_DATABASE=${options.storage}`,
+        `MCP_STATE_HOST=${options.bind === "localhost" ? "127.0.0.1" : "0.0.0.0"}`,
+        `MCP_STATE_AUTH_TOKEN=${options.bind === "network" ? `set-${options.tokenEnv}-outside-git` : ""}`,
+        options.storage === "postgres" ? "MCP_STATE_POSTGRES_URL=postgres://aidlc:change-me@postgres:5432/aidlc" : "MCP_STATE_SQLITE_PATH=/data/mcp-state.db"
+    ].join("\n");
+    writeFileSync(join(plan.target, ".env.example"), `${env}\n`, "utf8");
+    const configPath = join(resolve(options.root), ".agents/config.json");
+    const current = existsSync(configPath) ? JSON.parse(readFileSync(configPath, "utf8")) : { schemaVersion: 3, extends: ["topology/single"], specs: { roots: [] }, commands: {}, rules: { include: [] }, risk: { default: "normal" }, context: { maxChars: 16000 }, agentState: {} };
+    current.mcp = plan.config;
+    writeFileSync(configPath, `${JSON.stringify(current, null, 2)}\n`, "utf8");
+    return plan;
+};