memorix 1.4.6 → 1.5.1

package/src/dashboard/project-classification.ts

@@ -1,64 +1,64 @@
-/**
- * Project classification helpers — shared by /api/projects and /api/identity.
- *
- * Three kinds:
- *   - 'real':        genuine user projects (e.g. AVIDS2/memorix, github.com/org/repo)
- *   - 'temporary':   test/demo/smoke/e2e scratch projects (local/task-*, local/smoke-*, etc.)
- *   - 'placeholder': unresolved / obviously broken IDs (placeholder/*, __unresolved__, System32)
- *
- * A 'dirty' project is one with a clearly broken canonical ID (System32 etc.).
- * 'dirty' and 'temporary' are orthogonal axes:
- *   - local/task-abc        → temporary, NOT dirty
- *   - placeholder/xxx       → placeholder, dirty
- *   - System32\something    → real-looking location but dirty (broken ID)
- */
-
-export type ProjectKind = 'real' | 'temporary' | 'placeholder';
-
-/** Regex list — anything matching is temporary (scratch projects) */
-const TEMPORARY_PATTERNS: RegExp[] = [
-  /^local\/task-/i,
-  /^local\/smoke-/i,
-  /^local\/release-smoke-/i,
-  /^local\/memorix-e2e-/i,
-  /^local\/orchestrate-/i,
-  /^local\/scratch-/i,
-  /^local\/tmp-/i,
-];
-
-/** Regex list — anything matching is placeholder/unresolved */
-const PLACEHOLDER_PATTERNS: RegExp[] = [
-  /^__unresolved__$/,
-  /^placeholder\//i,
-];
-
-/** Regex list — IDs that indicate a broken canonical ID (dirty). */
-const DIRTY_PATTERNS: RegExp[] = [
-  /^placeholder\//i,
-  /System32/i,
-  /Microsoft VS Code/i,
-  /node_modules/i,
-  /\.vscode/i,
-  /^local\/[A-Z]:\\/i,
-];
-
-export function classifyProjectId(id: string): ProjectKind {
-  if (!id) return 'placeholder';
-  if (PLACEHOLDER_PATTERNS.some(p => p.test(id))) return 'placeholder';
-  if (TEMPORARY_PATTERNS.some(p => p.test(id))) return 'temporary';
-  return 'real';
-}
-
-export function isDirtyProjectId(id: string): boolean {
-  if (!id) return false;
-  return DIRTY_PATTERNS.some(p => p.test(id));
-}
-
-/** Friendly label for UI badges */
-export function projectKindLabel(kind: ProjectKind): string {
-  switch (kind) {
-    case 'real': return 'real';
-    case 'temporary': return 'temporary';
-    case 'placeholder': return 'placeholder';
-  }
-}
+/**
+ * Project classification helpers — shared by /api/projects and /api/identity.
+ *
+ * Three kinds:
+ *   - 'real':        genuine user projects (e.g. AVIDS2/memorix, github.com/org/repo)
+ *   - 'temporary':   test/demo/smoke/e2e scratch projects (local/task-*, local/smoke-*, etc.)
+ *   - 'placeholder': unresolved / obviously broken IDs (placeholder/*, __unresolved__, System32)
+ *
+ * A 'dirty' project is one with a clearly broken canonical ID (System32 etc.).
+ * 'dirty' and 'temporary' are orthogonal axes:
+ *   - local/task-abc        → temporary, NOT dirty
+ *   - placeholder/xxx       → placeholder, dirty
+ *   - System32\something    → real-looking location but dirty (broken ID)
+ */
+
+export type ProjectKind = 'real' | 'temporary' | 'placeholder';
+
+/** Regex list — anything matching is temporary (scratch projects) */
+const TEMPORARY_PATTERNS: RegExp[] = [
+  /^local\/task-/i,
+  /^local\/smoke-/i,
+  /^local\/release-smoke-/i,
+  /^local\/memorix-e2e-/i,
+  /^local\/orchestrate-/i,
+  /^local\/scratch-/i,
+  /^local\/tmp-/i,
+];
+
+/** Regex list — anything matching is placeholder/unresolved */
+const PLACEHOLDER_PATTERNS: RegExp[] = [
+  /^__unresolved__$/,
+  /^placeholder\//i,
+];
+
+/** Regex list — IDs that indicate a broken canonical ID (dirty). */
+const DIRTY_PATTERNS: RegExp[] = [
+  /^placeholder\//i,
+  /System32/i,
+  /Microsoft VS Code/i,
+  /node_modules/i,
+  /\.vscode/i,
+  /^local\/[A-Z]:\\/i,
+];
+
+export function classifyProjectId(id: string): ProjectKind {
+  if (!id) return 'placeholder';
+  if (PLACEHOLDER_PATTERNS.some(p => p.test(id))) return 'placeholder';
+  if (TEMPORARY_PATTERNS.some(p => p.test(id))) return 'temporary';
+  return 'real';
+}
+
+export function isDirtyProjectId(id: string): boolean {
+  if (!id) return false;
+  return DIRTY_PATTERNS.some(p => p.test(id));
+}
+
+/** Friendly label for UI badges */
+export function projectKindLabel(kind: ProjectKind): string {
+  switch (kind) {
+    case 'real': return 'real';
+    case 'temporary': return 'temporary';
+    case 'placeholder': return 'placeholder';
+  }
+}

