@kaelio/ktx 0.0.0 → 0.1.0-rc.0

package/dist/io/mode.d.ts

@@ -0,0 +1,9 @@
+import type { KtxCliIo } from '../cli-runtime.js';
+export type KtxOutputMode = 'pretty' | 'plain' | 'json';
+export interface ResolveOutputModeArgs {
+    explicit?: string;
+    json?: boolean;
+    io: KtxCliIo;
+    env?: NodeJS.ProcessEnv;
+}
+export declare function resolveOutputMode(args: ResolveOutputModeArgs): KtxOutputMode;

package/dist/io/mode.js

@@ -0,0 +1,28 @@
+const MODES = new Set(['pretty', 'plain', 'json']);
+export function resolveOutputMode(args) {
+    if (args.json === true) {
+        return 'json';
+    }
+    if (args.explicit !== undefined) {
+        if (!MODES.has(args.explicit)) {
+            throw new Error(`Invalid --output value: ${args.explicit}. Expected one of pretty, plain, json.`);
+        }
+        return args.explicit;
+    }
+    const env = args.env ?? process.env;
+    const envMode = env.KTX_OUTPUT;
+    if (envMode !== undefined && envMode !== '') {
+        if (!MODES.has(envMode)) {
+            throw new Error(`Invalid KTX_OUTPUT value: ${envMode}. Expected one of pretty, plain, json.`);
+        }
+        return envMode;
+    }
+    const ci = env.CI;
+    if (ci !== undefined && ci !== '' && ci !== '0' && ci !== 'false') {
+        return 'plain';
+    }
+    if (args.io.stdout.isTTY === true) {
+        return 'pretty';
+    }
+    return 'plain';
+}

package/dist/io/mode.test.d.ts

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

package/dist/io/mode.test.js

@@ -0,0 +1,48 @@
+import { describe, expect, it } from 'vitest';
+import { resolveOutputMode } from './mode.js';
+function ioWith(isTTY) {
+    return {
+        stdout: { isTTY, write: () => { } },
+        stderr: { write: () => { } },
+    };
+}
+describe('resolveOutputMode', () => {
+    it('uses explicit value when provided', () => {
+        expect(resolveOutputMode({ explicit: 'pretty', io: ioWith(false), env: {} })).toBe('pretty');
+        expect(resolveOutputMode({ explicit: 'plain', io: ioWith(true), env: {} })).toBe('plain');
+        expect(resolveOutputMode({ explicit: 'json', io: ioWith(true), env: {} })).toBe('json');
+    });
+    it('json:true takes precedence over explicit value', () => {
+        expect(resolveOutputMode({ explicit: 'pretty', json: true, io: ioWith(true), env: {} })).toBe('json');
+    });
+    it('throws on unknown explicit value', () => {
+        expect(() => resolveOutputMode({ explicit: 'fancy', io: ioWith(true), env: {} })).toThrow(/Invalid --output/);
+    });
+    it('honors KTX_OUTPUT env var when no explicit value', () => {
+        expect(resolveOutputMode({ io: ioWith(true), env: { KTX_OUTPUT: 'plain' } })).toBe('plain');
+        expect(resolveOutputMode({ io: ioWith(false), env: { KTX_OUTPUT: 'pretty' } })).toBe('pretty');
+        expect(resolveOutputMode({ io: ioWith(false), env: { KTX_OUTPUT: 'json' } })).toBe('json');
+    });
+    it('throws on unknown KTX_OUTPUT', () => {
+        expect(() => resolveOutputMode({ io: ioWith(true), env: { KTX_OUTPUT: 'fancy' } })).toThrow(/Invalid KTX_OUTPUT/);
+    });
+    it('returns plain when CI is set to a truthy value', () => {
+        expect(resolveOutputMode({ io: ioWith(true), env: { CI: 'true' } })).toBe('plain');
+        expect(resolveOutputMode({ io: ioWith(true), env: { CI: '1' } })).toBe('plain');
+    });
+    it('ignores CI when set to a falsy value', () => {
+        expect(resolveOutputMode({ io: ioWith(true), env: { CI: '' } })).toBe('pretty');
+        expect(resolveOutputMode({ io: ioWith(true), env: { CI: '0' } })).toBe('pretty');
+        expect(resolveOutputMode({ io: ioWith(true), env: { CI: 'false' } })).toBe('pretty');
+    });
+    it('returns pretty when stdout is a TTY and CI is not set', () => {
+        expect(resolveOutputMode({ io: ioWith(true), env: {} })).toBe('pretty');
+    });
+    it('returns plain when stdout is not a TTY', () => {
+        expect(resolveOutputMode({ io: ioWith(false), env: {} })).toBe('plain');
+        expect(resolveOutputMode({ io: ioWith(undefined), env: {} })).toBe('plain');
+    });
+    it('explicit value beats KTX_OUTPUT env var', () => {
+        expect(resolveOutputMode({ explicit: 'json', io: ioWith(true), env: { KTX_OUTPUT: 'plain' } })).toBe('json');
+    });
+});

