@a-company/paradigm 3.9.0 → 3.11.0

package/dist/{diff-J6C5IHPV.js → diff-PZAYCIAE.js}

@@ -1,16 +1,16 @@
 #!/usr/bin/env node
 import {
   BackgroundOrchestrator
-} from "./chunk-Y4XZWCHK.js";
+} from "./chunk-24AAVLME.js";
 import "./chunk-6QC3YGB6.js";
-import "./chunk-HPC3JAUP.js";
-import "./chunk-6RNYVBSG.js";
-import "./chunk-PBHIFAL4.js";
-import "./chunk-CCG6KYBT.js";
+import "./chunk-CP6IZGUN.js";
 import "./chunk-PMXRGPRQ.js";
+import "./chunk-PBHIFAL4.js";
+import "./chunk-5N5LR2KS.js";
 import "./chunk-6P4IFIK2.js";
 import "./chunk-MRENOFTR.js";
 import "./chunk-IRKUEJVW.js";
+import "./chunk-MW5DMGBB.js";
 import "./chunk-5JGJACDU.js";
 import "./chunk-MO4EEYFW.js";
 

package/dist/{dist-OLFOTUHS.js → dist-6SX5ZKKF.js}

@@ -20,7 +20,7 @@ import {
   loadAllSeedPatterns,
   loadParadigmPatterns,
   loadUniversalPatterns
-} from "./chunk-GY5KO3YZ.js";
+} from "./chunk-RDPXBMHK.js";
 import {
   DEFAULT_AUTH_CONFIG,
   DEFAULT_RATE_LIMIT_CONFIG,
@@ -29,7 +29,7 @@ import {
   loadConfig,
   loadServerConfig,
   writeConfig
-} from "./chunk-ADOBV4PH.js";
+} from "./chunk-UVI3OH3G.js";
 import "./chunk-MO4EEYFW.js";
 export {
   ContextEnricher,

package/dist/{dist-OMY7U6NR.js → dist-YB7T54QE.js}

@@ -26,8 +26,7 @@ import {
   loadServerConfig,
   loadUniversalPatterns,
   writeConfig
-} from "./chunk-5S5CF3ER.js";
-import "./chunk-MO4EEYFW.js";
+} from "./chunk-4ZO3ZOPM.js";
 export {
   ContextEnricher,
   DEFAULT_AUTH_CONFIG,

package/dist/{doctor-TQYRF7KK.js → doctor-3YQ55536.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   doctorCommand
-} from "./chunk-KFHK6EBI.js";
+} from "./chunk-OSYMVGWX.js";
 import "./chunk-2QNZ6PVD.js";
 import "./chunk-4NCFWYGG.js";
 import "./chunk-YO6DVTL7.js";

