@kaelio/ktx 0.4.1 → 0.5.0

package/node_modules/@ktx/context/dist/ingest/stages/stage-3-work-units.test.js

@@ -1,175 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { addTouchedSlSource, createTouchedSlSources } from '../../tools/index.js';
-import { executeWorkUnit } from './stage-3-work-units.js';
-const makeWu = (overrides = {}) => ({
-    unitKey: 'u1',
-    rawFiles: ['a.yml'],
-    peerFileIndex: [],
-    dependencyPaths: [],
-    ...overrides,
-});
-const makeDeps = () => {
-    const session = {
-        userId: 'system',
-        chatId: 'u1',
-        userMessage: '',
-        connectionId: 'c1',
-        userScopedEnabled: false,
-        forceGlobalScope: true,
-        touchedSlSources: createTouchedSlSources(),
-        preHead: null,
-    };
-    const sessionActions = [];
-    return {
-        sessionWorktreeGit: { revParseHead: vi.fn() },
-        agentRunner: { runLoop: vi.fn() },
-        validateTouchedSources: vi.fn().mockResolvedValue({ validSources: [], invalidSources: [] }),
-        resetHardTo: vi.fn(),
-        buildSystemPrompt: () => 'sys',
-        buildUserPrompt: () => 'usr',
-        buildToolSet: () => ({ noop: { description: 'x', inputSchema: {}, execute: vi.fn() } }),
-        captureSession: session,
-        sessionActions,
-        modelRole: 'candidateExtraction',
-        stepBudget: 40,
-        sourceKey: 'fake',
-        connectionId: 'c1',
-        jobId: 'j1',
-    };
-};
-describe('Stage 3 — executeWorkUnit', () => {
-    beforeEach(() => vi.clearAllMocks());
-    it('clean path — no touched sources, passes through as success with empty actions', async () => {
-        const deps = makeDeps();
-        deps.sessionWorktreeGit.revParseHead = vi.fn().mockResolvedValueOnce('pre').mockResolvedValueOnce('post');
-        deps.agentRunner.runLoop = vi.fn().mockResolvedValue({ stopReason: 'natural' });
-        const outcome = await executeWorkUnit(deps, makeWu());
-        expect(outcome.status).toBe('success');
-        expect(outcome.preSha).toBe('pre');
-        expect(outcome.postSha).toBe('post');
-        expect(outcome.actions).toEqual([]);
-        expect(deps.validateTouchedSources).not.toHaveBeenCalled();
-        expect(deps.resetHardTo).not.toHaveBeenCalled();
-        expect(deps.agentRunner.runLoop).toHaveBeenCalledWith(expect.objectContaining({ modelRole: 'candidateExtraction' }));
-    });
-    it('validates touched sources and passes through as success when all are valid', async () => {
-        const deps = makeDeps();
-        deps.sessionWorktreeGit.revParseHead = vi.fn().mockResolvedValueOnce('pre').mockResolvedValueOnce('post');
-        deps.agentRunner.runLoop = vi.fn().mockImplementation(() => {
-            deps.sessionActions.push({ target: 'sl', type: 'created', key: 'src_good', detail: '' });
-            addTouchedSlSource(deps.captureSession.touchedSlSources, 'c1', 'src_good');
-            return Promise.resolve({ stopReason: 'natural' });
-        });
-        deps.validateTouchedSources = vi.fn().mockResolvedValue({ validSources: ['c1:src_good'], invalidSources: [] });
-        const outcome = await executeWorkUnit(deps, makeWu());
-        expect(outcome.status).toBe('success');
-        expect(outcome.actions.map((a) => a.key)).toEqual(['src_good']);
-        expect(outcome.touchedSlSources).toEqual([{ connectionId: 'c1', sourceName: 'src_good' }]);
-        expect(deps.resetHardTo).not.toHaveBeenCalled();
-    });
-    it('any invalid source resets to the pre-WU SHA and marks WU failed', async () => {
-        const deps = makeDeps();
-        deps.sessionWorktreeGit.revParseHead = vi.fn().mockResolvedValueOnce('pre').mockResolvedValueOnce('post');
-        deps.agentRunner.runLoop = vi.fn().mockImplementation(() => {
-            deps.sessionActions.push({ target: 'sl', type: 'created', key: 'src_bad', detail: '' });
-            deps.sessionActions.push({ target: 'sl', type: 'created', key: 'src_good', detail: '' });
-            addTouchedSlSource(deps.captureSession.touchedSlSources, 'c1', 'src_bad');
-            addTouchedSlSource(deps.captureSession.touchedSlSources, 'c1', 'src_good');
-            return Promise.resolve({ stopReason: 'natural' });
-        });
-        deps.validateTouchedSources = vi
-            .fn()
-            .mockResolvedValue({ validSources: ['c1:src_good'], invalidSources: ['c1:src_bad'] });
-        const outcome = await executeWorkUnit(deps, makeWu());
-        expect(outcome.status).toBe('failed');
-        expect(outcome.reason).toMatch(/src_bad/);
-        expect(outcome.actions).toEqual([]);
-        expect(outcome.touchedSlSources).toEqual([]);
-        expect(deps.resetHardTo).toHaveBeenCalledWith('pre');
-    });
-    it('runner loop error resets to the pre-WU SHA and marks WU failed', async () => {
-        const deps = makeDeps();
-        deps.sessionWorktreeGit.revParseHead = vi.fn().mockResolvedValueOnce('pre').mockResolvedValueOnce('post');
-        deps.agentRunner.runLoop = vi.fn().mockResolvedValue({ stopReason: 'error', error: new Error('LLM down') });
-        const outcome = await executeWorkUnit(deps, makeWu());
-        expect(outcome.status).toBe('failed');
-        expect(outcome.reason).toMatch(/LLM down/);
-        expect(deps.resetHardTo).toHaveBeenCalledWith('pre');
-    });
-    it('tool failures reset to the pre-WU SHA and mark WU failed even when the loop ends naturally', async () => {
-        const deps = makeDeps();
-        deps.sessionWorktreeGit.revParseHead = vi.fn().mockResolvedValueOnce('pre').mockResolvedValueOnce('post');
-        deps.agentRunner.runLoop = vi.fn().mockResolvedValue({ stopReason: 'natural' });
-        deps.toolFailureCount = vi.fn().mockReturnValue(2);
-        const outcome = await executeWorkUnit(deps, makeWu());
-        expect(outcome.status).toBe('failed');
-        expect(outcome.reason).toContain('2 tool call(s) failed');
-        expect(outcome.actions).toEqual([]);
-        expect(outcome.touchedSlSources).toEqual([]);
-        expect(deps.resetHardTo).toHaveBeenCalledWith('pre');
-    });
-    it('dangling wiki refs reset to the pre-WU SHA and mark WU failed after the agent loop', async () => {
-        const deps = makeDeps();
-        deps.sessionWorktreeGit.revParseHead = vi.fn().mockResolvedValueOnce('pre').mockResolvedValueOnce('post');
-        deps.agentRunner.runLoop = vi.fn().mockImplementation(() => {
-            deps.sessionActions.push({ target: 'wiki', type: 'created', key: 'page-a', detail: 'Page A' });
-            return Promise.resolve({ stopReason: 'natural' });
-        });
-        deps.validateWikiRefs = vi.fn().mockResolvedValue(['page-a -> page-b']);
-        const outcome = await executeWorkUnit(deps, makeWu());
-        expect(outcome.status).toBe('failed');
-        expect(outcome.reason).toContain('wiki references target missing page(s): page-a -> page-b');
-        expect(outcome.actions).toEqual([]);
-        expect(outcome.touchedSlSources).toEqual([]);
-        expect(deps.resetHardTo).toHaveBeenCalledWith('pre');
-    });
-    it('resolved wiki refs pass post-WU validation and preserve actions', async () => {
-        const deps = makeDeps();
-        deps.sessionWorktreeGit.revParseHead = vi.fn().mockResolvedValueOnce('pre').mockResolvedValueOnce('post');
-        deps.agentRunner.runLoop = vi.fn().mockImplementation(() => {
-            deps.sessionActions.push({ target: 'wiki', type: 'created', key: 'page-a', detail: 'Page A' });
-            deps.sessionActions.push({ target: 'wiki', type: 'created', key: 'page-b', detail: 'Page B' });
-            return Promise.resolve({ stopReason: 'natural' });
-        });
-        deps.validateWikiRefs = vi.fn().mockResolvedValue([]);
-        const outcome = await executeWorkUnit(deps, makeWu());
-        expect(outcome.status).toBe('success');
-        expect(outcome.actions.map((action) => action.key)).toEqual(['page-a', 'page-b']);
-        expect(deps.resetHardTo).not.toHaveBeenCalled();
-    });
-    it('runner loop thrown exception resets to the pre-WU SHA and marks WU failed', async () => {
-        const deps = makeDeps();
-        deps.sessionWorktreeGit.revParseHead = vi.fn().mockResolvedValueOnce('pre').mockResolvedValueOnce('post');
-        deps.agentRunner.runLoop = vi.fn().mockRejectedValue(new Error('provider disconnected'));
-        const outcome = await executeWorkUnit(deps, makeWu());
-        expect(outcome).toMatchObject({
-            unitKey: 'u1',
-            status: 'failed',
-            reason: 'provider disconnected',
-            preSha: 'pre',
-            postSha: 'post',
-            actions: [],
-            touchedSlSources: [],
-        });
-        expect(deps.resetHardTo).toHaveBeenCalledWith('pre');
-    });
-    it('fails before model execution when the assembled prompt is too large', async () => {
-        const deps = makeDeps();
-        deps.sessionWorktreeGit.revParseHead = vi.fn().mockResolvedValue('pre');
-        deps.buildSystemPrompt = () => 'sys';
-        deps.buildUserPrompt = () => 'x'.repeat(260_000);
-        const outcome = await executeWorkUnit(deps, makeWu());
-        expect(outcome.status).toBe('failed');
-        expect(outcome.reason).toMatch(/prompt too large/i);
-        expect(deps.agentRunner.runLoop).not.toHaveBeenCalled();
-        expect(deps.resetHardTo).not.toHaveBeenCalled();
-    });
-    it('no commits made during WU — skips resetHardTo even on runner error', async () => {
-        const deps = makeDeps();
-        deps.sessionWorktreeGit.revParseHead = vi.fn().mockResolvedValueOnce('same').mockResolvedValueOnce('same');
-        deps.agentRunner.runLoop = vi.fn().mockResolvedValue({ stopReason: 'error', error: new Error('bail') });
-        const outcome = await executeWorkUnit(deps, makeWu());
-        expect(outcome.status).toBe('failed');
-        expect(deps.resetHardTo).not.toHaveBeenCalled();
-    });
-});

