@shahmilsaari/memory-core 0.2.14 → 0.2.16

package/dist/cli.js

@@ -7,13 +7,14 @@ import {
   deleteMemories,
   deleteMemory,
   getMemory,
+  getPool,
   listMemories,
   runMigrations,
   saveMemory,
   searchMemories,
   updateMemory,
   upsertMemory
-} from "./chunk-25Y2KI7M.js";
+} from "./chunk-WUL7HLAA.js";
 import "./chunk-KSLFLWB4.js";
 
 // src/cli.ts
@@ -24,7 +25,6 @@ import ora from "ora";
 import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync6, mkdirSync as mkdirSync2, appendFileSync, rmSync, unlinkSync as unlinkSync2 } from "fs";
 import { join as join6, dirname as dirname2 } from "path";
 import { homedir } from "os";
-import { execSync as execSync2 } from "child_process";
 
 // src/generator.ts
 import { readFileSync as readFileSync2, readdirSync, writeFileSync, mkdirSync, existsSync as existsSync2 } from "fs";
@@ -112,6 +112,17 @@ var FRAMEWORK_ARCHITECTURE_MAP = {
   "Vue.js": ["vue"],
   Svelte: ["svelte"]
 };
+var KNOWN_ARCHITECTURE_KEYS = /* @__PURE__ */ new Set([
+  ...Object.values(FRAMEWORK_ARCHITECTURE_MAP).flat(),
+  "angular",
+  "clean-architecture",
+  "express",
+  "fastify",
+  "hexagonal",
+  "modular-monolith",
+  "mvc",
+  "react-native"
+]);
 function normalizeText(value) {
   return value.toLowerCase().replace(/[`"'()[\]{}.,:;!?/\\<>|=*+-]/g, " ").replace(/\s+/g, " ").trim();
 }
@@ -139,6 +150,33 @@ function mergeMemory(primary, secondary) {
     reason
   };
 }
+function memoryArchitectureKeys(memory) {
+  if (memory.architecture && memory.architecture !== "global") {
+    return [memory.architecture];
+  }
+  return (memory.tags ?? []).filter((tag) => KNOWN_ARCHITECTURE_KEYS.has(tag));
+}
+function getStackReason(memory, activeArchitectures) {
+  const architectureKeys = memoryArchitectureKeys(memory);
+  if (architectureKeys.length === 0) {
+    return {
+      included: true,
+      reason: "global memory: no architecture-specific tag"
+    };
+  }
+  const matched = architectureKeys.filter((architecture) => activeArchitectures.has(architecture));
+  if (matched.length > 0) {
+    return {
+      included: true,
+      reason: `matched active architecture: ${matched.join(", ")}`
+    };
+  }
+  const active = [...activeArchitectures].join(", ") || "none detected";
+  return {
+    included: false,
+    reason: `excluded: tagged for ${architectureKeys.join(", ")}; active stack is ${active}`
+  };
+}
 function dedupeMemories(memories, threshold = 0.8) {
   const deduped = [];
   for (const memory of memories) {
@@ -160,6 +198,9 @@ function inferProjectArchitectures(cwd = process.cwd(), config) {
   const inferred = /* @__PURE__ */ new Set();
   if (config?.backendArchitecture) inferred.add(config.backendArchitecture);
   if (config?.frontendFramework) inferred.add(config.frontendFramework);
+  if (config?.projectType === "backend" && !config.backendArchitecture) {
+    inferred.add("clean-architecture");
+  }
   const detected = detectProject(cwd);
   for (const architecture of FRAMEWORK_ARCHITECTURE_MAP[detected.framework] ?? []) {
     inferred.add(architecture);
@@ -169,13 +210,63 @@ function inferProjectArchitectures(cwd = process.cwd(), config) {
 function getAllowPatterns(config) {
   return [...new Set(config?.allowPatterns?.filter(Boolean) ?? [])];
 }
+function filterRelevantMemories(memories, config, cwd = process.cwd()) {
+  return explainMemorySelection(memories, config, cwd).included;
+}
+function explainMemorySelection(memories, config, cwd = process.cwd(), threshold = 0.8) {
+  const activeArchitectures = inferProjectArchitectures(cwd, config);
+  const activeSet = new Set(activeArchitectures);
+  const included = [];
+  const decisions = [];
+  for (const memory of memories) {
+    const stackDecision = getStackReason(memory, activeSet);
+    if (!stackDecision.included) {
+      decisions.push({
+        memory,
+        status: "excluded",
+        reason: stackDecision.reason
+      });
+      continue;
+    }
+    const existingIndex = included.findIndex((candidate) => {
+      if (candidate.content_hash && memory.content_hash && candidate.content_hash === memory.content_hash) {
+        return true;
+      }
+      return similarityScore(candidate.content, memory.content) >= threshold;
+    });
+    if (existingIndex === -1) {
+      included.push(memory);
+      decisions.push({
+        memory,
+        status: "included",
+        reason: stackDecision.reason
+      });
+      continue;
+    }
+    included[existingIndex] = mergeMemory(included[existingIndex], memory);
+    decisions.push({
+      memory,
+      status: "excluded",
+      reason: `duplicate or near-duplicate of memory #${included[existingIndex].id}`
+    });
+  }
+  return {
+    included,
+    excluded: decisions.filter((decision) => decision.status === "excluded"),
+    decisions,
+    activeArchitectures
+  };
+}
 function buildContextQuery(parts, maxLength = 1200) {
   return parts.filter(Boolean).join("\n").slice(0, maxLength);
 }
 async function retrieveContextualMemories(options) {
+  return (await retrieveMemorySelection(options)).included;
+}
+async function retrieveMemorySelection(options) {
   const architectures = inferProjectArchitectures(options.cwd, options.config);
   const memories = await retrieve(options.query, architectures, options.limit ?? 15);
-  return dedupeMemories(memories);
+  return explainMemorySelection(memories, options.config, options.cwd);
 }
 
 // src/generator.ts
@@ -216,6 +307,23 @@ Handlebars.registerHelper(
   (arr) => Array.isArray(arr) ? arr.map((i, idx) => `${idx + 1}. ${i}`).join("\n") : ""
 );
 Handlebars.registerHelper("json", (val) => JSON.stringify(val, null, 2));
