@shahmilsaari/memory-core 1.0.25 → 1.0.26

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
+};

package/dist/ollama-judge-D2LFK5PB.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+import {
+  callChatModel
+} from "./chunk-PQBWHAZN.js";
+
+// src/models/ollama-judge.ts
+function loadOllamaConfig(_configDir) {
+  return {};
+}
+var MAX_RETRIES = 3;
+var BASE_DELAY_MS = 800;
+function isRetryable(err) {
+  if (!(err instanceof Error)) return false;
+  const msg = err.message.toLowerCase();
+  if (msg.includes("timeout") || msg.includes("etimedout") || msg.includes("econnrefused") || msg.includes("fetch failed") || msg.includes("enotfound")) return true;
+  const code = err.cause?.code;
+  if (code && /^(ECONNREFUSED|ETIMEDOUT|ENOTFOUND|ECONNRESET|EPIPE)$/.test(code)) return true;
+  return false;
+}
+async function withRetry(fn, retries = MAX_RETRIES) {
+  let lastErr;
+  for (let attempt = 0; attempt < retries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (!isRetryable(err) || attempt === retries - 1) throw err;
+      await new Promise((r) => setTimeout(r, BASE_DELAY_MS * (attempt + 1)));
+    }
+  }
+  throw lastErr;
+}
+var OllamaJudge = class {
+  constructor(_config) {
+  }
+  async judge(packet, memories = []) {
+    try {
+      const result = await withRetry(() => callChatModel([
+        {
+          role: "system",
+          content: "You are an architecture review system. Analyze evidence and return ONLY valid JSON with no extra text."
+        },
+        {
+          role: "user",
+          content: buildPrompt(packet, memories)
+        }
+      ]));
+      return calibrateConfidence(parseDecision(result.content), packet);
+    } catch (err) {
+      return fallbackToDeterministic(packet, err);
+    }
+  }
+};
+function buildPrompt(packet, memories = []) {
+  const memoriesSection = memories.length > 0 ? `
+PROJECT RULES FROM MEMORY:
+${memories.map((m) => `- [${m.type}] ${m.content}${m.reason ? ` (reason: ${m.reason})` : ""}`).join("\n")}
+` : "";
+  return `Analyze the following architecture evidence and return ONLY valid JSON.
+
+RULES THAT APPLY:
+${packet.matchedRules.map((r) => `- ${r.name} (${r.severity}): ${r.description}`).join("\n") || "None"}
+${memoriesSection}
+CHANGED FILES:
+${packet.changedFiles.map((f) => `- ${f.file} (layer: ${f.layer})`).join("\n") || "None"}
+
+IMPORTS ANALYZED:
+${packet.imports.map((i) => `${i.file}:
+${i.imports.map((imp) => `  - "${imp.module}"${imp.isExternal ? " [external]" : ""}`).join("\n")}`).join("\n") || "None"}
+
+VIOLATIONS DETECTED:
+${packet.violations.length > 0 ? packet.violations.map((v) => `- ${v.rule.name} (${v.rule.severity}): ${v.fromFile} \u2192 ${v.toFile}`).join("\n") : "None"}
+
+GRAPH VIOLATIONS:
+${packet.graphViolations.length > 0 ? packet.graphViolations.map((v) => `- ${v.ruleName}: ${v.fromLayer} \u2192 ${v.toLayer}`).join("\n") : "None"}
+
+TASK:
+1. Do the violations represent real rule breaches?
+2. Are there hidden violations not yet detected?
+3. Is this change safe to merge?
+
+CONSTRAINTS:
+- Only cite evidence from the packet above \u2014 do NOT invent project conventions
+- If uncertain, return "warn" not "block"
+- Return ONLY this JSON structure, no other text:
+{
+  "decision": "allow",
+  "confidence": 0.9,
+  "violations": [],
+  "evidence": [],
+  "suggestedFix": "",
+  "reasoning": ""
+}`;
+}
+function parseDecision(raw) {
+  const match = raw.match(/\{[\s\S]*\}/);
+  if (!match) throw new Error("Model did not return valid JSON");
+  const parsed = JSON.parse(match[0]);
+  return {
+    decision: ["allow", "warn", "block"].includes(parsed.decision) ? parsed.decision : "warn",
+    confidence: typeof parsed.confidence === "number" ? Math.max(0, Math.min(1, parsed.confidence)) : 0.5,
+    violations: Array.isArray(parsed.violations) ? parsed.violations : [],
+    evidence: Array.isArray(parsed.evidence) ? parsed.evidence : [],
+    suggestedFix: parsed.suggestedFix ?? "",
+    reasoning: parsed.reasoning ?? ""
+  };
+}
+function calibrateConfidence(raw, packet) {
+  const blockViolations = packet.violations.filter((v) => v.rule.enforcement === "block").length;
+  const warnViolations = packet.violations.filter((v) => v.rule.enforcement === "warn").length;
+  const graphViolationCount = packet.graphViolations.length;
+  const totalDeterministicViolations = blockViolations + warnViolations + graphViolationCount;
+  let adjusted = raw.confidence;
+  if (blockViolations > 0 || graphViolationCount > 0) {
+    adjusted = Math.max(adjusted, 0.85 + Math.min(blockViolations + graphViolationCount, 5) * 0.02);
+  } else if (totalDeterministicViolations === 0 && raw.decision === "block") {
+    adjusted = Math.min(adjusted, 0.6);
+  } else if (totalDeterministicViolations === 0 && raw.decision === "allow") {
+    adjusted = Math.max(adjusted, 0.75);
+  }
+  return { ...raw, confidence: Math.max(0, Math.min(1, adjusted)) };
+}
+function fallbackToDeterministic(packet, err) {
+  const hasBlock = packet.violations.some((v) => v.rule.enforcement === "block") || packet.graphViolations.length > 0;
+  return {
+    decision: hasBlock ? "block" : "warn",
+    confidence: 1,
+    violations: packet.violations.map((v) => v.rule.name),
+    evidence: ["Deterministic fallback (chat model unavailable)"],
+    suggestedFix: "Remove imports from blocked layers",
+    reasoning: `Chat model unavailable (${err instanceof Error ? err.message : String(err)}); used AST/graph analysis`
+  };
+}
+export {
+  OllamaJudge,
+  loadOllamaConfig
+};

