@kaddo/mcp 3.106.0 → 3.107.0

package/dist/index.js

@@ -19055,6 +19055,110 @@ function materializeCandidate(dir, id, candidateId) {
   if (!updated) throw new InitiativeWriteError("Failed to parse the Initiative after materialization.");
   return { workItemId: wiId, fileName, initiative: updated };
 }
+var SUCCESS_HEADING_RE = /^#{1,6}\s*(success criteria|criterios de[ét]xito|criterios de éxito)\s*$/i;
+var HEADING_RE2 = /^#{1,6}\s+/;
+var CHECK_ITEM_RE = /^\s*[-*]\s+\[([ xX])\]\s+(.*)$/;
+var BULLET_RE2 = /^\s*[-*]\s+(.*)$/;
+var PLACEHOLDER_RE = /^_.*_$/;
+function parseSuccessCriteria(body) {
+  const lines = body.split(/\r?\n/);
+  const out = [];
+  let capture = false;
+  for (const line of lines) {
+    if (capture && HEADING_RE2.test(line)) break;
+    if (!capture) {
+      if (SUCCESS_HEADING_RE.test(line.trim())) capture = true;
+      continue;
+    }
+    const check = line.match(CHECK_ITEM_RE);
+    if (check) {
+      const text22 = check[2].trim();
+      if (text22 && !PLACEHOLDER_RE.test(text22)) {
+        out.push({ text: text22, checked: check[1].toLowerCase() === "x" });
+      }
+      continue;
+    }
+    const bullet = line.match(BULLET_RE2);
+    if (bullet) {
+      const text22 = bullet[1].trim();
+      if (text22 && !PLACEHOLDER_RE.test(text22)) out.push({ text: text22, checked: null });
+    }
+  }
+  return out;
+}
+function analyzeInitiative(dir, ini) {
+  const progress = computeInitiativeProgress(dir, ini);
+  const successCriteria = parseSuccessCriteria(ini.body);
+  const pendingCandidates = ini.candidates.filter((c) => !c.materializedAs);
+  const associated = associatedWorkItems(dir, ini.id);
+  const findings = [];
+  if (successCriteria.length === 0) {
+    findings.push({
+      code: "no-success-criteria",
+      severity: "warning",
+      message: "The Initiative has no explicit Success Criteria; completion cannot be judged by outcome, only by delivery."
+    });
+  } else {
+    const uncovered = successCriteria.filter((c) => c.checked === false);
+    if (uncovered.length > 0) {
+      findings.push({
+        code: "uncovered-success-criteria",
+        severity: "blocking",
+        message: `${uncovered.length} success criterion/criteria remain uncovered.`,
+        items: uncovered.map((c) => c.text)
+      });
+    }
+  }
+  if (pendingCandidates.length > 0) {
+    findings.push({
+      code: "pending-candidates",
+      severity: "blocking",
+      message: `${pendingCandidates.length} committed candidate(s) not yet materialized into Work Items.`,
+      items: pendingCandidates.map((c) => `${c.id}: ${c.title}`)
+    });
+  }
+  const notCompleted = associated.filter((w3) => w3.status !== "completed" && w3.status !== "archived");
+  if (associated.length === 0) {
+    findings.push({
+      code: "no-delivery",
+      severity: "info",
+      message: "No Work Items are associated with this Initiative yet."
+    });
+  } else if (notCompleted.length > 0) {
+    findings.push({
+      code: "incomplete-delivery",
+      severity: "blocking",
+      message: `${notCompleted.length} associated Work Item(s) are not completed.`,
+      items: notCompleted.map((w3) => `${w3.id} (${w3.status})`)
+    });
+  }
+  return {
+    initiative: ini.id,
+    status: ini.status,
+    progress,
+    successCriteria,
+    pendingCandidates,
+    findings,
+    suggestedCandidates: pendingCandidates
+  };
+}
+function evaluateInitiativeCompletion(dir, ini) {
+  const analysis = analyzeInitiative(dir, ini);
+  const reasons = [];
+  for (const f3 of analysis.findings) {
+    if (f3.severity === "blocking") reasons.push(f3.message);
+  }
+  if (analysis.progress.delivery.total === 0 && analysis.pendingCandidates.length === 0) {
+    reasons.push("Nothing has been delivered or committed under this Initiative.");
+  }
+  const ready = reasons.length === 0;
+  return {
+    initiative: ini.id,
+    ready,
+    readiness: ready ? "ready" : "not-ready",
+    reasons
+  };
+}
 
 // src/tools.ts
 var ok = (data) => ({ ok: true, data });
@@ -22673,6 +22777,30 @@ function materializeInitiativeCandidateTool(root, args) {
     () => materializeCandidate(root, args.id, args.candidateId)
   );
 }
+function analyzeInitiativeTool(root, id) {
+  const ini = getInitiative(root, id);
+  if (!ini) return fail4(`Initiative ${id} not found.`);
+  return ok5(analyzeInitiative(root, ini));
+}
+function completeInitiativeTool(root, args) {
+  const ini = getInitiative(root, args.id);
+  if (!ini) return fail4(`Initiative ${args.id} not found.`);
+  const readiness = evaluateInitiativeCompletion(root, ini);
+  if (!args.confirm) {
+    return ok5({
+      action: "complete-initiative",
+      readiness,
+      instruction: readiness.ready ? "Initiative looks ready. Call again with confirm=true to complete (human decision)." : "Initiative is NOT ready (see readiness.reasons). Completion requires an explicit human decision: call again with confirm=true only if the human chooses to complete anyway."
+    });
+  }
+  try {
+    const done = transitionInitiative(root, args.id, "completed");
+    return ok5({ applied: true, readiness, result: { id: done.id, status: done.status } });
+  } catch (err) {
+    if (err instanceof InitiativeWriteError) return fail4(err.message);
+    throw err;
+  }
+}
 
 // src/server.ts
 var SERVER_NAME = "kaddo";
@@ -23156,6 +23284,24 @@ function createServer(root) {
     },
     async (args) => toolText(guarded(root, () => materializeInitiativeCandidateTool(root, args)))
   );
+  server.registerTool(
+    "kaddo_analyze_initiative",
+    {
+      title: "Analyze initiative",
+      description: `Read-only gap analysis: success-criteria coverage, pending candidates, delivery status, grounded findings, and the Initiative's own pending candidates as suggestions. Never invents work. ${INITIATIVE_READ_NOTE}`,
+      inputSchema: { id: z4.string() }
+    },
+    async (args) => toolText(guarded(root, () => analyzeInitiativeTool(root, args.id)))
+  );
+  server.registerTool(
+    "kaddo_complete_initiative",
+    {
+      title: "Complete initiative",
+      description: "Human-gated completion. Without confirm returns completion readiness (does NOT complete). With confirm=true transitions the Initiative to completed; readiness findings are returned either way so uncovered scope stays visible. Never completes autonomously.",
+      inputSchema: { id: z4.string(), confirm: z4.boolean().optional() }
+    },
+    async (args) => toolText(guarded(root, () => completeInitiativeTool(root, args)))
+  );
   server.registerTool(
     "kaddo_telemetry_status",
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaddo/mcp",
-  "version": "3.106.0",
+  "version": "3.107.0",
   "description": "MCP server for Kaddo project knowledge: read-only resources/tools/prompts plus safe derived generation under .kaddo/.",
   "license": "MIT",
   "repository": {