kanbo-cli 0.1.0

package/dist/lib/mcp/index.cjs

@@ -0,0 +1,184 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_manifest = require("../manifest-CpZOcB_6.cjs");
+const require_migrations_path = require("../migrations-path-CZxVOgeD.cjs");
+let zod = require("zod");
+//#region src/mcp/http-transport.ts
+const IssueSchema = zod.z.object({
+	id: zod.z.string(),
+	number: zod.z.number(),
+	title: zod.z.string(),
+	description: zod.z.string().nullable(),
+	statusId: zod.z.string().nullable(),
+	statusLine: zod.z.string().nullable(),
+	waitingFor: zod.z.literal("human").nullable(),
+	priority: zod.z.enum([
+		"none",
+		"low",
+		"medium",
+		"high",
+		"urgent"
+	]),
+	labels: zod.z.array(zod.z.string()),
+	executionMode: zod.z.enum(["worktree", "main"]),
+	parentIssueId: zod.z.string().nullable(),
+	updatedAt: zod.z.number(),
+	attemptCount: zod.z.number(),
+	activeRun: zod.z.object({
+		id: zod.z.string(),
+		agentName: zod.z.string(),
+		state: zod.z.enum([
+			"running",
+			"finished",
+			"failed",
+			"stopped"
+		]),
+		executionMode: zod.z.enum(["worktree", "main"]),
+		branch: zod.z.string().nullable(),
+		startedAt: zod.z.number()
+	}).nullable()
+});
+const StatusSchema = zod.z.object({
+	id: zod.z.string(),
+	name: zod.z.string(),
+	description: zod.z.string().nullable(),
+	order: zod.z.number(),
+	entryRules: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).nullish()
+});
+const CommentSchema = zod.z.object({
+	id: zod.z.string(),
+	issueId: zod.z.string(),
+	content: zod.z.string(),
+	createdAt: zod.z.number()
+});
+const RunSchema = zod.z.object({
+	id: zod.z.string(),
+	issueId: zod.z.string(),
+	agentName: zod.z.string(),
+	state: zod.z.enum([
+		"running",
+		"finished",
+		"failed",
+		"stopped"
+	]),
+	executionMode: zod.z.enum(["worktree", "main"]),
+	branch: zod.z.string().nullable(),
+	startedAt: zod.z.number(),
+	endedAt: zod.z.number().nullable(),
+	externalSessionRef: zod.z.string().nullish()
+});
+const PullRequestSchema = zod.z.object({
+	id: zod.z.string(),
+	issueId: zod.z.string(),
+	owner: zod.z.string(),
+	repo: zod.z.string(),
+	number: zod.z.number(),
+	url: zod.z.string(),
+	createdAt: zod.z.number()
+});
+const SprintSchema = zod.z.object({
+	id: zod.z.string(),
+	title: zod.z.string(),
+	status: zod.z.enum(["open", "closed"]),
+	startDate: zod.z.number().nullable(),
+	dueDate: zod.z.number().nullable(),
+	current: zod.z.boolean(),
+	cards: zod.z.object({
+		open: zod.z.number(),
+		done: zod.z.number()
+	})
+});
+const PrimeSchema = zod.z.object({ text: zod.z.string() });
+function createHttpTransport(input) {
+	const { request } = input;
+	async function readColumns() {
+		return zod.z.array(StatusSchema).parse(await request("GET", `/issues/statuses?workspaceId=${encodeURIComponent(input.workspaceId())}`)).map(require_manifest.projectKanboColumn);
+	}
+	/**
+	* One card as a tool prints it. The response carries the column as a foreign
+	* key, so the columns are read alongside it to turn that back into the slug
+	* an agent moves a card by.
+	*/
+	async function projectOne(response) {
+		return require_manifest.projectKanboCard(IssueSchema.parse(response), await readColumns());
+	}
+	/** The column a caller named, by slug or by name, as the id the list route filters on. */
+	function requireColumn(columns, nameOrId) {
+		const slug = require_manifest.normalizeStatusName(nameOrId);
+		const column = columns.find((candidate) => candidate.id === nameOrId || candidate.slug === slug);
+		if (!column) throw new require_migrations_path.BoardError("issue_status_not_found", {
+			statusName: nameOrId,
+			normalizedStatusName: slug
+		});
+		return column;
+	}
+	return {
+		prime: async () => PrimeSchema.parse(await request("GET", `/issues/prime?workspaceId=${encodeURIComponent(input.workspaceId())}`)),
+		ready: async ({ limit }) => {
+			const query = new URLSearchParams({ workspaceId: input.workspaceId() });
+			if (limit !== void 0) query.set("limit", String(limit));
+			const cards = zod.z.array(IssueSchema).parse(await request("GET", `/issues/ready?${query.toString()}`));
+			const columns = await readColumns();
+			return cards.map((row) => require_manifest.projectKanboCard(row, columns));
+		},
+		columns: readColumns,
+		sprints: async () => zod.z.array(SprintSchema).parse(await request("GET", `/issues/sprints?workspaceId=${encodeURIComponent(input.workspaceId())}`)).map(require_manifest.projectKanboSprint),
+		cardGet: async ({ card }) => {
+			const found = IssueSchema.parse(await request("GET", `/issues/${encodeURIComponent(card)}`));
+			const columns = await readColumns();
+			const query = new URLSearchParams({
+				workspaceId: input.workspaceId(),
+				parentIssueId: found.id
+			});
+			const subCards = zod.z.array(IssueSchema).parse(await request("GET", `/issues/?${query.toString()}`));
+			return {
+				...require_manifest.projectKanboCard(found, columns),
+				subCards: subCards.map((row) => require_manifest.projectKanboSubCard(row, columns))
+			};
+		},
+		cardList: async ({ column, limit }) => {
+			const columns = await readColumns();
+			const query = new URLSearchParams({ workspaceId: input.workspaceId() });
+			if (column) query.set("statusId", requireColumn(columns, column).id);
+			return zod.z.array(IssueSchema).parse(await request("GET", `/issues/?${query.toString()}`)).slice(0, limit ?? Number.POSITIVE_INFINITY).map((row) => require_manifest.projectKanboCard(row, columns));
+		},
+		cardCreate: async ({ title, description, column, parent, executionMode }) => await projectOne(await request("POST", "/issues/", {
+			workspaceId: input.workspaceId(),
+			...title !== void 0 ? { title } : {},
+			...description !== void 0 ? { description } : {},
+			...column !== void 0 ? { statusName: column } : {},
+			...parent !== void 0 ? { parentIssueId: parent } : {},
+			...executionMode !== void 0 ? { executionMode } : {}
+		})),
+		cardUpdate: async ({ card, ...patch }) => await projectOne(await request("PATCH", `/issues/${encodeURIComponent(card)}`, patch)),
+		cardMove: async ({ card, column }) => await projectOne(await request("PATCH", `/issues/${encodeURIComponent(card)}/status/${encodeURIComponent(column)}`)),
+		cardComment: async ({ card, content }) => CommentSchema.parse(await request("POST", `/issues/${encodeURIComponent(card)}/comments`, { content })),
+		cardLinkPullRequest: async ({ card, url }) => require_manifest.projectKanboPullRequest(PullRequestSchema.parse(await request("POST", `/issues/${encodeURIComponent(card)}/pull-requests`, { url }))),
+		cardPullRequests: async ({ card }) => zod.z.array(PullRequestSchema).parse(await request("GET", `/issues/${encodeURIComponent(card)}/pull-requests`)).map(require_manifest.projectKanboPullRequest),
+		statusLine: async ({ card, text }) => await projectOne(await request("PATCH", `/issues/${encodeURIComponent(card)}/status-line`, { statusLine: text })),
+		waitApproval: async ({ card, text }) => await projectOne(await request("POST", `/issues/${encodeURIComponent(card)}/wait-approval`, text === void 0 ? {} : { statusLine: text })),
+		runStart: async ({ card, agent, branch, executionMode, session }) => require_manifest.projectKanboRun(RunSchema.parse(await request("POST", `/issues/${encodeURIComponent(card)}/runs`, {
+			agentName: agent,
+			...branch !== void 0 ? { branch } : {},
+			...executionMode !== void 0 ? { executionMode } : {},
+			...session !== void 0 ? { externalSessionRef: session } : {}
+		}))),
+		runFinish: async ({ run, state, errorText }) => require_manifest.projectKanboRun(RunSchema.parse(await request("PATCH", `/issues/runs/${encodeURIComponent(run)}`, {
+			state,
+			...errorText !== void 0 ? { errorText } : {}
+		})))
+	};
+}
+//#endregion
+exports.KANBO_CAPABILITIES_MARKDOWN_RESOURCE_URI = require_manifest.KANBO_CAPABILITIES_MARKDOWN_RESOURCE_URI;
+exports.KANBO_CAPABILITIES_RESOURCE_URI = require_manifest.KANBO_CAPABILITIES_RESOURCE_URI;
+exports.KANBO_MCP_SERVER_NAME = require_manifest.KANBO_MCP_SERVER_NAME;
+exports.KANBO_TOOLS = require_manifest.KANBO_TOOLS;
+exports.KANBO_TOOL_CLI_EQUIVALENTS = require_manifest.KANBO_TOOL_CLI_EQUIVALENTS;
+exports.KANBO_TOOL_NAMES = require_manifest.KANBO_TOOL_NAMES;
+exports.buildKanboTools = require_manifest.buildKanboTools;
+exports.createHttpTransport = createHttpTransport;
+exports.createKanboMcpServer = require_manifest.createKanboMcpServer;
+exports.registerKanboCapabilitiesResources = require_manifest.registerKanboCapabilitiesResources;
+exports.registerKanboTools = require_manifest.registerKanboTools;
+
+//# sourceMappingURL=index.cjs.map

