cogmem 3.6.2

package/dist/algorithm/Phase2ModelAlgorithmReviewBackend.js

@@ -0,0 +1,372 @@
+// @ts-nocheck
+import { normalizeLexiconText } from '../lexicon/coreMemoryLexicon.js';
+import { buildAlgorithmReviewMetadata, MODEL_BACKED_PHASE2_REVIEW_VERSION, NoopAlgorithmReviewBackend, Phase1RuleAlgorithmReviewBackend, PHASE1_RULE_REVIEW_VERSION } from './AlgorithmReviewBackend.js';
+import { SemanticBackendRuntime } from '../backend/SemanticBackend.js';
+import { ModelRegistry } from '../models/ModelRegistry.js';
+import { createMemoryReviewAdapter } from '../models/adapters/MemoryReviewAdapter.js';
+export function resolveAlgorithmReviewBackendMode() {
+    return 'noop';
+}
+export function createAlgorithmReviewBackend(options = {}) {
+    const registry = options.modelRegistry || ModelRegistry.defaults();
+    if (!registry.isRuleOnly('memory')) {
+        return createMemoryReviewAdapter(registry);
+    }
+    const mode = resolveAlgorithmReviewBackendMode();
+    if (mode === 'phase1_rule')
+        return new Phase1RuleAlgorithmReviewBackend();
+    if (mode === 'model_backed_phase2') {
+        return new Phase2ModelAlgorithmReviewBackend({
+            semanticBackend: options.semanticBackend,
+            modelRuntime: options.modelRuntime,
+            fallbackBackend: options.fallbackBackend || new Phase1RuleAlgorithmReviewBackend()
+        });
+    }
+    return new NoopAlgorithmReviewBackend();
+}
+export class Phase2ModelAlgorithmReviewBackend {
+    options;
+    semanticBackend;
+    fallbackBackend;
+    runtimePromise;
+    constructor(options = {}) {
+        this.options = options;
+        this.semanticBackend = options.semanticBackend || new SemanticBackendRuntime();
+        this.fallbackBackend = options.fallbackBackend || new Phase1RuleAlgorithmReviewBackend();
+    }
+    async reviewProvisionalFactCandidates(input) {
+        const baseline = await this.fallbackBackend.reviewProvisionalFactCandidates(input);
+        const runtime = await this.prepareRuntime('offline_deep_consolidation');
+        if (!runtime)
+            return this.annotateFallbackProvisional(baseline);
+        const reviewed = await runtime.reviewProvisionalFactCandidates(input);
+        return {
+            adjudications: this.mergeAdjudications(baseline.adjudications, reviewed.adjudications || []),
+            aliasMergeSuggestions: this.mergeAliasSuggestions(baseline.aliasMergeSuggestions, reviewed.aliasMergeSuggestions || [])
+        };
+    }
+    async reviewSelfCorrectionCandidates(input) {
+        const baseline = await this.fallbackBackend.reviewSelfCorrectionCandidates(input);
+        const runtime = await this.prepareRuntime('optional_semantic_task');
+        if (!runtime)
+            return this.annotateFallbackSuggestedFacts(baseline);
+        const reviewed = await runtime.reviewSelfCorrectionCandidates(input);
+        return {
+            suggestedFacts: this.mergeSuggestedFacts(baseline.suggestedFacts, reviewed.suggestedFacts || [], {
+                defaultKind: 'model_backed_self_correction_repair'
+            })
+        };
+    }
+    async reviewMultiFactExtractionCandidates(input) {
+        const baseline = await this.fallbackBackend.reviewMultiFactExtractionCandidates(input);
+        const runtime = await this.prepareRuntime(input.mode === 'offline' ? 'offline_deep_consolidation' : 'async_low_confidence_enrichment');
+        if (!runtime)
+            return this.annotateFallbackMultiFact(baseline);
+        const reviewed = await runtime.reviewMultiFactExtractionCandidates(input);
+        return {
+            suggestedEntities: this.mergeSuggestedEntities(baseline.suggestedEntities, reviewed.suggestedEntities || []),
+            suggestedFacts: this.mergeSuggestedFacts(baseline.suggestedFacts, reviewed.suggestedFacts || [], {
+                defaultKind: 'model_backed_multi_fact_repair'
+            })
+        };
+    }
+    async prepareRuntime(task) {
+        const invocation = this.semanticBackend.prepare(task);
+        if (invocation.selectedBackend === 'rule-only-fallback') {
+            return null;
+        }
+        if (!this.runtimePromise) {
+            this.runtimePromise = this.options.modelRuntime
+                ? Promise.resolve(this.options.modelRuntime)
+                : this.createDefaultRuntime();
+        }
+        return this.runtimePromise;
+    }
+    async createDefaultRuntime() {
+        const status = this.semanticBackend.getStatus();
+        if (!status.modelPath) {
+            throw new Error('Phase2ModelAlgorithmReviewBackend requires a warmed local model path.');
+        }
+        return new GemmaPhase2LocalReviewRuntime(status.modelPath);
+    }
+    annotateFallbackProvisional(result) {
+        return {
+            adjudications: result.adjudications.map((item) => ({
+                ...item,
+                metadata: buildAlgorithmReviewMetadata({
+                    reviewBackendMode: 'phase1_rule',
+                    reviewVersion: PHASE1_RULE_REVIEW_VERSION,
+                    reviewKind: `${item.metadata?.reviewKind || item.metadata?.algorithm_review_kind || 'provisional_fact_adjudication'}`,
+                    reviewFallbackFrom: 'model_backed_phase2',
+                    provenance: `${item.metadata?.provenance || 'algorithm_review_phase1'}`,
+                    metadata: item.metadata
+                })
+            })),
+            aliasMergeSuggestions: result.aliasMergeSuggestions
+        };
+    }
+    annotateFallbackSuggestedFacts(result) {
+        return {
+            suggestedFacts: result.suggestedFacts.map((fact) => ({
+                ...fact,
+                metadata: buildAlgorithmReviewMetadata({
+                    reviewBackendMode: 'phase1_rule',
+                    reviewVersion: PHASE1_RULE_REVIEW_VERSION,
+                    reviewKind: `${fact.metadata?.reviewKind || fact.metadata?.algorithm_review_kind || 'self_correction_repair'}`,
+                    reviewFallbackFrom: 'model_backed_phase2',
+                    provenance: `${fact.metadata?.provenance || 'algorithm_review_phase1'}`,
+                    metadata: fact.metadata
+                })
+            }))
+        };
+    }
+    annotateFallbackMultiFact(result) {
+        return {
+            suggestedEntities: result.suggestedEntities.map((entity) => ({
+                ...entity,
+                metadata: buildAlgorithmReviewMetadata({
+                    reviewBackendMode: 'phase1_rule',
+                    reviewVersion: PHASE1_RULE_REVIEW_VERSION,
+                    reviewKind: `${entity.metadata?.reviewKind || entity.metadata?.algorithm_review_kind || 'explicit_entity_wording_repair'}`,
+                    reviewFallbackFrom: 'model_backed_phase2',
+                    provenance: `${entity.metadata?.provenance || 'algorithm_review_phase1'}`,
+                    metadata: entity.metadata
+                })
+            })),
+            suggestedFacts: result.suggestedFacts.map((fact) => ({
+                ...fact,
+                metadata: buildAlgorithmReviewMetadata({
+                    reviewBackendMode: 'phase1_rule',
+                    reviewVersion: PHASE1_RULE_REVIEW_VERSION,
+                    reviewKind: `${fact.metadata?.reviewKind || fact.metadata?.algorithm_review_kind || 'multi_fact_repair'}`,
+                    reviewFallbackFrom: 'model_backed_phase2',
+                    provenance: `${fact.metadata?.provenance || 'algorithm_review_phase1'}`,
+                    metadata: fact.metadata
+                })
+            }))
+        };
+    }
+    mergeAdjudications(baseline, reviewed) {
+        const merged = new Map(baseline.map((item) => [item.factId, item]));
+        for (const item of reviewed) {
+            if (!item.factId || !item.action || !item.reason)
+                continue;
+            merged.set(item.factId, {
+                factId: item.factId,
+                action: item.action,
+                reason: item.reason,
+                confidence: item.confidence,
+                supersededByFactId: item.supersededByFactId,
+                metadata: buildAlgorithmReviewMetadata({
+                    reviewBackendMode: 'model_backed_phase2',
+                    reviewVersion: MODEL_BACKED_PHASE2_REVIEW_VERSION,
+                    reviewKind: `${item.metadata?.reviewKind || item.metadata?.algorithm_review_kind || 'model_backed_provisional_fact_adjudication'}`,
+                    provenance: 'algorithm_review_phase2',
+                    metadata: item.metadata
+                })
+            });
+        }
+        return [...merged.values()];
+    }
+    mergeAliasSuggestions(baseline, reviewed) {
+        const merged = new Map();
+        for (const item of baseline) {
+            merged.set(`${item.primaryEntityId}|${item.duplicateEntityId}`, item);
+        }
+        for (const item of reviewed) {
+            if (!item.primaryEntityId || !item.duplicateEntityId || !item.reason)
+                continue;
+            merged.set(`${item.primaryEntityId}|${item.duplicateEntityId}`, item);
+        }
+        return [...merged.values()];
+    }
+    mergeSuggestedEntities(baseline, reviewed) {
+        const merged = new Map();
+        for (const entity of baseline) {
+            merged.set(`${entity.type}|${normalizeLexiconText(entity.canonicalName).toLowerCase()}`, entity);
+        }
+        for (const entity of reviewed) {
+            if (!entity.canonicalName || !entity.type)
+                continue;
+            const key = `${entity.type}|${normalizeLexiconText(entity.canonicalName).toLowerCase()}`;
+            merged.set(key, {
+                canonicalName: entity.canonicalName,
+                type: entity.type,
+                aliases: entity.aliases,
+                instanceMode: entity.instanceMode,
+                metadata: buildAlgorithmReviewMetadata({
+                    reviewBackendMode: 'model_backed_phase2',
+                    reviewVersion: MODEL_BACKED_PHASE2_REVIEW_VERSION,
+                    reviewKind: `${entity.metadata?.reviewKind || entity.metadata?.algorithm_review_kind || 'model_backed_entity_wording_repair'}`,
+                    provenance: 'algorithm_review_phase2',
+                    metadata: entity.metadata
+                })
+            });
+        }
+        return [...merged.values()];
+    }
+    mergeSuggestedFacts(baseline, reviewed, options) {
+        const merged = new Map();
+        for (const fact of baseline) {
+            merged.set(this.factKey(fact), fact);
+        }
+        for (const fact of reviewed) {
+            if (!fact.neuronId || !fact.subject || !fact.predicateFamily || !fact.validFrom || !fact.sourceText)
+                continue;
+            const record = {
+                neuronId: fact.neuronId,
+                subject: fact.subject,
+                predicateFamily: fact.predicateFamily,
+                predicateValue: fact.predicateValue,
+                object: fact.object,
+                entityId: fact.entityId,
+                validFrom: fact.validFrom,
+                certaintyLevel: fact.certaintyLevel || 'probable',
+                confidence: fact.confidence || 0.82,
+                status: fact.status || 'provisional_enriched',
+                sourceText: fact.sourceText,
+                metadata: buildAlgorithmReviewMetadata({
+                    reviewBackendMode: 'model_backed_phase2',
+                    reviewVersion: MODEL_BACKED_PHASE2_REVIEW_VERSION,
+                    reviewKind: `${fact.metadata?.reviewKind || fact.metadata?.algorithm_review_kind || options.defaultKind}`,
+                    provenance: 'algorithm_review_phase2',
+                    metadata: fact.metadata
+                })
+            };
+            merged.set(this.factKey(record), record);
+        }
+        return [...merged.values()];
+    }
+    factKey(fact) {
+        return [
+            fact.neuronId,
+            fact.predicateFamily,
+            normalizeLexiconText(fact.predicateValue || '').toLowerCase(),
+            normalizeLexiconText(fact.object || '').toLowerCase(),
+            fact.entityId || ''
+        ].join('|');
+    }
+}
+class GemmaPhase2LocalReviewRuntime {
+    modelPath;
+    pipelinePromise;
+    constructor(modelPath) {
+        this.modelPath = modelPath;
+    }
+    async reviewProvisionalFactCandidates(input) {
+        const prompt = [
+            'Return JSON only.',
+            'Task: adjudicate provisional facts for offline consolidation.',
+            'Schema: {"adjudications":[{"factId":"...","action":"verify|archive|reject|supersede|keep_provisional","reason":"...","confidence":0.0,"supersededByFactId":"...","metadata":{"algorithm_review_kind":"..."}}],"aliasMergeSuggestions":[]}',
+            JSON.stringify({
+                rawEpisodes: input.rawEpisodes.map((episode) => ({ id: episode.id, content: episode.content })),
+                facts: input.facts.map((fact) => ({
+                    factId: fact.factId,
+                    predicateFamily: fact.predicateFamily,
+                    predicateValue: fact.predicateValue,
+                    object: fact.object,
+                    confidence: fact.confidence,
+                    status: fact.status,
+                    metadata: fact.metadata
+                })),
+                entities: input.entities.map((entity) => ({
+                    entityId: entity.entityId,
+                    canonicalName: entity.canonicalName,
+                    type: entity.type,
+                    aliases: entity.aliases
+                }))
+            })
+        ].join('\n');
+        const parsed = await this.generateStructuredReply(prompt);
+        return {
+            adjudications: parsed.adjudications || [],
+            aliasMergeSuggestions: []
+        };
+    }
+    async reviewSelfCorrectionCandidates(input) {
+        const prompt = [
+            'Return JSON only.',
+            'Task: propose corrected derived facts for self-correction utterances.',
+            'Schema: {"suggestedFacts":[{"neuronId":"...","subject":"device|user|person|project","predicateFamily":"...","predicateValue":"...","object":"...","entityId":"...","validFrom":0,"certaintyLevel":"possible|probable|high","confidence":0.0,"status":"provisional_enriched","sourceText":"...","metadata":{"algorithm_review_kind":"model_backed_self_correction_repair"}}]}',
+            JSON.stringify({
+                rawEpisodes: input.rawEpisodes.map((episode) => ({ id: episode.id, content: episode.content, createdAt: episode.metadata.createdAt })),
+                facts: input.facts.map((fact) => ({
+                    factId: fact.factId,
+                    neuronId: fact.neuronId,
+                    predicateFamily: fact.predicateFamily,
+                    predicateValue: fact.predicateValue,
+                    object: fact.object,
+                    entityId: fact.entityId,
+                    validFrom: fact.validFrom,
+                    sourceText: fact.sourceText,
+                    metadata: fact.metadata
+                }))
+            })
+        ].join('\n');
+        const parsed = await this.generateStructuredReply(prompt);
+        return {
+            suggestedFacts: parsed.suggestedFacts || []
+        };
+    }
+    async reviewMultiFactExtractionCandidates(input) {
+        const prompt = [
+            'Return JSON only.',
+            'Task: propose missing derived facts and entities for multi-fact extraction repair.',
+            'Schema: {"suggestedEntities":[{"canonicalName":"...","type":"device|project|person|brand|issue","aliases":["..."],"instanceMode":"auto|canonical|new_instance","metadata":{"algorithm_review_kind":"model_backed_entity_wording_repair"}}],"suggestedFacts":[{"neuronId":"...","subject":"device|user|person|project","predicateFamily":"...","predicateValue":"...","object":"...","entityId":"...","validFrom":0,"certaintyLevel":"possible|probable|high","confidence":0.0,"status":"provisional_enriched","sourceText":"...","metadata":{"algorithm_review_kind":"model_backed_multi_fact_repair"}}]}',
+            JSON.stringify({
+                mode: input.mode,
+                rawEpisodes: input.rawEpisodes.map((episode) => ({ id: episode.id, content: episode.content, createdAt: episode.metadata.createdAt })),
+                facts: input.facts.map((fact) => ({
+                    factId: fact.factId,
+                    neuronId: fact.neuronId,
+                    predicateFamily: fact.predicateFamily,
+                    predicateValue: fact.predicateValue,
+                    object: fact.object,
+                    entityId: fact.entityId
+                })),
+                entities: input.entities.map((entity) => ({
+                    entityId: entity.entityId,
+                    canonicalName: entity.canonicalName,
+                    type: entity.type
+                }))
+            })
+        ].join('\n');
+        const parsed = await this.generateStructuredReply(prompt);
+        return {
+            suggestedEntities: parsed.suggestedEntities || [],
+            suggestedFacts: parsed.suggestedFacts || []
+        };
+    }
+    async generateStructuredReply(prompt) {
+        const pipeline = await this.getPipeline();
+        const response = await pipeline(prompt, {
+            max_new_tokens: 512,
+            temperature: 0.1,
+            do_sample: false,
+            return_full_text: false
+        });
+        const raw = response[0]?.generated_text || '';
+        return parseStructuredReply(raw);
+    }
+    async getPipeline() {
+        if (!this.pipelinePromise) {
+            this.pipelinePromise = (async () => {
+                const transformers = await import('@xenova/transformers');
+                return await transformers.pipeline('text-generation', this.modelPath);
+            })();
+        }
+        return this.pipelinePromise;
+    }
+}
+function parseStructuredReply(raw) {
+    const start = raw.indexOf('{');
+    const end = raw.lastIndexOf('}');
+    if (start === -1 || end === -1 || end <= start)
+        return {};
+    try {
+        return JSON.parse(raw.slice(start, end + 1));
+    }
+    catch {
+        return {};
+    }
+}

