unforgit 0.8.4 → 0.9.0

package/dist/index.js

@@ -7,7 +7,9 @@ import {
   defaultConfig,
   detectGitInfo,
   executeConsolidation,
+  exportMarkdownMemories,
   findConsolidationCandidates,
+  findUnsafeMarkdownMemoryFindings,
   formatCandidatePreview,
   formatTemplateList,
   generateEmbedding,
@@ -21,6 +23,7 @@ import {
   loadConfig,
   mergeAndRank,
   parseConfidence,
+  parseMarkdownMemories,
   parsePositiveInt,
   parseThreshold,
   parseTtl,
@@ -30,11 +33,12 @@ import {
   resolveVisibility,
   runLocalLifecycleMaintenance,
   saveConfig,
+  shouldImportMarkdownMemory,
   validateMemoryType
-} from "./chunk-VESJIIT2.js";
+} from "./chunk-JXSAAZ3I.js";
 
 // src/index.ts
-import { Command as Command31 } from "commander";
+import { Command as Command32 } from "commander";
 
 // src/commands/init.ts
 import fs2 from "fs";
@@ -4005,6 +4009,126 @@ var suggestionsCommand = new Command30("suggestions").description("Reviewable cu
   })
 );
 
+// src/commands/md.ts
+import fs7 from "fs";
+import path5 from "path";
+import { Command as Command31 } from "commander";
+var mdCommand = new Command31("md").description("Import and export markdown memory files such as CLAUDE.md and MEMORY.md");
+function readMarkdownFile(file) {
+  if (!fs7.existsSync(file)) {
+    logger.error(`Markdown file not found: ${file}`);
+    process.exit(EXIT_ERROR);
+  }
+  return fs7.readFileSync(file, "utf-8");
+}
+function importMarkdown(file, opts) {
+  const config = loadConfig();
+  const sourceFile = path5.resolve(file);
+  const markdown = readMarkdownFile(sourceFile);
+  const parsed = parseMarkdownMemories(markdown, { sourceFile });
+  const findings = findUnsafeMarkdownMemoryFindings(parsed);
+  const importable = parsed.filter((memory) => shouldImportMarkdownMemory(memory, findings));
+  const dryRun = !opts.apply;
+  const storedIds = [];
+  if (!dryRun) {
+    const store = new LocalStore(getDbPath());
+    try {
+      const existing = store.list({
+        orgId: config.remote.orgId || "local",
+        repoId: config.remote.repoId || "local",
+        status: ["active"],
+        limit: 1e4
+      });
+      const existingChecksums = new Set(
+        existing.map((memory) => {
+          const markdownSource = memory.sourceRefs?.markdown;
+          return markdownSource?.checksum;
+        }).filter((checksum) => Boolean(checksum))
+      );
+      const existingTexts = new Set(existing.map((memory) => memory.text.trim().toLowerCase()));
+      for (const memory of importable) {
+        if (existingChecksums.has(memory.checksum) || existingTexts.has(memory.text.trim().toLowerCase())) {
+          continue;
+        }
+        const stored = store.store({
+          orgId: config.remote.orgId || "local",
+          repoId: config.remote.repoId || "local",
+          memoryType: memory.memoryType,
+          text: memory.text,
+          tags: memory.tags,
+          sourceRefs: {
+            markdown: {
+              sourceFile,
+              sourceId: memory.id,
+              lineStart: memory.lineStart,
+              lineEnd: memory.lineEnd,
+              checksum: memory.checksum,
+              headingPath: memory.headingPath
+            }
+          }
+        });
+        storedIds.push(stored.id);
+      }
+    } finally {
+      store.close();
+    }
+  }
+  const payload = {
+    file: sourceFile,
+    parsed: parsed.length,
+    importable: importable.length,
+    skippedUnsafe: findings.length,
+    stored: storedIds.length,
+    dryRun,
+    findings,
+    storedIds
+  };
+  if (opts.json || isJsonMode()) {
+    outputJson(payload);
+  } else {
+    logger.info(`${dryRun ? "Would import" : "Imported"}: ${payload.stored || importable.length} memories`);
+    logger.info(`Parsed: ${parsed.length}`);
+    logger.info(`Skipped unsafe: ${findings.length}`);
+    for (const finding of findings) logger.warn(`- ${finding.message}`);
+  }
+}
+mdCommand.command("import").description("Import a markdown memory file into Unforgit; dry-run by default").argument("<file>", "Markdown file to import, for example CLAUDE.md or MEMORY.md").option("--dry-run", "Preview import without writing memories").option("--apply", "Store safe, non-duplicate parsed memories").option("--json", "Output machine-readable JSON").action((file, opts) => importMarkdown(file, opts));
+mdCommand.command("scan").description("Parse and safety-check a markdown memory file without writing").argument("<file>", "Markdown file to scan").option("--json", "Output machine-readable JSON").action((file, opts) => importMarkdown(file, { ...opts, dryRun: true }));
+mdCommand.command("export").description("Export active Unforgit memories to a markdown memory file").option("--format <format>", "Markdown flavor (claude|generic)", "generic").option("--out <file>", "Output markdown path").option("--tags <tags>", "Comma-separated tag filter").option("--types <types>", "Comma-separated memory types").option("--json", "Output machine-readable JSON").action((opts) => {
+  const config = loadConfig();
+  const store = new LocalStore(getDbPath());
+  const out = path5.resolve(opts.out ?? (opts.format === "claude" ? "CLAUDE.md" : "MEMORY.md"));
+  try {
+    const types = opts.types ? opts.types.split(",").map((type) => type.trim()).filter(Boolean) : void 0;
+    const tags = opts.tags ? opts.tags.split(",").map((tag) => tag.trim()).filter(Boolean) : void 0;
+    const memories = store.list({
+      orgId: config.remote.orgId || "local",
+      repoId: config.remote.repoId || "local",
+      status: ["active"],
+      types,
+      tags,
+      limit: 1e4
+    });
+    const markdown = exportMarkdownMemories(
+      memories.map((memory) => ({
+        id: memory.id,
+        text: memory.text,
+        memoryType: memory.memoryType,
+        tags: memory.tags
+      })),
+      { format: opts.format === "claude" ? "claude" : "generic", title: path5.basename(out) }
+    );
+    fs7.mkdirSync(path5.dirname(out), { recursive: true });
+    fs7.writeFileSync(out, markdown, "utf-8");
+    const payload = { exported: memories.length, out, format: opts.format };
+    if (opts.json || isJsonMode()) outputJson(payload);
+    else logger.info(`Exported ${memories.length} memories to ${out}`);
+  } finally {
+    store.close();
+  }
+});
+mdCommand.command("doctor").description("Check a markdown memory file for unsafe entries and importability").argument("<file>", "Markdown file to inspect").option("--json", "Output machine-readable JSON").action((file, opts) => importMarkdown(file, { ...opts, dryRun: true }));
+
 // src/index.ts
 import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
@@ -4043,7 +4167,7 @@ process.on("unhandledRejection", (err) => {
   runCleanup();
   process.exit(EXIT_ERROR);
 });
-var program = new Command31();
+var program = new Command32();
 program.name("unforgit").description("Unforgit \u2014 repository memory for agents and developers").version(pkg.version).option("--verbose", "Enable verbose output").option("--quiet", "Suppress non-essential output").option("--json", "Output results as JSON (for scripting)").hook("preAction", () => {
   const opts = program.opts();
   if (opts.quiet) setVerbosity(0);
@@ -4085,6 +4209,7 @@ program.addCommand(dashboardCommand);
 program.addCommand(doctorCommand);
 program.addCommand(curateCommand);
 program.addCommand(suggestionsCommand);
+program.addCommand(mdCommand);
 program.addCommand(completionCommand);
 program.parseAsync().catch((err) => {
   console.error(`fatal: ${err instanceof Error ? err.message : err}`);