@a-company/paradigm 3.7.0 → 3.8.0

package/dist/mcp.js

@@ -15940,6 +15940,7 @@ var import_sql2 = __toESM(require_sql_wasm(), 1);
 import * as fs24 from "fs";
 import * as path27 from "path";
 import * as crypto5 from "crypto";
+import { execSync as execSync2 } from "child_process";
 var cachedSQL = null;
 async function getSqlJs() {
   if (!cachedSQL) {
@@ -15967,6 +15968,8 @@ var SCHEMA_STATEMENTS = [
     start_line INTEGER NOT NULL,
     end_line INTEGER NOT NULL,
     content_hash TEXT,
+    normalized_hash TEXT,
+    materialized_at_commit TEXT,
     last_verified TEXT,
     drifted INTEGER DEFAULT 0
   )`,
@@ -16072,9 +16075,14 @@ function closeAspectGraph(db, rootDir) {
   }
   db.close();
 }
-function materializeAspects(db, symbols) {
+function materializeAspects(db, symbols, rootDir) {
   const aspects = symbols.filter((s) => s.type === "aspect");
   const now = (/* @__PURE__ */ new Date()).toISOString();
+  let headCommit = null;
+  try {
+    headCommit = execSync2("git rev-parse HEAD", { cwd: rootDir, encoding: "utf8" }).trim();
+  } catch {
+  }
   db.run("DELETE FROM anchors");
   db.run("DELETE FROM edges");
   db.run("DELETE FROM aspects");
@@ -16108,11 +16116,11 @@ function materializeAspects(db, symbols) {
     if (entry.anchors) {
       for (const anchor of entry.anchors) {
         const { startLine, endLine } = resolveAnchorLines(anchor);
-        const contentHash = computeAnchorHash(anchor, null);
+        const hashes = computeAnchorHash(anchor, null);
         db.run(
-          `INSERT INTO anchors (aspect_id, file_path, start_line, end_line, content_hash, last_verified)
-           VALUES (?, ?, ?, ?, ?, ?)`,
-          [entry.symbol, anchor.path, startLine, endLine, contentHash, now]
+          `INSERT INTO anchors (aspect_id, file_path, start_line, end_line, content_hash, normalized_hash, materialized_at_commit, last_verified)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+          [entry.symbol, anchor.path, startLine, endLine, hashes.exact, hashes.normalized, headCommit, now]
         );
       }
     }
@@ -16195,7 +16203,7 @@ function getHeatmap(db, limit = 20, accessType) {
     [limit]
   );
 }