package/dist/drift-FH2UY64B.js

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/drift.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as crypto from "crypto";
+import { execSync } from "child_process";
+import chalk from "chalk";
+function normalizeForHash(content) {
+  return content.split("\n").map((l) => l.trimEnd()).filter((l) => l.trim().length > 0).join("\n").replace(/\s+/g, " ").trim();
+}
+function parseHunks(diff) {
+  const hunks = [];
+  const pattern = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/gm;
+  let match;
+  while ((match = pattern.exec(diff)) !== null) {
+    hunks.push({
+      oldStart: parseInt(match[1], 10),
+      oldCount: match[2] !== void 0 ? parseInt(match[2], 10) : 1,
+      newCount: match[4] !== void 0 ? parseInt(match[4], 10) : 1
+    });
+  }
+  return hunks;
+}
+function computeShift(rootDir, filePath, fromCommit, startLine, endLine) {
+  let diff;
+  try {
+    diff = execSync(
+      `git diff ${fromCommit}..HEAD --unified=0 -- "${filePath}"`,
+      { cwd: rootDir, encoding: "utf8", timeout: 5e3 }
+    );
+  } catch {
+    return null;
+  }
+  if (!diff.trim()) {
+    return null;
+  }
+  const hunks = parseHunks(diff);
+  let offset = 0;
+  for (const hunk of hunks) {
+    const hunkEnd = hunk.oldStart + hunk.oldCount;
+    if (hunkEnd <= startLine) {
+      offset += hunk.newCount - hunk.oldCount;
+      continue;
+    }
+    if (hunk.oldStart < endLine) {
+      return null;
+    }
+    break;
+  }
+  if (offset === 0) return null;
+  return { newStart: startLine + offset, newEnd: endLine + offset };
+}
+function healPurposeFile(rootDir, purposePath, anchorFile, oldStart, oldEnd, newStart, newEnd) {
+  const absPath = path.isAbsolute(purposePath) ? purposePath : path.join(rootDir, purposePath);
+  if (!fs.existsSync(absPath)) return false;
+  try {
+    const content = fs.readFileSync(absPath, "utf8");
+    const oldRef = oldStart === oldEnd ? `${anchorFile}:${oldStart}` : `${anchorFile}:${oldStart}-${oldEnd}`;
+    const newRef = newStart === newEnd ? `${anchorFile}:${newStart}` : `${anchorFile}:${newStart}-${newEnd}`;
+    if (!content.includes(oldRef)) return false;
+    fs.writeFileSync(absPath, content.replace(oldRef, newRef), "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function driftCheckCommand(options) {
+  const rootDir = process.cwd();
+  const dbPath = path.join(rootDir, ".paradigm", "aspect-graph.db");
+  if (!fs.existsSync(dbPath)) {
+    if (options.json) {
+      console.log(JSON.stringify({ driftedCount: 0, healedCount: 0, cleanCount: 0, missingCount: 0, details: [] }));
+    } else {
+      console.log(chalk.gray("No aspect-graph.db found. Run paradigm_aspect_check to initialize."));
+    }
+    return;
+  }
+  const autoHeal = options.autoHeal !== false;
+  try {
+    const initSqlJs = (await import("sql.js")).default;
+    const SQL = await initSqlJs();
+    const buffer = fs.readFileSync(dbPath);
+    const db = new SQL.Database(buffer);
+    const results = [];
+    try {
+      const stmt = db.prepare("SELECT id, aspect_id, file_path, start_line, end_line, content_hash, normalized_hash, materialized_at_commit, drifted FROM anchors");
+      const anchors = [];
+      while (stmt.step()) {
+        const row = stmt.getAsObject();
+        anchors.push(row);
+      }
+      stmt.free();
+      for (const anchor of anchors) {
+        const absFile = path.isAbsolute(anchor.file_path) ? anchor.file_path : path.join(rootDir, anchor.file_path);
+        if (!fs.existsSync(absFile)) {
+          results.push({
+            aspectId: anchor.aspect_id,
+            path: anchor.file_path,
+            startLine: anchor.start_line,
+            endLine: anchor.end_line,
+            status: "missing"
+          });
+          continue;
+        }
+        const fileContent = fs.readFileSync(absFile, "utf8");
+        const lines = fileContent.split("\n");
+        const startIdx = Math.max(0, anchor.start_line - 1);
+        const endIdx = Math.min(lines.length, anchor.end_line);
+        const slice = lines.slice(startIdx, endIdx).join("\n");
+        const exactHash = crypto.createHash("sha256").update(slice).digest("hex");
+        if (anchor.content_hash != null && exactHash === anchor.content_hash) {
+          if (anchor.drifted === 1) {
+            db.run("UPDATE anchors SET drifted = 0 WHERE id = ?", [anchor.id]);
+          }
+          results.push({
+            aspectId: anchor.aspect_id,
+            path: anchor.file_path,
+            startLine: anchor.start_line,
+            endLine: anchor.end_line,
+            status: "clean"
+          });
+          continue;
+        }
+        const normHash = crypto.createHash("sha256").update(normalizeForHash(slice)).digest("hex");
+        if (anchor.normalized_hash != null && normHash === anchor.normalized_hash) {
+          db.run("UPDATE anchors SET content_hash = ?, drifted = 0 WHERE id = ?", [exactHash, anchor.id]);
+          results.push({
+            aspectId: anchor.aspect_id,
+            path: anchor.file_path,
+            startLine: anchor.start_line,
+            endLine: anchor.end_line,
+            status: "cosmetic"
+          });
+          continue;
+        }
+        if (anchor.content_hash == null && anchor.normalized_hash == null) {
+          db.run(
+            "UPDATE anchors SET content_hash = ?, normalized_hash = ?, drifted = 0 WHERE id = ?",
+            [exactHash, normHash, anchor.id]
+          );
+          results.push({
+            aspectId: anchor.aspect_id,
+            path: anchor.file_path,
+            startLine: anchor.start_line,
+            endLine: anchor.end_line,
+            status: "clean"
+          });
+          continue;
+        }
+        let resolved = false;
+        if (anchor.materialized_at_commit) {
+          const shift = computeShift(rootDir, anchor.file_path, anchor.materialized_at_commit, anchor.start_line, anchor.end_line);
+          if (shift) {
+            const shiftedSlice = lines.slice(Math.max(0, shift.newStart - 1), Math.min(lines.length, shift.newEnd)).join("\n");
+            const shiftedHash = crypto.createHash("sha256").update(shiftedSlice).digest("hex");
+            if (anchor.content_hash != null && shiftedHash === anchor.content_hash || anchor.normalized_hash != null && crypto.createHash("sha256").update(normalizeForHash(shiftedSlice)).digest("hex") === anchor.normalized_hash) {
+              if (autoHeal) {
+                const newHash = crypto.createHash("sha256").update(shiftedSlice).digest("hex");
+                db.run(
+                  "UPDATE anchors SET start_line = ?, end_line = ?, content_hash = ?, drifted = 0 WHERE id = ?",
+                  [shift.newStart, shift.newEnd, newHash, anchor.id]
+                );
+                const aspectStmt = db.prepare("SELECT defined_in FROM aspects WHERE id = ?");
+                aspectStmt.bind([anchor.aspect_id]);
+                if (aspectStmt.step()) {
+                  const aspectRow = aspectStmt.getAsObject();
+                  healPurposeFile(
+                    rootDir,
+                    aspectRow.defined_in,
+                    anchor.file_path,
+                    anchor.start_line,
+                    anchor.end_line,
+                    shift.newStart,
+                    shift.newEnd
+                  );
+                }
+                aspectStmt.free();
+              }
+              results.push({
+                aspectId: anchor.aspect_id,
+                path: anchor.file_path,
+                startLine: autoHeal ? shift.newStart : anchor.start_line,
+                endLine: autoHeal ? shift.newEnd : anchor.end_line,
+                status: "shifted",
+                autoHealed: autoHeal
+              });
+              resolved = true;
+            }
+          }
+        }
+        if (!resolved) {
+          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,
+            status: "modified"
+          });
+        }
+      }
+      const data = db.export();
+      fs.writeFileSync(dbPath, Buffer.from(data));
+    } finally {
+      db.close();
+    }
+    const summary = {
+      driftedCount: results.filter((r) => r.status === "modified").length,
+      healedCount: results.filter((r) => r.status === "shifted" && r.autoHealed).length,
+      cleanCount: results.filter((r) => r.status === "clean" || r.status === "cosmetic").length,
+      missingCount: results.filter((r) => r.status === "missing").length,
+      details: results
+    };
+    if (options.json) {
+      console.log(JSON.stringify(summary));
+    } else {
+      console.log(chalk.blue("\nAspect Drift Check\n"));
+      if (summary.healedCount > 0) {
+        console.log(chalk.green(`  Auto-healed: ${summary.healedCount} shifted anchor(s)`));
+      }
+      if (summary.cleanCount > 0) {
+        console.log(chalk.green(`  Clean: ${summary.cleanCount} anchor(s)`));
+      }
+      if (summary.driftedCount > 0) {
+        console.log(chalk.red(`  Drifted: ${summary.driftedCount} anchor(s) (content changed)`));
+        for (const d of results.filter((d2) => d2.status === "modified")) {
+          console.log(chalk.red(`    ${d.aspectId}: ${d.path}:${d.startLine}-${d.endLine}`));
+        }
+      }
+      if (summary.missingCount > 0) {
+        console.log(chalk.yellow(`  Missing: ${summary.missingCount} anchor file(s) deleted`));
+      }
+      if (summary.driftedCount === 0 && summary.missingCount === 0) {
+        console.log(chalk.green("\n  All anchors are clean.\n"));
+      } else {
+        console.log(chalk.gray("\n  Run paradigm_aspect_check to review and fix.\n"));
+      }
+    }
+  } catch (err) {
+    if (options.json) {
+      console.log(JSON.stringify({ driftedCount: 0, healedCount: 0, cleanCount: 0, missingCount: 0, details: [], error: String(err) }));
+    } else {
+      console.log(chalk.red(`Drift check failed: ${err}`));
+    }
+  }
+}
+export {
+  driftCheckCommand
+};

