@shahmilsaari/memory-core 1.0.33 → 1.0.35

package/dist/{dashboard-server-LWMXEJHE.js → dashboard-server-UBZHOPRC.js}

@@ -1,17 +1,18 @@
 #!/usr/bin/env node
 import {
   buildArchRules,
-  buildLayersTemplate,
+  buildLayersTemplate
+} from "./chunk-HJCPBM7B.js";
+import {
   detectProject,
-  embed,
   inferProjectArchitectures,
   startWatch
-} from "./chunk-23GUWJ6F.js";
+} from "./chunk-4QWIYO2G.js";
+import "./chunk-ZZBQEXEO.js";
 import {
-  getChatProviderLabel
-} from "./chunk-PQBWHAZN.js";
+  embed
+} from "./chunk-SKR44CRD.js";
 import {
-  Config,
   closePool,
   countUsers,
   createUser,
@@ -19,6 +20,7 @@ import {
   deleteMemory,
   deleteUser,
   getArchProfile,
+  getMemory,
   getPool,
   getUserByEmail,
   listArchProfiles,
@@ -27,13 +29,21 @@ import {
   saveArchProfile,
   saveMemory,
   updateLastLogin,
-  updateMemory
-} from "./chunk-GIPKVQSA.js";
-import "./chunk-ZZBQEXEO.js";
+  updateMemory,
+  upsertMemory
+} from "./chunk-5T2QBBYT.js";
+import {
+  Config
+} from "./chunk-2LNDQGDD.js";
+import {
+  callChatModel,
+  getChatProviderLabel
+} from "./chunk-XAE3RY5D.js";
+import "./chunk-K3NQKI34.js";
 
 // src/dashboard-server.ts
 import { createHash } from "crypto";
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 import { createReadStream, existsSync, mkdirSync, readFileSync, watch, writeFileSync } from "fs";
 import { createServer } from "http";
 import { basename, dirname, extname, join, normalize, relative, resolve } from "path";
@@ -88,6 +98,8 @@ var watcherStatus = {
 };
 var RUNTIME_ENV_KEYS = [
   "DATABASE_URL",
+  "EMBEDDING_URL",
+  "EMBEDDING_MODEL",
   "OLLAMA_URL",
   "OLLAMA_MODEL",
   "CHAT_PROVIDER",
@@ -127,7 +139,7 @@ function readViolationHistory() {
 }
 function getGitAuthor(file) {
   try {
-    return execSync(`git log --format="%an" -1 -- "${file}"`, { cwd: projectRoot, stdio: ["ignore", "pipe", "ignore"], timeout: 2e3 }).toString().trim() || void 0;
+    return execFileSync("git", ["log", "--format=%an", "-1", "--", file], { cwd: projectRoot, stdio: ["ignore", "pipe", "ignore"], timeout: 2e3 }).toString().trim() || void 0;
   } catch {
     return void 0;
   }
@@ -144,14 +156,65 @@ function appendViolationHistory(file, violations, timestamp) {
   } catch {
   }
 }
+function settingsPath() {
+  return join(projectRoot, ".archmind", "dashboard-settings.json");
+}
+var DEFAULT_SETTINGS = {
+  autoFix: false,
+  verbose: false,
+  debug: false,
+  scanOnStart: false
+};
+var cachedSettings = null;
+function readSettings() {
+  if (cachedSettings) return cachedSettings;
+  const path = settingsPath();
+  if (!existsSync(path)) {
+    cachedSettings = { ...DEFAULT_SETTINGS };
+    return cachedSettings;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    cachedSettings = { ...DEFAULT_SETTINGS, ...parsed };
+  } catch {
+    cachedSettings = { ...DEFAULT_SETTINGS };
+  }
+  return cachedSettings;
+}
+function writeSettings(next) {
+  try {
+    const archmindDir = join(projectRoot, ".archmind");
+    mkdirSync(archmindDir, { recursive: true });
+    writeFileSync(settingsPath(), JSON.stringify(next, null, 2), "utf-8");
+    cachedSettings = next;
+  } catch {
+  }
+}
+function markFileResolved(file, timestamp) {
+  try {
+    const history = readViolationHistory();
+    let changed = false;
+    for (const entry of history) {
+      if (entry.file === file && !entry.resolved) {
+        entry.resolved = true;
+        entry.resolvedAt = timestamp;
+        changed = true;
+      }
+    }
+    if (changed) {
+      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;
+    const queue = existsSync(queuePath) ? JSON.parse(readFileSync(queuePath, "utf-8")) : [];
+    archState.pendingRules = Array.isArray(queue) ? queue.filter((i) => i.status === "pending").length : 0;
   } catch {
     archState.pendingRules = 0;
   }
@@ -364,8 +427,8 @@ function buildModelStatusCacheKey() {
   return [
     Config.chatProvider,
     Config.chatModel,
-    Config.ollamaModel,
-    Config.ollamaUrl,
+    Config.embeddingModel,
+    Config.embeddingUrl,
     Config.chatApiKey ? "key:set" : "key:empty"
   ].join("|");
 }
@@ -377,8 +440,8 @@ async function getModelStatus(forceRefresh = false) {
   }
   const provider = Config.chatProvider;
   const checkModel = Config.chatModel;
-  const embeddingModel = Config.ollamaModel;
-  const ollamaUrl = Config.ollamaUrl;
+  const embeddingModel = Config.embeddingModel;
+  const ollamaUrl = Config.embeddingUrl;
   const status = {
     provider,
     checkModel,
@@ -668,6 +731,87 @@ async function handleApi(req, res, url) {
       scheduleSnapshotBroadcast({ delayMs: 0, forceBaseRefresh: true });
       return;
     }
+    if (req.method === "POST" && url.pathname.endsWith("/check")) {
+      const checkMatch = url.pathname.match(/^\/api\/memories\/(\d+)\/check$/);
+      if (!checkMatch) {
+        sendJson(res, 400, { error: "Invalid path" });
+        return;
+      }
+      const id = Number(checkMatch[1]);
+      const memory = await getMemory(id);
+      if (!memory) {
+        sendJson(res, 404, { error: `No memory found with ID ${id}` });
+        return;
+      }
+      const config = readProjectConfig();
+      const architectures = inferProjectArchitectures(projectRoot, config);
+      const projectInfo = [
+        `Project: ${config?.projectName ?? "unknown"}`,
+        `Type: ${config?.projectType ?? "unknown"}`,
+        config?.backendArchitecture ? `Backend: ${config.backendArchitecture}` : "",
+        config?.frontendFramework ? `Frontend: ${config.frontendFramework}` : "",
+        config?.language ? `Language: ${config.language}` : ""
+      ].filter(Boolean).join(", ");
+      const systemPrompt = 'Audit memory rule quality. Return JSON: {"status":"valid|stale|duplicate|vague","confidence":0.X,"reasoning":"","suggestion":"","issues":[]}. stale=outdated APIs/patterns. duplicate=says what other rules say. vague=not actionable.';
+      const truncatedContent = memory.content.length > 800 ? `${memory.content.slice(0, 800)}\u2026[truncated]` : memory.content;
+      const userPrompt = [
+        `Project: ${projectInfo}`,
+        `Arch: ${architectures.join(",") || "none"}`,
+        `Type: ${memory.type} | Scope: ${memory.scope} | Architecture: ${memory.architecture ?? "none"}`,
+        `Tags: ${(memory.tags ?? []).join(",") || "none"}`,
+        memory.title ? `Title: ${memory.title}` : "",
+        "",
+        truncatedContent
+      ].filter(Boolean).join("\n");
+      try {
+        const result = await callChatModel([
+          { role: "system", content: systemPrompt, cache: true },
+          { role: "user", content: userPrompt }
+        ], { timeoutMs: 3e4 });
+        const trimmed = result.content.trim();
+        const jsonMatch = trimmed.match(/(?:```(?:json)?\s*)?(\{[\s\S]*\})(?:\s*```)?/);
+        const parsed = jsonMatch ? JSON.parse(jsonMatch[1]) : JSON.parse(trimmed);
+        sendJson(res, 200, {
+          id: memory.id,
+          status: parsed.status ?? "unknown",
+          confidence: typeof parsed.confidence === "number" ? parsed.confidence : 0,
+          reasoning: parsed.reasoning ?? "",
+          suggestion: parsed.suggestion ?? "",
+          issues: Array.isArray(parsed.issues) ? parsed.issues : [],
+          memory
+        });
+      } catch (err) {
+        sendJson(res, 500, { error: `Model check failed: ${err.message}` });
+      }
+      return;
+    }
+    if (req.method === "POST" && url.pathname.endsWith("/apply-suggestion")) {
+      const applyMatch = url.pathname.match(/^\/api\/memories\/(\d+)\/apply-suggestion$/);
+      if (!applyMatch) {
+        sendJson(res, 400, { error: "Invalid path" });
+        return;
+      }
+      const id = Number(applyMatch[1]);
+      const body = await readBody(req);
+      const content = typeof body.content === "string" ? body.content.trim() : "";
+      if (!content) {
+        sendJson(res, 400, { error: "content is required" });
+        return;
+      }
+      const updated = await updateMemory(id, {
+        content,
+        reason: typeof body.reason === "string" && body.reason.trim() ? body.reason.trim() : void 0,
+        embedding: await embed(content)
+      });
+      if (!updated) {
+        sendJson(res, 404, { error: `No memory found with ID ${id}` });
+        return;
+      }
+      sendJson(res, 200, updated);
+      invalidateSnapshotBase();
+      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;
@@ -704,7 +848,7 @@ async function handleApi(req, res, url) {
       const warnings = [];
       if (effectiveProvider === "ollama") {
         try {
-          const ollamaUrl = process.env.OLLAMA_URL ?? "http://localhost:11434";
+          const ollamaUrl = Config.embeddingUrl;
           const r = await fetch(`${ollamaUrl}/api/tags`, { signal: AbortSignal.timeout(5e3) });
           if (!r.ok) warnings.push(`Ollama returned HTTP ${r.status}`);
         } catch (err) {
@@ -808,13 +952,30 @@ async function handleApi(req, res, url) {
         teamActivity,
         summary: {
           total: history.reduce((s, e) => s + e.violations.length, 0),
-          resolved: history.filter((e) => e.resolved).length,
-          open: history.filter((e) => !e.resolved).length,
+          resolved: history.filter((e) => e.resolved).reduce((s, e) => s + e.violations.length, 0),
+          open: history.filter((e) => !e.resolved).reduce((s, e) => s + e.violations.length, 0),
           uniqueFiles: new Set(history.map((e) => e.file)).size
         }
       });
       return;
     }
+    if (req.method === "GET" && url.pathname === "/api/settings") {
+      sendJson(res, 200, readSettings());
+      return;
+    }
+    if (req.method === "POST" && url.pathname === "/api/settings") {
+      const body = await readBody(req);
+      const current = readSettings();
+      const next = {
+        autoFix: typeof body.autoFix === "boolean" ? body.autoFix : current.autoFix,
+        verbose: typeof body.verbose === "boolean" ? body.verbose : current.verbose,
+        debug: typeof body.debug === "boolean" ? body.debug : current.debug,
+        scanOnStart: typeof body.scanOnStart === "boolean" ? body.scanOnStart : current.scanOnStart
+      };
+      writeSettings(next);
+      sendJson(res, 200, next);
+      return;
+    }
     if (req.method === "DELETE" && url.pathname === "/api/history") {
       try {
         const path = historyPath();
@@ -1145,6 +1306,53 @@ async function handleApi(req, res, url) {
       sendJson(res, deleted ? 200 : 404, deleted ? { ok: true } : { error: "User not found" });
       return;
     }
+    if (req.method === "GET" && url.pathname === "/api/proposals") {
+      const queuePath = join(projectRoot, ".archmind", "approval-queue.json");
+      const items = existsSync(queuePath) ? JSON.parse(readFileSync(queuePath, "utf-8")) : [];
+      const pending = Array.isArray(items) ? items.filter((i) => i.status === "pending") : [];
+      sendJson(res, 200, { proposals: pending });
+      return;
+    }
+    const proposalMatch = url.pathname.match(/^\/api\/proposals\/([^/]+)\/(approve|reject)$/);
+    if (proposalMatch && req.method === "POST") {
+      const [, id, action] = proposalMatch;
+      const queuePath = join(projectRoot, ".archmind", "approval-queue.json");
+      if (!existsSync(queuePath)) {
+        sendJson(res, 404, { error: "No proposals" });
+        return;
+      }
+      const items = JSON.parse(readFileSync(queuePath, "utf-8"));
+      const item = items.find((i) => i.id === id);
+      if (!item) {
+        sendJson(res, 404, { error: "Proposal not found" });
+        return;
+      }
+      item.status = action === "approve" ? "approved" : "rejected";
+      writeFileSync(queuePath, JSON.stringify(items, null, 2));
+      if (action === "approve") {
+        try {
+          const embedding = await embed(item.rule.description);
+          await upsertMemory({
+            type: "rule",
+            scope: "project",
+            title: item.rule.name,
+            content: item.rule.description,
+            reason: `Auto-captured from ${item.source} (confidence: ${item.confidence})`,
+            tags: [item.source, item.rule.severity],
+            embedding
+          });
+          const remaining = items.filter((i) => i.status !== "approved");
+          writeFileSync(queuePath, JSON.stringify(remaining, null, 2));
+          readArchState();
+        } catch (err) {
+          sendJson(res, 500, { error: `Saved to queue but DB insert failed: ${err.message}` });
+          return;
+        }
+      }
+      readArchState();
+      sendJson(res, 200, { ok: true });
+      return;
+    }
     sendJson(res, 404, { error: "Not found" });
   } catch (err) {
     sendJson(res, 500, { error: err.message });
@@ -1272,6 +1480,43 @@ function scheduleSnapshotBroadcast(options = {}) {
     void flushSnapshotBroadcast();
   }, Math.max(0, delayMs));
 }
+async function draftProposalsFromViolations(file, violations) {
+  if (violations.length === 0) return;
+  try {
+    const { draftRuleWithAI, draftRuleFallback } = await import("./draft-rule-NUXOSRRS.js");
+    const { ApprovalQueue } = await import("./approval-queue-4RK46FNE.js");
+    const queue = new ApprovalQueue(join(projectRoot, ".archmind"));
+    let queued = 0;
+    for (const v of violations) {
+      const context = `${v.rule}. Issue: ${v.issue}. File: ${file}`;
+      const aiResult = await draftRuleWithAI({ context, source: "watch" });
+      const { rule, confidence } = aiResult ?? draftRuleFallback({ context, source: "watch" });
+      if (confidence === "high") {
+        try {
+          const embedding = await embed(rule.description);
+          await upsertMemory({
+            type: "rule",
+            scope: "project",
+            title: rule.name,
+            content: rule.description,
+            reason: `Auto-captured from watcher violation in ${file} (high confidence)`,
+            tags: ["watcher", rule.severity],
+            embedding
+          });
+          continue;
+        } catch {
+        }
+      }
+      queue.add(rule, "watch", confidence, { file, evidence: `${v.rule}: ${v.issue}` });
+      queued++;
+    }
+    if (queued > 0) {
+      readArchState();
+      broadcast({ type: "proposals-updated", count: queue.pending().length });
+    }
+  } catch {
+  }
+}
 function handleWatchEvent(event) {
   recentEvents.push(event);
   if (recentEvents.length > 100) recentEvents.shift();
@@ -1298,6 +1543,7 @@ function handleWatchEvent(event) {
       lastSeen: event.timestamp,
       violations: []
     });
+    markFileResolved(event.file, event.timestamp);
   }
   if (event.type === "skipped") {
     fileStatuses.set(event.file, {
@@ -1316,6 +1562,7 @@ function handleWatchEvent(event) {
       violations: event.violations
     });
     appendViolationHistory(event.file, event.violations, event.timestamp);
+    void draftProposalsFromViolations(event.file, event.violations);
   }
   if (event.type === "error") {
     watcherStatus.error = event.message;
@@ -1444,9 +1691,15 @@ async function startDashboard(options = {}) {
   console.log(chalk.gray(`  Project root: ${projectRoot}`));
   if (options.watch ?? true) {
     watcherStatus.enabled = true;
+    const initial = readSettings();
     void startWatch({
       projectRoot,
       path: ".",
+      autoFix: initial.autoFix,
+      verbose: initial.verbose,
+      debug: initial.debug,
+      scanOnStart: initial.scanOnStart,
+      getAutoFix: () => readSettings().autoFix,
       onEvent: handleWatchEvent,
       exitOnSetupFailure: false
     });

package/dist/{db-FLFZZXG3.js → db-RE23O4DV.js}

@@ -23,7 +23,9 @@ import {
   updateLastLogin,
   updateMemory,
   upsertMemory
-} from "./chunk-GIPKVQSA.js";
+} from "./chunk-5T2QBBYT.js";
+import "./chunk-2LNDQGDD.js";
+import "./chunk-K3NQKI34.js";
 export {
   closePool,
   countUsers,

package/dist/{deterministic-validator-PP56B46I.js → deterministic-validator-3LB234OG.js}

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import "./chunk-K3NQKI34.js";
 
 // src/models/deterministic-validator.ts
 var DeterministicValidator = class {

package/dist/draft-rule-NUXOSRRS.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import {
+  draftRuleFallback,
+  draftRuleWithAI
+} from "./chunk-FPRSYCOZ.js";
+import "./chunk-XAE3RY5D.js";
+import "./chunk-K3NQKI34.js";
+export {
+  draftRuleFallback,
+  draftRuleWithAI
+};

package/dist/embedding-VIMV6O2P.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import {
+  embed
+} from "./chunk-SKR44CRD.js";
+import "./chunk-2LNDQGDD.js";
+import "./chunk-K3NQKI34.js";
+export {
+  embed
+};

package/dist/{evidence-HVMSONTT.js → evidence-WFMGWSOP.js}

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import "./chunk-K3NQKI34.js";
 
 // src/core/evidence.ts
 import { dirname, resolve } from "path";

package/dist/{graph-TFNTB5OK.js → graph-UJJAKNHD.js}

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import "./chunk-K3NQKI34.js";
 
 // src/core/graph.ts
 import { dirname, resolve } from "path";

package/dist/{incident-capture-RVPZULS7.js → incident-capture-5YUVJJM3.js}

@@ -1,7 +1,18 @@
 #!/usr/bin/env node
+import {
+  draftRuleFallback,
+  draftRuleWithAI
+} from "./chunk-FPRSYCOZ.js";
+import "./chunk-XAE3RY5D.js";
+import "./chunk-K3NQKI34.js";
 
 // src/automation/incident-capture.ts
 var IncidentCaptureService = class {
+  async draftRuleWithAI(incident) {
+    const context = `What broke: ${incident.what}. Root cause: ${incident.why}. Location: ${incident.where}`;
+    const result = await draftRuleWithAI({ context, source: "incident", hint: incident.why });
+    return result ?? draftRuleFallback({ context, source: "incident" });
+  }
   draftRule(incident) {
     return {
       id: `auto-incident-${Date.now()}`,