@kaelio/ktx 0.5.0 → 0.7.0

package/dist/sql.test.js

@@ -1,253 +0,0 @@
-import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { initKtxProject } from './context/project/project.js';
-import { parseKtxProjectConfig, serializeKtxProjectConfig } from './context/project/config.js';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { runKtxSql } from './sql.js';
-function makeIo(options = {}) {
-    let stdout = '';
-    let stderr = '';
-    return {
-        io: {
-            stdout: {
-                isTTY: options.isTTY,
-                write: (chunk) => {
-                    stdout += chunk;
-                },
-            },
-            stderr: {
-                write: (chunk) => {
-                    stderr += chunk;
-                },
-            },
-        },
-        stdout: () => stdout,
-        stderr: () => stderr,
-    };
-}
-function makeSqlAnalysis(result) {
-    return {
-        analyzeForFingerprint: vi.fn(),
-        analyzeBatch: vi.fn(async () => new Map([['cli-sql', { tablesTouched: ['orders'], columnsByClause: {} }]])),
-        validateReadOnly: vi.fn(async () => result),
-    };
-}
-function makeConnector(overrides = {}) {
-    return {
-        id: 'sqlite:warehouse',
-        driver: 'sqlite',
-        capabilities: {
-            structuralIntrospection: true,
-            tableSampling: true,
-            columnSampling: true,
-            columnStats: true,
-            readOnlySql: true,
-            nestedAnalysis: false,
-            eventStreamDiscovery: false,
-            formalForeignKeys: true,
-            estimatedRowCounts: true,
-        },
-        introspect: vi.fn(),
-        executeReadOnly: vi.fn(async () => ({
-            headers: ['id', 'status'],
-            headerTypes: ['integer', 'text'],
-            rows: [
-                [1, 'paid'],
-                [2, 'open'],
-            ],
-            totalRows: 2,
-            rowCount: 2,
-        })),
-        cleanup: vi.fn(async () => undefined),
-        ...overrides,
-    };
-}
-describe('runKtxSql', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-cli-sql-'));
-    });
-    afterEach(async () => {
-        vi.unstubAllEnvs();
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    async function writeConnections(projectDir, connections) {
-        const config = parseKtxProjectConfig(await readFile(join(projectDir, 'ktx.yaml'), 'utf-8'));
-        await writeFile(join(projectDir, 'ktx.yaml'), serializeKtxProjectConfig({ ...config, connections }), 'utf-8');
-    }
-    it('validates SQL, executes through the scan connector, and prints a pretty table', async () => {
-        const projectDir = join(tempDir, 'project');
-        await initKtxProject({ projectDir });
-        await writeConnections(projectDir, { warehouse: { driver: 'sqlite', path: 'warehouse.db' } });
-        const sqlAnalysis = makeSqlAnalysis({ ok: true, error: null });
-        const connector = makeConnector();
-        const createScanConnector = vi.fn(async () => connector);
-        const io = makeIo();
-        await expect(runKtxSql({
-            command: 'execute',
-            projectDir,
-            connectionId: 'warehouse',
-            sql: 'select id, status from orders',
-            maxRows: 1000,
-            output: 'pretty',
-            json: false,
-            cliVersion: '0.0.0-test',
-        }, io.io, {
-            createSqlAnalysis: () => sqlAnalysis,
-            createScanConnector,
-        })).resolves.toBe(0);
-        expect(sqlAnalysis.validateReadOnly).toHaveBeenCalledWith('select id, status from orders', 'sqlite');
-        expect(createScanConnector).toHaveBeenCalledWith(expect.objectContaining({ projectDir }), 'warehouse');
-        expect(connector.executeReadOnly).toHaveBeenCalledWith({ connectionId: 'warehouse', sql: 'select id, status from orders', maxRows: 1000 }, { runId: 'cli-sql' });
-        expect(connector.cleanup).toHaveBeenCalledTimes(1);
-        expect(io.stdout()).toContain('id  status');
-        expect(io.stdout()).toContain('1   paid');
-        expect(io.stdout()).toContain('2   open');
-        expect(io.stdout()).toContain('2 rows');
-        expect(io.stderr()).toBe('');
-    });
-    it('emits debug telemetry for SQL without raw query text', async () => {
-        vi.stubEnv('KTX_TELEMETRY_DEBUG', '1');
-        vi.stubEnv('CI', '');
-        const projectDir = join(tempDir, 'project');
-        await initKtxProject({ projectDir });
-        await writeConnections(projectDir, { warehouse: { driver: 'sqlite', path: 'warehouse.db' } });
-        const io = makeIo({ isTTY: true });
-        await expect(runKtxSql({
-            command: 'execute',
-            projectDir,
-            connectionId: 'warehouse',
-            sql: 'select count(*) from orders',
-            maxRows: 10,
-            output: 'json',
-            json: true,
-            cliVersion: '0.0.0-test',
-        }, io.io, {
-            createSqlAnalysis: () => makeSqlAnalysis({ ok: true, error: null }),
-            createScanConnector: vi.fn(async () => makeConnector()),
-        })).resolves.toBe(0);
-        expect(io.stderr()).toContain('"event":"sql_completed"');
-        expect(io.stderr()).toContain('"queryVerb":"select"');
-        expect(io.stderr()).not.toContain('select count(*)');
-    });
-    it('prints JSON output', async () => {
-        const projectDir = join(tempDir, 'project');
-        await initKtxProject({ projectDir });
-        await writeConnections(projectDir, { warehouse: { driver: 'sqlite', path: 'warehouse.db' } });
-        const io = makeIo();
-        await expect(runKtxSql({
-            command: 'execute',
-            projectDir,
-            connectionId: 'warehouse',
-            sql: 'select id from orders',
-            maxRows: 10,
-            output: undefined,
-            json: true,
-            cliVersion: '0.0.0-test',
-        }, io.io, {
-            createSqlAnalysis: () => makeSqlAnalysis({ ok: true, error: null }),
-            createScanConnector: vi.fn(async () => makeConnector()),
-        })).resolves.toBe(0);
-        expect(JSON.parse(io.stdout())).toEqual({
-            connectionId: 'warehouse',
-            headers: ['id', 'status'],
-            headerTypes: ['integer', 'text'],
-            rows: [
-                [1, 'paid'],
-                [2, 'open'],
-            ],
-            rowCount: 2,
-        });
-    });
-    it('prints plain TSV output', async () => {
-        const projectDir = join(tempDir, 'project');
-        await initKtxProject({ projectDir });
-        await writeConnections(projectDir, { warehouse: { driver: 'sqlite', path: 'warehouse.db' } });
-        const io = makeIo();
-        await expect(runKtxSql({
-            command: 'execute',
-            projectDir,
-            connectionId: 'warehouse',
-            sql: 'select id from orders',
-            maxRows: 10,
-            output: 'plain',
-            json: false,
-            cliVersion: '0.0.0-test',
-        }, io.io, {
-            createSqlAnalysis: () => makeSqlAnalysis({ ok: true, error: null }),
-            createScanConnector: vi.fn(async () => makeConnector()),
-        })).resolves.toBe(0);
-        expect(io.stdout()).toBe('id\tstatus\n1\tpaid\n2\topen\n');
-        expect(io.stderr()).toBe('');
-    });
-    it('rejects non-read-only SQL before executing connector SQL', async () => {
-        const projectDir = join(tempDir, 'project');
-        await initKtxProject({ projectDir });
-        await writeConnections(projectDir, { warehouse: { driver: 'sqlite', path: 'warehouse.db' } });
-        const connector = makeConnector();
-        const io = makeIo();
-        await expect(runKtxSql({
-            command: 'execute',
-            projectDir,
-            connectionId: 'warehouse',
-            sql: 'delete from orders',
-            maxRows: 1000,
-            output: 'pretty',
-            json: false,
-            cliVersion: '0.0.0-test',
-        }, io.io, {
-            createSqlAnalysis: () => makeSqlAnalysis({ ok: false, error: 'SQL contains read/write operation: Delete' }),
-            createScanConnector: vi.fn(async () => connector),
-        })).resolves.toBe(1);
-        expect(connector.executeReadOnly).not.toHaveBeenCalled();
-        expect(connector.cleanup).not.toHaveBeenCalled();
-        expect(io.stderr()).toContain('SQL contains read/write operation: Delete');
-    });
-    it('rejects missing connections', async () => {
-        const projectDir = join(tempDir, 'project');
-        await initKtxProject({ projectDir });
-        const io = makeIo();
-        await expect(runKtxSql({
-            command: 'execute',
-            projectDir,
-            connectionId: 'warehouse',
-            sql: 'select 1',
-            maxRows: 1000,
-            output: 'pretty',
-            json: false,
-            cliVersion: '0.0.0-test',
-        }, io.io, {
-            createSqlAnalysis: () => makeSqlAnalysis({ ok: true, error: null }),
-        })).resolves.toBe(1);
-        expect(io.stderr()).toContain('Connection "warehouse" is not configured in ktx.yaml');
-    });
-    it('rejects connectors without read-only SQL support and still cleans up', async () => {
-        const projectDir = join(tempDir, 'project');
-        await initKtxProject({ projectDir });
-        await writeConnections(projectDir, { warehouse: { driver: 'sqlite', path: 'warehouse.db' } });
-        const connector = makeConnector({
-            capabilities: {
-                ...makeConnector().capabilities,
-                readOnlySql: false,
-            },
-        });
-        const io = makeIo();
-        await expect(runKtxSql({
-            command: 'execute',
-            projectDir,
-            connectionId: 'warehouse',
-            sql: 'select 1',
-            maxRows: 1000,
-            output: 'pretty',
-            json: false,
-            cliVersion: '0.0.0-test',
-        }, io.io, {
-            createSqlAnalysis: () => makeSqlAnalysis({ ok: true, error: null }),
-            createScanConnector: vi.fn(async () => connector),
-        })).resolves.toBe(1);
-        expect(connector.executeReadOnly).not.toHaveBeenCalled();
-        expect(connector.cleanup).toHaveBeenCalledTimes(1);
-        expect(io.stderr()).toContain('Connection "warehouse" does not support read-only SQL execution.');
-    });
-});

