@pellux/goodvibes-sdk 0.18.14 → 0.18.15

package/dist/_internal/platform/intelligence/config.js

@@ -2,8 +2,8 @@
  * Per-language configuration for CodeIntelligence.
  *
  * Config is loaded from (in priority order, higher overrides lower):
- *   1. .goodvibes/tui/languages/{langId}.json  (project-level)
- *   2. ~/.goodvibes/tui/languages/{langId}.json (user-level)
+ *   1. .goodvibes/goodvibes/languages/{langId}.json  (project-level)
+ *   2. ~/.goodvibes/goodvibes/languages/{langId}.json (user-level)
  *   3. Built-in defaults (this file)
  */
 import { existsSync, readFileSync } from 'fs';
@@ -88,8 +88,8 @@ function readConfigFile(filePath) {
  */
 export function loadLanguageConfigs(roots) {
     const result = getDefaultConfigs();
-    const userDir = join(roots.homeDirectory, '.goodvibes', 'tui', 'languages');
-    const projectDir = join(roots.workingDirectory, '.goodvibes', 'tui', 'languages');
+    const userDir = join(roots.homeDirectory, '.goodvibes', 'goodvibes', 'languages');
+    const projectDir = join(roots.workingDirectory, '.goodvibes', 'goodvibes', 'languages');
     // Collect all known language IDs (from defaults + scan would go here).
     // For now we apply overrides only for IDs we already know about.
     for (const [langId, defaultCfg] of result.entries()) {

package/dist/_internal/platform/intelligence/facade.d.ts

@@ -32,7 +32,7 @@ export declare class CodeIntelligence {
     /**
      * Initialize all services. Call once at startup.
      * Loads language configs and registers LSP server commands with LspService
-     * so that user/project overrides in .goodvibes/tui/languages/ are respected.
+     * so that user/project overrides in .goodvibes/goodvibes/languages/ are respected.
      */
     initialize(): Promise<void>;
     /** Shutdown all owned services for this facade instance. */

package/dist/_internal/platform/intelligence/facade.js

@@ -6,7 +6,7 @@
  *   - LSP is optional; falls back to tree-sitter where possible.
  *   - Tree-sitter is optional; falls back to empty arrays/null.
  *   - On initialization, language configs are read and registered with LspService
- *     so user/project overrides in .goodvibes/tui/languages/*.json take effect.
+ *     so user/project overrides in .goodvibes/goodvibes/languages/*.json take effect.
  */
 import { resolve } from 'path';
 import { pathToFileURL, fileURLToPath } from 'url';
@@ -52,7 +52,7 @@ export class CodeIntelligence {
     /**
      * Initialize all services. Call once at startup.
      * Loads language configs and registers LSP server commands with LspService
-     * so that user/project overrides in .goodvibes/tui/languages/ are respected.
+     * so that user/project overrides in .goodvibes/goodvibes/languages/ are respected.
      */
     async initialize() {
         if (!this.shellPaths) {

package/dist/_internal/platform/knowledge/consolidation.d.ts

@@ -0,0 +1,23 @@
+import type { MemoryRegistry } from '../state/index.js';
+import type { KnowledgeStore } from '@pellux/goodvibes-sdk/platform/knowledge/store';
+import type { KnowledgeConsolidationCandidateRecord, KnowledgeConsolidationReportRecord } from '@pellux/goodvibes-sdk/platform/knowledge/types';
+export interface KnowledgeConsolidationContext {
+    readonly store: KnowledgeStore;
+    readonly memoryRegistry: Pick<MemoryRegistry, 'add' | 'getStore'>;
+    readonly syncReviewedMemory: () => Promise<void>;
+}
+export declare function decideKnowledgeConsolidationCandidate(context: KnowledgeConsolidationContext, id: string, decision: 'accept' | 'reject' | 'supersede', input?: {
+    readonly decidedBy?: string;
+    readonly memoryClass?: string;
+    readonly scope?: string;
+    readonly detail?: string;
+}): Promise<KnowledgeConsolidationCandidateRecord>;
+export declare function refreshKnowledgeConsolidationCandidates(context: KnowledgeConsolidationContext, limit?: number): Promise<KnowledgeConsolidationCandidateRecord[]>;
+export declare function runKnowledgeConsolidation(context: KnowledgeConsolidationContext, kind: Extract<KnowledgeConsolidationReportRecord['kind'], 'light-consolidation' | 'deep-consolidation'>, input: {
+    readonly limit?: number;
+    readonly autoPromote: boolean;
+}): Promise<KnowledgeConsolidationReportRecord>;
+export declare function syncReviewedKnowledgeMemory(context: {
+    readonly syncReviewedMemory: () => Promise<void>;
+}): Promise<void>;
+//# sourceMappingURL=consolidation.d.ts.map

package/dist/_internal/platform/knowledge/consolidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consolidation.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/knowledge/consolidation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,cAAc,EAAe,MAAM,mBAAmB,CAAC;AAClF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gDAAgD,CAAC;AACrF,OAAO,KAAK,EACV,qCAAqC,EACrC,kCAAkC,EAInC,MAAM,gDAAgD,CAAC;AAYxD,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,cAAc,EAAE,IAAI,CAAC,cAAc,EAAE,KAAK,GAAG,UAAU,CAAC,CAAC;IAClE,QAAQ,CAAC,kBAAkB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAClD;AAED,wBAAsB,qCAAqC,CACzD,OAAO,EAAE,6BAA6B,EACtC,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,QAAQ,GAAG,QAAQ,GAAG,WAAW,EAC3C,KAAK,GAAE;IACL,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CACrB,GACL,OAAO,CAAC,qCAAqC,CAAC,CA4DhD;AAED,wBAAsB,uCAAuC,CAC3D,OAAO,EAAE,6BAA6B,EACtC,KAAK,SAAK,GACT,OAAO,CAAC,qCAAqC,EAAE,CAAC,CAgFlD;AAED,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,6BAA6B,EACtC,IAAI,EAAE,OAAO,CAAC,kCAAkC,CAAC,MAAM,CAAC,EAAE,qBAAqB,GAAG,oBAAoB,CAAC,EACvG,KAAK,EAAE;IAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAA;CAAE,GAChE,OAAO,CAAC,kCAAkC,CAAC,CA0C7C;AAED,wBAAsB,2BAA2B,CAAC,OAAO,EAAE;IAAE,QAAQ,CAAC,kBAAkB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAE9H"}

package/dist/_internal/platform/knowledge/consolidation.js

@@ -0,0 +1,274 @@
+import { DEEP_CONSOLIDATION_AUTOPROMOTE_THRESHOLD, LIGHT_CONSOLIDATION_THRESHOLD, coerceStringArray, mergeTags, slugify, summarizeCompact, topKeywords, usageWindowCutoff, } from './internal.js';
+export async function decideKnowledgeConsolidationCandidate(context, id, decision, input = {}) {
+    await context.store.init();
+    const candidate = context.store.getConsolidationCandidate(id);
+    if (!candidate)
+        throw new Error(`Unknown knowledge consolidation candidate: ${id}`);
+    const decidedAt = Date.now();
+    let acceptedMemoryId;
+    if (decision === 'accept' && candidate.candidateType === 'memory-promotion') {
+        const record = context.store.getItem(candidate.subjectId);
+        await context.memoryRegistry.getStore().init();
+        const summary = summarizeCompact(candidate.title, 160) ?? candidate.title;
+        const detail = input.detail
+            ?? candidate.summary
+            ?? record?.source?.summary
+            ?? record?.node?.summary
+            ?? summary;
+        const tags = mergeTags(candidate.evidence, record?.source?.tags, record?.node?.aliases, coerceStringArray(candidate.metadata.tags));
+        const memory = await context.memoryRegistry.add({
+            cls: (input.memoryClass ?? candidate.suggestedMemoryClass ?? 'fact'),
+            scope: (input.scope ?? candidate.suggestedScope ?? 'project'),
+            summary,
+            detail,
+            tags,
+            provenance: [
+                ...(record?.source?.sessionId ? [{ kind: 'session', ref: record.source.sessionId }] : []),
+                { kind: 'event', ref: candidate.id, label: 'knowledge consolidation candidate' },
+            ],
+            review: {
+                state: 'reviewed',
+                confidence: Math.max(60, Math.min(100, Math.round(candidate.score))),
+                reviewedAt: decidedAt,
+                reviewedBy: input.decidedBy,
+            },
+        });
+        acceptedMemoryId = memory.id;
+        await context.syncReviewedMemory();
+    }
+    return context.store.upsertConsolidationCandidate({
+        id: candidate.id,
+        candidateType: candidate.candidateType,
+        subjectKind: candidate.subjectKind,
+        subjectId: candidate.subjectId,
+        title: candidate.title,
+        summary: candidate.summary,
+        score: candidate.score,
+        evidence: candidate.evidence,
+        suggestedMemoryClass: input.memoryClass ?? candidate.suggestedMemoryClass,
+        suggestedScope: input.scope ?? candidate.suggestedScope,
+        status: decision === 'accept' ? 'accepted' : decision === 'reject' ? 'rejected' : 'superseded',
+        decidedAt,
+        decidedBy: input.decidedBy,
+        metadata: {
+            ...candidate.metadata,
+            ...(acceptedMemoryId ? { acceptedMemoryId } : {}),
+        },
+    });
+}
+export async function refreshKnowledgeConsolidationCandidates(context, limit = 24) {
+    await context.store.init();
+    await context.syncReviewedMemory();
+    const usageStats = await buildUsageStats(context);
+    const proposals = [];
+    const seenSubjects = new Set();
+    for (const [key, stats] of usageStats.entries()) {
+        const [subjectKind, subjectId] = key.split(':', 2);
+        if (subjectKind === 'issue')
+            continue;
+        const item = context.store.getItem(subjectId);
+        if (!item?.source && !item?.node)
+            continue;
+        const subjectTitle = item.source?.title ?? item.source?.canonicalUri ?? item.node?.title ?? subjectId;
+        const subjectSummary = summarizeCompact(item.source?.summary ?? item.node?.summary ?? item.source?.description);
+        const relationCount = subjectKind === 'source'
+            ? context.store.edgesFor('source', subjectId).length
+            : context.store.edgesFor('node', subjectId).length;
+        const score = Math.round(scoreUsageBoost(stats)
+            + Math.min(16, relationCount * 2)
+            + (item.node?.kind === 'memory' ? 10 : 0));
+        if (score < LIGHT_CONSOLIDATION_THRESHOLD)
+            continue;
+        const candidateType = item.node?.kind === 'memory' && item.node.status === 'stale'
+            ? 'memory-review'
+            : subjectKind === 'source' && isSourcePastRefreshWindow(item.source)
+                ? 'source-refresh'
+                : 'memory-promotion';
+        const evidence = mergeTags([
+            `used ${stats.count} time(s) in the last 30 days`,
+            `observed via ${stats.usageKinds.size} usage pattern(s)`,
+            `linked to ${relationCount} graph relation(s)`,
+        ], subjectKind === 'source' ? item.source?.tags : item.node?.aliases).slice(0, 8);
+        const candidate = await context.store.upsertConsolidationCandidate({
+            candidateType,
+            subjectKind,
+            subjectId,
+            title: subjectTitle,
+            summary: subjectSummary,
+            score,
+            evidence,
+            suggestedMemoryClass: inferMemoryClassForCandidate(context, subjectKind, subjectId),
+            suggestedScope: 'project',
+            metadata: {
+                usageCount: stats.count,
+                lastUsedAt: stats.lastUsedAt,
+                usageKinds: [...stats.usageKinds],
+                relationCount,
+            },
+        });
+        proposals.push(candidate);
+        seenSubjects.add(`${candidate.candidateType}:${candidate.subjectKind}:${candidate.subjectId}`);
+    }
+    for (const existing of context.store.listConsolidationCandidates(1_000, { status: 'open' })) {
+        const key = `${existing.candidateType}:${existing.subjectKind}:${existing.subjectId}`;
+        if (seenSubjects.has(key))
+            continue;
+        await context.store.upsertConsolidationCandidate({
+            id: existing.id,
+            candidateType: existing.candidateType,
+            status: 'superseded',
+            subjectKind: existing.subjectKind,
+            subjectId: existing.subjectId,
+            title: existing.title,
+            summary: existing.summary,
+            score: existing.score,
+            evidence: existing.evidence,
+            suggestedMemoryClass: existing.suggestedMemoryClass,
+            suggestedScope: existing.suggestedScope,
+            metadata: existing.metadata,
+        });
+    }
+    return proposals
+        .sort((a, b) => b.score - a.score || b.updatedAt - a.updatedAt || a.id.localeCompare(b.id))
+        .slice(0, Math.max(1, limit));
+}
+export async function runKnowledgeConsolidation(context, kind, input) {
+    const limit = Math.max(1, input.limit ?? 24);
+    const candidates = await refreshKnowledgeConsolidationCandidates(context, limit);
+    let accepted = 0;
+    let rejected = 0;
+    let superseded = 0;
+    if (input.autoPromote) {
+        for (const candidate of candidates) {
+            if (candidate.candidateType !== 'memory-promotion')
+                continue;
+            if (candidate.score < DEEP_CONSOLIDATION_AUTOPROMOTE_THRESHOLD)
+                continue;
+            const decided = await decideKnowledgeConsolidationCandidate(context, candidate.id, 'accept', {
+                decidedBy: 'knowledge.deep-consolidation',
+                memoryClass: candidate.suggestedMemoryClass,
+                scope: candidate.suggestedScope,
+            });
+            if (decided.status === 'accepted')
+                accepted += 1;
+        }
+    }
+    const current = context.store.listConsolidationCandidates(1_000);
+    for (const candidate of current) {
+        if (candidate.status === 'rejected')
+            rejected += 1;
+        if (candidate.status === 'superseded')
+            superseded += 1;
+    }
+    const openCount = current.filter((entry) => entry.status === 'open').length;
+    return context.store.upsertConsolidationReport({
+        kind,
+        title: kind === 'light-consolidation' ? 'Light Consolidation Report' : 'Deep Consolidation Report',
+        summary: kind === 'light-consolidation'
+            ? `Reviewed ${candidates.length} high-signal knowledge subjects and refreshed the consolidation queue.`
+            : `Reviewed ${candidates.length} high-signal knowledge subjects and auto-promoted the highest-confidence candidates into durable memory.`,
+        highlights: candidates.slice(0, 6).map((candidate) => `${candidate.title} (${candidate.candidateType}, score ${candidate.score})`),
+        metrics: {
+            candidateCount: candidates.length,
+            openCount,
+            acceptedCount: accepted,
+            rejectedCount: rejected,
+            supersededCount: superseded,
+        },
+        metadata: {
+            autoPromote: input.autoPromote,
+        },
+    });
+}
+export async function syncReviewedKnowledgeMemory(context) {
+    await context.syncReviewedMemory();
+}
+async function buildUsageStats(context, limit = 10_000) {
+    const stats = new Map();
+    const cutoff = usageWindowCutoff();
+    for (const record of context.store.listUsageRecords(limit)) {
+        if (record.createdAt < cutoff)
+            continue;
+        const key = `${record.targetKind}:${record.targetId}`;
+        const current = stats.get(key) ?? {
+            count: 0,
+            scoreTotal: 0,
+            lastUsedAt: 0,
+            usageKinds: new Set(),
+            sessionIds: new Set(),
+        };
+        current.count += 1;
+        current.scoreTotal += Number(record.score ?? 0);
+        current.lastUsedAt = Math.max(current.lastUsedAt, record.createdAt);
+        current.usageKinds.add(record.usageKind);
+        if (record.sessionId)
+            current.sessionIds.add(record.sessionId);
+        stats.set(key, current);
+    }
+    return stats;
+}
+function scoreUsageBoost(stats) {
+    if (!stats)
+        return 0;
+    const frequency = Math.min(28, stats.count * 4);
+    const diversity = Math.min(14, stats.usageKinds.size * 3 + stats.sessionIds.size * 2);
+    const averageScore = stats.count > 0 ? stats.scoreTotal / stats.count : 0;
+    const scoreBoost = Math.min(12, Math.max(0, averageScore / 12));
+    const ageMs = Math.max(0, Date.now() - stats.lastUsedAt);
+    const recency = ageMs <= (24 * 60 * 60 * 1000) ? 10 : ageMs <= 7 * (24 * 60 * 60 * 1000) ? 6 : ageMs <= 14 * (24 * 60 * 60 * 1000) ? 3 : 0;
+    return frequency + diversity + scoreBoost + recency;
+}
+function inferMemoryClassForCandidate(context, subjectKind, subjectId) {
+    if (subjectKind === 'node') {
+        const node = context.store.getNode(subjectId);
+        switch (node?.kind) {
+            case 'project':
+            case 'capability':
+            case 'repo':
+            case 'service':
+            case 'environment':
+                return 'architecture';
+            case 'provider':
+                return 'fact';
+            case 'user':
+                return 'ownership';
+            case 'memory':
+                return 'fact';
+            default:
+                return 'fact';
+        }
+    }
+    const source = context.store.getSource(subjectId);
+    switch (source?.sourceType) {
+        case 'repo':
+            return 'architecture';
+        case 'bookmark':
+        case 'url':
+        case 'bookmark-list':
+            return 'fact';
+        case 'document':
+            return 'runbook';
+        default:
+            return 'fact';
+    }
+}
+function isSourcePastRefreshWindow(source) {
+    if (!source.lastCrawledAt)
+        return source.status === 'stale';
+    return source.lastCrawledAt < (Date.now() - getSourceRefreshWindowMs(source));
+}
+function getSourceRefreshWindowMs(source) {
+    const connectorKey = source.connectorId === 'url-list' ? 'url-list' : source.connectorId;
+    return {
+        bookmark: 7 * 24 * 60 * 60 * 1000,
+        'bookmark-list': 7 * 24 * 60 * 60 * 1000,
+        'url-list': 7 * 24 * 60 * 60 * 1000,
+        url: 14 * 24 * 60 * 60 * 1000,
+        repo: 14 * 24 * 60 * 60 * 1000,
+        document: 21 * 24 * 60 * 60 * 1000,
+        image: 21 * 24 * 60 * 60 * 1000,
+        dataset: 30 * 24 * 60 * 60 * 1000,
+        manual: 45 * 24 * 60 * 60 * 1000,
+        other: 30 * 24 * 60 * 60 * 1000,
+    }[connectorKey] ?? 30 * 24 * 60 * 60 * 1000;
+}

package/dist/_internal/platform/knowledge/graphql.d.ts

@@ -0,0 +1,25 @@
+import type { KnowledgeService } from './service.js';
+export interface KnowledgeGraphqlAccessProfile {
+    readonly operation: 'query' | 'mutation';
+    readonly requiredScopes: readonly string[];
+    readonly adminRequired: boolean;
+}
+export declare function inspectKnowledgeGraphqlAccess(source: string, operationName?: string): KnowledgeGraphqlAccessProfile;
+export interface KnowledgeGraphqlExecuteInput {
+    readonly query: string;
+    readonly operationName?: string;
+    readonly variables?: Record<string, unknown>;
+    readonly admin: boolean;
+    readonly scopes: readonly string[];
+}
+export declare class KnowledgeGraphqlService {
+    private readonly service;
+    private static readonly schema;
+    static readonly schemaSdl: string;
+    constructor(service: KnowledgeService);
+    get schemaText(): string;
+    execute(input: KnowledgeGraphqlExecuteInput): Promise<import("graphql").ExecutionResult<import("graphql/jsutils/ObjMap.js").ObjMap<unknown>, import("graphql/jsutils/ObjMap.js").ObjMap<unknown>>>;
+    private createRootValue;
+}
+export declare function getKnowledgeGraphqlSchemaText(): string;
+//# sourceMappingURL=graphql.d.ts.map

package/dist/_internal/platform/knowledge/graphql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/knowledge/graphql.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAiBrD,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,SAAS,EAAE,OAAO,GAAG,UAAU,CAAC;IACzC,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;CACjC;AAED,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,MAAM,EACd,aAAa,CAAC,EAAE,MAAM,GACrB,6BAA6B,CAM/B;AAiBD,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7C,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED,qBAAa,uBAAuB;IAStB,OAAO,CAAC,QAAQ,CAAC,OAAO;IARpC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAIzB;IAEL,MAAM,CAAC,QAAQ,CAAC,SAAS,SAA+C;gBAE3C,OAAO,EAAE,gBAAgB;IAEtD,IAAI,UAAU,IAAI,MAAM,CAEvB;IAEK,OAAO,CAAC,KAAK,EAAE,4BAA4B;IAkBjD,OAAO,CAAC,eAAe;CAoOxB;AAED,wBAAgB,6BAA6B,IAAI,MAAM,CAEtD"}

package/dist/_internal/platform/knowledge/graphql.js

@@ -0,0 +1,232 @@
+import { GraphQLError, buildSchema, graphql, parse, printSchema } from 'graphql';
+import { KNOWLEDGE_GRAPHQL_SDL, clampInt, clampOffset, installJsonScalar, mapJob, mapJobRun, mapPacket, mapProjectionBundle, mapProjectionTarget, pickOperation, toJobMode, toPacketDetail, toProjectionKind, } from '@pellux/goodvibes-sdk/platform/knowledge/graphql-schema';
+export function inspectKnowledgeGraphqlAccess(source, operationName) {
+    const document = parse(source);
+    const operation = pickOperation(document, operationName);
+    return operation === 'mutation'
+        ? { operation, requiredScopes: ['write:knowledge'], adminRequired: true }
+        : { operation, requiredScopes: ['read:knowledge'], adminRequired: false };
+}
+function assertWriteAccess(context) {
+    if (!context.admin) {
+        throw new GraphQLError('Knowledge GraphQL mutation requires admin access.');
+    }
+    if (!context.scopes.includes('write:knowledge')) {
+        throw new GraphQLError('Knowledge GraphQL mutation requires write:knowledge.');
+    }
+}
+export class KnowledgeGraphqlService {
+    service;
+    static schema = (() => {
+        const schema = buildSchema(KNOWLEDGE_GRAPHQL_SDL);
+        installJsonScalar(schema);
+        return schema;
+    })();
+    static schemaSdl = printSchema(KnowledgeGraphqlService.schema);
+    constructor(service) {
+        this.service = service;
+    }
+    get schemaText() {
+        return KnowledgeGraphqlService.schemaSdl;
+    }
+    async execute(input) {
+        const rootValue = this.createRootValue();
+        const context = {
+            service: this.service,
+            admin: input.admin,
+            scopes: [...input.scopes],
+        };
+        const result = await graphql({
+            schema: KnowledgeGraphqlService.schema,
+            source: input.query,
+            rootValue,
+            contextValue: context,
+            variableValues: input.variables,
+            operationName: input.operationName,
+        });
+        return result;
+    }
+    createRootValue() {
+        return {
+            status: async () => this.service.getStatus(),
+            sources: ({ limit }) => this.service.listSources(clampInt(limit, 100)),
+            nodes: ({ limit }) => this.service.listNodes(clampInt(limit, 100)),
+            issues: ({ limit }) => this.service.listIssues(clampInt(limit, 100)),
+            source: ({ id }) => this.service.listSources(10_000).find((source) => source.id === id) ?? null,
+            node: ({ id }) => this.service.listNodes(10_000).find((node) => node.id === id) ?? null,
+            issue: ({ id }) => this.service.listIssues(10_000).find((issue) => issue.id === id) ?? null,
+            item: ({ id }) => this.service.getItem(id),
+            items: ({ ids }) => this.service.getItems(ids),
+            sourcesConnection: (args) => this.service.querySources({
+                limit: clampInt(args.limit, 100),
+                offset: clampOffset(args.offset),
+                status: args.status,
+                connectorId: args.connectorId,
+                sourceType: args.sourceType,
+                tag: args.tag,
+                query: args.query,
+            }),
+            nodesConnection: (args) => this.service.queryNodes({
+                limit: clampInt(args.limit, 100),
+                offset: clampOffset(args.offset),
+                kind: args.kind,
+                status: args.status,
+                query: args.query,
+            }),
+            issuesConnection: (args) => this.service.queryIssues({
+                limit: clampInt(args.limit, 100),
+                offset: clampOffset(args.offset),
+                severity: args.severity,
+                status: args.status,
+                code: args.code,
+                query: args.query,
+            }),
+            extractions: ({ limit, sourceId }) => this.service.listExtractions(clampInt(limit, 100), sourceId),
+            sourceExtraction: ({ sourceId }) => this.service.getSourceExtraction(sourceId),
+            neighbors: ({ kind, id, relation, limit }) => {
+                if (kind !== 'source' && kind !== 'node') {
+                    throw new GraphQLError(`Unsupported knowledge neighbor kind: ${kind}`);
+                }
+                return this.service.getNeighbors(kind, id, { relation, limit: clampInt(limit, 20) });
+            },
+            search: ({ query, limit }) => this.service.search(query, clampInt(limit, 10)),
+            packet: async ({ task, writeScope, limit, detail, budgetLimit }) => mapPacket(await this.service.buildPacket(task, writeScope ?? [], clampInt(limit, 6), {
+                detail: toPacketDetail(detail),
+                ...(typeof budgetLimit === 'number' ? { budgetLimit } : {}),
+            })),
+            connectors: () => this.service.listConnectors(),
+            connector: ({ id }) => this.service.getConnector(id),
+            connectorDoctor: ({ id }) => this.service.doctorConnector(id),
+            projectionTargets: async ({ limit }) => (await this.service.listProjectionTargets(clampInt(limit, 25))).map((target) => mapProjectionTarget(target)),
+            projection: async ({ kind, id, limit }) => mapProjectionBundle(await this.service.renderProjection({
+                kind: toProjectionKind(kind),
+                id,
+                limit: clampInt(limit, 12),
+            })),
+            jobs: () => this.service.listJobs().map((job) => mapJob(job)),
+            job: ({ id }) => {
+                const job = this.service.getJob(id);
+                return job ? mapJob(job) : null;
+            },
+            jobRuns: ({ limit, jobId }) => this.service.listJobRuns(clampInt(limit, 25), jobId).map((run) => mapJobRun(run)),
+            usage: ({ limit, targetKind, targetId, usageKind }) => (this.service.listUsageRecords(clampInt(limit, 100), {
+                ...(targetKind ? { targetKind } : {}),
+                ...(targetId ? { targetId } : {}),
+                ...(usageKind ? { usageKind: usageKind } : {}),
+            })),
+            consolidationCandidates: ({ limit, status, subjectKind, subjectId }) => (this.service.listConsolidationCandidates(clampInt(limit, 100), {
+                ...(status ? { status: status } : {}),
+                ...(subjectKind ? { subjectKind } : {}),
+                ...(subjectId ? { subjectId } : {}),
+            })),
+            consolidationCandidate: ({ id }) => this.service.getConsolidationCandidate(id),
+            consolidationReports: ({ limit }) => this.service.listConsolidationReports(clampInt(limit, 100)),
+            consolidationReport: ({ id }) => this.service.getConsolidationReport(id),
+            schedules: ({ limit }) => this.service.listSchedules(clampInt(limit, 100)),
+            schedule: ({ id }) => this.service.getSchedule(id),
+            ingestUrl: async (args, context) => {
+                assertWriteAccess(context);
+                const result = await this.service.ingestUrl({
+                    url: args.url,
+                    title: args.title,
+                    tags: args.tags,
+                    folderPath: args.folderPath,
+                    sessionId: args.sessionId,
+                    sourceType: args.sourceType,
+                    connectorId: args.connectorId,
+                    allowPrivateHosts: args.allowPrivateHosts,
+                    metadata: args.metadata,
+                });
+                return result.source;
+            },
+            ingestArtifact: async (args, context) => {
+                assertWriteAccess(context);
+                const result = await this.service.ingestArtifact({
+                    artifactId: args.artifactId,
+                    path: args.path,
+                    uri: args.uri,
+                    title: args.title,
+                    tags: args.tags,
+                    folderPath: args.folderPath,
+                    sessionId: args.sessionId,
+                    sourceType: args.sourceType,
+                    connectorId: args.connectorId,
+                    allowPrivateHosts: args.allowPrivateHosts,
+                    metadata: args.metadata,
+                });
+                return result.source;
+            },
+            importBookmarks: async (args, context) => {
+                assertWriteAccess(context);
+                return this.service.importBookmarksFromFile(args);
+            },
+            importUrls: async (args, context) => {
+                assertWriteAccess(context);
+                return this.service.importUrlsFromFile(args);
+            },
+            ingestConnector: async (args, context) => {
+                assertWriteAccess(context);
+                return this.service.ingestConnectorInput(args);
+            },
+            lint: async (_args, context) => {
+                assertWriteAccess(context);
+                return this.service.lint();
+            },
+            reindex: async (_args, context) => {
+                assertWriteAccess(context);
+                return this.service.reindex();
+            },
+            runJob: async (args, context) => {
+                assertWriteAccess(context);
+                return mapJobRun(await this.service.runJob(args.id, {
+                    ...(args.mode ? { mode: toJobMode(args.mode) } : {}),
+                    ...(args.sourceIds ? { sourceIds: args.sourceIds } : {}),
+                    ...(typeof args.limit === 'number' ? { limit: args.limit } : {}),
+                }));
+            },
+            decideCandidate: async (args, context) => {
+                assertWriteAccess(context);
+                return this.service.decideConsolidationCandidate(args.id, args.decision, {
+                    decidedBy: args.decidedBy,
+                    memoryClass: args.memoryClass,
+                    scope: args.scope,
+                    detail: args.detail,
+                });
+            },
+            saveSchedule: async (args, context) => {
+                assertWriteAccess(context);
+                return this.service.saveSchedule({
+                    id: args.id,
+                    jobId: args.jobId,
+                    label: args.label,
+                    enabled: args.enabled,
+                    schedule: args.schedule,
+                });
+            },
+            deleteSchedule: async (args, context) => {
+                assertWriteAccess(context);
+                return this.service.deleteSchedule(args.id);
+            },
+            setScheduleEnabled: async (args, context) => {
+                assertWriteAccess(context);
+                return this.service.setScheduleEnabled(args.id, args.enabled);
+            },
+            materializeProjection: async (args, context) => {
+                assertWriteAccess(context);
+                const materialized = await this.service.materializeProjection({
+                    kind: toProjectionKind(args.kind),
+                    id: args.id,
+                    limit: clampInt(args.limit, 12),
+                    filename: args.filename,
+                });
+                return {
+                    ...materialized,
+                    bundle: mapProjectionBundle(materialized.bundle),
+                };
+            },
+        };
+    }
+}
+export function getKnowledgeGraphqlSchemaText() {
+    return KnowledgeGraphqlService.schemaSdl;
+}

package/dist/_internal/platform/knowledge/index.d.ts

@@ -0,0 +1,13 @@
+export { KnowledgeConnectorRegistry, createDefaultKnowledgeConnectorRegistry } from '@pellux/goodvibes-sdk/platform/knowledge/connectors';
+export { extractKnowledgeArtifact } from '@pellux/goodvibes-sdk/platform/knowledge/extractors';
+export { KnowledgeGraphqlService, getKnowledgeGraphqlSchemaText, inspectKnowledgeGraphqlAccess } from './graphql.js';
+export type { KnowledgeGraphqlAccessProfile, KnowledgeGraphqlExecuteInput } from './graphql.js';
+export { createKnowledgeApi } from './knowledge-api.js';
+export { createKnowledgeSchema, getKnowledgeSchemaStatements, knowledgeNowMs, loadKnowledgeStoreSnapshot, parseKnowledgeJsonValue, renderKnowledgeSchemaSql, resolveKnowledgeDbPathFromControlPlaneDir, stabilizeKnowledgeText, uniqKnowledgeValues, } from '@pellux/goodvibes-sdk/platform/knowledge/persistence';
+export type { KnowledgeStoreSnapshot, KnowledgeStoreReadView } from '@pellux/goodvibes-sdk/platform/knowledge/persistence';
+export type { KnowledgeApi, KnowledgeApiArtifactIngestInput, KnowledgeApiUrlIngestInput, KnowledgeInjection, KnowledgeInjectionIngestMode, KnowledgeInjectionProvenance, KnowledgeInjectionRetention, KnowledgeInjectionTrustTier, KnowledgeInjectionUseAs, } from './knowledge-api.js';
+export { KnowledgeProjectionService } from '@pellux/goodvibes-sdk/platform/knowledge/projections';
+export { KnowledgeStore } from '@pellux/goodvibes-sdk/platform/knowledge/store';
+export { KnowledgeService, buildCuratedKnowledgePromptSync } from './service.js';
+export type { KnowledgeBatchIngestResult, KnowledgeBookmarkSeed, KnowledgeConnector, KnowledgeConnectorDoctorReport, KnowledgeConnectorParseResult, KnowledgeConsolidationCandidateRecord, KnowledgeConsolidationReportRecord, KnowledgeEdgeRecord, KnowledgeExtractionRecord, KnowledgeIssueRecord, KnowledgeItemView, KnowledgeJobRecord, KnowledgeJobRunRecord, KnowledgeMaterializedProjection, KnowledgeNodeRecord, KnowledgePacket, KnowledgePacketDetail, KnowledgePacketItem, KnowledgeProjectionBundle, KnowledgeProjectionPage, KnowledgeProjectionTarget, KnowledgeProjectionTargetKind, KnowledgeScheduleRecord, KnowledgeSearchResult, KnowledgeSourceRecord, KnowledgeStatus, KnowledgeUsageRecord, } from '@pellux/goodvibes-sdk/platform/knowledge/types';
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/knowledge/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/knowledge/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,uCAAuC,EAAE,MAAM,qDAAqD,CAAC;AAC1I,OAAO,EAAE,wBAAwB,EAAE,MAAM,qDAAqD,CAAC;AAC/F,OAAO,EAAE,uBAAuB,EAAE,6BAA6B,EAAE,6BAA6B,EAAE,MAAM,cAAc,CAAC;AACrH,YAAY,EAAE,6BAA6B,EAAE,4BAA4B,EAAE,MAAM,cAAc,CAAC;AAChG,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EACL,qBAAqB,EACrB,4BAA4B,EAC5B,cAAc,EACd,0BAA0B,EAC1B,uBAAuB,EACvB,wBAAwB,EACxB,yCAAyC,EACzC,sBAAsB,EACtB,mBAAmB,GACpB,MAAM,sDAAsD,CAAC;AAC9D,YAAY,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,sDAAsD,CAAC;AAC3H,YAAY,EACV,YAAY,EACZ,+BAA+B,EAC/B,0BAA0B,EAC1B,kBAAkB,EAClB,4BAA4B,EAC5B,4BAA4B,EAC5B,2BAA2B,EAC3B,2BAA2B,EAC3B,uBAAuB,GACxB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,0BAA0B,EAAE,MAAM,sDAAsD,CAAC;AAClG,OAAO,EAAE,cAAc,EAAE,MAAM,gDAAgD,CAAC;AAChF,OAAO,EAAE,gBAAgB,EAAE,+BAA+B,EAAE,MAAM,cAAc,CAAC;AACjF,YAAY,EACV,0BAA0B,EAC1B,qBAAqB,EACrB,kBAAkB,EAClB,8BAA8B,EAC9B,6BAA6B,EAC7B,qCAAqC,EACrC,kCAAkC,EAClC,mBAAmB,EACnB,yBAAyB,EACzB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACrB,+BAA+B,EAC/B,mBAAmB,EACnB,eAAe,EACf,qBAAqB,EACrB,mBAAmB,EACnB,yBAAyB,EACzB,uBAAuB,EACvB,yBAAyB,EACzB,6BAA6B,EAC7B,uBAAuB,EACvB,qBAAqB,EACrB,qBAAqB,EACrB,eAAe,EACf,oBAAoB,GACrB,MAAM,gDAAgD,CAAC"}

package/dist/_internal/platform/knowledge/index.js

@@ -0,0 +1,8 @@
+export { KnowledgeConnectorRegistry, createDefaultKnowledgeConnectorRegistry } from '@pellux/goodvibes-sdk/platform/knowledge/connectors';
+export { extractKnowledgeArtifact } from '@pellux/goodvibes-sdk/platform/knowledge/extractors';
+export { KnowledgeGraphqlService, getKnowledgeGraphqlSchemaText, inspectKnowledgeGraphqlAccess } from './graphql.js';
+export { createKnowledgeApi } from './knowledge-api.js';
+export { createKnowledgeSchema, getKnowledgeSchemaStatements, knowledgeNowMs, loadKnowledgeStoreSnapshot, parseKnowledgeJsonValue, renderKnowledgeSchemaSql, resolveKnowledgeDbPathFromControlPlaneDir, stabilizeKnowledgeText, uniqKnowledgeValues, } from '@pellux/goodvibes-sdk/platform/knowledge/persistence';
+export { KnowledgeProjectionService } from '@pellux/goodvibes-sdk/platform/knowledge/projections';
+export { KnowledgeStore } from '@pellux/goodvibes-sdk/platform/knowledge/store';
+export { KnowledgeService, buildCuratedKnowledgePromptSync } from './service.js';