@kaelio/ktx 0.4.1 → 0.6.0

package/node_modules/@ktx/context/dist/wiki/tools/wiki-read.tool.test.d.ts

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

package/node_modules/@ktx/context/dist/wiki/tools/wiki-read.tool.test.js

@@ -1,66 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createTouchedSlSources } from '../../tools/index.js';
-import { WikiReadTool } from './wiki-read.tool.js';
-describe('WikiReadTool', () => {
-    const baseContext = { sourceId: 's', messageId: 'm', userId: 'u' };
-    it('reads from the session wiki service when a worktree-scoped ingest session is present', async () => {
-        const rootWikiService = { readPageForUser: vi.fn().mockResolvedValue(null) };
-        const sessionWikiService = {
-            readPageForUser: vi.fn().mockResolvedValue({
-                pageKey: 'staged-page',
-                scope: 'GLOBAL',
-                frontmatter: { summary: 'Staged', tags: ['notion'], refs: ['related'] },
-                content: 'A page written earlier in the same ingest worktree.',
-            }),
-        };
-        const pagesRepository = { findPageByKey: vi.fn().mockResolvedValue({ id: 'page-1' }), incrementUsageCount: vi.fn() };
-        const tool = new WikiReadTool(rootWikiService, pagesRepository);
-        const session = {
-            connectionId: 'c',
-            isWorktreeScoped: true,
-            preHead: null,
-            touchedSlSources: createTouchedSlSources(),
-            actions: [],
-            semanticLayerService: {},
-            wikiService: sessionWikiService,
-            configService: {},
-            gitService: {},
-        };
-        const result = await tool.call({ key: 'staged-page' }, { ...baseContext, session });
-        expect(rootWikiService.readPageForUser).not.toHaveBeenCalled();
-        expect(sessionWikiService.readPageForUser).toHaveBeenCalledWith('u', 'staged-page');
-        expect(result.structured).toMatchObject({ found: true, blockKey: 'staged-page', scope: 'GLOBAL' });
-        expect(result.markdown).toContain('A page written earlier in the same ingest worktree.');
-    });
-    it('rejects slash-delimited page keys with a flat-key suggestion', async () => {
-        const rootWikiService = { readPageForUser: vi.fn().mockResolvedValue(null) };
-        const pagesRepository = { findPageByKey: vi.fn(), incrementUsageCount: vi.fn() };
-        const tool = new WikiReadTool(rootWikiService, pagesRepository);
-        const result = await tool.call({ key: 'orbit/company-overview' }, baseContext);
-        expect(result.structured).toEqual({
-            blockKey: 'orbit/company-overview',
-            content: '',
-            scope: '',
-            found: false,
-        });
-        expect(result.markdown).toContain('Invalid wiki key "orbit/company-overview". Wiki keys must be flat; use "orbit-company-overview".');
-        expect(rootWikiService.readPageForUser).not.toHaveBeenCalled();
-    });
-    it('does not append derived refs to the editable markdown body', async () => {
-        const rootWikiService = {
-            readPageForUser: vi.fn().mockResolvedValue({
-                pageKey: 'orbit-how-we-work',
-                scope: 'GLOBAL',
-                frontmatter: { summary: 'How we work', tags: ['policy'], refs: ['orbit-company-overview'] },
-                content: '## How We Work\n\nUse written-first operating norms.',
-            }),
-        };
-        const pagesRepository = { findPageByKey: vi.fn().mockResolvedValue(null), incrementUsageCount: vi.fn() };
-        const tool = new WikiReadTool(rootWikiService, pagesRepository);
-        const result = await tool.call({ key: 'orbit-how-we-work' }, baseContext);
-        expect(result.markdown).toBe('## How We Work\n\nUse written-first operating norms.');
-        expect(result.markdown).not.toContain('See also');
-        expect(result.markdown).not.toContain('[[orbit-company-overview]]');
-        expect(result.structured.refs).toEqual(['orbit-company-overview']);
-    });
-});

package/node_modules/@ktx/context/dist/wiki/tools/wiki-remove.tool.d.ts