-function checkDrift(db, rootDir, aspectId) {
+function checkDrift(db, rootDir, aspectId, autoHeal = true) {
   const anchorRows = aspectId ? queryRows(db, "SELECT * FROM anchors WHERE aspect_id = ?", [aspectId]) : queryRows(db, "SELECT * FROM anchors");
   const results = [];
   for (const anchor of anchorRows) {
@@ -16206,8 +16214,10 @@ function checkDrift(db, rootDir, aspectId) {
         path: anchor.file_path,
         startLine: anchor.start_line,
         endLine: anchor.end_line,
-        drifted: true,
-        exists: false
+        status: "missing",
+        resolvedBy: "none",
+        exists: false,
+        drifted: true
       });
       continue;
     }
@@ -16217,30 +16227,174 @@ function checkDrift(db, rootDir, aspectId) {
       const startIdx = Math.max(0, anchor.start_line - 1);
       const endIdx = Math.min(lines.length, anchor.end_line);
       const sliceContent = lines.slice(startIdx, endIdx).join("\n");
-      const currentHash = crypto5.createHash("sha256").update(sliceContent).digest("hex");
-      const drifted = anchor.content_hash != null && currentHash !== anchor.content_hash;
+      const currentExactHash = crypto5.createHash("sha256").update(sliceContent).digest("hex");
+      if (anchor.content_hash != null && currentExactHash === anchor.content_hash) {
+        results.push({
+          aspectId: anchor.aspect_id,
+          path: anchor.file_path,
+          startLine: anchor.start_line,
+          endLine: anchor.end_line,
+          status: "clean",
+          resolvedBy: "exact-hash",
+          exists: true,
+          drifted: false
+        });
+        if (anchor.drifted === 1) {
+          db.run("UPDATE anchors SET drifted = 0 WHERE id = ?", [anchor.id]);
+        }
+        continue;
+      }
+      const currentNormalizedHash = crypto5.createHash("sha256").update(normalizeForHash(sliceContent)).digest("hex");
+      if (anchor.normalized_hash != null && currentNormalizedHash === anchor.normalized_hash) {
+        db.run("UPDATE anchors SET content_hash = ?, drifted = 0 WHERE id = ?", [currentExactHash, anchor.id]);
+        results.push({
+          aspectId: anchor.aspect_id,
+          path: anchor.file_path,
+          startLine: anchor.start_line,
+          endLine: anchor.end_line,
+          status: "cosmetic",
+          resolvedBy: "normalized-hash",
+          exists: true,
+          drifted: false
+        });
+        continue;
+      }
+      if (anchor.content_hash == null && anchor.normalized_hash == null) {
+        db.run(
+          "UPDATE anchors SET content_hash = ?, normalized_hash = ?, drifted = 0 WHERE id = ?",
+          [currentExactHash, currentNormalizedHash, anchor.id]
+        );
+        results.push({
+          aspectId: anchor.aspect_id,
+          path: anchor.file_path,
+          startLine: anchor.start_line,
+          endLine: anchor.end_line,
+          status: "clean",
+          resolvedBy: "exact-hash",
+          exists: true,
+          drifted: false
+        });
+        continue;
+      }
+      let resolvedByGit = false;
+      if (anchor.materialized_at_commit) {
+        const mapping = computeLineShift(
+          rootDir,
+          anchor.file_path,
+          anchor.materialized_at_commit,
+          anchor.start_line,
+          anchor.end_line
+        );
+        if (mapping) {
+          const shiftedStartIdx = Math.max(0, mapping.currentStart - 1);
+          const shiftedEndIdx = Math.min(lines.length, mapping.currentEnd);
+          const shiftedContent = lines.slice(shiftedStartIdx, shiftedEndIdx).join("\n");
+          const shiftedExactHash = crypto5.createHash("sha256").update(shiftedContent).digest("hex");
+          if (anchor.content_hash != null && shiftedExactHash === anchor.content_hash) {
+            const healed = autoHeal;
+            if (healed) {
+              db.run(
+                "UPDATE anchors SET start_line = ?, end_line = ?, drifted = 0 WHERE id = ?",
+                [mapping.currentStart, mapping.currentEnd, anchor.id]
+              );
+              const aspectRow = queryRows(
+                db,
+                "SELECT defined_in FROM aspects WHERE id = ?",
+                [anchor.aspect_id]
+              );
+              if (aspectRow.length > 0) {
+                healAnchorInPurposeFile(
+                  rootDir,
+                  aspectRow[0].defined_in,
+                  anchor.file_path,
+                  anchor.start_line,
+                  anchor.end_line,
+                  mapping.currentStart,
+                  mapping.currentEnd
+                );
+              }
+            }
+            results.push({
+              aspectId: anchor.aspect_id,
+              path: anchor.file_path,
+              startLine: healed ? mapping.currentStart : anchor.start_line,
+              endLine: healed ? mapping.currentEnd : anchor.end_line,
+              status: "shifted",
+              resolvedBy: "git-line-mapping",
+              exists: true,
+              drifted: false,
+              suggestedStart: mapping.currentStart,
+              suggestedEnd: mapping.currentEnd,
+              autoHealed: healed
+            });
+            resolvedByGit = true;
+          } else {
+            const shiftedNormalized = crypto5.createHash("sha256").update(normalizeForHash(shiftedContent)).digest("hex");
+            if (anchor.normalized_hash != null && shiftedNormalized === anchor.normalized_hash) {
+              if (autoHeal) {
+                const shiftedNewHash = crypto5.createHash("sha256").update(shiftedContent).digest("hex");
+                db.run(
+                  "UPDATE anchors SET start_line = ?, end_line = ?, content_hash = ?, drifted = 0 WHERE id = ?",
+                  [mapping.currentStart, mapping.currentEnd, shiftedNewHash, anchor.id]
+                );
+                const aspectRow = queryRows(
+                  db,
+                  "SELECT defined_in FROM aspects WHERE id = ?",
+                  [anchor.aspect_id]
+                );
+                if (aspectRow.length > 0) {
+                  healAnchorInPurposeFile(
+                    rootDir,
+                    aspectRow[0].defined_in,
+                    anchor.file_path,
+                    anchor.start_line,
+                    anchor.end_line,
+                    mapping.currentStart,
+                    mapping.currentEnd
+                  );
+                }
+              }
+              results.push({
+                aspectId: anchor.aspect_id,
+                path: anchor.file_path,
+                startLine: autoHeal ? mapping.currentStart : anchor.start_line,
+                endLine: autoHeal ? mapping.currentEnd : anchor.end_line,
+                status: "shifted",
+                resolvedBy: "git-line-mapping",
+                exists: true,
+                drifted: false,
+                suggestedStart: mapping.currentStart,
+                suggestedEnd: mapping.currentEnd,
+                autoHealed: autoHeal
+              });
+              resolvedByGit = true;
+            }
+          }
+        }
+      }
+      if (resolvedByGit) continue;
+      db.run("UPDATE anchors SET drifted = 1 WHERE id = ?", [anchor.id]);
       results.push({
         aspectId: anchor.aspect_id,
         path: anchor.file_path,
         startLine: anchor.start_line,
         endLine: anchor.end_line,
-        drifted,
+        status: "modified",
+        resolvedBy: "none",
         exists: true,
-        currentContent: drifted ? sliceContent : void 0
+        currentContent: sliceContent,
+        drifted: true
       });
-      if (drifted) {
-        db.run("UPDATE anchors SET drifted = 1 WHERE id = ?", [anchor.id]);
-      } else if (anchor.drifted === 1) {
-        db.run("UPDATE anchors SET drifted = 0 WHERE id = ?", [anchor.id]);
-      }
     } catch {
       results.push({
         aspectId: anchor.aspect_id,
         path: anchor.file_path,
         startLine: anchor.start_line,
         endLine: anchor.end_line,
-        drifted: true,
-        exists: true
+        status: "modified",
+        resolvedBy: "none",
+        exists: true,
+        drifted: true
       });
     }
   }
