memorix 1.1.10 → 1.1.12

package/src/cli/update-checker.ts

@@ -9,85 +9,85 @@
  * Set MEMORIX_AUTO_UPDATE=install to opt into silent background install.
  * Disable via MEMORIX_AUTO_UPDATE=off.
  */
-
-import { execFile } from 'node:child_process';
-import type { ExecFileException } from 'node:child_process';
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-import { getCliVersion } from './version.js';
-
-const PACKAGE_NAME = 'memorix';
-const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
-const DEFAULT_AUTO_UPDATE_TIMEOUT_MS = 5 * 60 * 1000;
-const MIN_AUTO_UPDATE_TIMEOUT_MS = 5_000;
-const MAX_AUTO_UPDATE_TIMEOUT_MS = 30 * 60 * 1000;
-const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
-const CACHE_DIR = join(homedir(), '.memorix');
-const CACHE_FILE = join(CACHE_DIR, 'update-check.json');
-
+
+import { execFile } from 'node:child_process';
+import type { ExecFileException } from 'node:child_process';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { getCliVersion } from './version.js';
+
+const PACKAGE_NAME = 'memorix';
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const DEFAULT_AUTO_UPDATE_TIMEOUT_MS = 5 * 60 * 1000;
+const MIN_AUTO_UPDATE_TIMEOUT_MS = 5_000;
+const MAX_AUTO_UPDATE_TIMEOUT_MS = 30 * 60 * 1000;
+const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+const CACHE_DIR = join(homedir(), '.memorix');
+const CACHE_FILE = join(CACHE_DIR, 'update-check.json');
+
 export interface UpdateCache {
-  lastCheck: number;
-  latestVersion: string;
-  lastAutoUpdate?: number;
-  lastAutoUpdateStatus?: 'success' | 'failed';
-  lastAutoUpdateError?: string;
-  lastAutoUpdateTimedOut?: boolean;
-  lastAutoUpdateExitCode?: number | null;
-  lastAutoUpdateSignal?: string | null;
-  lastAutoUpdateTimeoutMs?: number;
-  updatedFrom?: string;
-  updatedTo?: string;
+  lastCheck: number;
+  latestVersion: string;
+  lastAutoUpdate?: number;
+  lastAutoUpdateStatus?: 'success' | 'failed';
+  lastAutoUpdateError?: string;
+  lastAutoUpdateTimedOut?: boolean;
+  lastAutoUpdateExitCode?: number | null;
+  lastAutoUpdateSignal?: string | null;
+  lastAutoUpdateTimeoutMs?: number;
+  updatedFrom?: string;
+  updatedTo?: string;
 }
 
 export type AutoUpdateMode = 'off' | 'notify' | 'install';
