@kaelio/ktx 0.0.0 → 0.1.0-rc.0

package/node_modules/@ktx/context/dist/ingest/adapters/looker/client.test.js

@@ -0,0 +1,392 @@
+import { describe, expect, it, vi } from 'vitest';
+import { LookerClient } from './client.js';
+const clientSecretParam = 'client_secret'; // pragma: allowlist secret
+function params() {
+    return {
+        base_url: 'https://example.looker.com',
+        client_id: 'id',
+        [clientSecretParam]: 'credential', // pragma: allowlist secret
+    };
+}
+function sdk(overrides = {}) {
+    const port = {
+        me: vi.fn().mockResolvedValue({ id: '1', display_name: 'API User', email: 'api@example.com' }),
+        search_dashboards: vi.fn().mockResolvedValue([{ id: '10' }]),
+        dashboard: vi.fn().mockResolvedValue({
+            id: '10',
+            title: 'Revenue Dashboard',
+            description: 'Revenue concepts',
+            folder_id: '20',
+            user_id: '1',
+            updated_at: '2026-04-30T00:00:00.000Z',
+            dashboard_elements: [
+                {
+                    id: '99',
+                    title: 'ARR',
+                    look_id: null,
+                    query: {
+                        id: 'q1',
+                        model: 'b2b',
+                        view: 'sales_pipeline',
+                        fields: ['opportunities.arr', 'opportunities.stage'],
+                        filters: { 'opportunities.stage': 'open' },
+                        sorts: ['opportunities.arr desc'],
+                        limit: '500',
+                    },
+                },
+            ],
+        }),
+        search_looks: vi.fn().mockResolvedValue([{ id: '30' }]),
+        search_scheduled_plans: vi.fn().mockResolvedValue([]),
+        look: vi.fn().mockResolvedValue({
+            id: '30',
+            title: 'Open Pipeline ARR',
+            description: 'ARR for open opportunities',
+            folder_id: '20',
+            user_id: '1',
+            updated_at: '2026-04-30T00:00:00.000Z',
+            query: {
+                id: 'q2',
+                model: 'b2b',
+                view: 'sales_pipeline',
+                fields: ['opportunities.arr'],
+                filters: { 'opportunities.stage': 'open' },
+            },
+        }),
+        all_folders: vi.fn().mockResolvedValue([{ id: '20', name: 'Executive', parent_id: null }]),
+        all_users: vi.fn().mockResolvedValue([{ id: '1', display_name: 'API User', email: 'api@example.com' }]),
+        all_groups: vi.fn().mockResolvedValue([{ id: '2', name: 'Finance' }]),
+        all_connections: vi.fn().mockResolvedValue([
+            {
+                name: 'b2b_sandbox_bq',
+                host: 'warehouse.example.com',
+                database: 'analytics',
+                schema: 'public',
+                dialect_name: 'bigquery_standard_sql',
+            },
+        ]),
+        all_lookml_models: vi
+            .fn()
+            .mockResolvedValue([
+            { name: 'b2b', label: 'B2B', explores: [{ name: 'sales_pipeline', label: 'Sales Pipeline' }] },
+        ]),
+        lookml_model_explore: vi.fn().mockResolvedValue({
+            name: 'sales_pipeline',
+            label: 'Sales Pipeline',
+            description: 'Opportunity pipeline',
+            sql_table_name: 'proj.dataset.opportunities AS opportunities',
+            connection_name: 'b2b_sandbox_bq',
+            view_name: 'opportunities',
+            fields: {
+                dimensions: [{ name: 'opportunities.stage', label: 'Stage', type: 'string', sql: '$' + '{TABLE}.stage' }],
+                measures: [{ name: 'opportunities.arr', label: 'ARR', type: 'sum', sql: '$' + '{TABLE}.arr' }],
+            },
+            joins: [
+                {
+                    name: 'accounts',
+                    type: 'left_outer',
+                    relationship: 'many_to_one',
+                    sql_table_name: 'proj.dataset.accounts',
+                    sql_on: '$' + '{opportunities.account_id} = $' + '{accounts.id}',
+                    from: null,
+                },
+            ],
+        }),
+        run_inline_query: vi.fn().mockResolvedValue('[]'),
+        logout: vi.fn().mockResolvedValue(undefined),
+        ...overrides,
+    };
+    return port;
+}
+describe('LookerClient', () => {
+    it('validates credentials with me()', async () => {
+        const client = new LookerClient(params(), { sdkFactory: () => sdk() });
+        await expect(client.testConnection()).resolves.toEqual({
+            success: true,
+            metadata: { userId: '1', displayName: 'API User', email: 'api@example.com' },
+        });
+    });
+    it('maps dashboards, looks, folders, models, explores, users, and groups to staged DTOs', async () => {
+        const fakeSdk = sdk();
+        const client = new LookerClient(params(), { sdkFactory: () => fakeSdk });
+        await expect(client.listDashboards()).resolves.toEqual([{ id: '10', updatedAt: null }]);
+        await expect(client.getDashboard('10')).resolves.toMatchObject({
+            lookerId: '10',
+            title: 'Revenue Dashboard',
+            tiles: [{ id: '99', query: { model: 'b2b', view: 'sales_pipeline' } }],
+        });
+        await expect(client.listLooks()).resolves.toEqual([{ id: '30', updatedAt: null }]);
+        await expect(client.getLook('30')).resolves.toMatchObject({
+            lookerId: '30',
+            title: 'Open Pipeline ARR',
+            query: { model: 'b2b', view: 'sales_pipeline' },
+        });
+        await expect(client.listFolders()).resolves.toEqual({
+            folders: [{ id: '20', name: 'Executive', parentId: null, path: ['Executive'] }],
+        });
+        await expect(client.listLookmlModels()).resolves.toEqual({
+            models: [{ name: 'b2b', label: 'B2B', explores: [{ name: 'sales_pipeline', label: 'Sales Pipeline' }] }],
+        });
+        await expect(client.listLookerConnections()).resolves.toEqual([
+            {
+                name: 'b2b_sandbox_bq',
+                host: 'warehouse.example.com',
+                database: 'analytics',
+                schema: 'public',
+                dialect: 'bigquery_standard_sql',
+            },
+        ]);
+        await expect(client.getExplore('b2b', 'sales_pipeline')).resolves.toMatchObject({
+            modelName: 'b2b',
+            exploreName: 'sales_pipeline',
+            rawSqlTableName: 'proj.dataset.opportunities AS opportunities',
+            connectionName: 'b2b_sandbox_bq',
+            viewName: 'opportunities',
+            fields: { dimensions: [{ name: 'opportunities.stage' }], measures: [{ name: 'opportunities.arr' }] },
+            joins: [
+                {
+                    name: 'accounts',
+                    rawSqlTableName: 'proj.dataset.accounts',
+                    sqlOn: '$' + '{opportunities.account_id} = $' + '{accounts.id}',
+                    from: null,
+                    targetTable: null,
+                },
+            ],
+            targetWarehouseConnectionId: null,
+            targetTable: null,
+        });
+        expect(fakeSdk.dashboard).toHaveBeenCalledWith('10', 'id,title,description,folder_id,user_id,updated_at,dashboard_elements(id,title,look_id,query(id,model,view,fields,filters,sorts,limit,dynamic_fields))');
+        expect(fakeSdk.look).toHaveBeenCalledWith('30', 'id,title,description,folder_id,user_id,updated_at,query(id,model,view,fields,filters,sorts,limit,dynamic_fields)');
+        expect(fakeSdk.lookml_model_explore).toHaveBeenCalledWith('b2b', 'sales_pipeline', 'name,label,description,sql_table_name,connection_name,view_name,fields,joins(name,type,relationship,sql_table_name,sql_on,from)');
+        expect(fakeSdk.all_connections).toHaveBeenCalledWith('name,host,database,schema,dialect_name');
+    });
+    it('returns empty usage signals when system activity access fails', async () => {
+        const client = new LookerClient(params(), {
+            sdkFactory: () => sdk({
+                run_inline_query: vi.fn().mockRejectedValue(new Error('access denied')),
+                search_dashboards: vi.fn().mockResolvedValue([{ id: '10', favorite_count: 4 }]),
+                search_looks: vi.fn().mockResolvedValue([{ id: '30', favorite_count: 2 }]),
+                search_scheduled_plans: vi.fn().mockResolvedValue([]),
+            }),
+        });
+        await expect(client.getSignals()).resolves.toEqual({
+            dashboardUsage: [],
+            lookUsage: [],
+            scheduledPlans: [],
+            favorites: [
+                { contentId: '10', contentType: 'dashboard', favoriteCount: 4 },
+                { contentId: '30', contentType: 'look', favoriteCount: 2 },
+            ],
+        });
+    });
+    it('paginates dashboard and Look searches', async () => {
+        const dashboardPageOne = Array.from({ length: 500 }, (_, index) => ({ id: String(index + 1) }));
+        const lookPageOne = Array.from({ length: 500 }, (_, index) => ({ id: String(index + 1001) }));
+        const fakeSdk = sdk({
+            search_dashboards: vi
+                .fn()
+                .mockResolvedValueOnce(dashboardPageOne)
+                .mockResolvedValueOnce([{ id: '501' }]),
+            search_looks: vi
+                .fn()
+                .mockResolvedValueOnce(lookPageOne)
+                .mockResolvedValueOnce([{ id: '1501' }]),
+        });
+        const client = new LookerClient(params(), { sdkFactory: () => fakeSdk });
+        await expect(client.listDashboards()).resolves.toHaveLength(501);
+        await expect(client.listLooks()).resolves.toHaveLength(501);
+        expect(fakeSdk.search_dashboards).toHaveBeenNthCalledWith(1, expect.objectContaining({
+            deleted: false,
+            fields: 'id,updated_at',
+            limit: 500,
+            offset: 0,
+            sorts: 'id',
+        }));
+        expect(fakeSdk.search_dashboards).toHaveBeenNthCalledWith(2, expect.objectContaining({
+            limit: 500,
+            offset: 500,
+        }));
+        expect(fakeSdk.search_looks).toHaveBeenNthCalledWith(1, expect.objectContaining({
+            deleted: false,
+            fields: 'id,updated_at',
+            limit: 500,
+            offset: 0,
+            sorts: 'id',
+        }));
+        expect(fakeSdk.search_looks).toHaveBeenNthCalledWith(2, expect.objectContaining({
+            limit: 500,
+            offset: 500,
+        }));
+    });
+    it('returns updatedAt cursors from dashboard and Look listing rows', async () => {
+        const fakeSdk = sdk({
+            search_dashboards: vi.fn().mockResolvedValue([{ id: '10', updated_at: '2026-04-30T12:00:00.000Z' }]),
+            search_looks: vi.fn().mockResolvedValue([{ id: '30', updated_at: '2026-04-30T11:00:00.000Z' }]),
+        });
+        const client = new LookerClient(params(), { sdkFactory: () => fakeSdk });
+        await expect(client.listDashboards()).resolves.toEqual([{ id: '10', updatedAt: '2026-04-30T12:00:00.000Z' }]);
+        await expect(client.listLooks()).resolves.toEqual([{ id: '30', updatedAt: '2026-04-30T11:00:00.000Z' }]);
+    });
+    it('logs out the SDK session during cleanup', async () => {
+        const fakeSdk = sdk();
+        const client = new LookerClient(params(), { sdkFactory: () => fakeSdk });
+        await client.testConnection();
+        await client.cleanup();
+        expect(fakeSdk.logout).toHaveBeenCalledTimes(1);
+    });
+    it('aggregates usage, scheduled-plan, and favorite signals', async () => {
+        const runInlineQuery = vi
+            .fn()
+            .mockResolvedValueOnce(JSON.stringify([
+            {
+                'dashboard.id': '10',
+                'history.query_run_count': 3,
+                'history.created_date': '2026-04-30',
+                'user.id': 'user-1',
+            },
+            {
+                'dashboard.id': '10',
+                'history.query_run_count': '2',
+                'history.created_date': '2026-04-29',
+                'user.id': 'user-2',
+            },
+        ]))
+            .mockResolvedValueOnce(JSON.stringify([
+            {
+                'look.id': '30',
+                'history.query_run_count': 7,
+                'history.created_date': '2026-04-28',
+                'user.id': 'user-1',
+            },
+        ]));
+        const fakeSdk = sdk({
+            run_inline_query: runInlineQuery,
+            search_dashboards: vi.fn().mockResolvedValueOnce([{ id: '10', favorite_count: 4 }]),
+            search_looks: vi.fn().mockResolvedValueOnce([{ id: '30', favorite_count: 2 }]),
+            search_scheduled_plans: vi.fn().mockResolvedValueOnce([
+                {
+                    id: 'sp-dashboard',
+                    dashboard_id: '10',
+                    look_id: null,
+                    enabled: true,
+                    scheduled_plan_destination: [{ id: 'dest-1' }, { id: 'dest-2' }],
+                },
+                {
+                    id: 'sp-look',
+                    dashboard_id: null,
+                    look_id: '30',
+                    enabled: true,
+                    scheduled_plan_destination: [{ id: 'dest-3' }],
+                },
+            ]),
+        });
+        const client = new LookerClient(params(), { sdkFactory: () => fakeSdk });
+        await expect(client.getSignals()).resolves.toEqual({
+            dashboardUsage: [
+                {
+                    contentId: '10',
+                    queryCount30d: 5,
+                    uniqueUsers30d: 2,
+                    lastRunAt: '2026-04-30',
+                    topUsers: ['user-1', 'user-2'],
+                },
+            ],
+            lookUsage: [
+                {
+                    contentId: '30',
+                    queryCount30d: 7,
+                    uniqueUsers30d: 1,
+                    lastRunAt: '2026-04-28',
+                    topUsers: ['user-1'],
+                },
+            ],
+            scheduledPlans: [
+                {
+                    contentId: '10',
+                    contentType: 'dashboard',
+                    isScheduled: true,
+                    scheduleCount: 1,
+                    recipientCount: 2,
+                },
+                {
+                    contentId: '30',
+                    contentType: 'look',
+                    isScheduled: true,
+                    scheduleCount: 1,
+                    recipientCount: 1,
+                },
+            ],
+            favorites: [
+                { contentId: '10', contentType: 'dashboard', favoriteCount: 4 },
+                { contentId: '30', contentType: 'look', favoriteCount: 2 },
+            ],
+        });
+        expect(runInlineQuery).toHaveBeenNthCalledWith(1, expect.objectContaining({
+            result_format: 'json',
+            body: expect.objectContaining({
+                model: 'system__activity',
+                view: 'history',
+                fields: ['dashboard.id', 'history.query_run_count', 'history.created_date', 'user.id'],
+            }),
+        }));
+        expect(fakeSdk.search_scheduled_plans).toHaveBeenCalledWith(expect.objectContaining({
+            all_users: true,
+            fields: 'id,dashboard_id,look_id,enabled,scheduled_plan_destination',
+            limit: 500,
+            offset: 0,
+            sorts: 'id',
+        }));
+    });
+    it('retries a 429 response once using Retry-After seconds', async () => {
+        const sleep = vi.fn().mockResolvedValue(undefined);
+        const rateLimitError = new Error('rate limited');
+        Object.assign(rateLimitError, { statusCode: 429, headers: { 'retry-after': '2' } });
+        const fakeSdk = sdk({
+            search_dashboards: vi
+                .fn()
+                .mockRejectedValueOnce(rateLimitError)
+                .mockResolvedValueOnce([{ id: '10' }]),
+        });
+        const client = new LookerClient(params(), { sdkFactory: () => fakeSdk, sleep });
+        await expect(client.listDashboards()).resolves.toEqual([{ id: '10', updatedAt: null }]);
+        expect(sleep).toHaveBeenCalledWith(2000);
+        expect(fakeSdk.search_dashboards).toHaveBeenCalledTimes(2);
+    });
+    it('does not retry non-429 errors', async () => {
+        const sleep = vi.fn().mockResolvedValue(undefined);
+        const error = new Error('broken dashboard');
+        Object.assign(error, { statusCode: 500 });
+        const fakeSdk = sdk({ dashboard: vi.fn().mockRejectedValue(error) });
+        const client = new LookerClient(params(), { sdkFactory: () => fakeSdk, sleep });
+        await expect(client.getDashboard('10')).rejects.toThrow('broken dashboard');
+        expect(sleep).not.toHaveBeenCalled();
+        expect(fakeSdk.dashboard).toHaveBeenCalledTimes(1);
+    });
+    it('initializes the real @looker/sdk-node SDK with inline credentials without throwing', async () => {
+        const client = new LookerClient(params());
+        const result = await client.testConnection();
+        // Without injected sdkFactory the real SDK is constructed via InlineLookerSettings.
+        // This used to throw "Missing required configuration values like base_url" because
+        // the parent NodeSettingsIniFile constructor validated config before the override
+        // could supply credentials. Whatever happens now (auth/network failure against the
+        // bogus example URL is fine) — what must NOT happen is a synchronous SDK-init throw.
+        expect(result.success).toBe(false);
+        expect(result.error).toBeDefined();
+        expect(result.error).not.toMatch(/Missing required configuration values/i);
+        await client.cleanup();
+    });
+    it('strips trailing /api/4.0 from base_url so the SDK does not double-prefix it', async () => {
+        const clientWithSuffix = new LookerClient({
+            base_url: 'https://example.looker.com/api/4.0',
+            client_id: 'id',
+            [clientSecretParam]: 'credential', // pragma: allowlist secret
+        });
+        const result = await clientWithSuffix.testConnection();
+        expect(result.success).toBe(false);
+        // If base_url is double-prefixed the SDK would hit /api/4.0/api/4.0/login. Either
+        // the URL is correctly normalized (transport-level network failure) or we'd see a
+        // 404/HTML response — either way the stack must not be a config-validation throw.
+        expect(result.error).not.toMatch(/Missing required configuration values/i);
+        await clientWithSuffix.cleanup();
+    });
+});

