@kaelio/ktx 0.8.0 → 0.10.0

package/dist/update-check/update-check.js

@@ -0,0 +1,116 @@
+import { cyan, dim } from '../clack.js';
+import { resolveOutputMode } from '../io/mode.js';
+import { readUpdateCheckCache, writeUpdateCheckCache } from './cache.js';
+import { decideUpdate, inferUpdateChannel } from './channel.js';
+import { fetchDistTags as defaultFetchDistTags } from './registry.js';
+const DAY_MS = 24 * 60 * 60 * 1000;
+function truthy(value) {
+    return value !== undefined && value !== '' && value !== '0' && value !== 'false';
+}
+function commandRequestsJson(options) {
+    return options?.json === true || options?.output === 'json' || options?.format === 'json';
+}
+/** @internal */
+export function shouldSuppressUpdateCheck(args) {
+    const env = args.env ?? process.env;
+    if (truthy(env.KTX_NO_UPDATE_CHECK) || truthy(env.NO_UPDATE_NOTIFIER) || truthy(env.DO_NOT_TRACK)) {
+        return true;
+    }
+    if (commandRequestsJson(args.commandOptions) || truthy(env.CI) || args.io.stdout.isTTY !== true) {
+        return true;
+    }
+    try {
+        const mode = resolveOutputMode({
+            json: false,
+            io: args.io,
+            env,
+        });
+        return mode !== 'pretty';
+    }
+    catch {
+        return true;
+    }
+}
+/** @internal */
+export function renderUpdateNotice(args) {
+    const command = args.channel === 'next' ? 'npm i -g @kaelio/ktx@next' : 'npm i -g @kaelio/ktx';
+    return `${cyan('↑', args.env)} Update available: ktx ${args.installedVersion} → ${args.targetVersion}\n  ${dim(command, args.env)}\n`;
+}
+function timestampMs(value) {
+    if (!value) {
+        return null;
+    }
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? null : parsed;
+}
+function elapsedAtLeast(value, now, intervalMs) {
+    const previous = timestampMs(value);
+    if (previous === null) {
+        return true;
+    }
+    return now.getTime() - previous >= intervalMs;
+}
+function shouldRefreshCache(cache, installedVersion, now) {
+    if (!cache || cache.installedVersion !== installedVersion) {
+        return true;
+    }
+    return elapsedAtLeast(cache.checkedAt, now, DAY_MS);
+}
+async function refreshUpdateCache(args) {
+    const distTags = await args.fetchDistTags();
+    const decision = decideUpdate(args.installedVersion, distTags);
+    if (decision.status === 'skip') {
+        return;
+    }
+    await writeUpdateCheckCache({
+        checkedAt: args.now.toISOString(),
+        channel: decision.channel,
+        installedVersion: args.installedVersion,
+        latestForChannel: decision.target,
+        ...(args.cache?.installedVersion === args.installedVersion && args.cache.channel === decision.channel
+            ? { lastNoticeAt: args.cache.lastNoticeAt }
+            : {}),
+    }, { homeDir: args.homeDir });
+}
+export async function prepareUpdateCheckNotice(options) {
+    const env = options.env ?? process.env;
+    const now = (options.now ?? (() => new Date()))();
+    const fetchDistTags = options.fetchDistTags ?? defaultFetchDistTags;
+    if (shouldSuppressUpdateCheck({
+        commandOptions: options.commandOptions,
+        env,
+        io: options.io,
+    })) {
+        return { notice: null };
+    }
+    if (!inferUpdateChannel(options.installedVersion)) {
+        return { notice: null };
+    }
+    let cache = await readUpdateCheckCache({ homeDir: options.homeDir });
+    let notice = null;
+    if (cache?.installedVersion === options.installedVersion) {
+        const decision = decideUpdate(options.installedVersion, {
+            [cache.channel]: cache.latestForChannel,
+        });
+        if (decision.status === 'available' && elapsedAtLeast(cache.lastNoticeAt, now, DAY_MS)) {
+            notice = renderUpdateNotice({
+                channel: decision.channel,
+                env,
+                installedVersion: options.installedVersion,
+                targetVersion: decision.target,
+            });
+            cache = { ...cache, lastNoticeAt: now.toISOString() };
+            await writeUpdateCheckCache(cache, { homeDir: options.homeDir });
+        }
+    }
+    if (shouldRefreshCache(cache, options.installedVersion, now)) {
+        void refreshUpdateCache({
+            cache,
+            fetchDistTags,
+            homeDir: options.homeDir,
+            installedVersion: options.installedVersion,
+            now,
+        }).catch(() => { });
+    }
+    return { notice };
+}

