memoir-cli 3.11.3 → 3.14.0

package/src/memory/lexical-index.js

@@ -0,0 +1,65 @@
+// Rebuildable, process-local postings. Canonical files remain authoritative;
+// nothing is persisted or trusted across a filesystem refresh or scope change.
+export class LexicalIndex {
+  constructor() { this.clear(); }
+
+  clear() {
+    this.documents = new Set();
+    this.postings = new Map();
+    this.tokensByDocument = new Map();
+    this.vocabulary = null;
+  }
+
+  sync(documents) {
+    const current = new Set(documents);
+    for (const doc of this.documents) {
+      if (current.has(doc)) continue;
+      for (const token of this.tokensByDocument.get(doc)) {
+        const posting = this.postings.get(token);
+        posting.delete(doc);
+        if (!posting.size) { this.postings.delete(token); this.vocabulary = null; }
+      }
+      this.tokensByDocument.delete(doc);
+    }
+    for (const doc of current) {
+      if (this.documents.has(doc)) continue;
+      const tokens = new Set(Object.values(doc.tf).flatMap(field => [...field.keys()]));
+      this.tokensByDocument.set(doc, tokens);
+      for (const token of tokens) {
+        if (!this.postings.has(token)) { this.postings.set(token, new Set()); this.vocabulary = null; }
+        this.postings.get(token).add(doc);
+      }
+    }
+    this.documents = current;
+  }
+
+  lookup(terms) {
+    if (!this.vocabulary) this.vocabulary = [...this.postings.keys()].sort();
+    const documents = new Set();
+    const matches = new Map();
+    for (const term of terms) {
+      const tokens = new Map();
+      if (this.postings.has(term)) tokens.set(term, 1);
+      if (term.length >= 4) {
+        // Binary seek to query-prefix matches; no full vocabulary scan.
+        let lo = 0, hi = this.vocabulary.length;
+        while (lo < hi) {
+          const mid = (lo + hi) >>> 1;
+          if (this.vocabulary[mid] < term) lo = mid + 1; else hi = mid;
+        }
+        for (let i = lo; i < this.vocabulary.length && this.vocabulary[i].startsWith(term); i++) {
+          const token = this.vocabulary[i];
+          if (token !== term) tokens.set(token, .6);
+        }
+        // The reference scorer also allows a document token to prefix the query.
+        for (let n = 4; n < term.length; n++) {
+          const token = term.slice(0, n);
+          if (this.postings.has(token)) tokens.set(token, .6);
+        }
+      }
+      matches.set(term, tokens);
+      for (const token of tokens.keys()) for (const doc of this.postings.get(token)) documents.add(doc);
+    }
+    return { documents, matches };
+  }
+}

package/src/memory/repository.js

@@ -0,0 +1,16 @@
+import { execFileSync } from 'node:child_process';
+
+export function repositoryState(project) {
+  const run = args => execFileSync('git', args, { cwd: project, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000 }).trim();
+  try {
+    return {
+      root: run(['rev-parse', '--show-toplevel']),
+      head: run(['rev-parse', 'HEAD']),
+      branch: run(['branch', '--show-current']) || '(detached)',
+      // git status can execute fsmonitor hooks and clean filters from project
+      // configuration. Reading a memory record must not run that code. File
+      // hashes provide scoped check freshness; report overall dirtiness unknown.
+      dirty: null,
+    };
+  } catch { return { root: project, head: null, branch: null, dirty: null }; }
+}

package/src/memory/scope.js

@@ -0,0 +1,65 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+import { execFileSync } from 'child_process';
+
+const cache = new Map();
+export function projectIdentity(project = process.env.MEMOIR_PROJECT_ROOT || process.cwd()) {
+  if (project === 'shared') return 'shared';
+  if (/^(git|local):[a-f0-9]{32}$/.test(project)) return project;
+  let absolute = path.resolve(project.replace(/^~/, os.homedir()));
+  try { absolute = fs.realpathSync(absolute); } catch {}
+  const old = cache.get(absolute);
+  if (old && Date.now() - old.at < 60_000) return old.id;
+  let home = os.homedir();
+  try { home = fs.realpathSync(home); } catch {}
+  let key = path.relative(home, absolute).replace(/\\/g, '/');
+  let kind = 'local';
+  try {
+    const remote = execFileSync('git', ['config', '--get', 'remote.origin.url'], { cwd: absolute, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 2000 }).trim();
+    if (remote) {
+      // Normalize common SSH/HTTPS spellings; never persist embedded credentials.
+      key = remote.replace(/^git@([^:]+):/, '$1/').replace(/^https?:\/\/(?:[^/@]+@)?/, '').replace(/^ssh:\/\/git@/, '').replace(/\.git\/?$/, '').replace(/\/$/, '');
+      kind = 'git';
+    }
+  } catch {}
+  const id = kind + ':' + crypto.createHash('sha256').update(key).digest('hex').slice(0, 32);
+  cache.set(absolute, { id, at: Date.now() });
+  return id;
+}
+
+// Resolve project paths once per query, not once for every stored record.
+// A new predicate is created on each query so time-based validity is current.
+export function memoryVisibility({ project = process.env.MEMOIR_PROJECT_ROOT || process.cwd(), allProjects = false, now = Date.now() } = {}) {
+  let activeId, currentKey, sharedKey;
+  const identities = new Map();
+  return item => {
+    if (!item || item.hidden === true || item.hidden === 'true' || item.deleted === true || ['deleted', 'hidden', 'superseded'].includes(item.status) || item.superseded_by) return false;
+    if (item.valid_from && Date.parse(item.valid_from) > now) return false;
+    if (item.valid_until && Date.parse(item.valid_until) <= now) return false;
+    if (!allProjects && item.claudeProjectKey) {
+      currentKey ??= path.resolve(project.replace(/^~/, os.homedir())).replace(/[\\/:]/g, '-');
+      sharedKey ??= os.homedir().replace(/[\\/:]/g, '-');
+      if (item.claudeProjectKey !== currentKey && item.claudeProjectKey !== sharedKey) return false;
+    }
+    if (allProjects || !item.project || item.project === 'shared') return true;
+    activeId ??= projectIdentity(project);
+    const key = String(item.project);
+    if (!identities.has(key)) identities.set(key, projectIdentity(key));
+    return identities.get(key) === activeId;
+  };
+}
+
+export function visibleMemory(item, options = {}) {
+  return memoryVisibility(options)(item);
+}
+
+export function sessionView(state, options = {}) {
+  const current = { ...(state?.current || {}) };
+  for (const key of ['goals', 'next_actions', 'parked_actions', 'open_questions', 'decisions']) {
+    const archived = { goals: 'archived_goals', decisions: 'archived_decisions', open_questions: 'archived_questions' }[key];
+    current[key] = [...(current[key] || []), ...(archived ? current[archived] || [] : [])].filter(item => visibleMemory(item, options));
+  }
+  return { ...state, current, history: (state?.history || []).filter(item => visibleMemory(item, options)) };
+}