@kaelio/ktx 0.4.1 → 0.5.0

package/node_modules/@ktx/context/dist/wiki/local-knowledge.d.ts

@@ -1,55 +0,0 @@
-import type { KtxEmbeddingPort, KtxFileWriteResult } from '../core/index.js';
-import type { KtxLocalProject } from '../project/index.js';
-import type { HistoricSqlWikiUsageFrontmatter, WikiSearchLaneSummary, WikiSearchMatchReason } from './types.js';
-export type LocalKnowledgeScope = 'GLOBAL' | 'USER';
-export interface LocalKnowledgePage {
-    key: string;
-    path: string;
-    scope: LocalKnowledgeScope;
-    summary: string;
-    content: string;
-    tags: string[];
-    refs: string[];
-    slRefs: string[];
-}
-export interface LocalKnowledgeSummary {
-    key: string;
-    path: string;
-    scope: LocalKnowledgeScope;
-    summary: string;
-}
-export interface LocalKnowledgeSearchResult extends LocalKnowledgeSummary {
-    score: number;
-    matchReasons: WikiSearchMatchReason[];
-    lanes?: WikiSearchLaneSummary[];
-}
-export interface WriteLocalKnowledgePageInput {
-    key: string;
-    scope: LocalKnowledgeScope;
-    userId?: string;
-    summary: string;
-    content: string;
-    tags?: string[];
-    refs?: string[];
-    slRefs?: string[];
-    source?: string;
-    intent?: string;
-    tables?: string[];
-    representativeSql?: string;
-    usage?: HistoricSqlWikiUsageFrontmatter;
-    fingerprints?: string[];
-}
-export declare function writeLocalKnowledgePage(project: KtxLocalProject, input: WriteLocalKnowledgePageInput): Promise<KtxFileWriteResult>;
-export declare function readLocalKnowledgePage(project: KtxLocalProject, input: {
-    key: string;
-    userId?: string;
-}): Promise<LocalKnowledgePage | null>;
-export declare function listLocalKnowledgePages(project: KtxLocalProject, input?: {
-    userId?: string;
-}): Promise<LocalKnowledgeSummary[]>;
-export declare function searchLocalKnowledgePages(project: KtxLocalProject, input: {
-    query: string;
-    userId?: string;
-    embeddingService?: KtxEmbeddingPort | null;
-    limit?: number;
-}): Promise<LocalKnowledgeSearchResult[]>;

package/node_modules/@ktx/context/dist/wiki/local-knowledge.js