package/node_modules/@ktx/context/dist/ingest/adapters/looker/daemon-table-identifier-parser.d.ts

@@ -0,0 +1,7 @@
+import type { LookerTableIdentifierParser } from './mapping.js';
+export type KtxDaemonTableIdentifierHttpJsonRunner = (path: string, payload: Record<string, unknown>) => Promise<Record<string, unknown>>;
+export interface DaemonLookerTableIdentifierParserOptions {
+    baseUrl: string;
+    requestJson?: KtxDaemonTableIdentifierHttpJsonRunner;
+}
+export declare function createDaemonLookerTableIdentifierParser(options: DaemonLookerTableIdentifierParserOptions): LookerTableIdentifierParser;

package/node_modules/@ktx/context/dist/ingest/adapters/looker/daemon-table-identifier-parser.js

@@ -0,0 +1,57 @@
+import { request as httpRequest } from 'node:http';
+import { request as httpsRequest } from 'node:https';
+import { URL } from 'node:url';
+export function createDaemonLookerTableIdentifierParser(options) {
+    const requestJson = options.requestJson ?? postJson(options.baseUrl);
+    return {
+        async parse(items) {
+            const raw = await requestJson('/sql/parse-table-identifier', { items });
+            if (!raw.results || typeof raw.results !== 'object' || Array.isArray(raw.results)) {
+                throw new Error('ktx-daemon table identifier parser returned invalid results');
+            }
+            return raw.results;
+        },
+    };
+}
+function normalizedBaseUrl(baseUrl) {
+    return baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
+}
+function postJson(baseUrl) {
+    return async (path, payload) => new Promise((resolve, reject) => {
+        const target = new URL(path.replace(/^\//, ''), normalizedBaseUrl(baseUrl));
+        const body = JSON.stringify(payload);
+        const client = target.protocol === 'https:' ? httpsRequest : httpRequest;
+        const request = client(target, {
+            method: 'POST',
+            headers: {
+                accept: 'application/json',
+                'content-type': 'application/json',
+                'content-length': Buffer.byteLength(body),
+            },
+        }, (response) => {
+            const chunks = [];
+            response.on('data', (chunk) => chunks.push(chunk));
+            response.on('end', () => {
+                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}`));
+                    return;
+                }
+                try {
+                    const parsed = JSON.parse(text);
+                    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+                        reject(new Error(`ktx-daemon HTTP ${path} returned non-object JSON`));
+                        return;
+                    }
+                    resolve(parsed);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+        request.on('error', reject);
+        request.end(body);
+    });
+}

package/node_modules/@ktx/context/dist/ingest/adapters/looker/daemon-table-identifier-parser.test.d.ts

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

package/node_modules/@ktx/context/dist/ingest/adapters/looker/daemon-table-identifier-parser.test.js

@@ -0,0 +1,40 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createDaemonLookerTableIdentifierParser } from './daemon-table-identifier-parser.js';
+describe('createDaemonLookerTableIdentifierParser', () => {
+    it('posts parse items to the daemon endpoint', async () => {
+        const requestJson = vi.fn(async () => ({
+            results: {
+                orders: {
+                    ok: true,
+                    catalog: null,
+                    schema: 'public',
+                    name: 'orders',
+                    canonical_table: 'public.orders',
+                },
+            },
+        }));
+        const parser = createDaemonLookerTableIdentifierParser({
+            baseUrl: 'http://127.0.0.1:8765',
+            requestJson,
+        });
+        await expect(parser.parse([{ key: 'orders', sql_table_name: 'public.orders', dialect: 'postgres' }])).resolves.toEqual({
+            orders: {
+                ok: true,
+                catalog: null,
+                schema: 'public',
+                name: 'orders',
+                canonical_table: 'public.orders',
+            },
+        });
+        expect(requestJson).toHaveBeenCalledWith('/sql/parse-table-identifier', {
+            items: [{ key: 'orders', sql_table_name: 'public.orders', dialect: 'postgres' }],
+        });
+    });
+    it('rejects non-object daemon responses', async () => {
+        const parser = createDaemonLookerTableIdentifierParser({
+            baseUrl: 'http://127.0.0.1:8765',
+            requestJson: async () => ({ results: null }),
+        });
+        await expect(parser.parse([])).rejects.toThrow('ktx-daemon table identifier parser returned invalid results');
+    });
+});

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

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

package/node_modules/@ktx/context/dist/ingest/adapters/looker/detect.js

@@ -0,0 +1,26 @@
+import { readdir, stat } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { STAGED_FILES } from './types.js';
+const LOOKER_ENTITY_FILE_RE = /^(explores\/[^/]+\/[^/]+|dashboards\/[^/]+|looks\/[^/]+)\.json$/;
+async function walk(root) {
+    const entries = await readdir(root, { withFileTypes: true, recursive: true });
+    return entries
+        .filter((entry) => entry.isFile())
+        .map((entry) => relative(root, join(entry.parentPath, entry.name)).replace(/\\/g, '/'))
+        .sort();
+}
+export async function detectLookerStagedDir(stagedDir) {
+    try {
+        await stat(join(stagedDir, STAGED_FILES.syncConfig));
+    }
+    catch {
+        return false;
+    }
+    try {
+        const paths = await walk(stagedDir);
+        return paths.some((path) => LOOKER_ENTITY_FILE_RE.test(path));
+    }
+    catch {
+        return false;
+    }
+}

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

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

package/node_modules/@ktx/context/dist/ingest/adapters/looker/detect.test.js

@@ -0,0 +1,39 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { detectLookerStagedDir } from './detect.js';
+async function touch(stagedDir, relPath, body = '{}\n') {
+    const abs = join(stagedDir, relPath);
+    await mkdir(join(abs, '..'), { recursive: true });
+    await writeFile(abs, body, 'utf-8');
+}
+describe('detectLookerStagedDir', () => {
+    let stagedDir;
+    beforeEach(async () => {
+        stagedDir = await mkdtemp(join(tmpdir(), 'looker-detect-'));
+    });
+    afterEach(async () => {
+        await rm(stagedDir, { recursive: true, force: true });
+    });
+    it('returns true when sync-config.json and at least one runtime entity are present', async () => {
+        await touch(stagedDir, 'sync-config.json');
+        await touch(stagedDir, 'explores/b2b/sales_pipeline.json');
+        expect(await detectLookerStagedDir(stagedDir)).toBe(true);
+    });
+    it('returns true for dashboard-only staged dirs', async () => {
+        await touch(stagedDir, 'sync-config.json');
+        await touch(stagedDir, 'dashboards/10.json');
+        expect(await detectLookerStagedDir(stagedDir)).toBe(true);
+    });
+    it('returns false without sync-config.json', async () => {
+        await touch(stagedDir, 'looks/20.json');
+        expect(await detectLookerStagedDir(stagedDir)).toBe(false);
+    });
+    it('returns false when only control files are present', async () => {
+        await touch(stagedDir, 'sync-config.json');
+        await touch(stagedDir, 'lookml_models.json');
+        await touch(stagedDir, 'signals/dashboard_usage.json', '[]\n');
+        expect(await detectLookerStagedDir(stagedDir)).toBe(false);
+    });
+});

package/node_modules/@ktx/context/dist/ingest/adapters/looker/evidence-documents.d.ts

@@ -0,0 +1,3 @@
+import type { TriageSignals } from '../../types.js';
+export declare function writeLookerEvidenceDocuments(stagedDir: string): Promise<void>;
+export declare function getLookerTriageSignals(stagedDir: string, externalId: string): Promise<TriageSignals>;