@kaddo/mcp 3.129.0 → 3.129.2

package/dist/index.js

@@ -25921,101 +25921,97 @@ function relFromDir(dir, filePath) {
 function sha256(content) {
   return createHash3("sha256").update(content, "utf-8").digest("hex");
 }
-var GENERIC_HEADINGS = /* @__PURE__ */ new Set([
-  "purpose",
-  "proposito",
-  "prop\xF3sito",
-  "intent",
-  "goal",
-  "objetivo",
-  "summary",
-  "resumen",
-  "overview",
-  "context",
-  "contexto",
-  "scope",
-  "alcance",
-  "out of scope",
-  "fuera de alcance",
-  "acceptance criteria",
-  "criterios de aceptacion",
-  "criterios de aceptaci\xF3n",
-  "validation",
-  "validation scenarios",
-  "validacion",
-  "validaci\xF3n",
-  "escenarios de validacion",
-  "escenarios de validaci\xF3n",
-  "notes",
-  "notas",
-  "references",
-  "referencias",
-  "examples",
-  "ejemplos",
-  "learning",
-  "learnings",
-  "aprendizaje",
-  "aprendizajes",
-  // Work Item template sections
-  "problem",
-  "problema",
-  "expected result",
-  "resultado esperado",
-  "refinement",
-  "refinamiento",
-  "implementation guidance",
-  "guia de implementacion",
-  "gu\xEDa de implementaci\xF3n",
-  "definition of done",
-  "definicion de hecho",
-  "definici\xF3n de hecho",
-  "commit gate",
-  "future evolution",
-  "evolucion futura",
-  "evoluci\xF3n futura",
-  "guiding principle",
-  "principio rector",
-  "open questions",
-  "preguntas abiertas",
-  "dependencies",
-  "dependencias",
-  "conceptual model",
-  "goal"
-]);
-var RULE_KEYWORDS = [
-  "siempre",
-  "nunca",
-  "debe",
-  "deben",
-  "requiere",
-  "requieren",
-  "invariante",
-  "restriccion",
-  "restricci\xF3n",
-  "regla",
-  "obligatorio",
-  "must",
-  "always",
-  "never",
-  "require",
-  "requires",
-  "constraint",
-  "invariant",
-  "rule"
-];
-function normalizeHeading(h2) {
-  return h2.trim().toLowerCase().replace(/\s+/g, " ");
+var SHINGLE_SIZE = 6;
+var MIN_SHARED_RUN = 6;
+function stripNoise(text3) {
+  return text3.replace(/```[\s\S]*?```/g, " ").replace(/`[^`]*`/g, " ").replace(/https?:\/\/\S+|www\.\S+/gi, " ");
 }
-function distinctiveHeadings(body) {
-  const out = [];
-  for (const line of body.split(/\r?\n/)) {
-    const m2 = line.match(/^#{2,3}\s+(.+?)\s*$/);
-    if (!m2) continue;
-    const norm = normalizeHeading(m2[1]);
-    if (!norm || GENERIC_HEADINGS.has(norm)) continue;
-    out.push(norm);
+function contentBlocks(body) {
+  const blocks = [];
+  let cur = [];
+  let inFence = false;
+  const flush = () => {
+    if (cur.length) blocks.push(cur);
+    cur = [];
+  };
+  for (const raw of body.split(/\r?\n/)) {
+    const t = raw.trim();
+    if (/^```/.test(t)) {
+      inFence = !inFence;
+      flush();
+      continue;
+    }
+    if (inFence) continue;
+    if (t === "" || /^#{1,6}\s/.test(t) || /^>/.test(t)) {
+      flush();
+      continue;
+    }
+    const isListItem = /^([-*+]\s+|\d+\.\s+)/.test(t);
+    if (isListItem) flush();
+    const text3 = stripNoise(t.replace(/^([-*+]\s+|\d+\.\s+)/, ""));
+    const matched = text3.toLowerCase().match(/[a-záéíóúñü0-9]+/gi);
+    if (matched) cur.push(...matched);
   }
-  return [...new Set(out)];
+  flush();
+  return blocks;
+}
+function buildShingles(body) {
+  const blocks = contentBlocks(body);
+  const set = /* @__PURE__ */ new Set();
+  for (const block of blocks) {
+    for (let i = 0; i + SHINGLE_SIZE <= block.length; i++) {
+      set.add(block.slice(i, i + SHINGLE_SIZE).join(" "));
+    }
+  }
+  return { blocks, set };
+}
+function longestSharedRun(a2, b2) {
+  let best = 0;
+  let bestSnippet = "";
+  for (const block of a2.blocks) {
+    let run = 0;
+    let runStart = 0;
+    for (let i = 0; i + SHINGLE_SIZE <= block.length; i++) {
+      const key = block.slice(i, i + SHINGLE_SIZE).join(" ");
+      if (b2.set.has(key)) {
+        if (run === 0) runStart = i;
+        run += 1;
+        if (run > best) {
+          best = run;
+          bestSnippet = block.slice(runStart, runStart + SHINGLE_SIZE + run - 1).join(" ");
+        }
+      } else {
+        run = 0;
+      }
+    }
+  }
+  return { length: best, snippet: bestSnippet };
+}
+var NORMATIVE_RE = /(^|[^a-záéíóúñü])(must|should|shall|debe[ns]?|deber[ií]a[ns]?|se\s+debe|hay\s+que|requiere[ns]?|require[sd]?|no\s+debe|invariant[e]?|invariants|restricci[oó]n|constraint|regla|obligatori[oa])([^a-záéíóúñü]|$)/i;
+var PAST_RESULT_RE = /(compil[aoeéó]\w*|compiled|benchmark\w*|passed|succeed\w*|succeeded|ran\s+successfully|ejecut\w*|resultad\w*|crates?\b|ns\/op|µs\b|throughput|latenc\w*|baseline|measured|medid\w*|\d+\s*%|\bx\d|faster|slower)/i;
+var TEST_RE = /(\btest\w*|\bpruebas?\b|coverage|cobertura|verde[s]?|green\b|assert\w*)/i;
+var BENCH_RE = /(benchmark\w*|ns\/op|µs\b|throughput|latenc\w*|ops\/s|\d+\s*%|faster|slower|baseline)/i;
+var EXPERIMENT_RE = /(experiment\w*|experiment[oa]\w*|prototyp\w*|prototip\w*|spike\b|probamos|probé|intentamos)/i;
+function splitSentences(text3) {
+  return text3.replace(/\s+/g, " ").split(/(?<=[.!?;])\s+/).map((s) => s.trim()).filter(Boolean);
+}
+function classifyLearningSentence(sentence) {
+  const s = sentence.trim();
+  if (!s) return "none";
+  const normative = NORMATIVE_RE.test(s);
+  const pastResult = PAST_RESULT_RE.test(s);
+  if (normative && !pastResult) return "durable-rule";
+  if (BENCH_RE.test(s)) return "benchmark-evidence";
+  if (pastResult) return "historical-result";
+  if (TEST_RE.test(s)) return "test-observation";
+  if (EXPERIMENT_RE.test(s)) return "experimental-result";
+  return "none";
+}
+function firstRuleFragment(learning) {
+  for (const sentence of splitSentences(learning)) {
+    if (classifyLearningSentence(sentence) === "durable-rule") return sentence;
+  }
+  return null;
 }
 function sectionBody(body, titles) {
   const lines = body.split(/\r?\n/);
@@ -26099,32 +26095,33 @@ function buildConsolidationPlan(dir, opts = {}) {
       requires_semantic_review: false
     });
   }
