recallnest 1.4.1 → 2.2.1

package/src/cli.ts

@@ -14,6 +14,7 @@ import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { homedir } from "node:os";
 
+import { metaDir } from "./compat.js";
 import type { RetrievalResult } from "./retriever.js";
 import { applyRetrievalProfile, listRetrievalProfiles } from "./retrieval-profiles.js";
 import { distillResults, formatExplainResults, formatSearchResults, selectBriefSeedResults, summarizeResults } from "./memory-output.js";
@@ -280,19 +281,19 @@ function filterConflictsByAttention<T extends { status: string; createdAt: strin
 function workflowPatternSeedsPath(file?: string): string {
   return file
     ? resolve(file)
-    : resolve(import.meta.dir, "../eval/continuity/pattern-seeds.json");
+    : resolve(metaDir(import.meta), "../eval/continuity/pattern-seeds.json");
 }
 
 function caseMemorySeedsPath(file?: string): string {
   return file
     ? resolve(file)
-    : resolve(import.meta.dir, "../eval/continuity/case-seeds.json");
+    : resolve(metaDir(import.meta), "../eval/continuity/case-seeds.json");
 }
 
 function memorySeedsPath(file?: string): string {
   return file
     ? resolve(file)
-    : resolve(import.meta.dir, "../eval/continuity/memory-seeds.json");
+    : resolve(metaDir(import.meta), "../eval/continuity/memory-seeds.json");
 }
 
 function parseMetadata(raw?: string): Record<string, unknown> {
@@ -1409,7 +1410,7 @@ program
     if (source === "all" || source === "desktop") {
       const desktopSource = config.sources.desktop;
       if (desktopSource) {
-        const desktopPath = resolve(import.meta.dir, "..", desktopSource.path);
+        const desktopPath = resolve(metaDir(import.meta), "..", desktopSource.path);
         if (existsSync(desktopPath)) {
           console.log("🖥️  导入 Claude Desktop 对话...");
           const r = await ingestCCTranscripts(store, embedder, desktopPath, ingestOpts);
@@ -1580,7 +1581,7 @@ program
     }
 
     const config = loadConfig();
-    const dbPath = resolve(import.meta.dir, "..", expandHome(config.dbPath));
+    const dbPath = resolve(metaDir(import.meta), "..", expandHome(config.dbPath));
 
     if (existsSync(dbPath)) {
       const { rmSync } = await import("node:fs");
@@ -1898,6 +1899,51 @@ program
     }
   });
 
+program
+  .command("import <path>")
+  .description("导入多格式对话文件到记忆索引")
+  .option("-f, --format <format>", "格式: auto|claude-code|chatgpt|slack|claude-ai|plaintext", "auto")
+  .option("-s, --scope <scope>", "目标 scope（必须）")
+  .action(async (filePath: string, options) => {
+    if (!options.scope) {
+      console.error("❌ --scope is required");
+      process.exitCode = 1;
+      return;
+    }
+    const resolvedPath = resolve(filePath);
+    if (!existsSync(resolvedPath)) {
+      console.error(`❌ File not found: ${resolvedPath}`);
+      process.exitCode = 1;
+      return;
+    }
+    const validFormats = ["auto", "claude-code", "chatgpt", "slack", "claude-ai", "plaintext"] as const;
+    if (!validFormats.includes(options.format)) {
+      console.error(`❌ Invalid format: ${options.format}. Must be one of: ${validFormats.join(", ")}`);
+      process.exitCode = 1;
+      return;
+    }
+
+    const config = loadConfig();
+    const { store, embedder, llm } = createComponents(config);
+
+    const { importConversation } = await import("./conversation-importer.js");
+    const result = await importConversation(
+      { store, embedder, llm },
+      resolvedPath,
+      options.scope,
+      options.format as "auto" | "claude-code" | "chatgpt" | "slack" | "claude-ai" | "plaintext",
+    );
+
+    console.log(`\n📥 Import complete`);
+    console.log(`  Total messages: ${result.total}`);
+    console.log(`  Stored: ${result.stored}`);
+    console.log(`  Rejected: ${result.rejected}`);
+    if (result.errors.length > 0) {
+      console.log(`  Errors: ${result.errors.length}`);
+      for (const e of result.errors) console.log(`    ${e}`);
+    }
+  });
+
 program
   .command("doctor")
   .description("检查安装状态和配置")
@@ -1909,6 +1955,62 @@ program
     if (hasFailure) process.exitCode = 1;
   });
 
