nexusmem 0.6.0 → 0.7.0

package/CHANGELOG.md

@@ -9,6 +9,36 @@ built from, matched by publish timestamp: `v0.1.0` → `67a4776`, `v0.1.1` → `
 
 ## [Unreleased]
 
+No unreleased changes yet.
+
+## [0.7.0] — 2026-08-21
+
+### Added
+
+- `nexusmem stale --check-contradictions`: for each stale candidate, finds the most similar newer
+  node (local embedding search) and asks a local SLM (Ollama, `qwen2.5:3b` by default) whether it
+  actually contradicts the older one, instead of only surfacing by age. Suggest-only — nothing is
+  written, same as plain `stale`. Live-dogfooded against this repo's own real database and Ollama
+  instance; found and fixed a real gap along the way (below) before the feature surfaced anything
+  useful.
+- Import graph: bare Python imports with no leading dot (`import foo`, `from foo import bar`)
+  now resolve to a same-directory sibling file too, alongside the existing relative-dot support.
+  Found dogfooding two real local projects: neither used a single PEP 328 relative import, both
+  relied entirely on this flat-script style. Guarded by a static list of stdlib module names so a
+  bare `import os`/`import queue`/etc. is never mistaken for a same-named local file.
+
+### Fixed
+
+- Import graph: a Java wildcard import (`import a.b.*;`) no longer merges files from two
+  unrelated packages that happen to share a directory-name suffix (e.g. two Gradle/Maven modules
+  each with their own `.../foo`) — it now refuses to guess, same as the single-class-import case.
+- `stale --check-contradictions`'s neighbor search now looks past same-timestamp sibling nodes
+  (e.g. the many chunks one long conversation gets split into) to reach genuinely newer content.
+  Found live-dogfooding against this repo's own database: the first real candidate's closest 15
+  neighbors were all same-conversation siblings sharing its exact timestamp, so the original
+  5-neighbor default silently found zero suggestions for every candidate, regardless of what the
+  SLM would have said.
+
 ## [0.6.0] — 2026-08-20
 
 ### Added
@@ -451,7 +481,8 @@ First public release.
   there is no local-model summarization pass, and the conversation collector has never been audited
   for the stale-node bug that was found and fixed in the docs collector.
 
-[Unreleased]: https://github.com/yaminbkk/NexusMem/compare/v0.6.0...HEAD
+[Unreleased]: https://github.com/yaminbkk/NexusMem/compare/v0.7.0...HEAD
+[0.7.0]: https://github.com/yaminbkk/NexusMem/compare/v0.6.0...v0.7.0
 [0.6.0]: https://github.com/yaminbkk/NexusMem/compare/v0.5.4...v0.6.0
 [0.5.4]: https://github.com/yaminbkk/NexusMem/compare/v0.5.3...v0.5.4
 [0.5.3]: https://github.com/yaminbkk/NexusMem/compare/v0.5.2...v0.5.3

package/README.md

@@ -290,10 +290,22 @@ nexusmem mark-stale <oldNodeId> --supersedes <newNodeId>
 Links `newNodeId` as the replacement for `oldNodeId`. The ranker down-weights the old node from then
 on (it stays queryable, just usually loses to its replacement) — nothing is deleted, unlike `forget`.
 
-**What this doesn't do:** nothing here reads content to detect a real contradiction. If a later commit
-contradicts an earlier doc section, `nexusmem stale` won't know that specifically — it only knows the
-doc section is old and inferred. Actual contradiction detection (comparing what two nodes claim, not
-just how old one is) is still an open problem.
+```bash
+nexusmem stale --check-contradictions
+```
+
+For each candidate, finds the most similar newer node (local embedding search) and asks a local SLM
+(Ollama, `qwen2.5:3b` by default) whether it actually contradicts the older one — real content
+comparison, not just age. A match is printed as `likely superseded by <id> <title> -- <reason>`
+under the candidate; nothing is written, same as plain `stale`. Needs Ollama running; costs one
+embedding call and, when a plausible newer node exists, one chat completion per candidate (capped at
+10 by default — pass `-n` to raise it).
+
+**What this doesn't do:** it is one small model's yes/no judgment on one older/newer pair, not a
+verified fact — treat a match as a lead to check, not a conclusion. It also only ever compares a
+candidate against nodes *found by embedding similarity*; a contradiction from an unrelated-sounding
+node would never surface. Real contradiction detection (comprehensively, not just for the pair the
+vector search happens to surface) is still an open problem.
 
 ## Where it breaks
 
@@ -361,8 +373,9 @@ just how old one is) is still an open problem.
 ## Commands
 
 `init`, `sync`, `query <text>`, `status` (add `--share` for a plain-text summary worth pasting
-somewhere), `projects`, `mcp`, `forget <value>`, `stale`,
-`mark-stale <nodeId> --supersedes <newNodeId>`, and `hook install|remove|status`.
+somewhere), `projects`, `mcp`, `forget <value>`, `stale` (add `--check-contradictions` for a local-SLM
+content check, see above), `mark-stale <nodeId> --supersedes <newNodeId>`, and
+`hook install|remove|status`.
 
 There are also five dry-run previews (`scan-git`, `scan-diff`, `scan-shell`, `scan-docs`,
 `scan-conversation`)

package/dist/cli/index.js

@@ -4216,6 +4216,8 @@ function extractPhpIncludeSpecifiers(source) {
 
 // src/structure/extract-python.ts
 var RELATIVE_IMPORT_PATTERN = /\bfrom\s+(\.+)([\w.]*)\s+import\s+([^\n]+)/g;
+var BARE_FROM_IMPORT_PATTERN = /^[ \t]*from\s+([A-Za-z_]\w*)\s+import\b/gm;
+var BARE_IMPORT_PATTERN = /^[ \t]*import\s+([^\n]+)/gm;
 function cleanNames(raw) {
   return raw.split("#")[0].replace(/[()]/g, "").split(",").map((token) => token.trim().split(/\s+as\s+/)[0].trim()).filter((name) => /^[A-Za-z_]\w*$/.test(name));
 }
@@ -4234,6 +4236,16 @@ function extractPythonImportSpecifiers(source) {
       seen.add(dots + name);
     }
   }
+  BARE_FROM_IMPORT_PATTERN.lastIndex = 0;
+  while ((match = BARE_FROM_IMPORT_PATTERN.exec(source)) !== null) {
+    seen.add(match[1]);
+  }
+  BARE_IMPORT_PATTERN.lastIndex = 0;
+  while ((match = BARE_IMPORT_PATTERN.exec(source)) !== null) {
+    for (const name of cleanNames(match[1])) {
+      seen.add(name);
+    }
+  }
   return [...seen];
 }
 
@@ -4314,7 +4326,9 @@ function resolveJavaSpecifier(specifier, trackedPaths) {
   if (segments.length === 0) return [];
   if (isWildcard) {
     const dirSuffix = segments.join("/");
-    return [...trackedPaths].filter((p) => p.endsWith(".java") && endsAtSegmentBoundary(posix3.dirname(p), dirSuffix)).sort();
+    const matches2 = [...trackedPaths].filter((p) => p.endsWith(".java") && endsAtSegmentBoundary(posix3.dirname(p), dirSuffix));
+    const dirs = new Set(matches2.map((p) => posix3.dirname(p)));
+    return dirs.size === 1 ? matches2.sort() : [];
   }
   const fileSuffix = `${segments.join("/")}.java`;
   const matches = [...trackedPaths].filter((p) => endsAtSegmentBoundary(p, fileSuffix));
@@ -4335,11 +4349,182 @@ function resolvePhpSpecifier(fromPath, specifier, trackedPaths) {
 
 // src/structure/resolve-python.ts
 import { posix as posix5 } from "path";
+var STDLIB_MODULES = /* @__PURE__ */ new Set([
+  "__future__",
+  "abc",
+  "argparse",
+  "array",
+  "ast",
+  "asyncio",
+  "base64",
+  "bisect",
+  "builtins",
+  "calendar",
+  "cgi",
+  "cgitb",
+  "cmd",
+  "codecs",
+  "collections",
+  "colorsys",
+  "compileall",
+  "concurrent",
+  "configparser",
+  "contextlib",
+  "contextvars",
+  "copy",
+  "copyreg",
+  "cProfile",
+  "csv",
+  "ctypes",
+  "curses",
+  "dataclasses",
+  "datetime",
+  "dbm",
+  "decimal",
+  "difflib",
+  "dis",
+  "doctest",
+  "email",
+  "encodings",
+  "ensurepip",
+  "enum",
+  "errno",
+  "faulthandler",
+  "fcntl",
+  "filecmp",
+  "fileinput",
+  "fnmatch",
+  "fractions",
+  "ftplib",
+  "functools",
+  "gc",
+  "getopt",
+  "getpass",
+  "gettext",
+  "glob",
+  "graphlib",
+  "grp",
+  "gzip",
+  "hashlib",
+  "heapq",
+  "hmac",
+  "html",
+  "http",
+  "imaplib",
+  "importlib",
+  "inspect",
+  "io",
+  "ipaddress",
+  "itertools",
+  "json",
+  "keyword",
+  "locale",
+  "logging",
+  "lzma",
+  "mailbox",
+  "marshal",
+  "math",
+  "mimetypes",
+  "mmap",
+  "msvcrt",
+  "multiprocessing",
+  "operator",
+  "os",
+  "pathlib",
+  "pdb",
+  "pickle",
+  "pickletools",
+  "pkgutil",
+  "platform",
+  "plistlib",
+  "poplib",
+  "posix",
+  "pprint",
+  "profile",
+  "pstats",
+  "pty",
+  "pwd",
+  "py_compile",
+  "pyclbr",
+  "pydoc",
+  "queue",
+  "quopri",
+  "random",
+  "re",
+  "readline",
+  "reprlib",
+  "resource",
+  "rlcompleter",
+  "runpy",
+  "sched",
+  "secrets",
+  "select",
+  "selectors",
+  "shelve",
+  "shlex",
+  "shutil",
+  "signal",
+  "site",
+  "smtplib",
+  "socket",
+  "socketserver",
+  "sqlite3",
+  "ssl",
+  "stat",
+  "statistics",
+  "string",
+  "stringprep",
+  "struct",
+  "subprocess",
+  "symtable",
+  "sys",
+  "sysconfig",
+  "syslog",
+  "tarfile",
+  "telnetlib",
+  "tempfile",
+  "termios",
+  "test",
+  "textwrap",
+  "threading",
+  "time",
+  "timeit",
+  "tkinter",
+  "token",
+  "tokenize",
+  "tomllib",
+  "trace",
+  "traceback",
+  "tracemalloc",
+  "tty",
+  "turtle",
+  "types",
+  "typing",
+  "unicodedata",
+  "unittest",
+  "urllib",
+  "uuid",
+  "venv",
+  "warnings",
+  "wave",
+  "weakref",
+  "webbrowser",
+  "winreg",
+  "winsound",
+  "wsgiref",
+  "xml",
+  "xmlrpc",
+  "zipapp",
+  "zipfile",
+  "zipimport",
+  "zlib",
+  "zoneinfo"
+]);
 function resolvePythonSpecifier(fromPath, specifier, trackedPaths) {
   const dotsMatch = specifier.match(/^\.+/);
-  if (!dotsMatch) return null;
-  const level = dotsMatch[0].length;
-  const segments = specifier.slice(level).split(".").filter(Boolean);
+  const level = dotsMatch ? dotsMatch[0].length : 0;
+  if (level === 0 && STDLIB_MODULES.has(specifier)) return null;
+  const segments = (level === 0 ? specifier : specifier.slice(level)).split(".").filter(Boolean);
   if (segments.length === 0) return null;
   let dir = posix5.dirname(fromPath);
   for (let i = 1; i < level; i++) {
@@ -5602,6 +5787,81 @@ ${pc17.bold(String(edges.length))} edge(s) from ${filesScanned} tracked ${TRACKE
 
 // src/cli/commands/stale.ts
 import pc18 from "picocolors";
+
+// src/slm/contradiction.ts
+var MAX_BODY_CHARS = 1500;
+var MAX_REASON_CHARS = 200;
+var CONTRADICTION_INSTRUCTIONS = `You are checking whether a NEWER memory replaces or contradicts an OLDER one, for an AI coding assistant's memory index.
+
+Answer in exactly this shape:
+VERDICT: YES or NO
+REASON: <one line, under 20 words>
+
+Say YES only if the NEWER memory states something that makes the OLDER one factually wrong or obsolete -- a decision reversed, a bug fixed, a plan abandoned. Say NO if they are about different things, or the newer one only adds detail without contradicting the older one. When unsure, say NO.`;
+function buildContradictionPrompt(older, newer) {
+  const body = [
+    `OLDER (${older.title}):`,
+    truncate(older.body, MAX_BODY_CHARS),
+    "",
+    `NEWER (${newer.title}):`,
+    truncate(newer.body, MAX_BODY_CHARS)
+  ].join("\n");
+  return `${CONTRADICTION_INSTRUCTIONS}
+
+---
+
+${body}
+
+---
+
+Answer:`;
+}
+function parseContradictionVerdict(raw) {
+  const lines = raw.trim().split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
+  const verdictLine = lines.find((l) => /^VERDICT:/i.test(l));
+  if (!verdictLine) return null;
+  const verdict = /^VERDICT:\s*(YES|NO)\b/i.exec(verdictLine);
+  if (!verdict) return null;
+  const reasonLine = lines.find((l) => /^REASON:/i.test(l));
+  const reason = reasonLine ? reasonLine.replace(/^REASON:\s*/i, "").trim() : "";
+  return {
+    contradicts: verdict[1].toUpperCase() === "YES",
+    reason: truncate(reason, MAX_REASON_CHARS)
+  };
+}
+
+// src/retrieval/contradiction.ts
+var DEFAULT_LIMIT = 10;
+var DEFAULT_NEIGHBOR_LIMIT = 25;
+async function checkContradictions(store, embeddingProvider, slmProvider, projectId, candidates, opts = {}) {
+  const limit = opts.limit ?? DEFAULT_LIMIT;
+  const neighborLimit = opts.neighborLimit ?? DEFAULT_NEIGHBOR_LIMIT;
+  const suggestions = [];
+  for (const candidate of candidates.slice(0, limit)) {
+    const full = store.getNodesByIds([candidate.id])[0];
+    if (!full) continue;
+    const embedding = await embeddingProvider.embed(`${full.title}
+${full.body}`);
+    if (!embedding) continue;
+    const candidateEpoch = Date.parse(candidate.ts);
+    const nearest = store.vectorSearch(projectId, embedding, neighborLimit + 1).find((hit) => hit.id !== candidate.id && Date.parse(hit.ts) > candidateEpoch);
+    if (!nearest) continue;
+    const reply = await slmProvider.complete(buildContradictionPrompt(full, nearest));
+    if (!reply) continue;
+    const verdict = parseContradictionVerdict(reply);
+    if (!verdict?.contradicts) continue;
+    suggestions.push({
+      candidateId: candidate.id,
+      againstId: nearest.id,
+      againstTitle: nearest.title,
+      reason: verdict.reason
+    });
+  }
+  return suggestions;
+}
+
+// src/cli/commands/stale.ts
+var STALE_DEFAULT_MODEL = DEFAULT_SLM_MODEL;
 async function runStale(opts) {
   const { projectId, ws } = await loadContext(opts.cwd);
   const out = opts.out ?? ((chunk2) => void process.stdout.write(chunk2));
@@ -5613,12 +5873,26 @@ async function runStale(opts) {
 `);
       return 0;
     }