package/dist/assets/FileAssetIngestionService.d.ts

@@ -0,0 +1,32 @@
+import type { IngestInput, Neuron } from '../types/index.js';
+import { FileAssetStore } from './FileAssetStore.js';
+import { FileBlockStore } from './FileBlockStore.js';
+import { FileChunkStore } from './FileChunkStore.js';
+import { FileChunker } from './FileChunker.js';
+import { FileLoaderRegistry } from './FileLoaderRegistry.js';
+import type { FileAssetPrivacyLevel, FileIngestionResult } from './types.js';
+export interface FileAssetIngestionServiceDeps {
+    assetStore: FileAssetStore;
+    blockStore: FileBlockStore;
+    chunkStore: FileChunkStore;
+    ingest: (input: IngestInput) => Promise<Neuron>;
+    loaderRegistry?: FileLoaderRegistry;
+    chunker?: FileChunker;
+}
+export interface IngestFileOptions {
+    projectId?: string;
+    mimeType?: string;
+    privacyLevel?: FileAssetPrivacyLevel;
+    forceReindex?: boolean;
+    tags?: string[];
+}
+export declare class FileAssetIngestionService {
+    private readonly deps;
+    private readonly loaderRegistry;
+    private readonly chunker;
+    constructor(deps: FileAssetIngestionServiceDeps);
+    ingestFile(filePath: string, options?: IngestFileOptions): Promise<FileIngestionResult>;
+    private decorateChunkText;
+    private inferMimeType;
+}
+//# sourceMappingURL=FileAssetIngestionService.d.ts.map