package/dist/lib/mcp/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["z","projectKanboColumn","projectKanboCard","normalizeStatusName","BoardError","projectKanboSprint","projectKanboSubCard","projectKanboPullRequest","projectKanboRun"],"sources":["../../../src/mcp/http-transport.ts"],"sourcesContent":["import { z } from 'zod'\n\nimport { BoardError } from '../domain/errors'\nimport { normalizeStatusName } from '../domain/status-name'\nimport type { KanboCardResult, KanboColumnResult, KanboToolTransport } from './transport'\nimport {\n  projectKanboCard,\n  projectKanboColumn,\n  projectKanboPullRequest,\n  projectKanboRun,\n  projectKanboSprint,\n  projectKanboSubCard,\n} from './transport'\n\n/**\n * The board's tools, run against a server of the board's `/issues` routes over\n * HTTP.\n *\n * This is the transport an app's own MCP server holds, and going\n * through the server rather than the file is the whole point of it: the server\n * is the board's single writing connection, it resolves the calling agent from\n * the session the request carries, it registers the await that wakes a session\n * whose card is waiting for a person, and its board version is what every open\n * host window is watching.\n *\n * How the request is made is the host's: it passes `request`, which is where\n * the server URL, the session header and the error contract live. This package\n * knows only the routes and the shapes that come back.\n */\n\n/** One call to the server. The host owns the URL, the headers and what a failure means. */\nexport type KanboHttpRequest = (\n  method: 'GET' | 'POST' | 'PATCH',\n  path: string,\n  body?: Record<string, unknown>,\n) => Promise<unknown>\n\n/** How to reach the server, and which board to ask it about. */\nexport interface KanboHttpTransportInput {\n  request: KanboHttpRequest\n  /**\n   * The workspace every question is about, asked per call rather than captured:\n   * the host learns it when a runtime is launched, which can be after the tools\n   * were built.\n   */\n  workspaceId: () => string\n}\n\nconst IssueSchema = z.object({\n  id: z.string(),\n  number: z.number(),\n  title: z.string(),\n  description: z.string().nullable(),\n  statusId: z.string().nullable(),\n  statusLine: z.string().nullable(),\n  waitingFor: z.literal('human').nullable(),\n  priority: z.enum(['none', 'low', 'medium', 'high', 'urgent']),\n  labels: z.array(z.string()),\n  executionMode: z.enum(['worktree', 'main']),\n  parentIssueId: z.string().nullable(),\n  updatedAt: z.number(),\n  attemptCount: z.number(),\n  activeRun: z.object({\n    id: z.string(),\n    agentName: z.string(),\n    state: z.enum(['running', 'finished', 'failed', 'stopped']),\n    executionMode: z.enum(['worktree', 'main']),\n    branch: z.string().nullable(),\n    startedAt: z.number(),\n  }).nullable(),\n})\n\nconst StatusSchema = z.object({\n  id: z.string(),\n  name: z.string(),\n  description: z.string().nullable(),\n  order: z.number(),\n  // The column's entry rules, as the row stores them (a JSON array in text) or\n  // already read into a list; absent from a server that predates them.\n  entryRules: z.union([z.string(), z.array(z.string())]).nullish(),\n})\n\nconst CommentSchema = z.object({\n  id: z.string(),\n  issueId: z.string(),\n  content: z.string(),\n  createdAt: z.number(),\n})\n\nconst RunSchema = z.object({\n  id: z.string(),\n  issueId: z.string(),\n  agentName: z.string(),\n  state: z.enum(['running', 'finished', 'failed', 'stopped']),\n  executionMode: z.enum(['worktree', 'main']),\n  branch: z.string().nullable(),\n  startedAt: z.number(),\n  endedAt: z.number().nullable(),\n  // Absent from a server that predates it (ruling 7-1).\n  externalSessionRef: z.string().nullish(),\n})\n\nconst PullRequestSchema = z.object({\n  id: z.string(),\n  issueId: z.string(),\n  owner: z.string(),\n  repo: z.string(),\n  number: z.number(),\n  url: z.string(),\n  createdAt: z.number(),\n})\n\nconst SprintSchema = z.object({\n  id: z.string(),\n  title: z.string(),\n  status: z.enum(['open', 'closed']),\n  startDate: z.number().nullable(),\n  dueDate: z.number().nullable(),\n  current: z.boolean(),\n  cards: z.object({ open: z.number(), done: z.number() }),\n})\n\nconst PrimeSchema = z.object({ text: z.string() })\n\nexport function createHttpTransport(input: KanboHttpTransportInput): KanboToolTransport {\n  const { request } = input\n\n  async function readColumns(): Promise<KanboColumnResult[]> {\n    const statuses = z.array(StatusSchema).parse(\n      await request('GET', `/issues/statuses?workspaceId=${encodeURIComponent(input.workspaceId())}`),\n    )\n    return statuses.map(projectKanboColumn)\n  }\n\n  /**\n   * One card as a tool prints it. The response carries the column as a foreign\n   * key, so the columns are read alongside it to turn that back into the slug\n   * an agent moves a card by.\n   */\n  async function projectOne(response: unknown): Promise<KanboCardResult> {\n    return projectKanboCard(IssueSchema.parse(response), await readColumns())\n  }\n\n  /** The column a caller named, by slug or by name, as the id the list route filters on. */\n  function requireColumn(columns: KanboColumnResult[], nameOrId: string): KanboColumnResult {\n    const slug = normalizeStatusName(nameOrId)\n    const column = columns.find(candidate => candidate.id === nameOrId || candidate.slug === slug)\n    if (!column) {\n      throw new BoardError('issue_status_not_found', { statusName: nameOrId, normalizedStatusName: slug })\n    }\n    return column\n  }\n\n  return {\n    prime: async () => PrimeSchema.parse(\n      await request('GET', `/issues/prime?workspaceId=${encodeURIComponent(input.workspaceId())}`),\n    ),\n\n    ready: async ({ limit }) => {\n      const query = new URLSearchParams({ workspaceId: input.workspaceId() })\n      if (limit !== undefined) {\n        query.set('limit', String(limit))\n      }\n      const cards = z.array(IssueSchema).parse(await request('GET', `/issues/ready?${query.toString()}`))\n      const columns = await readColumns()\n      return cards.map(row => projectKanboCard(row, columns))\n    },\n\n    columns: readColumns,\n\n    sprints: async () => z.array(SprintSchema).parse(\n      await request('GET', `/issues/sprints?workspaceId=${encodeURIComponent(input.workspaceId())}`),\n    ).map(projectKanboSprint),\n\n    cardGet: async ({ card }) => {\n      const found = IssueSchema.parse(await request('GET', `/issues/${encodeURIComponent(card)}`))\n      const columns = await readColumns()\n      const query = new URLSearchParams({ workspaceId: input.workspaceId(), parentIssueId: found.id })\n      const subCards = z.array(IssueSchema).parse(await request('GET', `/issues/?${query.toString()}`))\n      return {\n        ...projectKanboCard(found, columns),\n        subCards: subCards.map(row => projectKanboSubCard(row, columns)),\n      }\n    },\n\n    cardList: async ({ column, limit }) => {\n      const columns = await readColumns()\n      const query = new URLSearchParams({ workspaceId: input.workspaceId() })\n      if (column) {\n        query.set('statusId', requireColumn(columns, column).id)\n      }\n      const cards = z.array(IssueSchema).parse(await request('GET', `/issues/?${query.toString()}`))\n      return cards.slice(0, limit ?? Number.POSITIVE_INFINITY).map(row => projectKanboCard(row, columns))\n    },\n\n    cardCreate: async ({ title, description, column, parent, executionMode }) => await projectOne(\n      await request('POST', '/issues/', {\n        workspaceId: input.workspaceId(),\n        ...(title !== undefined ? { title } : {}),\n        ...(description !== undefined ? { description } : {}),\n        ...(column !== undefined ? { statusName: column } : {}),\n        ...(parent !== undefined ? { parentIssueId: parent } : {}),\n        ...(executionMode !== undefined ? { executionMode } : {}),\n      }),\n    ),\n\n    cardUpdate: async ({ card, ...patch }) => await projectOne(\n      await request('PATCH', `/issues/${encodeURIComponent(card)}`, patch),\n    ),\n\n    cardMove: async ({ card, column }) => await projectOne(\n      await request('PATCH', `/issues/${encodeURIComponent(card)}/status/${encodeURIComponent(column)}`),\n    ),\n\n    cardComment: async ({ card, content }) => CommentSchema.parse(\n      await request('POST', `/issues/${encodeURIComponent(card)}/comments`, { content }),\n    ),\n\n    cardLinkPullRequest: async ({ card, url }) => projectKanboPullRequest(PullRequestSchema.parse(\n      await request('POST', `/issues/${encodeURIComponent(card)}/pull-requests`, { url }),\n    )),\n\n    cardPullRequests: async ({ card }) => z.array(PullRequestSchema).parse(\n      await request('GET', `/issues/${encodeURIComponent(card)}/pull-requests`),\n    ).map(projectKanboPullRequest),\n\n    statusLine: async ({ card, text }) => await projectOne(\n      await request('PATCH', `/issues/${encodeURIComponent(card)}/status-line`, { statusLine: text }),\n    ),\n\n    waitApproval: async ({ card, text }) => await projectOne(\n      await request(\n        'POST',\n        `/issues/${encodeURIComponent(card)}/wait-approval`,\n        text === undefined ? {} : { statusLine: text },\n      ),\n    ),\n\n    runStart: async ({ card, agent, branch, executionMode, session }) => projectKanboRun(RunSchema.parse(\n      await request('POST', `/issues/${encodeURIComponent(card)}/runs`, {\n        agentName: agent,\n        ...(branch !== undefined ? { branch } : {}),\n        ...(executionMode !== undefined ? { executionMode } : {}),\n        ...(session !== undefined ? { externalSessionRef: session } : {}),\n      }),\n    )),\n\n    runFinish: async ({ run, state, errorText }) => projectKanboRun(RunSchema.parse(\n      await request('PATCH', `/issues/runs/${encodeURIComponent(run)}`, {\n        state,\n        ...(errorText !== undefined ? { errorText } : {}),\n      }),\n    )),\n  }\n}\n"],"mappings":"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"}