package/node_modules/@ktx/context/dist/ingest/stages/stage-4-reconciliation.d.ts

@@ -1,28 +0,0 @@
-import type { AgentRunnerPort, KtxRuntimeToolSet } from '@ktx/context';
-import type { KtxModelRole } from '@ktx/llm';
-import type { EvictionUnit } from '../types.js';
-import type { StageIndex } from './stage-index.types.js';
-export interface ReconciliationContext {
-    stageIndex: StageIndex;
-    evictionUnit: EvictionUnit | undefined;
-    agentRunner: AgentRunnerPort;
-    buildSystemPrompt: (idx: StageIndex, ev: EvictionUnit | undefined) => string;
-    buildUserPrompt: (idx: StageIndex, ev: EvictionUnit | undefined) => string;
-    buildToolSet: () => KtxRuntimeToolSet;
-    modelRole: KtxModelRole;
-    stepBudget: number;
-    sourceKey: string;
-    jobId: string;
-    force?: boolean;
-    onStepFinish?: (info: {
-        stepIndex: number;
-        stepBudget: number;
-    }) => void;
-    forceRun?: boolean;
-}
-export interface ReconciliationOutcome {
-    skipped: boolean;
-    stopReason?: 'budget' | 'natural' | 'error';
-    error?: Error;
-}
-export declare function runReconciliationStage4(ctx: ReconciliationContext): Promise<ReconciliationOutcome>;

