@kitsy/coop-mcp 0.0.1 → 1.0.0

package/README.md

@@ -0,0 +1,92 @@
+# @kitsy/coop-mcp
+
+MCP server for COOP.
+
+This package exposes local COOP workspace state and operations to MCP-compatible clients over `stdio`.
+
+## Exposed Tools
+
+- `coop_workspace_info()`
+- `coop_list_tasks(filters?)`
+- `coop_show_task(id)`
+- `coop_graph_next(track?)`
+- `coop_plan_delivery(name)`
+- `coop_transition_task(id, status)`
+- `coop_create_task(fields)`
+
+## Exposed Resources
+
+- `coop://workspace`
+- `coop://tasks`
+- `coop://tasks/{id}`
+- `coop://deliveries`
+- `coop://graph`
+
+## Local Usage
+
+From the repo root:
+
+```bash
+pnpm --filter @kitsy/coop-mcp build
+node packages/mcp/dist/index.js --repo C:/path/to/your/repo
+```
+
+Or, after installation/build:
+
+```bash
+coop-mcp --repo C:/path/to/your/repo
+```
+
+If `--repo` is omitted, the server resolves the nearest parent directory containing `.coop/`.
+
+## Claude Code Setup
+
+Example MCP configuration:
+
+```json
+{
+  "mcpServers": {
+    "coop": {
+      "command": "node",
+      "args": [
+        "C:/Users/pkvsi/Wks/kitsy/coop/packages/mcp/dist/index.js",
+        "--repo",
+        "C:/path/to/your/workspace"
+      ]
+    }
+  }
+}
+```
+
+If you prefer `pnpm` during local development:
+
+```json
+{
+  "mcpServers": {
+    "coop": {
+      "command": "pnpm",
+      "args": [
+        "--dir",
+        "C:/Users/pkvsi/Wks/kitsy/coop",
+        "--filter",
+        "@kitsy/coop-mcp",
+        "exec",
+        "coop-mcp",
+        "--repo",
+        "C:/path/to/your/workspace"
+      ]
+    }
+  }
+}
+```
+
+## Other MCP-Compatible Tools
+
+Any MCP client that supports `stdio` transports can launch this server with the same command/args pattern.
+
+## Notes
+
+- The server reads and writes the local `.coop/` workspace directly.
+- Tool mutations go through shared core rules for task writing, planning, and state transitions.
+- Workspace identity is exposed from `.coop/config.yml -> project` for orchestrators and multi-repo agents.
+- This phase intentionally keeps transport simple: local `stdio`, no remote hosting, no auth layer.

package/dist/index.d.ts

