@kaelio/ktx 0.1.0-rc.5 → 0.1.0

package/dist/sql.js

@@ -0,0 +1,125 @@
+import { loadKtxProject } from '@ktx/context/project';
+import { createKtxCliScanConnector } from './local-scan-connectors.js';
+import { createManagedDaemonSqlAnalysisPort } from './managed-python-http.js';
+import { profileMark } from './startup-profile.js';
+profileMark('module:sql');
+function sqlAnalysisDialectForDriver(driver) {
+    const normalized = String(driver ?? '').trim().toLowerCase();
+    const map = {
+        postgres: 'postgres',
+        postgresql: 'postgres',
+        bigquery: 'bigquery',
+        snowflake: 'snowflake',
+        mysql: 'mysql',
+        sqlserver: 'tsql',
+        mssql: 'tsql',
+        sqlite: 'sqlite',
+        sqlite3: 'sqlite',
+        clickhouse: 'clickhouse',
+        redshift: 'redshift',
+    };
+    return map[normalized] ?? 'postgres';
+}
+function resolveOutputMode(args) {
+    if (args.json === true)
+        return 'json';
+    return args.output ?? 'pretty';
+}
+function formatValue(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint')
+        return String(value);
+    return JSON.stringify(value);
+}
+function printJson(output, io) {
+    io.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+}
+function printPlain(output, io) {
+    io.stdout.write(`${output.headers.join('\t')}\n`);
+    for (const row of output.rows) {
+        io.stdout.write(`${row.map(formatValue).join('\t')}\n`);
+    }
+}
+function printPretty(output, io) {
+    const rows = output.rows.map((row) => row.map(formatValue));
+    const widths = output.headers.map((header, index) => Math.max(header.length, ...rows.map((row) => row[index]?.length ?? 0)));
+    const renderRow = (cells) => cells.map((cell, index) => cell.padEnd(widths[index] ?? cell.length)).join('  ').trimEnd();
+    if (output.headers.length > 0) {
+        io.stdout.write(`${renderRow(output.headers)}\n`);
+        io.stdout.write(`${renderRow(widths.map((width) => '-'.repeat(width)))}\n`);
+    }
+    for (const row of rows) {
+        io.stdout.write(`${renderRow(row)}\n`);
+    }
+    io.stdout.write(`\n${output.rowCount} ${output.rowCount === 1 ? 'row' : 'rows'}\n`);
+}
+function printSqlResult(output, mode, io) {
+    if (mode === 'json') {
+        printJson(output, io);
+        return;
+    }
+    if (mode === 'plain') {
+        printPlain(output, io);
+        return;
+    }
+    printPretty(output, io);
+}
+async function cleanupConnector(connector) {
+    if (connector?.cleanup) {
+        await connector.cleanup();
+    }
+}
+function resultOutput(connectionId, result) {
+    return {
+        connectionId,
+        headers: result.headers,
+        ...(result.headerTypes ? { headerTypes: result.headerTypes } : {}),
+        rows: result.rows,
+        rowCount: result.rowCount ?? result.rows.length,
+    };
+}
+export async function runKtxSql(args, io = process, deps = {}) {
+    try {
+        const 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`);
+        }
+        const sqlAnalysis = deps.createSqlAnalysis ??
+            (() => createManagedDaemonSqlAnalysisPort({
+                cliVersion: args.cliVersion,
+                projectDir: args.projectDir,
+                installPolicy: 'auto',
+                io,
+            }));
+        const validation = await sqlAnalysis().validateReadOnly(args.sql, sqlAnalysisDialectForDriver(connection.driver));
+        if (!validation.ok) {
+            throw new Error(validation.error ?? 'SQL is not read-only.');
+        }
+        const createScanConnector = deps.createScanConnector ?? createKtxCliScanConnector;
+        let connector = null;
+        try {
+            connector = await createScanConnector(project, args.connectionId);
+            if (!connector.capabilities.readOnlySql || !connector.executeReadOnly) {
+                throw new Error(`Connection "${args.connectionId}" does not support read-only SQL execution.`);
+            }
+            const result = await connector.executeReadOnly({
+                connectionId: args.connectionId,
+                sql: args.sql,
+                maxRows: args.maxRows,
+            }, { runId: 'cli-sql' });
+            printSqlResult(resultOutput(args.connectionId, result), resolveOutputMode(args), io);
+            return 0;
+        }
+        finally {
+            await cleanupConnector(connector);
+        }
+    }
+    catch (error) {
+        io.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        return 1;
+    }
+}

package/dist/sql.test.d.ts

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

package/dist/sql.test.js

@@ -0,0 +1,226 @@
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { initKtxProject, parseKtxProjectConfig, serializeKtxProjectConfig } from '@ktx/context/project';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { runKtxSql } from './sql.js';
+function makeIo() {
+    let stdout = '';
+    let stderr = '';
+    return {
+        io: {
+            stdout: {
+                write: (chunk) => {
+                    stdout += chunk;
+                },
+            },
+            stderr: {
+                write: (chunk) => {
+                    stderr += chunk;
+                },
+            },
+        },
+        stdout: () => stdout,
+        stderr: () => stderr,
+    };
+}
+function makeSqlAnalysis(result) {
+    return {
+        analyzeForFingerprint: vi.fn(),
+        analyzeBatch: vi.fn(),
+        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 () => {
+        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('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/node_modules/@ktx/connector-clickhouse/dist/package-exports.test.js

@@ -6,5 +6,5 @@ describe('@ktx/connector-clickhouse package exports', () => {
         expect(connector.KtxClickHouseScanConnector).toBeTypeOf('function');
         expect(connector.clickHouseClientConfigFromConfig).toBeTypeOf('function');
         expect(connector.createClickHouseLiveDatabaseIntrospection).toBeTypeOf('function');
-    });
+    }, 20_000);
 });

package/node_modules/@ktx/context/dist/connections/connection-type.d.ts

@@ -1,12 +1,12 @@
 import { z } from 'zod';
 export declare const connectionTypeSchema: z.ZodEnum<{
-    SNOWFLAKE: "SNOWFLAKE";
+    POSTGRESQL: "POSTGRESQL";
     BIGQUERY: "BIGQUERY";
+    SNOWFLAKE: "SNOWFLAKE";
     MYSQL: "MYSQL";
-    CLICKHOUSE: "CLICKHOUSE";
-    POSTGRESQL: "POSTGRESQL";
-    SQLITE: "SQLITE";
     SQLSERVER: "SQLSERVER";
+    SQLITE: "SQLITE";
+    CLICKHOUSE: "CLICKHOUSE";
     CENTRALREACH: "CENTRALREACH";
     EPIC: "EPIC";
     CERNER: "CERNER";

package/node_modules/@ktx/context/dist/core/git.service.d.ts

@@ -153,6 +153,9 @@ export declare class GitService {
      * unmerged paths in the index.
      */
     assertWorktreeClean(): Promise<void>;
+    writeBinaryNoRenamePatch(from: string, to: string, patchPath: string): Promise<void>;
+    applyPatchFile3WayIndex(patchPath: string): Promise<void>;
+    commitStaged(commitMessage: string, author: string, authorEmail: string): Promise<GitCommitInfo>;
     private fileExists;
     /**
      * Create a new worktree at `path` with a new branch `branch` pointing at `startSha`.

package/node_modules/@ktx/context/dist/core/git.service.js

@@ -1,5 +1,5 @@
 import { promises as fs } from 'node:fs';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { noopLogger, resolveConfigDir } from './config.js';
 import { createSimpleGit } from './git-env.js';
 function mergeErrorMessage(error) {
@@ -596,6 +596,52 @@ export class GitService {
             throw new Error(`Worktree has ${unmerged.length} unmerged path(s): ${unmerged.slice(0, 5).join(', ')}; refusing to proceed`);
         }
     }
+    async writeBinaryNoRenamePatch(from, to, patchPath) {
+        await this.withMutationQueue(async () => {
+            const patch = await this.git.raw(['diff', '--binary', '--no-renames', `${from}..${to}`]);
+            await fs.mkdir(dirname(patchPath), { recursive: true });
+            await fs.writeFile(patchPath, patch, 'utf-8');
+        });
+    }
+    async applyPatchFile3WayIndex(patchPath) {
+        await this.withMutationQueue(async () => {
+            await this.git.raw(['apply', '--3way', '--index', patchPath]);
+        });
+    }
+    async commitStaged(commitMessage, author, authorEmail) {
+        return this.withMutationQueue(async () => {
+            const stagedChanges = await this.git.diff(['--cached', '--name-only']);
+            if (!stagedChanges.trim()) {
+                const head = (await this.git.revparse(['HEAD'])).trim();
+                const log = await this.git.log({ maxCount: 1 });
+                const latest = log.latest;
+                return {
+                    commitHash: head,
+                    shortHash: head.substring(0, 8),
+                    message: latest?.message ?? '',
+                    author: latest?.author_name ?? '',
+                    authorEmail: latest?.author_email ?? '',
+                    timestamp: latest?.date ?? new Date(0).toISOString(),
+                    committedDate: latest?.date ? new Date(latest.date).toISOString() : new Date(0).toISOString(),
+                    created: false,
+                };
+            }
+            await this.git.commit(commitMessage, { '--author': `${author} <${authorEmail}>` });
+            const head = (await this.git.revparse(['HEAD'])).trim();
+            const log = await this.git.log({ maxCount: 1 });
+            const latest = log.latest;
+            return {
+                commitHash: head,
+                shortHash: head.substring(0, 8),
+                message: latest?.message ?? commitMessage,
+                author: latest?.author_name ?? author,
+                authorEmail: latest?.author_email ?? authorEmail,
+                timestamp: latest?.date ?? new Date().toISOString(),
+                committedDate: latest?.date ? new Date(latest.date).toISOString() : new Date().toISOString(),
+                created: true,
+            };
+        });
+    }
     async fileExists(path) {
         try {
             await fs.access(path);

package/node_modules/@ktx/context/dist/core/git.service.patch.test.d.ts

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

package/node_modules/@ktx/context/dist/core/git.service.patch.test.js

@@ -0,0 +1,40 @@
+import { mkdir, mkdtemp, readFile, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { GitService } from './git.service.js';
+async function makeGit() {
+    const homeDir = await mkdtemp(join(tmpdir(), 'ktx-git-patch-'));
+    const configDir = join(homeDir, 'config');
+    const git = new GitService({
+        storage: { configDir, homeDir },
+        git: {
+            userName: 'System User',
+            userEmail: 'system@example.com',
+            bootstrapMessage: 'init',
+            bootstrapAuthor: 'system',
+            bootstrapAuthorEmail: 'system@example.com',
+        },
+    });
+    await git.onModuleInit();
+    return { homeDir, configDir, git };
+}
+describe('GitService patch helpers', () => {
+    it('collects binary-safe no-rename patches and applies them with --3way --index', async () => {
+        const { homeDir, configDir, git } = await makeGit();
+        await mkdir(join(configDir, 'wiki/global'), { recursive: true });
+        await writeFile(join(configDir, 'wiki/global/page.md'), 'old\n');
+        await git.commitFiles(['wiki/global/page.md'], 'add page', 'System User', 'system@example.com');
+        const base = await git.revParseHead();
+        await writeFile(join(configDir, 'wiki/global/page.md'), 'new\n');
+        await git.commitFiles(['wiki/global/page.md'], 'edit page', 'System User', 'system@example.com');
+        const patchPath = join(homeDir, 'proposal.patch');
+        await git.writeBinaryNoRenamePatch(base, 'HEAD', patchPath);
+        const targetDir = join(homeDir, 'target');
+        await git.addWorktree(targetDir, 'target', base);
+        const targetGit = git.forWorktree(targetDir);
+        await targetGit.applyPatchFile3WayIndex(patchPath);
+        await targetGit.commitStaged('apply proposal', 'System User', 'system@example.com');
+        await expect(readFile(join(targetDir, 'wiki/global/page.md'), 'utf-8')).resolves.toBe('new\n');
+    });
+});

package/node_modules/@ktx/context/dist/ingest/adapters/historic-sql/types.d.ts

@@ -3,8 +3,8 @@ import type { SqlAnalysisPort } from '../../../sql-analysis/index.js';
 export declare const HISTORIC_SQL_SOURCE_KEY: "historic-sql";
 declare const historicSqlDialectSchema: z.ZodEnum<{
     postgres: "postgres";
-    snowflake: "snowflake";
     bigquery: "bigquery";
+    snowflake: "snowflake";
 }>;
 export type HistoricSqlDialect = z.infer<typeof historicSqlDialectSchema>;
 export declare const historicSqlUnifiedPullConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -35,8 +35,8 @@ export declare const historicSqlUnifiedPullConfigSchema: z.ZodDiscriminatedUnion
     redactionPatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
     staleArchiveAfterDays: z.ZodDefault<z.ZodNumber>;
     dialect: z.ZodEnum<{
-        snowflake: "snowflake";
         bigquery: "bigquery";
+        snowflake: "snowflake";
     }>;
     windowDays: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>, z.ZodObject<{
@@ -74,8 +74,8 @@ export declare const aggregatedTemplateSchema: z.ZodObject<{
     canonicalSql: z.ZodString;
     dialect: z.ZodEnum<{
         postgres: "postgres";
-        snowflake: "snowflake";
         bigquery: "bigquery";
+        snowflake: "snowflake";
     }>;
     stats: z.ZodObject<{
         executions: z.ZodNumber;
@@ -126,8 +126,8 @@ export declare const stagedPatternsInputSchema: z.ZodObject<{
         distinctUsersBucket: z.ZodString;
         dialect: z.ZodEnum<{
             postgres: "postgres";
-            snowflake: "snowflake";
             bigquery: "bigquery";
+            snowflake: "snowflake";
         }>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
@@ -137,8 +137,8 @@ export declare const stagedManifestSchema: z.ZodObject<{
     connectionId: z.ZodString;
     dialect: z.ZodEnum<{
         postgres: "postgres";
-        snowflake: "snowflake";
         bigquery: "bigquery";
+        snowflake: "snowflake";
     }>;
     fetchedAt: z.ZodISODateTime;
     windowStart: z.ZodISODateTime;

package/node_modules/@ktx/context/dist/ingest/adapters/looker/looker.adapter.d.ts

@@ -34,7 +34,7 @@ export declare class LookerSourceAdapter implements SourceAdapter {
             statusCode: number | null;
             message: string;
             retryRecommended: boolean;
-            kind?: "lookml_connection_mismatch" | "unmapped_looker_connection" | "unparseable_sql_table_name" | "looker_template_unresolved" | "derived_table_not_supported" | undefined;
+            kind?: "lookml_connection_mismatch" | "looker_template_unresolved" | "derived_table_not_supported" | "unmapped_looker_connection" | "unparseable_sql_table_name" | undefined;
             details?: Record<string, unknown> | undefined;
         }[];
         warnings: {
@@ -45,7 +45,7 @@ export declare class LookerSourceAdapter implements SourceAdapter {
             statusCode: number | null;
             message: string;
             retryRecommended: boolean;
-            kind?: "lookml_connection_mismatch" | "unmapped_looker_connection" | "unparseable_sql_table_name" | "looker_template_unresolved" | "derived_table_not_supported" | undefined;
+            kind?: "lookml_connection_mismatch" | "looker_template_unresolved" | "derived_table_not_supported" | "unmapped_looker_connection" | "unparseable_sql_table_name" | undefined;
             details?: Record<string, unknown> | undefined;
         }[];
     } | null>;

package/node_modules/@ktx/context/dist/ingest/adapters/looker/tools/looker-query-to-sl.tool.d.ts

@@ -21,9 +21,9 @@ export declare const lookerQueryToSlInputSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             ok: z.ZodLiteral<false>;
             reason: z.ZodEnum<{
+                no_connection_mapping: "no_connection_mapping";
                 looker_template_unresolved: "looker_template_unresolved";
                 derived_table_not_supported: "derived_table_not_supported";
-                no_connection_mapping: "no_connection_mapping";
                 no_physical_table: "no_physical_table";
                 multiple_table_references: "multiple_table_references";
                 unsupported_dialect: "unsupported_dialect";
@@ -89,7 +89,7 @@ export declare function createLookerQueryToSlTool(): import("ai").Tool<{
             canonicalTable: string;
         } | {
             ok: false;
-            reason: "looker_template_unresolved" | "derived_table_not_supported" | "no_connection_mapping" | "no_physical_table" | "multiple_table_references" | "unsupported_dialect" | "parse_error";
+            reason: "no_connection_mapping" | "looker_template_unresolved" | "derived_table_not_supported" | "no_physical_table" | "multiple_table_references" | "unsupported_dialect" | "parse_error";
             detail?: string | undefined;
         } | null;
         id?: string | undefined;