package/node_modules/@ktx/context/dist/ingest/stages/stage-index.types.d.ts

@@ -1,50 +0,0 @@
-import type { MemoryAction } from '../../memory/index.js';
-import type { TouchedSlSource } from '../../tools/index.js';
-export interface StageIndexWorkUnit {
-    unitKey: string;
-    rawFiles: string[];
-    status: 'success' | 'failed';
-    reason?: string;
-    actions: MemoryAction[];
-    touchedSlSources: TouchedSlSource[];
-    slDisallowed?: boolean;
-    slDisallowedReason?: 'lookml_connection_mismatch';
-}
-export interface ConflictResolvedRecord {
-    unitKey?: string;
-    kind: 'structural_duplicate' | 'near_duplicate' | 'definitional_contradiction' | 're_ingest_change';
-    contestedKey?: string;
-    artifactKey: string;
-    detail: string;
-    flaggedForHuman: boolean;
-}
-export interface EvictionAppliedRecord {
-    rawPath: string;
-    artifactKind: 'sl' | 'wiki';
-    artifactKey: string;
-    action: 'removed';
-    reason: string;
-}
-export type UnmappedFallbackReason = 'no_connection_mapping' | 'looker_template_unresolved' | 'derived_table_not_supported' | 'no_physical_table' | 'multiple_table_references' | 'unsupported_dialect' | 'parse_error' | 'missing_target_table' | 'cumulative_metric_unsupported' | 'conversion_metric_unsupported';
-export interface UnmappedFallbackRecord {
-    rawPath: string;
-    reason: UnmappedFallbackReason;
-    detail?: string;
-    fallback: 'sql_standalone' | 'wiki_only' | 'flagged';
-}
-export interface ArtifactResolutionRecord {
-    rawPath: string;
-    artifactKind: 'sl' | 'wiki';
-    artifactKey: string;
-    actionType: 'merged' | 'subsumed';
-    reason: string;
-}
-export interface StageIndex {
-    jobId: string;
-    connectionId: string;
-    workUnits: StageIndexWorkUnit[];
-    conflictsResolved: ConflictResolvedRecord[];
-    evictionsApplied: EvictionAppliedRecord[];
-    unmappedFallbacks: UnmappedFallbackRecord[];
-    artifactResolutions?: ArtifactResolutionRecord[];
-}