package/dist/assets/FileAssetIngestionService.js

@@ -0,0 +1,133 @@
+import { createHash, randomUUID } from 'crypto';
+import { basename, extname } from 'node:path';
+import { readFileSync, statSync } from 'node:fs';
+import { FileChunker } from './FileChunker.js';
+import { FileLoaderRegistry } from './FileLoaderRegistry.js';
+export class FileAssetIngestionService {
+    deps;
+    loaderRegistry;
+    chunker;
+    constructor(deps) {
+        this.deps = deps;
+        this.loaderRegistry = deps.loaderRegistry || new FileLoaderRegistry();
+        this.chunker = deps.chunker || new FileChunker();
+    }
+    async ingestFile(filePath, options = {}) {
+        const stat = statSync(filePath);
+        const content = readFileSync(filePath);
+        const extension = extname(filePath).toLowerCase();
+        const contentHash = createHash('sha256').update(content).digest('hex');
+        const existing = this.deps.assetStore.findByPath(filePath, options.projectId);
+        const asset = this.deps.assetStore.upsert({
+            assetId: existing?.assetId,
+            projectId: options.projectId,
+            filePath,
+            originalName: basename(filePath),
+            mimeType: options.mimeType || this.inferMimeType(extension),
+            extension,
+            sizeBytes: stat.size,
+            contentHash,
+            mtimeMs: stat.mtimeMs,
+            ingestStatus: 'tracked',
+            parseStatus: 'not_started',
+            privacyLevel: options.privacyLevel || existing?.privacyLevel || 'local'
+        });
+        if (existing && !options.forceReindex && existing.contentHash === contentHash && existing.ingestStatus === 'indexed') {
+            return {
+                asset,
+                blocks: this.deps.blockStore.listByAsset(asset.assetId),
+                chunks: this.deps.chunkStore.listByAsset(asset.assetId),
+                neurons: [],
+                skipped: true,
+                warnings: []
+            };
+        }
+        const loader = this.loaderRegistry.resolve({ filePath, extension, mimeType: asset.mimeType });
+        if (!loader) {
+            const failed = this.deps.assetStore.upsert({
+                ...asset,
+                ingestStatus: 'failed',
+                parseStatus: 'unsupported'
+            });
+            return {
+                asset: failed,
+                blocks: [],
+                chunks: [],
+                neurons: [],
+                skipped: false,
+                warnings: [{ code: 'unsupported_file_type', message: `No loader for ${extension || filePath}`, recoverable: true }]
+            };
+        }
+        const loaded = await loader.load({
+            assetId: asset.assetId,
+            filePath,
+            projectId: options.projectId,
+            mimeType: asset.mimeType
+        });
+        const blocks = this.deps.blockStore.replaceBlocks(asset.assetId, loaded.blocks);
+        const drafts = this.chunker.chunk(loaded.blocks);
+        const neurons = [];
+        const chunkInputs = [];
+        for (let i = 0; i < drafts.length; i += 1) {
+            const draft = drafts[i];
+            const neuron = await this.deps.ingest({
+                type: 'doc',
+                content: this.decorateChunkText(asset.filePath, draft.text, draft.metadata),
+                filePath: asset.filePath,
+                projectId: options.projectId,
+                sourceType: 'external_tool',
+                tags: [
+                    'namespace:file_asset',
+                    `asset:${asset.assetId}`,
+                    `source_kind:${draft.kind}`,
+                    ...(options.tags || [])
+                ]
+            });
+            neurons.push(neuron);
+            chunkInputs.push({
+                ...draft,
+                chunkId: `chunk-${randomUUID()}`,
+                assetId: asset.assetId,
+                neuronId: neuron.id,
+                chunkIndex: i,
+                textHash: this.chunker.hashText(draft.text)
+            });
+        }
+        const chunks = this.deps.chunkStore.replaceChunks(asset.assetId, chunkInputs);
+        const indexed = this.deps.assetStore.markIndexed(asset.assetId, 'text_extracted') || asset;
+        return {
+            asset: indexed,
+            blocks,
+            chunks,
+            neurons,
+            skipped: false,
+            warnings: loaded.warnings
+        };
+    }
+    decorateChunkText(filePath, text, metadata) {
+        const lines = [`Source: ${filePath}`];
+        if (metadata?.page)
+            lines.push(`Page: ${metadata.page}`);
+        if (metadata?.sheetName)
+            lines.push(`Sheet: ${metadata.sheetName}`);
+        if (metadata?.rowStart || metadata?.rowEnd)
+            lines.push(`Rows: ${metadata.rowStart || ''}-${metadata.rowEnd || ''}`);
+        if (metadata?.lineStart || metadata?.lineEnd)
+            lines.push(`Lines: ${metadata.lineStart || ''}-${metadata.lineEnd || ''}`);
+        return `${lines.join('\n')}\n\n${text}`;
+    }
+    inferMimeType(extension) {
+        const table = {
+            '.txt': 'text/plain',
+            '.md': 'text/markdown',
+            '.log': 'text/plain',
+            '.csv': 'text/csv',
+            '.json': 'application/json',
+            '.yaml': 'application/yaml',
+            '.yml': 'application/yaml',
+            '.html': 'text/html',
+            '.htm': 'text/html'
+        };
+        return table[extension] || (extension ? `text/x-${extension.slice(1)}` : 'application/octet-stream');
+    }
+}