package/dist/io/print-list.d.ts

@@ -0,0 +1,27 @@
+import type { KtxCliIo } from '../cli-runtime.js';
+import type { KtxOutputMode } from './mode.js';
+export interface PrintListColumn<Row> {
+    key: keyof Row & string;
+    label?: string;
+    /**
+     * Plain-mode rendering control.
+     * - `string` (including `''`): emit `${plain}${value}` as a tab-separated cell.
+     * - `false`: omit this column entirely in plain mode.
+     * - `undefined`: same as `''`.
+     */
+    plain?: string | false;
+    /** Skip this column when the row's value is null / undefined / empty string. */
+    optional?: boolean;
+    /** Pretty-mode hint: render this column dim. */
+    dim?: boolean;
+}
+export interface PrintListArgs<Row> {
+    rows: ReadonlyArray<Row>;
+    columns: ReadonlyArray<PrintListColumn<Row>>;
+    groupBy?: keyof Row & string;
+    emptyMessage: string;
+    command: string;
+    mode: KtxOutputMode;
+    io: KtxCliIo;
+}
+export declare function printList<Row extends object>(args: PrintListArgs<Row>): void;

package/dist/io/print-list.js

@@ -0,0 +1,121 @@
+import { bold, dim, SYMBOLS } from './symbols.js';
+export function printList(args) {
+    switch (args.mode) {
+        case 'json':
+            printListJson(args);
+            return;
+        case 'plain':
+            printListPlain(args);
+            return;
+        case 'pretty':
+            printListPretty(args);
+            return;
+    }
+}
+function isEmpty(value) {
+    return value === undefined || value === null || value === '';
+}
+function printListPlain(args) {
+    for (const row of args.rows) {
+        const cells = [];
+        for (const col of args.columns) {
+            if (col.plain === false)
+                continue;
+            const value = row[col.key];
+            if (col.optional && isEmpty(value))
+                continue;
+            const prefix = col.plain ?? '';
+            cells.push(`${prefix}${value === undefined || value === null ? '' : String(value)}`);
+        }
+        args.io.stdout.write(`${cells.join('\t')}\n`);
+    }
+}
+function printListJson(args) {
+    const envelope = {
+        kind: 'list',
+        data: { items: args.rows },
+        meta: { command: args.command },
+    };
+    args.io.stdout.write(`${JSON.stringify(envelope, null, 2)}\n`);
+}
+function pluralize(count, singular) {
+    return `${count} ${count === 1 ? singular : `${singular}s`}`;
+}
+function metricCell(label, count) {
+    // "5 cols", "3 measures", "1 join" / "2 joins"
+    // The label in PrintListColumn is uppercase; pretty mode lowercases it.
+    const word = label.toLowerCase();
+    return `${count} ${count === 1 ? singularize(word) : word}`;
+}
+function singularize(word) {
+    if (word === 'joins')
+        return 'join';
+    if (word === 'measures')
+        return 'measure';
+    if (word === 'cols')
+        return 'col';
+    if (word.endsWith('s'))
+        return word.slice(0, -1);
+    return word;
+}
+function groupRows(rows, key) {
+    const groups = new Map();
+    for (const row of rows) {
+        const value = String(row[key] ?? '');
+        const bucket = groups.get(value);
+        if (bucket) {
+            bucket.push(row);
+        }
+        else {
+            groups.set(value, [row]);
+        }
+    }
+    return groups;
+}
+function printListPretty(args) {
+    const { io, command, rows, columns, groupBy, emptyMessage } = args;
+    io.stdout.write(`${SYMBOLS.barStart}  ${command}\n`);
+    io.stdout.write(`${SYMBOLS.bar}\n`);
+    if (rows.length === 0) {
+        io.stdout.write(`${SYMBOLS.barEnd}  ${emptyMessage}\n`);
+        return;
+    }
+    // Identify role of each column.
+    // - First non-grouped, non-metric, non-optional column = "name" column (bolded)
+    // - Columns with a `plain` prefix = metric columns (rendered as "N word")
+    // - optional columns = trailing suffix (em-dash + value), only when value is present
+    const nameCol = columns.find((c) => c.key !== groupBy && !c.plain && !c.optional && c.plain !== false);
+    const metricCols = columns.filter((c) => typeof c.plain === 'string' && c.plain.length > 0);
+    const optionalCols = columns.filter((c) => c.optional === true);
+    const buckets = groupBy ? groupRows(rows, groupBy) : new Map([['', [...rows]]]);
+    const nameWidth = nameCol
+        ? Math.max(...rows.map((r) => String(r[nameCol.key] ?? '').length))
+        : 0;
+    for (const [groupValue, groupRowList] of buckets) {
+        if (groupBy) {
+            io.stdout.write(`${SYMBOLS.bar}  ${SYMBOLS.group} ${bold(groupValue)} ${dim(`(${pluralize(groupRowList.length, 'source')})`)}\n`);
+        }
+        for (const row of groupRowList) {
+            const segments = [];
+            if (nameCol) {
+                segments.push(String(row[nameCol.key] ?? '').padEnd(nameWidth));
+            }
+            const metrics = metricCols
+                .map((c) => metricCell(c.label ?? c.key, Number(row[c.key] ?? 0)))
+                .join(` ${SYMBOLS.middot} `);
+            if (metrics.length > 0)
+                segments.push(dim(metrics));
+            const optionalSuffix = optionalCols
+                .map((c) => row[c.key])
+                .filter((v) => !isEmpty(v))
+                .map((v) => `${SYMBOLS.emDash} ${dim(String(v))}`)
+                .join(' ');
+            if (optionalSuffix.length > 0)
+                segments.push(optionalSuffix);
+            const indent = groupBy ? '    ' : '  ';
+            io.stdout.write(`${SYMBOLS.bar}${indent}${SYMBOLS.item} ${segments.join('  ')}\n`);
+        }
+    }
+    io.stdout.write(`${SYMBOLS.bar}\n`);
+    io.stdout.write(`${SYMBOLS.barEnd}  ${pluralize(rows.length, 'source')}\n`);
+}