package/node_modules/@ktx/context/dist/ingest/stages/validate-wu-sources.d.ts

@@ -1,9 +0,0 @@
-import type { SlValidationDeps, SlValidatorPort } from '@ktx/context/sl';
-import type { TouchedSlSource } from '../../tools/index.js';
-export interface WuValidationResult {
-    validSources: string[];
-    invalidSources: string[];
-}
-export declare function validateWuTouchedSources(deps: SlValidationDeps & {
-    slValidator: SlValidatorPort<SlValidationDeps>;
-}, touched: TouchedSlSource[]): Promise<WuValidationResult>;

package/node_modules/@ktx/context/dist/ingest/tools/tool-call-logger.d.ts

@@ -1,33 +0,0 @@
-import type { KtxRuntimeToolSet } from '../../llm/index.js';
-export interface ToolCallLogEntry {
-    ts: string;
-    wuKey: string;
-    toolCallId?: string;
-    toolName: string;
-    durationMs: number;
-    input: unknown;
-    output?: unknown;
-    error?: {
-        message: string;
-        name?: string;
-    };
-}
-interface ToolCallLoggerOptions {
-    onEntry?(entry: ToolCallLogEntry): void;
-}
-/**
- * Wrap every tool in `tools` so each invocation appends a JSONL record with
- * `{toolName, input, output | error, durationMs}` to `logFilePath`. Used by
- * the ingest runner to produce per-WU transcripts so a completed sync can be
- * inspected the way `parse_chat.py` inspects a chat.
- *
- * Tool shape is preserved (description, inputSchema, ...). Tools without an
- * `execute` function (provider-defined) pass through untouched.
- *
- * Log writes are best-effort and fire-and-forget; a failing write will never
- * block or error the agent. Tool execution inside a single agent loop is
- * sequential (`generateText` awaits each tool result), so per-WU files are
- * effectively single-writer and lines land in call order.
- */
-export declare function wrapToolsWithLogger<T extends KtxRuntimeToolSet>(tools: T, logFilePath: string, wuKey: string, options?: ToolCallLoggerOptions): T;
-export {};

