@shahmilsaari/memory-core 1.0.22 → 1.0.26

package/dist/{dashboard-server-VOT2ZRVN.js → dashboard-server-EEFNE6NX.js}

@@ -1,22 +1,27 @@
 #!/usr/bin/env node
+import {
+  detectProject,
+  embed,
+  inferProjectArchitectures,
+  startWatch
+} from "./chunk-3XTHE74V.js";
+import {
+  getChatProviderLabel
+} from "./chunk-PQBWHAZN.js";
 import {
   Config,
   closePool,
   deleteMemory,
-  detectProject,
-  embed,
-  getChatProviderLabel,
   getPool,
-  inferProjectArchitectures,
   listMemories,
   saveMemory,
-  startWatch,
   updateMemory
-} from "./chunk-UZDALJVQ.js";
+} from "./chunk-M7NKSXFS.js";
+import "./chunk-ZZBQEXEO.js";
 
 // src/dashboard-server.ts
 import { createHash } from "crypto";
-import { createReadStream, existsSync, readFileSync, watch } from "fs";
+import { createReadStream, existsSync, mkdirSync, readFileSync, watch, writeFileSync } from "fs";
 import { createServer } from "http";
 import { basename, dirname, extname, join, normalize, relative, resolve } from "path";
 import { fileURLToPath } from "url";
@@ -47,6 +52,63 @@ var snapshotBroadcastInFlight = false;
 var snapshotBroadcastQueued = false;
 var snapshotBroadcastForceRefresh = false;
 var projectRoot = process.cwd();