@@ -16262,10 +16416,76 @@ function resolveAnchorLines(anchor) {
   }
   return { startLine: 1, endLine: 1 };
 }
+function parseUnifiedDiffHunks(diffOutput) {
+  const hunks = [];
+  const hunkPattern = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/gm;
+  let match;
+  while ((match = hunkPattern.exec(diffOutput)) !== null) {
+    hunks.push({
+      oldStart: parseInt(match[1], 10),
+      oldCount: match[2] !== void 0 ? parseInt(match[2], 10) : 1,
+      newStart: parseInt(match[3], 10),
+      newCount: match[4] !== void 0 ? parseInt(match[4], 10) : 1
+    });
+  }
+  return hunks;
+}
+function computeLineShift(rootDir, filePath, fromCommit, originalStart, originalEnd) {
+  let diff;
+  try {
+    diff = execSync2(
+      `git diff ${fromCommit}..HEAD --unified=0 -- "${filePath}"`,
+      { cwd: rootDir, encoding: "utf8", timeout: 5e3 }
+    );
+  } catch {
+    return null;
+  }
+  if (!diff.trim()) {
+    return { originalStart, originalEnd, currentStart: originalStart, currentEnd: originalEnd };
+  }
+  const hunks = parseUnifiedDiffHunks(diff);
+  let offset = 0;
+  for (const hunk of hunks) {
+    const hunkOldEnd = hunk.oldStart + hunk.oldCount;
+    if (hunkOldEnd <= originalStart) {
+      offset += hunk.newCount - hunk.oldCount;
+      continue;
+    }
+    if (hunk.oldStart < originalEnd) {
+      return null;
+    }
+    break;
+  }
+  if (offset === 0) return null;
+  return {
+    originalStart,
+    originalEnd,
+    currentStart: originalStart + offset,
+    currentEnd: originalEnd + offset
+  };
+}
+function healAnchorInPurposeFile(rootDir, purposeFilePath, anchorFilePath, oldStart, oldEnd, newStart, newEnd) {
+  const absolutePurpose = path27.isAbsolute(purposeFilePath) ? purposeFilePath : path27.join(rootDir, purposeFilePath);
+  if (!fs24.existsSync(absolutePurpose)) return false;
+  try {
+    const content = fs24.readFileSync(absolutePurpose, "utf8");
+    const oldAnchor = oldStart === oldEnd ? `${anchorFilePath}:${oldStart}` : `${anchorFilePath}:${oldStart}-${oldEnd}`;
+    const newAnchor = newStart === newEnd ? `${anchorFilePath}:${newStart}` : `${anchorFilePath}:${newStart}-${newEnd}`;
+    if (!content.includes(oldAnchor)) return false;
+    const updated = content.replace(oldAnchor, newAnchor);
+    fs24.writeFileSync(absolutePurpose, updated, "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeForHash(content) {
+  return content.split("\n").map((line) => line.trimEnd()).filter((line) => line.trim() !== "").map((line) => line.replace(/\s+/g, " ")).join("\n");
+}
 function computeAnchorHash(anchor, rootDir) {
-  if (!rootDir) return null;
+  if (!rootDir) return { exact: null, normalized: null };
   const absolutePath = path27.isAbsolute(anchor.path) ? anchor.path : path27.join(rootDir, anchor.path);
-  if (!fs24.existsSync(absolutePath)) return null;
+  if (!fs24.existsSync(absolutePath)) return { exact: null, normalized: null };
   try {
     const fileContent = fs24.readFileSync(absolutePath, "utf8");
     const lines = fileContent.split("\n");
@@ -16273,9 +16493,11 @@ function computeAnchorHash(anchor, rootDir) {
     const startIdx = Math.max(0, startLine - 1);
     const endIdx = Math.min(lines.length, endLine);
     const sliceContent = lines.slice(startIdx, endIdx).join("\n");
-    return crypto5.createHash("sha256").update(sliceContent).digest("hex");
+    const exact = crypto5.createHash("sha256").update(sliceContent).digest("hex");
+    const normalized = crypto5.createHash("sha256").update(normalizeForHash(sliceContent)).digest("hex");
+    return { exact, normalized };
   } catch {
-    return null;
+    return { exact: null, normalized: null };
   }
 }
 function inferCategory(data, entry) {
@@ -16878,7 +17100,7 @@ async function rebuildStaticFiles(rootDir, ctx) {
   let aspectGraphStats;
   try {
     const db = await openAspectGraph(rootDir);
-    materializeAspects(db, aggregation.symbols);
+    materializeAspects(db, aggregation.symbols, rootDir);
     const loreLinks = await materializeLoreLinks(db, rootDir);
     const inferredEdges = await inferLoreEdges(db, rootDir);
     const aspectCount = db.exec("SELECT COUNT(*) FROM aspects")[0]?.values[0]?.[0] ?? 0;
@@ -17593,7 +17815,7 @@ function summarizeEntry(entry) {
 // ../paradigm-mcp/src/tools/habits.ts
 import * as fs27 from "fs";
 import * as path30 from "path";
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 function getHabitsToolsList() {
   return [
     {
@@ -17797,7 +18019,7 @@ async function handleHabitsCheck(args, ctx) {
   ].some((k) => taskLower.includes(k));
   let gitClean;
   try {
-    const status = execSync2("git status --porcelain", {
+    const status = execSync3("git status --porcelain", {
       cwd: ctx.rootDir,
       encoding: "utf8",
       timeout: 5e3
@@ -18493,18 +18715,22 @@ function getAspectGraphToolsList() {
     },
     {
       name: "paradigm_aspect_drift",
-      description: "Check if code at aspect anchor locations has changed since last materialization. Detects broken or stale anchors. ~200 tokens.",
+      description: "Smart drift detection for code anchors. Layer 1: normalized hash (ignores formatting). Layer 2: git-aware line mapping (detects shifts, auto-heals .purpose files). ~200 tokens.",
       inputSchema: {
         type: "object",
         properties: {
           aspectId: {
             type: "string",
             description: "Optional: check a specific aspect. If omitted, checks all aspects."
+          },
+          autoHeal: {
+            type: "boolean",
+            description: "Auto-update anchors for high-confidence shifts (default: true)"
           }
         }
       },
       annotations: {
-        readOnlyHint: true,
+        readOnlyHint: false,
         destructiveHint: false
       }
     },
@@ -18894,34 +19120,51 @@ async function handleAspectSuggestScan(args, ctx) {
   }
 }
 async function handleAspectDrift(args, ctx) {
-  const { aspectId } = args;
+  const { aspectId, autoHeal: autoHealArg } = args;
+  const autoHeal = autoHealArg !== false;
   const normalizedId = aspectId ? aspectId.startsWith("~") ? aspectId.slice(1) : aspectId : void 0;
   let db = null;
   try {
     db = await openAspectGraph(ctx.rootDir);
-    const results = checkDrift(db, ctx.rootDir, normalizedId);
-    const driftedCount = results.filter((r) => r.drifted).length;
-    const missingCount = results.filter((r) => !r.exists).length;
-    const healthyCount = results.filter((r) => !r.drifted && r.exists).length;
+    const results = checkDrift(db, ctx.rootDir, normalizedId, autoHeal);
+    const cleanCount = results.filter((r) => r.status === "clean").length;
+    const cosmeticCount = results.filter((r) => r.status === "cosmetic").length;
+    const shiftedCount = results.filter((r) => r.status === "shifted").length;
+    const modifiedCount = results.filter((r) => r.status === "modified").length;
+    const missingCount = results.filter((r) => r.status === "missing").length;
+    const hasIssues = modifiedCount > 0 || missingCount > 0;
+    const hasHeals = cosmeticCount > 0 || shiftedCount > 0;
+    const overallStatus = hasIssues ? "drift-detected" : hasHeals ? "clean-with-heals" : "clean";
     const response = {
       ...normalizedId ? { aspectId: normalizedId } : { scope: "all" },
       totalAnchors: results.length,
-      healthy: healthyCount,
-      drifted: driftedCount,
+      clean: cleanCount,
+      cosmetic: cosmeticCount,
+      shifted: shiftedCount,
+      modified: modifiedCount,
       missing: missingCount,
-      status: driftedCount === 0 && missingCount === 0 ? "clean" : "drift-detected",
+      status: overallStatus,
       results: results.map((r) => ({
         aspectId: r.aspectId,
         path: r.path,
         startLine: r.startLine,
         endLine: r.endLine,
-        drifted: r.drifted,
+        status: r.status,
+        resolvedBy: r.resolvedBy,
         exists: r.exists,
-        // Include current content only for drifted anchors (truncated)
-        ...r.drifted && r.currentContent ? { currentContent: r.currentContent.slice(0, 500) } : {}
+        // Include shift details for shifted anchors
+        ...r.status === "shifted" ? { suggestedStart: r.suggestedStart, suggestedEnd: r.suggestedEnd, autoHealed: r.autoHealed } : {},
+        // Include current content only for modified anchors (truncated)
+        ...r.status === "modified" && r.currentContent ? { currentContent: r.currentContent.slice(0, 500) } : {}
       })),
-      ...driftedCount > 0 || missingCount > 0 ? {
-        suggestion: "Run `paradigm scan` to re-materialize the aspect graph and update anchor hashes. Review drifted anchors to ensure aspects still apply."
+      ...cosmeticCount > 0 || shiftedCount > 0 ? {
+        healed: [
+          cosmeticCount > 0 ? `${cosmeticCount} cosmetic (whitespace/formatting \u2014 hashes updated)` : "",
+          shiftedCount > 0 ? `${shiftedCount} shifted (line numbers updated via git diff${autoHeal ? " \u2014 .purpose files patched" : ""})` : ""
+        ].filter(Boolean).join(", ")
+      } : {},
+      ...hasIssues ? {
+        suggestion: "Review drifted anchors to ensure aspects still apply. Run `paradigm scan` to re-materialize after fixing."
       } : {}
     };
     const text = JSON.stringify(response, null, 2);
@@ -19371,7 +19614,7 @@ async function handleAssessmentTool(name, args, ctx) {
 
 // ../paradigm-mcp/src/tools/fallback-grep.ts
 import * as path32 from "path";
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 function grepForReferences(rootDir, symbol, options = {}) {
   const { maxResults = 20 } = options;
   const results = [];
@@ -19385,7 +19628,7 @@ function grepForReferences(rootDir, symbol, options = {}) {
   let output = "";
   for (const cmd of grepCommands) {
     try {
-      output = execSync3(cmd, { encoding: "utf8", maxBuffer: 1024 * 1024 });
+      output = execSync4(cmd, { encoding: "utf8", maxBuffer: 1024 * 1024 });
       if (output.trim()) break;
     } catch {
       continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-company/paradigm",
-  "version": "3.7.0",
+  "version": "3.8.0",
   "description": "Unified CLI for Paradigm developer tools",
   "type": "module",
   "main": "./dist/index.js",