@kaelio/ktx 0.9.0 → 0.10.0

package/dist/setup-prompts.js

@@ -1,5 +1,6 @@
-import { autocomplete, autocompleteMultiselect, cancel, confirm, intro, isCancel, log, multiselect, note, password, select, text, } from '@clack/prompts';
+import { autocomplete, autocompleteMultiselect, cancel, confirm, intro, isCancel, log, multiselect, note, select, text, } from '@clack/prompts';
 import { withMenuOptionsSpacing, withTextInputNavigation } from './prompt-navigation.js';
+import { revealPassword } from './reveal-password-prompt.js';
 import { withSetupInterruptConfirmation } from './setup-interrupt.js';
 const DEFAULT_SETUP_CANCEL_MESSAGE = 'Setup cancelled.';
 export function createKtxSetupPromptAdapter(options) {
@@ -89,7 +90,7 @@ export function createKtxSetupPromptAdapter(options) {
             return isCancel(value) ? undefined : String(value);
         },
         async password(promptOptions) {
-            const value = await withSetupInterruptConfirmation(() => password({ ...promptOptions, message: withTextInputNavigation(promptOptions.message) }));
+            const value = await withSetupInterruptConfirmation(() => revealPassword({ ...promptOptions, message: withTextInputNavigation(promptOptions.message) }));
             return isCancel(value) ? undefined : String(value);
         },
         cancel(message) {

package/dist/setup-sources.js

@@ -29,11 +29,11 @@ import { createKtxSetupPromptAdapter, } from './setup-prompts.js';
 const DEFAULT_NOTION_MAX_KNOWLEDGE_CREATES_PER_RUN = 25;
 const SOURCE_OPTIONS = [
     { value: 'dbt', label: 'dbt' },
-    { value: 'metricflow', label: 'MetricFlow' },
     { value: 'metabase', label: 'Metabase' },
+    { value: 'notion', label: 'Notion' },
+    { value: 'metricflow', label: 'MetricFlow' },
     { value: 'looker', label: 'Looker' },
     { value: 'lookml', label: 'LookML' },
-    { value: 'notion', label: 'Notion' },
 ];
 const SOURCE_LABELS = Object.fromEntries(SOURCE_OPTIONS.map((option) => [option.value, option.label]));
 const PRIMARY_SOURCE_DRIVERS = new Set([
@@ -146,8 +146,8 @@ async function chooseSourceCredentialRef(input) {
             message: `How should KTX find your ${input.label}?`,
             options: [
                 ...(input.existingRef ? [{ value: 'keep', label: 'Keep existing credential' }] : []),
-                { value: 'env', label: `Use ${input.envName} from the environment` },
                 { value: 'paste', label: 'Paste a key and save it as a local secret file' },
+                { value: 'env', label: `Use ${input.envName} from the environment` },
                 { value: 'back', label: 'Back' },
             ],
         });
@@ -179,8 +179,8 @@ async function chooseGitAuthCredentialRef(input) {
             message: `${label} repo requires authentication.`,
             options: [
                 ...(input.existingRef ? [{ value: 'keep', label: 'Keep existing credential' }] : []),
-                { value: 'env', label: 'Use GITHUB_TOKEN from the environment' },
                 { value: 'paste', label: 'Paste a token and save it as a local secret file' },
+                { value: 'env', label: 'Use GITHUB_TOKEN from the environment' },
                 { value: 'skip', label: 'Skip — try without authentication' },
                 { value: 'back', label: 'Back' },
             ],
@@ -800,8 +800,8 @@ async function promptForInteractiveSource(args, source, prompts, io, deps, defau
                 const selectedLocation = await prompts.select({
                     message: `${source} source location`,
                     options: [
-                        { value: 'path', label: 'Local path' },
                         { value: 'git', label: 'Git URL' },
+                        { value: 'path', label: 'Local path' },
                         { value: 'back', label: 'Back' },
                     ],
                 });
@@ -1101,8 +1101,8 @@ async function promptForInteractiveSource(args, source, prompts, io, deps, defau
             const crawlMode = await prompts.select({
                 message: 'Which Notion pages should KTX ingest?',
                 options: [
-                    { value: 'selected_roots', label: 'Specific pages and their subpages (choose them in a picker)' },
                     { value: 'all_accessible', label: 'All pages the integration can access' },
+                    { value: 'selected_roots', label: 'Specific pages and their subpages (choose them in a picker)' },
                     { value: 'back', label: 'Back' },
                 ],
             });
@@ -1667,7 +1667,7 @@ export async function runKtxSetupSourcesStep(args, io, deps = {}) {
                     const addMore = await prompts.select({
                         message: `${readyConnectionIds.length} context source${readyConnectionIds.length > 1 ? 's' : ''} configured (${readyConnectionIds.join(', ')}). Add another?`,
                         options: [
-                            { value: 'done', label: 'Done — continue to context build' },
+                            { value: 'done', label: 'Done adding context sources' },
                             { value: 'edit', label: 'Edit an existing context source' },
                             { value: 'add', label: 'Add another context source' },
                         ],

package/dist/setup.d.ts

@@ -58,12 +58,12 @@ export type KtxSetupArgs = {
     agentScope?: KtxAgentScope;
     skipAgents?: boolean;
     inputMode: 'auto' | 'disabled';
+    debug?: boolean;
     yes: boolean;
     cliVersion: string;
     llmBackend?: KtxSetupLlmBackend;
     anthropicApiKeyEnv?: string;
     anthropicApiKeyFile?: string;
-    llmModel?: string;
     vertexProject?: string;
     vertexLocation?: string;
     skipLlm: boolean;

package/dist/setup.js

@@ -443,7 +443,6 @@ async function runKtxSetupInner(args, io, deps = {}) {
                     ...(args.llmBackend ? { llmBackend: args.llmBackend } : {}),
                     ...(args.anthropicApiKeyEnv ? { anthropicApiKeyEnv: args.anthropicApiKeyEnv } : {}),
                     ...(args.anthropicApiKeyFile ? { anthropicApiKeyFile: args.anthropicApiKeyFile } : {}),
-                    ...(args.llmModel ? { llmModel: args.llmModel } : {}),
                     ...(args.vertexProject ? { vertexProject: args.vertexProject } : {}),
                     ...(args.vertexLocation ? { vertexLocation: args.vertexLocation } : {}),
                     forcePrompt: forcePromptSteps.has('models') || runOnly === 'models',
@@ -473,6 +472,7 @@ async function runKtxSetupInner(args, io, deps = {}) {
                 const databaseResult = await databasesRunner({
                     projectDir: projectResult.projectDir,
                     inputMode: args.inputMode,
+                    ...(args.debug !== undefined ? { debug: args.debug } : {}),
                     yes: args.yes,
                     cliVersion: args.cliVersion,
                     runtimeInstallPolicy: setupRuntimeInstallPolicy(args),

package/dist/sl.d.ts

@@ -1,7 +1,7 @@
 import type { KtxCliIo } from './cli-runtime.js';
 import type { KtxSqlQueryExecutorPort } from './context/connections/query-executor.js';
 import type { KtxSemanticLayerComputePort } from './context/daemon/semantic-layer-compute.js';
-import { loadKtxProject } from './context/project/project.js';
+import { loadKtxProject, type KtxLocalProject } from './context/project/project.js';
 import { searchLocalSlSources as defaultSearchLocalSlSources } from './context/sl/local-sl.js';
 import type { SemanticLayerQueryInput } from './context/sl/types.js';
 import { resolveProjectEmbeddingProvider } from './embedding-resolution.js';
@@ -57,7 +57,7 @@ interface KtxSlDeps {
         io: KtxSlIo;
         projectDir?: string;
     }) => Promise<KtxSemanticLayerComputePort>;
-    createQueryExecutor?: () => KtxSqlQueryExecutorPort;
+    createQueryExecutor?: (project: KtxLocalProject) => KtxSqlQueryExecutorPort;
 }
 export declare function runKtxSl(args: KtxSlArgs, io?: KtxSlIo, deps?: KtxSlDeps): Promise<number>;
 export {};

package/dist/sl.js

@@ -1,13 +1,14 @@
 import { readFile } from 'node:fs/promises';
-import { createDefaultLocalQueryExecutor } from './context/connections/local-query-executor.js';
 import { KtxIngestEmbeddingPortAdapter } from './context/llm/embedding-port.js';
 import { loadKtxProject } from './context/project/project.js';
 import { compileLocalSlQuery } from './context/sl/local-query.js';
 import { listLocalSlSources, resolveLocalSlSource, searchLocalSlSources as defaultSearchLocalSlSources, validateLocalSlSource, } from './context/sl/local-sl.js';
 import { resolveProjectEmbeddingProvider, } from './embedding-resolution.js';
+import { createKtxCliIngestQueryExecutor } from './ingest-query-executor.js';
 import { createManagedPythonSemanticLayerComputePort, } from './managed-python-command.js';
 import { profileMark } from './startup-profile.js';
-import { emitTelemetryEvent } from './telemetry/index.js';
+import { emitTelemetryEvent, reportException } from './telemetry/index.js';
+import { collectTelemetryRedactionSecrets } from './telemetry/redaction-secrets.js';
 import { scrubErrorClass } from './telemetry/scrubber.js';
 profileMark('module:sl');
 function resolutionToEmbeddingPort(resolution) {
@@ -91,8 +92,9 @@ function ambiguousSourceMessage(sourceName, connectionIds) {
 export async function runKtxSl(args, io = process, deps = {}) {
     const startedAt = performance.now();
     let queryForTelemetry;
+    let project;
     try {
-        const project = await (deps.loadProject ?? loadKtxProject)({ projectDir: args.projectDir });
+        project = await (deps.loadProject ?? loadKtxProject)({ projectDir: args.projectDir });
         if (args.command === 'list') {
             const sources = await listLocalSlSources(project, { connectionId: args.connectionId });
             await printSlSources({
@@ -204,7 +206,7 @@ export async function runKtxSl(args, io = process, deps = {}) {
                     io,
                     projectDir: args.projectDir,
                 });
-            const queryExecutor = args.execute ? (deps.createQueryExecutor ?? createDefaultLocalQueryExecutor)() : undefined;
+            const queryExecutor = args.execute ? (deps.createQueryExecutor ?? createKtxCliIngestQueryExecutor)(project) : undefined;
             const result = await compileLocalSlQuery(project, {
                 connectionId: args.connectionId,
                 query,
@@ -237,6 +239,20 @@ export async function runKtxSl(args, io = process, deps = {}) {
         throw new Error(`Unsupported sl command: ${JSON.stringify(_exhaustive)}`);
     }
     catch (error) {
+        await reportException({
+            error,
+            context: { source: `sl ${args.command}`, handled: true, fatal: false },
+            projectDir: args.projectDir,
+            io,
+            redactionSecrets: await collectTelemetryRedactionSecrets({
+                project,
+                projectDir: args.projectDir,
+                connectionId: args.connectionId,
+                includeLlm: args.command === 'query',
+                includeEmbeddings: args.command === 'search' || args.command === 'query',
+                env: process.env,
+            }),
+        });
         if (args.command === 'validate') {
             const errorClass = scrubErrorClass(error);
             await emitTelemetryEvent({

package/dist/sql.js

@@ -4,7 +4,8 @@ import { createKtxCliScanConnector } from './local-scan-connectors.js';
 import { createManagedDaemonSqlAnalysisPort } from './managed-python-http.js';
 import { profileMark } from './startup-profile.js';
 import { isDemoConnection } from './telemetry/demo-detect.js';
-import { emitTelemetryEvent } from './telemetry/index.js';
+import { emitTelemetryEvent, reportException } from './telemetry/index.js';
+import { collectTelemetryRedactionSecrets } from './telemetry/redaction-secrets.js';
 import { scrubErrorClass } from './telemetry/scrubber.js';
 profileMark('module:sql');
 function sqlAnalysisDialectForDriver(driver) {
@@ -96,8 +97,9 @@ export async function runKtxSql(args, io = process, deps = {}) {
     const startedAt = performance.now();
     let driver = 'unknown';
     let demoConnection = false;
+    let project;
     try {
-        const project = await (deps.loadProject ?? loadKtxProject)({ projectDir: args.projectDir });
+        project = await (deps.loadProject ?? loadKtxProject)({ projectDir: args.projectDir });
         const connection = project.config.connections[args.connectionId];
         if (!connection) {
             throw new Error(`Connection "${args.connectionId}" is not configured in ktx.yaml`);
@@ -167,6 +169,20 @@ export async function runKtxSql(args, io = process, deps = {}) {
                 ...(errorClass ? { errorClass } : {}),
             },
         });
+        await reportException({
+            error,
+            context: { source: 'sql run', handled: true, fatal: false },
+            projectDir: args.projectDir,
+            io,
+            redactionSecrets: await collectTelemetryRedactionSecrets({
+                project,
+                projectDir: args.projectDir,
+                connectionId: args.connectionId,
+                includeLlm: false,
+                includeEmbeddings: false,
+                env: process.env,
+            }),
+        });
         io.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
         return 1;
     }

package/dist/star-prompt/cache.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+declare const starCountCacheSchema: z.ZodObject<{
+    count: z.ZodNumber;
+    fetchedAt: z.ZodString;
+}, z.core.$strict>;
+export type StarCountCache = z.infer<typeof starCountCacheSchema>;
+/** @internal */
+export declare function starCountCachePath(homeDir?: string): string;
+export declare function readStarCountCache(options?: {
+    homeDir?: string;
+}): StarCountCache | null;
+export declare function writeStarCountCache(value: StarCountCache, options?: {
+    homeDir?: string;
+}): Promise<void>;
+export declare function isFreshStarCountCache(cache: StarCountCache | null, now: Date, ttlMs: number): boolean;
+export {};

package/dist/star-prompt/cache.js

@@ -0,0 +1,45 @@
+import { readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { z } from 'zod';
+const starCountCacheSchema = z
+    .object({
+    count: z.number().int().nonnegative(),
+    fetchedAt: z.string(),
+})
+    .strict();
+/** @internal */
+export function starCountCachePath(homeDir = homedir()) {
+    return join(homeDir, '.ktx', 'star-count.json');
+}
+export function readStarCountCache(options = {}) {
+    try {
+        return starCountCacheSchema.parse(JSON.parse(readFileSync(starCountCachePath(options.homeDir), 'utf-8')));
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeStarCountCache(value, options = {}) {
+    try {
+        const path = starCountCachePath(options.homeDir);
+        await mkdir(dirname(path), { recursive: true });
+        const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+        writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
+        renameSync(tempPath, path);
+    }
+    catch {
+        return;
+    }
+}
+export function isFreshStarCountCache(cache, now, ttlMs) {
+    if (!cache) {
+        return false;
+    }
+    const fetchedAtMs = Date.parse(cache.fetchedAt);
+    if (Number.isNaN(fetchedAtMs)) {
+        return false;
+    }
+    return now.getTime() - fetchedAtMs < ttlMs;
+}

package/dist/star-prompt/star-count.d.ts

@@ -0,0 +1,7 @@
+import { request as httpsRequest } from 'node:https';
+type HttpsRequest = typeof httpsRequest;
+export declare function fetchGitHubStarCount(options?: {
+    request?: HttpsRequest;
+    timeoutMs?: number;
+}): Promise<number | null>;
+export {};

package/dist/star-prompt/star-count.js

@@ -0,0 +1,66 @@
+import { request as httpsRequest } from 'node:https';
+import { URL } from 'node:url';
+import { z } from 'zod';
+const GITHUB_REPO_URL = new URL('https://api.github.com/repos/Kaelio/ktx');
+const DEFAULT_TIMEOUT_MS = 5000;
+const githubRepoSchema = z.object({
+    stargazers_count: z.number().int().nonnegative(),
+});
+function parseStarCount(raw) {
+    return githubRepoSchema.parse(JSON.parse(raw)).stargazers_count;
+}
+export function fetchGitHubStarCount(options = {}) {
+    const requestImpl = options.request ?? httpsRequest;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (count) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            resolve(count);
+        };
+        try {
+            const request = requestImpl(GITHUB_REPO_URL, {
+                method: 'GET',
+                headers: {
+                    accept: 'application/vnd.github+json',
+                    'user-agent': 'ktx-star-prompt',
+                },
+            }, (response) => {
+                const chunks = [];
+                response.on('data', (chunk) => {
+                    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                });
+                response.on('end', () => {
+                    const statusCode = response.statusCode ?? 0;
+                    if (statusCode < 200 || statusCode >= 300) {
+                        finish(null);
+                        return;
+                    }
+                    try {
+                        finish(parseStarCount(Buffer.concat(chunks).toString('utf8')));
+                    }
+                    catch {
+                        finish(null);
+                    }
+                });
+            });
+            request.on('socket', (socket) => {
+                socket.unref();
+            });
+            request.on('error', () => {
+                finish(null);
+            });
+            request.setTimeout(timeoutMs, () => {
+                request.destroy(new Error('GitHub star count request timed out'));
+                finish(null);
+            });
+            request.end();
+        }
+        catch {
+            finish(null);
+        }
+    });
+}

package/dist/star-prompt/star-line.d.ts

@@ -0,0 +1,12 @@
+interface StarPromptSymbols {
+    star: string;
+    middot: string;
+    rightArrow: string;
+}
+export interface RenderStarPromptLineOptions {
+    columns: number;
+    count?: number | null;
+    symbols?: StarPromptSymbols;
+}
+export declare function renderStarPromptLine(options: RenderStarPromptLineOptions): string;
+export {};

package/dist/star-prompt/star-line.js

@@ -0,0 +1,26 @@
+import { SYMBOLS } from '../io/symbols.js';
+const STAR_PROMPT_URL = 'github.com/Kaelio/ktx';
+const STAR_PROMPT_TEXT = 'This takes a few minutes - mind giving ktx a star while you wait?';
+function usableColumns(columns) {
+    return Number.isFinite(columns) && columns > 0 ? Math.floor(columns) : 80;
+}
+function starCountSegment(count, symbols) {
+    if (typeof count !== 'number' || !Number.isFinite(count)) {
+        return '';
+    }
+    const formatted = new Intl.NumberFormat('en-US').format(count);
+    return ` ${symbols.middot} ${formatted} ${symbols.star}`;
+}
+export function renderStarPromptLine(options) {
+    const symbols = options.symbols ?? SYMBOLS;
+    const columns = usableColumns(options.columns);
+    const base = `  ${symbols.star}  ${STAR_PROMPT_TEXT}  ${STAR_PROMPT_URL}`;
+    const withCount = `${base}${starCountSegment(options.count, symbols)}`;
+    if (withCount.length <= columns) {
+        return withCount;
+    }
+    if (base.length <= columns) {
+        return base;
+    }
+    return `  ${symbols.star} Star ktx ${symbols.rightArrow} ${STAR_PROMPT_URL}`;
+}

package/dist/telemetry/emitter.d.ts

@@ -15,6 +15,16 @@ export declare function trackTelemetryEvent(input: {
     projectApiKey?: string;
     host?: string;
 }): Promise<void>;
+export declare function trackTelemetryException(input: {
+    error: Error;
+    distinctId: string;
+    properties: Record<string, unknown>;
+    env?: TelemetryEmitterEnv;
+    stderr: TelemetrySink;
+    projectApiKey?: string;
+    host?: string;
+    immediate?: boolean;
+}): Promise<void>;
 export declare function shutdownTelemetryEmitter(): Promise<void>;
 /** @internal */
 export declare function __resetTelemetryEmitterForTests(): void;

package/dist/telemetry/emitter.js

@@ -56,6 +56,37 @@ export async function trackTelemetryEvent(input) {
         return;
     }
 }
+function writeDebugExceptionPayload(input) {
+    input.stderr.write(`[telemetry-exception] ${JSON.stringify({
+        distinctId: input.distinctId,
+        message: input.error.message,
+        name: input.error.name,
+        properties: input.properties,
+    })}\n`);
+}
+export async function trackTelemetryException(input) {
+    const env = input.env ?? process.env;
+    if (debugEnabled(env)) {
+        writeDebugExceptionPayload(input);
+        return;
+    }
+    const projectApiKey = telemetryProjectApiKey(input.projectApiKey);
+    const host = telemetryHost(env, input.host);
+    const client = await getPostHogClient(projectApiKey, host);
+    if (!client) {
+        return;
+    }
+    try {
+        if (input.immediate) {
+            await client.captureExceptionImmediate(input.error, input.distinctId, input.properties);
+            return;
+        }
+        client.captureException(input.error, input.distinctId, input.properties);
+    }
+    catch {
+        return;
+    }
+}
 export async function shutdownTelemetryEmitter() {
     const client = await clientPromise;
     if (!client) {

package/dist/telemetry/events.d.ts

@@ -386,6 +386,26 @@ export declare const telemetryEventSchemas: {
         errorClass: z.ZodOptional<z.ZodString>;
         durationMs: z.ZodNumber;
     }, z.core.$strict>;
+    readonly query_history_filter_completed: z.ZodObject<{
+        cliVersion: z.ZodString;
+        nodeVersion: z.ZodString;
+        osPlatform: z.ZodString;
+        osRelease: z.ZodString;
+        arch: z.ZodString;
+        runtime: z.ZodEnum<{
+            node: "node";
+            "daemon-py": "daemon-py";
+        }>;
+        isCi: z.ZodBoolean;
+        dialect: z.ZodString;
+        consideredRoleCount: z.ZodNumber;
+        excludedRoleCount: z.ZodNumber;
+        parseFailedCount: z.ZodNumber;
+        outcome: z.ZodEnum<{
+            ok: "ok";
+            error: "error";
+        }>;
+    }, z.core.$strict>;
 };
 /** @internal */
 export declare const telemetryEventCatalog: readonly [{
@@ -456,6 +476,10 @@ export declare const telemetryEventCatalog: readonly [{
     readonly name: "sql_gen_completed";
     readonly description: "Emitted after daemon SQL generation completes.";
     readonly fields: readonly ["outcome", "dialect", "errorClass", "durationMs"];
+}, {
+    readonly name: "query_history_filter_completed";
+    readonly description: "Emitted after the setup query-history service-account filter picker runs.";
+    readonly fields: readonly ["dialect", "consideredRoleCount", "excludedRoleCount", "parseFailedCount", "outcome"];
 }];
 export type TelemetryEventName = keyof typeof telemetryEventSchemas;
 export type TelemetryCommonEnvelope = z.infer<typeof telemetryCommonEnvelopeSchema>;

package/dist/telemetry/events.js

@@ -185,6 +185,15 @@ const sqlGenCompletedSchema = telemetryCommonEnvelopeSchema
     durationMs: z.number().nonnegative(),
 })
     .strict();
+const queryHistoryFilterCompletedSchema = telemetryCommonEnvelopeSchema
+    .extend({
+    dialect: z.string(),
+    consideredRoleCount: z.number().int().nonnegative(),
+    excludedRoleCount: z.number().int().nonnegative(),
+    parseFailedCount: z.number().int().nonnegative(),
+    outcome: outcomeSchema,
+})
+    .strict();
 /** @internal */
 export const telemetryEventSchemas = {
     install_first_run: installFirstRunSchema,
@@ -204,6 +213,7 @@ export const telemetryEventSchemas = {
     daemon_stopped: daemonStoppedSchema,
     sl_plan_completed: slPlanCompletedSchema,
     sql_gen_completed: sqlGenCompletedSchema,
+    query_history_filter_completed: queryHistoryFilterCompletedSchema,
 };
 /** @internal */
 export const telemetryEventCatalog = [
@@ -338,6 +348,11 @@ export const telemetryEventCatalog = [
         description: 'Emitted after daemon SQL generation completes.',
         fields: ['outcome', 'dialect', 'errorClass', 'durationMs'],
     },
+    {
+        name: 'query_history_filter_completed',
+        description: 'Emitted after the setup query-history service-account filter picker runs.',
+        fields: ['dialect', 'consideredRoleCount', 'excludedRoleCount', 'parseFailedCount', 'outcome'],
+    },
 ];
 export function buildCommonEnvelope(input) {
     return {

package/dist/telemetry/exception.d.ts

@@ -0,0 +1,18 @@
+import { type KtxCliIo, type KtxCliPackageInfo } from '../cli-runtime.js';
+export interface ExceptionContext {
+    source: string;
+    handled: boolean;
+    fatal: boolean;
+    extra?: Record<string, string | number | boolean>;
+}
+export declare function reportException(input: {
+    error: unknown;
+    context: ExceptionContext;
+    io: KtxCliIo;
+    packageInfo?: KtxCliPackageInfo;
+    projectDir?: string;
+    immediate?: boolean;
+    redactionSecrets?: ReadonlyArray<string>;
+}): Promise<void>;
+/** @internal */
+export declare function __resetTelemetryExceptionStateForTests(): void;