@kaelio/ktx 0.5.0 → 0.7.0

package/dist/database-tree-picker.test.d.ts

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

package/dist/database-tree-picker.test.js

@@ -1,188 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { pickDatabaseScope, } from './database-tree-picker.js';
-function makeIo() {
-    let stdout = '';
-    let stderr = '';
-    return {
-        io: {
-            stdout: {
-                isTTY: true,
-                write: (chunk) => {
-                    stdout += chunk;
-                },
-            },
-            stderr: {
-                write: (chunk) => {
-                    stderr += chunk;
-                },
-            },
-        },
-        stdout: () => stdout,
-        stderr: () => stderr,
-    };
-}
-function captureRenderer() {
-    const capture = {};
-    let nextResult = { kind: 'quit' };
-    const renderer = vi.fn(async (chrome, state) => {
-        capture.chrome = chrome;
-        capture.state = state;
-        return nextResult;
-    });
-    return {
-        renderer,
-        capture,
-        setResult: (result) => {
-            nextResult = result;
-        },
-    };
-}
-const discovered = [
-    { schema: 'analytics', name: 'customers', kind: 'table' },
-    { schema: 'analytics', name: 'orders', kind: 'table' },
-    { schema: 'public', name: 'events', kind: 'view' },
-    { schema: 'public', name: 'sessions', kind: 'table' },
-];
-function promptAdapter(overrides = {}) {
-    return {
-        autocompleteMultiselect: vi.fn(async () => ['analytics']),
-        select: vi.fn(async () => 'refine'),
-        ...overrides,
-    };
-}
-function baseArgs(overrides = {}) {
-    return {
-        connectionId: 'warehouse',
-        schemaNoun: 'schema',
-        schemaNounPlural: 'schemas',
-        schemas: ['analytics', 'public'],
-        schemaSuggestion: { excluded: new Set(), suggested: new Set(['analytics']) },
-        existing: { enabledTables: [] },
-        supportsSchemaScope: true,
-        listTablesForSchemas: vi.fn(async () => discovered),
-        prompts: promptAdapter(),
-        ...overrides,
-    };
-}
-describe('pickDatabaseScope', () => {
-    it('starts Stage 1 with no checked schemas and does not enumerate tables before schema selection', async () => {
-        const prompts = promptAdapter({
-            autocompleteMultiselect: vi.fn(async () => ['analytics']),
-            select: vi.fn(async () => 'save'),
-        });
-        const listTablesForSchemas = vi.fn(async () => [
-            { schema: 'analytics', name: 'orders', kind: 'table' },
-        ]);
-        const result = await pickDatabaseScope(baseArgs({
-            connectionId: 'warehouse',
-            schemaNoun: 'dataset',
-            schemaNounPlural: 'datasets',
-            schemas: ['analytics', 'raw'],
-            schemaSuggestion: { excluded: new Set(['raw']), suggested: new Set(['analytics']) },
-            listTablesForSchemas,
-            prompts,
-        }), makeIo().io, captureRenderer().renderer);
-        expect(listTablesForSchemas).toHaveBeenCalledTimes(1);
-        expect(listTablesForSchemas).toHaveBeenCalledWith(['analytics']);
-        expect(result).toEqual({
-            kind: 'selected',
-            activeSchemas: ['analytics'],
-            enabledTables: ['analytics.orders'],
-        });
-    });
-    it('routes partial existing allowlists through Stage 2 so save preserves table selections', async () => {
-        const { renderer, setResult } = captureRenderer();
-        setResult({ kind: 'save', selectedIds: ['analytics.customers'] });
-        const prompts = promptAdapter({
-            autocompleteMultiselect: vi.fn(async () => ['analytics']),
-            select: vi.fn(async () => 'save'),
-        });
-        const listTablesForSchemas = vi.fn(async () => [
-            { schema: 'analytics', name: 'customers', kind: 'table' },
-            { schema: 'analytics', name: 'orders', kind: 'table' },
-        ]);
-        const result = await pickDatabaseScope(baseArgs({
-            schemas: ['analytics'],
-            schemaSuggestion: { excluded: new Set(), suggested: new Set(['analytics']) },
-            existing: { enabledTables: ['analytics.customers'] },
-            listTablesForSchemas,
-            prompts,
-        }), makeIo().io, renderer);
-        expect(result).toEqual({
-            kind: 'selected',
-            activeSchemas: ['analytics'],
-            enabledTables: ['analytics.customers'],
-        });
-    });
-    it('builds a 2-level tree (schemas as parents, tables as children) and uses save-empty action', async () => {
-        const { renderer, capture, setResult } = captureRenderer();
-        setResult({ kind: 'save', selectedIds: ['analytics'] });
-        await pickDatabaseScope(baseArgs(), makeIo().io, renderer);
-        expect(capture.state?.skipEmptyAction).toBe('save-empty');
-        const schemaIds = capture.state?.tree.filter((n) => n.parentId === null).map((n) => n.id);
-        const tableIds = capture.state?.tree.filter((n) => n.parentId !== null).map((n) => n.id);
-        expect((schemaIds ?? []).sort()).toEqual(['analytics', 'public']);
-        expect((tableIds ?? []).sort()).toEqual([
-            'analytics.customers',
-            'analytics.orders',
-            'public.events',
-            'public.sessions',
-        ]);
-        expect(capture.state?.byId.get('public.events')?.title).toBe('events (view)');
-    });
-    it('pre-checks selected schemas at the parent level when no existing selection reaches Stage 2', async () => {
-        const { renderer, capture, setResult } = captureRenderer();
-        setResult({ kind: 'save', selectedIds: ['analytics'] });
-        await pickDatabaseScope(baseArgs(), makeIo().io, renderer);
-        expect([...(capture.state?.checked ?? [])]).toEqual(['analytics']);
-    });
-    it('collapses an existing full-schema selection back into the parent check', async () => {
-        const { renderer, capture, setResult } = captureRenderer();
-        setResult({ kind: 'save', selectedIds: ['analytics'] });
-        await pickDatabaseScope(baseArgs({ existing: { enabledTables: ['analytics.customers', 'analytics.orders'] } }), makeIo().io, renderer);
-        expect([...(capture.state?.checked ?? [])]).toEqual(['analytics']);
-    });
-    it('keeps a partial existing selection at the leaf level', async () => {
-        const { renderer, capture, setResult } = captureRenderer();
-        setResult({ kind: 'save', selectedIds: ['analytics.customers'] });
-        await pickDatabaseScope(baseArgs({ existing: { enabledTables: ['analytics.customers'] } }), makeIo().io, renderer);
-        expect([...(capture.state?.checked ?? [])]).toEqual(['analytics.customers']);
-    });
-    it('expands a selected schema parent into all its tables and derives activeSchemas', async () => {
-        const { renderer, setResult } = captureRenderer();
-        setResult({ kind: 'save', selectedIds: ['analytics'] });
-        const result = await pickDatabaseScope(baseArgs(), makeIo().io, renderer);
-        expect(result).toEqual({
-            kind: 'selected',
-            activeSchemas: ['analytics'],
-            enabledTables: ['analytics.customers', 'analytics.orders'],
-        });
-    });
-    it('combines parent and individual leaf selections without duplicate tables', async () => {
-        const { renderer, setResult } = captureRenderer();
-        setResult({ kind: 'save', selectedIds: ['analytics', 'public.events'] });
-        const result = await pickDatabaseScope(baseArgs(), makeIo().io, renderer);
-        expect(result).toEqual({
-            kind: 'selected',
-            activeSchemas: ['analytics', 'public'],
-            enabledTables: ['analytics.customers', 'analytics.orders', 'public.events'],
-        });
-    });
-    it('omits activeSchemas when the driver does not support a schema scope', async () => {
-        const { renderer, setResult } = captureRenderer();
-        setResult({ kind: 'save', selectedIds: ['analytics'] });
-        const result = await pickDatabaseScope(baseArgs({ supportsSchemaScope: false }), makeIo().io, renderer);
-        expect(result).toEqual({
-            kind: 'selected',
-            activeSchemas: [],
-            enabledTables: ['analytics.customers', 'analytics.orders'],
-        });
-    });
-    it('returns back when Stage 1 is cancelled', async () => {
-        const prompts = promptAdapter({
-            autocompleteMultiselect: vi.fn(async () => ['back']),
-        });
-        const result = await pickDatabaseScope(baseArgs({ prompts }), makeIo().io, captureRenderer().renderer);
-        expect(result).toEqual({ kind: 'back' });
-    });
-});

