@evref-bl/dev-nexus 0.1.0-alpha.0

package/dist/nexusMcpServer.js

@@ -0,0 +1,1036 @@
+import path from "node:path";
+import process from "node:process";
+import { defaultNexusHomePath, loadNexusHomeConfigFile, resolveNexusHome, saveNexusHomeConfigFile, validateNexusHomeConfigBase, } from "./nexusHomeConfig.js";
+import { loadProjectConfig, } from "./nexusProjectConfig.js";
+import { getNexusProjectStatus, } from "./nexusProjectHomeService.js";
+import { resolvePrimaryProjectComponent, resolveProjectComponents, } from "./nexusProjectLifecycle.js";
+import { buildNexusProjectStatusForPath, } from "./nexusProjectRegistry.js";
+import { getNexusAutomationStatus, } from "./nexusAutomationStatus.js";
+import { getNexusAutomationAgentProfileSummary, getNexusAutomationEligibleWorkSummary, } from "./nexusAutomationAgentSurface.js";
+import { appendNexusAutomationTargetCycleRecord, maxNexusAutomationTargetCycleNoteLength, readNexusAutomationTargetCycleLedger, } from "./nexusAutomationTargetCycle.js";
+import { buildNexusAutomationTargetReport, } from "./nexusAutomationTargetReport.js";
+import { createNexusCoordinationHandoff, getNexusCoordinationIntegrationPlan, getNexusCoordinationStatus, parseNexusCoordinationHandoffStatus, } from "./nexusCoordination.js";
+import { createWorkItemService, } from "./workItemService.js";
+export const devNexusMcpProtocolVersion = "2024-11-05";
+const tools = [
+    {
+        name: "project_status",
+        description: "Show one DevNexus project by registered id or filesystem path.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                homePath: { type: "string" },
+                project: { type: "string" },
+            },
+            required: ["project"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "automation_status",
+        description: "Read DevNexus automation readiness, target context, and eligible work without mutating state.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                homePath: { type: "string" },
+                project: { type: "string" },
+                projectRoot: { type: "string" },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "eligible_work",
+        description: "List concise DevNexus eligible work grouped by component using the configured automation selector.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                homePath: { type: "string" },
+                project: { type: "string" },
+                projectRoot: { type: "string" },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "agent_profiles",
+        description: "Inspect concise DevNexus coordinator and subagent profile policy without dumping full project config.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                homePath: { type: "string" },
+                project: { type: "string" },
+                projectRoot: { type: "string" },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "target_cycle_list",
+        description: "List recorded DevNexus target cycles without mutating state.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                homePath: { type: "string" },
+                project: { type: "string" },
+                projectRoot: { type: "string" },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "target_cycle_record",
+        description: "Record caller-reported DevNexus target cycle progress.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                homePath: { type: "string" },
+                project: { type: "string" },
+                projectRoot: { type: "string" },
+                cycleId: { type: "string" },
+                runId: { type: "string" },
+                status: {
+                    type: "string",
+                    enum: ["started", "dispatched", "completed", "blocked", "failed", "skipped"],
+                },
+                summary: { type: ["string", "null"] },
+                eligibleWorkItemCount: { type: ["number", "null"] },
+                workItems: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            componentId: { type: ["string", "null"] },
+                            id: { type: "string" },
+                            title: { type: ["string", "null"] },
+                            status: { type: ["string", "null"] },
+                            cycleStatus: {
+                                type: ["string", "null"],
+                                enum: [
+                                    "eligible",
+                                    "selected",
+                                    "dispatched",
+                                    "in_progress",
+                                    "completed",
+                                    "blocked",
+                                    "skipped",
+                                    null,
+                                ],
+                            },
+                            agentProfileId: { type: ["string", "null"] },
+                            notes: {
+                                type: ["string", "null"],
+                                maxLength: maxNexusAutomationTargetCycleNoteLength,
+                            },
+                        },
+                        required: ["id"],
+                        additionalProperties: false,
+                    },
+                },
+                blockers: { type: "array", items: { type: "string" } },
+                notes: {
+                    type: "array",
+                    items: {
+                        type: "string",
+                        maxLength: maxNexusAutomationTargetCycleNoteLength,
+                    },
+                },
+            },
+            required: ["status"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "target_report",
+        description: "Build a factual DevNexus target report from recorded target, cycle, run, and work-item facts.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                homePath: { type: "string" },
+                project: { type: "string" },
+                projectRoot: { type: "string" },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "coordination_status",
+        description: "Report advisory shared coordination status for a component worktree and optional work item.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                homePath: { type: "string" },
+                project: { type: "string" },
+                projectRoot: { type: "string" },
+                componentId: { type: "string" },
+                workItemId: { type: "string" },
+                currentPath: { type: "string" },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "coordination_handoff",
+        description: "Record an advisory structured coordination handoff as a tracker-backed work-item comment.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                homePath: { type: "string" },
+                project: { type: "string" },
+                projectRoot: { type: "string" },
+                componentId: { type: "string" },
+                workItemId: { type: "string" },
+                status: {
+                    type: "string",
+                    enum: ["working", "ready", "blocked", "merged"],
+                },
+                hostId: { type: "string" },
+                agentId: { type: "string" },
+                changedAreas: { type: "array", items: { type: "string" } },
+                decisions: { type: "array", items: { type: "string" } },
+                verificationSummary: { type: ["string", "null"] },
+                integrationPreference: { type: ["string", "null"] },
+                note: { type: ["string", "null"] },
+                currentPath: { type: "string" },
+            },
+            required: ["workItemId", "status"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "coordination_integrate",
+        description: "Build a read-only integration plan from related handoff branches, Git merge analysis, and recorded decisions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                homePath: { type: "string" },
+                project: { type: "string" },
+                projectRoot: { type: "string" },
+                componentId: { type: "string" },
+                workItemId: { type: "string" },
+                targetBranch: { type: "string" },
+                fetch: { type: "boolean" },
+                currentPath: { type: "string" },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "work_item_create",
+        description: "Create a work item through the configured DevNexus work tracker.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                homePath: { type: "string" },
+                project: { type: "string" },
+                projectRoot: { type: "string" },
+                componentId: { type: "string" },
+                title: { type: "string" },
+                description: { type: ["string", "null"] },
+                status: { type: "string" },
+                labels: { type: "array", items: { type: "string" } },
+                assignees: { type: "array", items: { type: "string" } },
+                milestone: { type: ["string", "null"] },
+            },
+            required: ["title"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "work_item_list",
+        description: "List work items through the configured DevNexus work tracker.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                homePath: { type: "string" },
+                project: { type: "string" },
+                projectRoot: { type: "string" },
+                componentId: { type: "string" },
+                status: {
+                    oneOf: [
+                        { type: "string" },
+                        { type: "array", items: { type: "string" } },
+                    ],
+                },
+                labels: { type: "array", items: { type: "string" } },
+                assignees: { type: "array", items: { type: "string" } },
+                search: { type: "string" },
+                limit: { type: "number" },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "work_item_get",
+        description: "Get a work item through the configured DevNexus work tracker.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                homePath: { type: "string" },
+                project: { type: "string" },
+                projectRoot: { type: "string" },
+                componentId: { type: "string" },
+                id: { type: "string" },
+                provider: { type: "string" },
+                externalRef: { type: "object" },
+                ref: { type: "object" },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "work_item_update",
+        description: "Update a work item through the configured DevNexus work tracker.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                homePath: { type: "string" },
+                project: { type: "string" },
+                projectRoot: { type: "string" },
+                componentId: { type: "string" },
+                id: { type: "string" },
+                provider: { type: "string" },
+                externalRef: { type: "object" },
+                ref: { type: "object" },
+                title: { type: "string" },
+                description: { type: ["string", "null"] },
+                status: { type: "string" },
+                labels: { type: "array", items: { type: "string" } },
+                assignees: { type: "array", items: { type: "string" } },
+                milestone: { type: ["string", "null"] },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "work_item_comment",
+        description: "Add a comment to a work item through the configured DevNexus work tracker.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                homePath: { type: "string" },
+                project: { type: "string" },
+                projectRoot: { type: "string" },
+                componentId: { type: "string" },
+                id: { type: "string" },
+                provider: { type: "string" },
+                externalRef: { type: "object" },
+                ref: { type: "object" },
+                body: { type: "string" },
+            },
+            required: ["body"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "work_item_set_status",
+        description: "Set a work item's status through the configured DevNexus work tracker.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                homePath: { type: "string" },
+                project: { type: "string" },
+                projectRoot: { type: "string" },
+                componentId: { type: "string" },
+                id: { type: "string" },
+                provider: { type: "string" },
+                externalRef: { type: "object" },
+                ref: { type: "object" },
+                status: { type: "string" },
+            },
+            required: ["status"],
+            additionalProperties: false,
+        },
+    },
+];
+export function listDevNexusMcpTools() {
+    return tools;
+}
+export async function callDevNexusMcpTool(name, argsValue, context = {}) {
+    try {
+        const args = argsValue === undefined ? {} : asRecord(argsValue, "arguments");
+        switch (name) {
+            case "project_status":
+                return toolResult({
+                    ok: true,
+                    project: projectStatusFromArgs(args),
+                });
+            case "automation_status":
+                return toolResult({
+                    ok: true,
+                    ...(await getNexusAutomationStatus({
+                        projectRoot: projectRootFromArgs(args),
+                        now: context.now,
+                    })),
+                });
+            case "eligible_work":
+                return toolResult({
+                    ok: true,
+                    ...(await getNexusAutomationEligibleWorkSummary({
+                        projectRoot: projectRootFromArgs(args),
+                        now: context.now,
+                    })),
+                });
+            case "agent_profiles":
+                return toolResult({
+                    ok: true,
+                    ...getNexusAutomationAgentProfileSummary(projectRootFromArgs(args)),
+                });
+            case "target_cycle_list":
+                return toolResult({
+                    ok: true,
+                    ...targetCycleLedgerFromArgs(args),
+                });
+            case "target_cycle_record":
+                return toolResult({
+                    ok: true,
+                    ...appendTargetCycleFromArgs(args, context),
+                });
+            case "target_report":
+                return toolResult({
+                    ok: true,
+                    report: buildNexusAutomationTargetReport({
+                        projectRoot: projectRootFromArgs(args),
+                        now: context.now?.(),
+                    }),
+                });
+            case "coordination_status":
+                return toolResult({
+                    ok: true,
+                    status: await getNexusCoordinationStatus({
+                        projectRoot: projectRootFromArgs(args),
+                        componentId: optionalString(args, "componentId", "arguments"),
+                        workItemId: optionalString(args, "workItemId", "arguments"),
+                        currentPath: optionalString(args, "currentPath", "arguments") ??
+                            context.currentPath ??
+                            process.cwd(),
+                        gitRunner: context.gitRunner,
+                        now: context.now,
+                    }),
+                });
+            case "coordination_handoff":
+                return toolResult({
+                    ok: true,
+                    ...(await createNexusCoordinationHandoff({
+                        projectRoot: projectRootFromArgs(args),
+                        componentId: optionalString(args, "componentId", "arguments"),
+                        workItemId: requiredString(args, "workItemId", "arguments"),
+                        status: parseNexusCoordinationHandoffStatus(requiredString(args, "status", "arguments"), "arguments.status"),
+                        hostId: optionalString(args, "hostId", "arguments"),
+                        agentId: optionalString(args, "agentId", "arguments"),
+                        changedAreas: optionalStringArray(args, "changedAreas", "arguments") ?? [],
+                        decisions: optionalStringArray(args, "decisions", "arguments") ?? [],
+                        verificationSummary: optionalNullableString(args, "verificationSummary", "arguments"),
+                        integrationPreference: optionalNullableString(args, "integrationPreference", "arguments"),
+                        note: optionalNullableString(args, "note", "arguments"),
+                        currentPath: optionalString(args, "currentPath", "arguments") ??
+                            context.currentPath ??
+                            process.cwd(),
+                        gitRunner: context.gitRunner,
+                        now: context.now,
+                    })),
+                });
+            case "coordination_integrate":
+                return toolResult({
+                    ok: true,
+                    plan: await getNexusCoordinationIntegrationPlan({
+                        projectRoot: projectRootFromArgs(args),
+                        componentId: optionalString(args, "componentId", "arguments"),
+                        workItemId: optionalString(args, "workItemId", "arguments"),
+                        targetBranch: optionalString(args, "targetBranch", "arguments"),
+                        fetch: optionalBoolean(args, "fetch", "arguments"),
+                        currentPath: optionalString(args, "currentPath", "arguments") ??
+                            context.currentPath ??
+                            process.cwd(),
+                        gitRunner: context.gitRunner,
+                        now: context.now,
+                    }),
+                });
+            case "work_item_create":
+                return toolResult({
+                    ok: true,
+                    workItem: await workItemServiceFromArgs(args, context).createWorkItem({
+                        ...projectSelectorFromArgs(args),
+                        title: requiredString(args, "title", "arguments"),
+                        description: optionalNullableString(args, "description", "arguments"),
+                        status: optionalWorkStatus(args, "status", "arguments"),
+                        labels: optionalStringArray(args, "labels", "arguments") ?? [],
+                        assignees: optionalStringArray(args, "assignees", "arguments") ?? [],
+                        milestone: optionalNullableString(args, "milestone", "arguments"),
+                    }),
+                });
+            case "work_item_list":
+                return toolResult({
+                    ok: true,
+                    workItems: await workItemServiceFromArgs(args, context).listWorkItems({
+                        ...projectSelectorFromArgs(args),
+                        status: optionalWorkStatusQuery(args, "status", "arguments"),
+                        labels: optionalStringArray(args, "labels", "arguments"),
+                        assignees: optionalStringArray(args, "assignees", "arguments"),
+                        search: optionalString(args, "search", "arguments"),
+                        limit: optionalPositiveInteger(args, "limit", "arguments"),
+                    }),
+                });
+            case "work_item_get":
+                return toolResult({
+                    ok: true,
+                    workItem: await workItemServiceFromArgs(args, context).getWorkItem({
+                        ...projectSelectorFromArgs(args),
+                        ...workItemRefFromArgs(args),
+                    }),
+                });
+            case "work_item_update":
+                return toolResult({
+                    ok: true,
+                    workItem: await workItemServiceFromArgs(args, context).updateWorkItem({
+                        ...projectSelectorFromArgs(args),
+                        ref: workItemRefFromArgs(args),
+                        patch: workItemPatchFromArgs(args),
+                    }),
+                });
+            case "work_item_comment":
+                return toolResult({
+                    ok: true,
+                    comment: await workItemServiceFromArgs(args, context).addComment({
+                        ...projectSelectorFromArgs(args),
+                        ref: workItemRefFromArgs(args),
+                        body: requiredString(args, "body", "arguments"),
+                    }),
+                });
+            case "work_item_set_status":
+                return toolResult({
+                    ok: true,
+                    workItem: await workItemServiceFromArgs(args, context).setStatus({
+                        ...projectSelectorFromArgs(args),
+                        ref: workItemRefFromArgs(args),
+                        status: parseWorkStatus(requiredString(args, "status", "arguments"), "arguments.status"),
+                    }),
+                });
+            default:
+                return toolResult({
+                    ok: false,
+                    error: `Unknown DevNexus MCP tool: ${name}`,
+                }, true);
+        }
+    }
+    catch (error) {
+        return toolResult({
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+        }, true);
+    }
+}
+export async function handleDevNexusMcpJsonRpcMessage(message) {
+    switch (message.method) {
+        case "initialize":
+            return jsonRpcResult(message.id, {
+                protocolVersion: devNexusMcpProtocolVersion,
+                capabilities: {
+                    tools: {},
+                },
+                serverInfo: {
+                    name: "dev-nexus",
+                    version: "0.1.0",
+                },
+            });
+        case "notifications/initialized":
+            return undefined;
+        case "tools/list":
+            return jsonRpcResult(message.id, {
+                tools: listDevNexusMcpTools(),
+            });
+        case "tools/call": {
+            const params = parseToolCallParams(message.params);
+            return jsonRpcResult(message.id, await callDevNexusMcpTool(params.name, params.arguments));
+        }
+        default:
+            if (message.id === undefined) {
+                return undefined;
+            }
+            return jsonRpcError(message.id, -32601, `Method not found: ${message.method}`);
+    }
+}
+export async function runDevNexusMcpStdioServer() {
+    const transport = new StdioJsonRpcTransport(handleDevNexusMcpJsonRpcMessage);
+    await transport.start();
+}
+function workItemServiceFromArgs(args, context) {
+    const homePath = homePathFromArgs(args);
+    return createWorkItemService({
+        resolveProject: (selector) => resolveWorkItemProject(selector, homePath),
+        now: context.now,
+    });
+}
+function targetCycleLedgerFromArgs(args) {
+    const { projectRoot, projectConfig, automationConfig } = targetCycleProjectFromArgs(args);
+    return {
+        projectRoot,
+        projectId: projectConfig.id,
+        ledger: readNexusAutomationTargetCycleLedger(projectRoot, automationConfig),
+    };
+}
+function appendTargetCycleFromArgs(args, context) {
+    const { projectRoot, projectConfig, automationConfig } = targetCycleProjectFromArgs(args);
+    const cycleId = optionalString(args, "cycleId", "arguments");
+    const ledger = appendNexusAutomationTargetCycleRecord({
+        projectRoot,
+        config: automationConfig,
+        now: context.now?.(),
+        record: {
+            ...(cycleId ? { id: cycleId } : {}),
+            projectId: projectConfig.id,
+            targetId: automationConfig.target.id,
+            objective: automationConfig.target.objective,
+            runId: optionalNullableString(args, "runId", "arguments") ?? null,
+            status: parseTargetCycleStatus(requiredString(args, "status", "arguments"), "arguments.status"),
+            summary: optionalNullableString(args, "summary", "arguments") ?? null,
+            eligibleWorkItemCount: optionalNullableNonNegativeInteger(args, "eligibleWorkItemCount", "arguments"),
+            workItems: optionalTargetCycleWorkItems(args, "workItems", "arguments") ?? [],
+            blockers: optionalStringArray(args, "blockers", "arguments") ?? [],
+            notes: optionalStringArray(args, "notes", "arguments") ?? [],
+        },
+    });
+    return {
+        projectRoot,
+        projectId: projectConfig.id,
+        record: ledger.cycles.at(-1),
+        ledger,
+    };
+}
+function targetCycleProjectFromArgs(args) {
+    const projectRoot = projectRootFromArgs(args);
+    const projectConfig = loadProjectConfig(projectRoot);
+    const automationConfig = projectConfig.automation;
+    if (!automationConfig) {
+        throw new Error("Project automation is not configured");
+    }
+    return { projectRoot, projectConfig, automationConfig };
+}
+function resolveWorkItemProject(selector, homePath) {
+    const projectRoot = selector.projectRoot
+        ? path.resolve(selector.projectRoot)
+        : getNexusProjectStatus({
+            homePath,
+            homeStore: fileProjectHomeStore(),
+            project: requiredPlainString(selector.project, "project"),
+        }).project.projectRoot;
+    const config = loadProjectConfig(projectRoot);
+    const componentId = selector.componentId;
+    const component = componentId
+        ? resolveProjectComponents(projectRoot, config).find((candidate) => candidate.id === componentId)
+        : resolvePrimaryProjectComponent(projectRoot, config);
+    if (!component) {
+        throw new Error(`Project component is not configured: ${componentId}`);
+    }
+    if (!component.workTracking) {
+        throw new Error(`Component ${component.id} work tracking is not configured`);
+    }
+    return {
+        homePath: config.home ?? homePath,
+        projectRoot,
+        projectId: config.id,
+        projectName: config.name,
+        componentId: component.id,
+        componentName: component.name,
+        sourceRoot: component.sourceRoot,
+        workTracking: component.workTracking,
+    };
+}
+function projectRootFromArgs(args) {
+    const projectRoot = optionalString(args, "projectRoot", "arguments");
+    if (projectRoot) {
+        return path.resolve(projectRoot);
+    }
+    return projectStatusFromArgs(args).projectRoot;
+}
+function projectStatusFromArgs(args) {
+    const project = requiredString(args, "project", "arguments");
+    const homePath = optionalString(args, "homePath", "arguments");
+    if (homePath) {
+        return getNexusProjectStatus({
+            homePath,
+            homeStore: fileProjectHomeStore(),
+            project,
+        }).project;
+    }
+    try {
+        return buildNexusProjectStatusForPath(project);
+    }
+    catch (pathError) {
+        try {
+            return getNexusProjectStatus({
+                homePath: defaultNexusHomePath(),
+                homeStore: fileProjectHomeStore(),
+                project,
+            }).project;
+        }
+        catch {
+            throw pathError;
+        }
+    }
+}
+function fileProjectHomeStore() {
+    return {
+        resolveHomePath: resolveNexusHome,
+        loadHomeConfig: (homePath) => loadNexusHomeConfigFile(homePath, validateNexusHomeConfigBase),
+        saveHomeConfig: (homePath, registry) => saveNexusHomeConfigFile(homePath, registry, validateNexusHomeConfigBase),
+    };
+}
+function homePathFromArgs(args) {
+    return optionalString(args, "homePath", "arguments") ?? defaultNexusHomePath();
+}
+function projectSelectorFromArgs(args) {
+    const project = optionalString(args, "project", "arguments");
+    const projectRoot = optionalString(args, "projectRoot", "arguments");
+    const componentId = optionalString(args, "componentId", "arguments");
+    return {
+        ...(project ? { project } : {}),
+        ...(projectRoot ? { projectRoot } : {}),
+        ...(componentId ? { componentId } : {}),
+    };
+}
+function workItemRefFromArgs(args) {
+    const ref = args.ref;
+    if (ref !== undefined && ref !== null) {
+        return workItemRefFromRecord(asRecord(ref, "arguments.ref"), "arguments.ref");
+    }
+    return workItemRefFromRecord(args, "arguments");
+}
+function workItemRefFromRecord(record, pathName) {
+    const provider = optionalString(record, "provider", pathName);
+    const id = optionalString(record, "id", pathName);
+    const externalRef = record.externalRef;
+    return {
+        ...(provider ? { provider } : {}),
+        ...(id ? { id } : {}),
+        ...(externalRef !== undefined && externalRef !== null
+            ? {
+                externalRef: externalRefFromRecord(asRecord(externalRef, `${pathName}.externalRef`), `${pathName}.externalRef`),
+            }
+            : {}),
+    };
+}
+function externalRefFromRecord(record, pathName) {
+    const itemNumber = optionalPositiveInteger(record, "itemNumber", pathName);
+    return {
+        provider: requiredString(record, "provider", pathName),
+        host: optionalNullableString(record, "host", pathName),
+        repositoryId: optionalNullableString(record, "repositoryId", pathName),
+        repositoryOwner: optionalNullableString(record, "repositoryOwner", pathName),
+        repositoryName: optionalNullableString(record, "repositoryName", pathName),
+        projectId: optionalNullableString(record, "projectId", pathName),
+        boardId: optionalNullableString(record, "boardId", pathName),
+        itemId: requiredString(record, "itemId", pathName),
+        itemNumber,
+        itemKey: optionalNullableString(record, "itemKey", pathName),
+        nodeId: optionalNullableString(record, "nodeId", pathName),
+        webUrl: optionalNullableString(record, "webUrl", pathName),
+    };
+}
+function workItemPatchFromArgs(args) {
+    const patch = {};
+    if (hasOwn(args, "title")) {
+        patch.title = requiredString(args, "title", "arguments");
+    }
+    if (hasOwn(args, "description")) {
+        patch.description = optionalNullableString(args, "description", "arguments") ?? null;
+    }
+    if (hasOwn(args, "status")) {
+        patch.status = optionalWorkStatus(args, "status", "arguments");
+    }
+    if (hasOwn(args, "labels")) {
+        patch.labels = optionalStringArray(args, "labels", "arguments") ?? [];
+    }
+    if (hasOwn(args, "assignees")) {
+        patch.assignees = optionalStringArray(args, "assignees", "arguments") ?? [];
+    }
+    if (hasOwn(args, "milestone")) {
+        patch.milestone = optionalNullableString(args, "milestone", "arguments") ?? null;
+    }
+    if (Object.keys(patch).length === 0) {
+        throw new Error("arguments must include at least one work item field to update");
+    }
+    return patch;
+}
+function parseToolCallParams(value) {
+    const params = asRecord(value, "params");
+    return {
+        name: requiredString(params, "name", "params"),
+        arguments: params.arguments,
+    };
+}
+function toolResult(value, isError = false) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(value, null, 2),
+            },
+        ],
+        ...(isError ? { isError: true } : {}),
+    };
+}
+function jsonRpcResult(id, result) {
+    return {
+        jsonrpc: "2.0",
+        id,
+        result,
+    };
+}
+function jsonRpcError(id, code, message) {
+    return {
+        jsonrpc: "2.0",
+        id,
+        error: {
+            code,
+            message,
+        },
+    };
+}
+class StdioJsonRpcTransport {
+    onMessage;
+    buffer = Buffer.alloc(0);
+    processing = false;
+    constructor(onMessage) {
+        this.onMessage = onMessage;
+    }
+    start() {
+        return new Promise((resolve) => {
+            process.stdin.on("data", (chunk) => {
+                this.buffer = Buffer.concat([this.buffer, chunk]);
+                void this.processBuffer().catch((error) => {
+                    this.send(jsonRpcError(undefined, -32603, error instanceof Error ? error.message : String(error)));
+                });
+            });
+            process.stdin.once("end", resolve);
+        });
+    }
+    async processBuffer() {
+        if (this.processing) {
+            return;
+        }
+        this.processing = true;
+        try {
+            while (true) {
+                const headerEnd = this.headerEndIndex();
+                if (!headerEnd) {
+                    return;
+                }
+                const [endIndex, separatorLength] = headerEnd;
+                const header = this.buffer.slice(0, endIndex).toString("utf8");
+                const lengthMatch = /^Content-Length:\s*(\d+)\s*$/imu.exec(header);
+                if (!lengthMatch) {
+                    throw new Error("Missing Content-Length header");
+                }
+                const contentLength = Number(lengthMatch[1]);
+                const messageStart = endIndex + separatorLength;
+                const messageEnd = messageStart + contentLength;
+                if (this.buffer.length < messageEnd) {
+                    return;
+                }
+                const body = this.buffer.slice(messageStart, messageEnd).toString("utf8");
+                this.buffer = this.buffer.slice(messageEnd);
+                const response = await this.onMessage(JSON.parse(body));
+                if (response) {
+                    this.send(response);
+                }
+            }
+        }
+        finally {
+            this.processing = false;
+            if (this.headerEndIndex()) {
+                void this.processBuffer();
+            }
+        }
+    }
+    headerEndIndex() {
+        const crlfIndex = this.buffer.indexOf("\r\n\r\n");
+        if (crlfIndex >= 0) {
+            return [crlfIndex, 4];
+        }
+        const lfIndex = this.buffer.indexOf("\n\n");
+        return lfIndex >= 0 ? [lfIndex, 2] : undefined;
+    }
+    send(message) {
+        const body = JSON.stringify(message);
+        process.stdout.write(`Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`);
+    }
+}
+function asRecord(value, pathName) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${pathName} must be an object`);
+    }
+    return value;
+}
+function optionalString(record, key, pathName) {
+    const value = record[key];
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`${pathName}.${key} must be a non-empty string`);
+    }
+    return value.trim();
+}
+function optionalNullableString(record, key, pathName) {
+    const value = record[key];
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`${pathName}.${key} must be a non-empty string or null`);
+    }
+    return value.trim();
+}
+function optionalStringArray(record, key, pathName) {
+    const value = record[key];
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`${pathName}.${key} must be an array of strings`);
+    }
+    return value.map((item, index) => {
+        if (typeof item !== "string" || item.trim().length === 0) {
+            throw new Error(`${pathName}.${key}[${index}] must be a non-empty string`);
+        }
+        return item.trim();
+    });
+}
+function optionalBoolean(record, key, pathName) {
+    const value = record[key];
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value !== "boolean") {
+        throw new Error(`${pathName}.${key} must be a boolean`);
+    }
+    return value;
+}
+function optionalPositiveInteger(record, key, pathName) {
+    const value = record[key];
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+        throw new Error(`${pathName}.${key} must be a positive integer`);
+    }
+    return value;
+}
+function requiredString(record, key, pathName) {
+    const value = optionalString(record, key, pathName);
+    if (!value) {
+        throw new Error(`${pathName}.${key} is required`);
+    }
+    return value;
+}
+function requiredPlainString(value, name) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`${name} is required`);
+    }
+    return value.trim();
+}
+const workStatuses = new Set([
+    "todo",
+    "ready",
+    "in_progress",
+    "blocked",
+    "done",
+    "wont_do",
+]);
+function parseWorkStatus(value, pathName) {
+    if (!workStatuses.has(value)) {
+        throw new Error(`${pathName} must be todo, ready, in_progress, blocked, done, or wont_do`);
+    }
+    return value;
+}
+function optionalWorkStatus(record, key, pathName) {
+    const value = optionalString(record, key, pathName);
+    return value === undefined ? undefined : parseWorkStatus(value, `${pathName}.${key}`);
+}
+function optionalWorkStatusQuery(record, key, pathName) {
+    const value = record[key];
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value === "string") {
+        return parseWorkStatus(value, `${pathName}.${key}`);
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`${pathName}.${key} must be a status or array of statuses`);
+    }
+    return value.map((item, index) => {
+        if (typeof item !== "string") {
+            throw new Error(`${pathName}.${key}[${index}] must be a status`);
+        }
+        return parseWorkStatus(item, `${pathName}.${key}[${index}]`);
+    });
+}
+function parseTargetCycleStatus(value, pathName) {
+    if (value === "started" ||
+        value === "dispatched" ||
+        value === "completed" ||
+        value === "blocked" ||
+        value === "failed" ||
+        value === "skipped") {
+        return value;
+    }
+    throw new Error(`${pathName} must be a valid target cycle status`);
+}
+function optionalNullableNonNegativeInteger(record, key, pathName) {
+    const value = record[key];
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+        throw new Error(`${pathName}.${key} must be a non-negative integer or null`);
+    }
+    return value;
+}
+function optionalTargetCycleWorkItems(record, key, pathName) {
+    const value = record[key];
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`${pathName}.${key} must be an array`);
+    }
+    return value.map((item, index) => targetCycleWorkItemFromRecord(asRecord(item, `${pathName}.${key}[${index}]`), `${pathName}.${key}[${index}]`));
+}
+function targetCycleWorkItemFromRecord(record, pathName) {
+    return {
+        componentId: optionalNullableString(record, "componentId", pathName) ?? null,
+        id: requiredString(record, "id", pathName),
+        title: optionalNullableString(record, "title", pathName) ?? null,
+        status: nullableWorkStatus(record, "status", pathName),
+        cycleStatus: nullableTargetCycleWorkItemStatus(record, "cycleStatus", pathName),
+        agentProfileId: optionalNullableString(record, "agentProfileId", pathName) ?? null,
+        notes: optionalNullableString(record, "notes", pathName) ?? null,
+    };
+}
+function nullableWorkStatus(record, key, pathName) {
+    const value = optionalString(record, key, pathName);
+    return value === undefined ? null : parseWorkStatus(value, `${pathName}.${key}`);
+}
+function nullableTargetCycleWorkItemStatus(record, key, pathName) {
+    const value = optionalString(record, key, pathName);
+    if (value === undefined) {
+        return null;
+    }
+    if (value === "eligible" ||
+        value === "selected" ||
+        value === "dispatched" ||
+        value === "in_progress" ||
+        value === "completed" ||
+        value === "blocked" ||
+        value === "skipped") {
+        return value;
+    }
+    throw new Error(`${pathName}.${key} must be a valid target cycle work item status`);
+}
+function hasOwn(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key);
+}