package/src/embedding/api-provider.ts

@@ -406,6 +406,16 @@ interface APIEmbeddingConfig {
   requestedDimensions: number | null;
 }
 
+class EmbeddingAPIError extends Error {
+  readonly status: number;
+
+  constructor(status: number, detail: string) {
+    super(`Embedding API error (${status}): ${detail}`);
+    this.name = 'EmbeddingAPIError';
+    this.status = status;
+  }
+}
+
 export interface APIEmbeddingProviderCreateOptions {
   /**
    * When false, only previously persisted dimension metadata may initialize
@@ -432,6 +442,14 @@ function getPreferredBatchSize(config: APIEmbeddingConfig): number {
 function parseBatchLimit(error: unknown): number | null {
   if (!(error instanceof Error)) return null;
 
+  // Only a provider-side request-shape error may trigger recursive batch
+  // splitting. Billing, authentication, quota, and upstream errors must fail
+  // once; retrying them multiplies latency without changing the request.
+  const status = error instanceof EmbeddingAPIError
+    ? error.status
+    : Number(error.message.match(/Embedding API error \((\d{3})\)/i)?.[1] ?? 0);
+  if (status > 0 && status !== 400) return null;
+
   const explicit = error.message.match(/should not be larger than\s+(\d+)/i);
   if (explicit) return parseInt(explicit[1], 10);
 
@@ -712,16 +730,14 @@ export class APIEmbeddingProvider implements EmbeddingProvider {
         }
       } catch (error) {
         const providerLimit = parseBatchLimit(error);
-        const fallbackSize = providerLimit ?? Math.ceil(chunkTexts.length / 2);
-
-        if (chunkTexts.length > 1 && fallbackSize < chunkTexts.length) {
+        if (providerLimit !== null && chunkTexts.length > 1 && providerLimit < chunkTexts.length) {
           console.error(
-            `[memorix] Embedding batch too large for provider, retrying in chunks of ${fallbackSize}`,
+            `[memorix] Embedding batch too large for provider, retrying in chunks of ${providerLimit}`,
           );
-          for (let start = 0; start < chunkTexts.length; start += fallbackSize) {
+          for (let start = 0; start < chunkTexts.length; start += providerLimit) {
             await processChunk(
-              chunkTexts.slice(start, start + fallbackSize),
-              chunkIndices.slice(start, start + fallbackSize),
+              chunkTexts.slice(start, start + providerLimit),
+              chunkIndices.slice(start, start + providerLimit),
             );
           }
           return;
@@ -842,6 +858,9 @@ async function fetchWithRetry(
     ? Math.max(100, Math.min(Math.floor(options.timeoutMs), 60_000))
     : 10_000;
   const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  const signal = options.signal
+    ? AbortSignal.any([options.signal, controller.signal])
+    : controller.signal;
   let response: Response;
   try {
     response = await fetch(url, {
@@ -850,30 +869,94 @@ async function fetchWithRetry(
         ? { 'Content-Type': 'application/json', 'x-goog-api-key': apiKey }
         : { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
       body: JSON.stringify(body),
-      signal: controller.signal,
+      signal,
     });
   } catch (err: unknown) {
     clearTimeout(timeout);
-    if (err instanceof Error && err.name === 'AbortError') {
+    if (err instanceof Error && (err.name === 'AbortError' || controller.signal.aborted || options.signal?.aborted)) {
       throw new Error(`Embedding API timeout after ${timeoutMs}ms: ${url}`);
     }
     throw err;
   }
-  clearTimeout(timeout);
 
-  if (response.ok) {
-    return response.json() as Promise<EmbeddingAPIResponse>;
-  }
+  try {
+    if (response.ok) {
+      return await raceWithAbort(
+        response.json() as Promise<EmbeddingAPIResponse>,
+        signal,
+      );
+    }
+
+    if (options.retry !== false && (response.status === 429 || response.status >= 500) && attempt < MAX_RETRIES) {
+      const delay = BASE_DELAY_MS * Math.pow(2, attempt);
+      const retryAfter = response.headers.get('retry-after');
+      const parsedRetryAfter = retryAfter ? parseInt(retryAfter, 10) * 1000 : NaN;
+      const waitMs = Number.isFinite(parsedRetryAfter) ? parsedRetryAfter : delay;
+      console.error(`[memorix] Embedding API ${response.status}, retry ${attempt + 1}/${MAX_RETRIES} in ${waitMs}ms`);
+      await waitForRetry(waitMs, options.signal);
+      return fetchWithRetry(url, apiKey, body, options, attempt + 1, nativeGemini);
+    }
 
-  if (options.retry !== false && (response.status === 429 || response.status >= 500) && attempt < MAX_RETRIES) {
-    const delay = BASE_DELAY_MS * Math.pow(2, attempt);
-    const retryAfter = response.headers.get('retry-after');
-    const waitMs = retryAfter ? parseInt(retryAfter, 10) * 1000 : delay;
-    console.error(`[memorix] Embedding API ${response.status}, retry ${attempt + 1}/${MAX_RETRIES} in ${waitMs}ms`);
-    await new Promise(resolve => setTimeout(resolve, waitMs));
-    return fetchWithRetry(url, apiKey, body, options, attempt + 1, nativeGemini);
+    const errorText = await raceWithAbort(
+      response.text().catch(() => 'unknown error'),
+      signal,
+    );
+    throw new EmbeddingAPIError(response.status, errorText);
+  } catch (err: unknown) {
+    if (err instanceof Error && (err.name === 'AbortError' || controller.signal.aborted || options.signal?.aborted)) {
+      throw new Error(`Embedding API timeout after ${timeoutMs}ms: ${url}`);
+    }
+    throw err;
+  } finally {
+    clearTimeout(timeout);
   }
+}
 
-  const errorText = await response.text().catch(() => 'unknown error');
-  throw new Error(`Embedding API error (${response.status}): ${errorText}`);
+function abortError(): Error {
+  const error = new Error('Embedding API request aborted');
+  error.name = 'AbortError';
+  return error;
+}
+
+function raceWithAbort<T>(promise: Promise<T>, signal: AbortSignal): Promise<T> {
+  if (signal.aborted) return Promise.reject(abortError());
+  return new Promise<T>((resolve, reject) => {
+    const onAbort = () => {
+      signal.removeEventListener('abort', onAbort);
+      reject(abortError());
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener('abort', onAbort);
+        resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener('abort', onAbort);
+        reject(error);
+      },
+    );
+  });
+}
+
+async function waitForRetry(waitMs: number, signal?: AbortSignal): Promise<void> {
+  if (!signal) {
+    await new Promise<void>((resolve) => setTimeout(resolve, waitMs));
+    return;
+  }
+  const abortSignal = signal;
+  if (abortSignal.aborted) throw new Error('Embedding API retry aborted');
+  await new Promise<void>((resolve, reject) => {
+    const timer = setTimeout(done, waitMs);
+    const onAbort = () => {
+      clearTimeout(timer);
+      abortSignal.removeEventListener('abort', onAbort);
+      reject(new Error('Embedding API retry aborted'));
+    };
+    function done() {
+      abortSignal.removeEventListener('abort', onAbort);
+      resolve();
+    }
+    abortSignal.addEventListener('abort', onAbort, { once: true });
+  });
 }

package/src/embedding/provider.ts

@@ -34,6 +34,8 @@ export interface EmbeddingRequestOptions {
   timeoutMs?: number;
   /** Disable provider retries for latency-sensitive best-effort work. */
   retry?: boolean;
+  /** Abort the request and any retry wait when the caller's budget expires. */
+  signal?: AbortSignal;
 }
 
 export type EmbeddingModality = 'text' | 'image' | 'audio' | 'video' | 'document';

