@kaelio/ktx 0.14.0 → 0.16.0

package/dist/context/core/config-reference.js

@@ -1,6 +1,7 @@
 import { readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { resolve } from 'node:path';
+import { KtxExpectedError } from '../../errors.js';
 /** @internal */
 export function resolveKtxHomePath(path) {
     if (path === '~') {
@@ -22,7 +23,16 @@ export function resolveKtxConfigReference(value, env) {
     }
     if (value.startsWith('file:')) {
         const filePath = resolveKtxHomePath(value.slice('file:'.length).trim());
-        const fileValue = readFileSync(filePath, 'utf8').trim();
+        let fileValue;
+        try {
+            fileValue = readFileSync(filePath, 'utf8').trim();
+        }
+        catch (error) {
+            // A `file:` secret whose target is missing or unreadable is a config
+            // problem (secrets/ is gitignored, so absent after a clone), not a ktx
+            // fault — classify it so it stays out of Error Tracking.
+            throw new KtxExpectedError(`Could not read the secret file referenced in ktx.yaml: ${filePath}`, { cause: error });
+        }
         return fileValue.length > 0 ? fileValue : undefined;
     }
     const trimmed = value.trim();

package/dist/context/daemon/semantic-layer-compute.d.ts

@@ -1,4 +1,20 @@
 import type { ResolvedSemanticLayerSource, SemanticLayerQueryInput } from '../sl/types.js';
+/**
+ * A ktx-daemon compute call failed. `inputRejected` is true when the daemon
+ * refused the request as invalid (a caller-driven outcome) rather than faulting;
+ * callers can promote those to an expected KtxQueryError while letting genuine
+ * daemon crashes reach Error Tracking. `detail` is the daemon's own message,
+ * unwrapped for surfacing to the caller.
+ */
+export declare class KtxDaemonComputeError extends Error {
+    readonly inputRejected: boolean;
+    readonly detail: string;
+    constructor(message: string, options: {
+        inputRejected: boolean;
+        detail: string;
+        cause?: unknown;
+    });
+}
 interface KtxSemanticLayerComputeQueryResult {
     sql: string;
     dialect: string;

package/dist/context/daemon/semantic-layer-compute.js

@@ -2,6 +2,41 @@ import { request as httpRequest } from 'node:http';
 import { request as httpsRequest } from 'node:https';
 import { URL } from 'node:url';
 import { spawn } from 'node:child_process';
+// The daemon signals "the caller sent a well-formed request I refused as
+// invalid" with a distinct subprocess exit code (INPUT_REJECTED_EXIT_CODE in
+// python/ktx-daemon/__main__.py) or HTTP 400. Kept in sync across the boundary.
+const DAEMON_INPUT_REJECTED_EXIT_CODE = 3;
+const DAEMON_INPUT_REJECTED_HTTP_STATUS = 400;
+/**
+ * A ktx-daemon compute call failed. `inputRejected` is true when the daemon
+ * refused the request as invalid (a caller-driven outcome) rather than faulting;
+ * callers can promote those to an expected KtxQueryError while letting genuine
+ * daemon crashes reach Error Tracking. `detail` is the daemon's own message,
+ * unwrapped for surfacing to the caller.
+ */
+export class KtxDaemonComputeError extends Error {
+    inputRejected;
+    detail;
+    constructor(message, options) {
+        super(message, options.cause !== undefined ? { cause: options.cause } : undefined);
+        this.name = 'KtxDaemonComputeError';
+        this.inputRejected = options.inputRejected;
+        this.detail = options.detail;
+    }
+}
+/** The daemon reports HTTP failures as `{ "detail": "…" }`; fall back to the raw body. */
+function daemonHttpErrorDetail(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object' && typeof parsed.detail === 'string') {
+            return parsed.detail;
+        }
+    }
+    catch {
+        // Non-JSON body (e.g. a proxy error page) — surface it verbatim.
+    }
+    return raw;
+}
 function parseJsonObject(raw, subcommand) {
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
@@ -25,7 +60,11 @@ function runProcessJson(options) {
             const stdoutText = Buffer.concat(stdout).toString('utf8').trim();
             const stderrText = Buffer.concat(stderr).toString('utf8').trim();
             if (code !== 0) {
-                reject(new Error(`ktx-daemon ${subcommand} failed: ${stderrText || `exit code ${code}`}`));
+                const detail = stderrText || `exit code ${code}`;
+                reject(new KtxDaemonComputeError(`ktx-daemon ${subcommand} failed: ${detail}`, {
+                    inputRejected: code === DAEMON_INPUT_REJECTED_EXIT_CODE,
+                    detail,
+                }));
                 return;
             }
             try {
@@ -60,7 +99,10 @@ function postJson(baseUrl) {
                 const text = Buffer.concat(chunks).toString('utf8');
                 const statusCode = response.statusCode ?? 0;
                 if (statusCode < 200 || statusCode >= 300) {
-                    reject(new Error(`ktx-daemon HTTP ${path} failed with ${statusCode}: ${text}`));
+                    reject(new KtxDaemonComputeError(`ktx-daemon HTTP ${path} failed with ${statusCode}: ${text}`, {
+                        inputRejected: statusCode === DAEMON_INPUT_REJECTED_HTTP_STATUS,
+                        detail: daemonHttpErrorDetail(text),
+                    }));
                     return;
                 }
                 try {

package/dist/context/ingest/adapters/looker/mapping.d.ts

@@ -10,6 +10,7 @@ declare const LOOKER_DIALECT_TO_CONNECTION_TYPE: {
     readonly sqlite: "SQLITE";
     readonly sqlserver: "SQLSERVER";
     readonly clickhouse: "CLICKHOUSE";
+    readonly awsathena: "ATHENA";
 };
 /** @internal */
 export type LookerWarehouseTargetConnectionType = (typeof LOOKER_DIALECT_TO_CONNECTION_TYPE)[keyof typeof LOOKER_DIALECT_TO_CONNECTION_TYPE];

package/dist/context/ingest/adapters/looker/mapping.js

@@ -1,3 +1,4 @@
+import { warehouseTargetDialect } from '../../../connections/connection-type-dialect.js';
 const LOOKER_DIALECT_TO_CONNECTION_TYPE = {
     bigquery: 'BIGQUERY',
     bigquery_standard_sql: 'BIGQUERY',
@@ -7,15 +8,7 @@ const LOOKER_DIALECT_TO_CONNECTION_TYPE = {
     sqlite: 'SQLITE',
     sqlserver: 'SQLSERVER',
     clickhouse: 'CLICKHOUSE',
-};
-const SQLGLOT_DIALECT_BY_CONNECTION_TYPE = {
-    BIGQUERY: 'bigquery',
-    SNOWFLAKE: 'snowflake',
-    POSTGRESQL: 'postgres',
-    MYSQL: 'mysql',
-    SQLITE: 'sqlite',
-    SQLSERVER: 'tsql',
-    CLICKHOUSE: 'clickhouse',
+    awsathena: 'ATHENA',
 };
 export async function discoverLookerConnections(client) {
     return client.listLookerConnections();
@@ -29,7 +22,7 @@ export function lookerDialectToConnectionType(dialect) {
 }
 /** @internal */
 export function sqlglotDialectForConnectionType(connectionType) {
-    return SQLGLOT_DIALECT_BY_CONNECTION_TYPE[connectionType] ?? null;
+    return warehouseTargetDialect(connectionType);
 }
 /** @internal */
 export function validateLookerWarehouseTarget(connectionType) {

package/dist/context/ingest/adapters/looker/types.d.ts

@@ -12,27 +12,18 @@ export declare const lookerPullConfigSchema: z.ZodObject<{
     lookUpdatedSince: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
     connectionMappings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     connectionTypes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<{
-        PLAIN: "PLAIN";
+        POSTGRESQL: "POSTGRESQL";
+        SQLITE: "SQLITE";
+        DUCKDB: "DUCKDB";
+        SQLSERVER: "SQLSERVER";
         BIGQUERY: "BIGQUERY";
         SNOWFLAKE: "SNOWFLAKE";
-        MYSQL: "MYSQL";
-        SQLSERVER: "SQLSERVER";
-        SQLITE: "SQLITE";
-        CLICKHOUSE: "CLICKHOUSE";
-        POSTGRESQL: "POSTGRESQL";
-        CENTRALREACH: "CENTRALREACH";
-        EPIC: "EPIC";
-        CERNER: "CERNER";
         ATHENA: "ATHENA";
-        QUICKBOOKS: "QUICKBOOKS";
-        WORKDAY: "WORKDAY";
-        REST: "REST";
-        S3: "S3";
-        SLACK: "SLACK";
         METABASE: "METABASE";
         LOOKER: "LOOKER";
         NOTION: "NOTION";
-        BETTERSTACK: "BETTERSTACK";
+        MYSQL: "MYSQL";
+        CLICKHOUSE: "CLICKHOUSE";
     }>>>;
     parsedTargetTables: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
         ok: z.ZodLiteral<true>;

package/dist/context/ingest/adapters/metabase/mapping.d.ts

@@ -7,6 +7,7 @@ export declare const METABASE_ENGINE_TO_CONNECTION_TYPE: {
     readonly snowflake: "SNOWFLAKE";
     readonly sqlserver: "SQLSERVER";
     readonly mysql: "MYSQL";
+    readonly athena: "ATHENA";
 };
 export interface DiscoveredMetabaseDatabase {
     id: number;

package/dist/context/ingest/adapters/metabase/mapping.js

@@ -6,6 +6,7 @@ export const METABASE_ENGINE_TO_CONNECTION_TYPE = {
     snowflake: 'SNOWFLAKE',
     sqlserver: 'SQLSERVER',
     mysql: 'MYSQL',
+    athena: 'ATHENA',
 };
 function isRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);

package/dist/context/ingest/adapters/sigma/chunk.d.ts

@@ -0,0 +1,6 @@
+import type { ChunkResult, DiffSet } from '../../types.js';
+interface ChunkOptions {
+    diffSet?: DiffSet;
+}
+export declare function chunkSigmaStagedDir(stagedDir: string, opts?: ChunkOptions): Promise<ChunkResult>;
+export {};

package/dist/context/ingest/adapters/sigma/chunk.js

@@ -0,0 +1,119 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { sigmaManifestSchema, stagedDataModelFileSchema, stagedWorkbookFileSchema, STAGED_FILES, } from './types.js';
+async function walkStagedDir(stagedDir) {
+    let entries;
+    try {
+        entries = await readdir(stagedDir, { withFileTypes: true, recursive: true });
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return [];
+        throw err;
+    }
+    const paths = [];
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        const abs = join(entry.parentPath, entry.name);
+        paths.push(relative(stagedDir, abs).replace(/\\/g, '/'));
+    }
+    paths.sort();
+    return paths;
+}
+async function loadBundle(stagedDir) {
+    const allPaths = await walkStagedDir(stagedDir);
+    let manifest = null;
+    try {
+        const body = await readFile(join(stagedDir, STAGED_FILES.manifest), 'utf-8');
+        manifest = sigmaManifestSchema.parse(JSON.parse(body));
+    }
+    catch {
+        manifest = null;
+    }
+    const dataModelsByPath = new Map();
+    const dmPrefix = `${STAGED_FILES.dataModelsDir}/`;
+    for (const path of allPaths) {
+        if (!path.startsWith(dmPrefix) || !path.endsWith('.json'))
+            continue;
+        try {
+            const body = await readFile(join(stagedDir, path), 'utf-8');
+            const parsed = stagedDataModelFileSchema.parse(JSON.parse(body));
+            dataModelsByPath.set(path, parsed);
+        }
+        catch {
+            // Malformed file — skip.
+        }
+    }
+    const workbooksByPath = new Map();
+    const wbPrefix = `${STAGED_FILES.workbooksDir}/`;
+    for (const path of allPaths) {
+        if (!path.startsWith(wbPrefix) || !path.endsWith('.json'))
+            continue;
+        try {
+            const body = await readFile(join(stagedDir, path), 'utf-8');
+            const parsed = stagedWorkbookFileSchema.parse(JSON.parse(body));
+            workbooksByPath.set(path, parsed);
+        }
+        catch {
+            // Malformed file — skip.
+        }
+    }
+    return { manifest, dataModelsByPath, workbooksByPath, allPaths };
+}
+/** Max data models per LLM work unit. Controls parallel processing granularity. */
+const DATA_MODELS_PER_UNIT = 50;
+/** Max workbooks per LLM work unit. Controls incremental re-sync granularity. */
+const WORKBOOKS_PER_UNIT = 2000;
+function emitBatches(paths, perUnit, unitKeyBase, labelBase, noun, allPaths) {
+    const batches = Math.ceil(paths.length / perUnit) || 0;
+    const units = [];
+    for (let i = 0; i < batches; i++) {
+        const batch = paths.slice(i * perUnit, (i + 1) * perUnit);
+        const rawFiles = [...batch].sort();
+        const rawFilesSet = new Set(rawFiles);
+        const suffix = batches > 1 ? `-${i}` : '';
+        units.push({
+            unitKey: `${unitKeyBase}${suffix}`,
+            displayLabel: batches > 1 ? `${labelBase} (${i + 1}/${batches})` : labelBase,
+            rawFiles,
+            peerFileIndex: allPaths.filter((p) => !rawFilesSet.has(p)).sort(),
+            dependencyPaths: [],
+            notes: `${batch.length} ${noun}${batch.length === 1 ? '' : 's'}`,
+        });
+    }
+    return units;
+}
+function emitWorkUnits(bundle) {
+    if (!bundle.manifest)
+        return [];
+    const dmPaths = [...bundle.dataModelsByPath.keys()].sort();
+    const wbPaths = [...bundle.workbooksByPath.keys()].sort();
+    return [
+        ...emitBatches(dmPaths, DATA_MODELS_PER_UNIT, 'sigma-data-models', 'Sigma: data models', 'data model', bundle.allPaths),
+        ...emitBatches(wbPaths, WORKBOOKS_PER_UNIT, 'sigma-workbooks', 'Sigma: workbooks', 'workbook', bundle.allPaths),
+    ];
+}
+export async function chunkSigmaStagedDir(stagedDir, opts = {}) {
+    const bundle = await loadBundle(stagedDir);
+    if (!bundle.manifest) {
+        return { workUnits: [] };
+    }
+    const firstRunUnits = emitWorkUnits(bundle);
+    if (!opts.diffSet) {
+        return { workUnits: firstRunUnits };
+    }
+    const touched = new Set([...opts.diffSet.added, ...opts.diffSet.modified]);
+    const kept = [];
+    for (const wu of firstRunUnits) {
+        const anyTouched = wu.rawFiles.some((p) => touched.has(p));
+        if (!anyTouched)
+            continue;
+        const changedFiles = wu.rawFiles.filter((p) => touched.has(p));
+        const unchangedFiles = wu.rawFiles.filter((p) => !touched.has(p));
+        const deps = new Set([...wu.dependencyPaths, ...unchangedFiles]);
+        kept.push({ ...wu, rawFiles: changedFiles.sort(), dependencyPaths: [...deps].sort() });
+    }
+    const eviction = opts.diffSet.deleted.length > 0 ? { deletedRawPaths: [...opts.diffSet.deleted].sort() } : undefined;
+    return { workUnits: kept, eviction };
+}

package/dist/context/ingest/adapters/sigma/client-port.d.ts

@@ -0,0 +1,45 @@
+import type { FetchContext } from '../../types.js';
+import type { SigmaPullConfig, WorkbookFilterInput } from './types.js';
+export interface SigmaTestConnectionResult {
+    success: boolean;
+    message?: string;
+    error?: string;
+}
+/** Data model summary shape from GET /v2/dataModels list response. */
+export interface SigmaDataModelSummary {
+    dataModelId: string;
+    dataModelUrlId: string;
+    name: string;
+    path: string;
+    latestVersion: number;
+    ownerId: string;
+    createdAt: string;
+    updatedAt: string;
+    isArchived?: boolean;
+}
+/** Workbook summary shape from GET /v2/workbooks list response. */
+export interface SigmaWorkbookSummary {
+    workbookId: string;
+    workbookUrlId: string;
+    name: string;
+    path: string;
+    latestVersion: number;
+    ownerId: string;
+    createdAt: string;
+    updatedAt: string;
+    isArchived?: boolean;
+    description?: string;
+}
+/** Re-exported so callers can reference the type without importing from types.ts directly. */
+export type { WorkbookFilterInput as ListWorkbooksOptions } from './types.js';
+export interface SigmaRuntimeClient {
+    testConnection(): Promise<SigmaTestConnectionResult>;
+    listDataModels(): Promise<SigmaDataModelSummary[]>;
+    listWorkbooks(opts?: WorkbookFilterInput): Promise<SigmaWorkbookSummary[]>;
+    /** Returns the raw spec object from GET /v2/dataModels/{id}/spec. */
+    getDataModelSpec(dataModelId: string): Promise<unknown>;
+    cleanup(): Promise<void>;
+}
+export interface SigmaClientFactory {
+    createClient(config: SigmaPullConfig, ctx: FetchContext): Promise<SigmaRuntimeClient> | SigmaRuntimeClient;
+}

package/dist/context/ingest/adapters/sigma/client-port.js

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

package/dist/context/ingest/adapters/sigma/client.d.ts

@@ -0,0 +1,33 @@
+import type { ListWorkbooksOptions, SigmaDataModelSummary, SigmaRuntimeClient, SigmaTestConnectionResult, SigmaWorkbookSummary } from './client-port.js';
+export interface SigmaClientRuntimeConfig {
+    apiUrl: string;
+    clientId: string;
+    clientSecret: string;
+}
+export interface SigmaClientConfig {
+    maxRetries: number;
+    baseDelayMs: number;
+    maxDelayMs: number;
+    timeoutMs: number;
+}
+export declare const DEFAULT_SIGMA_CLIENT_CONFIG: SigmaClientConfig;
+export declare class DefaultSigmaClient implements SigmaRuntimeClient {
+    private readonly runtimeConfig;
+    private readonly clientConfig;
+    private accessToken;
+    private refreshToken;
+    private tokenExpiresAt;
+    private tokenInflight;
+    constructor(runtimeConfig: SigmaClientRuntimeConfig, clientConfig?: SigmaClientConfig);
+    private get apiUrl();
+    private basicAuthHeader;
+    private fetchToken;
+    private ensureToken;
+    private request;
+    private paginateAll;
+    testConnection(): Promise<SigmaTestConnectionResult>;
+    listDataModels(): Promise<SigmaDataModelSummary[]>;
+    listWorkbooks(opts?: ListWorkbooksOptions): Promise<SigmaWorkbookSummary[]>;
+    getDataModelSpec(dataModelId: string): Promise<unknown>;
+    cleanup(): Promise<void>;
+}

package/dist/context/ingest/adapters/sigma/client.js

@@ -0,0 +1,176 @@
+export const DEFAULT_SIGMA_CLIENT_CONFIG = {
+    maxRetries: 3,
+    baseDelayMs: 500,
+    maxDelayMs: 10_000,
+    timeoutMs: 30_000,
+};
+function isNonRetryable500(text) {
+    try {
+        const body = JSON.parse(text);
+        // service_error indicates a deterministic Sigma rejection (e.g. unsupported data
+        // source subtype). Retrying will not help, so throw immediately.
+        return body['code'] === 'service_error';
+    }
+    catch {
+        return false;
+    }
+}
+export class DefaultSigmaClient {
+    runtimeConfig;
+    clientConfig;
+    accessToken = null;
+    refreshToken = null;
+    tokenExpiresAt = 0;
+    tokenInflight = null;
+    constructor(runtimeConfig, clientConfig = DEFAULT_SIGMA_CLIENT_CONFIG) {
+        this.runtimeConfig = runtimeConfig;
+        this.clientConfig = clientConfig;
+    }
+    get apiUrl() {
+        return this.runtimeConfig.apiUrl.replace(/\/$/, '');
+    }
+    basicAuthHeader() {
+        const credentials = Buffer.from(`${this.runtimeConfig.clientId}:${this.runtimeConfig.clientSecret}`).toString('base64');
+        return `Basic ${credentials}`;
+    }
+    async fetchToken(body) {
+        const res = await fetch(`${this.apiUrl}/v2/auth/token`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                Authorization: this.basicAuthHeader(),
+            },
+            body: body.toString(),
+            signal: AbortSignal.timeout(this.clientConfig.timeoutMs),
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => '');
+            throw new Error(`Sigma auth failed (${res.status}): ${text}`);
+        }
+        return res.json();
+    }
+    async ensureToken() {
+        const now = Date.now();
+        // Refresh 60 s before expiry so in-flight requests don't get 401.
+        if (this.accessToken && now < this.tokenExpiresAt - 60_000) {
+            return;
+        }
+        if (this.tokenInflight)
+            return this.tokenInflight;
+        const body = new URLSearchParams();
+        if (this.refreshToken) {
+            body.set('grant_type', 'refresh_token');
+            body.set('refresh_token', this.refreshToken);
+        }
+        else {
+            body.set('grant_type', 'client_credentials');
+        }
+        this.tokenInflight = this.fetchToken(body)
+            .then((data) => {
+            this.accessToken = data.access_token;
+            this.refreshToken = data.refresh_token ?? null;
+            this.tokenExpiresAt = Date.now() + data.expires_in * 1000;
+        })
+            .finally(() => {
+            this.tokenInflight = null;
+        });
+        return this.tokenInflight;
+    }
+    async request(path, query) {
+        await this.ensureToken();
+        const url = new URL(`${this.apiUrl}${path}`);
+        if (query) {
+            for (const [k, v] of Object.entries(query)) {
+                url.searchParams.set(k, v);
+            }
+        }
+        let lastError = null;
+        for (let attempt = 0; attempt <= this.clientConfig.maxRetries; attempt++) {
+            if (attempt > 0) {
+                const delay = Math.min(this.clientConfig.baseDelayMs * 2 ** (attempt - 1), this.clientConfig.maxDelayMs);
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+            const res = await fetch(url.toString(), {
+                headers: { Authorization: `Bearer ${this.accessToken}` },
+                signal: AbortSignal.timeout(this.clientConfig.timeoutMs),
+            });
+            if (res.status === 401) {
+                // Token rejected — force full re-auth and retry once.
+                this.accessToken = null;
+                this.refreshToken = null;
+                this.tokenExpiresAt = 0;
+                await this.ensureToken();
+                const retried = await fetch(url.toString(), {
+                    headers: { Authorization: `Bearer ${this.accessToken}` },
+                    signal: AbortSignal.timeout(this.clientConfig.timeoutMs),
+                });
+                if (!retried.ok) {
+                    const text = await retried.text().catch(() => '');
+                    throw new Error(`Sigma API error after token refresh (${retried.status}): ${text}`);
+                }
+                return retried.json();
+            }
+            if (res.status === 429 || res.status >= 500) {
+                const text = await res.text().catch(() => '');
+                lastError = new Error(`Sigma API error (${res.status}): ${text}`);
+                if (isNonRetryable500(text))
+                    throw lastError;
+                continue;
+            }
+            if (!res.ok) {
+                const text = await res.text().catch(() => '');
+                throw new Error(`Sigma API error (${res.status}): ${text}`);
+            }
+            return res.json();
+        }
+        throw lastError ?? new Error('Sigma API request failed after retries');
+    }
+    async paginateAll(path, query = {}) {
+        const all = [];
+        let page = null;
+        do {
+            const q = { ...query, limit: '1000' };
+            if (page) {
+                q['page'] = page;
+            }
+            const res = await this.request(path, q);
+            all.push(...res.entries);
+            page = res.nextPage ?? null;
+        } while (page !== null);
+        return all;
+    }
+    async testConnection() {
+        try {
+            await this.ensureToken();
+            return { success: true };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async listDataModels() {
+        return this.paginateAll('/v2/dataModels');
+    }
+    async listWorkbooks(opts = {}) {
+        const query = {};
+        if (!opts.includeExplorations)
+            query['excludeExplorations'] = 'true';
+        let results = await this.paginateAll('/v2/workbooks', query);
+        if (!opts.includeArchived) {
+            results = results.filter((wb) => !wb.isArchived);
+        }
+        if (opts.updatedSince) {
+            const since = new Date(opts.updatedSince).getTime();
+            results = results.filter((wb) => new Date(wb.updatedAt).getTime() >= since);
+        }
+        return results;
+    }
+    async getDataModelSpec(dataModelId) {
+        return this.request(`/v2/dataModels/${encodeURIComponent(dataModelId)}/spec`);
+    }
+    async cleanup() {
+        this.accessToken = null;
+        this.refreshToken = null;
+        this.tokenExpiresAt = 0;
+    }
+}

package/dist/context/ingest/adapters/sigma/detect.d.ts

@@ -0,0 +1 @@
+export declare function detectSigmaStagedDir(stagedDir: string): Promise<boolean>;

package/dist/context/ingest/adapters/sigma/detect.js

@@ -0,0 +1,23 @@
+import { readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { STAGED_FILES } from './types.js';
+export async function detectSigmaStagedDir(stagedDir) {
+    try {
+        await stat(join(stagedDir, STAGED_FILES.manifest));
+    }
+    catch {
+        return false;
+    }
+    for (const subdir of [STAGED_FILES.dataModelsDir, STAGED_FILES.workbooksDir]) {
+        let entries;
+        try {
+            entries = await readdir(join(stagedDir, subdir));
+        }
+        catch {
+            continue;
+        }
+        if (entries.some((name) => name.endsWith('.json')))
+            return true;
+    }
+    return false;
+}

package/dist/context/ingest/adapters/sigma/fetch.d.ts

@@ -0,0 +1,14 @@
+import type { FetchContext } from '../../types.js';
+import type { SigmaClientFactory } from './client-port.js';
+export interface SigmaFetchLogger {
+    log(message: string): void;
+    warn(message: string): void;
+}
+export interface FetchSigmaBundleParams {
+    pullConfig: unknown;
+    stagedDir: string;
+    ctx: FetchContext;
+    clientFactory: SigmaClientFactory;
+    logger?: SigmaFetchLogger;
+}
+export declare function fetchSigmaBundle({ pullConfig, stagedDir, ctx, clientFactory, logger, }: FetchSigmaBundleParams): Promise<void>;