package/node_modules/@ktx/context/dist/ingest/tools/verification-ledger.tool.d.ts

@@ -1,14 +0,0 @@
-import type { KtxRuntimeToolSet } from '../../llm/index.js';
-interface VerificationLedgerEntry {
-    summary: string;
-    verifiedIdentifiers: string[];
-    unverifiedIdentifiers: string[];
-    notes?: string;
-}
-export interface VerificationLedgerState {
-    entries: VerificationLedgerEntry[];
-}
-export declare const VERIFICATION_LEDGER_PROMPT = "<pre_write_verification>\nBefore any durable wiki, semantic-layer, or unmapped-fallback write (wiki_write, wiki_remove, sl_write_source, sl_edit_source, emit_unmapped_fallback), call record_verification_ledger.\nThe ledger is a model-authored checkpoint, not a deterministic parser gate. Summarize the verification protocol from the loaded skill, list identifiers verified with discover_data/entity_details/sql_execution, and list anything intentionally left unverified. If the write contains no warehouse identifiers, say that explicitly.\nIf a write tool returns verification_ledger_required, complete the ledger and retry the write.\n</pre_write_verification>";
-export declare function createVerificationLedgerState(): VerificationLedgerState;
-export declare function withVerificationLedger(tools: KtxRuntimeToolSet, state: VerificationLedgerState): KtxRuntimeToolSet;
-export {};

package/node_modules/@ktx/context/dist/ingest/tools/warehouse-verification/discover-data.tool.d.ts

