@pellux/goodvibes-sdk 0.27.8 → 0.27.10

package/dist/_internal/platform/knowledge/semantic/self-improvement.js

@@ -0,0 +1,486 @@
+import { isGeneratedKnowledgeSource } from '../generated-projections.js';
+import { getKnowledgeSpaceId, normalizeKnowledgeSpaceId } from '../spaces.js';
+import { readRecord, readString, semanticHash, semanticMetadata, semanticSlug, sourceKnowledgeSpace, uniqueStrings, } from './utils.js';
+const RETRY_DELAY_MS = 6 * 60 * 60 * 1000;
+export async function runKnowledgeSemanticSelfImprovement(context, input = {}) {
+    await context.store.init();
+    const sourceIdFilter = input.sourceIds?.length ? new Set(input.sourceIds) : null;
+    const gapIdFilter = input.gapIds?.length ? new Set(input.gapIds) : null;
+    const spaceId = resolveSelfImproveSpace(context.store, input);
+    const createdGaps = await discoverIntrinsicGaps(context.store, spaceId, sourceIdFilter);
+    const gaps = collectCandidateGaps(context.store, spaceId, sourceIdFilter, gapIdFilter)
+        .slice(0, Math.max(1, input.limit ?? 24));
+    let repairableGaps = 0;
+    let suppressedGaps = 0;
+    let skippedGaps = 0;
+    let searched = 0;
+    let ingestedSources = 0;
+    let linkedRepairs = 0;
+    const errors = [];
+    for (const gap of gaps) {
+        const gapContext = buildGapContext(context.store, spaceId, gap);
+        const classification = classifyGap(gapContext, input.force === true);
+        if (classification.action === 'suppress') {
+            await suppressGap(context.store, gap, classification.reason, spaceId);
+            suppressedGaps += 1;
+            continue;
+        }
+        if (classification.action === 'skip') {
+            skippedGaps += 1;
+            if (classification.markAttempt) {
+                await markGapRepairAttempt(context.store, gap, spaceId, {
+                    status: classification.status ?? 'skipped',
+                    reason: classification.reason,
+                });
+            }
+            continue;
+        }
+        repairableGaps += 1;
+        if (!context.gapRepairer) {
+            skippedGaps += 1;
+            await markGapRepairAttempt(context.store, gap, spaceId, {
+                status: 'no_repairer',
+                reason: 'No semantic gap repairer is configured.',
+            });
+            continue;
+        }
+        const repairKey = `${spaceId}:${gap.id}`;
+        if (context.activeGapRepairs.has(repairKey)) {
+            skippedGaps += 1;
+            continue;
+        }
+        context.activeGapRepairs.add(repairKey);
+        try {
+            const result = await context.gapRepairer({
+                spaceId,
+                query: gap.title,
+                gaps: [gap],
+                sources: gapContext.sources,
+                linkedObjects: gapContext.linkedObjects,
+                facts: gapContext.facts,
+            });
+            if (result?.searched)
+                searched += 1;
+            ingestedSources += result?.ingestedSourceIds.length ?? 0;
+            linkedRepairs += await linkRepairSources(context.store, spaceId, gap, result?.ingestedSourceIds ?? [], result?.query ?? gap.title);
+            await markGapRepairAttempt(context.store, gap, spaceId, {
+                status: result?.ingestedSourceIds.length ? 'repaired' : 'searched_no_sources',
+                reason: result?.reason,
+                query: result?.query,
+            });
+        }
+        catch (error) {
+            errors.push({ gapId: gap.id, error: error instanceof Error ? error.message : String(error) });
+            await markGapRepairAttempt(context.store, gap, spaceId, {
+                status: 'failed',
+                reason: error instanceof Error ? error.message : String(error),
+            });
+        }
+        finally {
+            context.activeGapRepairs.delete(repairKey);
+        }
+    }
+    return {
+        scannedGaps: gaps.length,
+        createdGaps,
+        repairableGaps,
+        suppressedGaps,
+        skippedGaps,
+        searched,
+        ingestedSources,
+        linkedRepairs,
+        errors,
+    };
+}
+function resolveSelfImproveSpace(store, input) {
+    if (input.knowledgeSpaceId)
+        return normalizeKnowledgeSpaceId(input.knowledgeSpaceId);
+    const firstSource = input.sourceIds?.map((id) => store.getSource(id)).find((source) => Boolean(source));
+    if (firstSource)
+        return sourceKnowledgeSpace(firstSource);
+    const firstGap = input.gapIds?.map((id) => store.getNode(id)).find((node) => Boolean(node));
+    return normalizeKnowledgeSpaceId(firstGap ? getKnowledgeSpaceId(firstGap) : undefined);
+}
+async function discoverIntrinsicGaps(store, spaceId, sourceIdFilter) {
+    const edges = store.listEdges();
+    const sourcesById = new Map(store.listSources(10_000)
+        .filter((source) => source.status === 'indexed')
+        .filter((source) => !isGeneratedKnowledgeSource(source))
+        .filter((source) => getKnowledgeSpaceId(source) === spaceId)
+        .filter((source) => !sourceIdFilter || sourceIdFilter.has(source.id))
+        .map((source) => [source.id, source]));
+    const nodesById = new Map(store.listNodes(10_000).filter((node) => getKnowledgeSpaceId(node) === spaceId).map((node) => [node.id, node]));
+    const createdIds = new Set();
+    let created = 0;
+    for (const source of sourcesById.values()) {
+        const linkedObjects = linkedObjectsForSource(source.id, edges, nodesById);
+        const facts = factsForSource(source.id, edges, nodesById);
+        for (const subject of linkedObjects.filter(isConcreteRepairSubject)) {
+            if (!shouldCreateIntrinsicFeatureGap(subject, facts, source))
+                continue;
+            if (await upsertIntrinsicFeatureGap(store, spaceId, subject, [source], createdIds))
+                created += 1;
+        }
+    }
+    if (!sourceIdFilter) {
+        for (const subject of nodesById.values()) {
+            if (!isConcreteRepairSubject(subject))
+                continue;
+            const sourceList = sourcesForObject(subject.id, edges, sourcesById);
+            const facts = [
+                ...sourceList.flatMap((source) => factsForSource(source.id, edges, nodesById)),
+                ...factsForObject(subject.id, edges, nodesById),
+            ];
+            const coverage = factCoverage(facts);
+            if (coverage.coreFactCount >= 4 && coverage.coveredAreas.size >= 3)
+                continue;
+            if (!hasSpecificIdentity(subject, sourceList[0]))
+                continue;
+            if (await upsertIntrinsicFeatureGap(store, spaceId, subject, sourceList, createdIds))
+                created += 1;
+        }
+    }
+    return created;
+}
+async function upsertIntrinsicFeatureGap(store, spaceId, subject, sources, createdIds) {
+    const id = `sem-intrinsic-gap-${semanticHash(spaceId, subject.id, 'features-specifications')}`;
+    if (createdIds.has(id))
+        return false;
+    createdIds.add(id);
+    const existing = store.getNode(id);
+    if (existing?.status === 'active' && readString(existing.metadata.repairStatus) === 'repaired')
+        return false;
+    const title = `What are the complete features and specifications for ${subjectTitle(subject)}?`;
+    const primarySource = sources[0];
+    const gap = await store.upsertNode({
+        id,
+        kind: 'knowledge_gap',
+        slug: semanticSlug(`${spaceId}-intrinsic-gap-${subject.title}`),
+        title,
+        summary: `The current source-backed facts for ${subjectTitle(subject)} do not yet cover the full feature/specification profile.`,
+        aliases: [subject.title, ...subject.aliases].slice(0, 8),
+        confidence: 75,
+        ...(primarySource ? { sourceId: primarySource.id } : {}),
+        metadata: semanticMetadata(spaceId, {
+            semanticKind: 'gap',
+            gapKind: 'intrinsic_features',
+            subject: subject.title,
+            sourceIds: sources.map((source) => source.id),
+            linkedObjectIds: [subject.id],
+            repairStatus: readString(existing?.metadata.repairStatus) ?? 'open',
+            createdBy: 'semantic-self-improvement',
+        }),
+    });
+    for (const source of sources) {
+        await store.upsertEdge({
+            fromKind: 'source',
+            fromId: source.id,
+            toKind: 'node',
+            toId: gap.id,
+            relation: 'has_gap',
+            metadata: semanticMetadata(spaceId, { intrinsic: true }),
+        });
+    }
+    await store.upsertEdge({
+        fromKind: 'node',
+        fromId: subject.id,
+        toKind: 'node',
+        toId: gap.id,
+        relation: 'has_gap',
+        metadata: semanticMetadata(spaceId, { intrinsic: true }),
+    });
+    await store.upsertIssue({
+        id: `sem-intrinsic-gap-issue-${semanticHash(spaceId, subject.id, 'features-specifications')}`,
+        severity: 'info',
+        code: 'knowledge.intrinsic_gap',
+        message: title,
+        status: 'open',
+        ...(primarySource ? { sourceId: primarySource.id } : {}),
+        nodeId: gap.id,
+        metadata: semanticMetadata(spaceId, {
+            namespace: `knowledge:${spaceId}:semantic`,
+            subjectId: subject.id,
+            gapKind: 'intrinsic_features',
+        }),
+    });
+    return !existing;
+}
+function collectCandidateGaps(store, spaceId, sourceIdFilter, gapIdFilter) {
+    const edges = store.listEdges();
+    return store.listNodes(10_000)
+        .filter((node) => node.kind === 'knowledge_gap' && node.status === 'active')
+        .filter((node) => getKnowledgeSpaceId(node) === spaceId)
+        .filter((node) => !gapIdFilter || gapIdFilter.has(node.id))
+        .filter((node) => !sourceIdFilter || gapMatchesSourceFilter(node, sourceIdFilter, edges))
+        .sort((left, right) => right.confidence - left.confidence || left.id.localeCompare(right.id));
+}
+function gapMatchesSourceFilter(gap, sourceIdFilter, edges) {
+    if (gap.sourceId && sourceIdFilter.has(gap.sourceId))
+        return true;
+    if (readStringArray(gap.metadata.sourceIds).some((sourceId) => sourceIdFilter.has(sourceId)))
+        return true;
+    return edges.some((edge) => (edge.fromKind === 'source'
+        && sourceIdFilter.has(edge.fromId)
+        && edge.toKind === 'node'
+        && edge.toId === gap.id));
+}
+function buildGapContext(store, spaceId, gap) {
+    const edges = store.listEdges();
+    const sourcesById = new Map(store.listSources(10_000).filter((source) => getKnowledgeSpaceId(source) === spaceId).map((source) => [source.id, source]));
+    const nodesById = new Map(store.listNodes(10_000).filter((node) => getKnowledgeSpaceId(node) === spaceId).map((node) => [node.id, node]));
+    const sourceIds = uniqueStrings([
+        gap.sourceId,
+        ...readStringArray(gap.metadata.sourceIds),
+        ...edges
+            .filter((edge) => edge.toKind === 'node' && edge.toId === gap.id && edge.fromKind === 'source')
+            .map((edge) => edge.fromId),
+    ]);
+    const directSources = sourceIds.map((id) => sourcesById.get(id)).filter((source) => Boolean(source));
+    const linkedObjects = uniqueById([
+        ...readStringArray(gap.metadata.linkedObjectIds).map((id) => nodesById.get(id)).filter((node) => Boolean(node)),
+        ...sourceIds.flatMap((sourceId) => linkedObjectsForSource(sourceId, edges, nodesById)),
+        ...edges
+            .filter((edge) => edge.fromKind === 'node' && edge.toKind === 'node' && edge.toId === gap.id)
+            .map((edge) => nodesById.get(edge.fromId))
+            .filter((node) => Boolean(node)),
+    ]);
+    const sources = uniqueById([
+        ...directSources,
+        ...linkedObjects.flatMap((object) => sourcesForObject(object.id, edges, sourcesById)),
+    ]);
+    const facts = uniqueById([
+        ...sources.flatMap((source) => factsForSource(source.id, edges, nodesById)),
+        ...linkedObjects.flatMap((object) => factsForObject(object.id, edges, nodesById)),
+    ]);
+    return { gap, sources, linkedObjects, facts };
+}
+function classifyGap(context, force) {
+    const status = readString(context.gap.metadata.repairStatus);
+    const nextAttemptAt = readNumber(context.gap.metadata.nextRepairAttemptAt);
+    if (!force && status === 'repaired')
+        return { action: 'skip', reason: 'Gap already has linked repair sources.' };
+    if (!force && nextAttemptAt && nextAttemptAt > Date.now())
+        return { action: 'skip', reason: 'Gap repair retry window has not elapsed.' };
+    if (hasRepairEdge(context))
+        return { action: 'skip', reason: 'Gap already has a repair source.' };
+    if (isNotApplicableGap(context))
+        return { action: 'suppress', reason: 'The gap is not applicable to the linked subject.' };
+    if (!hasConcreteSubject(context)) {
+        return { action: 'skip', reason: 'Gap has no concrete source or subject for automatic repair.', status: 'needs_context', markAttempt: true };
+    }
+    if (context.sources.length === 0 && context.linkedObjects.length === 0) {
+        return { action: 'skip', reason: 'Gap has no source context for automatic repair.', status: 'needs_context', markAttempt: true };
+    }
+    return { action: 'repair' };
+}
+function hasRepairEdge(context) {
+    return context.sources.some((source) => source.metadata.sourceDiscovery && readRecord(source.metadata.sourceDiscovery).purpose === 'semantic-gap-repair')
+        || context.facts.some((fact) => readString(fact.metadata.repairStatus) === 'repaired');
+}
+function isNotApplicableGap(context) {
+    const text = `${context.gap.title} ${context.gap.summary ?? ''}`.toLowerCase();
+    if (text.includes('battery')) {
+        return context.linkedObjects.some((node) => node.metadata.batteryPowered === false || readString(node.metadata.batteryType) === 'none');
+    }
+    return false;
+}
+function hasConcreteSubject(context) {
+    return context.linkedObjects.some((node) => {
+        if (isConcreteRepairSubject(node))
+            return true;
+        return Boolean(readString(node.metadata.manufacturer) && readString(node.metadata.model));
+    }) || context.sources.some((source) => Boolean(source.title || source.sourceUri || source.canonicalUri));
+}
+async function suppressGap(store, gap, reason, spaceId) {
+    await store.upsertNode({
+        id: gap.id,
+        kind: gap.kind,
+        slug: gap.slug,
+        title: gap.title,
+        summary: gap.summary,
+        aliases: gap.aliases,
+        status: 'stale',
+        confidence: gap.confidence,
+        sourceId: gap.sourceId,
+        metadata: {
+            ...gap.metadata,
+            repairStatus: 'not_applicable',
+            repairReason: reason,
+            repairedAt: Date.now(),
+        },
+    });
+    for (const issue of store.listIssues(10_000).filter((entry) => entry.nodeId === gap.id && entry.status === 'open')) {
+        await resolveIssue(store, issue, spaceId, reason ?? 'Gap was classified as not applicable.');
+    }
+}
+async function markGapRepairAttempt(store, gap, spaceId, details) {
+    await store.upsertNode({
+        id: gap.id,
+        kind: gap.kind,
+        slug: gap.slug,
+        title: gap.title,
+        summary: gap.summary,
+        aliases: gap.aliases,
+        status: gap.status,
+        confidence: gap.confidence,
+        sourceId: gap.sourceId,
+        metadata: {
+            ...gap.metadata,
+            repairStatus: details.status,
+            ...(details.reason ? { repairReason: details.reason } : {}),
+            ...(details.query ? { repairQuery: details.query } : {}),
+            lastRepairAttemptAt: Date.now(),
+            nextRepairAttemptAt: details.status === 'searched_no_sources' || details.status === 'failed'
+                ? Date.now() + RETRY_DELAY_MS
+                : undefined,
+            knowledgeSpaceId: spaceId,
+        },
+    });
+}
+async function linkRepairSources(store, spaceId, gap, sourceIds, query) {
+    let linked = 0;
+    for (const sourceId of sourceIds) {
+        if (!store.getSource(sourceId))
+            continue;
+        await store.upsertEdge({
+            fromKind: 'source',
+            fromId: sourceId,
+            toKind: 'node',
+            toId: gap.id,
+            relation: 'repairs_gap',
+            weight: 0.8,
+            metadata: semanticMetadata(spaceId, {
+                query,
+                repairedAt: Date.now(),
+            }),
+        });
+        linked += 1;
+    }
+    return linked;
+}
+async function resolveIssue(store, issue, spaceId, reason) {
+    await store.upsertIssue({
+        id: issue.id,
+        severity: issue.severity,
+        code: issue.code,
+        message: issue.message,
+        status: 'resolved',
+        sourceId: issue.sourceId,
+        nodeId: issue.nodeId,
+        metadata: semanticMetadata(spaceId, {
+            ...issue.metadata,
+            resolution: {
+                reason,
+                resolvedBy: 'semantic-self-improvement',
+                resolvedAt: Date.now(),
+            },
+        }),
+    });
+}
+function linkedObjectsForSource(sourceId, edges, nodesById) {
+    return uniqueById(edges
+        .filter((edge) => edge.fromKind === 'source' && edge.fromId === sourceId && edge.toKind === 'node')
+        .map((edge) => nodesById.get(edge.toId))
+        .filter((node) => Boolean(node))
+        .filter((node) => node.status !== 'stale')
+        .filter((node) => node.metadata.semanticKind !== 'fact' && node.metadata.semanticKind !== 'gap' && node.kind !== 'wiki_page'));
+}
+function factsForSource(sourceId, edges, nodesById) {
+    return uniqueById(edges
+        .filter((edge) => edge.fromKind === 'source' && edge.fromId === sourceId && edge.toKind === 'node')
+        .map((edge) => nodesById.get(edge.toId))
+        .filter((node) => Boolean(node))
+        .filter((node) => node.kind === 'fact' && node.status !== 'stale'));
+}
+function sourcesForObject(objectId, edges, sourcesById) {
+    return uniqueById(edges
+        .filter((edge) => edge.fromKind === 'source' && edge.toKind === 'node' && edge.toId === objectId)
+        .map((edge) => sourcesById.get(edge.fromId))
+        .filter((source) => Boolean(source))
+        .filter((source) => source.status === 'indexed' && !isGeneratedKnowledgeSource(source)));
+}
+function factsForObject(objectId, edges, nodesById) {
+    const directlyDescribing = edges
+        .filter((edge) => edge.fromKind === 'node' && edge.toKind === 'node' && edge.toId === objectId && edge.relation === 'describes')
+        .map((edge) => nodesById.get(edge.fromId));
+    return uniqueById(directlyDescribing
+        .filter((node) => Boolean(node))
+        .filter((node) => node.kind === 'fact' && node.status !== 'stale'));
+}
+function shouldCreateIntrinsicFeatureGap(subject, facts, source) {
+    if (!isConcreteRepairSubject(subject))
+        return false;
+    if (!hasSpecificIdentity(subject, source))
+        return false;
+    const coverage = factCoverage(facts);
+    return coverage.coreFactCount < 4 || coverage.coveredAreas.size < 3;
+}
+function isConcreteRepairSubject(node) {
+    if (node.status === 'stale')
+        return false;
+    if (typeof node.metadata.semanticKind === 'string')
+        return false;
+    if (['ha_device', 'ha_integration', 'service', 'provider', 'capability'].includes(node.kind))
+        return true;
+    if (node.kind !== 'knowledge_entity')
+        return false;
+    const entityKind = readString(node.metadata.entityKind)?.toLowerCase() ?? '';
+    return /\b(device|product|service|appliance|controller|platform|provider|tool)\b/.test(entityKind);
+}
+function hasSpecificIdentity(subject, source) {
+    if (readString(subject.metadata.model))
+        return true;
+    if (readString(subject.metadata.manufacturer) && readString(subject.metadata.model))
+        return true;
+    const text = `${subject.title} ${subject.aliases.join(' ')} ${source?.title ?? ''}`;
+    return /\b[A-Z]{2,}[-_ ]?[0-9][A-Z0-9._-]{2,}\b/.test(text);
+}
+function factCoverage(facts) {
+    const coveredAreas = new Set();
+    let coreFactCount = 0;
+    for (const fact of facts) {
+        const kind = readString(fact.metadata.factKind);
+        if (!['feature', 'capability', 'specification', 'compatibility', 'configuration'].includes(kind ?? ''))
+            continue;
+        coreFactCount += 1;
+        const text = `${fact.title} ${fact.summary ?? ''} ${fact.aliases.join(' ')} ${JSON.stringify(fact.metadata)}`.toLowerCase();
+        for (const [area, pattern] of [
+            ['display', /\b(display|screen|resolution|hdr|dolby vision|refresh|panel)\b/],
+            ['ports', /\b(hdmi|usb|ethernet|port|input|output|earc|arc)\b/],
+            ['audio', /\b(audio|speaker|dolby|pcm|sound)\b/],
+            ['network', /\b(wi-?fi|bluetooth|ethernet|network|wireless)\b/],
+            ['smart', /\b(app|webos|smart|assistant|voice|stream)\b/],
+            ['control', /\b(remote|rs-?232|control|automation|api)\b/],
+        ]) {
+            if (pattern.test(text))
+                coveredAreas.add(area);
+        }
+    }
+    return { coreFactCount, coveredAreas };
+}
+function subjectTitle(subject) {
+    return uniqueStrings([
+        readString(subject.metadata.manufacturer),
+        readString(subject.metadata.model),
+        subject.title,
+    ]).join(' ');
+}
+function uniqueById(items) {
+    const seen = new Set();
+    const result = [];
+    for (const item of items) {
+        if (!item || seen.has(item.id))
+            continue;
+        seen.add(item.id);
+        result.push(item);
+    }
+    return result;
+}
+function readStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return uniqueStrings(value.map((entry) => typeof entry === 'string' ? entry : undefined));
+}
+function readNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}