package/package.json

@@ -1,7 +1,11 @@
 {
   "name": "@kaelio/ktx",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Standalone ktx context layer for data agents",
+  "author": {
+    "name": "Kaelio",
+    "url": "https://www.kaelio.com"
+  },
   "type": "module",
   "engines": {
     "node": ">=22.0.0"
@@ -32,6 +36,7 @@
     "@ai-sdk/devtools": "0.0.18",
     "@ai-sdk/google-vertex": "^4.0.134",
     "@anthropic-ai/claude-agent-sdk": "0.3.146",
+    "@clack/core": "1.3.1",
     "@clack/prompts": "1.4.0",
     "@clickhouse/client": "^1.18.5",
     "@commander-js/extra-typings": "14.0.0",
@@ -41,6 +46,7 @@
     "@looker/sdk-rtl": "^21.6.5",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@notionhq/client": "^5.22.0",
+    "@openai/codex-sdk": "^0.133.0",
     "ai": "^6.0.188",
     "better-sqlite3": "^12.10.0",
     "commander": "14.0.3",
@@ -56,6 +62,7 @@
     "pg": "^8.21.0",
     "posthog-node": "^5.34.9",
     "react": "^19.2.6",
+    "semver": "^7.8.1",
     "simple-git": "3.36.0",
     "snowflake-sdk": "^2.4.2",
     "yaml": "^2.9.0",
@@ -69,6 +76,7 @@
     "@types/node": "^25.9.1",
     "@types/pg": "^8.20.0",
     "@types/react": "^19.2.15",
+    "@types/semver": "^7.7.1",
     "@vitest/coverage-v8": "^4.1.7",
     "ajv": "8.20.0",
     "ink-testing-library": "^4.0.0",
@@ -78,13 +86,13 @@
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "https://github.com/Kaelio/ktx-ai-data-agents-context",
+    "url": "https://github.com/Kaelio/ktx",
     "directory": "packages/cli"
   },
   "bugs": {
-    "url": "https://github.com/Kaelio/ktx-ai-data-agents-context/issues"
+    "url": "https://github.com/Kaelio/ktx/issues"
   },
-  "homepage": "https://github.com/Kaelio/ktx-ai-data-agents-context#readme",
+  "homepage": "https://github.com/Kaelio/ktx#readme",
   "scripts": {
     "assets:demo": "node scripts/build-demo-assets.mjs",
     "build": "tsc -p tsconfig.json && node dist/telemetry/schema-writer.js src/telemetry/events.schema.json ../../python/ktx-daemon/src/ktx_daemon/telemetry/events.schema.json && node scripts/copy-runtime-assets.mjs && node ../../scripts/prepare-cli-bin.mjs",

package/dist/context/connections/local-query-executor.d.ts

@@ -1,6 +0,0 @@
-import type { KtxSqlQueryExecutorPort } from './query-executor.js';
-export interface DefaultLocalQueryExecutorOptions {
-    postgres?: KtxSqlQueryExecutorPort;
-    sqlite?: KtxSqlQueryExecutorPort;
-}
-export declare function createDefaultLocalQueryExecutor(options?: DefaultLocalQueryExecutorOptions): KtxSqlQueryExecutorPort;

package/dist/context/connections/local-query-executor.js

@@ -1,39 +0,0 @@
-import { driverRegistrations, getDriverRegistration } from './drivers.js';
-import { createPostgresQueryExecutor } from './postgres-query-executor.js';
-import { createSqliteQueryExecutor } from './sqlite-query-executor.js';
-function driverFor(input) {
-    return String(input.connection?.driver ?? '').toLowerCase();
-}
-function localExecutorMap(options) {
-    const wiredExecutors = {
-        postgres: options.postgres ?? createPostgresQueryExecutor(),
-        sqlite: options.sqlite ?? createSqliteQueryExecutor(),
-    };
-    const executors = {};
-    for (const registration of Object.values(driverRegistrations)) {
-        if (!registration.hasLocalQueryExecutor)
-            continue;
-        const executor = wiredExecutors[registration.driver];
-        if (executor) {
-            executors[registration.driver] = executor;
-        }
-    }
-    return executors;
-}
-export function createDefaultLocalQueryExecutor(options = {}) {
-    const executors = localExecutorMap(options);
-    return {
-        async execute(input) {
-            const driver = driverFor(input);
-            const registration = getDriverRegistration(driver);
-            if (!registration?.hasLocalQueryExecutor) {
-                throw new Error(`No local query executor is configured for driver "${input.connection?.driver ?? 'unknown'}".`);
-            }
-            const executor = executors[registration.driver];
-            if (!executor) {
-                throw new Error(`Local query executor flag is enabled for driver "${registration.driver}", but no executor factory is wired.`);
-            }
-            return executor.execute(input);
-        },
-    };
-}

package/dist/context/connections/postgres-query-executor.d.ts

@@ -1,25 +0,0 @@
-import { type ClientConfig } from 'pg';
-import type { KtxSqlQueryExecutorPort } from './query-executor.js';
-interface PgClientLike {
-    connect(): Promise<unknown>;
-    query(input: string | {
-        text: string;
-        rowMode: 'array';
-    }): Promise<{
-        fields: Array<{
-            name: string;
-        }>;
-        rows: unknown[][];
-        command: string;
-        rowCount: number | null;
-    }>;
-    end(): Promise<void>;
-}
-interface PostgresQueryExecutorOptions {
-    statementTimeoutMs?: number;
-    queryTimeoutMs?: number;
-    connectionTimeoutMs?: number;
-    clientFactory?: (config: ClientConfig) => PgClientLike;
-}
-export declare function createPostgresQueryExecutor(options?: PostgresQueryExecutorOptions): KtxSqlQueryExecutorPort;
-export {};

package/dist/context/connections/postgres-query-executor.js

@@ -1,53 +0,0 @@
-import { Client } from 'pg';
-import { limitSqlForExecution } from './read-only-sql.js';
-function connectionDriver(input) {
-    return String(input.connection?.driver ?? '').toLowerCase();
-}
-function createDefaultClient(config) {
-    return new Client(config);
-}
-export function createPostgresQueryExecutor(options = {}) {
-    const clientFactory = options.clientFactory ?? createDefaultClient;
-    return {
-        async execute(input) {
-            const driver = connectionDriver(input);
-            const connection = input.connection;
-            if (driver !== 'postgres') {
-                throw new Error(`Local Postgres execution cannot run driver "${connection?.driver ?? 'unknown'}".`);
-            }
-            if (typeof connection?.url !== 'string' || connection.url.trim().length === 0) {
-                throw new Error(`Local Postgres execution requires connections.${input.connectionId}.url.`);
-            }
-            const client = clientFactory({
-                connectionString: connection.url,
-                statement_timeout: options.statementTimeoutMs ?? 30_000,
-                query_timeout: options.queryTimeoutMs ?? 35_000,
-                connectionTimeoutMillis: options.connectionTimeoutMs ?? 5_000,
-                application_name: 'ktx-local-query',
-            });
-            await client.connect();
-            try {
-                await client.query('BEGIN READ ONLY');
-                const result = await client.query({
-                    text: limitSqlForExecution(input.sql, input.maxRows),
-                    rowMode: 'array',
-                });
-                await client.query('COMMIT');
-                return {
-                    headers: result.fields.map((field) => field.name),
-                    rows: result.rows,
-                    totalRows: result.rows.length,
-                    command: result.command,
-                    rowCount: result.rowCount,
-                };
-            }
-            catch (error) {
-                await client.query('ROLLBACK').catch(() => undefined);
-                throw error;
-            }
-            finally {
-                await client.end();
-            }
-        },
-    };
-}

package/dist/context/connections/sqlite-query-executor.d.ts

@@ -1,4 +0,0 @@
-import type { KtxSqlQueryExecutionInput, KtxSqlQueryExecutorPort } from './query-executor.js';
-/** @internal */
-export declare function sqliteDatabasePathFromConnection(input: KtxSqlQueryExecutionInput): string;
-export declare function createSqliteQueryExecutor(): KtxSqlQueryExecutorPort;

package/dist/context/connections/sqlite-query-executor.js

@@ -1,74 +0,0 @@
-import { isAbsolute, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import Database from 'better-sqlite3';
-import { readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { normalizeQueryRows } from './query-executor.js';
-import { limitSqlForExecution } from './read-only-sql.js';
-function connectionDriver(input) {
-    return String(input.connection?.driver ?? '').toLowerCase();
-}
-function stringConfigValue(connection, key) {
-    const value = connection?.[key];
-    return typeof value === 'string' && value.trim().length > 0 ? resolveStringReference(key, value.trim()) : undefined;
-}
-function resolveStringReference(key, value) {
-    if (value.startsWith('env:')) {
-        return process.env[value.slice('env:'.length)] ?? '';
-    }
-    if (key !== 'url' && value.startsWith('file:')) {
-        const rawPath = value.slice('file:'.length);
-        const path = rawPath.startsWith('~') ? resolve(homedir(), rawPath.slice(1)) : rawPath;
-        return readFileSync(path, 'utf-8').trim();
-    }
-    return value;
-}
-function sqlitePathFromUrl(url) {
-    if (url.startsWith('file:')) {
-        return fileURLToPath(url);
-    }
-    if (url.startsWith('sqlite:')) {
-        const parsed = new URL(url);
-        if (parsed.pathname.length > 0) {
-            return decodeURIComponent(parsed.pathname);
-        }
-    }
-    return url;
-}
-/** @internal */
-export function sqliteDatabasePathFromConnection(input) {
-    const driver = connectionDriver(input);
-    if (driver !== 'sqlite') {
-        throw new Error(`Local SQLite execution cannot run driver "${input.connection?.driver ?? 'unknown'}".`);
-    }
-    const pathValue = stringConfigValue(input.connection, 'path');
-    const urlValue = stringConfigValue(input.connection, 'url');
-    if (!pathValue && !urlValue) {
-        throw new Error(`Local SQLite execution requires connections.${input.connectionId}.path or connections.${input.connectionId}.url.`);
-    }
-    const candidate = pathValue ?? sqlitePathFromUrl(urlValue);
-    return isAbsolute(candidate) ? candidate : resolve(input.projectDir ?? process.cwd(), candidate);
-}
-export function createSqliteQueryExecutor() {
-    return {
-        async execute(input) {
-            const sql = limitSqlForExecution(input.sql, input.maxRows);
-            const dbPath = sqliteDatabasePathFromConnection(input);
-            const db = new Database(dbPath, { readonly: true, fileMustExist: true });
-            try {
-                const statement = db.prepare(sql);
-                const rows = statement.all();
-                return {
-                    headers: statement.columns().map((column) => column.name),
-                    rows: normalizeQueryRows(rows),
-                    totalRows: rows.length,
-                    command: 'SELECT',
-                    rowCount: rows.length,
-                };
-            }
-            finally {
-                db.close();
-            }
-        },
-    };
-}