@@ -1,7 +1,194 @@
-type CoopMcpPlaceholder = {
-    readonly package: "@kitsy/coop-mcp";
-    readonly status: "planned";
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import * as _kitsy_coop_core from '@kitsy/coop-core';
+import { TaskGraph, TaskType, TaskStatus } from '@kitsy/coop-core';
+
+type TaskListFilters = {
+    status?: string;
+    track?: string;
+    assignee?: string;
+    delivery?: string;
+    limit?: number;
+};
+type GraphNextFilters = {
+    track?: string;
+    limit?: number;
+    today?: string;
+};
+type TransitionTaskInput = {
+    id: string;
+    status: string;
+    actor?: string;
+};
+type CreateTaskInput = {
+    id?: string;
+    title: string;
+    type?: string;
+    status?: string;
+    track?: string;
+    priority?: string;
+    assignee?: string;
+    delivery?: string;
+    tags?: string[];
+    depends_on?: string[];
+    body?: string;
+};
+declare class CoopMcpService {
+    readonly repoRoot: string;
+    readonly coopDir: string;
+    constructor(repoRoot?: string);
+    loadGraph(): TaskGraph;
+    workspaceInfo(): {
+        instance: {
+            id: string;
+            name: string;
+            aliases: string[];
+        };
+        repo: {
+            name: string;
+            root: string;
+        };
+    };
+    listTasks(filters?: TaskListFilters): {
+        id: string;
+        title: string;
+        type: TaskType;
+        status: TaskStatus;
+        priority: _kitsy_coop_core.TaskPriority | null;
+        track: string | null;
+        assignee: string | null;
+        delivery: string | null;
+        depends_on: string[];
+        blocks: string[];
+        tags: string[];
+    }[];
+    showTask(id: string): {
+        created: string;
+        updated: string;
+        body: string;
+        raw: Record<string, unknown>;
+        execution: {
+            executor: _kitsy_coop_core.ExecutorType;
+            agent?: string;
+            context?: {
+                paths?: string[];
+                files?: string[];
+                tasks?: string[];
+            };
+            runbook?: _kitsy_coop_core.RunbookStep[];
+            permissions?: _kitsy_coop_core.ExecutionPermissions;
+            constraints?: _kitsy_coop_core.ExecutionConstraints;
+        } | null;
+        estimate: _kitsy_coop_core.TaskEstimate | null;
+        risk: {
+            level?: _kitsy_coop_core.RiskLevel;
+            probability?: number;
+            impact_hours?: number;
+            mitigation?: string;
+            contingency?: string;
+        } | null;
+        resources: _kitsy_coop_core.TaskResources | null;
+        file_path: string;
+        id: string;
+        title: string;
+        type: TaskType;
+        status: TaskStatus;
+        priority: _kitsy_coop_core.TaskPriority | null;
+        track: string | null;
+        assignee: string | null;
+        delivery: string | null;
+        depends_on: string[];
+        blocks: string[];
+        tags: string[];
+    };
+    graphNext(filters?: GraphNextFilters): {
+        id: string;
+        title: string;
+        score: number;
+        track: string | null;
+        priority: _kitsy_coop_core.TaskPriority | null;
+        fits_capacity: boolean;
+        fits_wip: boolean;
+    }[];
+    planDelivery(nameOrId: string, today?: string): {
+        delivery: {
+            id: string;
+            name: string;
+            status: _kitsy_coop_core.DeliveryStatus;
+            target_date: string | null;
+        };
+        result: _kitsy_coop_core.FeasibilityResult;
+    };
+    transitionTask(input: TransitionTaskInput): {
+        id: string;
+        from: TaskStatus;
+        to: TaskStatus;
+        updated: string;
+    };
+    createTask(input: CreateTaskInput): {
+        file_path: string;
+        id: string;
+        title: string;
+        type: TaskType;
+        status: TaskStatus;
+        priority: _kitsy_coop_core.TaskPriority | null;
+        track: string | null;
+        assignee: string | null;
+        delivery: string | null;
+        depends_on: string[];
+        blocks: string[];
+        tags: string[];
+    };
+    listDeliveries(): {
+        id: string;
+        name: string;
+        status: _kitsy_coop_core.DeliveryStatus;
+        target_date: string | null;
+        scope: string[];
+    }[];
+    graphResource(): {
+        nodes: {
+            id: string;
+            title: string;
+            type: TaskType;
+            status: TaskStatus;
+            priority: _kitsy_coop_core.TaskPriority | null;
+            track: string | null;
+            assignee: string | null;
+            delivery: string | null;
+            depends_on: string[];
+            blocks: string[];
+            tags: string[];
+        }[];
+        edges: {
+            from: string;
+            to: string;
+        }[];
+        deliveries: {
+            id: string;
+            name: string;
+            status: _kitsy_coop_core.DeliveryStatus;
+            target_date: string | null;
+            scope: string[];
+        }[];
+    };
+    listTaskResourceUris(): {
+        uri: string;
+        name: string;
+        mimeType: string;
+        description: string;
+    }[];
+    readResource(uri: string): string;
+}
+
+type CoopMcpServerOptions = {
+    repoRoot?: string;
+};
+declare function createCoopMcpServer(options?: CoopMcpServerOptions): {
+    server: McpServer;
+    service: CoopMcpService;
+    repoRoot: string;
 };
-declare const coopMcp: CoopMcpPlaceholder;
+declare function startCoopMcpServer(options?: CoopMcpServerOptions): Promise<McpServer>;
 
-export { type CoopMcpPlaceholder, coopMcp };
+export { type CoopMcpServerOptions, createCoopMcpServer, startCoopMcpServer };

package/dist/index.js

@@ -1,8 +1,667 @@
+#!/usr/bin/env node
+
 // src/index.ts
-var coopMcp = {
-  package: "@kitsy/coop-mcp",
-  status: "planned"
+import path2 from "path";
+import { pathToFileURL } from "url";
+import * as z from "zod/v4";
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/service.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import crypto from "crypto";
+import { spawnSync } from "child_process";
+import {
+  TaskStatus,
+  TaskType,
+  analyze_feasibility,
+  load_graph,
+  parseTaskFile,
+  parseYamlFile,
+  schedule_next,
+  transition,
+  validateStructural,
+  writeTask
+} from "@kitsy/coop-core";
+function toIsoDate(value = /* @__PURE__ */ new Date()) {
+  return value.toISOString().slice(0, 10);
+}
+function sanitizeIdPart(input, fallback, maxLength = 16) {
+  const normalized = input.toUpperCase().replace(/[^A-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
+  if (!normalized) return fallback;
+  return normalized.slice(0, maxLength);
+}
+function inferActor(root) {
+  const envValue = process.env.COOP_ID_NAMESPACE || process.env.GIT_AUTHOR_NAME || process.env.GIT_COMMITTER_NAME || process.env.GIT_AUTHOR_EMAIL || process.env.GIT_COMMITTER_EMAIL || process.env.USERNAME || process.env.USER;
+  if (envValue) {
+    return envValue.split("@")[0] ?? envValue;
+  }
+  const email = spawnSync("git", ["config", "--get", "user.email"], {
+    cwd: root,
+    encoding: "utf8",
+    windowsHide: true
+  }).stdout.trim();
+  if (email) {
+    return email.split("@")[0] ?? email;
+  }
+  const name = spawnSync("git", ["config", "--get", "user.name"], {
+    cwd: root,
+    encoding: "utf8",
+    windowsHide: true
+  }).stdout.trim();
+  if (name) return name;
+  return os.userInfo().username;
+}
+function shortDateToken(now = /* @__PURE__ */ new Date()) {
+  return now.toISOString().slice(2, 10).replace(/-/g, "");
+}
+function randomToken() {
+  return crypto.randomBytes(4).toString("hex").toUpperCase();
+}
+function readConfig(root) {
+  const configPath = path.join(root, ".coop", "config.yml");
+  if (!fs.existsSync(configPath)) {
+    return {};
+  }
+  return parseYamlFile(configPath);
+}
+function sequenceForPattern(existingIds, prefix, suffix) {
+  const escapedPrefix = prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const escapedSuffix = suffix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(`^${escapedPrefix}(\\d+)${escapedSuffix}$`);
+  let max = 0;
+  for (const id of existingIds) {
+    const match = regex.exec(id);
+    if (!match) continue;
+    const next = Number(match[1]);
+    if (Number.isInteger(next) && next > max) {
+      max = next;
+    }
+  }
+  return max + 1;
+}
+function renderIdTemplate(root, existingIds, input) {
+  const config = readConfig(root);
+  const prefix = sanitizeIdPart(config.id_prefixes?.task ?? "PM", "PM", 12);
+  const actor = sanitizeIdPart(inferActor(root), "USER", 16);
+  const title = sanitizeIdPart(input.title, "TASK", 24);
+  const track = sanitizeIdPart(input.track ?? "UNASSIGNED", "UNASSIGNED", 16);
+  const status = sanitizeIdPart(input.status ?? "TODO", "TODO", 16);
+  const type = sanitizeIdPart(input.type ?? "TASK", "TASK", 16);
+  const template = config.id?.naming?.trim() || "<TYPE>-<USER>-<YYMMDD>-<RAND>";
+  const seqPadding = Number.isInteger(config.id?.seq_padding) ? Number(config.id?.seq_padding) : 0;
+  const base = template.replace(/<([^>]+)>/g, (_, rawToken) => {
+    const token = rawToken.toUpperCase();
+    if (token === "PREFIX") return prefix;
+    if (token === "TYPE" || token === "ENTITY") return type;
+    if (token === "USER") return actor;
+    if (token === "YYMMDD") return shortDateToken();
+    if (token === "RAND") return randomToken();
+    if (token === "TITLE") return title;
+    if (token === "TRACK") return track;
+    if (token === "STATUS") return status;
+    if (token === "SEQ") return "__SEQ__";
+    return sanitizeIdPart(token, token);
+  });
+  const normalized = sanitizeIdPart(base, "PM-TASK", 64);
+  if (!normalized.includes("__SEQ__")) {
+    return normalized;
+  }
+  const upperExisting = existingIds.map((id) => id.toUpperCase());
+  const [head, tail] = normalized.split("__SEQ__");
+  const next = sequenceForPattern(upperExisting, head ?? "", tail ?? "");
+  const sequence = seqPadding > 0 ? String(next).padStart(seqPadding, "0") : String(next);
+  return `${head ?? ""}${sequence}${tail ?? ""}`;
+}
+function walkFiles(dirPath) {
+  if (!fs.existsSync(dirPath)) return [];
+  const out = [];
+  for (const entry of fs.readdirSync(dirPath, { withFileTypes: true })) {
+    const fullPath = path.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...walkFiles(fullPath));
+      continue;
+    }
+    if (entry.isFile() && fullPath.toLowerCase().endsWith(".md")) {
+      out.push(fullPath);
+    }
+  }
+  return out.sort((a, b) => a.localeCompare(b));
+}
+function taskFileById(root, id) {
+  const taskDir = path.join(root, ".coop", "tasks");
+  const wanted = `${id}.md`.toLowerCase();
+  const match = walkFiles(taskDir).find((filePath) => path.basename(filePath).toLowerCase() === wanted);
+  if (!match) {
+    throw new Error(`Task '${id}' not found.`);
+  }
+  return match;
+}
+function resolveDelivery(graph, nameOrId) {
+  const direct = graph.deliveries.get(nameOrId);
+  if (direct) return direct;
+  const match = Array.from(graph.deliveries.values()).find(
+    (delivery) => delivery.name.toLowerCase() === nameOrId.toLowerCase()
+  );
+  if (match) return match;
+  throw new Error(`Delivery '${nameOrId}' not found.`);
+}
+function deliveryScopeIds(delivery) {
+  const include = new Set(delivery.scope.include);
+  for (const excluded of delivery.scope.exclude) {
+    include.delete(excluded);
+  }
+  return include;
+}
+function taskSummary(graph, task) {
+  return {
+    id: task.id,
+    title: task.title,
+    type: task.type,
+    status: task.status,
+    priority: task.priority ?? null,
+    track: task.track ?? null,
+    assignee: task.assignee ?? null,
+    delivery: task.delivery ?? null,
+    depends_on: task.depends_on ?? [],
+    blocks: Array.from(graph.reverse.get(task.id) ?? /* @__PURE__ */ new Set()).sort((a, b) => a.localeCompare(b)),
+    tags: task.tags ?? []
+  };
+}
+function textJson(value) {
+  return JSON.stringify(value, null, 2);
+}
+function resolveRepoRoot(start = process.cwd()) {
+  let current = path.resolve(start);
+  while (true) {
+    if (fs.existsSync(path.join(current, ".coop"))) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return path.resolve(start);
+    }
+    current = parent;
+  }
+}
+var CoopMcpService = class {
+  repoRoot;
+  coopDir;
+  constructor(repoRoot = resolveRepoRoot(process.env.COOP_REPO_ROOT ?? process.cwd())) {
+    this.repoRoot = path.resolve(repoRoot);
+    this.coopDir = path.join(this.repoRoot, ".coop");
+    if (!fs.existsSync(this.coopDir)) {
+      throw new Error(`Missing .coop directory at ${this.coopDir}.`);
+    }
+  }
+  loadGraph() {
+    return load_graph(this.coopDir);
+  }
+  workspaceInfo() {
+    const config = readConfig(this.repoRoot);
+    const repoName = path.basename(this.repoRoot);
+    return {
+      instance: {
+        id: config.project?.id?.trim() || repoName,
+        name: config.project?.name?.trim() || repoName,
+        aliases: (config.project?.aliases ?? []).filter((entry) => typeof entry === "string" && entry.trim().length > 0)
+      },
+      repo: {
+        name: repoName,
+        root: this.repoRoot
+      }
+    };
+  }
+  listTasks(filters = {}) {
+    const graph = this.loadGraph();
+    let tasks = Array.from(graph.nodes.values());
+    if (filters.delivery) {
+      const delivery = resolveDelivery(graph, filters.delivery);
+      const scopeIds = deliveryScopeIds(delivery);
+      tasks = tasks.filter((task) => scopeIds.has(task.id));
+    }
+    if (filters.status) {
+      tasks = tasks.filter((task) => task.status === filters.status);
+    }
+    if (filters.track) {
+      tasks = tasks.filter((task) => (task.track ?? "unassigned") === filters.track);
+    }
+    if (filters.assignee) {
+      tasks = tasks.filter((task) => (task.assignee ?? "") === filters.assignee);
+    }
+    tasks.sort((a, b) => a.id.localeCompare(b.id));
+    const limit = typeof filters.limit === "number" && filters.limit > 0 ? filters.limit : void 0;
+    const limited = typeof limit === "number" ? tasks.slice(0, limit) : tasks;
+    return limited.map((task) => taskSummary(graph, task));
+  }
+  showTask(id) {
+    const graph = this.loadGraph();
+    const filePath = taskFileById(this.repoRoot, id);
+    const parsed = parseTaskFile(filePath);
+    const task = graph.nodes.get(parsed.task.id) ?? parsed.task;
+    return {
+      ...taskSummary(graph, task),
+      created: task.created,
+      updated: task.updated,
+      body: parsed.body,
+      raw: parsed.raw,
+      execution: task.execution ?? null,
+      estimate: task.estimate ?? null,
+      risk: task.risk ?? null,
+      resources: task.resources ?? null,
+      file_path: path.relative(this.repoRoot, filePath).replace(/\\/g, "/")
+    };
+  }
+  graphNext(filters = {}) {
+    const graph = this.loadGraph();
+    return schedule_next(graph, {
+      track: filters.track,
+      today: filters.today,
+      limit: filters.limit
+    }).map((entry) => ({
+      id: entry.task.id,
+      title: entry.task.title,
+      score: Number(entry.score.toFixed(2)),
+      track: entry.task.track ?? null,
+      priority: entry.task.priority ?? null,
+      fits_capacity: entry.fits_capacity,
+      fits_wip: entry.fits_wip
+    }));
+  }
+  planDelivery(nameOrId, today) {
+    const graph = this.loadGraph();
+    const delivery = resolveDelivery(graph, nameOrId);
+    const result = analyze_feasibility(delivery.id, graph, today ?? /* @__PURE__ */ new Date());
+    return {
+      delivery: {
+        id: delivery.id,
+        name: delivery.name,
+        status: delivery.status,
+        target_date: delivery.target_date
+      },
+      result
+    };
+  }
+  transitionTask(input) {
+    const target = input.status.toLowerCase();
+    if (!Object.values(TaskStatus).includes(target)) {
+      throw new Error(`Invalid target status '${input.status}'.`);
+    }
+    const graph = this.loadGraph();
+    const filePath = taskFileById(this.repoRoot, input.id);
+    const parsed = parseTaskFile(filePath);
+    const dependencyStatuses = /* @__PURE__ */ new Map();
+    for (const depId of parsed.task.depends_on ?? []) {
+      const depTask = graph.nodes.get(depId);
+      if (depTask) {
+        dependencyStatuses.set(depId, depTask.status);
+      }
+    }
+    const result = transition(parsed.task, target, {
+      actor: input.actor ?? inferActor(this.repoRoot),
+      dependencyStatuses
+    });
+    if (!result.success) {
+      throw new Error(result.error ?? "Transition failed.");
+    }
+    const structural = validateStructural(result.task, { filePath });
+    if (structural.length > 0) {
+      throw new Error(structural.map((issue) => issue.message).join(" | "));
+    }
+    writeTask(result.task, {
+      body: parsed.body,
+      raw: parsed.raw,
+      filePath
+    });
+    return {
+      id: result.task.id,
+      from: parsed.task.status,
+      to: result.task.status,
+      updated: result.task.updated
+    };
+  }
+  createTask(input) {
+    if (!input.title?.trim()) {
+      throw new Error("Field 'title' is required.");
+    }
+    const graph = this.loadGraph();
+    const type = (input.type ?? "feature").toLowerCase();
+    if (!Object.values(TaskType).includes(type)) {
+      throw new Error(`Invalid task type '${String(input.type)}'.`);
+    }
+    const status = (input.status ?? "todo").toLowerCase();
+    if (!Object.values(TaskStatus).includes(status)) {
+      throw new Error(`Invalid task status '${String(input.status)}'.`);
+    }
+    const id = input.id?.trim().toUpperCase() || renderIdTemplate(this.repoRoot, Array.from(graph.nodes.keys()), input);
+    if (graph.nodes.has(id)) {
+      throw new Error(`Task '${id}' already exists.`);
+    }
+    const filePath = path.join(this.coopDir, "tasks", `${id}.md`);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const task = {
+      id,
+      title: input.title.trim(),
+      type,
+      status,
+      created: toIsoDate(),
+      updated: toIsoDate(),
+      priority: input.priority ? input.priority.toLowerCase() : "p2",
+      track: input.track?.trim() || "unassigned",
+      assignee: input.assignee?.trim() || null,
+      delivery: input.delivery?.trim() || null,
+      tags: input.tags?.filter(Boolean) ?? [],
+      depends_on: input.depends_on?.filter(Boolean) ?? []
+    };
+    const structural = validateStructural(task, { filePath });
+    if (structural.length > 0) {
+      throw new Error(structural.map((issue) => issue.message).join(" | "));
+    }
+    writeTask(task, {
+      body: input.body ?? "",
+      filePath
+    });
+    return {
+      ...taskSummary(this.loadGraph(), task),
+      file_path: path.relative(this.repoRoot, filePath).replace(/\\/g, "/")
+    };
+  }
+  listDeliveries() {
+    const graph = this.loadGraph();
+    return Array.from(graph.deliveries.values()).sort((a, b) => a.id.localeCompare(b.id)).map((delivery) => ({
+      id: delivery.id,
+      name: delivery.name,
+      status: delivery.status,
+      target_date: delivery.target_date,
+      scope: Array.from(deliveryScopeIds(delivery)).sort((a, b) => a.localeCompare(b))
+    }));
+  }
+  graphResource() {
+    const graph = this.loadGraph();
+    return {
+      nodes: Array.from(graph.nodes.values()).sort((a, b) => a.id.localeCompare(b.id)).map((task) => taskSummary(graph, task)),
+      edges: Array.from(graph.forward.entries()).flatMap(([taskId, deps]) => Array.from(deps).map((depId) => ({ from: depId, to: taskId }))).sort((a, b) => `${a.from}:${a.to}`.localeCompare(`${b.from}:${b.to}`)),
+      deliveries: this.listDeliveries()
+    };
+  }
+  listTaskResourceUris() {
+    return this.listTasks().map((task) => ({
+      uri: `coop://tasks/${task.id}`,
+      name: task.id,
+      mimeType: "application/json",
+      description: task.title
+    }));
+  }
+  readResource(uri) {
+    const parsed = new URL(uri);
+    if (parsed.protocol !== "coop:") {
+      throw new Error(`Unsupported resource URI '${uri}'.`);
+    }
+    if (parsed.host === "tasks" && (parsed.pathname === "" || parsed.pathname === "/")) {
+      return textJson(this.listTasks());
+    }
+    if (parsed.host === "tasks" && parsed.pathname.length > 1) {
+      const id = decodeURIComponent(parsed.pathname.slice(1));
+      return textJson(this.showTask(id));
+    }
+    if (parsed.host === "deliveries") {
+      return textJson(this.listDeliveries());
+    }
+    if (parsed.host === "graph") {
+      return textJson(this.graphResource());
+    }
+    if (parsed.host === "workspace") {
+      return textJson(this.workspaceInfo());
+    }
+    throw new Error(`Unsupported resource URI '${uri}'.`);
+  }
 };
+function toolTextResult(value) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: textJson(value)
+      }
+    ]
+  };
+}
+function resourceTextResult(uri, value) {
+  return {
+    contents: [
+      {
+        uri,
+        mimeType: "application/json",
+        text: textJson(value)
+      }
+    ]
+  };
+}
+
+// src/index.ts
+function parseArgs(argv) {
+  let repoRoot;
+  for (let index = 2; index < argv.length; index += 1) {
+    const current = argv[index];
+    if (current === "--repo") {
+      repoRoot = argv[index + 1];
+      index += 1;
+    }
+  }
+  return { repoRoot };
+}
+function createCoopMcpServer(options = {}) {
+  const repoRoot = resolveRepoRoot(options.repoRoot ?? process.env.COOP_REPO_ROOT ?? process.cwd());
+  const service = new CoopMcpService(repoRoot);
+  const server = new McpServer(
+    {
+      name: "@kitsy/coop-mcp",
+      version: "1.0.0"
+    },
+    {
+      capabilities: {
+        logging: {}
+      },
+      instructions: "COOP MCP exposes local Git-native project state and operations from .coop for AI coding agents."
+    }
+  );
+  server.registerTool(
+    "coop_workspace_info",
+    {
+      description: "Show COOP workspace identity and repository metadata.",
+      inputSchema: {},
+      annotations: {
+        title: "COOP Workspace Info",
+        readOnlyHint: true
+      }
+    },
+    async () => toolTextResult(service.workspaceInfo())
+  );
+  server.registerTool(
+    "coop_list_tasks",
+    {
+      description: "List COOP task summaries with optional filters.",
+      inputSchema: {
+        status: z.string().optional(),
+        track: z.string().optional(),
+        assignee: z.string().optional(),
+        delivery: z.string().optional(),
+        limit: z.number().int().positive().optional()
+      },
+      annotations: {
+        title: "List COOP Tasks",
+        readOnlyHint: true
+      }
+    },
+    async (args) => toolTextResult(service.listTasks(args))
+  );
+  server.registerTool(
+    "coop_show_task",
+    {
+      description: "Show full COOP task details, including markdown body and computed blockers.",
+      inputSchema: {
+        id: z.string()
+      },
+      annotations: {
+        title: "Show COOP Task",
+        readOnlyHint: true
+      }
+    },
+    async ({ id }) => toolTextResult(service.showTask(id))
+  );
+  server.registerTool(
+    "coop_graph_next",
+    {
+      description: "Return recommended next tasks from the COOP scheduler.",
+      inputSchema: {
+        track: z.string().optional(),
+        limit: z.number().int().positive().optional(),
+        today: z.string().optional()
+      },
+      annotations: {
+        title: "COOP Graph Next",
+        readOnlyHint: true
+      }
+    },
+    async (args) => toolTextResult(service.graphNext(args))
+  );
+  server.registerTool(
+    "coop_plan_delivery",
+    {
+      description: "Run delivery feasibility planning for a COOP delivery.",
+      inputSchema: {
+        name: z.string(),
+        today: z.string().optional()
+      },
+      annotations: {
+        title: "Plan COOP Delivery",
+        readOnlyHint: true
+      }
+    },
+    async ({ name, today }) => toolTextResult(service.planDelivery(name, today))
+  );
+  server.registerTool(
+    "coop_transition_task",
+    {
+      description: "Transition a COOP task to a new status and persist the change.",
+      inputSchema: {
+        id: z.string(),
+        status: z.string(),
+        actor: z.string().optional()
+      },
+      annotations: {
+        title: "Transition COOP Task",
+        destructiveHint: true
+      }
+    },
+    async (args) => toolTextResult(service.transitionTask(args))
+  );
+  server.registerTool(
+    "coop_create_task",
+    {
+      description: "Create a new COOP task and persist it to .coop/tasks.",
+      inputSchema: {
+        id: z.string().optional(),
+        title: z.string(),
+        type: z.string().optional(),
+        status: z.string().optional(),
+        track: z.string().optional(),
+        priority: z.string().optional(),
+        assignee: z.string().optional(),
+        delivery: z.string().optional(),
+        tags: z.array(z.string()).optional(),
+        depends_on: z.array(z.string()).optional(),
+        body: z.string().optional()
+      },
+      annotations: {
+        title: "Create COOP Task",
+        destructiveHint: true
+      }
+    },
+    async (args) => toolTextResult(service.createTask(args))
+  );
+  server.registerResource(
+    "workspace",
+    "coop://workspace",
+    {
+      title: "COOP Workspace",
+      description: "Workspace identity, aliases, and repository metadata.",
+      mimeType: "application/json"
+    },
+    async () => resourceTextResult("coop://workspace", service.workspaceInfo())
+  );
+  server.registerResource(
+    "tasks",
+    "coop://tasks",
+    {
+      title: "COOP Tasks",
+      description: "All task summaries from the current COOP workspace.",
+      mimeType: "application/json"
+    },
+    async () => resourceTextResult("coop://tasks", service.listTasks())
+  );
+  server.registerResource(
+    "deliveries",
+    "coop://deliveries",
+    {
+      title: "COOP Deliveries",
+      description: "All deliveries from the current COOP workspace.",
+      mimeType: "application/json"
+    },
+    async () => resourceTextResult("coop://deliveries", service.listDeliveries())
+  );
+  server.registerResource(
+    "graph",
+    "coop://graph",
+    {
+      title: "COOP Graph",
+      description: "The current task graph, deliveries, and dependency edges.",
+      mimeType: "application/json"
+    },
+    async () => resourceTextResult("coop://graph", service.graphResource())
+  );
+  server.registerResource(
+    "task",
+    new ResourceTemplate("coop://tasks/{id}", {
+      list: async () => ({
+        resources: service.listTaskResourceUris()
+      }),
+      complete: {
+        id: async (value) => service.listTasks().map((task) => task.id).filter((id) => id.toLowerCase().startsWith(value.toLowerCase()))
+      }
+    }),
+    {
+      title: "COOP Task Resource",
+      description: "An individual COOP task by id.",
+      mimeType: "application/json"
+    },
+    async (uri) => resourceTextResult(uri.toString(), service.showTask(decodeURIComponent(uri.pathname.slice(1))))
+  );
+  return { server, service, repoRoot };
+}
+async function startCoopMcpServer(options = {}) {
+  const { server } = createCoopMcpServer(options);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  return server;
+}
+function isMainModule() {
+  const entryPath = process.argv[1];
+  if (!entryPath) {
+    return false;
+  }
+  return import.meta.url === pathToFileURL(path2.resolve(entryPath)).href;
+}
+if (isMainModule()) {
+  const options = parseArgs(process.argv);
+  startCoopMcpServer(options).catch((error) => {
+    console.error(error instanceof Error ? error.stack ?? error.message : String(error));
+    process.exitCode = 1;
+  });
+}
 export {
-  coopMcp
+  createCoopMcpServer,
+  startCoopMcpServer
 };

