memorix 1.2.2 → 1.2.3

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/compact/token-budget.ts

@@ -1,74 +1,74 @@
-/**
- * Token Budget Manager
- *
- * Provides token counting and budget management for Progressive Disclosure.
- * Source: gpt-tokenizer (737 stars, JS port of OpenAI's tiktoken)
- *
- * Used by the Compact Engine to determine which layer of detail
- * fits within the caller's token budget.
- */
-
-import { countTokens, isWithinTokenLimit } from 'gpt-tokenizer';
-
-/**
- * Count tokens in a string.
- */
-export function countTextTokens(text: string): number {
-  return countTokens(text);
-}
-
-/**
- * Check if text fits within a token limit.
- * Returns the token count if within limit, false otherwise.
- */
-export function fitsInBudget(text: string, limit: number): number | false {
-  return isWithinTokenLimit(text, limit);
-}
-
-/**
- * Truncate text to fit within a token budget.
- * Truncates at sentence boundaries when possible.
- */
-export function truncateToTokenBudget(text: string, budget: number): string {
-  if (fitsInBudget(text, budget) !== false) {
-    return text;
-  }
-
-  // Binary search for the right length
-  const sentences = text.split(/(?<=[.!?])\s+/);
-  let result = '';
-
-  for (const sentence of sentences) {
-    const candidate = result ? `${result} ${sentence}` : sentence;
-    if (fitsInBudget(candidate, budget) === false) {
-      break;
-    }
-    result = candidate;
-  }
-
-  // If no complete sentence fits, truncate by characters
-  if (!result) {
-    // Rough estimate: 1 token ≈ 4 chars for English, ≈ 1.5 chars for Chinese
-    const estimatedChars = budget * 2;
-    result = text.slice(0, estimatedChars);
-    // Refine
-    while (fitsInBudget(result, budget) === false && result.length > 0) {
-      result = result.slice(0, Math.floor(result.length * 0.9));
-    }
-    if (result.length < text.length) {
-      result += '...';
-    }
-  }
-
-  return result;
-}
-
-/**
- * Estimate the token cost of an IndexEntry line.
- * Used to predict compact index size.
- */
-export function estimateIndexEntryTokens(title: string): number {
-  // Format: "| #ID | Time | Icon | Title | ~Tokens |"
-  // Overhead is roughly 15 tokens for formatting
-  return countTextTokens(title) + 15;
-}
+/**
+ * Token Budget Manager
+ *
+ * Provides token counting and budget management for Progressive Disclosure.
+ * Source: gpt-tokenizer (737 stars, JS port of OpenAI's tiktoken)
+ *
+ * Used by the Compact Engine to determine which layer of detail
+ * fits within the caller's token budget.
+ */
+
+import { countTokens, isWithinTokenLimit } from 'gpt-tokenizer';
+
+/**
+ * Count tokens in a string.
+ */
+export function countTextTokens(text: string): number {
+  return countTokens(text);
+}
+
+/**
+ * Check if text fits within a token limit.
+ * Returns the token count if within limit, false otherwise.
+ */
+export function fitsInBudget(text: string, limit: number): number | false {
+  return isWithinTokenLimit(text, limit);
+}
+
+/**
+ * Truncate text to fit within a token budget.
+ * Truncates at sentence boundaries when possible.
+ */
+export function truncateToTokenBudget(text: string, budget: number): string {
+  if (fitsInBudget(text, budget) !== false) {
+    return text;
+  }
+
+  // Binary search for the right length
+  const sentences = text.split(/(?<=[.!?])\s+/);
+  let result = '';
+
+  for (const sentence of sentences) {
+    const candidate = result ? `${result} ${sentence}` : sentence;
+    if (fitsInBudget(candidate, budget) === false) {
+      break;
+    }
+    result = candidate;
+  }
+
+  // If no complete sentence fits, truncate by characters
+  if (!result) {
+    // Rough estimate: 1 token ≈ 4 chars for English, ≈ 1.5 chars for Chinese
+    const estimatedChars = budget * 2;
+    result = text.slice(0, estimatedChars);
+    // Refine
+    while (fitsInBudget(result, budget) === false && result.length > 0) {
+      result = result.slice(0, Math.floor(result.length * 0.9));
+    }
+    if (result.length < text.length) {
+      result += '...';
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Estimate the token cost of an IndexEntry line.
+ * Used to predict compact index size.
+ */
+export function estimateIndexEntryTokens(title: string): number {
+  // Format: "| #ID | Time | Icon | Title | ~Tokens |"
+  // Overhead is roughly 15 tokens for formatting
+  return countTextTokens(title) + 15;
+}