@agent-plan/mcp 0.2.9 → 0.2.11

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AA0vBA,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAItD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AA21BA,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAItD"}

package/dist/index.js

@@ -6,7 +6,8 @@ import { join } from "node:path";
 import { existsSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 import { PlanStore, ExportService, withFeatureLock, needsMotivation } from "@agent-plan/core";
-import { createChecklistItemId, createFeatureId, createPhaseId, createTaskId, normalizeSlug } from "@agent-plan/core/naming";
+import { serve } from "@agent-plan/server";
+import { createChecklistItemId, createFeatureId, createPhaseId, createTaskId, clampSlug, normalizeSlug } from "@agent-plan/core/naming";
 const STATUS_VALUES = ["planned", "in-progress", "done", "blocked", "canceled", "rejected", "deferred", "waiting"];
 const PHASE_STATUS_VALUES = ["draft", "discovery", ...STATUS_VALUES];
 function text(textValue, structuredContent) {
@@ -29,6 +30,67 @@ async function requireStore() {
         throw new Error(`No .planner/ found at ${st.root}. Use planner-init first.`);
     return st;
 }
+// In-process web server handle, managed by the planner-web tool and planner-load.
+// Lives as long as this MCP stdio process (i.e. the host session). Null when not running.
+let webHandle = null;
+/** Start the web dashboard on LAN (0.0.0.0:0, OS-assigned port) if not already
+ *  running. Returns the local/LAN URLs. No-op (empty url) when no .planner/ exists. */
+async function ensureWebStarted() {
+    if (webHandle)
+        return { localUrl: webHandle.localUrl, lanUrl: webHandle.lanUrl, mode: webHandle.mode };
+    const root = planRoot();
+    const st = new PlanStore(root);
+    if (!(await st.exists()))
+        return { localUrl: "" };
+    try {
+        webHandle = await serve({ planRoot: root, host: "0.0.0.0", port: 0, quiet: true });
+        return { localUrl: webHandle.localUrl, lanUrl: webHandle.lanUrl, mode: webHandle.mode };
+    }
+    catch {
+        return { localUrl: "" };
+    }
+}
+/** Build a consolidated planner recap (project state + active work + pending
+ *  handoff + web URL). Harness-agnostic equivalent of Pi's buildStartupResumeSummary. */
+async function buildRecapText(st, web) {
+    const [plan, resume, handoff] = await Promise.all([st.loadAll(), st.loadResume(), st.loadHandoff()]);
+    const allTasks = plan.phases.flatMap((p) => p.tasks.map((t) => ({ phase: p, task: t })));
+    const totalF = plan.features.features.length;
+    const doneF = plan.features.features.filter((f) => f.status === "done").length;
+    const activeF = plan.features.features.filter((f) => f.status === "in-progress").length;
+    const totalP = plan.phases.length;
+    const doneP = plan.phases.filter((p) => p.status === "done").length;
+    const activeP = plan.phases.filter((p) => p.status === "in-progress" || p.status === "discovery").length;
+    const totalT = allTasks.length;
+    const doneT = allTasks.filter(({ task }) => task.status === "done").length;
+    const activeT = allTasks.filter(({ task }) => task.status === "in-progress").length;
+    const inProgress = allTasks.filter(({ task }) => task.status === "in-progress");
+    const focus = inProgress[0];
+    const focusFeature = focus ? plan.features.features.find((f) => f.id === focus.phase.featureId) : undefined;
+    const lines = [];
+    lines.push("## Planner recap");
+    const name = plan.project.name || "(unnamed project)";
+    lines.push(`Project: ${name}${plan.project.goal ? " — " + plan.project.goal : ""}`);
+    lines.push(`Progress: Features ${doneF}/${totalF} done (${activeF} active) · Phases ${doneP}/${totalP} done (${activeP} active) · Tasks ${doneT}/${totalT} done (${activeT} active)`);
+    if (focus) {
+        lines.push(`Current focus: ${focusFeature?.name ?? "?"} / ${focus.phase.title} / ${focus.task.title} (in-progress)`);
+    }
+    else {
+        lines.push("Current focus: no active task — review the plan and pick the next concrete task");
+    }
+    if (resume?.nextSteps?.length)
+        lines.push(`Next step: ${resume.nextSteps[0]}`);
+    if (handoff) {
+        lines.push("", "## Pending handoff (read me first)", handoff.content || "(empty handoff)", "", "→ After processing the handoff above, call planner-handoff-clear to remove it.");
+    }
+    else if (activeT === 0) {
+        lines.push("", "No handoff pending and no task in-progress. Use planner-task-add / planner-task-start to begin work.");
+    }
+    if (web.localUrl) {
+        lines.push("", "## Web UI", `🌐 ${web.localUrl}${web.lanUrl ? " (LAN: " + web.lanUrl + ")" : ""}`);
+    }
+    return lines.join("\n");
+}
 function findFeatureByRef(features, ref) {
     const normalized = ref.trim().toLowerCase();
     return features.find((feature) => feature.id.toLowerCase() === normalized)
@@ -504,7 +566,7 @@ server.registerTool("planner-task-add", {
         id: taskId,
         phaseId: found.id,
         number: found.tasks.length + 1,
-        shortName: normalizeSlug(title).slice(0, 30),
+        shortName: clampSlug(title, 30, `task-${Date.now().toString(36)}`),
         title: title.trim(),
         status: "planned",
         description: description?.trim() ?? "",
@@ -640,12 +702,13 @@ server.registerTool("planner-task-start", {
     inputSchema: { task: z.string().min(1) },
 }, async ({ task: ref }) => {
     const st = await requireStore();
-    // Hygiene Gate: block starting work if a pending handoff exists.
-    if (existsSync(join(st.root, "HANDOFF.md"))) {
-        return text(`🚨 HYGIENE VIOLATION: A pending handoff file exists at .planner/HANDOFF.md. ` +
-            `You MUST read and delete it before you can officially start a task. ` +
-            `This is a non-negotiable rule in AGENTS.md.`);
-    }
+    // Hygiene notice (non-blocking): surface an existing handoff but never block
+    // task_start — the handoff is a captured-context artifact, not a lock (e.g. a
+    // small modification after writing a handoff should start without forcing
+    // deletion, which would lose context).
+    const handoffNotice = existsSync(join(st.root, "HANDOFF.md"))
+        ? "ℹ️  A handoff exists at .planner/HANDOFF.md — read it for context, then delete it with planner-handoff-delete when no longer needed. Proceeding with task start.\n"
+        : "";
     const found = findTaskByRef(await st.loadAllPhases(), ref);
     if (!found)
         return text(`Task not found: ${ref}`);
@@ -673,7 +736,7 @@ server.registerTool("planner-task-start", {
         return phase;
     });
     await st.syncTaskStatusRollup(found.phase.id);
-    return writeAndSummarize(st, `✅ Task started: ${found.task.id}`, { task: updatedTask ?? found.task });
+    return writeAndSummarize(st, `${handoffNotice}✅ Task started: ${found.task.id}`, { task: updatedTask ?? found.task });
 });
 server.registerTool("planner-task-complete", {
     description: "Set a task to done. Fails if checklist is incomplete unless force=true.",
@@ -754,14 +817,55 @@ server.registerTool("planner-handoff-clear", {
     return text("Deleted .planner/HANDOFF.md");
 });
 server.registerTool("planner-web", {
-    description: "Planner web command placeholder for MCP stdio. Use plan-server CLI directly for now.",
+    description: "Manage the planner web dashboard (start/status/stop) from MCP stdio. Runs an in-process HTTP+WS server bound to LAN; it lives as long as this MCP process. plan-root comes from AGENT_PLAN_ROOT or cwd()/.planner.",
     inputSchema: {
         action: z.enum(["start", "stop", "status"]).default("status"),
     },
-}, async ({ action }) => text(`planner-web ${action}: MCP stdio package does not manage the web server yet. Use \`pnpm --filter @agent-plan/server build\` and the plan-server CLI, or Pi /planner web ${action}.`));
+}, async ({ action }) => {
+    if (action === "start") {
+        if (webHandle) {
+            return text(`planner-web already running: ${webHandle.localUrl}${webHandle.lanUrl ? ` — LAN: ${webHandle.lanUrl}` : ""} (mode: ${webHandle.mode})`);
+        }
+        const root = planRoot();
+        const storeCheck = new PlanStore(root);
+        if (!(await storeCheck.exists())) {
+            return text(`planner-web start: no .planner/ found at ${root}. Run planner-init first.`);
+        }
+        try {
+            // port: 0 → OS assigns a free port (no conflict with plan-server CLI / Pi).
+            // host: 0.0.0.0 → bind LAN (reachable from other devices), like Pi /planner load.
+            webHandle = await serve({ planRoot: root, host: "0.0.0.0", port: 0, quiet: true });
+            return text(`planner-web started: ${webHandle.localUrl}${webHandle.lanUrl ? ` — LAN: ${webHandle.lanUrl}` : ""} (mode: ${webHandle.mode})`);
+        }
+        catch (err) {
+            webHandle = null;
+            return text(`planner-web start failed: ${err.message}`);
+        }
+    }
+    if (action === "stop") {
+        if (!webHandle)
+            return text("planner-web not running.");
+        const stoppedUrl = webHandle.localUrl;
+        await webHandle.close().catch(() => { });
+        webHandle = null;
+        return text(`planner-web stopped (was ${stoppedUrl}).`);
+    }
+    // status
+    if (webHandle) {
+        return text(`planner-web running: ${webHandle.localUrl}${webHandle.lanUrl ? ` — LAN: ${webHandle.lanUrl}` : ""} (mode: ${webHandle.mode}, bindHost: ${webHandle.bindHost})`);
+    }
+    return text("planner-web not running. Use planner-web with action=start to start the dashboard.");
+});
 server.registerTool("planner-load", {
-    description: "MCP no-op equivalent of Pi /planner load. MCP server is already loaded when tools are available.",
-}, async () => text("Planner MCP server is loaded."));
+    description: "Load/refresh the planner on explicit user request (NOT automatic): starts the web dashboard on LAN and returns a consolidated recap (project state, active task, pending handoff, web URL). This is the MCP equivalent of Pi /planner load. Call it ONLY when the user runs /planner load or /planner recap (or asks to load the planner). Present the recap to the user in that reply, including the web URL on a final prominent line. If a pending handoff is included, read it, summarize it to the user, then call planner-handoff-clear. Do NOT start the planner/web or show the web URL unless the user explicitly asks (load/recap/web status).",
+}, async () => {
+    const st = store();
+    if (!(await st.exists()))
+        return text("No .planner/ found at " + planRoot() + ". Run planner-init first.");
+    const web = await ensureWebStarted();
+    const recap = await buildRecapText(st, web);
+    return text(recap);
+});
 server.registerTool("planner-disable", {
     description: "MCP no-op equivalent of Pi /planner disable. Stop the MCP process from the host to disable it.",
 }, async () => text("To disable planner MCP, remove/disable this MCP server from the host config or stop the process."));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-plan/mcp",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "private": false,
   "description": "MCP server for Agent Plan, exposing planner-* tools over stdio.",
   "license": "MIT",
@@ -41,7 +41,8 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.17.0",
     "zod": "^3.24.0",
-    "@agent-plan/core": "0.2.9"
+    "@agent-plan/core": "0.2.11",
+    "@agent-plan/server": "0.2.11"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",