package/package.json

@@ -1,17 +1,26 @@
 {
   "name": "@kitsy/coop-mcp",
-  "version": "0.0.1",
+  "version": "1.0.0",
   "type": "module",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "coop-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "import": "./src/index.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     }
   },
   "dependencies": {
-    "@kitsy/coop-core": "0.0.1"
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "zod": "^4.3.6",
+    "@kitsy/coop-core": "1.0.0"
   },
   "devDependencies": {
     "@types/node": "^24.12.0",
@@ -19,7 +28,7 @@
     "typescript": "^5.9.3"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "build": "tsup src/index.ts --format esm --dts --clean",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   }
 }

package/dist/index.cjs

@@ -1,33 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  coopMcp: () => coopMcp
-});
-module.exports = __toCommonJS(index_exports);
-var coopMcp = {
-  package: "@kitsy/coop-mcp",
-  status: "planned"
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  coopMcp
-});

package/dist/index.d.cts

@@ -1,7 +0,0 @@
-type CoopMcpPlaceholder = {
-    readonly package: "@kitsy/coop-mcp";
-    readonly status: "planned";
-};
-declare const coopMcp: CoopMcpPlaceholder;
-
-export { type CoopMcpPlaceholder, coopMcp };

package/src/index.ts

@@ -1,9 +0,0 @@
-export type CoopMcpPlaceholder = {
-  readonly package: "@kitsy/coop-mcp";
-  readonly status: "planned";
-};
-
-export const coopMcp: CoopMcpPlaceholder = {
-  package: "@kitsy/coop-mcp",
-  status: "planned",
-};

package/tsconfig.json

@@ -1,7 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "dist"
-  },
-  "include": ["src/**/*.ts"]
-}