memorix 1.1.7 → 1.1.9

package/src/codegraph/lite-provider.ts

@@ -3,6 +3,7 @@ import { readdirSync, readFileSync, statSync, type Dirent } from 'node:fs';
 import { join, relative } from 'node:path';
 import type { CodeEdge, CodeFile, CodeSymbol } from './types.js';
 import { makeCodeEdgeId, makeCodeFileId, makeCodeSymbolId, normalizeCodePath } from './ids.js';
+import { isCodeGraphExcludedPath, normalizeCodeGraphExcludePatterns } from './exclude.js';
 
 export interface LiteIndexOptions {
   projectId: string;
@@ -169,19 +170,6 @@ function languageForPath(path: string): string {
   return LANGUAGE_BY_EXTENSION.get(ext) ?? 'unknown';
 }
 
-function isExcluded(path: string, exclude: string[]): boolean {
-  const normalized = normalizeCodePath(path);
-  return exclude.some((pattern) => {
-    const p = normalizeCodePath(pattern);
-    if (p.endsWith('/**')) {
-      const base = p.slice(0, -3);
-      return normalized === base || normalized.startsWith(`${base}/`);
-    }
-    if (p.startsWith('**/')) return normalized.endsWith(p.slice(3));
-    return normalized === p || normalized.startsWith(`${p}/`);
-  });
-}
-
 function walk(root: string, exclude: string[], maxFiles: number): string[] {
   const out: string[] = [];
   const visit = (dir: string) => {
@@ -196,9 +184,10 @@ function walk(root: string, exclude: string[], maxFiles: number): string[] {
     for (const entry of entries) {
       const abs = join(dir, entry.name);
       const rel = normalizeCodePath(relative(root, abs));
-      if (isExcluded(rel, exclude)) continue;
+      if (isCodeGraphExcludedPath(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;
@@ -289,15 +278,7 @@ function extractImportEdges(projectId: string, file: CodeFile, text: string, ind
 }
 
 export async function indexProjectLite(options: LiteIndexOptions): Promise<LiteIndexResult> {
-  const exclude = options.exclude ?? [
-    'node_modules/**',
-    'dist/**',
-    'build/**',
-    'coverage/**',
-    '.next/**',
-    '.turbo/**',
-    '.git/**',
-  ];
+  const exclude = normalizeCodeGraphExcludePatterns(options.exclude);
   const maxFiles = options.maxFiles ?? 5000;
   const indexedAt = new Date().toISOString();
   const paths = walk(options.projectRoot, exclude, maxFiles);

package/src/codegraph/project-context.ts

@@ -2,6 +2,7 @@ import type { ProjectInfo } from '../types.js';
 import { evaluateCodeRefFreshness } from './freshness.js';
 import type { CodeFile, CodeRefStatus, CodeSymbol, ObservationCodeRef } from './types.js';
 import type { CodeGraphStore } from './store.js';
+import { isCodeGraphExcludedPath } from './exclude.js';
 
 export interface ProjectContextObservation {
   id: number;
@@ -77,25 +78,17 @@ function countLanguages(files: CodeFile[]): LanguageSummary[] {
     .sort((a, b) => a.language.localeCompare(b.language));
 }
 
-function normalizePath(path: string): string {
-  return path.replace(/\\/g, '/');
-}
-
-function isGeneratedPath(path: string): boolean {
-  return /(^|\/)(dist|build|coverage|\.next|\.turbo|node_modules)\//i.test(normalizePath(path));
-}
-
 function suggestedReadRank(path: string): number {
-  const normalized = normalizePath(path);
+  const normalized = path.replace(/\\/g, '/');
   if (normalized.startsWith('src/')) return 0;
   if (normalized.startsWith('tests/') || normalized.startsWith('test/')) return 0;
   if (normalized.startsWith('packages/') && normalized.includes('/src/')) return 2;
   return 3;
 }
 
-function compactSuggestedReads(paths: string[], limit = 8): string[] {
+function compactSuggestedReads(paths: string[], limit = 8, exclude?: string[]): string[] {
   return uniq(paths)
-    .filter(path => !isGeneratedPath(path))
+    .filter(path => !isCodeGraphExcludedPath(path, exclude))
     .sort((a, b) => suggestedReadRank(a) - suggestedReadRank(b))
     .slice(0, limit);
 }
@@ -104,6 +97,7 @@ function collectGraph(
   store: CodeGraphStore,
   projectId: string,
   observations: ProjectContextObservation[],
+  exclude?: string[],
 ): {
   files: CodeFile[];
   symbols: CodeSymbol[];
@@ -135,7 +129,9 @@ function collectGraph(
 
     const observation = observationsById.get(ref.observationId);
     if (!observation) continue;
-    if (result.status === 'current' && file) suggestedReads.push(file.path);
+    const excluded = file ? isCodeGraphExcludedPath(file.path, exclude) : false;
+    if (result.status === 'current' && file && !excluded) suggestedReads.push(file.path);
+    if (excluded) continue;
     sources.push({
       observationId: observation.id,
       title: observation.title,
@@ -153,7 +149,7 @@ function collectGraph(
     refs,
     freshness,
     sources,
-    suggestedReads: compactSuggestedReads(suggestedReads),
+    suggestedReads: compactSuggestedReads(suggestedReads, 8, exclude),
   };
 }
 
@@ -161,9 +157,10 @@ export function buildProjectContextOverview(input: {
   project: Pick<ProjectInfo, 'id' | 'name' | 'rootPath'>;
   store: CodeGraphStore;
   observations: ProjectContextObservation[];
+  exclude?: string[];
 }): ProjectContextOverview {
   const active = activeObservations(input.observations, input.project.id);
-  const graph = collectGraph(input.store, input.project.id, active);
+  const graph = collectGraph(input.store, input.project.id, active, input.exclude);
   const status = input.store.status(input.project.id);
 
   return {
@@ -190,10 +187,11 @@ export function buildProjectContextExplain(input: {
   project: Pick<ProjectInfo, 'id' | 'name' | 'rootPath'>;
   store: CodeGraphStore;
   observations: ProjectContextObservation[];
+  exclude?: string[];
 }): ProjectContextExplain {
   const overview = buildProjectContextOverview(input);
   const active = activeObservations(input.observations, input.project.id);
-  const graph = collectGraph(input.store, input.project.id, active);
+  const graph = collectGraph(input.store, input.project.id, active, input.exclude);
   return {
     project: input.project,
     sources: graph.sources.sort((a, b) => a.observationId - b.observationId || (a.path ?? '').localeCompare(b.path ?? '')),

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;
+}

package/src/config/behavior.ts

@@ -1,59 +1,59 @@
-/**
- * Behavior Configuration Reader
- *
- * Reads behavior settings from ~/.memorix/config.json.
- * Falls back to sensible defaults if config is missing.
- */
-
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-
-export interface BehaviorConfig {
-  sessionInject: 'full' | 'minimal' | 'silent';
-  syncAdvisory: boolean;
-  autoCleanup: boolean;
-  formationMode: 'shadow' | 'active' | 'fallback';
-}
-
-const DEFAULTS: BehaviorConfig = {
-  sessionInject: 'minimal',
-  syncAdvisory: true,
-  autoCleanup: true,
-  formationMode: 'active',
-};
-
-let cached: BehaviorConfig | null = null;
-
-/**
- * Load behavior config from ~/.memorix/config.json.
- * Caches after first read. Returns defaults if file is missing.
- */
-export function getBehaviorConfig(): BehaviorConfig {
-  if (cached) return cached;
-
-  try {
-    const configPath = join(homedir(), '.memorix', 'config.json');
-    const raw = readFileSync(configPath, 'utf-8');
-    const config = JSON.parse(raw);
-    const behavior = config.behavior ?? {};
-
-    cached = {
-      sessionInject: behavior.sessionInject ?? DEFAULTS.sessionInject,
-      syncAdvisory: behavior.syncAdvisory ?? DEFAULTS.syncAdvisory,
-      autoCleanup: behavior.autoCleanup ?? DEFAULTS.autoCleanup,
-      formationMode: behavior.formationMode ?? DEFAULTS.formationMode,
-    };
-  } catch {
-    cached = { ...DEFAULTS };
-  }
-
-  return cached;
-}
-
-/**
- * Reset cached config (for testing or after config change).
- */
-export function resetBehaviorConfigCache(): void {
-  cached = null;
-}
+/**
+ * Behavior Configuration Reader
+ *
+ * Reads behavior settings from ~/.memorix/config.json.
+ * Falls back to sensible defaults if config is missing.
+ */
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+export interface BehaviorConfig {
+  sessionInject: 'full' | 'minimal' | 'silent';
+  syncAdvisory: boolean;
+  autoCleanup: boolean;
+  formationMode: 'shadow' | 'active' | 'fallback';
+}
+
+const DEFAULTS: BehaviorConfig = {
+  sessionInject: 'minimal',
+  syncAdvisory: true,
+  autoCleanup: true,
+  formationMode: 'active',
+};
+
+let cached: BehaviorConfig | null = null;
+
+/**
+ * Load behavior config from ~/.memorix/config.json.
+ * Caches after first read. Returns defaults if file is missing.
+ */
+export function getBehaviorConfig(): BehaviorConfig {
+  if (cached) return cached;
+
+  try {
+    const configPath = join(homedir(), '.memorix', 'config.json');
+    const raw = readFileSync(configPath, 'utf-8');
+    const config = JSON.parse(raw);
+    const behavior = config.behavior ?? {};
+
+    cached = {
+      sessionInject: behavior.sessionInject ?? DEFAULTS.sessionInject,
+      syncAdvisory: behavior.syncAdvisory ?? DEFAULTS.syncAdvisory,
+      autoCleanup: behavior.autoCleanup ?? DEFAULTS.autoCleanup,
+      formationMode: behavior.formationMode ?? DEFAULTS.formationMode,
+    };
+  } catch {
+    cached = { ...DEFAULTS };
+  }
+
+  return cached;
+}
+
+/**
+ * Reset cached config (for testing or after config change).
+ */
+export function resetBehaviorConfigCache(): void {
+  cached = null;
+}

package/src/config/resolved-config.ts

@@ -51,6 +51,9 @@ export interface ResolvedMemorixConfig {
     excludePatterns?: string[];
     noiseKeywords?: string[];
   };
+  codegraph: {
+    excludePatterns?: string[];
+  };
   server: {
     transport?: 'stdio' | 'http';
     dashboard?: boolean;
@@ -147,6 +150,9 @@ export function getResolvedConfig(options: ResolvedLaneOptions = {}): ResolvedMe
       excludePatterns: firstArray(toml.git?.exclude_patterns, yaml.git?.excludePatterns),
       noiseKeywords: firstArray(toml.git?.noise_keywords, yaml.git?.noiseKeywords),
     },
+    codegraph: {
+      excludePatterns: firstArray(toml.codegraph?.exclude_patterns, yaml.codegraph?.excludePatterns),
+    },
     server: {
       transport: first(toml.server?.transport, yaml.server?.transport),
       dashboard: firstBool(toml.server?.dashboard, yaml.server?.dashboard),

package/src/config/toml-loader.ts

@@ -39,6 +39,9 @@ export interface MemorixTomlConfig {
     exclude_patterns?: string[];
     noise_keywords?: string[];
   };
+  codegraph?: {
+    exclude_patterns?: string[];
+  };
   server?: {
     transport?: 'stdio' | 'http';
     dashboard?: boolean;
@@ -91,6 +94,7 @@ function mergeTomlConfig(base: MemorixTomlConfig, override: MemorixTomlConfig):
     embedding: { ...base.embedding, ...override.embedding },
     hooks: { ...base.hooks, ...override.hooks },
     git: { ...base.git, ...override.git },
+    codegraph: { ...base.codegraph, ...override.codegraph },
     server: { ...base.server, ...override.server },
   };
 }

package/src/config/yaml-loader.ts

@@ -64,6 +64,12 @@ export interface MemorixYamlConfig {
     noiseKeywords?: string[];
   };
 
+  /** CodeGraph / Project Context configuration */
+  codegraph?: {
+    /** File patterns to exclude from CodeGraph indexing and context suggestions */
+    excludePatterns?: string[];
+  };
+
   /** Behavior settings */
   behavior?: {
     /** Session start injection mode */
@@ -184,6 +190,7 @@ export function loadYamlConfig(projectRoot?: string | null): MemorixYamlConfig {
     agent: { ...userConfig.agent, ...projectConfig.agent },
     embedding: { ...userConfig.embedding, ...projectConfig.embedding },
     git: { ...userConfig.git, ...projectConfig.git },
+    codegraph: { ...userConfig.codegraph, ...projectConfig.codegraph },
     behavior: { ...userConfig.behavior, ...projectConfig.behavior },
     server: { ...userConfig.server, ...projectConfig.server },
     team: { ...userConfig.team, ...projectConfig.team },

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';
+  }
+}