@kaelio/ktx 0.0.0 → 0.1.0-rc.1

package/dist/demo-metrics.js

@@ -0,0 +1,131 @@
+const DEFAULT_INPUT_TOKENS_PER_STEP = 4500;
+const DEFAULT_OUTPUT_TOKENS_PER_STEP = 700;
+const DEFAULT_INPUT_PRICE_PER_MTOK_USD = 3;
+const DEFAULT_OUTPUT_PRICE_PER_MTOK_USD = 15;
+function eventsOf(events, type) {
+    return events.filter((event) => event.type === type);
+}
+function maxAgentStep(events) {
+    const steps = eventsOf(events, 'work_unit_step');
+    const started = eventsOf(events, 'work_unit_started');
+    const stepIndex = steps.reduce((max, event) => Math.max(max, event.stepIndex), 0);
+    const stepBudget = Math.max(0, ...steps.map((event) => event.stepBudget), ...started.map((event) => event.stepBudget));
+    return { step: stepIndex, budget: stepBudget };
+}
+function totalToolCalls(input) {
+    return input.details.transcripts.reduce((total, transcript) => total + transcript.toolCallCount, 0);
+}
+function workUnitProgress(input) {
+    const started = eventsOf(input.events, 'work_unit_started').length;
+    const finished = eventsOf(input.events, 'work_unit_finished').length;
+    const planned = input.plannedWorkUnits.length;
+    const planEvent = eventsOf(input.events, 'chunks_planned').at(-1);
+    const total = planned || planEvent?.workUnitCount || started || finished || 0;
+    return { started, finished, total };
+}
+function elapsedMsFromEvents(events, nowMs) {
+    const stamped = events
+        .map((event) => (event.emittedAt ? Date.parse(event.emittedAt) : Number.NaN))
+        .filter((value) => Number.isFinite(value));
+    if (stamped.length === 0)
+        return 0;
+    const first = Math.min(...stamped);
+    return Math.max(0, nowMs - first);
+}
+function estimateEtaMs(elapsedMs, finished, total, status) {
+    if (status !== 'running')
+        return 0;
+    if (total === 0 || finished === 0 || elapsedMs === 0)
+        return null;
+    const perUnit = elapsedMs / finished;
+    const remaining = Math.max(0, total - finished);
+    return Math.round(perUnit * remaining);
+}
+export function buildDemoMetrics(input, options = {}) {
+    const tuning = options.tuning ?? {};
+    const inputTokensPerStep = tuning.inputTokensPerStep ?? DEFAULT_INPUT_TOKENS_PER_STEP;
+    const outputTokensPerStep = tuning.outputTokensPerStep ?? DEFAULT_OUTPUT_TOKENS_PER_STEP;
+    const inputPrice = tuning.inputPricePerMTokUsd ?? DEFAULT_INPUT_PRICE_PER_MTOK_USD;
+    const outputPrice = tuning.outputPricePerMTokUsd ?? DEFAULT_OUTPUT_PRICE_PER_MTOK_USD;
+    const nowMs = (options.now ?? Date.now)();
+    const elapsedMs = elapsedMsFromEvents(input.events, nowMs);
+    const { step, budget } = maxAgentStep(input.events);
+    const toolCalls = totalToolCalls(input);
+    const progress = workUnitProgress(input);
+    const finishedCount = eventsOf(input.events, 'work_unit_finished').length;
+    const stepDriver = Math.max(step, toolCalls, finishedCount * 4);
+    const inputTokens = stepDriver * inputTokensPerStep;
+    const outputTokens = stepDriver * outputTokensPerStep;
+    const totalTokens = inputTokens + outputTokens;
+    const cost = (inputTokens / 1_000_000) * inputPrice + (outputTokens / 1_000_000) * outputPrice;
+    const elapsedSec = elapsedMs / 1000;
+    const tokensPerSec = elapsedSec > 0 ? totalTokens / elapsedSec : 0;
+    return {
+        elapsedMs,
+        etaMs: estimateEtaMs(elapsedMs, progress.finished, progress.total, input.status),
+        agentSteps: step,
+        agentStepBudget: budget,
+        toolCalls,
+        workUnitsStarted: progress.started,
+        workUnitsFinished: progress.finished,
+        workUnitsTotal: progress.total,
+        estimatedInputTokens: inputTokens,
+        estimatedOutputTokens: outputTokens,
+        estimatedTokens: totalTokens,
+        estimatedCostUsd: cost,
+        tokensPerSec,
+        status: input.status,
+        isCostEstimated: true,
+    };
+}
+export function formatDuration(ms) {
+    if (!Number.isFinite(ms) || ms < 0)
+        return '--';
+    const totalSec = Math.round(ms / 1000);
+    if (totalSec < 60)
+        return `${totalSec}s`;
+    const min = Math.floor(totalSec / 60);
+    const sec = totalSec % 60;
+    if (min < 60)
+        return `${min}m${sec.toString().padStart(2, '0')}s`;
+    const hr = Math.floor(min / 60);
+    return `${hr}h${(min % 60).toString().padStart(2, '0')}m`;
+}
+export function formatEta(ms, status) {
+    if (status !== 'running')
+        return 'done';
+    if (ms === null)
+        return 'estimating...';
+    return formatDuration(ms);
+}
+export function formatCost(usd) {
+    if (!Number.isFinite(usd) || usd <= 0)
+        return '$0.000';
+    if (usd < 0.001)
+        return '<$0.001';
+    if (usd < 1)
+        return `$${usd.toFixed(3)}`;
+    return `$${usd.toFixed(2)}`;
+}
+export function formatTokens(n) {
+    if (!Number.isFinite(n) || n <= 0)
+        return '0';
+    if (n < 1000)
+        return `${Math.round(n)}`;
+    if (n < 1_000_000)
+        return `${(n / 1000).toFixed(1)}K`;
+    return `${(n / 1_000_000).toFixed(2)}M`;
+}
+export function formatTokensPerSec(n) {
+    if (!Number.isFinite(n) || n <= 0)
+        return '0/s';
+    if (n < 1000)
+        return `${Math.round(n)}/s`;
+    return `${(n / 1000).toFixed(1)}K/s`;
+}
+const PROGRESS_BAR_WIDTH = 12;
+export function progressBar(ratio, width = PROGRESS_BAR_WIDTH) {
+    const clamped = Math.max(0, Math.min(1, ratio));
+    const filled = Math.round(clamped * width);
+    return `${'#'.repeat(filled)}${'-'.repeat(Math.max(0, width - filled))}`;
+}

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

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