@@ -1,28 +0,0 @@
-import { z } from 'zod';
-import type { KnowledgeIndexPort } from '../ports.js';
-import type { KnowledgeEventPort } from '../ports.js';
-import { KnowledgeWikiService } from '../index.js';
-import { BaseTool, type ToolContext, type ToolOutput } from '../../tools/index.js';
-declare const wikiRemoveInputSchema: z.ZodObject<{
-    key: z.ZodString;
-    rawPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-type WikiRemoveInput = z.infer<typeof wikiRemoveInputSchema>;
-interface WikiRemoveStructured {
-    success: boolean;
-    key: string;
-}
-export declare class WikiRemoveTool extends BaseTool<typeof wikiRemoveInputSchema> {
-    private readonly wikiService;
-    private readonly pagesRepository;
-    private readonly knowledgeRepository;
-    readonly name = "wiki_remove";
-    constructor(wikiService: KnowledgeWikiService, pagesRepository: KnowledgeIndexPort, knowledgeRepository: KnowledgeEventPort);
-    get description(): string;
-    get inputSchema(): z.ZodObject<{
-        key: z.ZodString;
-        rawPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>;
-    call(input: WikiRemoveInput, context: ToolContext): Promise<ToolOutput<WikiRemoveStructured>>;
-}
-export {};

package/node_modules/@ktx/context/dist/wiki/tools/wiki-remove.tool.js

@@ -1,85 +0,0 @@
-import { z } from 'zod';
-import { validateFlatWikiKey } from '../keys.js';
-import { BaseTool, validateActionRawPaths } from '../../tools/index.js';
-const SYSTEM_AUTHOR = 'System User';
-const SYSTEM_EMAIL = 'system@example.com';
-const wikiRemoveInputSchema = z.object({
-    key: z.string().describe('The page key to remove'),
-    rawPaths: z
-        .array(z.string().min(1))
-        .optional()
-        .describe('In ingest sessions, raw source file paths that directly support this removal.'),
-});
-export class WikiRemoveTool extends BaseTool {
-    wikiService;
-    pagesRepository;
-    knowledgeRepository;
-    name = 'wiki_remove';
-    constructor(wikiService, pagesRepository, knowledgeRepository) {
-        super();
-        this.wikiService = wikiService;
-        this.pagesRepository = pagesRepository;
-        this.knowledgeRepository = knowledgeRepository;
-    }
-    get description() {
-        return `<purpose>Remove a wiki page that is no longer relevant.</purpose>`;
-    }
-    get inputSchema() {
-        return wikiRemoveInputSchema;
-    }
-    async call(input, context) {
-        const wikiService = context.session?.wikiService ?? this.wikiService;
-        const writesGlobal = !!context.session;
-        const skipIndex = context.session?.isWorktreeScoped === true;
-        const keyValidation = validateFlatWikiKey(input.key);
-        if (!keyValidation.ok) {
-            return {
-                markdown: keyValidation.error,
-                structured: { success: false, key: input.key },
-            };
-        }
-        const rawPathValidation = validateActionRawPaths(context.session, input.rawPaths);
-        if (!rawPathValidation.ok) {
-            return {
-                markdown: `Error: ${rawPathValidation.error}`,
-                structured: { success: false, key: input.key },
-            };
-        }
-        const scope = writesGlobal ? 'GLOBAL' : 'USER';
-        const scopeId = scope === 'USER' ? context.userId : null;
-        const existing = context.session
-            ? await wikiService.readPage(scope, scopeId, input.key)
-            : await this.pagesRepository.findPageByKey(scope, scopeId, input.key);
-        if (!existing) {
-            return {
-                markdown: `Page "${input.key}" not found.`,
-                structured: { success: false, key: input.key },
-            };
-        }
-        await wikiService.deletePage(scope, scopeId, input.key, SYSTEM_AUTHOR, SYSTEM_EMAIL);
-        if (!skipIndex) {
-            await wikiService.deleteFromIndex(scope, scopeId, input.key);
-        }
-        await this.knowledgeRepository.createEvent({
-            blockId: null,
-            eventType: 'BLOCK_REMOVED',
-            actorId: context.userId,
-            chatId: null,
-            messageId: null,
-            payload: { removedKey: input.key, blockKey: input.key },
-        });
-        if (context.session) {
-            context.session.actions.push({
-                target: 'wiki',
-                type: 'removed',
-                key: input.key,
-                detail: `Removed page "${input.key}"`,
-                ...(rawPathValidation.rawPaths ? { rawPaths: rawPathValidation.rawPaths } : {}),
-            });
-        }
-        return {
-            markdown: `Page "${input.key}" removed.`,
-            structured: { success: true, key: input.key },
-        };
-    }
-}

package/node_modules/@ktx/context/dist/wiki/tools/wiki-remove.tool.test.d.ts

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

package/node_modules/@ktx/context/dist/wiki/tools/wiki-remove.tool.test.js

@@ -1,95 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createTouchedSlSources } from '../../tools/index.js';
-import { WikiRemoveTool } from './wiki-remove.tool.js';
-describe('WikiRemoveTool', () => {
-    const baseContext = { sourceId: 's', messageId: 'm', userId: 'u' };
-    it('removes an existing page when no session is present', async () => {
-        const wikiService = {
-            deletePage: vi.fn().mockResolvedValue(undefined),
-            deleteFromIndex: vi.fn().mockResolvedValue(undefined),
-        };
-        const pagesRepository = {
-            findPageByKey: vi.fn().mockResolvedValue({ page_key: 'old' }),
-        };
-        const knowledgeRepository = { createEvent: vi.fn().mockResolvedValue(undefined) };
-        const tool = new WikiRemoveTool(wikiService, pagesRepository, knowledgeRepository);
-        const result = await tool.call({ key: 'old' }, baseContext);
-        expect(wikiService.deletePage).toHaveBeenCalledTimes(1);
-        expect(wikiService.deleteFromIndex).toHaveBeenCalledTimes(1);
-        expect(result.markdown).toMatch(/removed/i);
-    });
-    it('rejects slash-delimited page keys with a flat-key suggestion', async () => {
-        const wikiService = {
-            deletePage: vi.fn().mockResolvedValue(undefined),
-            deleteFromIndex: vi.fn().mockResolvedValue(undefined),
-        };
-        const pagesRepository = { findPageByKey: vi.fn().mockResolvedValue({ page_key: 'old' }) };
-        const knowledgeRepository = { createEvent: vi.fn().mockResolvedValue(undefined) };
-        const tool = new WikiRemoveTool(wikiService, pagesRepository, knowledgeRepository);
-        const result = await tool.call({ key: 'orbit/company-overview' }, baseContext);
-        expect(result.structured).toEqual({ success: false, key: 'orbit/company-overview' });
-        expect(result.markdown).toContain('Invalid wiki key "orbit/company-overview". Wiki keys must be flat; use "orbit-company-overview".');
-        expect(pagesRepository.findPageByKey).not.toHaveBeenCalled();
-        expect(wikiService.deletePage).not.toHaveBeenCalled();
-    });
-    it('skips deleteFromIndex when session is worktree-scoped', async () => {
-        const wikiService = {
-            readPage: vi.fn().mockResolvedValue({ pageKey: 'old', frontmatter: { summary: 'Old' }, content: 'body' }),
-            deletePage: vi.fn().mockResolvedValue(undefined),
-            deleteFromIndex: vi.fn().mockResolvedValue(undefined),
-        };
-        const pagesRepository = { findPageByKey: vi.fn().mockResolvedValue({ page_key: 'old' }) };
-        const knowledgeRepository = { createEvent: vi.fn().mockResolvedValue(undefined) };
-        const tool = new WikiRemoveTool(wikiService, pagesRepository, knowledgeRepository);
-        const session = {
-            connectionId: 'c',
-            isWorktreeScoped: true,
-            preHead: null,
-            touchedSlSources: createTouchedSlSources(),
-            actions: [],
-            semanticLayerService: {},
-            wikiService: wikiService,
-            configService: {},
-            gitService: {},
-        };
-        await tool.call({ key: 'old' }, { ...baseContext, session });
-        expect(wikiService.deletePage).toHaveBeenCalledTimes(1);
-        expect(wikiService.deleteFromIndex).not.toHaveBeenCalled();
-        expect(session.actions).toContainEqual(expect.objectContaining({ target: 'wiki', type: 'removed', key: 'old' }));
-    });
-    it('finds pages through the session wiki service even when the shared index has not seen the worktree write', async () => {
-        const wikiService = {
-            readPage: vi.fn().mockResolvedValue({ pageKey: 'staged', frontmatter: { summary: 'Staged' }, content: 'body' }),
-            deletePage: vi.fn().mockResolvedValue(undefined),
-            deleteFromIndex: vi.fn().mockResolvedValue(undefined),
-        };
-        const pagesRepository = { findPageByKey: vi.fn().mockResolvedValue(null) };
-        const knowledgeRepository = { createEvent: vi.fn().mockResolvedValue(undefined) };
-        const tool = new WikiRemoveTool(wikiService, pagesRepository, knowledgeRepository);
-        const session = {
-            connectionId: 'c',
-            isWorktreeScoped: true,
-            preHead: null,
-            touchedSlSources: createTouchedSlSources(),
-            actions: [],
-            semanticLayerService: {},
-            wikiService: wikiService,
-            configService: {},
-            gitService: {},
-        };
-        const result = await tool.call({ key: 'staged' }, { ...baseContext, session });
-        expect(pagesRepository.findPageByKey).not.toHaveBeenCalled();
-        expect(wikiService.readPage).toHaveBeenCalledWith('GLOBAL', null, 'staged');
-        expect(wikiService.deletePage).toHaveBeenCalledTimes(1);
-        expect(result.structured).toEqual({ success: true, key: 'staged' });
-    });
-    it('returns a friendly message when the page does not exist', async () => {
-        const wikiService = { deletePage: vi.fn(), deleteFromIndex: vi.fn() };
-        const pagesRepository = { findPageByKey: vi.fn().mockResolvedValue(null) };
-        const knowledgeRepository = { createEvent: vi.fn() };
-        const tool = new WikiRemoveTool(wikiService, pagesRepository, knowledgeRepository);
-        const result = await tool.call({ key: 'missing' }, baseContext);
-        expect(result.structured.success).toBe(false);
-        expect(result.markdown).toMatch(/not found/i);
-    });
-});

package/node_modules/@ktx/context/dist/wiki/tools/wiki-search.tool.d.ts

@@ -1,49 +0,0 @@
-import { z } from 'zod';
-import { BaseTool, type ToolContext, type ToolOutput } from '../../tools/index.js';
-import type { WikiSearchLaneSummary, WikiSearchMatchReason } from '../types.js';
-declare const WikiSearchInputSchema: z.ZodObject<{
-    query: z.ZodString;
-    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-}, z.core.$strip>;
-type WikiSearchInput = z.infer<typeof WikiSearchInputSchema>;
-interface WikiSearchResult {
-    blockKey: string;
-    path: string;
-    summary: string;
-    score: number;
-    matchReasons?: WikiSearchMatchReason[];
-    lanes?: WikiSearchLaneSummary[];
-}
-interface WikiSearchStructured {
-    results: WikiSearchResult[];
-    totalFound: number;
-}
-export interface WikiSearchAdapterPort {
-    search(input: {
-        userId: string;
-        query: string;
-        limit: number;
-    }): Promise<{
-        results: Array<{
-            key: string;
-            path: string;
-            summary: string;
-            score: number;
-            matchReasons?: WikiSearchMatchReason[];
-            lanes?: WikiSearchLaneSummary[];
-        }>;
-        totalFound: number;
-    }>;
-}
-export declare class WikiSearchTool extends BaseTool<typeof WikiSearchInputSchema> {
-    private readonly searchAdapter;
-    readonly name = "wiki_search";
-    constructor(searchAdapter: WikiSearchAdapterPort);
-    get description(): string;
-    get inputSchema(): z.ZodObject<{
-        query: z.ZodString;
-        limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    }, z.core.$strip>;
-    call(input: WikiSearchInput, context: ToolContext): Promise<ToolOutput<WikiSearchStructured>>;
-}
-export {};

package/node_modules/@ktx/context/dist/wiki/tools/wiki-search.tool.js

@@ -1,51 +0,0 @@
-import { z } from 'zod';
-import { BaseTool } from '../../tools/index.js';
-const WikiSearchInputSchema = z.object({
-    query: z.string().describe('Natural language search query to find relevant knowledge blocks.'),
-    limit: z.number().optional().default(10).describe('Maximum number of results to return (default 10).'),
-});
-export class WikiSearchTool extends BaseTool {
-    searchAdapter;
-    name = 'wiki_search';
-    constructor(searchAdapter) {
-        super();
-        this.searchAdapter = searchAdapter;
-    }
-    get description() {
-        return ('Search knowledge blocks by hybrid lexical, semantic, and token matching. ' +
-            'Use this when you need to find knowledge on a topic not visible in the discovery index. ' +
-            'Returns ranked summaries — use wiki_read to load the full content of specific results.');
-    }
-    get inputSchema() {
-        return WikiSearchInputSchema;
-    }
-    async call(input, context) {
-        const response = await this.searchAdapter.search({
-            userId: context.userId,
-            query: input.query,
-            limit: input.limit,
-        });
-        if (response.results.length === 0) {
-            return {
-                markdown: `No knowledge blocks found matching "${input.query}".`,
-                structured: { results: [], totalFound: 0 },
-            };
-        }
-        const lines = response.results.map((r, i) => `${i + 1}. **${r.key}**: ${r.summary}`);
-        const structured = {
-            results: response.results.map((r) => ({
-                blockKey: r.key,
-                path: r.path,
-                summary: r.summary,
-                score: r.score,
-                matchReasons: r.matchReasons,
-                lanes: r.lanes,
-            })),
-            totalFound: response.totalFound,
-        };
-        return {
-            markdown: `Found ${response.results.length} knowledge block(s):\n\n${lines.join('\n')}`,
-            structured,
-        };
-    }
-}

package/node_modules/@ktx/context/dist/wiki/tools/wiki-search.tool.test.d.ts

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

package/node_modules/@ktx/context/dist/wiki/tools/wiki-search.tool.test.js

@@ -1,35 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { WikiSearchTool } from './wiki-search.tool.js';
-describe('WikiSearchTool', () => {
-    it('searches through the injected wiki adapter port', async () => {
-        const search = vi.fn(async () => ({
-            results: [
-                {
-                    key: 'metrics-revenue',
-                    path: 'wiki/global/metrics-revenue.md',
-                    scope: 'GLOBAL',
-                    summary: 'Revenue metric definition',
-                    score: 0.02459016393442623,
-                    matchReasons: ['lexical', 'token'],
-                },
-            ],
-            totalFound: 1,
-        }));
-        const tool = new WikiSearchTool({ search });
-        const result = await tool.call({ query: 'paid order', limit: 5 }, { sourceId: 'test', messageId: 'message-1', userId: 'agent' });
-        expect(search).toHaveBeenCalledWith({ userId: 'agent', query: 'paid order', limit: 5 });
-        expect(result.structured).toEqual({
-            results: [
-                {
-                    blockKey: 'metrics-revenue',
-                    path: 'wiki/global/metrics-revenue.md',
-                    summary: 'Revenue metric definition',
-                    score: 0.02459016393442623,
-                    matchReasons: ['lexical', 'token'],
-                },
-            ],
-            totalFound: 1,
-        });
-        expect(result.markdown).toContain('**metrics-revenue**');
-    });
-});

package/node_modules/@ktx/context/dist/wiki/tools/wiki-write.tool.d.ts

@@ -1,80 +0,0 @@
-import { z } from 'zod';
-import type { KnowledgeIndexPort } from '../ports.js';
-import type { KnowledgeEventPort } from '../ports.js';
-import { KnowledgeWikiService } from '../index.js';
-import { BaseTool, type ToolContext, type ToolOutput } from '../../tools/index.js';
-declare const wikiWriteInputSchema: z.ZodObject<{
-    key: z.ZodString;
-    summary: z.ZodString;
-    content: z.ZodOptional<z.ZodString>;
-    replacements: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        oldText: z.ZodString;
-        newText: z.ZodString;
-        reason: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    refs: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    sl_refs: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    source: z.ZodOptional<z.ZodString>;
-    intent: z.ZodOptional<z.ZodString>;
-    tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    representative_sql: z.ZodOptional<z.ZodString>;
-    usage: z.ZodOptional<z.ZodObject<{
-        executions: z.ZodNumber;
-        distinct_users: z.ZodNumber;
-        first_seen: z.ZodString;
-        last_seen: z.ZodString;
-        p50_runtime_ms: z.ZodNullable<z.ZodNumber>;
-        p95_runtime_ms: z.ZodNullable<z.ZodNumber>;
-        error_rate: z.ZodNumber;
-        rows_produced: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    fingerprints: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    rawPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-type WikiWriteInput = z.infer<typeof wikiWriteInputSchema>;
-interface WikiWriteStructured {
-    success: boolean;
-    key: string;
-    action?: 'created' | 'updated';
-    content?: string;
-}
-export declare class WikiWriteTool extends BaseTool<typeof wikiWriteInputSchema> {
-    private readonly wikiService;
-    private readonly pagesRepository;
-    private readonly knowledgeRepository;
-    readonly name = "wiki_write";
-    constructor(wikiService: KnowledgeWikiService, pagesRepository: KnowledgeIndexPort, knowledgeRepository: KnowledgeEventPort);
-    get description(): string;
-    get inputSchema(): z.ZodObject<{
-        key: z.ZodString;
-        summary: z.ZodString;
-        content: z.ZodOptional<z.ZodString>;
-        replacements: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            oldText: z.ZodString;
-            newText: z.ZodString;
-            reason: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        refs: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        sl_refs: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        source: z.ZodOptional<z.ZodString>;
-        intent: z.ZodOptional<z.ZodString>;
-        tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        representative_sql: z.ZodOptional<z.ZodString>;
-        usage: z.ZodOptional<z.ZodObject<{
-            executions: z.ZodNumber;
-            distinct_users: z.ZodNumber;
-            first_seen: z.ZodString;
-            last_seen: z.ZodString;
-            p50_runtime_ms: z.ZodNullable<z.ZodNumber>;
-            p95_runtime_ms: z.ZodNullable<z.ZodNumber>;
-            error_rate: z.ZodNumber;
-            rows_produced: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-        fingerprints: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        rawPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>;
-    call(input: WikiWriteInput, context: ToolContext): Promise<ToolOutput<WikiWriteStructured>>;
-}
-export {};