@aman_asmuei/aman-agent 0.41.0 → 0.42.0

package/dist/index.js

@@ -1939,6 +1939,19 @@ var DEFAULT_HOOKS = {
   featureHints: true,
   personalityAdapt: true
 };
+var DEFAULT_MIRROR = {
+  enabled: true,
+  dir: "",
+  // populated in loadConfig via homeDir() — empty string is a sentinel
+  tiers: ["core", "working", "archival"],
+  autoSyncOnStartup: true
+};
+function expandHome(p5) {
+  if (p5.startsWith("~/") || p5 === "~") {
+    return path.join(os.homedir(), p5.slice(1));
+  }
+  return p5;
+}
 function homeDir() {
   return process.env.AMAN_HOME || process.env.AMAN_AGENT_HOME || path.join(os.homedir(), ".aman-agent");
 }
@@ -1969,6 +1982,12 @@ function loadConfig() {
   try {
     const raw = JSON.parse(fs.readFileSync(p5, "utf-8"));
     raw.hooks = { ...DEFAULT_HOOKS, ...raw.hooks };
+    raw.mirror = {
+      ...DEFAULT_MIRROR,
+      dir: path.join(homeDir(), "memories"),
+      ...raw.mirror ?? {}
+    };
+    raw.mirror.dir = expandHome(raw.mirror.dir);
     return raw;
   } catch {
     return null;
@@ -3386,12 +3405,15 @@ import {
   syncFromClaude,
   exportForTeam,
   importFromTeam,
-  syncToCopilot
+  syncToCopilot,
+  MirrorEngine,
+  parseFrontmatter
 } from "@aman_asmuei/amem-core";
 import path7 from "path";
 import os6 from "os";
 import fs7 from "fs";
 var db = null;
+var mirrorEngine = null;
 var currentProject = "global";
 async function initMemory(project) {
   if (db) return db;
@@ -3420,6 +3442,23 @@ async function initMemory(project) {
     }
   }
   currentProject = project ?? "global";
+  try {
+    const agentCfg = loadConfig();
+    const mirrorCfg = agentCfg?.mirror;
+    const enabled = mirrorCfg?.enabled ?? true;
+    if (enabled) {
+      const dir = expandHome(mirrorCfg?.dir ?? path7.join(homeDir(), "memories"));
+      const tiers = mirrorCfg?.tiers ?? ["core", "working", "archival"];
+      mirrorEngine = new MirrorEngine(db, {
+        dir,
+        tiers,
+        includeIndex: true
+      });
+    }
+  } catch (err) {
+    console.warn(`[amem-mirror] construction failed: ${err instanceof Error ? err.message : String(err)}`);
+    mirrorEngine = null;
+  }
   preloadEmbeddings();
   setTimeout(() => {
     try {
@@ -3449,7 +3488,12 @@ async function memoryContext(topic, maxTokens) {
   return buildContext(getDb(), topic, { maxTokens, scope: currentProject });
 }
 async function memoryStore(opts) {
-  return storeMemory(getDb(), opts);
+  const result = await storeMemory(getDb(), opts);
+  if (result.action !== "private" && mirrorEngine) {
+    const saved = getDb().getById(result.id);
+    if (saved) void mirrorEngine.onSave(saved);
+  }
+  return result;
 }
 function memoryLog(sessionId, role, content) {
   return getDb().appendLog({
@@ -3473,6 +3517,7 @@ async function memoryForget(opts) {
     db2.deleteMemory(fullId);
     const vecIdx = getVectorIndex();
     if (vecIdx) vecIdx.remove(fullId);
+    void mirrorEngine?.onDelete(fullId, memory.type);
     return { deleted: 1, message: `Deleted: "${memory.content}" (${memory.type})` };
   }
   if (opts.type) {
@@ -3483,6 +3528,7 @@ async function memoryForget(opts) {
     for (const m of matches) {
       db2.deleteMemory(m.id);
       if (vecIdx) vecIdx.remove(m.id);
+      void mirrorEngine?.onDelete(m.id, m.type);
     }
     return { deleted: matches.length, message: `Deleted ${matches.length} "${opts.type}" memories.` };
   }
@@ -3494,6 +3540,7 @@ async function memoryForget(opts) {
     for (const m of matches) {
       db2.deleteMemory(m.id);
       if (vecIdx) vecIdx.remove(m.id);
+      void mirrorEngine?.onDelete(m.id, m.type);
     }
     return { deleted: matches.length, message: `Deleted ${matches.length} memories matching "${opts.query}".` };
   }
@@ -3649,6 +3696,140 @@ async function memorySync(action, opts = {}) {
     return { ok: false, error: err instanceof Error ? err.message : String(err) };
   }
 }
+function getMirrorEngine() {
+  return mirrorEngine;
+}
+function extractAmemFields(raw) {
+  const out = {};
+  const block = raw.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!block) return out;
+  for (const line of block[1].split("\n")) {
+    const kv = line.match(/^(amem_\w+)\s*:\s*(.+)$/);
+    if (!kv) continue;
+    const key = kv[1];
+    const val = kv[2].trim();
+    switch (key) {
+      case "amem_id":
+        out.amemId = val;
+        break;
+      case "amem_type":
+        out.amemType = val;
+        break;
+      case "amem_tier":
+        out.amemTier = val;
+        break;
+      case "amem_confidence": {
+        const n = Number(val);
+        if (Number.isFinite(n)) out.amemConfidence = n;
+        break;
+      }
+      case "amem_tags":
+        out.amemTags = val.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
+        break;
+      case "amem_created": {
+        const t = Date.parse(val);
+        if (!Number.isNaN(t)) out.amemCreated = t;
+        break;
+      }
+    }
+  }
+  return out;
+}
+var CLAUDE_TO_AMEM_TYPE = {
+  feedback: "correction",
+  project: "decision",
+  user: "preference",
+  reference: "topology"
+};
+async function startupAutoSync() {
+  const cfg = loadConfig();
+  const autoSync = cfg?.mirror?.autoSyncOnStartup ?? true;
+  const enabled = cfg?.mirror?.enabled ?? true;
+  if (!enabled || !autoSync) return null;
+  const engine = mirrorEngine;
+  if (!engine) return null;
+  const dir = engine.status().dir;
+  try {
+    return await syncFromMirrorDir(dir);
+  } catch {
+    return null;
+  }
+}
+async function syncFromMirrorDir(dir) {
+  const db2 = getDb();
+  const result = {
+    imported: 0,
+    skipped: 0,
+    updated: 0,
+    details: [],
+    projectsScanned: 1
+  };
+  if (!fs7.existsSync(dir)) return result;
+  const targets = [];
+  const walk = (d) => {
+    for (const name of fs7.readdirSync(d)) {
+      if (name === "INDEX.md") continue;
+      const full = path7.join(d, name);
+      const stat = fs7.statSync(full);
+      if (stat.isDirectory()) walk(full);
+      else if (name.endsWith(".md")) targets.push(full);
+    }
+  };
+  try {
+    walk(dir);
+  } catch {
+    return result;
+  }
+  for (const filePath of targets) {
+    const raw = fs7.readFileSync(filePath, "utf-8");
+    const parsed = parseFrontmatter(raw, filePath);
+    if (!parsed) {
+      result.skipped++;
+      result.details.push({ action: "skipped", name: filePath, type: "unknown", reason: "invalid frontmatter" });
+      continue;
+    }
+    const amem = extractAmemFields(raw);
+    const resolvedType = amem.amemType ?? CLAUDE_TO_AMEM_TYPE[parsed.type];
+    if (!resolvedType) {
+      result.skipped++;
+      result.details.push({ action: "skipped", name: parsed.name, type: parsed.type, reason: `Unknown type: ${parsed.type}` });
+      continue;
+    }
+    const content = parsed.body;
+    if (!content.trim()) {
+      result.skipped++;
+      result.details.push({ action: "skipped", name: parsed.name, type: resolvedType, reason: "empty body" });
+      continue;
+    }
+    const existing = db2.findByContentHash(content);
+    if (existing) {
+      result.skipped++;
+      result.details.push({ action: "skipped", name: parsed.name, type: resolvedType, reason: "duplicate content" });
+      continue;
+    }
+    const embedding = await generateEmbedding(content);
+    const confidence = amem.amemConfidence ?? 0.8;
+    const isGlobal = resolvedType === "preference" || resolvedType === "correction";
+    const scope = isGlobal ? "global" : currentProject;
+    const tags = amem.amemTags ?? ["mirror-sync"];
+    db2.insertMemory({
+      content,
+      type: resolvedType,
+      tags,
+      confidence,
+      source: "mirror-sync",
+      embedding,
+      scope,
+      ...amem.amemTier ? { tier: amem.amemTier } : {},
+      // Preserve original creation time when the mirror file carries it,
+      // so round-tripped memories keep their chronology for recency decay.
+      ...amem.amemCreated ? { validFrom: amem.amemCreated } : {}
+    });
+    result.imported++;
+    result.details.push({ action: "imported", name: parsed.name, type: resolvedType });
+  }
+  return result;
+}
 
 // src/profile-templates.ts
 import fs8 from "fs";
@@ -8628,7 +8809,7 @@ async function handleMemoryCommand(action, args, ctx) {
       return { handled: true, output: pc6.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
     }
   }
-  if (action && !["search", "clear", "timeline", "stats", "export", "since", "fts", "help", "doctor", "repair", "config", "reflect", "consolidate", "tier", "detail", "relate", "expire", "versions", "sync"].includes(action)) {
+  if (action && !["search", "clear", "timeline", "stats", "export", "since", "fts", "help", "doctor", "repair", "config", "reflect", "consolidate", "tier", "detail", "relate", "expire", "versions", "sync", "mirror"].includes(action)) {
     try {
       const topic = [action, ...args].join(" ");
       const result = await memoryContext(topic);
@@ -8739,6 +8920,24 @@ async function handleMemoryCommand(action, args, ctx) {
   }
   if (action === "export") {
     try {
+      const toDir = parseFlagValue(args, "--to");
+      if (toDir !== void 0) {
+        const engine = getMirrorEngine();
+        if (!engine) {
+          return { handled: true, output: pc6.yellow("Mirror is disabled \u2014 enable via config.mirror.enabled in config.json.") };
+        }
+        const resolved = expandHome(toDir);
+        const res = await engine.exportSnapshot(resolved);
+        const lines2 = [
+          `Wrote ${res.written} files to ${resolved} (${res.skipped} skipped, ${res.errors.length} errors).`
+        ];
+        if (res.errors.length > 0) {
+          lines2.push("");
+          for (const e of res.errors.slice(0, 5)) lines2.push(`  - ${e}`);
+          if (res.errors.length > 5) lines2.push(`  ...and ${res.errors.length - 5} more`);
+        }
+        return { handled: true, output: lines2.join("\n") };
+      }
       const format = args[0] === "json" ? "json" : "markdown";
       const memories = memoryExport();
       if (memories.length === 0) {
@@ -8819,12 +9018,16 @@ async function handleMemoryCommand(action, args, ctx) {
       `  ${pc6.cyan("/memory since")} <Nh|Nd|Nw>    Memories from time window`,
       `  ${pc6.cyan("/memory stats")}               Show memory statistics`,
       `  ${pc6.cyan("/memory export")} [json]        Export all memories`,
+      `  ${pc6.cyan("/memory export --to")} <dir>    Snapshot mirror-format files to <dir>`,
       `  ${pc6.cyan("/memory timeline")}            View memory timeline`,
       `  ${pc6.cyan("/memory clear")} <query>        Delete matching memories`,
       `  ${pc6.cyan("/memory clear --type")} <type>  Delete all of a type`,
       `  ${pc6.cyan("/memory doctor")}              Run memory diagnostics`,
       `  ${pc6.cyan("/memory repair")}              Dry-run repair (safe)`,
-      `  ${pc6.cyan("/memory config")} [key=value]  View or update config (e.g. consolidation.maxStaleDays=60)`
+      `  ${pc6.cyan("/memory config")} [key=value]  View or update config (e.g. consolidation.maxStaleDays=60)`,
+      `  ${pc6.cyan("/memory mirror status")}        Show mirror dir, file count, health`,
+      `  ${pc6.cyan("/memory mirror rebuild")}       Rebuild the mirror from the DB`,
+      `  ${pc6.cyan("/memory sync --from")} <dir>    Import edits from a mirror-format dir`
     ].join("\n") };
   }
   if (action === "doctor") {
@@ -9009,7 +9212,51 @@ async function handleMemoryCommand(action, args, ctx) {
     }
     return { handled: true, output: lines.join("\n") };
   }
+  if (action === "mirror") {
+    const sub = args[0];
+    try {
+      if (sub === "status") {
+        const engine = getMirrorEngine();
+        if (!engine) return { handled: true, output: pc6.yellow("Mirror is disabled \u2014 enable via config.mirror.enabled in config.json.") };
+        const s = engine.status();
+        const last = s.lastWriteAt ? `${new Date(s.lastWriteAt).toISOString()} (${relativeTimeFromNow(s.lastWriteAt)})` : "never";
+        const lines = [
+          pc6.bold("Mirror:"),
+          `  Dir:          ${s.dir}`,
+          `  File count:   ${s.fileCount}`,
+          `  Last write:   ${last}`,
+          `  Health:       ${s.healthy ? "healthy" : "drifted"}`
+        ];
+        return { handled: true, output: lines.join("\n") };
+      }
+      if (sub === "rebuild") {
+        const engine = getMirrorEngine();
+        if (!engine) return { handled: true, output: pc6.yellow("Mirror is disabled \u2014 enable via config.mirror.enabled in config.json.") };
+        const res = await engine.fullMirror();
+        return {
+          handled: true,
+          output: `Rebuilt mirror: ${res.written} files written, ${res.skipped} skipped, ${res.errors.length} errors.`
+        };
+      }
+      return { handled: true, output: pc6.yellow("Unknown mirror subcommand; try 'status' or 'rebuild'.") };
+    } catch (err) {
+      return { handled: true, output: pc6.red(`Mirror error: ${err instanceof Error ? err.message : String(err)}`) };
+    }
+  }
   if (action === "sync") {
+    const fromDir = parseFlagValue(args, "--from");
+    if (fromDir !== void 0) {
+      try {
+        const resolved = expandHome(fromDir);
+        const res = await syncFromMirrorDir(resolved);
+        return {
+          handled: true,
+          output: `Synced ${res.imported} memories from ${resolved} (${res.skipped} skipped, ${res.updated} updated).`
+        };
+      } catch (err) {
+        return { handled: true, output: pc6.red(`Sync error: ${err instanceof Error ? err.message : String(err)}`) };
+      }
+    }
     const syncAction = args[0];
     if (!syncAction) {
       return { handled: true, output: pc6.yellow("Usage: /memory sync <import-claude|export-team|import-team|sync-copilot>") };
@@ -9031,6 +9278,25 @@ ${JSON.stringify(result, null, 2)}` };
   }
   return { handled: true, output: pc6.yellow(`Unknown action: /memory ${action}. Try /memory --help`) };
 }
+function parseFlagValue(args, flag) {
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === flag) {
+      return args[i + 1];
+    }
+    if (a.startsWith(`${flag}=`)) {
+      return a.slice(flag.length + 1);
+    }
+  }
+  return void 0;
+}
+function relativeTimeFromNow(ts) {
+  const delta = Date.now() - ts;
+  if (delta < 6e4) return "just now";
+  if (delta < 36e5) return `${Math.round(delta / 6e4)}m ago`;
+  if (delta < 864e5) return `${Math.round(delta / 36e5)}h ago`;
+  return `${Math.round(delta / 864e5)}d ago`;
+}
 function handleStatusCommand(ctx) {
   const mcpToolCount = ctx.mcpManager ? ctx.mcpManager.getTools().length : 0;
   const amemConnected = isMemoryInitialized();
@@ -9188,7 +9454,7 @@ function handleReset(action) {
 function handleUpdate() {
   try {
     const current = execFileSync3("npm", ["view", "@aman_asmuei/aman-agent", "version"], { encoding: "utf-8" }).trim();
-    const local = true ? "0.41.0" : "unknown";
+    const local = true ? "0.42.0" : "unknown";
     if (current === local) {
       return { handled: true, output: `${pc6.green("Up to date")} \u2014 v${local}` };
     }
@@ -12342,7 +12608,7 @@ var Inbox = class {
 // package.json
 var package_default = {
   name: "@aman_asmuei/aman-agent",
-  version: "0.41.0",
+  version: "0.42.0",
   description: "Your AI companion, running locally \u2014 powered by the aman ecosystem",
   type: "module",
   engines: {
@@ -12365,10 +12631,10 @@ var package_default = {
     prepublishOnly: "npm run build"
   },
   dependencies: {
-    "@aman_asmuei/aman-core": "^0.3.0",
     "@aman_asmuei/acore-core": "^0.2.0",
+    "@aman_asmuei/aman-core": "^0.3.0",
+    "@aman_asmuei/amem-core": "^0.6.0",
     "@aman_asmuei/arules-core": "^0.2.0",
-    "@aman_asmuei/amem-core": "^0.5.0",
     "@anthropic-ai/sdk": "^0.39.0",
     "@clack/prompts": "^0.9.1",
     "@modelcontextprotocol/sdk": "^1.27.1",
@@ -12709,7 +12975,7 @@ function bootstrapEcosystem() {
   return true;
 }
 var program = new Command();
-program.name("aman-agent").description("Your AI companion, running locally").version("0.41.0").option("--model <model>", "Override LLM model").option("--budget <tokens>", "Token budget for system prompt (default: 8000)", parseInt).option("--profile <name>", "Use a specific agent profile (e.g., coder, writer, researcher)").action(async (options) => {
+program.name("aman-agent").description("Your AI companion, running locally").version("0.42.0").option("--model <model>", "Override LLM model").option("--budget <tokens>", "Token budget for system prompt (default: 8000)", parseInt).option("--profile <name>", "Use a specific agent profile (e.g., coder, writer, researcher)").action(async (options) => {
   p4.intro(pc9.bold("aman agent") + pc9.dim(" \u2014 your AI companion"));
   let config = loadConfig();
   if (!config) {
@@ -12983,6 +13249,22 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
   } catch (err) {
     p4.log.warning(`Memory initialization failed: ${err instanceof Error ? err.message : String(err)}`);
   }
+  if (isMemoryInitialized()) {
+    const mirrorSpinner = p4.spinner();
+    mirrorSpinner.start("Checking mirror dir for updates");
+    try {
+      const syncResult = await startupAutoSync();
+      mirrorSpinner.stop(
+        syncResult && syncResult.imported > 0 ? `[mirror] synced ${syncResult.imported} new` : ""
+      );
+    } catch (err) {
+      mirrorSpinner.stop(
+        pc9.dim(
+          `[mirror] auto-sync skipped: ${err instanceof Error ? err.message : String(err)}`
+        )
+      );
+    }
+  }
   if (isMemoryInitialized()) {
     const memSpinner = p4.spinner();
     memSpinner.start("Consolidating memory");