-  const canonical = scoped.filter(
-    (la) => la.layer !== null && !isWorkItem(la) && la.artifact.type !== "roadmap"
-  );
-  const byHeading = /* @__PURE__ */ new Map();
-  for (const la of canonical) {
-    for (const h2 of distinctiveHeadings(la.body)) {
-      const arr = byHeading.get(h2) ?? [];
+  const comparable = scoped.filter(isComparableKnowledge);
+  const shingleIndex = /* @__PURE__ */ new Map();
+  const shinglesByRel = /* @__PURE__ */ new Map();
+  for (const la of comparable) {
+    const shingles = buildShingles(la.body);
+    shinglesByRel.set(la.rel, shingles);
+    for (const key of shingles.set) {
+      const arr = shingleIndex.get(key) ?? [];
       arr.push(la);
-      byHeading.set(h2, arr);
+      shingleIndex.set(key, arr);
     }
   }
-  const pairHeadings = /* @__PURE__ */ new Map();
-  for (const [heading, arts] of byHeading) {
+  const candidatePairs = /* @__PURE__ */ new Map();
+  for (const arts of shingleIndex.values()) {
     if (arts.length < 2) continue;
     for (let i = 0; i < arts.length; i++) {
       for (let j2 = i + 1; j2 < arts.length; j2++) {
         if (arts[i].rel === arts[j2].rel) continue;
         const key = [arts[i].rel, arts[j2].rel].sort().join("||");
-        const entry = pairHeadings.get(key) ?? { a: arts[i], b: arts[j2], shared: /* @__PURE__ */ new Set() };
-        entry.shared.add(heading);
-        pairHeadings.set(key, entry);
+        if (!candidatePairs.has(key)) candidatePairs.set(key, { a: arts[i], b: arts[j2] });
       }
     }
   }
-  for (const { a: a2, b: b2, shared } of pairHeadings.values()) {
-    if (shared.size < 2) continue;
+  for (const { a: a2, b: b2 } of candidatePairs.values()) {
+    const run = longestSharedRun(shinglesByRel.get(a2.rel), shinglesByRel.get(b2.rel));
+    if (run.length < MIN_SHARED_RUN) continue;
+    const passageWords = SHINGLE_SIZE + run.length - 1;
     opportunities.push({
       id: stableOpportunityId("knowledge_redundancy", [label(a2), label(b2)]),
       category: "knowledge_redundancy",
@@ -26133,18 +26130,22 @@ function buildConsolidationPlan(dir, opts = {}) {
       title: `Possible overlapping content between ${label(a2)} and ${label(b2)}`,
       source_artifacts: [label(a2), label(b2)],
       target_artifacts: [label(a2), label(b2)],
-      evidence: [`Both artifacts declare the sections: ${[...shared].sort().join(", ")}.`],
-      rationale: "Shared section titles are a hint of potential overlap, NOT proof of duplication. Two documents can legitimately address the same topic from different layers/responsibilities.",
+      evidence: [
+        `A ${passageWords}-word passage appears verbatim in both artifacts: "${redactSecrets3(run.snippet)}".`
+      ],
+      rationale: "A verbatim shared passage is a hint of potential duplication, NOT proof. Two documents can legitimately restate context from different layers/responsibilities; shared template structure alone was NOT used.",
       possible_impact: "If genuinely duplicated, the same fact can drift out of sync across files.",
-      suggested_action: "Semantic review: compare the sections; if one restates the other, keep a single reference location and link the rest. Preserve layer separation.",
+      suggested_action: "Semantic review: compare the overlapping passage; if one restates the other, keep a single reference location and link the rest. Preserve layer separation.",
       requires_semantic_review: true
     });
   }
   for (const la of scoped) {
     if (!isCompletedWorkItem(la)) continue;
-    const learning = sectionBody(la.body, ["Learning", "Aprendizaje", "Aprendizajes", "Learnings"]);
-    if (!learning) continue;
-    if (!looksLikeDurableRule(learning)) continue;
+    const learningRaw = sectionBody(la.body, ["Learning", "Aprendizaje", "Aprendizajes", "Learnings"]);
+    if (!learningRaw) continue;
+    const learning = stripNoise(learningRaw);
+    const ruleFragment = firstRuleFragment(learning);
+    if (!ruleFragment) continue;
     opportunities.push({
       id: stableOpportunityId("unincorporated_learning", [label(la)]),
       category: "unincorporated_learning",
@@ -26152,16 +26153,18 @@ function buildConsolidationPlan(dir, opts = {}) {
       confidence: "requires-review",
       title: `${label(la)} captured a learning that may belong in current knowledge`,
       source_artifacts: [label(la)],
-      target_artifacts: ["knowledge/tech/codebase.md"],
-      evidence: [`Completed Work Item records a rule-like learning: "${firstSentence(learning)}"`],
-      rationale: "A learning phrased as a durable rule MAY represent live technical knowledge not yet reflected in Tech Knowledge. This is a candidate, not a confirmed gap.",
+      target_artifacts: [],
+      // unresolved — determined in semantic review (never invent a destination)
+      evidence: [`Completed Work Item records a rule-like learning (heuristic classification): "${redactSecrets3(ruleFragment)}"`],
+      rationale: "A sentence phrased as a durable rule MAY represent live technical knowledge not yet reflected in current knowledge. The rule/result distinction is a heuristic, not a verified conclusion \u2014 this is a candidate, not a confirmed gap.",
       possible_impact: "A relevant constraint stays buried in delivery history instead of informing current work.",
-      suggested_action: "Semantic review: decide whether this learning is a live rule; if so, incorporate it into the right Tech artifact WITH a reference back to the Work Item. Do not delete or summarize the Work Item.",
+      suggested_action: "Semantic review: confirm whether this is a live rule and determine the right destination artifact; if so, incorporate it WITH a reference back to the Work Item. Do not delete or summarize the Work Item.",
       requires_semantic_review: true
     });
   }
   const weakByFolder = /* @__PURE__ */ new Map();
   for (const la of scoped) {
+    if (!isConsolidatableKnowledge(la)) continue;
     const quality = safeQuality(dir, la.rel);
     if (quality === "placeholder" || quality === "weak") {
       opportunities.push({
@@ -26172,11 +26175,11 @@ function buildConsolidationPlan(dir, opts = {}) {
         title: `${label(la)} is ${quality} and may need consolidation or expansion`,
         source_artifacts: [label(la)],
         target_artifacts: [label(la)],
-        evidence: [`Artifact quality analysis classifies this artifact as "${quality}".`],
-        rationale: "Low-signal artifacts reduce retrieval quality. This is an observed quality signal, not a judgement that the content is wrong.",
+        evidence: [`Artifact quality analysis classifies this canonical knowledge artifact as "${quality}".`],
+        rationale: "Observed: the quality heuristic rates this artifact low-signal. Whether it should be expanded, merged or cross-referenced is a judgement that needs semantic review \u2014 the quality signal alone does not decide it.",
         possible_impact: "Readers must open more files to assemble a complete picture.",
-        suggested_action: "Review whether to expand, merge into a stronger artifact, or cross-reference it.",
-        requires_semantic_review: false
+        suggested_action: "Semantic review: decide whether to expand, merge into a stronger artifact, or cross-reference it.",
+        requires_semantic_review: true
       });
       const folder = la.rel.split("/").slice(0, -1).join("/");
       const arr = weakByFolder.get(folder) ?? [];
@@ -26191,11 +26194,11 @@ function buildConsolidationPlan(dir, opts = {}) {
       category: "knowledge_fragmentation",
       classification: "suggested",
       confidence: "requires-review",
-      title: `${folder}/ holds ${arts.length} low-signal artifacts \u2014 possible fragmentation`,
+      title: `${folder}/ holds ${arts.length} low-signal canonical artifacts \u2014 possible fragmentation`,
       source_artifacts: arts.map((a2) => label(a2)),
       target_artifacts: [folder],
-      evidence: [`${arts.length} placeholder/weak artifacts in the same folder: ${arts.map((a2) => a2.rel.split("/").pop()).join(", ")}.`],
-      rationale: "Several thin artifacts in one folder MAY be easier to consume if consolidated or cross-linked. Consolidation must preserve each distinct responsibility.",
+      evidence: [`${arts.length} placeholder/weak canonical knowledge artifacts in the same folder: ${arts.map((a2) => a2.rel.split("/").pop()).join(", ")}.`],
+      rationale: "Several thin canonical artifacts in one folder MAY be easier to consume if consolidated or cross-linked. Consolidation must preserve each distinct responsibility; Work Items and generated/lifecycle artifacts are not considered here.",
       possible_impact: "Related knowledge is spread across too many files to follow.",
       suggested_action: "Semantic review: evaluate whether cross-references or a consolidation would add clarity. Do not merge by file count alone.",
       requires_semantic_review: true
@@ -26287,7 +26290,9 @@ function renderConsolidationMarkdown(plan) {
     lines.push(`- Classification: **${o2.classification}**${o2.requires_semantic_review ? " (requires semantic review)" : ""}`);
     lines.push(`- Confidence: ${o2.confidence}`);
     lines.push(`- Source: ${o2.source_artifacts.join(", ") || "\u2014"}`);
-    lines.push(`- Suggested target: ${o2.target_artifacts.join(", ") || "\u2014"}`);
+    lines.push(
+      `- Suggested target: ${o2.target_artifacts.length > 0 ? o2.target_artifacts.join(", ") : "(unresolved \u2014 to be determined in semantic review)"}`
+    );
     lines.push(`- Evidence:`);
     for (const e of o2.evidence) lines.push(`  - ${e}`);
     lines.push(`- Rationale: ${o2.rationale}`);
@@ -26312,15 +26317,25 @@ function isCompletedWorkItem(la) {
   const p = toPosix8(la.artifact.filePath);
   return p.includes("/delivery/work-items/completed/") || isWorkItem(la) && la.artifact.status === "completed";
 }
-function looksLikeDurableRule(text3) {
-  const lower = text3.toLowerCase();
-  return RULE_KEYWORDS.some((k2) => new RegExp(`(^|[^a-z\xE1\xE9\xED\xF3\xFA\xF1])${k2}([^a-z\xE1\xE9\xED\xF3\xFA\xF1]|$)`, "i").test(lower));
+function isScaffolding(la) {
+  const p = toPosix8(la.artifact.filePath);
+  return p.includes(`/${KNOWLEDGE7}/agents/`) || p.includes(`/${KNOWLEDGE7}/skills/`) || p.includes(`/${KNOWLEDGE7}/external/`) || la.artifact.type === "knowledge-capsule";
+}
+var NON_KNOWLEDGE_DOC_TYPES = /* @__PURE__ */ new Set([
+  "roadmap",
+  "initiative",
+  "deprecation",
+  "knowledge-capsule",
+  "inventory",
+  "project-resource"
+]);
+function isComparableKnowledge(la) {
+  return !isWorkItem(la) && la.artifact.type !== "roadmap" && !isScaffolding(la);
 }
-function firstSentence(text3) {
-  const flat = text3.replace(/\s+/g, " ").trim();
-  const m2 = flat.match(/^(.{0,200}?[.!?])(\s|$)/);
-  const s = (m2 ? m2[1] : flat).slice(0, 200);
-  return redactSecrets3(s.trim());
+function isConsolidatableKnowledge(la) {
+  if (isWorkItem(la) || isScaffolding(la)) return false;
+  if (NON_KNOWLEDGE_DOC_TYPES.has(la.artifact.type)) return false;
+  return la.layer === "Business" || la.layer === "Product" || la.layer === "Tech";
 }
 var SECRET_TOKEN_PATTERNS = [
   /\bgh[pours]_[A-Za-z0-9]{16,}\b/g,

package/package.json

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