package/dist/_internal/platform/knowledge/semantic/service.d.ts

@@ -1,14 +1,17 @@
 import type { KnowledgeStore } from '../store.js';
 import type { KnowledgeSourceRecord } from '../types.js';
-import type { KnowledgeSemanticAnswerInput, KnowledgeSemanticAnswerResult, KnowledgeSemanticEnrichmentResult, KnowledgeSemanticLlm } from './types.js';
+import type { KnowledgeSemanticAnswerInput, KnowledgeSemanticAnswerResult, KnowledgeSemanticEnrichmentResult, KnowledgeSemanticGapRepairer, KnowledgeSemanticLlm, KnowledgeSemanticSelfImproveInput, KnowledgeSemanticSelfImproveResult } from './types.js';
 export interface KnowledgeSemanticServiceOptions {
     readonly llm?: KnowledgeSemanticLlm | null;
     readonly maxLlmSourcesPerReindex?: number;
+    readonly gapRepairer?: KnowledgeSemanticGapRepairer | null;
 }
 export declare class KnowledgeSemanticService {
     private readonly store;
-    private readonly options;
+    private options;
+    private readonly activeGapRepairs;
     constructor(store: KnowledgeStore, options?: KnowledgeSemanticServiceOptions);
+    setGapRepairer(gapRepairer: KnowledgeSemanticGapRepairer | null | undefined): void;
     enrichSource(sourceId: string, input?: {
         readonly force?: boolean;
         readonly knowledgeSpaceId?: string;
@@ -32,7 +35,11 @@ export declare class KnowledgeSemanticService {
             readonly sourceId: string;
             readonly error: string;
         }[];
+        readonly selfImprovement: KnowledgeSemanticSelfImproveResult;
     }>;
     answer(input: KnowledgeSemanticAnswerInput): Promise<KnowledgeSemanticAnswerResult>;
+    selfImprove(input?: KnowledgeSemanticSelfImproveInput): Promise<KnowledgeSemanticSelfImproveResult>;
+    private queueGapRepair;
+    private hasGapRepairSource;
 }
 //# sourceMappingURL=service.d.ts.map

package/dist/_internal/platform/knowledge/semantic/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/knowledge/semantic/service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAGzD,OAAO,KAAK,EACV,4BAA4B,EAC5B,6BAA6B,EAC7B,iCAAiC,EACjC,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAGpB,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,GAAG,CAAC,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAC3C,QAAQ,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAC;CAC3C;AAED,qBAAa,wBAAwB;IAEjC,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO;gBADP,KAAK,EAAE,cAAc,EACrB,OAAO,GAAE,+BAAoC;IAG1D,YAAY,CAChB,QAAQ,EAAE,MAAM,EAChB,KAAK,GAAE;QAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAO,GAC3E,OAAO,CAAC,iCAAiC,GAAG,IAAI,CAAC;IAO9C,aAAa,CACjB,OAAO,EAAE,SAAS,qBAAqB,EAAE,EACzC,KAAK,GAAE;QAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAO,GACpG,OAAO,CAAC,SAAS,iCAAiC,EAAE,CAAC;IASlD,OAAO,CAAC,KAAK,GAAE;QACnB,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QACvC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QACzB,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;KAC/B,GAAG,OAAO,CAAC;QACf,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,MAAM,EAAE,SAAS;YAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;KACnF,CAAC;IA6BI,MAAM,CAAC,KAAK,EAAE,4BAA4B,GAAG,OAAO,CAAC,6BAA6B,CAAC;CAI1F"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/knowledge/semantic/service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAIzD,OAAO,KAAK,EACV,4BAA4B,EAC5B,6BAA6B,EAC7B,iCAAiC,EACjC,4BAA4B,EAC5B,oBAAoB,EACpB,iCAAiC,EACjC,kCAAkC,EACnC,MAAM,YAAY,CAAC;AAKpB,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,GAAG,CAAC,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAC3C,QAAQ,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAC;IAC1C,QAAQ,CAAC,WAAW,CAAC,EAAE,4BAA4B,GAAG,IAAI,CAAC;CAC5D;AAED,qBAAa,wBAAwB;IAIjC,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,OAAO;IAJjB,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAqB;gBAGnC,KAAK,EAAE,cAAc,EAC9B,OAAO,GAAE,+BAAoC;IAGvD,cAAc,CAAC,WAAW,EAAE,4BAA4B,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI;IAO5E,YAAY,CAChB,QAAQ,EAAE,MAAM,EAChB,KAAK,GAAE;QAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAO,GAC3E,OAAO,CAAC,iCAAiC,GAAG,IAAI,CAAC;IAO9C,aAAa,CACjB,OAAO,EAAE,SAAS,qBAAqB,EAAE,EACzC,KAAK,GAAE;QAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAO,GACpG,OAAO,CAAC,SAAS,iCAAiC,EAAE,CAAC;IASlD,OAAO,CAAC,KAAK,GAAE;QACnB,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QACvC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QACzB,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;KAC/B,GAAG,OAAO,CAAC;QACf,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,MAAM,EAAE,SAAS;YAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;QAClF,QAAQ,CAAC,eAAe,EAAE,kCAAkC,CAAC;KAC9D,CAAC;IAoCI,MAAM,CAAC,KAAK,EAAE,4BAA4B,GAAG,OAAO,CAAC,6BAA6B,CAAC;IAOnF,WAAW,CAAC,KAAK,GAAE,iCAAsC,GAAG,OAAO,CAAC,kCAAkC,CAAC;IAyB7G,OAAO,CAAC,cAAc;IA2CtB,OAAO,CAAC,kBAAkB;CAS3B"}