package/src/git/hooks-path.ts

@@ -1,85 +1,85 @@
-/**
- * Git hooks path resolver — worktree-safe.
- *
- * In a normal repo:   .git is a directory  → hooks at .git/hooks/
- * In a git worktree:  .git is a FILE containing "gitdir: /path/to/actual/git/dir"
- *                     → hooks at that resolved path + /hooks/
- *
- * This utility ensures all hook install/uninstall/check operations
- * work correctly in both scenarios.
- */
-
-import { existsSync, readFileSync, statSync, mkdirSync } from 'node:fs';
-import path from 'node:path';
-
-/**
- * Resolve the actual .git directory path, following worktree indirection.
- *
- * @param projectRoot - The root of the working tree (where .git lives)
- * @returns Absolute path to the real git dir, or null if no .git found
- */
-export function resolveGitDir(projectRoot: string): string | null {
-  const dotGit = path.join(projectRoot, '.git');
-
-  if (!existsSync(dotGit)) return null;
-
-  const stat = statSync(dotGit);
-
-  if (stat.isDirectory()) {
-    // Normal repo — .git is a directory
-    return dotGit;
-  }
-
-  if (stat.isFile()) {
-    // Worktree — .git is a file: "gitdir: /path/to/actual/git/dir"
-    try {
-      const content = readFileSync(dotGit, 'utf-8').trim();
-      const match = content.match(/^gitdir:\s*(.+)$/);
-      if (match) {
-        const gitdir = match[1].trim();
-        // Resolve relative paths against the project root
-        const resolved = path.isAbsolute(gitdir)
-          ? gitdir
-          : path.resolve(projectRoot, gitdir);
-        if (existsSync(resolved)) {
-          return resolved;
-        }
-      }
-    } catch {
-      // Unreadable .git file — fall through
-    }
-  }
-
-  return null;
-}
-
-/**
- * Resolve the hooks directory for a project (read-only — does NOT create directories).
- * Handles both normal repos and git worktrees.
- *
- * @param projectRoot - The root of the working tree
- * @returns Object with hooksDir and hookPath for post-commit, or null if no .git found
- */
-export function resolveHooksDir(projectRoot: string): { hooksDir: string; hookPath: string } | null {
-  const gitDir = resolveGitDir(projectRoot);
-  if (!gitDir) return null;
-
-  const hooksDir = path.join(gitDir, 'hooks');
-
-  return {
-    hooksDir,
-    hookPath: path.join(hooksDir, 'post-commit'),
-  };
-}
-
-/**
- * Resolve hooks directory AND ensure it exists on disk.
- * Use this only in write paths (hook install / autoHook).
- */
-export function ensureHooksDir(projectRoot: string): { hooksDir: string; hookPath: string } | null {
-  const resolved = resolveHooksDir(projectRoot);
-  if (!resolved) return null;
-
-  mkdirSync(resolved.hooksDir, { recursive: true });
-  return resolved;
-}
+/**
+ * Git hooks path resolver — worktree-safe.
+ *
+ * In a normal repo:   .git is a directory  → hooks at .git/hooks/
+ * In a git worktree:  .git is a FILE containing "gitdir: /path/to/actual/git/dir"
+ *                     → hooks at that resolved path + /hooks/
+ *
+ * This utility ensures all hook install/uninstall/check operations
+ * work correctly in both scenarios.
+ */
+
+import { existsSync, readFileSync, statSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Resolve the actual .git directory path, following worktree indirection.
+ *
+ * @param projectRoot - The root of the working tree (where .git lives)
+ * @returns Absolute path to the real git dir, or null if no .git found
+ */
+export function resolveGitDir(projectRoot: string): string | null {
+  const dotGit = path.join(projectRoot, '.git');
+
+  if (!existsSync(dotGit)) return null;
+
+  const stat = statSync(dotGit);
+
+  if (stat.isDirectory()) {
+    // Normal repo — .git is a directory
+    return dotGit;
+  }
+
+  if (stat.isFile()) {
+    // Worktree — .git is a file: "gitdir: /path/to/actual/git/dir"
+    try {
+      const content = readFileSync(dotGit, 'utf-8').trim();
+      const match = content.match(/^gitdir:\s*(.+)$/);
+      if (match) {
+        const gitdir = match[1].trim();
+        // Resolve relative paths against the project root
+        const resolved = path.isAbsolute(gitdir)
+          ? gitdir
+          : path.resolve(projectRoot, gitdir);
+        if (existsSync(resolved)) {
+          return resolved;
+        }
+      }
+    } catch {
+      // Unreadable .git file — fall through
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Resolve the hooks directory for a project (read-only — does NOT create directories).
+ * Handles both normal repos and git worktrees.
+ *
+ * @param projectRoot - The root of the working tree
+ * @returns Object with hooksDir and hookPath for post-commit, or null if no .git found
+ */
+export function resolveHooksDir(projectRoot: string): { hooksDir: string; hookPath: string } | null {
+  const gitDir = resolveGitDir(projectRoot);
+  if (!gitDir) return null;
+
+  const hooksDir = path.join(gitDir, 'hooks');
+
+  return {
+    hooksDir,
+    hookPath: path.join(hooksDir, 'post-commit'),
+  };
+}
+
+/**
+ * Resolve hooks directory AND ensure it exists on disk.
+ * Use this only in write paths (hook install / autoHook).
+ */
+export function ensureHooksDir(projectRoot: string): { hooksDir: string; hookPath: string } | null {
+  const resolved = resolveHooksDir(projectRoot);
+  if (!resolved) return null;
+
+  mkdirSync(resolved.hooksDir, { recursive: true });
+  return resolved;
+}