package/dist/demo-metrics.test.js

@@ -0,0 +1,108 @@
+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/dev.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from '@commander-js/extra-typings';
+import { type KtxCliCommandContext } from './cli-program.js';
+export declare function registerDevCommands(program: Command, context: KtxCliCommandContext): void;

package/dist/dev.js

@@ -0,0 +1,48 @@
+import { resolve } from 'node:path';
+import { resolveCommandProjectDir } from './cli-program.js';
+import { registerRuntimeCommands } from './commands/runtime-commands.js';
+import { profileMark } from './startup-profile.js';
+profileMark('module:dev');
+export function registerDevCommands(program, context) {
+    const dev = program
+        .command('dev')
+        .description('Low-level project initialization and runtime management')
+        .showHelpAfterError();
+    dev.hook('preAction', (_thisCommand, actionCommand) => {
+        context.writeDebug?.('dev', actionCommand);
+    });
+    dev.action(() => {
+        dev.outputHelp();
+        context.setExitCode(0);
+    });
+    dev
+        .command('init')
+        .description('Initialize a Git-backed KTX project directory for maintenance scripts')
+        .argument('[directory]', 'Project directory')
+        .option('--force', 'Rewrite ktx.yaml and scaffold files in an existing project', false)
+        .action(async (projectDir, commandOptions, command) => {
+        context.setExitCode(await context.runInit({
+            projectDir: projectDir ? resolve(projectDir) : resolveCommandProjectDir(command),
+            force: commandOptions.force === true,
+        }, context.io));
+    });
+    dev
+        .command('schema')
+        .description('Print a JSON Schema describing ktx.yaml (for editors and LLM agents)')
+        .option('--output <file>', 'Write the schema to a file instead of stdout')
+        .action(async (options) => {
+        const { generateKtxProjectConfigJsonSchema } = await import('@ktx/context/project');
+        const json = `${JSON.stringify(generateKtxProjectConfigJsonSchema(), null, 2)}\n`;
+        if (options.output) {
+            const { writeFile } = await import('node:fs/promises');
+            const target = resolve(options.output);
+            await writeFile(target, json, 'utf8');
+            context.io.stdout.write(`Wrote ${target}\n`);
+        }
+        else {
+            context.io.stdout.write(json);
+        }
+        context.setExitCode(0);
+    });
+    registerRuntimeCommands(dev, context);
+}