@@ -1,36 +0,0 @@
-import { z } from 'zod';
-import { WarehouseCatalogService, type RawSchemaHit } from '../../../scan/warehouse-catalog.js';
-import { BaseTool, type ToolContext, type ToolOutput } from '../../../tools/index.js';
-declare const discoverDataInputSchema: z.ZodObject<{
-    query: z.ZodOptional<z.ZodString>;
-    connectionId: z.ZodOptional<z.ZodString>;
-    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    sourceName: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-type DiscoverDataInput = z.input<typeof discoverDataInputSchema>;
-export interface DiscoverDataStructured {
-    wiki: unknown | null;
-    sl: unknown | null;
-    raw: {
-        hits: RawSchemaHit[];
-    } | null;
-}
-interface DiscoverDataDeps {
-    wikiSearchTool: BaseTool;
-    slDiscoverTool: BaseTool;
-    catalogFactory: (context: ToolContext) => WarehouseCatalogService;
-}
-export declare class DiscoverDataTool extends BaseTool<typeof discoverDataInputSchema> {
-    private readonly deps;
-    readonly name = "discover_data";
-    constructor(deps: DiscoverDataDeps);
-    get description(): string;
-    get inputSchema(): z.ZodObject<{
-        query: z.ZodOptional<z.ZodString>;
-        connectionId: z.ZodOptional<z.ZodString>;
-        limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-        sourceName: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-    call(input: DiscoverDataInput, context: ToolContext): Promise<ToolOutput<DiscoverDataStructured>>;
-}
-export {};

package/node_modules/@ktx/context/dist/ingest/tools/warehouse-verification/discover-data.tool.js

@@ -1,94 +0,0 @@
-import { z } from 'zod';
-import { BaseTool } from '../../../tools/index.js';
-const discoverDataInputSchema = z.object({
-    query: z.string().optional(),
-    connectionId: z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/).optional(),
-    limit: z.number().int().positive().max(50).optional().default(10),
-    sourceName: z.string().optional(),
-}).strict();
-function totalFound(structured) {
-    return typeof structured === 'object' &&
-        structured !== null &&
-        'totalFound' in structured &&
-        typeof structured.totalFound === 'number'
-        ? structured.totalFound
-        : 0;
-}
-function totalSources(structured) {
-    return typeof structured === 'object' &&
-        structured !== null &&
-        'totalSources' in structured &&
-        typeof structured.totalSources === 'number'
-        ? structured.totalSources
-        : 0;
-}
-function allowedConnectionNames(context) {
-    return context.session?.allowedConnectionNames ?? null;
-}
-export class DiscoverDataTool extends BaseTool {
-    deps;
-    name = 'discover_data';
-    constructor(deps) {
-        super();
-        this.deps = deps;
-    }
-    get description() {
-        return 'Discover existing wiki pages, semantic layer sources, and raw warehouse schema hits before writing ingest output.';
-    }
-    get inputSchema() {
-        return discoverDataInputSchema;
-    }
-    async call(input, context) {
-        const allowed = allowedConnectionNames(context);
-        if (input.connectionId && allowed && !allowed.has(input.connectionId)) {
-            return {
-                markdown: `Connection "${input.connectionId}" is not available to this ingest stage.`,
-                structured: { wiki: null, sl: null, raw: null },
-            };
-        }
-        if (input.sourceName) {
-            const sl = await this.deps.slDiscoverTool.call({ sourceName: input.sourceName, connectionId: input.connectionId }, context);
-            return { markdown: sl.markdown, structured: { wiki: null, sl: sl.structured, raw: null } };
-        }
-        const query = input.query?.trim() || '';
-        const limit = input.limit ?? 10;
-        const parts = [];
-        let wiki = null;
-        let sl = null;
-        let raw = null;
-        if (query) {
-            const wikiResult = await this.deps.wikiSearchTool.call({ query, limit }, context);
-            if (totalFound(wikiResult.structured) > 0) {
-                parts.push('## Wiki Pages', '> use `wiki_read(blockKey)` for full content', wikiResult.markdown, '');
-                wiki = wikiResult.structured;
-            }
-        }
-        const slResult = await this.deps.slDiscoverTool.call({ query: query || undefined, connectionId: input.connectionId }, context);
-        if (totalSources(slResult.structured) > 0) {
-            parts.push('## Semantic Layer Sources', '> use `sl_read_source(sourceName)` for the YAML, or `entity_details` for warehouse-shape details', slResult.markdown, '');
-            sl = slResult.structured;
-        }
-        const catalog = this.deps.catalogFactory(context);
-        const connections = input.connectionId ? [input.connectionId] : [...(allowed ?? [])].sort();
-        const rawHits = [];
-        for (const connectionId of connections) {
-            rawHits.push(...(await catalog.searchByName(connectionId, query, limit)));
-        }
-        if (rawHits.length > 0) {
-            parts.push('## Raw Warehouse Schema', '> use `entity_details({connectionId, targets: [{display}]})` for full DDL + sample values');
-            parts.push(rawHits
-                .slice(0, limit)
-                .map((hit) => `- ${hit.kind}: ${hit.display} [connectionId=${hit.connectionId}] (matched on ${hit.matchedOn}) - ` +
-                `follow up with \`entity_details({connectionId: "${hit.connectionId}", targets: [{display: "${hit.display}"}]})\``)
-                .join('\n'));
-            raw = { hits: rawHits.slice(0, limit) };
-        }
-        if (parts.length === 0) {
-            return {
-                markdown: `No matches for "${query}" across wiki, semantic layer, or raw warehouse schema. Try broader terms; this concept may not exist yet.`,
-                structured: { wiki, sl, raw },
-            };
-        }
-        return { markdown: parts.join('\n'), structured: { wiki, sl, raw } };
-    }
-}

package/node_modules/@ktx/context/dist/ingest/tools/warehouse-verification/entity-details.tool.d.ts

@@ -1,43 +0,0 @@
-import { z } from 'zod';
-import type { KtxTableRef } from '../../../scan/types.js';
-import { WarehouseCatalogService, type TableDetail } from '../../../scan/warehouse-catalog.js';
-import { BaseTool, type ToolContext, type ToolOutput } from '../../../tools/index.js';
-declare const entityDetailsInputSchema: z.ZodObject<{
-    connectionId: z.ZodString;
-    targets: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        display: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        catalog: z.ZodNullable<z.ZodString>;
-        db: z.ZodNullable<z.ZodString>;
-        name: z.ZodString;
-        column: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>]>>;
-}, z.core.$strict>;
-type EntityDetailsInput = z.infer<typeof entityDetailsInputSchema>;
-export interface EntityDetailsStructured {
-    resolved: TableDetail[];
-    missing: Array<{
-        target: unknown;
-        candidates: KtxTableRef[];
-    }>;
-    scanAvailable: boolean;
-}
-export declare class EntityDetailsTool extends BaseTool<typeof entityDetailsInputSchema> {
-    private readonly catalogFactory;
-    readonly name = "entity_details";
-    constructor(catalogFactory: (context: ToolContext) => WarehouseCatalogService);
-    get description(): string;
-    get inputSchema(): z.ZodObject<{
-        connectionId: z.ZodString;
-        targets: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-            display: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
-            catalog: z.ZodNullable<z.ZodString>;
-            db: z.ZodNullable<z.ZodString>;
-            name: z.ZodString;
-            column: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>]>>;
-    }, z.core.$strict>;
-    call(input: EntityDetailsInput, context: ToolContext): Promise<ToolOutput<EntityDetailsStructured>>;
-}
-export {};