package/dist/rate-limiter-SLIPCXRF.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+// src/core/rate-limiter.ts
+import { writeFileSync, unlinkSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+var LOCK_TIMEOUT_MS = 3e4;
+var POLL_MS = 200;
+var CheckRateLimiter = class {
+  lockPath;
+  constructor(rootPath) {
+    const dir = join(rootPath, ".archmind", "cache");
+    mkdirSync(dir, { recursive: true });
+    this.lockPath = join(dir, "check.lock");
+  }
+  async acquire() {
+    const deadline = Date.now() + LOCK_TIMEOUT_MS;
+    while (existsSync(this.lockPath)) {
+      if (Date.now() > deadline) {
+        try {
+          unlinkSync(this.lockPath);
+        } catch {
+        }
+        break;
+      }
+      await new Promise((r) => setTimeout(r, POLL_MS));
+    }
+    try {
+      writeFileSync(this.lockPath, String(process.pid), "utf-8");
+    } catch {
+    }
+    return () => {
+      try {
+        unlinkSync(this.lockPath);
+      } catch {
+      }
+    };
+  }
+};
+export {
+  CheckRateLimiter
+};

package/dist/rules-V3QMN3AR.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+
+// src/core/rules.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+var RuleMatcher = class _RuleMatcher {
+  constructor(rules) {
+    this.rules = rules;
+  }
+  rules;
+  findApplicableRules(fromLayer, toLayer) {
+    return this.rules.filter(
+      (rule) => (rule.fromLayer === fromLayer || rule.fromLayer === "*") && (rule.toLayer === toLayer || rule.toLayer === "*")
+    );
+  }
+  findViolatingRules(fromLayer, toLayer) {
+    const hasExplicitAllow = this.rules.some(
+      (r) => r.fromLayer === fromLayer && r.toLayer === toLayer && r.allowed
+    );
+    return this.findApplicableRules(fromLayer, toLayer).filter((rule) => {
+      if (rule.allowed) return false;
+      if (rule.fromLayer === "*" || rule.toLayer === "*") return !hasExplicitAllow;
+      return true;
+    });
+  }
+  scoreViolations(violations) {
+    if (violations.some((v) => v.severity === "critical")) return "block";
+    if (violations.some((v) => v.severity === "medium")) return "warn";
+    return "suggest";
+  }
+  getRulesForLayers(layers) {
+    return this.rules.filter(
+      (rule) => layers.includes(rule.fromLayer) || rule.fromLayer === "*"
+    );
+  }
+  getAllRules() {
+    return this.rules;
+  }
+  static loadFromConfig(configDir) {
+    const rulesPath = join(configDir, "rules.json");
+    if (!existsSync(rulesPath)) {
+      return new _RuleMatcher(defaultRules());
+    }
+    const config = JSON.parse(readFileSync(rulesPath, "utf-8"));
+    return new _RuleMatcher(config.rules);
+  }
+};
+function defaultRules() {
+  return [
+    {
+      id: "domain-no-infra",
+      name: "Domain layer must not import infrastructure",
+      description: "Domain layer should depend only on itself and shared utilities",
+      fromLayer: "domain",
+      toLayer: "infrastructure",
+      allowed: false,
+      severity: "critical",
+      enforcement: "block"
+    },
+    {
+      id: "domain-no-api",
+      name: "Domain layer must not import API layer",
+      description: "Domain must remain framework-agnostic",
+      fromLayer: "domain",
+      toLayer: "api",
+      allowed: false,
+      severity: "critical",
+      enforcement: "block"
+    },
+    {
+      id: "api-no-infra-direct",
+      name: "API layer should not import infrastructure directly",
+      description: "HTTP handlers should use application/domain services, not infra directly",
+      fromLayer: "api",
+      toLayer: "infrastructure",
+      allowed: false,
+      severity: "medium",
+      enforcement: "warn"
+    },
+    {
+      id: "api-depends-on-domain",
+      name: "API layer should depend on domain layer",
+      description: "HTTP handlers should use domain services",
+      fromLayer: "api",
+      toLayer: "domain",
+      allowed: true,
+      severity: "low",
+      enforcement: "suggest"
+    }
+  ];
+}
+export {
+  RuleMatcher,
+  defaultRules
+};