@@ -1,289 +0,0 @@
-import { join } from 'node:path';
-import YAML from 'yaml';
-import { HybridSearchCore } from '../search/index.js';
-import { buildKnowledgeSearchText } from './knowledge-search-text.js';
-import { assertFlatWikiKey, isFlatWikiKey } from './keys.js';
-import { SqliteKnowledgeIndex } from './sqlite-knowledge-index.js';
-const LOCAL_AUTHOR = 'ktx';
-const LOCAL_AUTHOR_EMAIL = 'ktx@example.com';
-function assertSafePathToken(kind, value) {
-    if (value.trim().length === 0 ||
-        value.includes('..') ||
-        value.includes('\\') ||
-        value.startsWith('/') ||
-        value.startsWith('.') ||
-        value.includes('//')) {
-        throw new Error(`Unsafe ${kind}: ${value}`);
-    }
-    return value;
-}
-function stringArray(value) {
-    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
-}
-function knowledgePath(scope, userId, key) {
-    const safeKey = assertFlatWikiKey(key);
-    if (scope === 'GLOBAL') {
-        return `wiki/global/${safeKey}.md`;
-    }
-    return `wiki/user/${assertSafePathToken('user id', userId ?? 'local')}/${safeKey}.md`;
-}
-function keyFromKnowledgePath(path, scope, userId) {
-    const prefix = scope === 'GLOBAL' ? 'wiki/global/' : `wiki/user/${assertSafePathToken('user id', userId)}/`;
-    const key = path.slice(prefix.length).replace(/\.md$/, '');
-    if (isFlatWikiKey(key)) {
-        return key;
-    }
-    return null;
-}
-function parseKnowledgePage(key, path, scope, raw) {
-    const match = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-    if (!match) {
-        return {
-            key,
-            path,
-            scope,
-            summary: '',
-            content: raw.trim(),
-            tags: [],
-            refs: [],
-            slRefs: [],
-        };
-    }
-    const frontmatter = (YAML.parse(match[1]) ?? {});
-    return {
-        key,
-        path,
-        scope,
-        summary: typeof frontmatter.summary === 'string' ? frontmatter.summary : '',
-        content: match[2].trim(),
-        tags: stringArray(frontmatter.tags),
-        refs: stringArray(frontmatter.refs),
-        slRefs: stringArray(frontmatter.sl_refs),
-    };
-}
-function serializeKnowledgePage(input) {
-    const frontmatter = {
-        summary: input.summary,
-        tags: input.tags ?? [],
-        refs: input.refs ?? [],
-        sl_refs: input.slRefs ?? [],
-        usage_mode: 'auto',
-        ...(input.source === undefined ? {} : { source: input.source }),
-        ...(input.intent === undefined ? {} : { intent: input.intent }),
-        ...(input.tables === undefined ? {} : { tables: input.tables }),
-        ...(input.representativeSql === undefined ? {} : { representative_sql: input.representativeSql }),
-        ...(input.usage === undefined ? {} : { usage: input.usage }),
-        ...(input.fingerprints === undefined ? {} : { fingerprints: input.fingerprints }),
-    };
-    return `---\n${YAML.stringify(frontmatter, { indent: 2, lineWidth: 0 }).trimEnd()}\n---\n\n${input.content.trim()}\n`;
-}
-async function readPageAtPath(project, key, path, scope) {
-    try {
-        const result = await project.fileStore.readFile(path);
-        return parseKnowledgePage(key, path, scope, result.content);
-    }
-    catch {
-        return null;
-    }
-}
-export async function writeLocalKnowledgePage(project, input) {
-    const path = knowledgePath(input.scope, input.userId, input.key);
-    return project.fileStore.writeFile(path, serializeKnowledgePage(input), LOCAL_AUTHOR, LOCAL_AUTHOR_EMAIL, `Write wiki page: ${input.key}`);
-}
-export async function readLocalKnowledgePage(project, input) {
-    const userPath = knowledgePath('USER', input.userId, input.key);
-    const userPage = await readPageAtPath(project, input.key, userPath, 'USER');
-    if (userPage) {
-        return userPage;
-    }
-    return readPageAtPath(project, input.key, knowledgePath('GLOBAL', undefined, input.key), 'GLOBAL');
-}
-export async function listLocalKnowledgePages(project, input = {}) {
-    const userId = input.userId ?? 'local';
-    const pages = [];
-    for (const scope of ['GLOBAL', 'USER']) {
-        const root = scope === 'GLOBAL' ? 'wiki/global' : `wiki/user/${assertSafePathToken('user id', userId)}`;
-        const listed = await project.fileStore.listFiles(root);
-        for (const path of listed.files.filter((file) => file.endsWith('.md')).sort()) {
-            const key = keyFromKnowledgePath(path, scope, userId);
-            if (!key) {
-                continue;
-            }
-            const page = await readPageAtPath(project, key, path, scope);
-            if (page) {
-                pages.push({ key, path, scope, summary: page.summary });
-            }
-        }
-    }
-    return pages.sort((left, right) => left.path.localeCompare(right.path));
-}
-function scorePage(page, terms) {
-    const haystack = buildKnowledgeSearchText(page.key, page.summary, page.content, page.tags).toLowerCase();
-    return terms.some((term) => haystack.includes(term)) ? 3 : 0;
-}
-function sqliteKnowledgeDbPath(project) {
-    return join(project.projectDir, '.ktx', 'db.sqlite');
-}
-function pageSearchText(page) {
-    return buildKnowledgeSearchText(page.key, page.summary, page.content, page.tags);
-}
-async function embeddingForPageSearchText(searchText, embeddingService) {
-    if (!embeddingService) {
-        return null;
-    }
-    return embeddingService.computeEmbedding(searchText);
-}
-function tokenLaneCandidates(pages, terms) {
-    if (terms.length === 0) {
-        return [];
-    }
-    return pages
-        .map((page) => {
-        const haystack = pageSearchText(page).toLowerCase();
-        const matched = terms.filter((term) => haystack.includes(term)).length;
-        return { page, score: matched / terms.length };
-    })
-        .filter((result) => result.score > 0)
-        .sort((left, right) => right.score - left.score || left.page.path.localeCompare(right.page.path));
-}
-async function loadAllKnowledgePages(project, input = {}) {
-    const summaries = await listLocalKnowledgePages(project, { userId: input.userId });
-    const pages = [];
-    for (const summary of summaries) {
-        const page = await readPageAtPath(project, summary.key, summary.path, summary.scope);
-        if (page) {
-            pages.push(page);
-        }
-    }
-    return pages;
-}
-async function searchLocalKnowledgePagesWithSqlite(project, input) {
-    const pages = await loadAllKnowledgePages(project, { userId: input.userId });
-    const byPath = new Map(pages.map((page) => [page.path, page]));
-    const embeddingService = input.embeddingService ?? null;
-    const index = new SqliteKnowledgeIndex({ dbPath: sqliteKnowledgeDbPath(project) });
-    const existingPages = index.getExistingPages();
-    const indexPages = [];
-    for (const page of pages) {
-        const searchText = pageSearchText(page);
-        const existing = existingPages.get(page.path);
-        const embedding = existing?.searchText === searchText && existing.embedding
-            ? existing.embedding
-            : await embeddingForPageSearchText(searchText, embeddingService).catch(() => null);
-        indexPages.push({
-            path: page.path,
-            key: page.key,
-            scope: page.scope,
-            summary: page.summary,
-            content: page.content,
-            tags: page.tags,
-            embedding,
-        });
-    }
-    index.sync(indexPages);
-    const finalLimit = input.limit ?? Math.max(1, indexPages.length);
-    const core = new HybridSearchCore();
-    const generators = [
-        {
-            lane: 'lexical',
-            async generate(args) {
-                const rows = index.searchLexicalCandidates({
-                    queryText: args.queryText,
-                    limit: args.laneCandidatePoolLimit,
-                });
-                return {
-                    candidates: rows.map((row) => ({ id: row.id, rank: row.rank, rawScore: row.rawScore })),
-                };
-            },
-        },
-        {
-            lane: 'token',
-            async generate(args) {
-                const rows = tokenLaneCandidates(pages, args.normalizedQuery.terms).slice(0, args.laneCandidatePoolLimit);
-                return {
-                    candidates: rows.map((row, index) => ({
-                        id: row.page.path,
-                        rank: index + 1,
-                        rawScore: row.score,
-                    })),
-                };
-            },
-        },
-        {
-            lane: 'semantic',
-            weight: 3,
-            async generate(args) {
-                if (!embeddingService) {
-                    return { status: 'skipped', candidates: [], reason: 'embedding_unconfigured' };
-                }
-                try {
-                    const queryEmbedding = await embeddingService.computeEmbedding(args.queryText);
-                    const rows = index.searchSemanticCandidates({
-                        queryEmbedding,
-                        limit: args.laneCandidatePoolLimit,
-                    });
-                    return {
-                        candidates: rows
-                            .filter((row) => row.rawScore > 0)
-                            .map((row, index) => ({ id: row.id, rank: index + 1, rawScore: row.rawScore })),
-                    };
-                }
-                catch (error) {
-                    return {
-                        status: 'skipped',
-                        candidates: [],
-                        reason: `embedding_unhealthy:${error instanceof Error ? error.message : String(error)}`,
-                    };
-                }
-            },
-        },
-    ];
-    const result = await core.search({ queryText: input.query, limit: finalLimit, generators });
-    return result.results
-        .map((fused) => {
-        const page = byPath.get(fused.id);
-        return page
-            ? {
-                key: page.key,
-                path: page.path,
-                scope: page.scope,
-                summary: page.summary,
-                score: fused.score,
-                matchReasons: fused.matchReasons,
-                lanes: result.lanes,
-            }
-            : null;
-    })
-        .filter((result) => result !== null);
-}
-async function searchLocalKnowledgePagesWithScan(project, input) {
-    const terms = input.query
-        .toLowerCase()
-        .split(/\s+/)
-        .map((term) => term.trim())
-        .filter(Boolean);
-    const pages = await loadAllKnowledgePages(project, { userId: input.userId });
-    const results = [];
-    for (const page of pages) {
-        const score = scorePage(page, terms);
-        if (score > 0) {
-            results.push({
-                key: page.key,
-                path: page.path,
-                scope: page.scope,
-                summary: page.summary,
-                score,
-                matchReasons: ['token'],
-            });
-        }
-    }
-    return results
-        .sort((left, right) => right.score - left.score || left.path.localeCompare(right.path))
-        .slice(0, input.limit ?? results.length);
-}
-export async function searchLocalKnowledgePages(project, input) {
-    if (project.config.storage.search === 'sqlite-fts5') {
-        return searchLocalKnowledgePagesWithSqlite(project, input);
-    }
-    return searchLocalKnowledgePagesWithScan(project, input);
-}

