memorix 1.1.7 → 1.1.8

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/context-pack.ts

@@ -69,7 +69,11 @@ function timestampOf(observation: ContextPackObservation): number {
 }
 
 function isGeneratedPath(path: string): boolean {
-  return /(^|\/)(dist|build|coverage|\.next|\.turbo|node_modules)\//i.test(path.replace(/\\/g, '/'));
+  const normalized = path.replace(/\\/g, '/');
+  return (
+    /(^|\/)(dist|build|coverage|\.next|\.turbo|node_modules|\.git|\.tmp|\.worktrees)(\/|$)/i.test(normalized) ||
+    /(^|\/)\.claude\/worktrees(\/|$)/i.test(normalized)
+  );
 }
 
 function relevanceScore(observation: ContextPackObservation, taskTokens: string[]): number {

package/src/codegraph/lite-provider.ts

@@ -198,7 +198,8 @@ function walk(root: string, exclude: string[], maxFiles: number): string[] {
       const rel = normalizeCodePath(relative(root, abs));
       if (isExcluded(rel, exclude)) continue;
       if (entry.isDirectory()) {
-        if (entry.name === '.git' || entry.name === 'node_modules') continue;
+        if (entry.name === '.git' || entry.name === '.worktrees' || entry.name === '.tmp' || entry.name === 'node_modules') continue;
+        if (rel === '.claude/worktrees' || rel.startsWith('.claude/worktrees/')) continue;
         visit(abs);
         if (out.length >= maxFiles) return;
         continue;
@@ -297,6 +298,9 @@ export async function indexProjectLite(options: LiteIndexOptions): Promise<LiteI
     '.next/**',
     '.turbo/**',
     '.git/**',
+    '.tmp/**',
+    '.worktrees/**',
+    '.claude/worktrees/**',
   ];
   const maxFiles = options.maxFiles ?? 5000;
   const indexedAt = new Date().toISOString();

package/src/codegraph/project-context.ts

@@ -82,7 +82,11 @@ function normalizePath(path: string): string {
 }
 
 function isGeneratedPath(path: string): boolean {
-  return /(^|\/)(dist|build|coverage|\.next|\.turbo|node_modules)\//i.test(normalizePath(path));
+  const normalized = normalizePath(path);
+  return (
+    /(^|\/)(dist|build|coverage|\.next|\.turbo|node_modules|\.git|\.tmp|\.worktrees)(\/|$)/i.test(normalized) ||
+    /(^|\/)\.claude\/worktrees(\/|$)/i.test(normalized)
+  );
 }
 
 function suggestedReadRank(path: string): number {