package/dist/dev.test.d.ts

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

package/dist/dev.test.js

@@ -0,0 +1,169 @@
+import { describe, expect, it, vi } from 'vitest';
+import { runKtxCli } from './index.js';
+function makeIo() {
+    let stdout = '';
+    let stderr = '';
+    return {
+        io: {
+            stdout: {
+                write: (chunk) => {
+                    stdout += chunk;
+                },
+            },
+            stderr: {
+                write: (chunk) => {
+                    stderr += chunk;
+                },
+            },
+        },
+        stdout: () => stdout,
+        stderr: () => stderr,
+    };
+}
+describe('dev Commander tree', () => {
+    it('prints visible dev help with only supported low-level command groups', async () => {
+        const testIo = makeIo();
+        await expect(runKtxCli(['dev', '--help'], testIo.io)).resolves.toBe(0);
+        expect(testIo.stdout()).toContain('Usage: ktx dev [options] [command]');
+        for (const command of ['init', 'runtime']) {
+            expect(testIo.stdout()).toContain(command);
+        }
+        for (const removed of [
+            'doctor',
+            'scan',
+            'ingest',
+            'mapping',
+            'knowledge',
+            'model',
+            'replay',
+            'report',
+            'status',
+            'artifacts',
+            'config',
+            'tools',
+            'daemon',
+        ]) {
+            expect(testIo.stdout()).not.toContain(`${removed} `);
+        }
+        expect(testIo.stderr()).toBe('');
+    });
+    it('lists dev in root command rows', async () => {
+        const testIo = makeIo();
+        await expect(runKtxCli(['--help'], testIo.io)).resolves.toBe(0);
+        expect(testIo.stdout()).not.toContain('Advanced:');
+        expect(testIo.stdout()).toContain('dev');
+        expect(testIo.stdout()).toMatch(/Low-level project initialization and runtime\s+management/);
+        expect(testIo.stderr()).toBe('');
+    });
+    it('keeps project scaffolding under dev init', async () => {
+        const { mkdtemp, readFile, rm } = await import('node:fs/promises');
+        const { tmpdir } = await import('node:os');
+        const { join } = await import('node:path');
+        const tempDir = await mkdtemp(join(tmpdir(), 'ktx-dev-init-'));
+        const projectDir = join(tempDir, 'warehouse');
+        const testIo = makeIo();
+        try {
+            await expect(runKtxCli(['dev', 'init', projectDir], testIo.io)).resolves.toBe(0);
+            expect(testIo.stdout()).toContain(`Initialized KTX project at ${projectDir}`);
+            await expect(readFile(join(projectDir, 'ktx.yaml'), 'utf-8')).resolves.not.toContain('project:');
+            expect(testIo.stderr()).toBe('');
+        }
+        finally {
+            await rm(tempDir, { recursive: true, force: true });
+        }
+    });
+    it('uses global project-dir for dev init when the positional directory is omitted', async () => {
+        const { mkdtemp, rm } = await import('node:fs/promises');
+        const { tmpdir } = await import('node:os');
+        const { join } = await import('node:path');
+        const tempDir = await mkdtemp(join(tmpdir(), 'ktx-dev-init-global-'));
+        const projectDir = join(tempDir, 'global-init');
+        const testIo = makeIo();
+        try {
+            await expect(runKtxCli(['--project-dir', projectDir, 'dev', 'init'], testIo.io)).resolves.toBe(0);
+            expect(testIo.stdout()).toContain(`Initialized KTX project at ${projectDir}`);
+            expect(testIo.stderr()).toBe('');
+        }
+        finally {
+            await rm(tempDir, { recursive: true, force: true });
+        }
+    });
+    it('rejects removed dev command groups', async () => {
+        for (const argv of [
+            ['dev', 'doctor', 'setup'],
+            ['dev', 'runtime', 'doctor'],
+            ['dev', 'runtime', 'prune', '--dry-run'],
+            ['dev', 'scan', 'warehouse'],
+            ['dev', 'ingest', 'run'],
+            ['dev', 'mapping', 'list'],
+            ['dev', 'completion', 'zsh'],
+            ['dev', '__complete', '--shell', 'zsh', '--position', '2', '--', 'ktx', ''],
+            ['dev', 'knowledge', 'list'],
+            ['dev', 'model', 'list'],
+            ['dev', 'artifacts'],
+        ]) {
+            const testIo = makeIo();
+            await expect(runKtxCli(argv, testIo.io)).resolves.toBe(1);
+            expect(testIo.stderr()).toMatch(/unknown command|error:/);
+        }
+    });
+    it.each([
+        {
+            argv: ['dev', 'runtime', '--help'],
+            expected: ['Usage: ktx dev runtime', 'install', 'start', 'stop', 'status'],
+        },
+    ])('prints generated nested help for $argv', async ({ argv, expected }) => {
+        const io = makeIo();
+        const doctor = vi.fn(async () => 0);
+        await expect(runKtxCli(argv, io.io, { doctor })).resolves.toBe(0);
+        for (const text of expected) {
+            expect(io.stdout()).toContain(text);
+        }
+        if (argv.join(' ') === 'dev runtime --help') {
+            expect(io.stdout()).not.toContain('prune');
+            expect(io.stdout()).not.toContain('doctor');
+        }
+        expect(io.stderr()).toBe('');
+        expect(doctor).not.toHaveBeenCalled();
+    });
+    it('rejects old adapter-backed ingest flags through public option parsing and keeps run out of ingest help', async () => {
+        const helpIo = makeIo();
+        const runIo = makeIo();
+        const publicIngest = vi.fn(async () => 0);
+        await expect(runKtxCli(['ingest', '--help'], helpIo.io, { publicIngest })).resolves.toBe(0);
+        await expect(runKtxCli(['ingest', 'run', '--connection-id', 'warehouse', '--adapter', 'metabase', '--project-dir', '/tmp/project'], runIo.io, { publicIngest })).resolves.toBe(1);
+        expect(helpIo.stdout()).not.toMatch(/^  run\s/m);
+        expect(runIo.stderr()).toMatch(/unknown option '--connection-id'|error:/);
+        expect(publicIngest).not.toHaveBeenCalled();
+    });
+    it.each([
+        { argv: ['scan'] },
+        { argv: ['scan', '--help'] },
+        { argv: ['scan', 'warehouse'] },
+        { argv: ['scan', 'warehouse', '--project-dir', '/tmp/project', '--dry-run'] },
+        { argv: ['scan', 'warehouse', '--project-dir', '/tmp/project', '--mode', 'relationships'] },
+    ])('rejects removed top-level scan command $argv', async ({ argv }) => {
+        const io = makeIo();
+        const publicIngest = vi.fn(async () => 0);
+        await expect(runKtxCli(argv, io.io, { publicIngest })).resolves.toBe(1);
+        expect(publicIngest).not.toHaveBeenCalled();
+        expect(io.stderr()).toMatch(/unknown command|error:/);
+    });
+    it('rejects old adapter-backed top-level ingest flags without low-level ingest registration', async () => {
+        const io = makeIo();
+        const publicIngest = vi.fn(async () => 0);
+        await expect(runKtxCli([
+            'ingest',
+            'run',
+            '--connection-id',
+            'warehouse',
+            '--adapter',
+            'metabase',
+            '--project-dir',
+            '/tmp/project',
+            '--json',
+        ], io.io, { publicIngest })).resolves.toBe(1);
+        expect(publicIngest).not.toHaveBeenCalled();
+        expect(io.stderr()).toMatch(/unknown option '--connection-id'|error:/);
+    });
+});