package/dist/assets/FileAssetStore.d.ts

@@ -0,0 +1,36 @@
+import Database from 'bun:sqlite';
+import type { FileAssetIngestStatus, FileAssetParseStatus, FileAssetPrivacyLevel, FileAssetRecord } from './types.js';
+export interface UpsertFileAssetInput {
+    assetId?: string;
+    projectId?: string;
+    filePath: string;
+    originalName?: string;
+    mimeType?: string;
+    extension?: string;
+    sizeBytes: number;
+    contentHash: string;
+    mtimeMs: number;
+    ingestStatus?: FileAssetIngestStatus;
+    parseStatus?: FileAssetParseStatus;
+    privacyLevel?: FileAssetPrivacyLevel;
+    lastIndexedAt?: number;
+    metadata?: Record<string, unknown>;
+}
+export declare class FileAssetStore {
+    private readonly db;
+    constructor(db: Database);
+    initSchema(): void;
+    upsert(input: UpsertFileAssetInput): FileAssetRecord;
+    markIndexed(assetId: string, parseStatus?: FileAssetParseStatus): FileAssetRecord | null;
+    getById(assetId: string): FileAssetRecord | null;
+    findByPath(filePath: string, projectId?: string): FileAssetRecord | null;
+    listByQuery(input: {
+        query?: string;
+        projectId?: string;
+        extension?: string;
+        mimeType?: string;
+        limit?: number;
+    }): FileAssetRecord[];
+    private mapRow;
+}
+//# sourceMappingURL=FileAssetStore.d.ts.map