+var archState = {
+  pendingRules: 0,
+  archRuleCount: 0,
+  layers: [],
+  rules: [],
+  lastCheckResult: null
+};
+var HISTORY_MAX = 200;
+function historyPath() {
+  return join(projectRoot, ".archmind", "violation-history.json");
+}
+function readViolationHistory() {
+  const path = historyPath();
+  if (!existsSync(path)) return [];
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function appendViolationHistory(file, violations, timestamp) {
+  try {
+    const archmindDir = join(projectRoot, ".archmind");
+    mkdirSync(archmindDir, { recursive: true });
+    const history = readViolationHistory();
+    history.unshift({ timestamp, file, violations });
+    if (history.length > HISTORY_MAX) history.length = HISTORY_MAX;
+    writeFileSync(historyPath(), JSON.stringify(history, null, 2), "utf-8");
+  } catch {
+  }
+}
+function readArchState() {
+  const archmindDir = join(projectRoot, ".archmind");
+  const queuePath = join(archmindDir, "approval-queue.json");
+  const rulesPath = join(archmindDir, "rules.json");
+  const layersPath = join(archmindDir, "layers.json");
+  try {
+    const queue = readJsonFile(queuePath, {});
+    archState.pendingRules = Array.isArray(queue.items) ? queue.items.length : 0;
+  } catch {
+    archState.pendingRules = 0;
+  }
+  try {
+    const config = readJsonFile(rulesPath, {});
+    archState.rules = Array.isArray(config.rules) ? config.rules : [];
+    archState.archRuleCount = archState.rules.length;
+  } catch {
+    archState.rules = [];
+    archState.archRuleCount = 0;
+  }
+  try {
+    const config = readJsonFile(layersPath, {});
+    archState.layers = Array.isArray(config.layers) ? config.layers : [];
+  } catch {
+    archState.layers = [];
+  }
+}
 function resolveDashboardProjectRoot(inputPath) {
   const candidate = (inputPath ?? process.cwd()).trim();
   if (candidate.endsWith(".memory-core.json")) {
@@ -85,7 +147,7 @@ function resolveDeclaredArchitectures(config, detectedFramework) {
   const declaredArchitectures = [...new Set([
     backendArchitecture,
     frontendFramework
-  ].filter((value) => Boolean(value)))];
+  ].filter((value) => Boolean(value) && value !== "custom"))];
   if (declaredArchitectures.length > 0) {
     return { backendArchitecture, frontendFramework, declaredArchitectures };
   }
@@ -145,8 +207,7 @@ function parseEnvFile(raw) {
   return values;
 }
 function getRuntimeEnvPath() {
-  const memoryEnv = join(projectRoot, ".memory-core.env");
-  return existsSync(memoryEnv) ? memoryEnv : join(projectRoot, ".env");
+  return join(projectRoot, ".memory-core.env");
 }
 function reloadRuntimeEnv() {
   const envPath = getRuntimeEnvPath();
@@ -179,9 +240,20 @@ function buildStatsPayload() {
     files,
     topRules: topEntries(rules),
     topFiles: topEntries(files),
-    recentViolations: stats.recentViolations ?? []
+    recentViolations: stats.recentViolations ?? [],
+    tokens: stats.tokens ?? { calls: 0, inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+    bypasses: stats.bypasses ?? { total: 0, withReason: 0, withoutReason: 0 }
   };
 }
+function broadcastStats() {
+  const payload = JSON.stringify({ type: "stats", stats: buildStatsPayload(), timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  for (const client of clients) {
+    try {
+      client.write(payload);
+    } catch {
+    }
+  }
+}
 function redactDatabaseUrl(url) {
   if (!url) return "(not set)";
   return url.replace(/:\/\/([^:@/]+)(?::[^@/]+)?@/, "://$1:***@");
@@ -407,6 +479,7 @@ async function getSnapshotBase(forceRefresh = false) {
 }
 async function getSnapshot(options = {}) {
   const base = await getSnapshotBase(options.forceBaseRefresh ?? false);
+  readArchState();
   return {
     config: base.config,
     runtime: base.runtime,
@@ -416,7 +489,9 @@ async function getSnapshot(options = {}) {
     watcher: watcherStatus,
     memories: base.memories,
     memoryCount: base.memoryCount,
-    dbError: base.dbError
+    dbError: base.dbError,
+    arch: { ...archState },
+    violationHistory: readViolationHistory().slice(0, 50)
   };
 }
 function sendJson(res, status, payload) {
@@ -528,6 +603,53 @@ async function handleApi(req, res, url) {
       scheduleSnapshotBroadcast({ delayMs: 0, forceBaseRefresh: true });
       return;
     }
+    if (req.method === "POST" && url.pathname === "/api/config/model") {
+      const body = await readBody(req);
+      const provider = typeof body.provider === "string" && body.provider.trim() ? body.provider.trim() : null;
+      const model = typeof body.model === "string" && body.model.trim() ? body.model.trim() : null;
+      if (!provider && !model) {
+        sendJson(res, 400, { error: "provider or model is required" });
+        return;
+      }
+      const envPath = join(projectRoot, ".memory-core.env");
+      const existing = existsSync(envPath) ? readFileSync(envPath, "utf-8") : "";
+      let lines = existing.split("\n").filter((l) => l.trim());
+      if (provider) {
+        lines = lines.filter((l) => !l.startsWith("CHAT_PROVIDER="));
+        lines.push(`CHAT_PROVIDER=${provider}`);
+      }
+      if (model) {
+        lines = lines.filter((l) => !l.startsWith("CHAT_MODEL=") && !l.startsWith("OLLAMA_CHAT_MODEL="));
+        lines.push(`CHAT_MODEL=${model}`);
+      }
+      writeFileSync(envPath, lines.join("\n") + "\n", "utf-8");
+      reloadRuntimeEnv();
+      invalidateSnapshotBase();
+      scheduleSnapshotBroadcast({ delayMs: 0, forceBaseRefresh: true });
+      sendJson(res, 200, { ok: true });
+      return;
+    }
+    if (req.method === "POST" && url.pathname === "/api/actions/sync") {
+      const { spawn } = await import("child_process");
+      const proc = spawn("memory-core", ["sync", "--no-confirm"], { cwd: projectRoot, detached: true, stdio: "ignore" });
+      proc.unref();
+      sendJson(res, 200, { ok: true, message: "Sync started" });
+      return;
+    }
+    if (req.method === "POST" && url.pathname === "/api/actions/check-all") {
+      const { spawn } = await import("child_process");
+      const proc = spawn("memory-core", ["check", "--all"], { cwd: projectRoot, detached: true, stdio: "ignore" });
+      proc.unref();
+      sendJson(res, 200, { ok: true, message: "Full scan started" });
+      return;
+    }
+    if (req.method === "POST" && url.pathname === "/api/actions/tune") {
+      const { spawn } = await import("child_process");
+      const proc = spawn("memory-core", ["tune"], { cwd: projectRoot, detached: true, stdio: "ignore" });
+      proc.unref();
+      sendJson(res, 200, { ok: true, message: "Tune started" });
+      return;
+    }
     sendJson(res, 404, { error: "Not found" });
   } catch (err) {
     sendJson(res, 500, { error: err.message });
@@ -549,8 +671,14 @@ function contentType(path) {
       return "application/octet-stream";
   }
 }
+function resolveDashboardDir() {
+  const distDir = join(projectRoot, "dist", "dashboard");
+  if (existsSync(join(distDir, "index.html"))) return distDir;
+  const srcDir = join(fileURLToPath(new URL(".", import.meta.url)), "dashboard");
+  return srcDir;
+}
 function serveStatic(req, res, url) {
-  const dashboardDir = join(fileURLToPath(new URL(".", import.meta.url)), "dashboard");
+  const dashboardDir = resolveDashboardDir();
   const requested = url.pathname === "/" ? "/index.html" : url.pathname;
   const filePath = normalize(join(dashboardDir, requested));
   if (!filePath.startsWith(dashboardDir) || relative(dashboardDir, filePath).startsWith("..")) {
@@ -692,6 +820,7 @@ function handleWatchEvent(event) {
       lastSeen: event.timestamp,
       violations: event.violations
     });
+    appendViolationHistory(event.file, event.violations, event.timestamp);
   }
   if (event.type === "error") {
     watcherStatus.error = event.message;
@@ -726,18 +855,25 @@ function acceptWebSocket(req, socket) {
 function startConfigWatch() {
   let timer;
   const watchedFiles = [".env", ".memory-core.env", ".memory-core.json", ".memory-core-stats.json"];
+  const archmindFiles = ["approval-queue.json", "rules.json"];
+  const archmindDir = join(projectRoot, ".archmind");
   const watchedPaths = /* @__PURE__ */ new Set();
   const watchers = [];
   const reload = (filePath) => {
     if (timer) clearTimeout(timer);
     timer = setTimeout(async () => {
+      const fileName = filePath.split("/").pop() ?? "";
+      if (fileName === ".memory-core-stats.json") {
+        broadcastStats();
+        return;
+      }
       reloadRuntimeEnv();
       await closePool();
       invalidateSnapshotBase();
       recentEvents.push({
         type: "error",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        message: `Configuration reloaded from ${filePath.split("/").pop()}`
+        message: `Configuration reloaded from ${fileName}`
       });
       if (recentEvents.length > 100) recentEvents.shift();
       scheduleSnapshotBroadcast({ forceBaseRefresh: true });
@@ -759,6 +895,16 @@ function startConfigWatch() {
     }
     reload(filePath);
   }));
+  if (existsSync(archmindDir)) {
+    watchers.push(watch(archmindDir, (_eventType, filename) => {
+      if (typeof filename !== "string" || !archmindFiles.includes(filename)) return;
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => {
+        readArchState();
+        scheduleSnapshotBroadcast({ forceBaseRefresh: false });
+      }, 150);
+    }));
+  }
   return () => {
     if (timer) clearTimeout(timer);
     for (const watcher of watchers) watcher.close();
@@ -815,6 +961,7 @@ async function startDashboard(options = {}) {
 }
 export {
   mapFrameworkToArchitecture,
+  readViolationHistory,
   resolveDashboardProjectRoot,
   resolveDeclaredArchitectures,
   startDashboard

package/dist/db-PRDHI2CN.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import {
+  closePool,
+  deleteMemories,
+  deleteMemory,
+  getMemory,
+  getPool,
+  hashMemoryContent,
+  listMemories,
+  runMigrations,
+  saveMemory,
+  searchMemories,
+  updateMemory,
+  upsertMemory
+} from "./chunk-M7NKSXFS.js";
+export {
+  closePool,
+  deleteMemories,
+  deleteMemory,
+  getMemory,
+  getPool,
+  hashMemoryContent,
+  listMemories,
+  runMigrations,
+  saveMemory,
+  searchMemories,
+  updateMemory,
+  upsertMemory
+};

package/dist/deepseek-critique-MALVIYGF.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+import {
+  callChatModel
+} from "./chunk-PQBWHAZN.js";
+
+// src/models/deepseek-critique.ts
+function loadDeepSeekConfig(_configDir) {
+  return {};
+}
+var DeepSeekCritique = class {
+  constructor(_config) {
+  }
+  async critique(packet, primaryDecision) {
+    try {
+      const result = await callChatModel([
+        {
+          role: "system",
+          content: "You are an expert architecture reviewer. Validate or override model decisions based only on the provided evidence. Return ONLY valid JSON."
+        },
+        {
+          role: "user",
+          content: buildCritiquePrompt(packet, primaryDecision)
+        }
+      ]);
+      return parseDecision(result.content, primaryDecision);
+    } catch {
+      return {
+        decision: primaryDecision.decision,
+        confidence: primaryDecision.confidence,
+        reasoning: "Chat model unavailable for critique \u2014 using primary decision",
+        override: false
+      };
+    }
+  }
+};
+function buildCritiquePrompt(packet, primary) {
+  return `Validate this architecture review decision.
+
+PRIMARY DECISION:
+- Decision: ${primary.decision}
+- Confidence: ${primary.confidence}
+- Reasoning: ${primary.reasoning}
+- Violations cited: ${primary.violations.join(", ") || "none"}
+
+EVIDENCE SUMMARY:
+- Changed files: ${packet.changedFiles.map((f) => `${f.file} (${f.layer})`).join(", ") || "none"}
+- Violations: ${packet.violations.map((v) => `${v.rule.name}: ${v.fromFile} \u2192 ${v.toFile}`).join(", ") || "none"}
+- Graph violations: ${packet.graphViolations.map((v) => v.ruleName).join(", ") || "none"}
+- Matched rules: ${packet.matchedRules.map((r) => r.name).join(", ") || "none"}
+
+TASK:
+1. Is the primary decision supported by the evidence?
+2. Were any violations missed?
+3. Should the decision be overridden?
+
+Return ONLY this JSON, no other text:
+{
+  "decision": "allow",
+  "confidence": 0.9,
+  "reasoning": "",
+  "override": false
+}`;
+}
+function parseDecision(raw, fallback) {
+  try {
+    const match = raw.match(/\{[\s\S]*\}/);
+    if (!match) throw new Error("no JSON");
+    const parsed = JSON.parse(match[0]);
+    return {
+      decision: ["allow", "warn", "block"].includes(parsed.decision) ? parsed.decision : fallback.decision,
+      confidence: typeof parsed.confidence === "number" ? Math.max(0, Math.min(1, parsed.confidence)) : fallback.confidence,
+      reasoning: parsed.reasoning ?? "",
+      override: parsed.override ?? false
+    };
+  } catch {
+    return { decision: fallback.decision, confidence: fallback.confidence, reasoning: "Parse error", override: false };
+  }
+}
+export {
+  DeepSeekCritique,
+  loadDeepSeekConfig
+};

package/dist/deterministic-validator-PP56B46I.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+// src/models/deterministic-validator.ts
+var DeterministicValidator = class {
+  validate(packet) {
+    if (packet.violations.some((v) => v.rule.severity === "critical")) return "block";
+    if (packet.graphViolations.length > 0) return "block";
+    const newInRestricted = packet.changedFiles.filter(
+      (f) => f.isNew && ["infrastructure", "config"].includes(f.layer)
+    );
+    if (newInRestricted.length > 0) return "warn";
+    if (packet.violations.some((v) => v.rule.severity === "medium")) return "warn";
+    return "allow";
+  }
+};
+export {
+  DeterministicValidator
+};

package/dist/evidence-HVMSONTT.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+// src/core/evidence.ts
+import { dirname, resolve } from "path";
+var EvidencePacketBuilder = class {
+  constructor(cwd = process.cwd()) {
+    this.cwd = cwd;
+  }
+  cwd;
+  async build(diff, astAnalyzer, classifier, ruleMatcher, graph) {
+    const changedFiles = classifier.classifyDiff(diff);
+    const layersAffected = [...new Set(changedFiles.map((f) => f.layer))];
+    const importsMap = [];
+    const violations = [];
+    for (const file of [...diff.added, ...diff.modified]) {
+      const astInfo = astAnalyzer.analyze(file);
+      importsMap.push({ file, imports: astInfo.imports });
+      const fromClassified = classifier.classifyFile(file);
+      if (!fromClassified) continue;
+      for (const imp of astInfo.imports) {
+        if (imp.isExternal) continue;
+        const importedFile = this.resolveImport(file, imp.module);
+        const toClassified = classifier.classifyFile(importedFile);
+        if (!toClassified) continue;
+        const violatingRules = ruleMatcher.findViolatingRules(fromClassified.layer, toClassified.layer);
+        for (const rule of violatingRules) {
+          violations.push({ rule, fromFile: file, toFile: importedFile, imports: [imp] });
+        }
+      }
+    }
+    const graphViolations = graph.findViolations(ruleMatcher.getAllRules());
+    const matchedRules = ruleMatcher.getRulesForLayers(layersAffected);
+    return {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      changedFiles,
+      layersAffected,
+      imports: importsMap,
+      matchedRules,
+      violations,
+      graphViolations,
+      diffSummary: this.generateDiffSummary(changedFiles),
+      metadata: {
+        totalFilesChanged: diff.added.length + diff.modified.length,
+        newFiles: diff.added.length,
+        layerTransitions: violations.length
+      }
+    };
+  }
+  generateDiffSummary(files) {
+    const layers = [...new Set(files.map((f) => f.layer))];
+    const newCount = files.filter((f) => f.isNew).length;
+    return `Modified ${files.length} files across ${layers.length} layer(s) (${newCount} new)`;
+  }
+  resolveImport(fromFile, importPath) {
+    if (importPath.startsWith(".")) {
+      const abs = resolve(this.cwd, dirname(fromFile), importPath).replace(/\\/g, "/");
+      const base = this.cwd.replace(/\\/g, "/").replace(/\/?$/, "/");
+      return abs.startsWith(base) ? abs.slice(base.length) : abs;
+    }
+    return importPath;
+  }
+};
+export {
+  EvidencePacketBuilder
+};

package/dist/graph-TFNTB5OK.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+// src/core/graph.ts
+import { dirname, resolve } from "path";
+var DependencyGraph = class {
+  nodes = /* @__PURE__ */ new Map();
+  edges = [];
+  addNode(file, layer, imports) {
+    this.nodes.set(file, { id: file, layer, imports });
+  }
+  addEdge(from, to) {
+    this.edges.push({ from, to, type: "import" });
+  }
+  validateDependency(from, to, rules) {
+    const fromNode = this.nodes.get(from);
+    const toNode = this.nodes.get(to);
+    if (!fromNode || !toNode) return null;
+    for (const rule of rules) {
+      const fromMatches = rule.fromLayer === fromNode.layer || rule.fromLayer === "*";
+      const toMatches = rule.toLayer === toNode.layer || rule.toLayer === "*";
+      if (fromMatches && toMatches && !rule.allowed) {
+        return {
+          from,
+          fromLayer: fromNode.layer,
+          to,
+          toLayer: toNode.layer,
+          ruleName: rule.name,
+          path: [from, to]
+        };
+      }
+    }
+    return null;
+  }
+  findViolations(rules) {
+    const violations = [];
+    for (const edge of this.edges) {
+      const v = this.validateDependency(edge.from, edge.to, rules);
+      if (v) violations.push(v);
+    }
+    return violations;
+  }
+  findPath(from, to) {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [[from, [from]]];
+    while (queue.length > 0) {
+      const [current, path] = queue.shift();
+      if (current === to) return path;
+      if (visited.has(current)) continue;
+      visited.add(current);
+      const node = this.nodes.get(current);
+      if (!node) continue;
+      for (const neighbor of node.imports) {
+        if (!visited.has(neighbor)) queue.push([neighbor, [...path, neighbor]]);
+      }
+    }
+    return null;
+  }
+  getNodes() {
+    return [...this.nodes.values()];
+  }
+  getEdges() {
+    return this.edges;
+  }
+};
+var GraphBuilder = class {
+  constructor(astAnalyzer, classifier, cwd = process.cwd()) {
+    this.astAnalyzer = astAnalyzer;
+    this.classifier = classifier;
+    this.cwd = cwd;
+  }
+  astAnalyzer;
+  classifier;
+  cwd;
+  async buildFromFiles(files) {
+    const graph = new DependencyGraph();
+    for (const file of files) {
+      const classified = this.classifier.classifyFile(file);
+      if (!classified) continue;
+      const astInfo = this.astAnalyzer.analyze(file);
+      const resolvedImports = astInfo.imports.filter((imp) => !imp.isExternal).map((imp) => this.resolveImport(file, imp.module));
+      graph.addNode(file, classified.layer, resolvedImports);
+      for (const resolved of resolvedImports) {
+        graph.addEdge(file, resolved);
+      }
+    }
+    return graph;
+  }
+  resolveImport(fromFile, importPath) {
+    if (importPath.startsWith(".")) {
+      return resolve(this.cwd, dirname(fromFile), importPath).replace(/\\/g, "/");
+    }
+    return importPath;
+  }
+};
+export {
+  DependencyGraph,
+  GraphBuilder
+};

package/dist/incident-capture-RVPZULS7.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+// src/automation/incident-capture.ts
+var IncidentCaptureService = class {
+  draftRule(incident) {
+    return {
+      id: `auto-incident-${Date.now()}`,
+      name: `[INCIDENT] ${incident.what.slice(0, 60)}`,
+      description: `Root cause: ${incident.why}. Applies to: ${incident.where}`,
+      fromLayer: "*",
+      toLayer: "*",
+      allowed: false,
+      severity: "critical",
+      enforcement: "block"
+    };
+  }
+};
+export {
+  IncidentCaptureService
+};