package/dist/demo-assets.test.d.ts

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

package/dist/demo-assets.test.js

@@ -1,121 +0,0 @@
-import { access, readFile, rm, stat } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { DEMO_ADAPTER, DEMO_CONNECTION_ID, DEMO_REPLAY_FILE, defaultDemoProjectDir, ensureDemoProject, ensureSeededDemoProject, } from './demo-assets.js';
-const packagedDemoSource = 'packaged-orbit-demo';
-function packagedDemoAssetPath(relativePath) {
-    return fileURLToPath(new URL(`../assets/demo/orbit/${relativePath}`, import.meta.url));
-}
-async function readPackagedJson(relativePath) {
-    return JSON.parse(await readFile(packagedDemoAssetPath(relativePath), 'utf-8'));
-}
-function makeIo() {
-    let stderr = '';
-    return {
-        stdout: {
-            isTTY: true,
-            write() { },
-        },
-        stderr: {
-            write(chunk) {
-                stderr += chunk;
-            },
-        },
-        stderrText: () => stderr,
-    };
-}
-describe('demo assets', () => {
-    const projectDir = join(tmpdir(), `ktx-demo-assets-${process.pid}`);
-    afterEach(async () => {
-        vi.unstubAllEnvs();
-        await rm(projectDir, { recursive: true, force: true });
-    });
-    it('resolves the default demo root under the OS temp directory', () => {
-        const dir = defaultDemoProjectDir();
-        expect(dir.startsWith(join(tmpdir(), 'ktx-demo-'))).toBe(true);
-        expect(dir).toMatch(/ktx-demo-[a-f0-9]{8}$/);
-    });
-    it('exports the packaged Orbit demo identity', () => {
-        expect(DEMO_CONNECTION_ID).toBe('orbit_demo');
-        expect(DEMO_ADAPTER).toBe('live-database');
-        expect(DEMO_REPLAY_FILE).toBe('replay.memory-flow.v1.json');
-    });
-    it('ships the seeded demo bundle required by the May 6 PRD', async () => {
-        const manifest = await readPackagedJson('manifest.json');
-        expect(manifest).toMatchObject({
-            demoAssetSchemaVersion: 2,
-            name: 'orbit',
-            displayName: 'Orbit Demo',
-            mode: 'seeded',
-            source: packagedDemoSource,
-        });
-        expect(manifest.sources.warehouse.tables).toBeGreaterThanOrEqual(5);
-        expect(manifest.sources.warehouse.tables).toBeLessThanOrEqual(10);
-        expect(Object.keys(manifest.sources.warehouse.rowCounts).sort()).toEqual([
-            'accounts',
-            'arr_movements',
-            'contracts',
-            'invoices',
-            'plans',
-            'purchase_requests',
-            'support_tickets',
-            'users',
-        ]);
-        expect(manifest.sources.dbt.models).toBeGreaterThanOrEqual(3);
-        expect(manifest.sources.dbt.models).toBeLessThanOrEqual(6);
-        expect(manifest.sources.bi.explores).toBeGreaterThanOrEqual(2);
-        expect(manifest.sources.bi.dashboards).toBeGreaterThanOrEqual(2);
-        expect(manifest.sources.notion.pages).toBeGreaterThanOrEqual(5);
-        expect(manifest.generated.semanticLayer.sourceCount).toBeGreaterThanOrEqual(40);
-        expect(manifest.generated.knowledge.pageCount).toBeGreaterThanOrEqual(20);
-        expect(manifest.generated.links.linkCount).toBeGreaterThanOrEqual(10);
-        const dbStat = await stat(packagedDemoAssetPath('demo.db'));
-        expect(dbStat.size).toBeGreaterThan(0);
-        expect(dbStat.size).toBeLessThan(10 * 1024 * 1024);
-        await expect(access(packagedDemoAssetPath('semantic-layer/dbt-main/mart_arr_daily.yaml'))).resolves.toBeUndefined();
-        await expect(access(packagedDemoAssetPath('semantic-layer/postgres-warehouse/mart_account_activity.yaml'))).resolves.toBeUndefined();
-        await expect(access(packagedDemoAssetPath('wiki/global/orbit-company-overview.md'))).resolves.toBeUndefined();
-        await expect(access(packagedDemoAssetPath('links/provenance.json'))).resolves.toBeUndefined();
-        await expect(access(packagedDemoAssetPath('reports/seeded-demo-report.json'))).resolves.toBeUndefined();
-    });
-    it('initializes a flat demo project without writing literal credentials', async () => {
-        const result = await ensureDemoProject({ projectDir, force: false });
-        expect(result.projectDir).toBe(projectDir);
-        await expect(access(join(projectDir, 'demo.db'))).resolves.toBeUndefined();
-        await expect(access(join(projectDir, 'state.sqlite'))).resolves.toBeUndefined();
-        await expect(access(join(projectDir, 'reports'))).resolves.toBeUndefined();
-        await expect(access(join(projectDir, 'semantic-layer'))).resolves.toBeUndefined();
-        await expect(access(join(projectDir, 'wiki'))).resolves.toBeUndefined();
-        await expect(access(join(projectDir, 'replays', 'replay.memory-flow.v1.json'))).resolves.toBeUndefined();
-        await expect(access(join(projectDir, 'raw-sources'))).resolves.toBeUndefined();
-        await expect(access(join(projectDir, '_schema'))).rejects.toMatchObject({ code: 'ENOENT' });
-        const config = await readFile(join(projectDir, 'ktx.yaml'), 'utf-8');
-        expect(config).toContain('backend: anthropic');
-        expect(config).toContain('api_key: env:ANTHROPIC_API_KEY');
-        expect(config).not.toContain('sk-ant-');
-    });
-    it('rejects an existing demo project unless force is set', async () => {
-        await ensureDemoProject({ projectDir, force: false });
-        await expect(ensureDemoProject({ projectDir, force: false })).rejects.toThrow('Demo project already exists');
-        await expect(ensureDemoProject({ projectDir, force: true })).resolves.toMatchObject({ projectDir });
-    });
-    it('emits debug telemetry when the demo connection is created', async () => {
-        vi.stubEnv('KTX_TELEMETRY_DEBUG', '1');
-        vi.stubEnv('CI', '');
-        const io = makeIo();
-        await ensureDemoProject({ projectDir, force: false, io, cliVersion: '0.2.0' });
-        expect(io.stderrText()).toContain('"event":"connection_added"');
-        expect(io.stderrText()).toContain('"driver":"sqlite"');
-        expect(io.stderrText()).toContain('"isDemoConnection":true');
-        expect(io.stderrText()).not.toContain(projectDir);
-    });
-    it('copies the seeded project assets used by the setup wizard tour', async () => {
-        await ensureSeededDemoProject({ projectDir, force: false });
-        await expect(access(join(projectDir, 'semantic-layer', 'dbt-main', 'mart_arr_daily.yaml'))).resolves.toBeUndefined();
-        await expect(access(join(projectDir, 'wiki', 'global', 'orbit-company-overview.md'))).resolves.toBeUndefined();
-        await expect(access(join(projectDir, 'links', 'provenance.json'))).resolves.toBeUndefined();
-        await expect(access(join(projectDir, 'reports', 'seeded-demo-report.json'))).resolves.toBeUndefined();
-    });
-});