package/dist/{flow-7JUH6D4H.js → flow-MCKPJGRJ.js}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import "./chunk-HPC3JAUP.js";
+import "./chunk-MW5DMGBB.js";
 import {
   log
 } from "./chunk-4NCFWYGG.js";

package/dist/{habits-ZJBAL4HD.js → habits-NC2TRMRV.js}

@@ -911,7 +911,7 @@ async function habitsStatusCommand(options) {
   const enabled = getEnabledHabits(habits);
   let practiceData = null;
   try {
-    const { SentinelStorage } = await import("./dist-OLFOTUHS.js");
+    const { SentinelStorage } = await import("./dist-6SX5ZKKF.js");
     const sentinelDir = path3.join(rootDir, ".paradigm", "sentinel");
     if (fs2.existsSync(sentinelDir)) {
       const storage = new SentinelStorage(sentinelDir);
@@ -1279,7 +1279,7 @@ async function habitsCheckCommand(options) {
     try {
       const sentinelDir = path3.join(rootDir, ".paradigm", "sentinel");
       if (fs2.existsSync(sentinelDir)) {
-        const { SentinelStorage } = await import("./dist-OLFOTUHS.js");
+        const { SentinelStorage } = await import("./dist-6SX5ZKKF.js");
         const storage = new SentinelStorage(sentinelDir);
         for (const e of evaluation.evaluations) {
           storage.recordPracticeEvent({

package/dist/{hooks-DLZEYHI3.js → hooks-JXYHVGIN.js}

@@ -3,7 +3,7 @@ import {
   hooksInstallCommand,
   hooksStatusCommand,
   hooksUninstallCommand
-} from "./chunk-M2XMTJHQ.js";
+} from "./chunk-DS5QY37M.js";
 import "./chunk-MO4EEYFW.js";
 export {
   hooksInstallCommand,