+program
+  .command("lint")
+  .description("Run memory quality lint checks")
+  .option("--scope <scope>", "Limit to a specific scope")
+  .option("--json", "Output raw JSON instead of formatted report")
+  .option("--verbose", "Show all individual findings")
+  .action(async (options) => {
+    const { runMemoryLint, formatMemoryLintReport } = await import("./memory-lint.js");
+    const config = loadConfig();
+    const { store } = createComponents(config);
+
+    const report = await runMemoryLint({
+      store,
+      scope: options.scope,
+      verbose: options.verbose,
+    });
+
+    if (options.json) {
+      console.log(JSON.stringify(report, null, 2));
+    } else {
+      console.log();
+      console.log(formatMemoryLintReport(report));
+    }
+  });
+
+program
+  .command("graph")
+  .description("Export interactive knowledge graph as HTML")
+  .option("--scope <scope>", "Limit to a specific scope")
+  .option("--max-nodes <n>", "Maximum nodes (default 200)", "200")
+  .option("--out <path>", "Output file path")
+  .option("--open", "Open in browser after export")
+  .action(async (options) => {
+    const { exportMemoryGraph, formatGraphExportResult } = await import("./graph-export.js");
+    const config = loadConfig();
+    const { store } = createComponents(config);
+
+    const maxNodes = parseInt(options.maxNodes, 10) || 200;
+    const { path, graph } = await exportMemoryGraph(store, {
+      scope: options.scope,
+      maxNodes,
+      outputPath: options.out,
+    });
+
+    console.log();
+    console.log(formatGraphExportResult(path, graph));
+
+    if (options.open) {
+      const { execFileSync } = await import("node:child_process");
+      try {
+        const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+        execFileSync(cmd, [path], { stdio: "ignore" });
+      } catch {}
+    }
+  });
+
 // Run
 loadDotEnv();
 program.parseAsync(process.argv).catch((error) => {

package/src/compat.ts

@@ -0,0 +1,22 @@
+/**
+ * Cross-runtime compatibility helpers
+ *
+ * Bridges Bun-specific APIs to work with Node.js as well.
+ */
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+/**
+ * Cross-runtime replacement for Bun's `import.meta.dir`.
+ * - Bun: returns import.meta.dir (native, fast)
+ * - Node.js: derives from import.meta.url
+ *
+ * Usage: replace `import.meta.dir` with `metaDir(import.meta)`
+ */
+export function metaDir(meta: ImportMeta): string {
+  // Bun sets import.meta.dir natively
+  const dir = (meta as Record<string, unknown>).dir;
+  if (typeof dir === "string") return dir;
+  // Node.js fallback
+  return dirname(fileURLToPath(meta.url));
+}

package/src/confidence-tracker.ts

@@ -19,9 +19,13 @@
  *
  * Retrieval integration: confidence multiplies into the score pipeline
  * as `score *= (0.5 + 0.5 * confidence)` — same pattern as importance.
+ *
+ * Design: returns metadata patches instead of directly mutating the store.
+ * Callers apply patches via their own store.update() / patchMetadata().
+ * This keeps the module store-agnostic and easier to test.
  */
 
-import type { MemoryStore, MemoryEntry } from "./store.js";
+import type { MemoryEntry } from "./store.js";
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -32,24 +36,60 @@ export const CONFIDENCE_CONFIRMED = 1.0;
 export const CONFIDENCE_CORRECTED = 0.3;
 export const CONFIDENCE_CONTRADICTED = 0.0;
 
+/** Max history entries to keep per memory (prevents unbounded growth). */
+const MAX_CONFIDENCE_HISTORY = 20;
+
 // ---------------------------------------------------------------------------
-// Helpers
+// F1: Structured Confidence Metadata
 // ---------------------------------------------------------------------------
 
-function parseMeta(entry: MemoryEntry): Record<string, any> {
-  try { return JSON.parse(entry.metadata || "{}"); } catch { return {}; }
+export type ConfidenceReliability = "direct" | "inferred" | "hearsay";
+
+export interface ConfidenceMetadata {
+  /** 0–1 composite confidence score. */
+  score: number;
+  /** Source reliability tier. */
+  reliability: ConfidenceReliability;
+  /** Last verification timestamp (ms). */
+  verifiedAt?: number;
+  /** Who verified: user / system / llm. */
+  verifiedBy?: string;
 }
 
 /**
- * Read confidence from metadata. Returns default (0.7) if not set.
+ * F1: Assign default confidence based on memory source.
+ * Returns a ConfidenceMetadata object to embed in metadata JSON.
  */
-export function getConfidence(entry: MemoryEntry): number {
-  const meta = parseMeta(entry);
-  return typeof meta.confidence === "number" ? meta.confidence : CONFIDENCE_DEFAULT;
+export function assignDefaultConfidence(
+  source: string,
+  explicitConfidence?: Partial<ConfidenceMetadata>,
+): ConfidenceMetadata {
+  // If caller provided explicit values, use them (fill in defaults for missing fields)
+  if (explicitConfidence?.score != null) {
+    return {
+      score: explicitConfidence.score,
+      reliability: explicitConfidence.reliability ?? "inferred",
+      verifiedAt: explicitConfidence.verifiedAt,
+      verifiedBy: explicitConfidence.verifiedBy,
+    };
+  }
+  switch (source) {
+    case "manual":
+      return { score: 0.9, reliability: "direct" };
+    case "agent":
+    case "api":
+      return { score: 0.7, reliability: "inferred" };
+    case "session_distill":
+      return { score: 0.6, reliability: "inferred" };
+    case "conversation_import":
+      return { score: 0.5, reliability: "hearsay" };
+    default:
+      return { score: CONFIDENCE_DEFAULT, reliability: "inferred" };
+  }
 }
 
 // ---------------------------------------------------------------------------
-// Core operations
+// Types
 // ---------------------------------------------------------------------------
 
 export interface ConfidenceUpdate {
@@ -58,46 +98,118 @@ export interface ConfidenceUpdate {
   newConfidence: number;
 }
 
+export interface ConfidencePatch {
+  /** The metadata object to merge/write back. */
+  metadata: Record<string, unknown>;
+  /** Summary of what changed. */
+  update: ConfidenceUpdate;
+}
+
+interface ConfidenceHistoryEntry {
+  action: "confirmed" | "corrected" | "contradicted";
+  from: number;
+  to: number;
+  date: string;
+  correctedBy?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function parseMeta(entry: MemoryEntry): Record<string, unknown> {
+  try { return JSON.parse(entry.metadata || "{}"); } catch { return {}; }
+}
+
 /**
- * Mark a memory as confirmed (user validated it).
- * Bumps confidence to CONFIRMED (1.0).
+ * Read confidence score from metadata. Handles both flat number (legacy)
+ * and structured ConfidenceMetadata object (F1).
+ * Returns default (0.7) if not set.
  */
-export async function confirmMemory(
-  store: MemoryStore,
-  entryId: string,
-  scope: string,
-): Promise<ConfidenceUpdate | null> {
-  const entry = await store.getById(entryId);
+export function getConfidence(entry: MemoryEntry): number {
+  const meta = parseMeta(entry);
+  if (typeof meta.confidence === "number") return meta.confidence;
+  if (meta.confidence && typeof meta.confidence === "object") {
+    const obj = meta.confidence as Record<string, unknown>;
+    if (typeof obj.score === "number") return obj.score;
+  }
+  return CONFIDENCE_DEFAULT;
+}
+
+/**
+ * F1: Read full ConfidenceMetadata from entry. Returns null if not set.
+ */
+export function getConfidenceMetadata(entry: MemoryEntry): ConfidenceMetadata | null {
+  const meta = parseMeta(entry);
+  if (meta.confidence && typeof meta.confidence === "object") {
+    const obj = meta.confidence as Record<string, unknown>;
+    if (typeof obj.score === "number") {
+      return {
+        score: obj.score,
+        reliability: (obj.reliability as ConfidenceReliability) ?? "inferred",
+        verifiedAt: typeof obj.verifiedAt === "number" ? obj.verifiedAt : undefined,
+        verifiedBy: typeof obj.verifiedBy === "string" ? obj.verifiedBy : undefined,
+      };
+    }
+  }
+  // Legacy flat number → wrap
+  if (typeof meta.confidence === "number") {
+    return { score: meta.confidence, reliability: "inferred" };
+  }
+  return null;
+}
+
+function appendHistory(
+  meta: Record<string, unknown>,
+  entry: ConfidenceHistoryEntry,
+): void {
+  if (!Array.isArray(meta.confidence_history)) meta.confidence_history = [];
+  const history = meta.confidence_history as ConfidenceHistoryEntry[];
+  history.push(entry);
+  // Cap history length
+  if (history.length > MAX_CONFIDENCE_HISTORY) {
+    meta.confidence_history = history.slice(-MAX_CONFIDENCE_HISTORY);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Patch builders (store-agnostic — return patches, don't write)
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a patch to mark a memory as confirmed (user validated it).
+ * Returns null if entry is null (not found).
+ */
+export function buildConfirmPatch(
+  entry: MemoryEntry | null,
+): ConfidencePatch | null {
   if (!entry) return null;
 
   const meta = parseMeta(entry);
   const oldConfidence = typeof meta.confidence === "number" ? meta.confidence : CONFIDENCE_DEFAULT;
 
   meta.confidence = CONFIDENCE_CONFIRMED;
-  if (!Array.isArray(meta.confidence_history)) meta.confidence_history = [];
-  meta.confidence_history.push({
+  appendHistory(meta, {
     action: "confirmed",
     from: oldConfidence,
     to: CONFIDENCE_CONFIRMED,
     date: new Date().toISOString().slice(0, 10),
   });
 
-  await store.update(entryId, { metadata: JSON.stringify(meta) }, [scope]);
-
-  return { entryId, oldConfidence, newConfidence: CONFIDENCE_CONFIRMED };
+  return {
+    metadata: meta,
+    update: { entryId: entry.id, oldConfidence, newConfidence: CONFIDENCE_CONFIRMED },
+  };
 }
 
 /**
- * Mark a memory as corrected (user provided updated info).
- * Drops confidence to CORRECTED (0.3).
+ * Build a patch to mark a memory as corrected (user provided updated info).
+ * Returns null if entry is null (not found).
  */
-export async function correctMemory(
-  store: MemoryStore,
-  entryId: string,
-  scope: string,
+export function buildCorrectPatch(
+  entry: MemoryEntry | null,
   correctedById?: string,
-): Promise<ConfidenceUpdate | null> {
-  const entry = await store.getById(entryId);
+): ConfidencePatch | null {
   if (!entry) return null;
 
   const meta = parseMeta(entry);
@@ -105,8 +217,7 @@ export async function correctMemory(
 
   meta.confidence = CONFIDENCE_CORRECTED;
   if (correctedById) meta.corrected_by = correctedById;
-  if (!Array.isArray(meta.confidence_history)) meta.confidence_history = [];
-  meta.confidence_history.push({
+  appendHistory(meta, {
     action: "corrected",
     from: oldConfidence,
     to: CONFIDENCE_CORRECTED,
@@ -114,40 +225,92 @@ export async function correctMemory(
     date: new Date().toISOString().slice(0, 10),
   });
 
-  await store.update(entryId, { metadata: JSON.stringify(meta) }, [scope]);
-
-  return { entryId, oldConfidence, newConfidence: CONFIDENCE_CORRECTED };
+  return {
+    metadata: meta,
+    update: { entryId: entry.id, oldConfidence, newConfidence: CONFIDENCE_CORRECTED },
+  };
 }
 
 /**
- * Mark a memory as contradicted (explicitly wrong).
- * Drops confidence to CONTRADICTED (0.0).
+ * Build a patch to mark a memory as contradicted (explicitly wrong).
+ * Returns null if entry is null (not found).
  */
-export async function contradictMemory(
-  store: MemoryStore,
-  entryId: string,
-  scope: string,
-): Promise<ConfidenceUpdate | null> {
-  const entry = await store.getById(entryId);
+export function buildContradictPatch(
+  entry: MemoryEntry | null,
+): ConfidencePatch | null {
   if (!entry) return null;
 
   const meta = parseMeta(entry);
   const oldConfidence = typeof meta.confidence === "number" ? meta.confidence : CONFIDENCE_DEFAULT;
 
   meta.confidence = CONFIDENCE_CONTRADICTED;
-  if (!Array.isArray(meta.confidence_history)) meta.confidence_history = [];
-  meta.confidence_history.push({
+  appendHistory(meta, {
     action: "contradicted",
     from: oldConfidence,
     to: CONFIDENCE_CONTRADICTED,
     date: new Date().toISOString().slice(0, 10),
   });
 
-  await store.update(entryId, { metadata: JSON.stringify(meta) }, [scope]);
+  return {
+    metadata: meta,
+    update: { entryId: entry.id, oldConfidence, newConfidence: CONFIDENCE_CONTRADICTED },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Convenience wrappers (for callers who DO have a store)
+// ---------------------------------------------------------------------------
+
+/**
+ * Confirm a memory and write back to store. Convenience wrapper.
+ */
+export async function confirmMemory(
+  store: { getById(id: string): Promise<MemoryEntry | null>; update(id: string, data: { metadata: string }, scopes: string[]): Promise<void> },
+  entryId: string,
+  scope: string,
+): Promise<ConfidenceUpdate | null> {
+  const entry = await store.getById(entryId);
+  const patch = buildConfirmPatch(entry);
+  if (!patch) return null;
+  await store.update(entryId, { metadata: JSON.stringify(patch.metadata) }, [scope]);
+  return patch.update;
+}
+
+/**
+ * Correct a memory and write back to store. Convenience wrapper.
+ */
+export async function correctMemory(
+  store: { getById(id: string): Promise<MemoryEntry | null>; update(id: string, data: { metadata: string }, scopes: string[]): Promise<void> },
+  entryId: string,
+  scope: string,
+  correctedById?: string,
+): Promise<ConfidenceUpdate | null> {
+  const entry = await store.getById(entryId);
+  const patch = buildCorrectPatch(entry, correctedById);
+  if (!patch) return null;
+  await store.update(entryId, { metadata: JSON.stringify(patch.metadata) }, [scope]);
+  return patch.update;
+}
 
-  return { entryId, oldConfidence, newConfidence: CONFIDENCE_CONTRADICTED };
+/**
+ * Contradict a memory and write back to store. Convenience wrapper.
+ */
+export async function contradictMemory(
+  store: { getById(id: string): Promise<MemoryEntry | null>; update(id: string, data: { metadata: string }, scopes: string[]): Promise<void> },
+  entryId: string,
+  scope: string,
+): Promise<ConfidenceUpdate | null> {
+  const entry = await store.getById(entryId);
+  const patch = buildContradictPatch(entry);
+  if (!patch) return null;
+  await store.update(entryId, { metadata: JSON.stringify(patch.metadata) }, [scope]);
+  return patch.update;
 }
 
+// ---------------------------------------------------------------------------
+// Retrieval integration (unchanged — already store-agnostic)
+// ---------------------------------------------------------------------------
+
 /**
  * Apply confidence weighting to retrieval scores.
  * Formula: score *= (0.5 + 0.5 * confidence)

package/src/conflict-store.ts

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 
+import { metaDir } from "./compat.js";
 import type { ConflictCandidateRecord, ConflictStatus } from "./conflict-schema.js";
 import { ConflictCandidateRecordSchema } from "./conflict-schema.js";
 
@@ -24,7 +25,7 @@ function sortNewestFirst(records: ConflictCandidateRecord[]): ConflictCandidateR
 }
 
 export class ConflictCandidateStore {
-  constructor(private readonly dir = resolve(import.meta.dir, "../data/conflict-candidates")) {}
+  constructor(private readonly dir = resolve(metaDir(import.meta), "../data/conflict-candidates")) {}
 
   get dataDir(): string {
     return ensureDir(this.dir);
@@ -34,7 +35,11 @@ export class ConflictCandidateStore {
     const parsed = ConflictCandidateRecordSchema.parse(record);
     const timestampToken = parsed.createdAt.replace(/[:.]/g, "-");
     const path = join(this.dataDir, `${timestampToken}-${parsed.conflictId}.json`);
-    writeFileSync(path, JSON.stringify(parsed, null, 2) + "\n");
+    try {
+      writeFileSync(path, JSON.stringify(parsed, null, 2) + "\n");
+    } catch (err) {
+      console.error("[recallnest] Failed to save conflict record:", err instanceof Error ? err.message : String(err));
+    }
     return parsed;
   }
 
@@ -43,7 +48,11 @@ export class ConflictCandidateStore {
     const existingPath = this.findPathById(parsed.conflictId);
     const timestampToken = parsed.createdAt.replace(/[:.]/g, "-");
     const path = existingPath || join(this.dataDir, `${timestampToken}-${parsed.conflictId}.json`);
-    writeFileSync(path, JSON.stringify(parsed, null, 2) + "\n");
+    try {
+      writeFileSync(path, JSON.stringify(parsed, null, 2) + "\n");
+    } catch (err) {
+      console.error("[recallnest] Failed to replace conflict record:", err instanceof Error ? err.message : String(err));
+    }
     return parsed;
   }