+    let suggestions = [];
+    if (opts.checkContradictions) {
+      suggestions = await checkContradictions(
+        store,
+        new OllamaEmbeddingProvider(),
+        new OllamaChatProvider({ model: opts.model ?? DEFAULT_SLM_MODEL }),
+        projectId,
+        candidates
+      );
+    }
+    const byCandidateId = new Map(suggestions.map((s) => [s.candidateId, s]));
     out(
       [
         `${pc18.bold(String(candidates.length))} stale candidate(s) -- oldest first, none of these were changed:`,
-        ...candidates.map(
-          (c) => `  ${pc18.dim(c.id)} ${pc18.yellow(`${c.ageDays}d old`)} [${c.kind}] ${c.title}`
-        ),
+        ...candidates.map((c) => {
+          const line = `  ${pc18.dim(c.id)} ${pc18.yellow(`${c.ageDays}d old`)} [${c.kind}] ${c.title}`;
+          const hit = byCandidateId.get(c.id);
+          return hit ? `${line}
+    ${pc18.red("likely superseded by")} ${pc18.dim(hit.againstId)} ${hit.againstTitle} -- ${hit.reason}` : line;
+        }),
         "",
         `run ${pc18.bold("nexusmem mark-stale <id> --supersedes <newId>")} on any that are actually wrong`
       ].join("\n").concat("\n")
@@ -5839,8 +6113,19 @@ program.command("mark-stale").description(
 ).argument("<nodeId>", "id of the node to mark stale").requiredOption("--supersedes <newNodeId>", "id of the node that supersedes it").option("-C, --cwd <path>", "repository path", process.cwd()).action(
   (nodeId, options) => guard(() => runMarkStale({ cwd: options.cwd, nodeId, supersedesId: options.supersedes }))()
 );
-program.command("stale").description("List inferred nodes old enough to be worth double-checking (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).option("--min-age-days <days>", "only nodes at least this old", (v) => Number.parseFloat(v)).option("-n, --limit <count>", "stop after N candidates", (v) => Number.parseInt(v, 10)).action(
-  (options) => guard(() => runStale({ cwd: options.cwd, minAgeDays: options.minAgeDays, limit: options.limit }))()
+program.command("stale").description("List inferred nodes old enough to be worth double-checking (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).option("--min-age-days <days>", "only nodes at least this old", (v) => Number.parseFloat(v)).option("-n, --limit <count>", "stop after N candidates", (v) => Number.parseInt(v, 10)).option(
+  "--check-contradictions",
+  "ask the local SLM whether a similar newer node actually contradicts each candidate (needs Ollama)"
+).option("--model <name>", "Ollama chat model for --check-contradictions", STALE_DEFAULT_MODEL).action(
+  (options) => guard(
+    () => runStale({
+      cwd: options.cwd,
+      minAgeDays: options.minAgeDays,
+      limit: options.limit,
+      checkContradictions: options.checkContradictions,
+      model: options.model
+    })
+  )()
 );
 program.command("projects").description("List the repositories `query --all-projects` would search").option("--prune", "forget registered projects whose database is no longer on disk", false).option("--json", "emit the registry as JSON on stdout", false).action((options) => guard(() => runProjects({ prune: options.prune, json: options.json }))());
 program.command("scan-git").description("Preview the MemoryNodes git history would produce (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).option("--since <date>", "only commits newer than this git date expression, e.g. 90.days.ago").option("-n, --limit <count>", "stop after N commits", (v) => Number.parseInt(v, 10)).option("--no-merges", "skip merge commits").option("--min-signal <score>", "drop nodes below this signal", (v) => Number.parseFloat(v), 0).option("--json", "emit MemoryNodes as JSON on stdout", false).action(
@@ -5898,7 +6183,7 @@ program.command("precheck").description("Warn about staged files with unresolved
     })
   )()
 );
-program.command("scan-structure").description("Preview the JS/TS/Python import-graph edges a sync would produce (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).option("--json", "emit edges as JSON on stdout", false).action((options) => guard(() => runScanStructure({ cwd: options.cwd, json: options.json }))());
+program.command("scan-structure").description("Preview the JS/TS/Python/Go/Rust/Java/PHP import-graph edges a sync would produce (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).option("--json", "emit edges as JSON on stdout", false).action((options) => guard(() => runScanStructure({ cwd: options.cwd, json: options.json }))());
 program.command("mcp").description("Start the MCP server (stdio transport) for Claude Desktop, Cursor, Windsurf, etc.").action(() => guard(() => runMcpServer().then(() => 0))());
 program.parseAsync(process.argv).catch((err) => {
   const message = err instanceof Error ? err.message : String(err);