package/dist/demo-metrics.test.d.ts

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

package/dist/demo-metrics.test.js

@@ -1,108 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildDemoMetrics, formatCost, formatDuration, formatEta, formatTokens, formatTokensPerSec, progressBar, } from './demo-metrics.js';
-function snapshot(events, overrides = {}) {
-    return {
-        runId: 'run-1',
-        connectionId: 'orbit_demo',
-        adapter: 'live-database',
-        status: 'running',
-        sourceDir: null,
-        syncId: 'sync-1',
-        errors: [],
-        events,
-        plannedWorkUnits: [],
-        details: { actions: [], provenance: [], transcripts: [] },
-        ...overrides,
-    };
-}
-describe('buildDemoMetrics', () => {
-    it('estimates elapsed, agent steps, tool calls, and cost from event stream', () => {
-        const start = Date.UTC(2026, 0, 1, 0, 0, 0);
-        const input = snapshot([
-            { type: 'source_acquired', adapter: 'live-database', trigger: 'demo_full', fileCount: 5, emittedAt: new Date(start).toISOString() },
-            { type: 'work_unit_started', unitKey: 'orders', skills: [], stepBudget: 40, emittedAt: new Date(start + 1000).toISOString() },
-            { type: 'work_unit_step', unitKey: 'orders', stepIndex: 6, stepBudget: 40, emittedAt: new Date(start + 6000).toISOString() },
-        ], {
-            plannedWorkUnits: [
-                { unitKey: 'orders', rawFiles: [], peerFileCount: 0, dependencyCount: 0 },
-                { unitKey: 'customers', rawFiles: [], peerFileCount: 0, dependencyCount: 0 },
-            ],
-            details: {
-                actions: [],
-                provenance: [],
-                transcripts: [{ unitKey: 'orders', path: '/tmp/orders.jsonl', toolCallCount: 3, errorCount: 0, toolNames: ['x'] }],
-            },
-        });
-        const metrics = buildDemoMetrics(input, { now: () => start + 10_000 });
-        expect(metrics.elapsedMs).toBe(10_000);
-        expect(metrics.agentSteps).toBe(6);
-        expect(metrics.agentStepBudget).toBe(40);
-        expect(metrics.toolCalls).toBe(3);
-        expect(metrics.workUnitsTotal).toBe(2);
-        expect(metrics.estimatedTokens).toBeGreaterThan(0);
-        expect(metrics.estimatedCostUsd).toBeGreaterThan(0);
-        expect(metrics.isCostEstimated).toBe(true);
-    });
-    it('returns null ETA before the first work unit completes', () => {
-        const input = snapshot([{ type: 'source_acquired', adapter: 'live-database', trigger: 'x', fileCount: 1 }]);
-        const metrics = buildDemoMetrics(input, { now: () => Date.now() });
-        expect(metrics.etaMs).toBeNull();
-    });
-    it('extrapolates ETA from completed/total ratio when at least one unit finishes', () => {
-        const start = Date.UTC(2026, 0, 1);
-        const input = snapshot([
-            { type: 'source_acquired', adapter: 'a', trigger: 't', fileCount: 1, emittedAt: new Date(start).toISOString() },
-            { type: 'work_unit_started', unitKey: 'a', skills: [], stepBudget: 10, emittedAt: new Date(start + 1000).toISOString() },
-            { type: 'work_unit_finished', unitKey: 'a', status: 'success', emittedAt: new Date(start + 5000).toISOString() },
-        ], {
-            plannedWorkUnits: [
-                { unitKey: 'a', rawFiles: [], peerFileCount: 0, dependencyCount: 0 },
-                { unitKey: 'b', rawFiles: [], peerFileCount: 0, dependencyCount: 0 },
-                { unitKey: 'c', rawFiles: [], peerFileCount: 0, dependencyCount: 0 },
-            ],
-        });
-        const metrics = buildDemoMetrics(input, { now: () => start + 6_000 });
-        expect(metrics.etaMs).toBe(12_000);
-    });
-    it('reports ETA=0 when the run is finished', () => {
-        const input = snapshot([], { status: 'done' });
-        const metrics = buildDemoMetrics(input, { now: () => Date.now() });
-        expect(metrics.etaMs).toBe(0);
-    });
-});
-describe('format helpers', () => {
-    it('formats duration in s/m/h cascades', () => {
-        expect(formatDuration(5_000)).toBe('5s');
-        expect(formatDuration(95_000)).toBe('1m35s');
-        expect(formatDuration(3_700_000)).toBe('1h01m');
-        expect(formatDuration(-1)).toBe('--');
-    });
-    it('formats ETA as estimating before any data and as duration once running', () => {
-        expect(formatEta(null, 'running')).toBe('estimating...');
-        expect(formatEta(8_000, 'running')).toBe('8s');
-        expect(formatEta(8_000, 'done')).toBe('done');
-    });
-    it('formats cost with sub-cent guard', () => {
-        expect(formatCost(0)).toBe('$0.000');
-        expect(formatCost(0.0005)).toBe('<$0.001');
-        expect(formatCost(0.012)).toBe('$0.012');
-        expect(formatCost(2.5)).toBe('$2.50');
-    });
-    it('formats token counts with K/M abbreviations', () => {
-        expect(formatTokens(0)).toBe('0');
-        expect(formatTokens(450)).toBe('450');
-        expect(formatTokens(2_300)).toBe('2.3K');
-        expect(formatTokens(1_500_000)).toBe('1.50M');
-    });
-    it('formats tokens per second', () => {
-        expect(formatTokensPerSec(0)).toBe('0/s');
-        expect(formatTokensPerSec(450)).toBe('450/s');
-        expect(formatTokensPerSec(2300)).toBe('2.3K/s');
-    });
-    it('renders a deterministic progress bar with hash and dash characters', () => {
-        expect(progressBar(0, 10)).toBe('----------');
-        expect(progressBar(0.5, 10)).toBe('#####-----');
-        expect(progressBar(1, 10)).toBe('##########');
-        expect(progressBar(1.4, 10)).toBe('##########');
-    });
-});

package/dist/doctor.test.d.ts

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