package/node_modules/@ktx/context/dist/ingest/tools/warehouse-verification/entity-details.tool.js

@@ -1,137 +0,0 @@
-import { z } from 'zod';
-import { BaseTool } from '../../../tools/index.js';
-const targetSchema = z.union([
-    z.object({ display: z.string().min(1) }),
-    z.object({
-        catalog: z.string().nullable(),
-        db: z.string().nullable(),
-        name: z.string().min(1),
-        column: z.string().optional(),
-    }),
-]);
-const entityDetailsInputSchema = z.object({
-    connectionId: z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/),
-    targets: z.array(targetSchema).min(1).max(50),
-}).strict();
-function allowedConnectionNames(context) {
-    return context.session?.allowedConnectionNames ?? null;
-}
-function targetLabel(target) {
-    if ('display' in target) {
-        return target.display;
-    }
-    return [target.catalog, target.db, target.name, target.column].filter((part) => !!part).join('.');
-}
-function appendMissingTargetMarkdown(parts, target, candidates) {
-    parts.push(`Not found in scan: ${targetLabel(target)}`);
-    if (candidates.length > 0) {
-        parts.push(`Closest matches: ${candidates.map((candidate) => candidate.name).join(', ')}`);
-    }
-}
-async function resolveTarget(catalog, connectionId, target) {
-    if ('display' in target) {
-        return catalog.resolveDisplayTarget(connectionId, target.display);
-    }
-    const candidateResolution = await catalog.resolveDisplayTarget(connectionId, targetLabel(target));
-    return {
-        resolved: {
-            catalog: target.catalog,
-            db: target.db,
-            name: target.name,
-            column: target.column,
-        },
-        candidates: candidateResolution.candidates,
-    };
-}
-function sampleText(values) {
-    return values.length > 0 ? ` - sample: ${JSON.stringify(values.slice(0, 10))}` : '';
-}
-function appendTableMarkdown(parts, detail, columnName) {
-    const columns = columnName ? detail.columns.filter((column) => column.name === columnName) : detail.columns;
-    parts.push(`### ${detail.display}`);
-    parts.push(`Type: ${detail.kind} | Native columns: ${detail.columns.length}`);
-    if (detail.description || detail.comment) {
-        parts.push(`Description: ${detail.description ?? detail.comment}`);
-    }
-    parts.push('', 'Columns:');
-    for (const column of columns) {
-        const pk = column.primaryKey ? ', PK' : '';
-        parts.push(`- ${column.name} (${column.nativeType}, nullable=${column.nullable}${pk})${sampleText(column.sampleValues)}`);
-    }
-    parts.push('');
-}
-function findColumn(detail, columnName) {
-    const normalized = columnName.toLowerCase();
-    return detail.columns.find((column) => column.name.toLowerCase() === normalized) ?? null;
-}
-export class EntityDetailsTool extends BaseTool {
-    catalogFactory;
-    name = 'entity_details';
-    constructor(catalogFactory) {
-        super();
-        this.catalogFactory = catalogFactory;
-    }
-    get description() {
-        return 'Verify warehouse tables and columns from the latest live-database scan before writing them into wiki or semantic-layer output.';
-    }
-    get inputSchema() {
-        return entityDetailsInputSchema;
-    }
-    async call(input, context) {
-        const allowed = allowedConnectionNames(context);
-        if (allowed && !allowed.has(input.connectionId)) {
-            return {
-                markdown: `Connection "${input.connectionId}" is not available to this ingest stage.`,
-                structured: { resolved: [], missing: [], scanAvailable: false },
-            };
-        }
-        const catalog = this.catalogFactory(context);
-        const scanAvailable = await catalog.hasScan(input.connectionId);
-        if (!scanAvailable) {
-            return {
-                markdown: `No live-database scan available for connection "${input.connectionId}"; run \`ktx scan\` first.`,
-                structured: { resolved: [], missing: [], scanAvailable: false },
-            };
-        }
-        const parts = [];
-        const resolved = [];
-        const missing = [];
-        for (const target of input.targets) {
-            const resolution = await resolveTarget(catalog, input.connectionId, target);
-            if (!resolution.resolved) {
-                missing.push({ target, candidates: resolution.candidates });
-                appendMissingTargetMarkdown(parts, target, resolution.candidates);
-                continue;
-            }
-            const detail = await catalog.getTable({ connectionId: input.connectionId, ...resolution.resolved });
-            if (!detail) {
-                missing.push({ target, candidates: resolution.candidates });
-                appendMissingTargetMarkdown(parts, target, resolution.candidates);
-                continue;
-            }
-            const requestedColumn = resolution.resolved.column;
-            if (requestedColumn) {
-                const column = findColumn(detail, requestedColumn);
-                if (!column) {
-                    missing.push({
-                        target,
-                        candidates: [{ catalog: detail.catalog, db: detail.db, name: detail.name }],
-                    });
-                    parts.push(`Column not found in scan: ${detail.display}.${requestedColumn}`);
-                    parts.push(`Available columns: ${detail.columns.map((candidate) => candidate.name).join(', ')}`);
-                    continue;
-                }
-                const scopedDetail = { ...detail, columns: [column] };
-                resolved.push(scopedDetail);
-                appendTableMarkdown(parts, scopedDetail, column.name);
-                continue;
-            }
-            resolved.push(detail);
-            appendTableMarkdown(parts, detail);
-        }
-        return {
-            markdown: parts.join('\n').trim(),
-            structured: { resolved, missing, scanAvailable: true },
-        };
-    }
-}