@lonca/baron-mcp-server 0.1.0

package/dist/chunk-MUGSC3EW.js

@@ -0,0 +1,1076 @@
+// src/load.ts
+import { existsSync, readFileSync } from "fs";
+import { BaronError, parsePolicyJson } from "@lonca/baron-core";
+import { createLocalKnowledgeLoop } from "@lonca/baron-knowledge-loop";
+import {
+  buildPorts,
+  credentialsPath,
+  executeNativeRequest,
+  knowledgeDir,
+  mergeCredentials,
+  policyPath
+} from "@lonca/baron-providers";
+import { createRecipeService } from "@lonca/baron-recipes";
+function readIfPresent(path) {
+  return existsSync(path) ? readFileSync(path, "utf8") : void 0;
+}
+function loadPorts(root, env) {
+  const path = policyPath(root);
+  const raw = readIfPresent(path);
+  if (raw === void 0) {
+    throw new BaronError(
+      `No policy found at ${path}. Run \`baron init\` first.`,
+      "POLICY_NOT_FOUND"
+    );
+  }
+  const effectiveEnv = mergeCredentials(env, readIfPresent(credentialsPath(root)));
+  const policy = parsePolicyJson(raw);
+  const boundProviders = new Set(
+    Object.values(policy.providers).filter((p) => typeof p === "string")
+  );
+  const nativeAccess = (provider, request) => {
+    if (!boundProviders.has(provider)) {
+      throw new BaronError(
+        `Provider '${provider}' is not bound in this policy; the escape hatch only reaches bound providers.`,
+        "NATIVE_UNSUPPORTED"
+      );
+    }
+    return executeNativeRequest(provider, effectiveEnv, request);
+  };
+  const bound = buildPorts(policy, effectiveEnv);
+  const knowledge = createLocalKnowledgeLoop(knowledgeDir(root));
+  const recipes = createRecipeService({ ...bound, knowledge }, root);
+  return { ...bound, knowledge, nativeAccess, recipes };
+}
+
+// src/tools.ts
+import {
+  BaronError as BaronError2,
+  ISSUE_LINK_TYPES,
+  RUN_STATUSES,
+  WORKFLOW_ROLES,
+  WORK_ITEM_TYPE_ROLES,
+  isIssueLinkType,
+  isRunStatus,
+  isWorkItemTypeRole,
+  isWorkflowRole
+} from "@lonca/baron-core";
+import {
+  FOLLOWUP_STATUSES,
+  isFollowupStatus
+} from "@lonca/baron-knowledge-loop";
+var MCP_TOOL_NAMES = {
+  create: "baron_issue_create",
+  get: "baron_issue_get",
+  transition: "baron_issue_transition",
+  comment: "baron_issue_comment",
+  link: "baron_issue_link",
+  query: "baron_issue_query"
+};
+var SCM_TOOL_NAMES = {
+  branchCreate: "baron_scm_branch_create",
+  prCreate: "baron_scm_pr_create",
+  prThread: "baron_scm_pr_thread",
+  prStatus: "baron_scm_pr_status"
+};
+var CI_TOOL_NAMES = {
+  pipelines: "baron_ci_pipelines",
+  runs: "baron_ci_runs",
+  runGet: "baron_ci_run_get",
+  runLogs: "baron_ci_run_logs",
+  runTrigger: "baron_ci_run_trigger",
+  runCancel: "baron_ci_run_cancel"
+};
+var NOTIFY_TOOL_NAMES = {
+  send: "baron_notify_send"
+};
+var DEPLOY_TOOL_NAMES = {
+  environments: "baron_deploy_environments",
+  deployments: "baron_deploy_deployments"
+};
+var NATIVE_TOOL_NAMES = {
+  request: "baron_native_request"
+};
+var RECIPE_TOOL_NAMES = {
+  list: "baron_recipe_list",
+  run: "baron_recipe_run"
+};
+var LOOP_TOOL_NAMES = {
+  learningAppend: "baron_learning_append",
+  learningQuery: "baron_learning_query",
+  followupAppend: "baron_followup_append",
+  followupList: "baron_followup_list"
+};
+var ROLE_ENUM = [...WORKFLOW_ROLES];
+var TYPE_ROLE_ENUM = [...WORK_ITEM_TYPE_ROLES];
+var LINK_TYPE_ENUM = [...ISSUE_LINK_TYPES];
+var FOLLOWUP_STATUS_ENUM = [...FOLLOWUP_STATUSES];
+var RUN_STATUS_ENUM = [...RUN_STATUSES];
+var DEFAULT_QUERY_LIMIT = 50;
+var TOOL_DEFINITIONS = [
+  {
+    name: MCP_TOOL_NAMES.create,
+    description: "Create an issue from abstract terms. typeRole -> native work-item type and initialRole -> native state are translated automatically per the active policy; capability gaps (e.g. no native hierarchy) are handled by the configured gap policy.",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: ["title", "typeRole"],
+      properties: {
+        title: { type: "string", minLength: 1 },
+        typeRole: {
+          type: "string",
+          enum: TYPE_ROLE_ENUM,
+          description: "Abstract type role; the provider maps it to a native work-item type."
+        },
+        body: { type: "string" },
+        parentId: {
+          type: "string",
+          description: "Parent issue id. On providers without native hierarchy this is emulated or degraded per the gap policy."
+        },
+        labels: { type: "array", items: { type: "string" } },
+        initialRole: {
+          type: "string",
+          enum: ROLE_ENUM,
+          description: "Optional starting workflow role; omit to use the provider default."
+        }
+      }
+    }
+  },
+  {
+    name: MCP_TOOL_NAMES.get,
+    description: "Fetch a normalized issue by id.",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: ["id"],
+      properties: { id: { type: "string", minLength: 1 } }
+    }
+  },
+  {
+    name: MCP_TOOL_NAMES.transition,
+    description: "Transition an issue to a target workflow role (idempotent). The adapter resolves the role to the provider-native state/column/label.",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: ["id", "role"],
+      properties: {
+        id: { type: "string", minLength: 1 },
+        role: {
+          type: "string",
+          enum: ROLE_ENUM,
+          description: "Target workflow role. Translated to the provider-native target."
+        }
+      }
+    }
+  },
+  {
+    name: MCP_TOOL_NAMES.comment,
+    description: "Add a comment to an issue.",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: ["id", "body"],
+      properties: {
+        id: { type: "string", minLength: 1 },
+        body: { type: "string", minLength: 1 }
+      }
+    }
+  },
+  {
+    name: MCP_TOOL_NAMES.link,
+    description: "Link two issues with an abstract relationship. On providers without native typed links the link is emulated or degraded per the gap policy.",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: ["fromId", "toId", "type"],
+      properties: {
+        fromId: { type: "string", minLength: 1 },
+        toId: { type: "string", minLength: 1 },
+        type: {
+          type: "string",
+          enum: LINK_TYPE_ENUM,
+          description: "Relationship from the source (fromId) to the target (toId) issue."
+        }
+      }
+    }
+  },
+  {
+    name: MCP_TOOL_NAMES.query,
+    description: "List issues filtered by workflow role and/or type role (filters are AND-combined). Returns a lightweight projection (no body); fetch an issue with get for full detail.",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        role: { type: "string", enum: ROLE_ENUM, description: "Filter by workflow role." },
+        typeRole: { type: "string", enum: TYPE_ROLE_ENUM, description: "Filter by type role." },
+        limit: {
+          type: "number",
+          minimum: 1,
+          description: `Maximum number of issues to return. Defaults to ${DEFAULT_QUERY_LIMIT} to keep the result within an agent's context; pass a higher value for more.`
+        }
+      }
+    }
+  }
+];
+var SCM_TOOL_DEFINITIONS = [
+  {
+    name: SCM_TOOL_NAMES.branchCreate,
+    description: "Create a branch from a base branch (defaults to the repository default branch).",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: ["name"],
+      properties: {
+        name: {
+          type: "string",
+          minLength: 1,
+          description: "New branch name (without refs/heads/)."
+        },
+        fromBranch: {
+          type: "string",
+          minLength: 1,
+          description: "Branch to fork from. Defaults to the repository's default branch."
+        }
+      }
+    }
+  },
+  {
+    name: SCM_TOOL_NAMES.prCreate,
+    description: "Open a pull request. A requested draft may be degraded to a ready PR if the provider lacks draft support (per the gap policy); the returned `draft` reflects what was actually opened.",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: ["title", "sourceBranch"],
+      properties: {
+        title: { type: "string", minLength: 1 },
+        body: { type: "string" },
+        sourceBranch: { type: "string", minLength: 1 },
+        targetBranch: {
+          type: "string",
+          minLength: 1,
+          description: "Branch to merge into. Defaults to the repository's default branch."
+        },
+        draft: { type: "boolean", description: "Open as a draft PR when supported." }
+      }
+    }
+  },
+  {
+    name: SCM_TOOL_NAMES.prThread,
+    description: "Add a discussion thread/comment to a pull request.",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: ["pullRequestId", "body"],
+      properties: {
+        pullRequestId: { type: "string", minLength: 1 },
+        body: { type: "string", minLength: 1 }
+      }
+    }
+  },
+  {
+    name: SCM_TOOL_NAMES.prStatus,
+    description: `Read a pull request's normalized status: state, review decision, mergeability, and a checks rollup \u2014 the "is it ready to merge?" view.`,
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: ["pullRequestId"],
+      properties: { pullRequestId: { type: "string", minLength: 1 } }
+    }
+  }
+];
+var CI_TOOL_DEFINITIONS = [
+  {
+    name: CI_TOOL_NAMES.pipelines,
+    description: "List pipeline definitions.",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        limit: {
+          type: "number",
+          minimum: 1,
+          description: "Maximum number of pipelines to return."
+        }
+      }
+    }
+  },
+  {
+    name: CI_TOOL_NAMES.runs,
+    description: "List CI runs (filter by pipeline / branch / normalized status). Returns a lightweight projection; status is the provider-agnostic run status.",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        pipelineId: { type: "string", minLength: 1, description: "Restrict to one pipeline." },
+        branch: { type: "string", minLength: 1, description: "Restrict to a source branch." },
+        status: {
+          type: "string",
+          enum: RUN_STATUS_ENUM,
+          description: "Filter by normalized run status."
+        },
+        limit: {
+          type: "number",
+          minimum: 1,
+          description: `Maximum number of runs to return. Defaults to ${DEFAULT_QUERY_LIMIT} to keep the result within an agent's context.`
+        }
+      }
+    }
+  },
+  {
+    name: CI_TOOL_NAMES.runGet,
+    description: "Get one run, including its stages when the provider surfaces them.",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: ["id"],
+      properties: { id: { type: "string", minLength: 1 } }
+    }
+  },
+  {
+    name: CI_TOOL_NAMES.runLogs,
+    description: "Fetch a run's logs. Size-aware: returns a lean tail by default (`truncated` flags omitted content); raise `tailLines` for more.",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: ["runId"],
+      properties: {
+        runId: { type: "string", minLength: 1 },
+        tailLines: {
+          type: "number",
+          minimum: 1,
+          description: "Max lines to return from the tail."
+        }
+      }
+    }
+  },
+  {
+    name: CI_TOOL_NAMES.runTrigger,
+    description: "Queue a new run of a pipeline. Returns { accepted, run? } \u2014 `run` is present only when the provider returns it synchronously (some providers dispatch asynchronously with no run id).",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: ["pipelineId"],
+      properties: {
+        pipelineId: { type: "string", minLength: 1 },
+        ref: {
+          type: "string",
+          minLength: 1,
+          description: "Branch/tag to run on. Defaults to the repository's default branch."
+        },
+        variables: {
+          type: "object",
+          additionalProperties: { type: "string" },
+          description: "Pipeline variables / workflow inputs."
+        }
+      }
+    }
+  },
+  {
+    name: CI_TOOL_NAMES.runCancel,
+    description: "Cancel a run; returns the run with its updated status.",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: ["runId"],
+      properties: { runId: { type: "string", minLength: 1 } }
+    }
+  }
+];
+var NOTIFY_TOOL_DEFINITIONS = [
+  {
+    name: NOTIFY_TOOL_NAMES.send,
+    description: "Send a notification. Targeting a channel or threading a reply may be degraded/errored per the gap policy on providers that lack those capabilities.",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: ["text"],
+      properties: {
+        text: { type: "string", minLength: 1 },
+        channel: {
+          type: "string",
+          minLength: 1,
+          description: "Target channel (requires channels)."
+        },
+        threadKey: {
+          type: "string",
+          minLength: 1,
+          description: "Thread to reply under (an opaque key from a prior send; requires threads)."
+        }
+      }
+    }
+  }
+];
+var DEPLOY_TOOL_DEFINITIONS = [
+  {
+    name: DEPLOY_TOOL_NAMES.environments,
+    description: "List deployment environments (e.g. dev / staging / prod).",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        limit: { type: "number", minimum: 1, description: "Maximum number to return." }
+      }
+    }
+  },
+  {
+    name: DEPLOY_TOOL_NAMES.deployments,
+    description: "List recent deployments with a normalized status (optionally filtered to one environment).",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        environment: { type: "string", minLength: 1, description: "Restrict to one environment." },
+        limit: { type: "number", minimum: 1, description: "Maximum number to return." }
+      }
+    }
+  }
+];
+var NATIVE_TOOL_DEFINITIONS = [
+  {
+    name: NATIVE_TOOL_NAMES.request,
+    description: "ESCAPE HATCH \u2014 a raw, authenticated, NON-PORTABLE provider REST call. Last resort for when no normalized tool (issue/scm/ci/notify) covers the need. You supply the provider-native method + path (+ query/body); Baron only attaches the base URL + auth and returns the (size-capped) response. Prefer the normalized tools \u2014 this is provider-specific and will not port to another provider. Only providers bound in the active policy are reachable.",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: ["provider", "method", "path"],
+      properties: {
+        provider: { type: "string", minLength: 1, description: "A provider bound in the policy." },
+        method: { type: "string", minLength: 1, description: "HTTP method (GET/POST/PATCH/\u2026)." },
+        path: {
+          type: "string",
+          minLength: 1,
+          description: "Provider-relative path, including any required api-version query."
+        },
+        query: { type: "object", additionalProperties: { type: "string" } },
+        body: { description: "JSON request body (any shape)." }
+      }
+    }
+  }
+];
+var RECIPE_TOOL_DEFINITIONS = [
+  {
+    name: RECIPE_TOOL_NAMES.list,
+    description: "List the runnable recipes (built-ins + project recipes) with their declared inputs. Call this to discover what `baron_recipe_run` accepts before running a workflow.",
+    inputSchema: { type: "object", additionalProperties: false, properties: {} }
+  },
+  {
+    name: RECIPE_TOOL_NAMES.run,
+    description: "Run a named recipe end-to-end as ONE deterministic, rule-enforced workflow (the engine \u2014 not you \u2014 enforces the step order). Supply all required inputs (from baron_recipe_list) in `inputs`; a missing required input errors rather than prompting. Prefer this over composing the individual issue/scm/ci tools yourself for a packaged workflow.",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: ["name"],
+      properties: {
+        name: { type: "string", minLength: 1, description: "Recipe name (e.g. task-start)." },
+        inputs: {
+          type: "object",
+          description: "Values for the recipe's `ask` inputs, keyed by input name."
+        }
+      }
+    }
+  }
+];
+var LOOP_TOOL_DEFINITIONS = [
+  {
+    name: LOOP_TOOL_NAMES.learningAppend,
+    description: "Record a durable learning (knowledge that should survive across runs).",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: ["title", "body"],
+      properties: {
+        title: { type: "string", minLength: 1 },
+        body: { type: "string" },
+        tags: { type: "array", items: { type: "string" } }
+      }
+    }
+  },
+  {
+    name: LOOP_TOOL_NAMES.learningQuery,
+    description: "Query recorded learnings by tag and/or free text (newest first).",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        tag: { type: "string" },
+        text: { type: "string", description: "Case-insensitive substring over title + body." },
+        limit: { type: "number", minimum: 1 }
+      }
+    }
+  },
+  {
+    name: LOOP_TOOL_NAMES.followupAppend,
+    description: "Record an open follow-up (deferred work to revisit later).",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: ["title"],
+      properties: {
+        title: { type: "string", minLength: 1 },
+        body: { type: "string" },
+        tags: { type: "array", items: { type: "string" } }
+      }
+    }
+  },
+  {
+    name: LOOP_TOOL_NAMES.followupList,
+    description: "List follow-ups by status and/or tag (newest first).",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        status: { type: "string", enum: FOLLOWUP_STATUS_ENUM },
+        tag: { type: "string" },
+        limit: { type: "number", minimum: 1 }
+      }
+    }
+  }
+];
+var INVALID_ARGS = "INVALID_ARGS";
+function requireString(args, key) {
+  const value = args?.[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new BaronError2(`Missing or empty required string argument '${key}'.`, INVALID_ARGS);
+  }
+  return value;
+}
+function optionalString(args, key) {
+  const value = args?.[key];
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") {
+    throw new BaronError2(`Argument '${key}' must be a string.`, INVALID_ARGS);
+  }
+  return value;
+}
+function optionalLabels(args) {
+  const value = args?.labels;
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value) || value.some((label) => typeof label !== "string")) {
+    throw new BaronError2("Argument 'labels' must be an array of strings.", INVALID_ARGS);
+  }
+  return value;
+}
+function requireRole(args) {
+  const value = requireString(args, "role");
+  if (!isWorkflowRole(value)) {
+    throw new BaronError2(
+      `Invalid role '${value}'. Expected one of: ${WORKFLOW_ROLES.join(", ")}.`,
+      INVALID_ARGS
+    );
+  }
+  return value;
+}
+function requireLinkType(args) {
+  const value = requireString(args, "type");
+  if (!isIssueLinkType(value)) {
+    throw new BaronError2(
+      `Invalid link type '${value}'. Expected one of: ${ISSUE_LINK_TYPES.join(", ")}.`,
+      INVALID_ARGS
+    );
+  }
+  return value;
+}
+function toQuery(args) {
+  const roleRaw = optionalString(args, "role");
+  if (roleRaw !== void 0 && !isWorkflowRole(roleRaw)) {
+    throw new BaronError2(
+      `Invalid role '${roleRaw}'. Expected one of: ${WORKFLOW_ROLES.join(", ")}.`,
+      INVALID_ARGS
+    );
+  }
+  const typeRoleRaw = optionalString(args, "typeRole");
+  if (typeRoleRaw !== void 0 && !isWorkItemTypeRole(typeRoleRaw)) {
+    throw new BaronError2(
+      `Invalid typeRole '${typeRoleRaw}'. Expected one of: ${WORK_ITEM_TYPE_ROLES.join(", ")}.`,
+      INVALID_ARGS
+    );
+  }
+  const limit = args?.limit;
+  if (limit !== void 0 && (typeof limit !== "number" || !Number.isFinite(limit) || limit < 1)) {
+    throw new BaronError2("Argument 'limit' must be a positive number.", INVALID_ARGS);
+  }
+  return {
+    ...roleRaw !== void 0 ? { role: roleRaw } : {},
+    ...typeRoleRaw !== void 0 ? { typeRole: typeRoleRaw } : {},
+    limit: limit !== void 0 ? limit : DEFAULT_QUERY_LIMIT
+  };
+}
+function toDraft(args) {
+  const title = requireString(args, "title");
+  const typeRole = requireString(args, "typeRole");
+  if (!isWorkItemTypeRole(typeRole)) {
+    throw new BaronError2(
+      `Invalid typeRole '${typeRole}'. Expected one of: ${WORK_ITEM_TYPE_ROLES.join(", ")}.`,
+      INVALID_ARGS
+    );
+  }
+  const body = optionalString(args, "body");
+  const parentId = optionalString(args, "parentId");
+  const labels = optionalLabels(args);
+  const initialRoleRaw = optionalString(args, "initialRole");
+  if (initialRoleRaw !== void 0 && !isWorkflowRole(initialRoleRaw)) {
+    throw new BaronError2(
+      `Invalid initialRole '${initialRoleRaw}'. Expected one of: ${WORKFLOW_ROLES.join(", ")}.`,
+      INVALID_ARGS
+    );
+  }
+  return {
+    title,
+    typeRole,
+    ...body !== void 0 ? { body } : {},
+    ...parentId !== void 0 ? { parentId } : {},
+    ...labels !== void 0 ? { labels } : {},
+    ...initialRoleRaw !== void 0 ? { initialRole: initialRoleRaw } : {}
+  };
+}
+async function run(fn) {
+  try {
+    const result = await fn();
+    const text = result === void 0 ? '{"ok":true}' : JSON.stringify(result);
+    return { content: [{ type: "text", text }] };
+  } catch (error) {
+    if (error instanceof BaronError2) {
+      return {
+        isError: true,
+        content: [{ type: "text", text: `${error.code}: ${error.message}` }],
+        structuredContent: { code: error.code, message: error.message }
+      };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      isError: true,
+      content: [{ type: "text", text: `INTERNAL: ${message}` }],
+      structuredContent: { code: "INTERNAL", message }
+    };
+  }
+}
+function callTool(port, name, args) {
+  switch (name) {
+    case MCP_TOOL_NAMES.create:
+      return run(() => port.create(toDraft(args)));
+    case MCP_TOOL_NAMES.get:
+      return run(() => port.get(requireString(args, "id")));
+    case MCP_TOOL_NAMES.transition:
+      return run(() => port.transition(requireString(args, "id"), requireRole(args)));
+    case MCP_TOOL_NAMES.comment:
+      return run(() => port.comment(requireString(args, "id"), requireString(args, "body")));
+    case MCP_TOOL_NAMES.link:
+      return run(
+        () => port.link(
+          requireString(args, "fromId"),
+          requireString(args, "toId"),
+          requireLinkType(args)
+        )
+      );
+    case MCP_TOOL_NAMES.query:
+      return run(() => port.query(toQuery(args)));
+    default:
+      return run(() => {
+        throw new BaronError2(`Unknown tool '${name}'.`, "UNKNOWN_TOOL");
+      });
+  }
+}
+function optionalBoolean(args, key) {
+  const value = args?.[key];
+  if (value === void 0) return void 0;
+  if (typeof value !== "boolean") {
+    throw new BaronError2(`Argument '${key}' must be a boolean.`, INVALID_ARGS);
+  }
+  return value;
+}
+function callScmTool(port, name, args) {
+  switch (name) {
+    case SCM_TOOL_NAMES.branchCreate:
+      return run(() => {
+        const fromBranch = optionalString(args, "fromBranch");
+        return port.createBranch({
+          name: requireString(args, "name"),
+          ...fromBranch !== void 0 ? { fromBranch } : {}
+        });
+      });
+    case SCM_TOOL_NAMES.prCreate:
+      return run(() => {
+        const draft = optionalBoolean(args, "draft");
+        const body = optionalString(args, "body");
+        const targetBranch = optionalString(args, "targetBranch");
+        return port.createPullRequest({
+          title: requireString(args, "title"),
+          sourceBranch: requireString(args, "sourceBranch"),
+          ...targetBranch !== void 0 ? { targetBranch } : {},
+          ...body !== void 0 ? { body } : {},
+          ...draft !== void 0 ? { draft } : {}
+        });
+      });
+    case SCM_TOOL_NAMES.prStatus:
+      return run(() => port.prStatus(requireString(args, "pullRequestId")));
+    case SCM_TOOL_NAMES.prThread:
+      return run(
+        () => port.addPullRequestThread(
+          requireString(args, "pullRequestId"),
+          requireString(args, "body")
+        )
+      );
+    default:
+      return run(() => {
+        throw new BaronError2(`Unknown tool '${name}'.`, "UNKNOWN_TOOL");
+      });
+  }
+}
+function optStringArray(args, key) {
+  const value = args?.[key];
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new BaronError2(`Argument '${key}' must be an array of strings.`, INVALID_ARGS);
+  }
+  return value;
+}
+function optNumber(args, key) {
+  const value = args?.[key];
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new BaronError2(`Argument '${key}' must be a number.`, INVALID_ARGS);
+  }
+  return value;
+}
+function optFollowupStatus(args) {
+  const value = optionalString(args, "status");
+  if (value === void 0) return void 0;
+  if (!isFollowupStatus(value)) {
+    throw new BaronError2(
+      `Invalid status '${value}'. Expected one of: ${FOLLOWUP_STATUSES.join(", ")}.`,
+      INVALID_ARGS
+    );
+  }
+  return value;
+}
+function callLoopTool(loop, name, args) {
+  switch (name) {
+    case LOOP_TOOL_NAMES.learningAppend:
+      return run(() => {
+        const tags = optStringArray(args, "tags");
+        return loop.learningAppend({
+          title: requireString(args, "title"),
+          body: requireString(args, "body"),
+          ...tags !== void 0 ? { tags } : {}
+        });
+      });
+    case LOOP_TOOL_NAMES.learningQuery:
+      return run(() => {
+        const tag = optionalString(args, "tag");
+        const text = optionalString(args, "text");
+        const limit = optNumber(args, "limit");
+        return loop.learningQuery({
+          ...tag !== void 0 ? { tag } : {},
+          ...text !== void 0 ? { text } : {},
+          ...limit !== void 0 ? { limit } : {}
+        });
+      });
+    case LOOP_TOOL_NAMES.followupAppend:
+      return run(() => {
+        const body = optionalString(args, "body");
+        const tags = optStringArray(args, "tags");
+        return loop.followupAppend({
+          title: requireString(args, "title"),
+          ...body !== void 0 ? { body } : {},
+          ...tags !== void 0 ? { tags } : {}
+        });
+      });
+    case LOOP_TOOL_NAMES.followupList:
+      return run(() => {
+        const status = optFollowupStatus(args);
+        const tag = optionalString(args, "tag");
+        const limit = optNumber(args, "limit");
+        return loop.followupList({
+          ...status !== void 0 ? { status } : {},
+          ...tag !== void 0 ? { tag } : {},
+          ...limit !== void 0 ? { limit } : {}
+        });
+      });
+    default:
+      return run(() => {
+        throw new BaronError2(`Unknown tool '${name}'.`, "UNKNOWN_TOOL");
+      });
+  }
+}
+function toRunQuery(args) {
+  const pipelineId = optionalString(args, "pipelineId");
+  const branch = optionalString(args, "branch");
+  const statusRaw = optionalString(args, "status");
+  if (statusRaw !== void 0 && !isRunStatus(statusRaw)) {
+    throw new BaronError2(
+      `Invalid status '${statusRaw}'. Expected one of: ${RUN_STATUSES.join(", ")}.`,
+      INVALID_ARGS
+    );
+  }
+  const limit = args?.limit;
+  if (limit !== void 0 && (typeof limit !== "number" || !Number.isFinite(limit) || limit < 1)) {
+    throw new BaronError2("Argument 'limit' must be a positive number.", INVALID_ARGS);
+  }
+  return {
+    ...pipelineId !== void 0 ? { pipelineId } : {},
+    ...branch !== void 0 ? { branch } : {},
+    ...statusRaw !== void 0 ? { status: statusRaw } : {},
+    limit: limit !== void 0 ? limit : DEFAULT_QUERY_LIMIT
+  };
+}
+function optionalStringRecord(args, key) {
+  const value = args?.[key];
+  if (value === void 0) return void 0;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new BaronError2(`Argument '${key}' must be an object of string values.`, INVALID_ARGS);
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    if (typeof v !== "string") {
+      throw new BaronError2(`Argument '${key}.${k}' must be a string.`, INVALID_ARGS);
+    }
+    out[k] = v;
+  }
+  return out;
+}
+function callCiTool(port, name, args) {
+  switch (name) {
+    case CI_TOOL_NAMES.pipelines:
+      return run(() => {
+        const limit = optNumber(args, "limit");
+        return port.pipelines(limit !== void 0 ? { limit } : {});
+      });
+    case CI_TOOL_NAMES.runs:
+      return run(() => port.runs(toRunQuery(args)));
+    case CI_TOOL_NAMES.runGet:
+      return run(() => port.run(requireString(args, "id")));
+    case CI_TOOL_NAMES.runLogs:
+      return run(() => {
+        const tailLines = optNumber(args, "tailLines");
+        return port.logs(
+          requireString(args, "runId"),
+          tailLines !== void 0 ? { tailLines } : {}
+        );
+      });
+    case CI_TOOL_NAMES.runTrigger:
+      return run(() => {
+        const ref = optionalString(args, "ref");
+        const variables = optionalStringRecord(args, "variables");
+        return port.trigger({
+          pipelineId: requireString(args, "pipelineId"),
+          ...ref !== void 0 ? { ref } : {},
+          ...variables !== void 0 ? { variables } : {}
+        });
+      });
+    case CI_TOOL_NAMES.runCancel:
+      return run(() => port.cancel(requireString(args, "runId")));
+    default:
+      return run(() => {
+        throw new BaronError2(`Unknown tool '${name}'.`, "UNKNOWN_TOOL");
+      });
+  }
+}
+function callNotifyTool(port, name, args) {
+  switch (name) {
+    case NOTIFY_TOOL_NAMES.send:
+      return run(() => {
+        const channel = optionalString(args, "channel");
+        const threadKey = optionalString(args, "threadKey");
+        return port.send({
+          text: requireString(args, "text"),
+          ...channel !== void 0 ? { channel } : {},
+          ...threadKey !== void 0 ? { threadKey } : {}
+        });
+      });
+    default:
+      return run(() => {
+        throw new BaronError2(`Unknown tool '${name}'.`, "UNKNOWN_TOOL");
+      });
+  }
+}
+function callDeployTool(port, name, args) {
+  switch (name) {
+    case DEPLOY_TOOL_NAMES.environments:
+      return run(() => {
+        const limit = optNumber(args, "limit");
+        return port.environments(limit !== void 0 ? { limit } : {});
+      });
+    case DEPLOY_TOOL_NAMES.deployments:
+      return run(() => {
+        const environment = optionalString(args, "environment");
+        const limit = optNumber(args, "limit");
+        return port.deployments({
+          ...environment !== void 0 ? { environment } : {},
+          ...limit !== void 0 ? { limit } : {}
+        });
+      });
+    default:
+      return run(() => {
+        throw new BaronError2(`Unknown tool '${name}'.`, "UNKNOWN_TOOL");
+      });
+  }
+}
+function callRecipeTool(service, name, args) {
+  switch (name) {
+    case RECIPE_TOOL_NAMES.list:
+      return run(async () => service.list());
+    case RECIPE_TOOL_NAMES.run:
+      return run(() => {
+        const inputs = args?.inputs;
+        if (inputs !== void 0 && (typeof inputs !== "object" || inputs === null || Array.isArray(inputs))) {
+          throw new BaronError2("Argument 'inputs' must be an object.", INVALID_ARGS);
+        }
+        return service.run(
+          requireString(args, "name"),
+          inputs ?? {}
+        );
+      });
+    default:
+      return run(() => {
+        throw new BaronError2(`Unknown tool '${name}'.`, "UNKNOWN_TOOL");
+      });
+  }
+}
+function callNativeTool(access, name, args) {
+  switch (name) {
+    case NATIVE_TOOL_NAMES.request:
+      return run(() => {
+        const query = optionalStringRecord(args, "query");
+        const body = args?.body;
+        return access(requireString(args, "provider"), {
+          method: requireString(args, "method"),
+          path: requireString(args, "path"),
+          ...query !== void 0 ? { query } : {},
+          ...body !== void 0 ? { body } : {}
+        });
+      });
+    default:
+      return run(() => {
+        throw new BaronError2(`Unknown tool '${name}'.`, "UNKNOWN_TOOL");
+      });
+  }
+}
+function activeToolDefinitions(ports) {
+  return [
+    ...ports.issues ? TOOL_DEFINITIONS : [],
+    ...ports.scm ? SCM_TOOL_DEFINITIONS : [],
+    ...ports.ci ? CI_TOOL_DEFINITIONS : [],
+    ...ports.notify ? NOTIFY_TOOL_DEFINITIONS : [],
+    ...ports.deploy ? DEPLOY_TOOL_DEFINITIONS : [],
+    ...ports.recipes ? RECIPE_TOOL_DEFINITIONS : [],
+    ...ports.nativeAccess ? NATIVE_TOOL_DEFINITIONS : [],
+    ...ports.knowledge ? LOOP_TOOL_DEFINITIONS : []
+  ];
+}
+function dispatchTool(ports, name, args) {
+  if (name.startsWith("baron_issue_")) {
+    if (ports.issues === void 0) {
+      return run(() => {
+        throw new BaronError2("The issues port is not configured.", "PORT_UNBOUND");
+      });
+    }
+    return callTool(ports.issues, name, args);
+  }
+  if (name.startsWith("baron_scm_")) {
+    if (ports.scm === void 0) {
+      return run(() => {
+        throw new BaronError2("The scm port is not configured.", "PORT_UNBOUND");
+      });
+    }
+    return callScmTool(ports.scm, name, args);
+  }
+  if (name.startsWith("baron_ci_")) {
+    if (ports.ci === void 0) {
+      return run(() => {
+        throw new BaronError2("The ci port is not configured.", "PORT_UNBOUND");
+      });
+    }
+    return callCiTool(ports.ci, name, args);
+  }
+  if (name.startsWith("baron_notify_")) {
+    if (ports.notify === void 0) {
+      return run(() => {
+        throw new BaronError2("The notify port is not configured.", "PORT_UNBOUND");
+      });
+    }
+    return callNotifyTool(ports.notify, name, args);
+  }
+  if (name.startsWith("baron_deploy_")) {
+    if (ports.deploy === void 0) {
+      return run(() => {
+        throw new BaronError2("The deploy port is not configured.", "PORT_UNBOUND");
+      });
+    }
+    return callDeployTool(ports.deploy, name, args);
+  }
+  if (name.startsWith("baron_recipe_")) {
+    if (ports.recipes === void 0) {
+      return run(() => {
+        throw new BaronError2("The recipe runner is not available.", "PORT_UNBOUND");
+      });
+    }
+    return callRecipeTool(ports.recipes, name, args);
+  }
+  if (name.startsWith("baron_native_")) {
+    if (ports.nativeAccess === void 0) {
+      return run(() => {
+        throw new BaronError2("The provider-native escape hatch is not available.", "PORT_UNBOUND");
+      });
+    }
+    return callNativeTool(ports.nativeAccess, name, args);
+  }
+  if (name.startsWith("baron_learning_") || name.startsWith("baron_followup_")) {
+    if (ports.knowledge === void 0) {
+      return run(() => {
+        throw new BaronError2("The knowledge loop is not configured.", "PORT_UNBOUND");
+      });
+    }
+    return callLoopTool(ports.knowledge, name, args);
+  }
+  return run(() => {
+    throw new BaronError2(`Unknown tool '${name}'.`, "UNKNOWN_TOOL");
+  });
+}
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+var SERVER_INFO = { name: "baron", version: "0.0.0" };
+function createMcpServer(ports) {
+  const server = new Server(SERVER_INFO, { capabilities: { tools: {} } });
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: activeToolDefinitions(ports)
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const result = await dispatchTool(ports, request.params.name, request.params.arguments);
+    return result;
+  });
+  return server;
+}
+
+export {
+  loadPorts,
+  MCP_TOOL_NAMES,
+  SCM_TOOL_NAMES,
+  CI_TOOL_NAMES,
+  NOTIFY_TOOL_NAMES,
+  DEPLOY_TOOL_NAMES,
+  NATIVE_TOOL_NAMES,
+  RECIPE_TOOL_NAMES,
+  LOOP_TOOL_NAMES,
+  TOOL_DEFINITIONS,
+  SCM_TOOL_DEFINITIONS,
+  CI_TOOL_DEFINITIONS,
+  NOTIFY_TOOL_DEFINITIONS,
+  DEPLOY_TOOL_DEFINITIONS,
+  NATIVE_TOOL_DEFINITIONS,
+  RECIPE_TOOL_DEFINITIONS,
+  LOOP_TOOL_DEFINITIONS,
+  callTool,
+  callScmTool,
+  callLoopTool,
+  callCiTool,
+  callNotifyTool,
+  callDeployTool,
+  callRecipeTool,
+  callNativeTool,
+  activeToolDefinitions,
+  dispatchTool,
+  SERVER_INFO,
+  createMcpServer
+};