package/dist/watch-errors-B3FA26N4.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+import {
+  ApprovalQueue
+} from "./chunk-W6WEAV3S.js";
+
+// src/automation/watch-errors.ts
+import { spawn } from "child_process";
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
+import { join } from "path";
+function loadWatchConfig(configDir) {
+  const cfgPath = join(configDir, "watch-errors.json");
+  if (existsSync(cfgPath)) {
+    return JSON.parse(readFileSync(cfgPath, "utf-8"));
+  }
+  return defaultWatchConfig(configDir);
+}
+function defaultWatchConfig(configDir) {
+  return {
+    commands: ["npm test", "tsc --noEmit"],
+    patterns: {
+      "Cannot find module": { regex: "Cannot find module '([^']+)'", template: "Cannot find module" },
+      "Circular dependency": { regex: "Circular dependency detected: ([^ ]+)", template: "Circular dependency" },
+      "Type error": { regex: "error TS\\d+: (.+)", template: "TypeScript type error" }
+    },
+    outputDir: join(configDir, "auto-rules")
+  };
+}
+var WatchErrors = class {
+  constructor(config, configDir) {
+    this.config = config;
+    this.configDir = configDir;
+    this.queue = new ApprovalQueue(configDir);
+    if (!existsSync(config.outputDir)) {
+      mkdirSync(config.outputDir, { recursive: true });
+    }
+  }
+  config;
+  configDir;
+  processes = /* @__PURE__ */ new Map();
+  queue;
+  start(onDraft) {
+    for (const cmd of this.config.commands) {
+      const [bin, ...args] = cmd.split(" ");
+      const proc = spawn(bin, args, { shell: true, stdio: ["ignore", "pipe", "pipe"] });
+      const handleLine = (line) => {
+        const rule = this.analyzeErrorLine(line);
+        if (rule) {
+          this.queue.add(rule, "watch", "low");
+          this.saveRuleToDisk(rule);
+          onDraft?.(rule);
+        }
+      };
+      let buffer = "";
+      const flush = (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        lines.forEach(handleLine);
+      };
+      proc.stdout?.on("data", flush);
+      proc.stderr?.on("data", flush);
+      proc.on("exit", () => this.processes.delete(cmd));
+      this.processes.set(cmd, proc);
+    }
+  }
+  stop() {
+    for (const proc of this.processes.values()) {
+      proc.kill();
+    }
+    this.processes.clear();
+  }
+  analyzeErrorLine(line) {
+    for (const [key, pattern] of Object.entries(this.config.patterns)) {
+      const match = line.match(new RegExp(pattern.regex));
+      if (match) {
+        return {
+          id: `auto-watch-${Date.now()}`,
+          name: `[WATCH] ${key}: ${(match[1] ?? "").slice(0, 50)}`,
+          description: line.trim().slice(0, 200),
+          fromLayer: "*",
+          toLayer: "*",
+          allowed: true,
+          severity: "low",
+          enforcement: "suggest"
+        };
+      }
+    }
+    return null;
+  }
+  saveRuleToDisk(rule) {
+    const filename = join(this.config.outputDir, `${rule.id}.json`);
+    writeFileSync(filename, JSON.stringify(rule, null, 2));
+  }
+};
+export {
+  WatchErrors,
+  defaultWatchConfig,
+  loadWatchConfig
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shahmilsaari/memory-core",
-  "version": "1.0.25",
+  "version": "1.0.26",
   "description": "Universal AI memory core — generate AI context files from architecture profiles with RAG support",
   "homepage": "https://memory-core.shahmilsaari.my/",
   "type": "module",