package/dist/lib/mcp/index.d.cts

@@ -0,0 +1,346 @@
+import { s as IssueRun, t as Issue } from "../schema-fsHqNAip.cjs";
+import { i as KanboToolName, n as KANBO_TOOL_NAMES, r as KanboToolCliEquivalent, s as EntryRule, t as KANBO_TOOL_CLI_EQUIVALENTS } from "../tool-names-9cmCn0gP.cjs";
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+//#region src/mcp/transport.d.ts
+/**
+ * What the board's tools ask for, and what comes back.
+ *
+ * A tool knows one operation and nothing about how it is performed: the same
+ * `kanbo_card_move` runs against a server over HTTP inside an app's own MCP
+ * server, and against the board itself inside `kanbo mcp`, because both transports answer this interface. Which one a tool
+ * holds is the caller's decision, made once, and no tool can tell the
+ * difference.
+ *
+ * The workspace is not a parameter here. Each transport is built for one board
+ * — the CLI resolves it the way every `kanbo` command does, the server takes
+ * it from the runtime it was launched for — and a tool that could name a
+ * workspace could name one the agent was never given.
+ */
+/** A card, as a tool hands it to an agent. */
+interface KanboCardResult {
+  /** The issue key, which is also the row id: `MAN-012`. */
+  id: string;
+  number: number;
+  title: string;
+  description: string | null;
+  /** The column's name, `null` when the card sits in no column. */
+  column: string | null;
+  /** The same column as the slug `kanbo_card_move` takes. */
+  columnSlug: string | null;
+  statusLine: string | null;
+  waitingFor: 'human' | null;
+  priority: Issue['priority'];
+  labels: string[];
+  executionMode: Issue['executionMode'];
+  parentIssueId: string | null;
+  /** Every run the card has ever had; the next launch is attempt `attemptCount + 1`. */
+  attemptCount: number;
+  /** The run going on right now, `null` when nobody is working on the card. */
+  activeRun: KanboActiveRunResult | null;
+  updatedAt: number;
+}
+/**
+ * A card read on its own, as `kanbo_card_get` hands it to an agent: the card,
+ * and the sub-cards under it in board order. Its parent is `parentIssueId`.
+ */
+interface KanboCardDetailResult extends KanboCardResult {
+  subCards: Pick<KanboCardResult, 'id' | 'title' | 'columnSlug'>[];
+}
+/** The run of a card that is going on right now. */
+interface KanboActiveRunResult {
+  id: string;
+  agentName: string;
+  state: IssueRun['state'];
+  executionMode: IssueRun['executionMode'];
+  branch: string | null;
+  startedAt: number;
+}
+/**
+ * A column of the board, as a tool hands it to an agent.
+ *
+ * What the column means is its description, written for exactly this reader;
+ * the category behind it is the board's own classification of the column and says
+ * nothing an agent moving a card can act on.
+ */
+interface KanboColumnResult {
+  id: string;
+  name: string;
+  /** What `kanbo_card_move` calls this column. */
+  slug: string;
+  description: string | null;
+  order: number;
+  /** What a card must satisfy before an agent may move it here; empty for nothing. */
+  entryRules: EntryRule[];
+}
+/**
+ * A milestone read as a sprint, as `kanbo_sprints` hands it to an agent: its
+ * dates (unix seconds), whether it is the one running now, and how many of its
+ * cards are still open and how many are done.
+ */
+interface KanboSprintResult {
+  id: string;
+  title: string;
+  status: 'open' | 'closed';
+  startDate: number | null;
+  dueDate: number | null;
+  current: boolean;
+  openCards: number;
+  doneCards: number;
+}
+/** A comment, as `kanbo_card_comment` hands it back. */
+interface KanboCommentResult {
+  id: string;
+  issueId: string;
+  content: string;
+  createdAt: number;
+}
+/** A pull request a card names, as the pull-request tools hand it back. */
+interface KanboPullRequestResult {
+  id: string;
+  issueId: string;
+  owner: string;
+  repo: string;
+  number: number;
+  url: string;
+  createdAt: number;
+}
+/** One launch of a card, as the run tools hand it back. */
+interface KanboRunResult {
+  id: string;
+  issueId: string;
+  agentName: string;
+  state: IssueRun['state'];
+  executionMode: IssueRun['executionMode'];
+  branch: string | null;
+  startedAt: number;
+  endedAt: number | null;
+  /** Where the caller's own log of this run lives, if it said — `claude:<id>` or `codex:<id>` (ruling 7-1), else `null`. */
+  externalSessionRef: string | null;
+}
+/**
+ * What each tool asks its transport for. They are named rather than written
+ * inline so the interface below reads as a list of operations, and kept inside
+ * this module because a caller reaches them through `KanboToolTransport`.
+ */
+/** What `kanbo_card_create` needs to open a card. */
+interface KanboCardCreateInput {
+  /** Optional: a card without one is titled with its own key. */
+  title?: string;
+  description?: string;
+  /** The column to open it in, by slug or name; the board's first column when absent. */
+  column?: string;
+  /** The card this one belongs under, making it a sub-card. */
+  parent?: string;
+  executionMode?: Issue['executionMode'];
+}
+/** The fields `kanbo_card_update` may change. */
+interface KanboCardUpdateInput {
+  card: string;
+  title?: string;
+  description?: string;
+  priority?: Issue['priority'];
+  labels?: string[];
+  executionMode?: Issue['executionMode'];
+}
+/** What `kanbo_run_start` records about a launch. */
+interface KanboRunStartInput {
+  card: string;
+  agent: string;
+  branch?: string;
+  executionMode?: Issue['executionMode'];
+  /** Where the agent's own log of this run lives: `claude:<id>` or `codex:<id>` (ruling 7-1). */
+  session?: string;
+}
+/** How `kanbo_run_finish` says a run ended. */
+interface KanboRunFinishInput {
+  run: string;
+  state: 'finished' | 'failed' | 'stopped';
+  errorText?: string;
+}
+/** One method per thing the board's tools do. Both transports answer all of it. */
+interface KanboToolTransport {
+  prime: () => Promise<{
+    text: string;
+  }>;
+  ready: (input: {
+    limit?: number;
+  }) => Promise<KanboCardResult[]>;
+  columns: () => Promise<KanboColumnResult[]>;
+  sprints: () => Promise<KanboSprintResult[]>;
+  cardGet: (input: {
+    card: string;
+  }) => Promise<KanboCardDetailResult>;
+  cardList: (input: {
+    column?: string;
+    limit?: number;
+  }) => Promise<KanboCardResult[]>;
+  cardCreate: (input: KanboCardCreateInput) => Promise<KanboCardResult>;
+  cardUpdate: (input: KanboCardUpdateInput) => Promise<KanboCardResult>;
+  cardMove: (input: {
+    card: string;
+    column: string;
+  }) => Promise<KanboCardResult>;
+  cardComment: (input: {
+    card: string;
+    content: string;
+  }) => Promise<KanboCommentResult>;
+  cardLinkPullRequest: (input: {
+    card: string;
+    url: string;
+  }) => Promise<KanboPullRequestResult>;
+  cardPullRequests: (input: {
+    card: string;
+  }) => Promise<KanboPullRequestResult[]>;
+  statusLine: (input: {
+    card: string;
+    text: string;
+  }) => Promise<KanboCardResult>;
+  waitApproval: (input: {
+    card: string;
+    text?: string;
+  }) => Promise<KanboCardResult>;
+  runStart: (input: KanboRunStartInput) => Promise<KanboRunResult>;
+  runFinish: (input: KanboRunFinishInput) => Promise<KanboRunResult>;
+}
+//#endregion
+//#region src/mcp/http-transport.d.ts
+/**
+ * The board's tools, run against a server of the board's `/issues` routes over
+ * HTTP.
+ *
+ * This is the transport an app's own MCP server holds, and going
+ * through the server rather than the file is the whole point of it: the server
+ * is the board's single writing connection, it resolves the calling agent from
+ * the session the request carries, it registers the await that wakes a session
+ * whose card is waiting for a person, and its board version is what every open
+ * host window is watching.
+ *
+ * How the request is made is the host's: it passes `request`, which is where
+ * the server URL, the session header and the error contract live. This package
+ * knows only the routes and the shapes that come back.
+ */
+/** One call to the server. The host owns the URL, the headers and what a failure means. */
+type KanboHttpRequest = (method: 'GET' | 'POST' | 'PATCH', path: string, body?: Record<string, unknown>) => Promise<unknown>;
+/** How to reach the server, and which board to ask it about. */
+interface KanboHttpTransportInput {
+  request: KanboHttpRequest;
+  /**
+   * The workspace every question is about, asked per call rather than captured:
+   * the host learns it when a runtime is launched, which can be after the tools
+   * were built.
+   */
+  workspaceId: () => string;
+}
+declare function createHttpTransport(input: KanboHttpTransportInput): KanboToolTransport;
+//#endregion
+//#region src/mcp/resources.d.ts
+/** The URI a client reads the manifest as JSON from. */
+declare const KANBO_CAPABILITIES_RESOURCE_URI = "kanbo://capabilities";
+/** The URI a client reads the same manifest from, laid out as Markdown. */
+declare const KANBO_CAPABILITIES_MARKDOWN_RESOURCE_URI = "kanbo://capabilities.md";
+/**
+ * The board's own capabilities manifest, as two MCP resources rather than a
+ * tool: a client reads it once, before it ever calls a board tool, to learn
+ * what the tools take and what the board promises and refuses. `kanbo
+ * capabilities` prints the same two shapes from a terminal.
+ *
+ * Registered on the server `kanbo mcp` builds for itself rather than on
+ * `registerKanboTools` — the function an app's own MCP server calls to add the
+ * board's tools to an inventory of its own — so an agent inside such an app
+ * reads the manifest the way that app documents everything else, and a client
+ * with no server around it still gets the manifest from the one server it is
+ * talking to.
+ */
+declare function registerKanboCapabilitiesResources(server: McpServer): void;
+//#endregion
+//#region src/mcp/tools/tool.d.ts
+/**
+ * What every board tool is, and the one way all of them answer.
+ *
+ * A tool is a name, a schema and exactly one call into the transport. It never
+ * throws: a board rule the caller broke, a card that is not there, a server
+ * that refused — all of it comes back as a tool error the model can read and
+ * act on, because an exception out of a handler reaches the model as a
+ * transport failure with nothing in it to correct.
+ */
+/** The zod raw shape `McpServer.registerTool` takes. */
+type KanboToolShape = Record<string, z.ZodType>;
+/**
+ * What a tool call answers with: the result, or the reason it did not happen.
+ *
+ * It is the MCP result the protocol defines, narrowed to what the board's tools
+ * actually produce — one block of text, and whether that text is a failure.
+ */
+interface KanboToolResult extends CallToolResult {
+  content: {
+    type: 'text';
+    text: string;
+  }[];
+  isError?: true;
+}
+/** One tool of the board, ready to register against any transport. */
+interface KanboTool {
+  name: KanboToolName;
+  title: string;
+  description: string;
+  inputSchema: KanboToolShape;
+  run: (transport: KanboToolTransport, input: unknown) => Promise<KanboToolResult>;
+}
+//#endregion
+//#region src/mcp/tools/index.d.ts
+/**
+ * Every tool the board has, in the order it declares them.
+ *
+ * The list is the board's, not a server's: the same sixteen are registered
+ * whether they run against a server or against the board directly, and the
+ * only thing a host decides is which of them it publishes.
+ */
+declare const KANBO_TOOLS: readonly KanboTool[];
+/** What a host decides about the board's tools. */
+interface KanboToolOptions {
+  /** Publish `kanbo_run_start` and `kanbo_run_finish`. False for a host that manages runs itself. */
+  includeRunTools: boolean;
+}
+/** One tool bound to a transport, ready for an MCP server to register. */
+interface KanboToolRegistration {
+  name: KanboToolName;
+  register: (server: McpServer) => void;
+}
+/**
+ * The board's tools, bound to the transport they run against.
+ *
+ * Nothing here reaches the board: the registration is what an MCP server needs
+ * to publish the tool, and the transport is only called when a client actually
+ * calls one.
+ */
+declare function buildKanboTools(transport: KanboToolTransport, options: KanboToolOptions): KanboToolRegistration[];
+//#endregion
+//#region src/mcp/server.d.ts
+/** The name a client sees this server under. */
+declare const KANBO_MCP_SERVER_NAME = "kanbo";
+/**
+ * Add the board's tools to a server that already exists.
+ *
+ * This is how an app with an MCP server of its own carries them: one server holds every
+ * tool an agent has, and the board's are part of that inventory rather than a
+ * second server the runtime would have to be told about.
+ */
+declare function registerKanboTools(server: McpServer, transport: KanboToolTransport, options: KanboToolOptions): void;
+/**
+ * A server that is only the board — what `kanbo mcp` serves to a client that
+ * brings no board tools of its own: an editor, an agent CLI, another machine.
+ *
+ * It carries the capabilities manifest as two resources, on top of the tools
+ * `registerKanboTools` adds — a client here has no other way to learn the
+ * board's rules, its canonical strings or its CLI equivalents before it calls
+ * anything. An app's own MCP server does not get them through this
+ * function: it documents its capabilities its own way, and adding a second
+ * `kanbo://` resource namespace to an inventory that is not only the board's
+ * is a decision for that server to make, not this one.
+ */
+declare function createKanboMcpServer(transport: KanboToolTransport, options: KanboToolOptions): McpServer;
+//#endregion
+export { KANBO_CAPABILITIES_MARKDOWN_RESOURCE_URI, KANBO_CAPABILITIES_RESOURCE_URI, KANBO_MCP_SERVER_NAME, KANBO_TOOLS, KANBO_TOOL_CLI_EQUIVALENTS, KANBO_TOOL_NAMES, type KanboActiveRunResult, type KanboCardResult, type KanboColumnResult, type KanboCommentResult, type KanboHttpRequest, type KanboHttpTransportInput, type KanboPullRequestResult, type KanboRunResult, type KanboTool, type KanboToolCliEquivalent, type KanboToolName, type KanboToolOptions, type KanboToolRegistration, type KanboToolResult, type KanboToolTransport, buildKanboTools, createHttpTransport, createKanboMcpServer, registerKanboCapabilitiesResources, registerKanboTools };
+//# sourceMappingURL=index.d.cts.map