@rigour-labs/core 6.0.0 → 6.1.0-beta.1

package/dist/context/automatic-index.d.ts

@@ -0,0 +1,18 @@
+import type { PatternIndex } from '../pattern-index/types.js';
+export type SemanticIndexStatus = 'disabled' | 'warming' | 'ready' | 'degraded';
+export interface AutomaticIndexStatus {
+    structural: 'missing' | 'ready' | 'degraded';
+    graph: 'missing' | 'ready' | 'degraded';
+    semantic: SemanticIndexStatus;
+    message?: string;
+    updatedAt: string;
+}
+export declare function mergeSemanticEmbeddings(latest: PatternIndex, enriched: PatternIndex): PatternIndex;
+export declare function getAutomaticIndexStatus(cwd: string): Promise<AutomaticIndexStatus>;
+export declare function ensureAutomaticIndex(cwd: string, options?: {
+    backgroundSemantic?: boolean;
+}): Promise<PatternIndex>;
+export declare function updateAutomaticIndexForFiles(cwd: string, changedFiles: string[]): Promise<{
+    index: PatternIndex;
+    affectedFiles: string[];
+}>;

package/dist/context/automatic-index.js

@@ -0,0 +1,142 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { PatternIndexer, getDefaultIndexPath, loadPatternIndex, savePatternIndex } from '../pattern-index/indexer.js';
+import { affectedDependents, buildDependencyGraph, updateDependencyGraph } from './dependency-graph.js';
+import { syncIndexToContextCache } from './index-bridge.js';
+const enrichmentJobs = new Map();
+function projectRelativeFiles(cwd, files) {
+    const root = path.resolve(cwd);
+    return files.flatMap(file => {
+        const relative = path.relative(root, path.resolve(root, file));
+        if (!relative || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
+            return [];
+        return [relative.split(path.sep).join('/')];
+    });
+}
+export function mergeSemanticEmbeddings(latest, enriched) {
+    const embeddings = new Map(enriched.patterns
+        .filter(pattern => pattern.embedding?.length)
+        .map(pattern => [pattern.id, pattern.embedding]));
+    return {
+        ...latest,
+        lastUpdated: new Date().toISOString(),
+        patterns: latest.patterns.map(pattern => ({
+            ...pattern,
+            embedding: embeddings.get(pattern.id) ?? pattern.embedding,
+        })),
+    };
+}
+function statusPath(cwd) {
+    return path.join(cwd, '.rigour', 'index-status.json');
+}
+async function writeStatus(cwd, status) {
+    await fs.ensureDir(path.join(cwd, '.rigour'));
+    await fs.writeJson(statusPath(cwd), status, { spaces: 2 });
+}
+export async function getAutomaticIndexStatus(cwd) {
+    try {
+        return await fs.readJson(statusPath(cwd));
+    }
+    catch {
+        return {
+            structural: 'missing',
+            graph: 'missing',
+            semantic: 'disabled',
+            updatedAt: new Date().toISOString(),
+        };
+    }
+}
+async function enrichSemantic(cwd, index) {
+    const indexPath = getDefaultIndexPath(cwd);
+    try {
+        await writeStatus(cwd, {
+            structural: 'ready', graph: 'ready', semantic: 'warming', updatedAt: new Date().toISOString(),
+        });
+        const enriched = await new PatternIndexer(cwd, { useEmbeddings: true }).enrichIndex(index);
+        const latest = await loadPatternIndex(indexPath) ?? index;
+        const merged = mergeSemanticEmbeddings(latest, enriched);
+        const embedded = merged.patterns.filter((pattern) => (pattern.embedding?.length ?? 0) > 0).length;
+        await savePatternIndex(merged, indexPath);
+        await syncIndexToContextCache(cwd, merged);
+        await writeStatus(cwd, {
+            structural: 'ready',
+            graph: 'ready',
+            semantic: embedded > 0 ? 'ready' : 'degraded',
+            message: embedded > 0 ? `${embedded} patterns enriched` : 'Local embedding model unavailable; text matching remains active.',
+            updatedAt: new Date().toISOString(),
+        });
+    }
+    catch (error) {
+        await writeStatus(cwd, {
+            structural: 'ready',
+            graph: 'ready',
+            semantic: 'degraded',
+            message: error instanceof Error ? error.message : String(error),
+            updatedAt: new Date().toISOString(),
+        });
+    }
+    finally {
+        enrichmentJobs.delete(path.resolve(cwd));
+    }
+}
+function startEnrichment(cwd, index) {
+    const key = path.resolve(cwd);
+    if (enrichmentJobs.has(key))
+        return;
+    const job = enrichSemantic(cwd, index);
+    enrichmentJobs.set(key, job);
+}
+export async function ensureAutomaticIndex(cwd, options = {}) {
+    const indexPath = getDefaultIndexPath(cwd);
+    const existing = await loadPatternIndex(indexPath);
+    const indexer = new PatternIndexer(cwd, { useEmbeddings: false });
+    const index = existing ?? await indexer.buildIndex();
+    if (!existing)
+        await savePatternIndex(index, indexPath);
+    await syncIndexToContextCache(cwd, index);
+    if (!(await fs.pathExists(path.join(cwd, '.rigour', 'dependency-graph.json')))) {
+        await buildDependencyGraph(cwd, index);
+    }
+    const hasEmbeddings = index.patterns.some((pattern) => (pattern.embedding?.length ?? 0) > 0);
+    await writeStatus(cwd, {
+        structural: 'ready',
+        graph: 'ready',
+        semantic: hasEmbeddings ? 'ready' : options.backgroundSemantic === false ? 'disabled' : 'warming',
+        updatedAt: new Date().toISOString(),
+    });
+    if (!hasEmbeddings && options.backgroundSemantic !== false)
+        startEnrichment(cwd, index);
+    return index;
+}
+export async function updateAutomaticIndexForFiles(cwd, changedFiles) {
+    const normalizedChangedFiles = projectRelativeFiles(cwd, changedFiles);
+    const existing = await loadPatternIndex(getDefaultIndexPath(cwd));
+    if (!existing)
+        return { index: await ensureAutomaticIndex(cwd), affectedFiles: normalizedChangedFiles };
+    const previousStatus = await getAutomaticIndexStatus(cwd);
+    let graph = null;
+    try {
+        graph = await fs.readJson(path.join(cwd, '.rigour', 'dependency-graph.json'));
+    }
+    catch { /* baseline below */ }
+    const affectedFiles = graph ? affectedDependents(graph, normalizedChangedFiles) : normalizedChangedFiles;
+    const indexer = new PatternIndexer(cwd, { useEmbeddings: false });
+    const index = await indexer.updateFiles(existing, affectedFiles);
+    await savePatternIndex(index, getDefaultIndexPath(cwd));
+    await syncIndexToContextCache(cwd, index);
+    if (graph)
+        await updateDependencyGraph(cwd, index, graph, affectedFiles);
+    else
+        await buildDependencyGraph(cwd, index);
+    await writeStatus(cwd, {
+        structural: 'ready', graph: 'ready',
+        semantic: index.patterns.some(pattern => (pattern.embedding?.length ?? 0) > 0)
+            ? 'ready'
+            : previousStatus.semantic === 'disabled' ? 'disabled' : 'warming',
+        message: `${normalizedChangedFiles.length} changed file(s); ${affectedFiles.length} affected file(s) refreshed without a full scan.`,
+        updatedAt: new Date().toISOString(),
+    });
+    if (previousStatus.semantic !== 'disabled')
+        startEnrichment(cwd, index);
+    return { index, affectedFiles };
+}

package/dist/context/automatic-index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/context/automatic-index.test.js

@@ -0,0 +1,45 @@
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { ensureAutomaticIndex, mergeSemanticEmbeddings, updateAutomaticIndexForFiles } from './automatic-index.js';
+describe('automatic incremental index', () => {
+    const cwd = path.join(os.tmpdir(), `rigour-auto-index-${process.pid}`);
+    afterEach(() => fs.remove(cwd));
+    it('builds once and refreshes only changed files and their dependents', async () => {
+        await fs.outputFile(path.join(cwd, 'src/value.ts'), 'export const value = 1;');
+        await fs.outputFile(path.join(cwd, 'src/consumer.ts'), "import { value } from './value';\nexport const doubled = value * 2;");
+        const baseline = await ensureAutomaticIndex(cwd, { backgroundSemantic: false });
+        const untouched = baseline.files.find(file => file.path === 'src/consumer.ts')?.indexedAt;
+        await fs.writeFile(path.join(cwd, 'src/value.ts'), 'export const value = 2;');
+        const result = await updateAutomaticIndexForFiles(cwd, ['src/value.ts']);
+        expect(result.affectedFiles.sort()).toEqual(['src/consumer.ts', 'src/value.ts']);
+        expect(result.index.files.find(file => file.path === 'src/consumer.ts')?.indexedAt).not.toBe(untouched);
+    });
+    it('ignores changed-file paths outside the repository', async () => {
+        await fs.outputFile(path.join(cwd, 'src/value.ts'), 'export const value = 1;');
+        const baseline = await ensureAutomaticIndex(cwd, { backgroundSemantic: false });
+        const result = await updateAutomaticIndexForFiles(cwd, [path.join(cwd, '..', 'outside.ts')]);
+        expect(result.affectedFiles).toEqual([]);
+        expect(result.index.patterns).toEqual(baseline.patterns);
+    });
+    it('merges background embeddings onto the latest structural snapshot', () => {
+        const pattern = (id, file, embedding) => ({
+            id, file, embedding, type: 'function', name: id, line: 1, endLine: 1,
+            signature: '', description: '', keywords: [], hash: id, exported: true,
+            usageCount: 0, indexedAt: '2026-09-10T00:00:00.000Z',
+        });
+        const makeIndex = (patterns) => ({
+            version: '1.0.0', lastUpdated: '2026-09-10T00:00:00.000Z', rootDir: cwd,
+            patterns,
+            files: patterns.map(entry => ({ path: entry.file, hash: entry.hash, patternCount: 1, indexedAt: entry.indexedAt })),
+            stats: { totalPatterns: patterns.length, totalFiles: patterns.length, byType: { function: patterns.length }, indexDurationMs: 1 },
+        });
+        const latest = makeIndex([pattern('changed', 'src/changed.ts'), pattern('new', 'src/new.ts')]);
+        const enriched = makeIndex([pattern('changed', 'src/old.ts', [0.1, 0.2]), pattern('deleted', 'src/deleted.ts', [0.3])]);
+        const merged = mergeSemanticEmbeddings(latest, enriched);
+        expect(merged.patterns.map(entry => entry.id)).toEqual(['changed', 'new']);
+        expect(merged.patterns[0].file).toBe('src/changed.ts');
+        expect(merged.patterns[0].embedding).toEqual([0.1, 0.2]);
+    });
+});

package/dist/context/cache-engine.d.ts

@@ -36,6 +36,31 @@ export interface SemanticQueryEntry {
     evidence: string[];
     commitSha: string;
     confidence: number;
+    sourceTokens?: number;
+    candidateFiles?: number;
+    returnedFiles?: number;
+    guidance?: {
+        kind: 'context-scope' | 'pattern' | 'memory';
+        query?: string;
+        recommendation: string;
+        patternRefs?: Array<{
+            id: string;
+            label: string;
+            file?: string;
+        }>;
+        lessonRefs?: Array<{
+            id: string;
+            label: string;
+            visibility?: string;
+        }>;
+        memoryRefs?: Array<{
+            id: string;
+            label: string;
+        }>;
+        selectedFiles?: string[];
+        excludedFileCount?: number;
+        conflicts?: number;
+    };
 }
 export interface TaskCheckpointPacket {
     taskId: string;

package/dist/context/dependency-graph.d.ts

@@ -0,0 +1,13 @@
+import type { PatternIndex } from '../pattern-index/types.js';
+export interface DependencyGraph {
+    version: 1;
+    generatedAt: string;
+    nodes: string[];
+    edges: Array<{
+        from: string;
+        to: string;
+    }>;
+}
+export declare function buildDependencyGraph(cwd: string, index: PatternIndex): Promise<DependencyGraph>;
+export declare function updateDependencyGraph(cwd: string, index: PatternIndex, existing: DependencyGraph, changedFiles: string[]): Promise<DependencyGraph>;
+export declare function affectedDependents(graph: DependencyGraph, changedFiles: string[]): string[];

package/dist/context/dependency-graph.js

@@ -0,0 +1,97 @@
+import fs from 'fs-extra';
+import path from 'path';
+const IMPORT_PATTERNS = [
+    /(?:import|export)\s+(?:[^'"\n]+?\s+from\s+)?['"]([^'"]+)['"]/g,
+    /require\(\s*['"]([^'"]+)['"]\s*\)/g,
+    /from\s+([\w.]+)\s+import\s+/g,
+];
+function resolveImport(from, specifier, files) {
+    if (!specifier.startsWith('.') && !specifier.startsWith('/'))
+        return null;
+    const base = path.posix.normalize(path.posix.join(path.posix.dirname(from), specifier));
+    const candidates = [base, `${base}.ts`, `${base}.tsx`, `${base}.js`, `${base}.jsx`, `${base}.py`];
+    for (const indexName of ['index.ts', 'index.tsx', 'index.js', 'index.jsx']) {
+        candidates.push(path.posix.join(base, indexName));
+    }
+    return candidates.find((candidate) => files.has(candidate)) ?? null;
+}
+function importsFrom(content) {
+    const imports = new Set();
+    for (const pattern of IMPORT_PATTERNS) {
+        pattern.lastIndex = 0;
+        let match;
+        while ((match = pattern.exec(content)) !== null)
+            imports.add(match[1]);
+    }
+    return [...imports];
+}
+export async function buildDependencyGraph(cwd, index) {
+    const files = new Set(index.files.map((file) => file.path.split(path.sep).join('/')));
+    const edges = [];
+    for (const from of files) {
+        try {
+            const content = await fs.readFile(path.join(cwd, from), 'utf8');
+            for (const specifier of importsFrom(content)) {
+                const to = resolveImport(from, specifier, files);
+                if (to)
+                    edges.push({ from, to });
+            }
+        }
+        catch {
+            // A disappearing file is handled by the next incremental index update.
+        }
+    }
+    const graph = {
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        nodes: [...files],
+        edges,
+    };
+    const graphPath = path.join(cwd, '.rigour', 'dependency-graph.json');
+    await fs.ensureDir(path.dirname(graphPath));
+    await fs.writeJson(graphPath, graph, { spaces: 2 });
+    return graph;
+}
+export async function updateDependencyGraph(cwd, index, existing, changedFiles) {
+    const files = new Set(index.files.map(file => file.path.split(path.sep).join('/')));
+    const root = path.resolve(cwd);
+    const changed = new Set(changedFiles.flatMap(file => {
+        const relative = path.relative(root, path.resolve(root, file));
+        if (!relative || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
+            return [];
+        return [relative.split(path.sep).join('/')];
+    }));
+    const edges = existing.edges.filter(edge => !changed.has(edge.from) && files.has(edge.from) && files.has(edge.to));
+    for (const from of changed) {
+        if (!files.has(from))
+            continue;
+        try {
+            const content = await fs.readFile(path.join(cwd, from), 'utf8');
+            for (const specifier of importsFrom(content)) {
+                const to = resolveImport(from, specifier, files);
+                if (to)
+                    edges.push({ from, to });
+            }
+        }
+        catch {
+            // Deleted files are removed from the node and edge sets.
+        }
+    }
+    const graph = { version: 1, generatedAt: new Date().toISOString(), nodes: [...files], edges };
+    await fs.writeJson(path.join(cwd, '.rigour', 'dependency-graph.json'), graph, { spaces: 2 });
+    return graph;
+}
+export function affectedDependents(graph, changedFiles) {
+    const affected = new Set(changedFiles);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const edge of graph.edges) {
+            if (affected.has(edge.to) && !affected.has(edge.from)) {
+                affected.add(edge.from);
+                changed = true;
+            }
+        }
+    }
+    return [...affected];
+}

package/dist/context/dependency-graph.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/context/dependency-graph.test.js

@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest';
+import { affectedDependents } from './dependency-graph.js';
+describe('affectedDependents', () => {
+    it('includes direct and transitive consumers', () => {
+        const affected = affectedDependents({
+            version: 1,
+            generatedAt: '2026-09-10T00:00:00Z',
+            nodes: ['a.ts', 'b.ts', 'c.ts'],
+            edges: [{ from: 'b.ts', to: 'a.ts' }, { from: 'c.ts', to: 'b.ts' }],
+        }, ['a.ts']);
+        expect(new Set(affected)).toEqual(new Set(['a.ts', 'b.ts', 'c.ts']));
+    });
+});

package/dist/context/index-bridge.js

@@ -5,10 +5,29 @@
 import fs from 'fs-extra';
 import path from 'path';
 import { setStaticCache, setComponentCache, hashContent } from './cache-engine.js';
+import { getRepositoryId } from '../storage/lessons.js';
 function getIndexPath(cwd) {
     return path.join(cwd, '.rigour', 'patterns.json');
 }
 const DEFAULT_STALE_MS = 24 * 60 * 60 * 1000;
+async function resolveGitBranch(cwd) {
+    try {
+        let gitDir = path.join(cwd, '.git');
+        const gitStat = await fs.stat(gitDir);
+        if (gitStat.isFile()) {
+            const pointer = await fs.readFile(gitDir, 'utf8');
+            const match = pointer.match(/^gitdir:\s*(.+)$/m);
+            if (!match)
+                return 'workspace';
+            gitDir = path.resolve(cwd, match[1].trim());
+        }
+        const head = (await fs.readFile(path.join(gitDir, 'HEAD'), 'utf8')).trim();
+        return head.startsWith('ref: refs/heads/') ? head.slice('ref: refs/heads/'.length) : head.slice(0, 12);
+    }
+    catch {
+        return 'workspace';
+    }
+}
 function groupByComponent(patterns) {
     const groups = new Map();
     for (const p of patterns) {
@@ -41,8 +60,8 @@ function buildDossier(component, patterns) {
  */
 export async function syncIndexToContextCache(cwd, index) {
     const resolved = path.resolve(cwd);
-    const repo = path.basename(index.rootDir || resolved);
-    const branch = 'main';
+    const repo = await getRepositoryId(resolved);
+    const branch = await resolveGitBranch(resolved);
     const commitSha = hashContent(index.lastUpdated);
     let synced = 0;
     for (const file of index.files) {

package/dist/index.d.ts

@@ -24,6 +24,10 @@ export { openDatabase, isSQLiteAvailable, compactDatabase, getDatabaseSize, rese
 export type { RigourDB, CompactResult } from './storage/index.js';
 export { checkLocalPatterns, persistAndReinforce, getProjectStats } from './storage/index.js';
 export type { ProjectStats } from './storage/index.js';
+export { recordInteractionEvidence, countInteractionEvidence, recordInteractionLesson, listLessons, listKnowledgeLessons, getApplicableLessons, transitionLesson, getRepositoryId } from './storage/index.js';
+export type { ApplicableLessons, InteractionEvidence, LessonRecord, LessonState, LessonVisibility } from './storage/index.js';
+export { loadTeamConfiguration, saveTeamConfiguration, initializeTeamSchema, getTeamModeStatus, doctorTeamConnection, syncTeamOutbox, searchTeamKnowledge, backfillTeamEmbeddings, TEAM_CONFIG_PATH, validateTeamDatabaseUrl, } from './storage/index.js';
+export type { TeamConfiguration, TeamSemanticConfiguration, TeamModeStatus, TeamDoctorResult, SemanticKnowledgeCandidate, SemanticKnowledgeResult, } from './storage/index.js';
 export { generateTemporalDriftReport, formatDriftSummary } from './services/temporal-drift.js';
 export type { TemporalDriftReport, ProvenanceStream, MonthlyBucket, WeeklyBucket, DriftDirection } from './services/temporal-drift.js';
 export { getProvenanceTrends, getQualityTrend } from './services/adaptive-thresholds.js';
@@ -35,6 +39,11 @@ export type { RenderOptions, GateResult } from './services/terminal-renderer.js'
 export * from './context/cache-engine.js';
 export * from './context/context-session.js';
 export * from './context/index-bridge.js';
+export * from './context/automatic-index.js';
+export * from './context/dependency-graph.js';
 export * from './services/context-telemetry-service.js';
+export * from './services/system-health.js';
+export * from './services/agent-history.js';
+export * from './services/engineering-knowledge-graph.js';
 export * from './firewall/index.js';
 export { recordContextEvent, recordModelUsage, recordCheckpointMetric, getContextEvents, getModelUsages, getCheckpointMetrics, } from './storage/index.js';

package/dist/index.js

@@ -24,6 +24,8 @@ export { extractFacts, factsToPromptString } from './deep/fact-extractor.js';
 export { openDatabase, isSQLiteAvailable, compactDatabase, getDatabaseSize, resetDatabase, insertScan, insertFindings, getRecentScans, getScoreTrendFromDB, getTopIssues, reinforcePattern, getStrongPatterns } from './storage/index.js';
 // Local Project Memory (hybrid intelligence — SQLite-backed per-project learning)
 export { checkLocalPatterns, persistAndReinforce, getProjectStats } from './storage/index.js';
+export { recordInteractionEvidence, countInteractionEvidence, recordInteractionLesson, listLessons, listKnowledgeLessons, getApplicableLessons, transitionLesson, getRepositoryId } from './storage/index.js';
+export { loadTeamConfiguration, saveTeamConfiguration, initializeTeamSchema, getTeamModeStatus, doctorTeamConnection, syncTeamOutbox, searchTeamKnowledge, backfillTeamEmbeddings, TEAM_CONFIG_PATH, validateTeamDatabaseUrl, } from './storage/index.js';
 // Temporal Drift Engine (v5 — cross-session trend analysis + per-provenance EWMA)
 export { generateTemporalDriftReport, formatDriftSummary } from './services/temporal-drift.js';
 // Adaptive Thresholds (v5 — Z-score + per-provenance trends)
@@ -36,7 +38,12 @@ export { renderScoreGauge, renderSeveritySection, renderGateGrid, renderBrainSta
 export * from './context/cache-engine.js';
 export * from './context/context-session.js';
 export * from './context/index-bridge.js';
+export * from './context/automatic-index.js';
+export * from './context/dependency-graph.js';
 export * from './services/context-telemetry-service.js';
+export * from './services/system-health.js';
+export * from './services/agent-history.js';
+export * from './services/engineering-knowledge-graph.js';
 export * from './firewall/index.js';
 export { recordContextEvent, recordModelUsage, recordCheckpointMetric, getContextEvents, getModelUsages, getCheckpointMetrics, } from './storage/index.js';
 // Pattern Index is intentionally NOT exported here to prevent

package/dist/pattern-index/embeddings.js

@@ -7,6 +7,7 @@
  * Singleton for the embedding pipeline to avoid re-loading the model.
  */
 let embeddingPipeline = null;
+let embeddingUnavailable = false;
 /**
  * Get or initialize the embedding pipeline.
  */
@@ -21,6 +22,8 @@ async function getPipeline() {
             return { data: new Float32Array(vector) };
         };
     }
+    if (embeddingUnavailable)
+        return null;
     if (!embeddingPipeline) {
         try {
             // Dynamic import to isolate native dependency issues (like sharp)
@@ -29,8 +32,9 @@ async function getPipeline() {
             embeddingPipeline = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');
         }
         catch (error) {
-            console.error('Failed to initialize embedding pipeline:', error);
-            throw error;
+            embeddingUnavailable = true;
+            console.warn('Semantic enrichment is degraded; structural and text retrieval remain available.');
+            return null;
         }
     }
     return embeddingPipeline;
@@ -41,11 +45,14 @@ async function getPipeline() {
 export async function generateEmbedding(text) {
     try {
         const extractor = await getPipeline();
+        if (!extractor)
+            return [];
         const output = await extractor(text, { pooling: 'mean', normalize: true });
         return Array.from(output.data);
     }
     catch (error) {
-        console.warn('Semantic reasoning disabled: Embedding generation failed.', error);
+        embeddingUnavailable = true;
+        console.warn('Semantic enrichment is degraded; structural and text retrieval remain available.');
         return [];
     }
 }

package/dist/pattern-index/indexer.d.ts

@@ -15,6 +15,8 @@ export declare class PatternIndexer {
     constructor(rootDir: string, config?: Partial<PatternIndexConfig>);
     buildIndex(): Promise<PatternIndex>;
     updateIndex(existingIndex: PatternIndex): Promise<PatternIndex>;
+    updateFiles(existingIndex: PatternIndex, changedFiles: string[]): Promise<PatternIndex>;
+    enrichIndex(existingIndex: PatternIndex): Promise<PatternIndex>;
     private findFiles;
     private extractPatterns;
     private getScriptKind;

package/dist/pattern-index/indexer.js

@@ -12,6 +12,7 @@ import * as fs from 'fs/promises';
 import * as path from 'path';
 import { globby } from 'globby';
 import ts from 'typescript';
+import micromatch from 'micromatch';
 import { generateEmbedding } from './embeddings.js';
 import { hashContent } from './indexer-helpers.js';
 import { extractGoPatterns, extractRustPatterns, extractJVMStylePatterns, extractPythonPatterns, extractGenericCPatterns, } from './indexer-lang.js';
@@ -156,6 +157,77 @@ export class PatternIndexer {
             files: updatedFiles,
         };
     }
+    async updateFiles(existingIndex, changedFiles) {
+        const startTime = Date.now();
+        const root = path.resolve(this.rootDir);
+        const changed = new Set(changedFiles.flatMap(file => {
+            const absolute = path.resolve(root, file);
+            const relative = path.relative(root, absolute);
+            if (!relative || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
+                return [];
+            return [relative.split(path.sep).join('/')];
+        }));
+        const patterns = existingIndex.patterns.filter(pattern => !changed.has(pattern.file));
+        const files = existingIndex.files.filter(file => !changed.has(file.path));
+        for (const relativePath of changed) {
+            const absolutePath = path.join(root, relativePath);
+            const supported = this.config.extensions.includes(path.extname(relativePath).toLowerCase());
+            const included = micromatch.isMatch(relativePath.replace(/\\/g, '/'), this.config.include, { dot: false });
+            const excluded = micromatch.isMatch(relativePath.replace(/\\/g, '/'), this.config.exclude, { dot: true });
+            if (!supported || !included || excluded)
+                continue;
+            try {
+                const content = await fs.readFile(absolutePath, 'utf-8');
+                const filePatterns = await this.extractPatterns(absolutePath, content);
+                if (this.config.useEmbeddings) {
+                    await Promise.all(filePatterns.map(async (pattern) => {
+                        pattern.embedding = await generateEmbedding(`${pattern.name} ${pattern.type} ${pattern.description}`);
+                    }));
+                }
+                patterns.push(...filePatterns);
+                files.push({
+                    path: relativePath,
+                    hash: hashContent(content),
+                    patternCount: filePatterns.length,
+                    indexedAt: new Date().toISOString(),
+                });
+            }
+            catch (error) {
+                if (error?.code !== 'ENOENT')
+                    throw error;
+            }
+        }
+        return {
+            version: INDEX_VERSION,
+            lastUpdated: new Date().toISOString(),
+            rootDir: this.rootDir,
+            patterns,
+            files,
+            stats: this.calculateStats(patterns, files, Date.now() - startTime),
+        };
+    }
+    async enrichIndex(existingIndex) {
+        const startTime = Date.now();
+        const patterns = existingIndex.patterns.map(pattern => ({ ...pattern }));
+        const pending = patterns.filter(pattern => !pattern.embedding?.length);
+        if (pending.length > 0) {
+            pending[0].embedding = await generateEmbedding(`${pending[0].name} ${pending[0].type} ${pending[0].description}`);
+            if (!pending[0].embedding.length)
+                return existingIndex;
+        }
+        const batchSize = 10;
+        for (let i = 1; i < pending.length; i += batchSize) {
+            await Promise.all(pending.slice(i, i + batchSize).map(async (pattern) => {
+                pattern.embedding = await generateEmbedding(`${pattern.name} ${pattern.type} ${pattern.description}`);
+            }));
+        }
+        return {
+            ...existingIndex,
+            lastUpdated: new Date().toISOString(),
+            patterns,
+            stats: this.calculateStats(patterns, existingIndex.files, Date.now() - startTime),
+        };
+    }
     // -------------------------------------------------------------------------
     // Private helpers
     // -------------------------------------------------------------------------