package/dist/io/print-list.test.d.ts

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

package/dist/io/print-list.test.js

@@ -0,0 +1,147 @@
+import { describe, expect, it } from 'vitest';
+import { printList } from './print-list.js';
+import { SYMBOLS } from './symbols.js';
+function recorder() {
+    let stdout = '';
+    let stderr = '';
+    return {
+        io: {
+            stdout: { write: (chunk) => { stdout += chunk; } },
+            stderr: { write: (chunk) => { stderr += chunk; } },
+        },
+        out: () => stdout,
+        err: () => stderr,
+    };
+}
+const SL_COLUMNS = [
+    { key: 'connectionId', label: 'CONNECTION', plain: '' },
+    { key: 'name', label: 'NAME', plain: '' },
+    { key: 'columnCount', label: 'COLS', plain: 'columns=', dim: true },
+    { key: 'measureCount', label: 'MEASURES', plain: 'measures=', dim: true },
+    { key: 'joinCount', label: 'JOINS', plain: 'joins=', dim: true },
+    { key: 'description', label: 'DESCRIPTION', plain: false, optional: true, dim: true },
+];
+const ORDERS = { connectionId: 'warehouse', name: 'orders', columnCount: 5, measureCount: 3, joinCount: 1 };
+const USERS = { connectionId: 'warehouse', name: 'users', columnCount: 8, measureCount: 2, joinCount: 2, description: 'User profile + auth' };
+describe('printList — plain mode', () => {
+    it('emits one tab-separated row per item, skipping plain:false columns', () => {
+        const r = recorder();
+        printList({
+            rows: [ORDERS, USERS],
+            columns: SL_COLUMNS,
+            mode: 'plain',
+            command: 'sl list',
+            emptyMessage: 'No sources',
+            io: r.io,
+        });
+        expect(r.out()).toBe('warehouse\torders\tcolumns=5\tmeasures=3\tjoins=1\n' +
+            'warehouse\tusers\tcolumns=8\tmeasures=2\tjoins=2\n');
+    });
+    it('emits nothing on empty list (preserves current sl list zero-row behavior)', () => {
+        const r = recorder();
+        printList({
+            rows: [],
+            columns: SL_COLUMNS,
+            mode: 'plain',
+            command: 'sl list',
+            emptyMessage: 'No sources',
+            io: r.io,
+        });
+        expect(r.out()).toBe('');
+    });
+});
+describe('printList — json mode', () => {
+    it('emits the envelope with kind=list, data.items, and meta.command', () => {
+        const r = recorder();
+        printList({
+            rows: [ORDERS, USERS],
+            columns: SL_COLUMNS,
+            mode: 'json',
+            command: 'sl list',
+            emptyMessage: 'No sources',
+            io: r.io,
+        });
+        const written = r.out();
+        expect(written.endsWith('\n')).toBe(true);
+        const parsed = JSON.parse(written);
+        expect(parsed).toEqual({
+            kind: 'list',
+            data: { items: [ORDERS, USERS] },
+            meta: { command: 'sl list' },
+        });
+    });
+    it('emits an empty items array when no rows', () => {
+        const r = recorder();
+        printList({
+            rows: [],
+            columns: SL_COLUMNS,
+            mode: 'json',
+            command: 'sl list',
+            emptyMessage: 'No sources',
+            io: r.io,
+        });
+        expect(JSON.parse(r.out())).toEqual({
+            kind: 'list',
+            data: { items: [] },
+            meta: { command: 'sl list' },
+        });
+    });
+});
+function stripAnsi(s) {
+    // Matches ESC [ ... m sequences emitted by node:util.styleText.
+    return s.replace(/\[[0-9;]*m/g, '');
+}
+describe('printList — pretty mode', () => {
+    it('renders a Clack-style header, grouped rows, and footer', () => {
+        const r = recorder();
+        printList({
+            rows: [ORDERS, USERS],
+            columns: SL_COLUMNS,
+            groupBy: 'connectionId',
+            mode: 'pretty',
+            command: 'sl list',
+            emptyMessage: 'No sources',
+            io: r.io,
+        });
+        const out = stripAnsi(r.out());
+        expect(out).toContain(`${SYMBOLS.barStart}  sl list`);
+        expect(out).toContain(`${SYMBOLS.group} warehouse`);
+        expect(out).toContain('(2 sources)');
+        expect(out).toMatch(new RegExp(`${escapeRegExp(SYMBOLS.item)} orders\\s+5 cols ${escapeRegExp(SYMBOLS.middot)} 3 measures ${escapeRegExp(SYMBOLS.middot)} 1 join\\b`));
+        expect(out).toMatch(new RegExp(`${escapeRegExp(SYMBOLS.item)} users\\s+8 cols ${escapeRegExp(SYMBOLS.middot)} 2 measures ${escapeRegExp(SYMBOLS.middot)} 2 joins\\b`));
+        expect(out).toContain(`${SYMBOLS.emDash} User profile + auth`);
+        expect(out).toContain(`${SYMBOLS.barEnd}  2 sources`);
+    });
+    it('renders an empty-state message when no rows', () => {
+        const r = recorder();
+        printList({
+            rows: [],
+            columns: SL_COLUMNS,
+            groupBy: 'connectionId',
+            mode: 'pretty',
+            command: 'sl list',
+            emptyMessage: 'No semantic-layer sources found in /tmp/proj',
+            io: r.io,
+        });
+        const out = stripAnsi(r.out());
+        expect(out).toContain(`${SYMBOLS.barStart}  sl list`);
+        expect(out).toContain(`${SYMBOLS.barEnd}  No semantic-layer sources found in /tmp/proj`);
+    });
+    it('singularizes the footer when there is one row', () => {
+        const r = recorder();
+        printList({
+            rows: [ORDERS],
+            columns: SL_COLUMNS,
+            groupBy: 'connectionId',
+            mode: 'pretty',
+            command: 'sl list',
+            emptyMessage: 'No sources',
+            io: r.io,
+        });
+        const out = stripAnsi(r.out());
+        expect(out).toContain(`${SYMBOLS.barEnd}  1 source`);
+    });
+});
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/io/symbols.d.ts

@@ -0,0 +1,12 @@
+export declare const SYMBOLS: {
+    readonly bar: "|" | "│";
+    readonly barStart: "◇" | "o";
+    readonly barEnd: "└" | "—";
+    readonly group: "●" | "*";
+    readonly item: "*" | "◆";
+    readonly middot: "-" | "·";
+    readonly emDash: "--" | "—";
+};
+export declare function dim(text: string): string;
+export declare function bold(text: string): string;
+export declare function gray(text: string): string;

package/dist/io/symbols.js

@@ -0,0 +1,29 @@
+import { styleText } from 'node:util';
+function detectUnicodeSupport(env = process.env) {
+    if (process.platform !== 'win32') {
+        return env.TERM !== 'linux';
+    }
+    return (Boolean(env.WT_SESSION) ||
+        env.TERM_PROGRAM === 'vscode' ||
+        env.TERM === 'xterm-256color' ||
+        env.TERM === 'alacritty');
+}
+const unicode = detectUnicodeSupport();
+export const SYMBOLS = {
+    bar: unicode ? '│' : '|',
+    barStart: unicode ? '◇' : 'o',
+    barEnd: unicode ? '└' : '—',
+    group: unicode ? '●' : '*',
+    item: unicode ? '◆' : '*',
+    middot: unicode ? '·' : '-',
+    emDash: unicode ? '—' : '--',
+};
+export function dim(text) {
+    return styleText('dim', text);
+}
+export function bold(text) {
+    return styleText('bold', text);
+}
+export function gray(text) {
+    return styleText('gray', text);
+}

package/dist/knowledge.d.ts

@@ -0,0 +1,37 @@
+import { type LocalKnowledgeScope } from '@ktx/context/wiki';
+export type KtxKnowledgeArgs = {
+    command: 'list';
+    projectDir: string;
+    userId: string;
+} | {
+    command: 'read';
+    projectDir: string;
+    key: string;
+    userId: string;
+} | {
+    command: 'search';
+    projectDir: string;
+    query: string;
+    userId: string;
+} | {
+    command: 'write';
+    projectDir: string;
+    key: string;
+    scope: LocalKnowledgeScope;
+    userId: string;
+    summary: string;
+    content: string;
+    tags: string[];
+    refs: string[];
+    slRefs: string[];
+};
+interface KtxKnowledgeIo {
+    stdout: {
+        write(chunk: string): void;
+    };
+    stderr: {
+        write(chunk: string): void;
+    };
+}
+export declare function runKtxKnowledge(args: KtxKnowledgeArgs, io?: KtxKnowledgeIo): Promise<number>;
+export {};

package/dist/knowledge.js

@@ -0,0 +1,58 @@
+import { loadKtxProject } from '@ktx/context/project';
+import { listLocalKnowledgePages, readLocalKnowledgePage, searchLocalKnowledgePages, writeLocalKnowledgePage, } from '@ktx/context/wiki';
+export async function runKtxKnowledge(args, io = process) {
+    try {
+        const project = await loadKtxProject({ projectDir: args.projectDir });
+        if (args.command === 'list') {
+            const pages = await listLocalKnowledgePages(project, { userId: args.userId });
+            for (const page of pages) {
+                io.stdout.write(`${page.scope}\t${page.key}\t${page.summary}\n`);
+            }
+            return 0;
+        }
+        if (args.command === 'read') {
+            const page = await readLocalKnowledgePage(project, { key: args.key, userId: args.userId });
+            if (!page) {
+                throw new Error(`Knowledge page "${args.key}" was not found`);
+            }
+            io.stdout.write(`# ${page.key}\n\n`);
+            io.stdout.write(`Scope: ${page.scope}\n`);
+            io.stdout.write(`Summary: ${page.summary}\n\n`);
+            io.stdout.write(`${page.content}\n`);
+            return 0;
+        }
+        if (args.command === 'search') {
+            const results = await searchLocalKnowledgePages(project, { query: args.query, userId: args.userId });
+            if (results.length === 0) {
+                const pages = await listLocalKnowledgePages(project, { userId: args.userId });
+                if (pages.length === 0) {
+                    io.stderr.write(`No local wiki pages found in ${project.projectDir}. Create one with \`ktx wiki write <key> --summary <summary> --content <content>\` or run ingest.\n`);
+                }
+                else {
+                    io.stderr.write(`No local wiki pages matched "${args.query}". Run \`ktx wiki list\` to inspect available pages.\n`);
+                }
+                return 0;
+            }
+            for (const result of results) {
+                io.stdout.write(`${result.score}\t${result.scope}\t${result.key}\t${result.summary}\n`);
+            }
+            return 0;
+        }
+        const write = await writeLocalKnowledgePage(project, {
+            key: args.key,
+            scope: args.scope,
+            userId: args.userId,
+            summary: args.summary,
+            content: args.content,
+            tags: args.tags,
+            refs: args.refs,
+            slRefs: args.slRefs,
+        });
+        io.stdout.write(`Wrote ${write.path}\n`);
+        return 0;
+    }
+    catch (error) {
+        io.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        return 1;
+    }
+}

package/dist/knowledge.test.d.ts

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

package/dist/knowledge.test.js

@@ -0,0 +1,72 @@
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { initKtxProject } from '@ktx/context/project';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { runKtxKnowledge } from './knowledge.js';
+function makeIo() {
+    let stdout = '';
+    let stderr = '';
+    return {
+        io: {
+            stdout: {
+                write: (chunk) => {
+                    stdout += chunk;
+                },
+            },
+            stderr: {
+                write: (chunk) => {
+                    stderr += chunk;
+                },
+            },
+        },
+        stdout: () => stdout,
+        stderr: () => stderr,
+    };
+}
+describe('runKtxKnowledge', () => {
+    let tempDir;
+    beforeEach(async () => {
+        tempDir = await mkdtemp(join(tmpdir(), 'ktx-cli-knowledge-'));
+    });
+    afterEach(async () => {
+        await rm(tempDir, { recursive: true, force: true });
+    });
+    it('writes, reads, lists, and searches knowledge pages', async () => {
+        const projectDir = join(tempDir, 'project');
+        await initKtxProject({ projectDir, projectName: 'warehouse' });
+        const writeIo = makeIo();
+        await expect(runKtxKnowledge({
+            command: 'write',
+            projectDir,
+            key: 'metrics/revenue',
+            scope: 'GLOBAL',
+            userId: 'local',
+            summary: 'Revenue',
+            content: 'Revenue is paid order value.',
+            tags: ['finance'],
+            refs: [],
+            slRefs: ['orders'],
+        }, writeIo.io)).resolves.toBe(0);
+        expect(writeIo.stdout()).toContain('Wrote knowledge/global/metrics/revenue.md');
+        const readIo = makeIo();
+        await expect(runKtxKnowledge({ command: 'read', projectDir, key: 'metrics/revenue', userId: 'local' }, readIo.io)).resolves.toBe(0);
+        expect(readIo.stdout()).toContain('# metrics/revenue');
+        expect(readIo.stdout()).toContain('Revenue is paid order value.');
+        const listIo = makeIo();
+        await expect(runKtxKnowledge({ command: 'list', projectDir, userId: 'local' }, listIo.io)).resolves.toBe(0);
+        expect(listIo.stdout()).toContain('GLOBAL\tmetrics/revenue\tRevenue');
+        const searchIo = makeIo();
+        await expect(runKtxKnowledge({ command: 'search', projectDir, query: 'paid order', userId: 'local' }, searchIo.io)).resolves.toBe(0);
+        expect(searchIo.stdout()).toContain('metrics/revenue');
+    });
+    it('explains empty search results for a project without wiki pages', async () => {
+        const projectDir = join(tempDir, 'empty-project');
+        await initKtxProject({ projectDir, projectName: 'warehouse' });
+        const searchIo = makeIo();
+        await expect(runKtxKnowledge({ command: 'search', projectDir, query: 'revenue', userId: 'local' }, searchIo.io)).resolves.toBe(0);
+        expect(searchIo.stdout()).toBe('');
+        expect(searchIo.stderr()).toContain('No local wiki pages found');
+        expect(searchIo.stderr()).toContain('ktx wiki write');
+    });
+});

package/dist/local-adapters.d.ts

@@ -0,0 +1,9 @@
+import { type DefaultLocalIngestAdaptersOptions, type SourceAdapter } from '@ktx/context/ingest';
+import type { KtxLocalProject } from '@ktx/context/project';
+import { type ManagedPythonCoreDaemonOptions } from './managed-python-http.js';
+export interface KtxCliLocalIngestAdaptersOptions extends DefaultLocalIngestAdaptersOptions {
+    historicSqlConnectionId?: string;
+    sqlAnalysisUrl?: string;
+    managedDaemon?: ManagedPythonCoreDaemonOptions;
+}
+export declare function createKtxCliLocalIngestAdapters(project: KtxLocalProject, options?: KtxCliLocalIngestAdaptersOptions): SourceAdapter[];