package/node_modules/@ktx/context/dist/wiki/local-knowledge.test.js

@@ -1,270 +0,0 @@
-import { access, mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { initKtxProject } from '../project/index.js';
-import { listLocalKnowledgePages, readLocalKnowledgePage, searchLocalKnowledgePages, writeLocalKnowledgePage, } from './local-knowledge.js';
-class FakeEmbeddingPort {
-    maxBatchSize = 16;
-    async computeEmbedding(text) {
-        return text.toLowerCase().includes('semantic revenue') ? [1, 0] : [0, 1];
-    }
-    async computeEmbeddingsBulk(texts) {
-        return Promise.all(texts.map((text) => this.computeEmbedding(text)));
-    }
-}
-class ArrSynonymEmbeddingPort {
-    maxBatchSize = 16;
-    async computeEmbedding(text) {
-        const lower = text.toLowerCase();
-        if (lower.trim() === 'annual recurring revenue' || lower.includes('arr') || lower.includes('contract-first')) {
-            return [1, 0];
-        }
-        if (lower.includes('net revenue') || lower.includes('gross') || lower.includes('refund')) {
-            return [0, 1];
-        }
-        return [0.5, 0.5];
-    }
-    async computeEmbeddingsBulk(texts) {
-        return Promise.all(texts.map((text) => this.computeEmbedding(text)));
-    }
-}
-describe('local knowledge helpers', () => {
-    let tempDir;
-    let project;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-local-knowledge-'));
-        project = await initKtxProject({ projectDir: join(tempDir, 'project') });
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('writes, reads, lists, and searches global wiki pages', async () => {
-        const write = await writeLocalKnowledgePage(project, {
-            key: 'metrics-revenue',
-            scope: 'GLOBAL',
-            summary: 'Revenue metric definition',
-            content: 'Revenue is recognized when an order is paid.',
-            tags: ['finance'],
-            refs: ['semantic-layer/warehouse/orders.yaml'],
-            slRefs: ['orders'],
-        });
-        expect(write.path).toBe('wiki/global/metrics-revenue.md');
-        expect(write.operation).toBe('write');
-        await expect(readLocalKnowledgePage(project, { key: 'metrics-revenue', userId: 'local' })).resolves.toMatchObject({
-            key: 'metrics-revenue',
-            scope: 'GLOBAL',
-            summary: 'Revenue metric definition',
-            content: 'Revenue is recognized when an order is paid.',
-            tags: ['finance'],
-            refs: ['semantic-layer/warehouse/orders.yaml'],
-            slRefs: ['orders'],
-        });
-        await expect(listLocalKnowledgePages(project, { userId: 'local' })).resolves.toEqual([
-            {
-                key: 'metrics-revenue',
-                path: 'wiki/global/metrics-revenue.md',
-                scope: 'GLOBAL',
-                summary: 'Revenue metric definition',
-            },
-        ]);
-        const search = await searchLocalKnowledgePages(project, { query: 'paid order', userId: 'local' });
-        expect(search).toEqual([
-            expect.objectContaining({
-                key: 'metrics-revenue',
-                path: 'wiki/global/metrics-revenue.md',
-                scope: 'GLOBAL',
-                score: expect.any(Number),
-                matchReasons: expect.arrayContaining(['lexical']),
-                lanes: expect.arrayContaining([expect.objectContaining({ lane: 'lexical', status: 'available' })]),
-            }),
-        ]);
-        expect(search[0]?.score).toBeGreaterThan(0);
-        await expect(access(join(project.projectDir, '.ktx', 'db.sqlite'))).resolves.toBeUndefined();
-    });
-    it('adds the token lane alongside lexical wiki matches', async () => {
-        await writeLocalKnowledgePage(project, {
-            key: 'metrics-revenue',
-            scope: 'GLOBAL',
-            summary: 'Revenue metric definition',
-            content: 'Revenue is recognized when an order is paid.',
-            tags: ['finance'],
-        });
-        const search = await searchLocalKnowledgePages(project, { query: 'paid---', userId: 'local', limit: 5 });
-        expect(search[0]).toMatchObject({
-            key: 'metrics-revenue',
-            matchReasons: expect.arrayContaining(['token']),
-            lanes: expect.arrayContaining([expect.objectContaining({ lane: 'token', status: 'available' })]),
-        });
-    });
-    it('uses stored page embeddings when a wiki embedding backend is configured', async () => {
-        await writeLocalKnowledgePage(project, {
-            key: 'metrics-revenue',
-            scope: 'GLOBAL',
-            summary: 'Semantic revenue definition',
-            content: 'Revenue search text.',
-            tags: ['finance'],
-        });
-        await writeLocalKnowledgePage(project, {
-            key: 'support-escalations',
-            scope: 'GLOBAL',
-            summary: 'Support escalation process',
-            content: 'Support search text.',
-            tags: ['operations'],
-        });
-        const search = await searchLocalKnowledgePages(project, {
-            query: 'semantic revenue',
-            userId: 'local',
-            limit: 5,
-            embeddingService: new FakeEmbeddingPort(),
-        });
-        expect(search[0]).toMatchObject({
-            key: 'metrics-revenue',
-            matchReasons: expect.arrayContaining(['semantic']),
-            lanes: expect.arrayContaining([expect.objectContaining({ lane: 'semantic', status: 'available' })]),
-        });
-    });
-    it('ranks ARR synonym queries by semantic page embeddings over stronger lexical revenue matches', async () => {
-        await writeLocalKnowledgePage(project, {
-            key: 'arr-definition',
-            scope: 'GLOBAL',
-            summary: 'ARR is calculated contract-first for active customer contracts.',
-            content: 'Contract-first active contract value takes precedence over subscription values.',
-            tags: ['arr', 'contracts', 'finance'],
-        });
-        await writeLocalKnowledgePage(project, {
-            key: 'net-revenue-definition',
-            scope: 'GLOBAL',
-            summary: 'Net revenue definition',
-            content: 'Annual revenue is gross invoice revenue minus credits and refunds.',
-            tags: ['revenue', 'finance'],
-        });
-        const search = await searchLocalKnowledgePages(project, {
-            query: 'annual recurring revenue',
-            userId: 'local',
-            limit: 2,
-            embeddingService: new ArrSynonymEmbeddingPort(),
-        });
-        expect(search.map((result) => result.key)).toEqual(['arr-definition', 'net-revenue-definition']);
-        expect(search[0]).toMatchObject({
-            key: 'arr-definition',
-            matchReasons: expect.arrayContaining(['semantic']),
-            lanes: expect.arrayContaining([expect.objectContaining({ lane: 'semantic', status: 'available' })]),
-        });
-    });
-    it('reports semantic lane as skipped when wiki embeddings are not configured', async () => {
-        await writeLocalKnowledgePage(project, {
-            key: 'metrics-revenue',
-            scope: 'GLOBAL',
-            summary: 'Revenue metric definition',
-            content: 'Revenue is recognized when an order is paid.',
-            tags: ['finance'],
-        });
-        const search = await searchLocalKnowledgePages(project, { query: 'revenue', userId: 'local', limit: 5 });
-        expect(search[0]?.lanes).toEqual(expect.arrayContaining([
-            expect.objectContaining({ lane: 'semantic', status: 'skipped', reason: 'embedding_unconfigured' }),
-        ]));
-    });
-    it('prefers user knowledge over global pages with the same key', async () => {
-        await writeLocalKnowledgePage(project, {
-            key: 'handoff',
-            scope: 'GLOBAL',
-            summary: 'Global handoff',
-            content: 'Global context.',
-        });
-        await writeLocalKnowledgePage(project, {
-            key: 'handoff',
-            scope: 'USER',
-            userId: 'agent-1',
-            summary: 'User handoff',
-            content: 'User context.',
-        });
-        await expect(readLocalKnowledgePage(project, { key: 'handoff', userId: 'agent-1' })).resolves.toMatchObject({
-            scope: 'USER',
-            summary: 'User handoff',
-        });
-    });
-    it('serializes historic-SQL frontmatter fields for global pages', async () => {
-        await writeLocalKnowledgePage(project, {
-            key: 'monthly-paid-orders',
-            scope: 'GLOBAL',
-            summary: 'Monthly paid orders',
-            content: '## Monthly paid order count',
-            tags: ['historic-sql', 'query-pattern'],
-            slRefs: ['analytics.orders'],
-            source: 'historic-sql',
-            intent: 'Monthly paid order count',
-            tables: ['analytics.orders'],
-            representativeSql: "SELECT count(*) FROM analytics.orders WHERE status = 'paid'",
-            usage: {
-                executions: 42,
-                distinct_users: 3,
-                first_seen: '2026-02-01',
-                last_seen: '2026-05-04',
-                p50_runtime_ms: 100,
-                p95_runtime_ms: 200,
-                error_rate: 0,
-                rows_produced: 42,
-            },
-            fingerprints: ['fp_paid_orders'],
-        });
-        const raw = await project.fileStore.readFile('wiki/global/monthly-paid-orders.md');
-        expect(raw.content).toContain('source: historic-sql');
-        expect(raw.content).toContain('intent: Monthly paid order count');
-        expect(raw.content).toContain(['tables:', '  - analytics.orders'].join('\n'));
-        expect(raw.content).toContain("representative_sql: SELECT count(*) FROM analytics.orders WHERE status = 'paid'");
-        expect(raw.content).toContain(['usage:', '  executions: 42', '  distinct_users: 3'].join('\n'));
-        expect(raw.content).toContain(['fingerprints:', '  - fp_paid_orders'].join('\n'));
-    });
-    it('falls back to Markdown scanning when the config does not select sqlite-fts5', async () => {
-        project.config.storage.search = 'postgres-hybrid';
-        await writeLocalKnowledgePage(project, {
-            key: 'metrics-revenue',
-            scope: 'GLOBAL',
-            summary: 'Revenue metric definition',
-            content: 'Revenue is recognized when an order is paid.',
-            tags: ['finance'],
-        });
-        await expect(searchLocalKnowledgePages(project, { query: 'paid order', userId: 'local' })).resolves.toEqual([
-            expect.objectContaining({
-                key: 'metrics-revenue',
-                score: 3,
-                matchReasons: ['token'],
-            }),
-        ]);
-    });
-    it('rejects unsafe knowledge keys', async () => {
-        await expect(writeLocalKnowledgePage(project, {
-            key: '../secret',
-            scope: 'GLOBAL',
-            summary: 'bad',
-            content: 'bad',
-        })).rejects.toThrow('Invalid wiki key "../secret". Wiki keys must be flat; use "secret".');
-    });
-    it('rejects slash-delimited knowledge keys with a flat-key suggestion', async () => {
-        await expect(writeLocalKnowledgePage(project, {
-            key: 'orbit/company-overview',
-            scope: 'GLOBAL',
-            summary: 'bad',
-            content: 'bad',
-        })).rejects.toThrow('Invalid wiki key "orbit/company-overview". Wiki keys must be flat; use "orbit-company-overview".');
-    });
-    it('ignores nested historic-SQL legacy paths when listing local wiki pages', async () => {
-        await writeLocalKnowledgePage(project, {
-            key: 'historic-sql-paid-orders',
-            scope: 'GLOBAL',
-            summary: 'Flat historic SQL page',
-            content: 'Flat page body.',
-            tags: ['historic-sql'],
-        });
-        await project.fileStore.writeFile('wiki/global/historic-sql/paid-orders.md', '---\nsummary: Nested historic SQL page\nusage_mode: auto\n---\n\nNested body\n', 'Test', 'test@example.com', 'Write nested legacy page');
-        await expect(listLocalKnowledgePages(project, { userId: 'local' })).resolves.toEqual([
-            {
-                key: 'historic-sql-paid-orders',
-                path: 'wiki/global/historic-sql-paid-orders.md',
-                scope: 'GLOBAL',
-                summary: 'Flat historic SQL page',
-            },
-        ]);
-    });
-});

package/node_modules/@ktx/context/dist/wiki/ports.d.ts

@@ -1,70 +0,0 @@
-import type { KtxFileStorePort } from '../core/file-store.js';
-export interface UpsertPageParams {
-    scope: string;
-    scopeId: string | null;
-    pageKey: string;
-    summary: string;
-    usageMode: string;
-    sortOrder: number;
-    searchText: string;
-    embedding: number[] | null;
-    contentHash?: string | null;
-    sourceRunId?: string | null;
-}
-export interface KnowledgeIndexPageListing {
-    id?: string;
-    page_key: string;
-    summary: string;
-    scope: string;
-    scope_id: string | null;
-    tags: string[];
-}
-export interface KnowledgeIndexPort {
-    upsertPage(params: UpsertPageParams): Promise<void>;
-    applyDiffTransactional(params: {
-        runId: string;
-        upserts: UpsertPageParams[];
-        deletes: Array<{
-            scope: string;
-            scopeId: string | null;
-            pageKey: string;
-        }>;
-    }): Promise<void>;
-    getExistingSearchTexts(scope: string, scopeId: string | null): Promise<Map<string, {
-        searchText: string;
-        hasEmbedding: boolean;
-    }>>;
-    deleteStale(scope: string, scopeId: string | null, keepKeys: string[]): Promise<number>;
-    deleteByScope(scope: string, scopeId: string | null): Promise<number>;
-    deleteByKey(scope: string, scopeId: string | null, pageKey: string): Promise<number>;
-    findPageByKey(scope: string, scopeId: string | null, pageKey: string): Promise<{
-        id?: string;
-        page_key: string;
-    } | null | undefined>;
-    listPagesForUser(userId: string): Promise<KnowledgeIndexPageListing[]>;
-    getUserPageCount(userId: string): Promise<number>;
-    incrementUsageCount(pageIds: string[]): Promise<void>;
-    searchRRF(userId: string, queryEmbedding: number[] | null, queryText: string, limit: number): Promise<Array<{
-        pageKey: string;
-        summary: string;
-        rrfScore: number;
-    }>>;
-}
-export interface KnowledgeEventPort {
-    createEvent(params: {
-        blockId: string | null;
-        eventType: string;
-        actorId: string;
-        chatId?: string | null;
-        messageId?: string | null;
-        payload: Record<string, unknown>;
-    }): Promise<unknown>;
-}
-export interface KnowledgeGitDiffPort {
-    diffNameStatus(fromSha: string, toSha: string, pathPrefix?: string): Promise<Array<{
-        status: string;
-        path: string;
-    }>>;
-    getFileAtCommit(path: string, sha: string): Promise<string>;
-}
-export type WikiFileStorePort = KtxFileStorePort<WikiFileStorePort>;