package/dist/doctor.d.ts

@@ -0,0 +1,72 @@
+import type { KtxConfigIssue } from '@ktx/context/project';
+import type { BuildProjectStatusOptions } from './status-project.js';
+type DoctorStatus = 'pass' | 'warn' | 'fail';
+type KtxDoctorOutputMode = 'plain' | 'json';
+type KtxDoctorInputMode = 'auto' | 'disabled';
+type DoctorGroup = 'toolchain' | 'project' | 'search' | 'history';
+export interface DoctorCheck {
+    id: string;
+    label: string;
+    status: DoctorStatus;
+    detail: string;
+    fix?: string;
+    group?: DoctorGroup;
+}
+interface DoctorReport {
+    title: string;
+    checks: DoctorCheck[];
+}
+export type KtxDoctorArgs = {
+    command: 'setup';
+    outputMode: KtxDoctorOutputMode;
+    inputMode?: KtxDoctorInputMode;
+    verbose?: boolean;
+} | {
+    command: 'project';
+    projectDir: string;
+    outputMode: KtxDoctorOutputMode;
+    inputMode?: KtxDoctorInputMode;
+    verbose?: boolean;
+} | {
+    command: 'validate';
+    projectDir: string;
+    outputMode: KtxDoctorOutputMode;
+    inputMode?: KtxDoctorInputMode;
+};
+interface KtxDoctorIo {
+    stdout: {
+        isTTY?: boolean;
+        write(chunk: string): void;
+    };
+    stderr: {
+        write(chunk: string): void;
+    };
+}
+interface SetupDoctorDeps {
+    env?: NodeJS.ProcessEnv;
+    workspaceRoot?: string;
+    execText?: (command: string, args: string[], options?: {
+        cwd?: string;
+        env?: NodeJS.ProcessEnv;
+    }) => Promise<string>;
+    pathExists?: (path: string) => Promise<boolean>;
+    importBetterSqlite3?: () => Promise<unknown>;
+}
+interface KtxDoctorDeps extends BuildProjectStatusOptions {
+    runSetupChecks?: () => Promise<DoctorCheck[]>;
+}
+export declare function runSetupDoctorChecks(deps?: SetupDoctorDeps): Promise<DoctorCheck[]>;
+interface RenderOptions {
+    verbose: boolean;
+    useColor: boolean;
+    durationMs?: number;
+    projectName?: string;
+    projectDir?: string;
+    command?: 'setup' | 'project';
+}
+export declare function formatDoctorReport(report: DoctorReport, options?: Partial<RenderOptions>): string;
+export declare function renderInvalidConfigMessage(projectDir: string, issues: KtxConfigIssue[], outputMode: KtxDoctorOutputMode, io: KtxDoctorIo): void;
+export declare function renderValidConfigMessage(projectDir: string, outputMode: KtxDoctorOutputMode, io: KtxDoctorIo): void;
+export declare function renderMissingProjectMessage(projectDir: string, outputMode: KtxDoctorOutputMode, io: KtxDoctorIo): void;
+export declare function runKtxDoctor(args: KtxDoctorArgs, io?: KtxDoctorIo, deps?: KtxDoctorDeps): Promise<number>;
+export {};