-
-/**
- * Get the current installed version from package.json.
- */
-export function getCurrentVersion(): string {
-  try {
-    return getCliVersion();
-  } catch {
-    return '0.0.0';
-  }
-}
-
-/**
- * Compare two semver strings. Returns true if remote > local.
- */
-export function isNewer(remote: string, local: string): boolean {
-  const r = remote.split('.').map(Number);
-  const l = local.split('.').map(Number);
-  for (let i = 0; i < 3; i++) {
-    if ((r[i] ?? 0) > (l[i] ?? 0)) return true;
-    if ((r[i] ?? 0) < (l[i] ?? 0)) return false;
-  }
-  return false;
-}
-
-/**
- * Read the update check cache. Exported for doctor/status display.
- */
-export async function readCache(): Promise<UpdateCache | null> {
-  try {
-    const data = await readFile(CACHE_FILE, 'utf-8');
-    return JSON.parse(data);
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Write the update check cache.
- */
-async function writeCache(cache: UpdateCache): Promise<void> {
-  try {
-    await mkdir(CACHE_DIR, { recursive: true });
-    await writeFile(CACHE_FILE, JSON.stringify(cache, null, 2), 'utf-8');
-  } catch { /* silent */ }
-}
-
+
+/**
+ * Get the current installed version from package.json.
+ */
+export function getCurrentVersion(): string {
+  try {
+    return getCliVersion();
+  } catch {
+    return '0.0.0';
+  }
+}
+
+/**
+ * Compare two semver strings. Returns true if remote > local.
+ */
+export function isNewer(remote: string, local: string): boolean {
+  const r = remote.split('.').map(Number);
+  const l = local.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((r[i] ?? 0) > (l[i] ?? 0)) return true;
+    if ((r[i] ?? 0) < (l[i] ?? 0)) return false;
+  }
+  return false;
+}
+
+/**
+ * Read the update check cache. Exported for doctor/status display.
+ */
+export async function readCache(): Promise<UpdateCache | null> {
+  try {
+    const data = await readFile(CACHE_FILE, 'utf-8');
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Write the update check cache.
+ */
+async function writeCache(cache: UpdateCache): Promise<void> {
+  try {
+    await mkdir(CACHE_DIR, { recursive: true });
+    await writeFile(CACHE_FILE, JSON.stringify(cache, null, 2), 'utf-8');
+  } catch { /* silent */ }
+}
+
 /**
  * Parse MEMORIX_AUTO_UPDATE into an explicit mode.
  * Default: notify-only.
@@ -99,105 +99,105 @@ function parseAutoUpdateMode(raw: string | undefined): AutoUpdateMode {
   if (env === 'install' || env === 'true' || env === '1') return 'install';
   return 'notify';
 }
-
-function parseAutoUpdateTimeoutMs(raw: string | undefined): number {
-  const value = raw?.trim();
-  if (!value) return DEFAULT_AUTO_UPDATE_TIMEOUT_MS;
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed)) return DEFAULT_AUTO_UPDATE_TIMEOUT_MS;
-  return Math.max(MIN_AUTO_UPDATE_TIMEOUT_MS, Math.min(MAX_AUTO_UPDATE_TIMEOUT_MS, Math.floor(parsed)));
-}
-
-function describeAutoUpdateFailure(error: ExecFileException, timeoutMs: number): {
-  message: string;
-  timedOut: boolean;
-  exitCode: number | null;
-  signal: string | null;
-} {
-  const timedOut = /timed out/i.test(error.message);
-  const exitCode = typeof error.code === 'number' ? error.code : null;
-  const signal = typeof error.signal === 'string' ? error.signal : null;
-  const details: string[] = [];
-  if (timedOut) details.push(`timeout ${timeoutMs}ms`);
-  if (exitCode !== null) details.push(`exit code ${exitCode}`);
-  if (signal) details.push(`signal ${signal}`);
-  return {
-    message: details.length > 0 ? `${error.message} (${details.join(', ')})` : error.message,
-    timedOut,
-    exitCode,
-    signal,
-  };
-}
-
-/**
- * Fetch the latest version from npm registry.
- * Uses native https to avoid dependencies. Timeout: 5s.
- */
-async function fetchLatestVersion(): Promise<string | null> {
-  try {
-    const { default: https } = await import('node:https');
-    return new Promise((resolve) => {
-      const req = https.get(REGISTRY_URL, { timeout: 5000 }, (res) => {
-        if (res.statusCode !== 200) { resolve(null); return; }
-        let body = '';
-        res.on('data', (chunk: Buffer) => { body += chunk.toString(); });
-        res.on('end', () => {
-          try {
-            const data = JSON.parse(body);
-            resolve(data.version ?? null);
-          } catch { resolve(null); }
-        });
-      });
-      req.on('error', () => resolve(null));
-      req.on('timeout', () => { req.destroy(); resolve(null); });
-    });
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Silently install the latest version in the background.
- * Writes result to the cache file so doctor/status can report it.
- */
-function installUpdateInBackground(targetVersion: string, currentVersion: string, cache: UpdateCache): void {
-  try {
-    const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-    const timeoutMs = parseAutoUpdateTimeoutMs(process.env.MEMORIX_AUTO_UPDATE_TIMEOUT_MS);
-    const child = execFile(
-      npmCmd,
-      ['install', '-g', `${PACKAGE_NAME}@${targetVersion}`],
-      { timeout: timeoutMs },
-      async (error) => {
-        const failure = error ? describeAutoUpdateFailure(error, timeoutMs) : null;
-        const updatedCache: UpdateCache = {
-          ...cache,
-          lastAutoUpdate: Date.now(),
-          updatedFrom: currentVersion,
-          updatedTo: targetVersion,
-          lastAutoUpdateStatus: error ? 'failed' : 'success',
-          lastAutoUpdateError: failure?.message,
-          lastAutoUpdateTimedOut: failure?.timedOut,
-          lastAutoUpdateExitCode: failure?.exitCode,
-          lastAutoUpdateSignal: failure?.signal,
-          lastAutoUpdateTimeoutMs: timeoutMs,
-        };
-        await writeCache(updatedCache);
-        if (error) {
-          console.error(`[memorix] Auto-update failed: ${failure?.message ?? error.message}`);
-        } else {
-          console.error(`[memorix] Auto-updated to v${targetVersion} — restart to apply`);
-        }
-      },
-    );
-    // Unref so the child process doesn't prevent the main process from exiting
-    child.unref();
-  } catch (err) {
-    console.error(`[memorix] Auto-update spawn failed:`, (err as Error)?.message ?? err);
-  }
-}
-
-/**
+
+function parseAutoUpdateTimeoutMs(raw: string | undefined): number {
+  const value = raw?.trim();
+  if (!value) return DEFAULT_AUTO_UPDATE_TIMEOUT_MS;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return DEFAULT_AUTO_UPDATE_TIMEOUT_MS;
+  return Math.max(MIN_AUTO_UPDATE_TIMEOUT_MS, Math.min(MAX_AUTO_UPDATE_TIMEOUT_MS, Math.floor(parsed)));
+}
+
+function describeAutoUpdateFailure(error: ExecFileException, timeoutMs: number): {
+  message: string;
+  timedOut: boolean;
+  exitCode: number | null;
+  signal: string | null;
+} {
+  const timedOut = /timed out/i.test(error.message);
+  const exitCode = typeof error.code === 'number' ? error.code : null;
+  const signal = typeof error.signal === 'string' ? error.signal : null;
+  const details: string[] = [];
+  if (timedOut) details.push(`timeout ${timeoutMs}ms`);
+  if (exitCode !== null) details.push(`exit code ${exitCode}`);
+  if (signal) details.push(`signal ${signal}`);
+  return {
+    message: details.length > 0 ? `${error.message} (${details.join(', ')})` : error.message,
+    timedOut,
+    exitCode,
+    signal,
+  };
+}
+
+/**
+ * Fetch the latest version from npm registry.
+ * Uses native https to avoid dependencies. Timeout: 5s.
+ */
+async function fetchLatestVersion(): Promise<string | null> {
+  try {
+    const { default: https } = await import('node:https');
+    return new Promise((resolve) => {
+      const req = https.get(REGISTRY_URL, { timeout: 5000 }, (res) => {
+        if (res.statusCode !== 200) { resolve(null); return; }
+        let body = '';
+        res.on('data', (chunk: Buffer) => { body += chunk.toString(); });
+        res.on('end', () => {
+          try {
+            const data = JSON.parse(body);
+            resolve(data.version ?? null);
+          } catch { resolve(null); }
+        });
+      });
+      req.on('error', () => resolve(null));
+      req.on('timeout', () => { req.destroy(); resolve(null); });
+    });
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Silently install the latest version in the background.
+ * Writes result to the cache file so doctor/status can report it.
+ */
+function installUpdateInBackground(targetVersion: string, currentVersion: string, cache: UpdateCache): void {
+  try {
+    const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const timeoutMs = parseAutoUpdateTimeoutMs(process.env.MEMORIX_AUTO_UPDATE_TIMEOUT_MS);
+    const child = execFile(
+      npmCmd,
+      ['install', '-g', `${PACKAGE_NAME}@${targetVersion}`],
+      { timeout: timeoutMs },
+      async (error) => {
+        const failure = error ? describeAutoUpdateFailure(error, timeoutMs) : null;
+        const updatedCache: UpdateCache = {
+          ...cache,
+          lastAutoUpdate: Date.now(),
+          updatedFrom: currentVersion,
+          updatedTo: targetVersion,
+          lastAutoUpdateStatus: error ? 'failed' : 'success',
+          lastAutoUpdateError: failure?.message,
+          lastAutoUpdateTimedOut: failure?.timedOut,
+          lastAutoUpdateExitCode: failure?.exitCode,
+          lastAutoUpdateSignal: failure?.signal,
+          lastAutoUpdateTimeoutMs: timeoutMs,
+        };
+        await writeCache(updatedCache);
+        if (error) {
+          console.error(`[memorix] Auto-update failed: ${failure?.message ?? error.message}`);
+        } else {
+          console.error(`[memorix] Auto-updated to v${targetVersion} — restart to apply`);
+        }
+      },
+    );
+    // Unref so the child process doesn't prevent the main process from exiting
+    child.unref();
+  } catch (err) {
+    console.error(`[memorix] Auto-update spawn failed:`, (err as Error)?.message ?? err);
+  }
+}
+
+/**
  * Run the background update check.
  *
  * Call this fire-and-forget from entry points (serve-http, TUI).
@@ -215,32 +215,32 @@ export async function checkForUpdates(): Promise<void> {
 
     const cache = await readCache();
     const now = Date.now();
-
-    // Rate limit: skip if checked within the last 24 hours
-    if (cache && (now - cache.lastCheck) < CHECK_INTERVAL_MS) {
-      return;
-    }
-
-    const latestVersion = await fetchLatestVersion();
-    if (!latestVersion) return;
-
-    const currentVersion = getCurrentVersion();
-
-    // Update cache with check timestamp
-    const updatedCache: UpdateCache = {
-      lastCheck: now,
-      latestVersion,
-      lastAutoUpdate: cache?.lastAutoUpdate,
-      lastAutoUpdateStatus: cache?.lastAutoUpdateStatus,
-      lastAutoUpdateError: cache?.lastAutoUpdateError,
-      lastAutoUpdateTimedOut: cache?.lastAutoUpdateTimedOut,
-      lastAutoUpdateExitCode: cache?.lastAutoUpdateExitCode,
-      lastAutoUpdateSignal: cache?.lastAutoUpdateSignal,
-      lastAutoUpdateTimeoutMs: cache?.lastAutoUpdateTimeoutMs,
-      updatedFrom: cache?.updatedFrom,
-      updatedTo: cache?.updatedTo,
-    };
-    await writeCache(updatedCache);
+
+    // Rate limit: skip if checked within the last 24 hours
+    if (cache && (now - cache.lastCheck) < CHECK_INTERVAL_MS) {
+      return;
+    }
+
+    const latestVersion = await fetchLatestVersion();
+    if (!latestVersion) return;
+
+    const currentVersion = getCurrentVersion();
+
+    // Update cache with check timestamp
+    const updatedCache: UpdateCache = {
+      lastCheck: now,
+      latestVersion,
+      lastAutoUpdate: cache?.lastAutoUpdate,
+      lastAutoUpdateStatus: cache?.lastAutoUpdateStatus,
+      lastAutoUpdateError: cache?.lastAutoUpdateError,
+      lastAutoUpdateTimedOut: cache?.lastAutoUpdateTimedOut,
+      lastAutoUpdateExitCode: cache?.lastAutoUpdateExitCode,
+      lastAutoUpdateSignal: cache?.lastAutoUpdateSignal,
+      lastAutoUpdateTimeoutMs: cache?.lastAutoUpdateTimeoutMs,
+      updatedFrom: cache?.updatedFrom,
+      updatedTo: cache?.updatedTo,
+    };
+    await writeCache(updatedCache);
 
     if (isNewer(latestVersion, currentVersion)) {
       if (mode === 'install') {
@@ -254,12 +254,12 @@ export async function checkForUpdates(): Promise<void> {
     }
   } catch {
     // Entire update check is best-effort — never crash the caller
-  }
-}
-
-// ── Test helpers (exported for testing only) ──────────────────
-
-/** @internal */
+  }
+}
+
+// ── Test helpers (exported for testing only) ──────────────────
+
+/** @internal */
 export const _testing = {
   CACHE_FILE,
   CHECK_INTERVAL_MS,
@@ -268,8 +268,8 @@ export const _testing = {
   parseAutoUpdateTimeoutMs,
   describeAutoUpdateFailure,
   fetchLatestVersion,
-  installUpdateInBackground,
-  writeCache,
-  isNewer,
-  getCurrentVersion,
-};
+  installUpdateInBackground,
+  writeCache,
+  isNewer,
+  getCurrentVersion,
+};

package/src/cli/version.ts

@@ -1,7 +1,7 @@
-import pkg from '../../package.json';
-
-export function getCliVersion(): string {
-  return typeof __MEMORIX_VERSION__ !== 'undefined'
-    ? __MEMORIX_VERSION__
-    : pkg.version;
-}
+import pkg from '../../package.json';
+
+export function getCliVersion(): string {
+  return typeof __MEMORIX_VERSION__ !== 'undefined'
+    ? __MEMORIX_VERSION__
+    : pkg.version;
+}

package/src/cli/workbench.ts

@@ -5,4 +5,4 @@
  * Kept for backward-compat: `import { startWorkbench } from './workbench.js'`
  */
 
-export { startWorkbench } from './tui/index.js';
+export { startWorkbench } from './tui/index.js';

package/src/codegraph/auto-context.ts

@@ -4,7 +4,7 @@ import { getResolvedConfig } from '../config/resolved-config.js';
 import type { ProjectInfo } from '../types.js';
 import { backfillMissingObservationCodeRefs, type CodeRefBackfillResult } from './binder.js';
 import { collectCurrentProjectFacts, type CurrentProjectFacts } from './current-facts.js';
-import { indexProjectLite } from './lite-provider.js';
+import { refreshProjectLite } from './lite-provider.js';
 import {
   buildProjectContextExplain,
   type ProjectContextExplain,
@@ -27,7 +27,7 @@ export type AutoContextRefreshMode = 'auto' | 'always' | 'never';
 export interface AutoContextRefreshResult {
   mode: AutoContextRefreshMode;
   performed: boolean;
-  reason: 'forced' | 'empty-index' | 'missing-scan-time' | 'stale-index' | 'fresh-enough' | 'disabled' | 'failed';
+  reason: 'forced' | 'empty-index' | 'missing-scan-time' | 'stale-index' | 'fresh-enough' | 'disabled' | 'queued' | 'failed';
   message: string;
   backfill?: CodeRefBackfillResult;
 }
@@ -101,12 +101,20 @@ export async function buildAutoProjectContext(input: {
   maxAgeMs?: number;
   now?: Date;
   exclude?: string[];
+  maxFileBytes?: number;
+  /**
+   * When supplied, a needed refresh is queued instead of running in this
+   * request. MCP and hook callers use this to keep their response path fast.
+   */
+  enqueueRefresh?: () => void | Promise<void>;
 }): Promise<AutoProjectContext> {
   const refreshMode = input.refresh ?? 'auto';
   const now = input.now ?? new Date();
   const task = input.task?.trim();
   const lens = resolveTaskLens(task);
-  const exclude = input.exclude ?? getResolvedConfig({ projectRoot: input.project.rootPath }).codegraph.excludePatterns;
+  const codegraphConfig = getResolvedConfig({ projectRoot: input.project.rootPath }).codegraph;
+  const exclude = input.exclude ?? codegraphConfig.excludePatterns;
+  const maxFileBytes = input.maxFileBytes ?? codegraphConfig.maxFileBytes;
   const store = new CodeGraphStore();
   await store.init(input.dataDir);
 
@@ -124,25 +132,44 @@ export async function buildAutoProjectContext(input: {
   };
 
   if (decision.performed) {
-    try {
-      const indexed = await indexProjectLite({
-        projectId: input.project.id,
-        projectRoot: input.project.rootPath,
-        exclude,
-      });
-      store.replaceProjectIndex(input.project.id, indexed);
-      const backfill = await backfillMissingObservationCodeRefs(
-        store,
-        activeProjectObservations(input.observations, input.project.id) as any,
-      );
-      refresh = { ...refresh, backfill };
-    } catch (error) {
-      refresh = {
-        mode: refreshMode,
-        performed: false,
-        reason: 'failed',
-        message: `Project scan failed: ${error instanceof Error ? error.message : String(error)}`,
-      };
+    if (input.enqueueRefresh) {
+      try {
+        await input.enqueueRefresh();
+        refresh = {
+          mode: refreshMode,
+          performed: false,
+          reason: 'queued',
+          message: 'Code Memory refresh queued; this brief uses the latest completed scan.',
+        };
+      } catch (error) {
+        refresh = {
+          mode: refreshMode,
+          performed: false,
+          reason: 'failed',
+          message: `Could not queue Code Memory refresh: ${error instanceof Error ? error.message : String(error)}`,
+        };
+      }
+    } else {
+      try {
+        await refreshProjectLite(store, {
+          projectId: input.project.id,
+          projectRoot: input.project.rootPath,
+          exclude,
+          maxFileBytes,
+        });
+        const backfill = await backfillMissingObservationCodeRefs(
+          store,
+          activeProjectObservations(input.observations, input.project.id) as any,
+        );
+        refresh = { ...refresh, backfill };
+      } catch (error) {
+        refresh = {
+          mode: refreshMode,
+          performed: false,
+          reason: 'failed',
+          message: `Project scan failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+      }
     }
   }
 

package/src/codegraph/exclude.ts

@@ -9,6 +9,16 @@ export const DEFAULT_CODEGRAPH_EXCLUDES = [
   '.tmp/**',
   '.worktrees/**',
   '.claude/worktrees/**',
+  'vendor/**',
+  '.venv/**',
+  'venv/**',
+  '.tox/**',
+  'target/**',
+  '.gradle/**',
+  '.mvn/**',
+  'obj/**',
+  'Pods/**',
+  'DerivedData/**',
 ];
 
 export function normalizeCodeGraphExcludePatterns(exclude?: string[]): string[] {