package/dist/_internal/platform/knowledge/semantic/service.js

@@ -1,13 +1,23 @@
+import { getKnowledgeSpaceId } from '../spaces.js';
 import { answerKnowledgeQuery } from './answer.js';
 import { enrichKnowledgeSource } from './enrichment.js';
 import { readRecord, readString, sourceSemanticHash, sourceSemanticText } from './utils.js';
+import { uniqueStrings } from './utils.js';
+import { runKnowledgeSemanticSelfImprovement } from './self-improvement.js';
 export class KnowledgeSemanticService {
     store;
     options;
+    activeGapRepairs = new Set();
     constructor(store, options = {}) {
         this.store = store;
         this.options = options;
     }
+    setGapRepairer(gapRepairer) {
+        this.options = {
+            ...this.options,
+            gapRepairer: gapRepairer ?? null,
+        };
+    }
     async enrichSource(sourceId, input = {}) {
         await this.store.init();
         const source = this.store.getSource(sourceId);
@@ -54,11 +64,97 @@ export class KnowledgeSemanticService {
                 errors.push({ sourceId: source.id, error: error instanceof Error ? error.message : String(error) });
             }
         }
-        return { scanned: sources.length, enriched, skipped, failed, errors };
+        const selfImprovement = await this.selfImprove({
+            knowledgeSpaceId: input.knowledgeSpaceId,
+            sourceIds: input.sourceIds,
+            force: input.force,
+            reason: 'reindex',
+            limit: input.limit,
+        });
+        return { scanned: sources.length, enriched, skipped, failed, errors, selfImprovement };
     }
     async answer(input) {
         await this.store.init();
-        return answerKnowledgeQuery({ store: this.store, llm: this.options.llm }, input);
+        const answer = await answerKnowledgeQuery({ store: this.store, llm: this.options.llm }, input);
+        this.queueGapRepair(answer);
+        return answer;
+    }
+    async selfImprove(input = {}) {
+        await this.store.init();
+        if (!input.knowledgeSpaceId && !input.sourceIds?.length && !input.gapIds?.length) {
+            const spaces = uniqueStrings([
+                ...this.store.listSources(10_000).map((source) => getKnowledgeSpaceId(source)),
+                ...this.store.listNodes(10_000).map((node) => getKnowledgeSpaceId(node)),
+            ]);
+            let combined = emptySelfImproveResult();
+            for (const spaceId of spaces) {
+                const result = await runKnowledgeSemanticSelfImprovement({
+                    store: this.store,
+                    gapRepairer: this.options.gapRepairer,
+                    activeGapRepairs: this.activeGapRepairs,
+                }, { ...input, knowledgeSpaceId: spaceId });
+                combined = mergeSelfImproveResults(combined, result);
+            }
+            return combined;
+        }
+        return runKnowledgeSemanticSelfImprovement({
+            store: this.store,
+            gapRepairer: this.options.gapRepairer,
+            activeGapRepairs: this.activeGapRepairs,
+        }, input);
+    }
+    queueGapRepair(answer) {
+        if (!this.options.gapRepairer || answer.answer.gaps.length === 0 || answer.answer.sources.length === 0)
+            return;
+        const gaps = answer.answer.gaps.filter((gap) => !this.hasGapRepairSource(answer.spaceId, gap.id));
+        if (gaps.length === 0)
+            return;
+        const repairKey = `${answer.spaceId}:${gaps.map((gap) => gap.id).sort().join(',')}`;
+        if (this.activeGapRepairs.has(repairKey))
+            return;
+        this.activeGapRepairs.add(repairKey);
+        const repairer = this.options.gapRepairer;
+        void repairer({
+            spaceId: answer.spaceId,
+            query: answer.query,
+            gaps,
+            sources: answer.answer.sources,
+            linkedObjects: answer.answer.linkedObjects,
+            facts: answer.answer.facts,
+        })
+            .then(async (result) => {
+            if (!result?.ingestedSourceIds.length)
+                return;
+            for (const sourceId of result.ingestedSourceIds) {
+                for (const gap of gaps) {
+                    await this.store.upsertEdge({
+                        fromKind: 'source',
+                        fromId: sourceId,
+                        toKind: 'node',
+                        toId: gap.id,
+                        relation: 'repairs_gap',
+                        weight: 0.8,
+                        metadata: {
+                            semantic: true,
+                            knowledgeSpaceId: answer.spaceId,
+                            query: result.query ?? answer.query,
+                            repairedAt: Date.now(),
+                        },
+                    });
+                }
+            }
+        })
+            .catch(() => { })
+            .finally(() => {
+            this.activeGapRepairs.delete(repairKey);
+        });
+    }
+    hasGapRepairSource(spaceId, gapId) {
+        return this.store.listEdges().some((edge) => (edge.relation === 'repairs_gap'
+            && edge.toKind === 'node'
+            && edge.toId === gapId
+            && edge.fromKind === 'source'
+            && readString(edge.metadata.knowledgeSpaceId) === spaceId));
     }
 }
 function sourceCanUseLlmUpgrade(store, source) {
@@ -70,3 +166,29 @@ function sourceCanUseLlmUpgrade(store, source) {
     return existingSemantic.textHash !== sourceSemanticHash(source, extraction)
         || readString(existingSemantic.extractor) !== 'llm';
 }
+function emptySelfImproveResult() {
+    return {
+        scannedGaps: 0,
+        createdGaps: 0,
+        repairableGaps: 0,
+        suppressedGaps: 0,
+        skippedGaps: 0,
+        searched: 0,
+        ingestedSources: 0,
+        linkedRepairs: 0,
+        errors: [],
+    };
+}
+function mergeSelfImproveResults(left, right) {
+    return {
+        scannedGaps: left.scannedGaps + right.scannedGaps,
+        createdGaps: left.createdGaps + right.createdGaps,
+        repairableGaps: left.repairableGaps + right.repairableGaps,
+        suppressedGaps: left.suppressedGaps + right.suppressedGaps,
+        skippedGaps: left.skippedGaps + right.skippedGaps,
+        searched: left.searched + right.searched,
+        ingestedSources: left.ingestedSources + right.ingestedSources,
+        linkedRepairs: left.linkedRepairs + right.linkedRepairs,
+        errors: [...left.errors, ...right.errors],
+    };
+}