package/dist/standalone-smoke.test.d.ts

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

package/dist/standalone-smoke.test.js

@@ -1,250 +0,0 @@
-import { execFile } from 'node:child_process';
-import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { promisify } from 'node:util';
-import { parseKtxProjectConfig } from './context/project/config.js';
-import Database from 'better-sqlite3';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-const execFileAsync = promisify(execFile);
-const CLI_BIN = resolve(process.cwd(), 'dist/bin.js');
-function isExecFailure(error) {
-    return error instanceof Error && ('stdout' in error || 'stderr' in error || 'code' in error);
-}
-async function runBuiltCli(args, options = {}) {
-    try {
-        const result = await execFileAsync(process.execPath, [CLI_BIN, ...args], {
-            ...(options.cwd ? { cwd: options.cwd } : {}),
-            encoding: 'utf8',
-            timeout: 20_000,
-            env: options.env ?? process.env,
-        });
-        return {
-            code: 0,
-            stdout: result.stdout,
-            stderr: result.stderr,
-        };
-    }
-    catch (error) {
-        if (!isExecFailure(error)) {
-            throw error;
-        }
-        return {
-            code: typeof error.code === 'number' ? error.code : 1,
-            stdout: error.stdout ?? '',
-            stderr: error.stderr ?? error.message,
-        };
-    }
-}
-function createSqliteWarehouse(dbPath) {
-    const db = new Database(dbPath);
-    try {
-        db.exec(`
-      PRAGMA foreign_keys = ON;
-      CREATE TABLE customers (
-        id INTEGER PRIMARY KEY,
-        name TEXT NOT NULL
-      );
-      CREATE TABLE orders (
-        id INTEGER PRIMARY KEY,
-        customer_id INTEGER NOT NULL,
-        total NUMERIC,
-        created_at TEXT,
-        FOREIGN KEY(customer_id) REFERENCES customers(id)
-      );
-      INSERT INTO customers (id, name) VALUES (1, 'Ada'), (2, 'Grace');
-      INSERT INTO orders (id, customer_id, total, created_at)
-        VALUES (10, 1, 42.5, '2026-04-28'), (11, 2, 9.5, '2026-04-29');
-    `);
-    }
-    finally {
-        db.close();
-    }
-}
-async function writeSqliteScanConfig(projectDir, dbPath, enrich = false) {
-    await writeFile(join(projectDir, 'ktx.yaml'), [
-        'connections:',
-        '  warehouse:',
-        '    driver: sqlite',
-        `    path: ${JSON.stringify(dbPath)}`,
-        'ingest:',
-        '  adapters:',
-        '    - live-database',
-        ...(enrich
-            ? [
-                'scan:',
-                '  enrichment:',
-                '    mode: deterministic',
-                '    embeddings:',
-                '      backend: none',
-                '      dimensions: 6',
-            ]
-            : []),
-        '',
-    ].join('\n'), 'utf-8');
-}
-function expectProjectStderr(result, projectDir) {
-    expect(result).toMatchObject({ code: 0, stderr: `Project: ${projectDir}\n` });
-}
-function expectSetupStderr(result) {
-    expect(result).toMatchObject({ code: 0, stderr: '' });
-}
-async function runSetupNewProject(projectDir) {
-    return await runBuiltCli([
-        'setup',
-        '--project-dir',
-        projectDir,
-        '--no-input',
-        '--yes',
-        '--skip-llm',
-        '--skip-embeddings',
-        '--skip-databases',
-        '--skip-sources',
-        '--skip-agents',
-    ]);
-}
-describe('standalone built ktx CLI smoke', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-standalone-smoke-'));
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('rejects old low-level ingest flags through the built binary', async () => {
-        const projectDir = join(tempDir, 'project');
-        const init = await runSetupNewProject(projectDir);
-        expectSetupStderr(init);
-        expect(init.stdout).toContain(`Project: ${projectDir}`);
-        const reindex = await runBuiltCli(['--project-dir', projectDir, 'admin', 'reindex', '--output', 'plain']);
-        expect(reindex.code).toBe(0);
-        expect(reindex.stdout).toContain('reindex\t');
-        expect(reindex.stderr).toContain('wiki/global');
-        const run = await runBuiltCli([
-            'ingest',
-            'run',
-            '--connection-id',
-            'warehouse',
-            '--adapter',
-            'fake',
-        ]);
-        expect(run).toMatchObject({ code: 1, stdout: '' });
-        expect(run.stderr).toContain("unknown option '--adapter'");
-    });
-    it('rejects the removed agent command through the built binary', async () => {
-        const result = await runBuiltCli(['agent']);
-        expect(result.code).toBe(1);
-        expect(result.stdout).toBe('');
-        expect(result.stderr).toContain("unknown command 'agent'");
-    });
-    it('runs status setup checks through the built binary', async () => {
-        const result = await runBuiltCli(['status', '--verbose', '--no-input'], { cwd: tempDir });
-        expect(result.stdout).toMatch(/KTX status/);
-        if (result.stdout.includes('No project here yet.')) {
-            expect(result.stdout).toContain('ktx setup');
-        }
-        else {
-            expect(result.stdout).toContain('Node 22+');
-            expect(result.stdout).toContain('Workspace-local CLI');
-        }
-        expect(result.stdout).toContain('Node 22+');
-        expect(result.stdout).toContain('Workspace-local CLI');
-        expect(result.stderr === '' || result.stderr.startsWith('Project: ')).toBe(true);
-        expect([0, 1]).toContain(result.code);
-    });
-    it('runs fast public database ingest through the built binary with manifest artifacts', async () => {
-        const projectDir = join(tempDir, 'database-ingest-project');
-        const init = await runSetupNewProject(projectDir);
-        expectSetupStderr(init);
-        const dbPath = join(projectDir, 'warehouse.db');
-        createSqliteWarehouse(dbPath);
-        await writeSqliteScanConfig(projectDir, dbPath);
-        const connectionTest = await runBuiltCli(['connection', 'test', 'warehouse', '--project-dir', projectDir]);
-        expectProjectStderr(connectionTest, projectDir);
-        expect(connectionTest.stdout).toContain('Connection test passed: warehouse');
-        expect(connectionTest.stdout).toContain('Driver: sqlite');
-        expect(connectionTest.stdout).toContain('Status: ok');
-        const ingest = await runBuiltCli(['ingest', 'warehouse', '--project-dir', projectDir, '--fast', '--no-input']);
-        expectProjectStderr(ingest, projectDir);
-        expect(ingest.stdout).toContain('Ingest finished');
-        expect(ingest.stdout).toContain('warehouse');
-        expect(ingest.stdout).toContain('Database schema');
-        expect(ingest.stdout).toContain('warehouse      done');
-        expect(ingest.stdout).not.toContain('KTX scan completed');
-        const manifest = await readFile(join(projectDir, 'semantic-layer/warehouse/_schema/public.yaml'), 'utf-8');
-        expect(manifest).toContain('customers:');
-        expect(manifest).toContain('orders:');
-        expect(manifest).toContain('source: formal');
-        expect(manifest).not.toContain('ai:');
-    }, 30_000);
-    it('parses gateway LLM config and OpenAI enrichment embeddings used by standalone scans without network calls', async () => {
-        const projectDir = join(tempDir, 'gateway-config-project');
-        await mkdir(projectDir, { recursive: true });
-        await writeFile(join(projectDir, 'ktx.yaml'), [
-            'llm:',
-            '  provider:',
-            '    backend: gateway',
-            '    gateway:',
-            '      api_key: env:AI_GATEWAY_API_KEY', // pragma: allowlist secret
-            '  models:',
-            '    default: env:KTX_SCAN_LLM_MODEL',
-            'scan:',
-            '  enrichment:',
-            '    mode: llm',
-            '    embeddings:',
-            '      backend: openai',
-            '      model: env:KTX_SCAN_EMBEDDING_MODEL',
-            '      dimensions: 1536',
-            '      openai:',
-            '        api_key: env:OPENAI_API_KEY', // pragma: allowlist secret
-            '      batchSize: 16',
-            '',
-        ].join('\n'), 'utf8');
-        const config = parseKtxProjectConfig(await readFile(join(projectDir, 'ktx.yaml'), 'utf8'));
-        expect(config.llm).toEqual({
-            provider: {
-                backend: 'gateway',
-                gateway: { api_key: 'env:AI_GATEWAY_API_KEY' }, // pragma: allowlist secret
-            },
-            models: { default: 'env:KTX_SCAN_LLM_MODEL' },
-        });
-        expect(config.scan.enrichment).toEqual({
-            mode: 'llm',
-            embeddings: {
-                backend: 'openai',
-                model: 'env:KTX_SCAN_EMBEDDING_MODEL',
-                dimensions: 1536,
-                openai: { api_key: 'env:OPENAI_API_KEY' }, // pragma: allowlist secret
-                batchSize: 16,
-            },
-        });
-    });
-    it('rejects the removed connection add command through the built binary', async () => {
-        const projectDir = join(tempDir, 'notion-project');
-        const init = await runSetupNewProject(projectDir);
-        expectSetupStderr(init);
-        const add = await runBuiltCli([
-            'connection',
-            'add',
-            'notion',
-            'notion-main',
-            '--project-dir',
-            projectDir,
-            '--token-env',
-            'NOTION_TOKEN',
-            '--crawl-mode',
-            'all_accessible',
-            '--max-pages',
-            '5',
-        ]);
-        expect(add.code).toBe(1);
-        expect(add.stdout).toBe('');
-        expect(add.stderr).toMatch(/unknown (command|option)|too many arguments/);
-        const yaml = await readFile(join(projectDir, 'ktx.yaml'), 'utf-8');
-        expect(yaml).not.toContain('driver: notion');
-        expect(yaml).not.toContain('auth_token_ref: env:NOTION_TOKEN');
-        expect(yaml).not.toContain('ntn_');
-        const parsed = parseKtxProjectConfig(yaml);
-        expect(parsed.connections['notion-main']).toBeUndefined();
-    });
-});

package/dist/status-project.test.d.ts

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