+Handlebars.registerHelper("memoryBlock", (memory) => {
+  const meta = [memory.type, memory.architecture].filter(Boolean).join(" \xB7 ");
+  const label = memory.title ? `${memory.title}: ${memory.content}` : memory.content;
+  const lines = [`- [${meta || "memory"}] ${label}`];
+  if (memory.reason) lines.push(`  Why: ${memory.reason}`);
+  if (memory.context?.appliesTo?.length) lines.push(`  Use when: ${memory.context.appliesTo.join("; ")}`);
+  if (memory.context?.avoidWhen?.length) lines.push(`  Avoid when: ${memory.context.avoidWhen.join("; ")}`);
+  if (memory.context?.examples?.length) {
+    lines.push("  Examples:");
+    for (const example of memory.context.examples) lines.push(`    - ${example}`);
+  }
+  if (memory.tags?.length) lines.push(`  Tags: ${memory.tags.join(", ")}`);
+  if (memory.project_name || memory.context?.source) {
+    lines.push(`  Source: ${memory.context?.source ?? memory.project_name}`);
+  }
+  return new Handlebars.SafeString(lines.join("\n"));
+});
 function loadProfile(name) {
   const profilePath = join2(PKG_ROOT, "profiles", `${name}.yml`);
   if (!existsSync2(profilePath)) throw new Error(`Profile not found: ${name}`);
@@ -229,10 +337,15 @@ function listProfiles(layer) {
   if (layer === "frontend") return all.filter((p) => p.layer === "frontend" || p.layer === "fullstack");
   return all;
 }
-function buildTemplateData(options) {
+function buildTemplateData(options, cwd = process.cwd()) {
   const backend = options.backendArchitecture ? loadProfile(options.backendArchitecture) : null;
   const frontend = options.frontendFramework ? loadProfile(options.frontendFramework) : null;
-  const dedupedMemories = dedupeMemories(options.memories);
+  const dedupedMemories = filterRelevantMemories(options.memories, {
+    projectType: options.projectType,
+    backendArchitecture: options.backendArchitecture,
+    frontendFramework: options.frontendFramework,
+    language: options.language
+  }, cwd);
   const allRules = [
     ...backend?.rules ?? [],
     ...frontend?.rules ?? []
@@ -300,7 +413,7 @@ function writeFile(filePath, content) {
   return "written";
 }
 async function generate(options, cwd = process.cwd(), onlyAgents) {
-  const data = buildTemplateData(options);
+  const data = buildTemplateData(options, cwd);
   const written = [];
   const skipped = [];
   const files = onlyAgents ? OUTPUT_FILES.filter((f) => onlyAgents.includes(f.agent)) : OUTPUT_FILES;
@@ -823,9 +936,28 @@ function toPortableMemory(memory) {
     title: memory.title,
     content: memory.content,
     reason: memory.reason,
+    context: memory.context,
     tags: memory.tags ?? []
   };
 }
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const entries = value.filter((entry) => typeof entry === "string" && entry.trim() !== "");
+  return entries.length ? entries : void 0;
+}
+function parseContext(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const record = value;
+  const context = {};
+  const appliesTo = normalizeStringArray(record.appliesTo);
+  const avoidWhen = normalizeStringArray(record.avoidWhen);
+  const examples = normalizeStringArray(record.examples);
+  if (appliesTo) context.appliesTo = appliesTo;
+  if (avoidWhen) context.avoidWhen = avoidWhen;
+  if (examples) context.examples = examples;
+  if (typeof record.source === "string" && record.source.trim() !== "") context.source = record.source;
+  return Object.keys(context).length ? context : void 0;
+}
 function writeMemoryFile(memories, cwd = process.cwd()) {
   const path = join3(cwd, MEMORY_FILE);
   writeFileSync2(path, JSON.stringify(memories, null, 2) + "\n", "utf-8");
@@ -864,6 +996,7 @@ function parseMemoryFile(raw) {
       title: typeof record.title === "string" ? record.title : void 0,
       content: record.content,
       reason: typeof record.reason === "string" ? record.reason : void 0,
+      context: parseContext(record.context),
       tags: Array.isArray(record.tags) ? record.tags.filter((tag) => typeof tag === "string") : []
     };
   });
@@ -922,7 +1055,7 @@ async function promptToSaveViolations(violations) {
       default: selected.reason ?? selected.issue ?? ""
     });
     const { embed: embed2 } = await import("./embedding-PAYD2JYW.js");
-    const { upsertMemory: upsertMemory2 } = await import("./db-5X5LTUCB.js");
+    const { upsertMemory: upsertMemory2 } = await import("./db-MF3VKVKH.js");
     await upsertMemory2({
       type: "rule",
       scope: "project",
@@ -939,7 +1072,7 @@ async function promptToSaveViolations(violations) {
 }
 async function loadIgnorePatterns() {
   try {
-    const { listMemories: listMemories2, closePool: closePool2 } = await import("./db-5X5LTUCB.js");
+    const { listMemories: listMemories2, closePool: closePool2 } = await import("./db-MF3VKVKH.js");
     const ignores = await listMemories2({ type: "ignore", limit: 1e3 });
     await closePool2();
     return ignores.map((ignore) => ignore.content);
@@ -996,6 +1129,124 @@ ${violation.file}`.toLowerCase();
     return !allowPatterns.some((pattern) => haystack.includes(pattern.toLowerCase()));
   });
 }
+function normalizeViolation(value) {
+  if (!value || typeof value !== "object") return null;
+  const candidate = value;
+  if (typeof candidate.rule !== "string" || typeof candidate.issue !== "string") return null;
+  return {
+    rule: candidate.rule,
+    file: typeof candidate.file === "string" ? candidate.file : "diff",
+    line: typeof candidate.line === "number" ? candidate.line : void 0,
+    issue: candidate.issue,
+    suggestion: typeof candidate.suggestion === "string" ? candidate.suggestion : void 0,
+    reason: typeof candidate.reason === "string" ? candidate.reason : void 0
+  };
+}
+function parseModelViolations(raw) {
+  const candidates = [
+    raw,
+    raw.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "")
+  ];
+  const objectStart = raw.indexOf("{");
+  const objectEnd = raw.lastIndexOf("}");
+  if (objectStart !== -1 && objectEnd > objectStart) {
+    candidates.push(raw.slice(objectStart, objectEnd + 1));
+  }
+  const arrayStart = raw.indexOf("[");
+  const arrayEnd = raw.lastIndexOf("]");
+  if (arrayStart !== -1 && arrayEnd > arrayStart) {
+    candidates.push(raw.slice(arrayStart, arrayEnd + 1));
+  }
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(candidate);
+      const items = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.violations) ? parsed.violations : parsed?.rule ? [parsed] : null;
+      if (!items) continue;
+      return {
+        valid: true,
+        violations: items.map(normalizeViolation).filter((violation) => violation !== null)
+      };
+    } catch {
+    }
+  }
+  return { valid: false, violations: [] };
+}
+function getAddedLines(diff) {
+  const lines = [];
+  let currentFile = "diff";
+  let newLineNumber = 0;
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("+++ b/")) {
+      currentFile = line.slice("+++ b/".length);
+      continue;
+    }
+    const hunk = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+    if (hunk) {
+      newLineNumber = Number(hunk[1]);
+      continue;
+    }
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      lines.push({
+        file: currentFile,
+        line: Number.isFinite(newLineNumber) ? newLineNumber : void 0,
+        content: line.slice(1)
+      });
+      newLineNumber += 1;
+      continue;
+    }
+    if (!line.startsWith("-") && newLineNumber > 0) {
+      newLineNumber += 1;
+    }
+  }
+  return lines;
+}
+function dedupeViolations(violations) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const violation of violations) {
+    const key = [
+      violation.rule,
+      violation.file,
+      violation.line ?? "",
+      violation.issue
+    ].join("\0");
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(violation);
+  }
+  return deduped;
+}
+function findDeterministicViolations(diff, rules, avoids, allowPatterns = []) {
+  const rulePhrases = rules.flatMap(
+    (rule) => extractForbiddenPhrases(rule).map((phrase) => ({ rule, phrase }))
+  );
+  const avoidPhrases = avoids.map((avoid) => ({
+    rule: `Avoid: ${avoid}`,
+    phrase: avoid.toLowerCase()
+  }));
+  const phrases = [...rulePhrases, ...avoidPhrases].filter((item) => item.phrase.length > 0);
+  if (phrases.length === 0) return [];
+  const violations = [];
+  for (const addedLine of getAddedLines(diff)) {
+    const normalizedLine = addedLine.content.toLowerCase();
+    if (allowPatterns.some((pattern) => normalizedLine.includes(pattern.toLowerCase()))) {
+      continue;
+    }
+    for (const { rule, phrase } of phrases) {
+      if (normalizedLine.includes(phrase)) {
+        violations.push({
+          rule,
+          file: addedLine.file,
+          line: addedLine.line,
+          issue: `Added line contains forbidden phrase: "${phrase}"`,
+          suggestion: "Remove this pattern or add an explicit ignore memory if it is intentional.",
+          reason: reasonMap.get(rule)
+        });
+      }
+    }
+  }
+  return dedupeViolations(violations);
+}
 async function verifyViolations(diff, violations, allowPatterns, debug) {
   if (violations.length === 0) return violations;
   const systemPrompt = `You are verifying candidate architecture violations.
@@ -1023,9 +1274,8 @@ ${JSON.stringify(violations, null, 2)}`;
       { role: "system", content: systemPrompt },
       { role: "user", content: userPrompt }
     ]);
-    const parsed = JSON.parse(raw);
-    if (Array.isArray(parsed?.violations)) return parsed.violations;
-    if (Array.isArray(parsed)) return parsed;
+    const parsed = parseModelViolations(raw);
+    if (parsed.valid) return parsed.violations;
     return violations;
   } catch {
     return violations;
@@ -1142,7 +1392,8 @@ Do not include any text outside the JSON object.`;
     console.log(chalk.dim(diffToSend));
     console.log(chalk.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   }
-  let violations = [];
+  const deterministicViolations = findDeterministicViolations(diff, rules, avoids, allowPatterns);
+  let modelViolations = [];
   try {
     const raw = await callChatModel([
       { role: "system", content: systemPrompt },
@@ -1153,36 +1404,29 @@ ${diffToSend}` }
     if (options.verbose || options.debug) {
       console.log(chalk.gray(`  raw response: ${options.debug ? raw : raw.slice(0, 200)}`));
     }
-    try {
-      const parsed = JSON.parse(raw);
-      if (Array.isArray(parsed)) {
-        violations = parsed;
-      } else if (Array.isArray(parsed?.violations)) {
-        violations = parsed.violations;
-      } else if (parsed?.rule) {
-        violations = [parsed];
-      } else {
-        violations = [];
-      }
-    } catch {
-      violations = [];
+    const parsed = parseModelViolations(raw);
+    if (parsed.valid) {
+      modelViolations = parsed.violations;
+    } else {
+      console.log(chalk.yellow("  \u26A0  AI returned invalid JSON \u2014 using deterministic checks only."));
     }
   } catch (err) {
     if (err.message?.startsWith("MODEL_NOT_FOUND:")) {
       printModelMissing(err.message.split(":")[1]);
-      return;
-    }
-    if (err.cause?.code === "ECONNREFUSED" || err.message?.includes("ECONNREFUSED")) {
-      console.log(chalk.yellow("\n  \u26A0  Ollama not running \u2014 skipping rule check."));
+      modelViolations = [];
+    } else if (err.cause?.code === "ECONNREFUSED" || err.message?.includes("ECONNREFUSED")) {
+      console.log(chalk.yellow("\n  \u26A0  Ollama not running \u2014 using deterministic checks only."));
       console.log(chalk.gray("     Start it: ollama serve\n"));
-      return;
+      modelViolations = [];
+    } else {
+      console.log(chalk.yellow(`
+  \u26A0  AI rule check failed: ${err.message}`));
+      console.log(chalk.gray("     Using deterministic checks only.\n"));
+      modelViolations = [];
     }
-    console.log(chalk.yellow(`
-  \u26A0  Rule check failed: ${err.message}
-`));
-    return;
   }
-  violations = await verifyViolations(diff, violations, allowPatterns, options.debug ?? false);
+  modelViolations = await verifyViolations(diff, modelViolations, allowPatterns, options.debug ?? false);
+  let violations = dedupeViolations([...deterministicViolations, ...modelViolations]);
   violations = applyAllowPatterns(violations, allowPatterns);
   if (violations.length === 0) {
     console.log(chalk.green("  \u2713 No rule violations \u2014 commit allowed.\n"));
@@ -1454,7 +1698,7 @@ ${JSON.stringify(violations, null, 2)}`;
 }
 async function loadIgnorePatterns2() {
   try {
-    const { listMemories: listMemories2, closePool: closePool2 } = await import("./db-5X5LTUCB.js");
+    const { listMemories: listMemories2, closePool: closePool2 } = await import("./db-MF3VKVKH.js");
     const ignores = await listMemories2({ type: "ignore", limit: 1e3 });
     await closePool2();
     return ignores.map((ignore) => ignore.content);
@@ -1633,6 +1877,55 @@ async function startWatch(options = {}) {
   });
 }
 
+// src/remote-install.ts
+import { spawnSync as spawnSync3 } from "child_process";
+var CAVEMAN_INSTALL_URL = "https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.sh";
+var MAX_INSTALLER_BYTES = 2e5;
+var TRUSTED_INSTALL_HOSTS = /* @__PURE__ */ new Set(["raw.githubusercontent.com"]);
+function assertTrustedInstallerUrl(url) {
+  const parsed = new URL(url);
+  if (parsed.protocol !== "https:") {
+    throw new Error("Remote installer URL must use HTTPS");
+  }
+  if (!TRUSTED_INSTALL_HOSTS.has(parsed.hostname)) {
+    throw new Error(`Remote installer host is not trusted: ${parsed.hostname}`);
+  }
+}
+function defaultRunScript(script) {
+  return spawnSync3("bash", ["-s"], {
+    input: script,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+}
+async function fetchRemoteInstaller(url, fetchImpl = fetch) {
+  assertTrustedInstallerUrl(url);
+  const response = await fetchImpl(url, {
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to download installer (${response.status})`);
+  }
+  const script = await response.text();
+  if (script.length > MAX_INSTALLER_BYTES) {
+    throw new Error(`Installer is too large (${script.length} bytes)`);
+  }
+  if (script.includes("\0")) {
+    throw new Error("Installer contains null bytes");
+  }
+  return script;
+}
+async function installCavemanTokenSaver(options = {}) {
+  const url = options.url ?? CAVEMAN_INSTALL_URL;
+  const script = await fetchRemoteInstaller(url, options.fetchImpl ?? fetch);
+  const result = (options.runScript ?? defaultRunScript)(script);
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    const stderr = result.stderr ? String(result.stderr).trim() : "";
+    throw new Error(stderr || `Installer exited with status ${result.status}`);
+  }
+}
+
 // src/cli.ts
 function printBanner(projectName, agentCount, status) {
   const pg = status ? status.postgresOk ? chalk3.green("  \u2713 PostgreSQL ") + chalk3.bold("connected") : chalk3.red("  \u2717 PostgreSQL ") + chalk3.bold("not connected \u2014 check DATABASE_URL") : chalk3.green("  \u2713 Memory    ") + chalk3.bold("PostgreSQL + pgvector ready");
@@ -1697,6 +1990,7 @@ async function checkConnections(dbUrl, ollamaUrl, chatModel) {
 }
 var { version } = JSON.parse(readFileSync6(new URL("../package.json", import.meta.url), "utf-8"));
 var CONFIG_FILE = ".memory-core.json";
+var LOCAL_GENERATED_FILES = [".memory-core-stats.json"];
 var DEFAULT_OLLAMA_URL = "http://localhost:11434";
 var DEFAULT_EMBEDDING_MODEL = "nomic-embed-text";
 var DEFAULT_CHAT_MODEL = "llama3.2";
@@ -1772,6 +2066,22 @@ function ensureEnvFileIgnored(envPath = getEnvPath()) {
 `);
   }
 }
+function appendMissingGitignoreEntries(entries, heading) {
+  const gitignorePath = join6(process.cwd(), ".gitignore");
+  const existing = existsSync6(gitignorePath) ? readFileSync6(gitignorePath, "utf-8") : "";
+  const existingEntries = new Set(
+    existing.split(/\r?\n/).map((line) => line.trim()).filter(Boolean)
+  );
+  const toAdd = entries.filter((entry) => !existingEntries.has(entry));
+  if (toAdd.length === 0) {
+    return 0;
+  }
+  const prefix = existing.trim().length > 0 ? "\n" : "";
+  appendFileSync(gitignorePath, `${prefix}${heading}
+${toAdd.join("\n")}
+`);
+  return toAdd.length;
+}
 function normalizeProvider(value) {
   const provider2 = value.trim().toLowerCase();
   if (provider2 === "ollama" || provider2 === "openai" || provider2 === "anthropic" || provider2 === "minimax") {
@@ -1858,6 +2168,21 @@ function updateProjectConfig(mutator) {
 function parseTags(tags) {
   return tags ? tags.split(",").map((t) => t.trim()).filter(Boolean) : [];
 }
+function parseList(value) {
+  const entries = value?.split(",").map((entry) => entry.trim()).filter(Boolean) ?? [];
+  return entries.length ? entries : void 0;
+}
+function buildMemoryContext(opts) {
+  const context = {};
+  const appliesTo = parseList(opts.appliesTo);
+  const avoidWhen = parseList(opts.avoidWhen);
+  const examples = parseList(opts.example);
+  if (appliesTo) context.appliesTo = appliesTo;
+  if (avoidWhen) context.avoidWhen = avoidWhen;
+  if (examples) context.examples = examples;
+  if (opts.source?.trim()) context.source = opts.source.trim();
+  return Object.keys(context).length ? context : void 0;
+}
 function truncate(value, length) {
   if (!value) return "";
   return value.length > length ? `${value.slice(0, Math.max(0, length - 1))}\u2026` : value;
@@ -1877,6 +2202,9 @@ function printMemoryTable(memories, title = "Rules in memory") {
   });
   console.log(chalk3.gray("\n  Use: memory-core remove <id>  |  memory-core edit <id>\n"));
 }
+function getCurrentListArchitectures(config) {
+  return inferProjectArchitectures(process.cwd(), config).filter((architecture) => architecture !== "global");
+}
 function printStatusLine(label, value) {
   console.log(`  ${chalk3.dim(label.padEnd(18))} ${value}`);
 }
@@ -1974,6 +2302,7 @@ async function printProjectStatus() {
   printStatusLine("Architectures", architectures.length ? architectures.join(", ") : chalk3.gray("none detected"));
   printStatusLine("Agents", config?.agents?.length ? `${config.agents.length} selected` : chalk3.gray("none saved"));
   printStatusLine("Caveman", config?.caveman?.enabled ? `enabled (${config.caveman.intensity})` : "disabled");
+  printStatusLine("Auto sync", config?.autoSync === false ? "disabled" : "enabled");
   printStatusLine("Allow patterns", String(getAllowPatterns(config).length));
   printStatusLine("Env file", `${existsSync6(envPath) ? "present" : "missing"} (${envPath.split("/").pop()})`);
   printStatusLine("Memory file", existsSync6(memoryFilePath) ? MEMORY_FILE : chalk3.gray("not exported"));
@@ -2001,6 +2330,94 @@ async function printProjectStatus() {
   }
   console.log();
 }
+function printMemorySelection(selection, limit = 4) {
+  const active = selection.activeArchitectures.join(", ") || "none detected";
+  console.log(chalk3.gray(`    Stack filter: ${active}`));
+  const included = selection.decisions.filter((decision) => decision.status === "included");
+  if (included.length > 0) {
+    console.log(chalk3.gray(`    Included ${included.length}:`));
+    for (const decision of included.slice(0, limit)) {
+      console.log(chalk3.gray(`      + ${decision.memory.content} (${decision.reason})`));
+    }
+    if (included.length > limit) {
+      console.log(chalk3.gray(`      \u2026 ${included.length - limit} more included`));
+    }
+  }
+  if (selection.excluded.length > 0) {
+    console.log(chalk3.gray(`    Excluded ${selection.excluded.length}:`));
+    for (const decision of selection.excluded.slice(0, limit)) {
+      console.log(chalk3.gray(`      - ${decision.memory.content} (${decision.reason})`));
+    }
+    if (selection.excluded.length > limit) {
+      console.log(chalk3.gray(`      \u2026 ${selection.excluded.length - limit} more excluded`));
+    }
+  }
+}
+function getConfiguredAgents(config) {
+  const agents = config.agents?.length ? config.agents : AGENT_NAMES.filter((agent) => agent !== "Shared");
+  return [.../* @__PURE__ */ new Set([...agents, "Shared"])];
+}
+async function syncGeneratedFiles(config, agents, options = {}) {
+  const memorySpinner = ora(options.label ?? "Syncing memories\u2026").start();
+  let memories = [];
+  try {
+    const archQuery = [config.backendArchitecture, config.frontendFramework, config.language].filter(Boolean).join(" ");
+    const selection = await retrieveMemorySelection({
+      query: archQuery,
+      cwd: process.cwd(),
+      config,
+      limit: 25
+    });
+    memories = selection.included;
+    memorySpinner.succeed(`Found ${memories.length} memories`);
+    if (options.showSelection) {
+      printMemorySelection(selection);
+    }
+  } catch (err) {
+    memorySpinner.warn(`Could not retrieve memories: ${err.message}`);
+  }
+  const spinner = ora("Regenerating agent files\u2026").start();
+  const result = await generate(
+    {
+      projectName: config.projectName,
+      projectType: config.projectType,
+      backendArchitecture: config.backendArchitecture,
+      frontendFramework: config.frontendFramework,
+      language: config.language,
+      memories,
+      caveman: config.caveman
+    },
+    process.cwd(),
+    agents
+  );
+  spinner.succeed(
+    `Synced \u2014 ${chalk3.green(`${result.written.length} updated`)}, ${chalk3.dim(`${result.skipped.length} already up to date`)}`
+  );
+  if (result.written.length > 0) {
+    result.written.forEach((file) => console.log(chalk3.gray(`    \u2713 ${file}`)));
+  }
+}
+async function autoSyncGeneratedFiles(config, action, enabled = true) {
+  if (!enabled) {
+    console.log(chalk3.gray("  Auto-sync skipped (--no-sync). Run memory-core sync when ready."));
+    return;
+  }
+  if (!config) {
+    return;
+  }
+  if (config.autoSync === false) {
+    console.log(chalk3.gray("  Auto-sync disabled for this project. Run memory-core sync when ready."));
+    return;
+  }
+  try {
+    await syncGeneratedFiles(config, getConfiguredAgents(config), {
+      label: `Auto-syncing agent files after ${action}\u2026`
+    });
+  } catch (err) {
+    console.log(chalk3.yellow(`  Auto-sync skipped: ${err.message}`));
+    console.log(chalk3.gray("  Run memory-core sync manually when ready."));
+  }
+}
 var program = new Command();
 program.name("memory-core").description("Universal AI memory core \u2014 generate AI context files for all coding agents").version(version);
 program.command("init").description("Initialize memory-core in the current project").option("--quick", "Use smart defaults and skip optional prompts").action(async (opts) => {
@@ -2212,11 +2629,20 @@ program.command("init").description("Initialize memory-core in the current proje
     message: "Pull relevant memories from previous projects?",
     default: true
   });
-  const installCaveman = quick ? false : await confirm({
-    message: "Install caveman token saver? (~65-75% fewer tokens)",
+  let installCaveman = quick ? false : await confirm({
+    message: "Install caveman token saver? Downloads and runs the upstream installer.",
     default: false
   });
   let cavemanIntensity = "full";
+  if (installCaveman) {
+    const allowRemoteInstaller = await confirm({
+      message: `Security check: download and execute installer from ${CAVEMAN_INSTALL_URL}?`,
+      default: false
+    });
+    if (!allowRemoteInstaller) {
+      installCaveman = false;
+    }
+  }
   if (installCaveman) {
     cavemanIntensity = await select({
       message: "Caveman intensity?",
@@ -2258,20 +2684,23 @@ program.command("init").description("Initialize memory-core in the current proje
     language,
     caveman: { enabled: installCaveman, intensity: cavemanIntensity },
     agents: selectedAgents,
-    allowPatterns: []
+    allowPatterns: [],
+    autoSync: true
   };
   let memories = [];
   if (pullMemories) {
     const spinner2 = ora("Retrieving relevant memories\u2026").start();
     try {
       const archQuery = [backendArchitecture, frontendFramework, language].filter(Boolean).join(" ");
-      memories = await retrieveContextualMemories({
+      const selection = await retrieveMemorySelection({
         query: archQuery,
         cwd: process.cwd(),
         config,
         limit: 20
       });
+      memories = selection.included;
       spinner2.succeed(`Found ${memories.length} relevant memories`);
+      printMemorySelection(selection);
     } catch (err) {
       spinner2.warn(`Could not retrieve memories: ${err.message}`);
     }
@@ -2279,10 +2708,7 @@ program.command("init").description("Initialize memory-core in the current proje
   if (installCaveman) {
     const spinner2 = ora("Installing caveman token saver\u2026").start();
     try {
-      execSync2(
-        "curl -fsSL https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.sh | bash",
-        { stdio: "pipe", cwd: process.cwd() }
-      );
+      await installCavemanTokenSaver();
       spinner2.succeed("Caveman installed");
     } catch (err) {
       spinner2.warn(`Caveman install failed: ${err.message}`);
@@ -2296,15 +2722,11 @@ program.command("init").description("Initialize memory-core in the current proje
   );
   writeProjectConfig(config);
   spinner.succeed(`Generated ${written.written.length} files`);
-  const gitignorePath = join6(process.cwd(), ".gitignore");
-  const generatedPaths = written.written;
-  if (generatedPaths.length > 0) {
-    const existing = existsSync6(gitignorePath) ? readFileSync6(gitignorePath, "utf-8") : "";
-    const toAdd = generatedPaths.filter((p) => !existing.includes(p));
-    if (toAdd.length > 0) {
-      const block = "\n# memory-core generated files\n" + toAdd.join("\n") + "\n";
-      appendFileSync(gitignorePath, block);
-      console.log(chalk3.green(`  \u2713 Added ${toAdd.length} generated files to .gitignore`));
+  const gitignoreEntries = [...written.written, ...LOCAL_GENERATED_FILES];
+  if (gitignoreEntries.length > 0) {
+    const added = appendMissingGitignoreEntries(gitignoreEntries, "# memory-core generated files");
+    if (added > 0) {
+      console.log(chalk3.green(`  \u2713 Added ${added} generated files to .gitignore`));
     }
   }
   if (enableHook) {
@@ -2339,44 +2761,32 @@ program.command("sync").description("Re-pull memories and regenerate AI agent fi
     console.log(chalk3.yellow("  No agents selected \u2014 nothing to sync."));
     process.exit(0);
   }
-  const spinner = ora("Syncing memories\u2026").start();
-  let memories = [];
-  try {
-    const archQuery = [config.backendArchitecture, config.frontendFramework, config.language].filter(Boolean).join(" ");
-    memories = await retrieveContextualMemories({
-      query: archQuery,
-      cwd: process.cwd(),
-      config,
-      limit: 25
-    });
-    spinner.text = `Found ${memories.length} memories \u2014 regenerating files\u2026`;
-  } catch (err) {
-    spinner.warn(`Could not retrieve memories: ${err.message}`);
+  await syncGeneratedFiles(config, [...selectedAgents, "Shared"], { showSelection: true });
+  await closePool();
+});
+program.command("auto-sync [mode]").description("Show or change automatic agent file sync (on|off)").action((mode) => {
+  const config = readProjectConfig();
+  if (!config) {
+    console.error(chalk3.red("No .memory-core.json found. Run: memory-core init"));
+    process.exit(1);
   }
-  const result = await generate(
-    {
-      projectName: config.projectName,
-      projectType: config.projectType,
-      backendArchitecture: config.backendArchitecture,
-      frontendFramework: config.frontendFramework,
-      language: config.language,
-      memories,
-      caveman: config.caveman
-    },
-    process.cwd(),
-    [...selectedAgents, "Shared"]
-  );
-  const updatedCount = result.written.length;
-  const skippedCount = result.skipped.length;
-  spinner.succeed(
-    `Synced \u2014 ${chalk3.green(`${updatedCount} updated`)}, ${chalk3.dim(`${skippedCount} already up to date`)}`
-  );
-  if (result.written.length > 0) {
-    result.written.forEach((f) => console.log(chalk3.gray(`    \u2713 ${f}`)));
+  const normalized = mode?.trim().toLowerCase();
+  if (!normalized || normalized === "status") {
+    console.log(chalk3.bold("\n  Auto-sync\n"));
+    console.log(`  Status: ${config.autoSync === false ? chalk3.yellow("disabled") : chalk3.green("enabled")}`);
+    console.log(chalk3.gray("  Manual sync is always available: memory-core sync\n"));
+    return;
   }
-  await closePool();
+  if (normalized !== "on" && normalized !== "off") {
+    console.error(chalk3.red("Use: memory-core auto-sync [on|off|status]"));
+    process.exit(1);
+  }
+  const enabled = normalized === "on";
+  writeProjectConfig({ ...config, autoSync: enabled });
+  console.log(chalk3.green(`Auto-sync ${enabled ? "enabled" : "disabled"}`));
+  console.log(chalk3.gray("  Manual sync is always available: memory-core sync"));
 });
-program.command("remember <text>").description("Save a new memory to the central database").option("-t, --type <type>", "Memory type (decision|rule|pattern|note)", "decision").option("-s, --scope <scope>", "Scope (global|project)", "project").option("--tags <tags>", "Comma-separated tags").option("-r, --reason <reason>", "Why this rule exists \u2014 helps agents understand intent and debug violations").action(async (text, opts) => {
+program.command("remember <text>").description("Save a new memory to the central database").option("-t, --type <type>", "Memory type (decision|rule|pattern|note)", "decision").option("-s, --scope <scope>", "Scope (global|project)", "project").option("--tags <tags>", "Comma-separated tags").option("-r, --reason <reason>", "Why this rule exists \u2014 helps agents understand intent and debug violations").option("--applies-to <items>", "Comma-separated situations where this memory applies").option("--avoid-when <items>", "Comma-separated situations where this memory should not be used").option("--example <items>", "Comma-separated examples that teach agents how to apply this memory").option("--source <source>", "Human-readable source for this memory").option("--no-sync", "Skip automatic agent file sync after saving").action(async (text, opts) => {
   const config = readProjectConfig();
   let reason = opts.reason;
   if (!reason) {
@@ -2395,12 +2805,14 @@ program.command("remember <text>").description("Save a new memory to the central
       projectName: config?.projectName,
       content: text,
       reason: reason || void 0,
-      tags: opts.tags ? opts.tags.split(",").map((t) => t.trim()) : [],
+      context: buildMemoryContext(opts),
+      tags: parseTags(opts.tags),
       embedding
     });
     const reasonLine = reason ? chalk3.gray(`
   Why: ${reason}`) : "";
     spinner.succeed(chalk3.green(`Memory saved: "${text}"`) + reasonLine);
+    await autoSyncGeneratedFiles(config, "remember", opts.sync);
   } catch (err) {
     spinner.fail(`Failed: ${err.message}`);
     process.exit(1);
@@ -2428,6 +2840,10 @@ program.command("search <query>").description("Search memories using semantic si
         const sim = m.similarity ? chalk3.gray(` (${(m.similarity * 100).toFixed(0)}% match)`) : "";
         console.log(chalk3.cyan(`  ${i + 1}. [${m.type}] ${m.title ?? ""}`));
         console.log(chalk3.white(`     ${m.content}`) + sim);
+        if (m.reason) console.log(chalk3.gray(`     why: ${m.reason}`));
+        if (m.context?.appliesTo?.length) console.log(chalk3.gray(`     use when: ${m.context.appliesTo.join("; ")}`));
+        if (m.context?.avoidWhen?.length) console.log(chalk3.gray(`     avoid when: ${m.context.avoidWhen.join("; ")}`));
+        if (m.context?.examples?.length) console.log(chalk3.gray(`     examples: ${m.context.examples.join("; ")}`));
         if (m.tags?.length) console.log(chalk3.gray(`     tags: ${m.tags.join(", ")}`));
         console.log();
       });
@@ -2455,9 +2871,10 @@ program.command("export").description(`Export DB memories to ${MEMORY_FILE}`).op
     await closePool();
   }
 });
-program.command("import").description(`Import memories from ${MEMORY_FILE}`).option("--url <url>", "Import memories from a remote URL").option("-f, --file <file>", `Import file (default: ${MEMORY_FILE})`).action(async (opts) => {
+program.command("import").description(`Import memories from ${MEMORY_FILE}`).option("--url <url>", "Import memories from a remote URL").option("-f, --file <file>", `Import file (default: ${MEMORY_FILE})`).option("--no-sync", "Skip automatic agent file sync after import").action(async (opts) => {
   const spinner = ora("Reading memories\u2026").start();
   try {
+    const config = readProjectConfig();
     const memories = opts.url ? await readMemoryFileFromUrl(opts.url) : opts.file ? parseMemoryFile(readFileSync6(join6(process.cwd(), opts.file), "utf-8")) : readMemoryFile();
     let inserted = 0;
     let skipped = 0;
@@ -2472,6 +2889,7 @@ program.command("import").description(`Import memories from ${MEMORY_FILE}`).opt
         title: memory.title,
         content: memory.content,
         reason: memory.reason,
+        context: memory.context,
         tags: memory.tags,
         embedding
       });
@@ -2479,6 +2897,9 @@ program.command("import").description(`Import memories from ${MEMORY_FILE}`).opt
       else skipped++;
     }
     spinner.succeed(`Imported ${inserted} memories, skipped ${skipped} duplicates`);
+    if (inserted > 0) {
+      await autoSyncGeneratedFiles(config, "import", opts.sync);
+    }
   } catch (err) {
     spinner.fail(`Import failed: ${err.message}`);
     process.exit(1);
@@ -2486,15 +2907,24 @@ program.command("import").description(`Import memories from ${MEMORY_FILE}`).opt
     await closePool();
   }
 });
-program.command("list").description("List memories from the local database").option("--type <type>", "Filter by type").option("--scope <scope>", "Filter by scope").option("--arch <architecture>", "Filter by architecture").option("-n, --limit <n>", "Maximum rows to show", "200").action(async (opts) => {
+program.command("list").description("List memories from the local database").option("--type <type>", "Filter by type").option("--scope <scope>", "Filter by scope").option("--arch <architecture>", "Filter by architecture").option("--project <name>", "Filter by project name").option("--current", "Only show memories relevant to the current project (default)").option("--all", "Show all memories in the database").option("-n, --limit <n>", "Maximum rows to show", "200").action(async (opts) => {
   try {
+    const config = readProjectConfig();
+    const architectures = opts.arch ? opts.arch : opts.all ? void 0 : getCurrentListArchitectures(config);
+    const projectName = opts.project ? opts.project : opts.all || opts.arch ? void 0 : config?.projectName;
     const memories = await listMemories({
       type: opts.type,
       scope: opts.scope,
-      architecture: opts.arch,
+      architecture: architectures,
+      projectName,
+      includeGlobal: !opts.all,
       limit: parseInt(opts.limit, 10)
     });
-    printMemoryTable(memories);
+    const title = opts.all ? "All memories" : `Current project memories${architectures ? ` (${Array.isArray(architectures) ? architectures.join(", ") : architectures})` : ""}`;
+    printMemoryTable(memories, title);
+    if (!opts.all) {
+      console.log(chalk3.gray("  Showing current project context plus shared/global memories. Use --all for the full database.\n"));
+    }
   } catch (err) {
     console.error(chalk3.red(`List failed: ${err.message}`));
     process.exit(1);
@@ -2502,14 +2932,16 @@ program.command("list").description("List memories from the local database").opt
     await closePool();
   }
 });
-program.command("remove <id>").description("Remove a memory by ID").action(async (id) => {
+program.command("remove <id>").description("Remove a memory by ID").option("--no-sync", "Skip automatic agent file sync after removal").action(async (id, opts) => {
   try {
+    const config = readProjectConfig();
     const deleted = await deleteMemory(parseInt(id, 10));
     if (!deleted) {
       console.log(chalk3.yellow(`No memory found with ID ${id}`));
       process.exit(1);
     }
     console.log(chalk3.green(`Removed memory ${id}`));
+    await autoSyncGeneratedFiles(config, "remove", opts.sync);
   } catch (err) {
     console.error(chalk3.red(`Remove failed: ${err.message}`));
     process.exit(1);
@@ -2517,8 +2949,9 @@ program.command("remove <id>").description("Remove a memory by ID").action(async
     await closePool();
   }
 });
-program.command("forget").description("Bulk-delete memories by tag, scope, type, or architecture").option("--tag <tag>", "Delete memories with this tag").option("--scope <scope>", "Filter by scope").option("--type <type>", "Filter by type").option("--arch <architecture>", "Filter by architecture").action(async (opts) => {
+program.command("forget").description("Bulk-delete memories by tag, scope, type, or architecture").option("--tag <tag>", "Delete memories with this tag").option("--scope <scope>", "Filter by scope").option("--type <type>", "Filter by type").option("--arch <architecture>", "Filter by architecture").option("--no-sync", "Skip automatic agent file sync after deletion").action(async (opts) => {
   try {
+    const config = readProjectConfig();
     const deleted = await deleteMemories({
       tag: opts.tag,
       scope: opts.scope,
@@ -2526,6 +2959,9 @@ program.command("forget").description("Bulk-delete memories by tag, scope, type,
       architecture: opts.arch
     });
     console.log(chalk3.green(`Deleted ${deleted} memories`));
+    if (deleted > 0) {
+      await autoSyncGeneratedFiles(config, "forget", opts.sync);
+    }
   } catch (err) {
     console.error(chalk3.red(`Forget failed: ${err.message}`));
     process.exit(1);
@@ -2533,9 +2969,10 @@ program.command("forget").description("Bulk-delete memories by tag, scope, type,
     await closePool();
   }
 });
-program.command("edit <id>").description("Edit a memory interactively").action(async (id) => {
+program.command("edit <id>").description("Edit a memory interactively").option("--no-sync", "Skip automatic agent file sync after editing").action(async (id, opts) => {
   const memoryId = parseInt(id, 10);
   try {
+    const config = readProjectConfig();
     const existing = await getMemory(memoryId);
     if (!existing) {
       console.log(chalk3.yellow(`No memory found with ID ${id}`));
@@ -2546,6 +2983,10 @@ program.command("edit <id>").description("Edit a memory interactively").action(a
     const title = await input({ message: "Title?", default: existing.title ?? "" });
     const content = await input({ message: "Content?", default: existing.content });
     const reason = await input({ message: "Reason?", default: existing.reason ?? "" });
+    const appliesTo = await input({ message: "Applies to? (comma-separated)", default: existing.context?.appliesTo?.join(",") ?? "" });
+    const avoidWhen = await input({ message: "Avoid when? (comma-separated)", default: existing.context?.avoidWhen?.join(",") ?? "" });
+    const examples = await input({ message: "Examples? (comma-separated)", default: existing.context?.examples?.join(",") ?? "" });
+    const source = await input({ message: "Source?", default: existing.context?.source ?? "" });
     const tags = await input({ message: "Tags?", default: existing.tags.join(",") });
     const embedding = content === existing.content ? void 0 : await embed(content);
     await updateMemory(memoryId, {
@@ -2554,10 +2995,12 @@ program.command("edit <id>").description("Edit a memory interactively").action(a
       title: title || void 0,
       content,
       reason: reason || void 0,
+      context: buildMemoryContext({ appliesTo, avoidWhen, example: examples, source }),
       tags: parseTags(tags),
       embedding
     });
     console.log(chalk3.green(`Updated memory ${id}`));
+    await autoSyncGeneratedFiles(config, "edit", opts.sync);
   } catch (err) {
     console.error(chalk3.red(`Edit failed: ${err.message}`));
     process.exit(1);
@@ -2565,8 +3008,9 @@ program.command("edit <id>").description("Edit a memory interactively").action(a
     await closePool();
   }
 });
-program.command("ignore [pattern]").description("Manage project-scoped false-positive ignore patterns").option("--list", "List ignored patterns").option("--remove <id>", "Remove an ignored pattern by ID").action(async (pattern, opts) => {
+program.command("ignore [pattern]").description("Manage project-scoped false-positive ignore patterns").option("--list", "List ignored patterns").option("--remove <id>", "Remove an ignored pattern by ID").option("--no-sync", "Skip automatic agent file sync after changing ignore patterns").action(async (pattern, opts) => {
   try {
+    const config = readProjectConfig();
     if (opts.list) {
       printMemoryTable(await listMemories({ type: "ignore", limit: 1e3 }), "Ignored patterns");
       return;
@@ -2578,13 +3022,13 @@ program.command("ignore [pattern]").description("Manage project-scoped false-pos
         process.exit(1);
       }
       console.log(chalk3.green(`Removed ignore pattern ${opts.remove}`));
+      await autoSyncGeneratedFiles(config, "ignore remove", opts.sync);
       return;
     }
     if (!pattern) {
       console.error(chalk3.red("Provide a pattern, --list, or --remove <id>"));
       process.exit(1);
     }
-    const config = readProjectConfig();
     const embedding = await embed(pattern);
     await upsertMemory({
       type: "ignore",
@@ -2596,6 +3040,7 @@ program.command("ignore [pattern]").description("Manage project-scoped false-pos
       embedding
     });
     console.log(chalk3.green(`Ignored pattern saved: "${pattern}"`));
+    await autoSyncGeneratedFiles(config, "ignore", opts.sync);
   } catch (err) {
     console.error(chalk3.red(`Ignore failed: ${err.message}`));
     process.exit(1);
@@ -2673,7 +3118,6 @@ program.command("reset").description("Remove memory-core generated files and loc
       default: false
     });
     if (ok) {
-      const { getPool } = await import("./db-5X5LTUCB.js");
       await getPool().query("DROP TABLE IF EXISTS memories");
       await closePool();
       console.log(chalk3.yellow("Dropped memories table"));