@kaelio/ktx 0.0.0 → 0.1.0-rc.0

package/node_modules/@ktx/context/dist/sl/sqlite-sl-sources-index.js

@@ -0,0 +1,407 @@
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import Database from 'better-sqlite3';
+function candidateId(connectionId, sourceName) {
+    return `${connectionId}/${sourceName}`;
+}
+function cosineSimilarity(left, right) {
+    if (left.length === 0 || left.length !== right.length) {
+        return 0;
+    }
+    let dot = 0;
+    let leftNorm = 0;
+    let rightNorm = 0;
+    for (let i = 0; i < left.length; i++) {
+        const l = left[i] ?? 0;
+        const r = right[i] ?? 0;
+        dot += l * r;
+        leftNorm += l * l;
+        rightNorm += r * r;
+    }
+    if (leftNorm === 0 || rightNorm === 0) {
+        return 0;
+    }
+    return dot / (Math.sqrt(leftNorm) * Math.sqrt(rightNorm));
+}
+function normalizeFtsQuery(query) {
+    const terms = query
+        .toLowerCase()
+        .split(/[^a-z0-9_]+/u)
+        .map((term) => term.trim())
+        .filter(Boolean);
+    return [...new Set(terms)].map((term) => `"${term.replaceAll('"', '""')}"`).join(' OR ');
+}
+function scoreFromRank(rank) {
+    return Number((1 / (1 + Math.abs(rank))).toFixed(6));
+}
+export class SqliteSlSourcesIndex {
+    db;
+    constructor(options) {
+        mkdirSync(dirname(options.dbPath), { recursive: true });
+        this.db = new Database(options.dbPath);
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('foreign_keys = ON');
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS local_sl_sources (
+        connection_id TEXT NOT NULL,
+        source_name TEXT NOT NULL,
+        search_text TEXT NOT NULL,
+        embedding_json TEXT,
+        content_hash TEXT,
+        updated_at TEXT NOT NULL,
+        PRIMARY KEY (connection_id, source_name)
+      );
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS local_sl_sources_fts USING fts5(
+        connection_id UNINDEXED,
+        source_name UNINDEXED,
+        search_text
+      );
+
+      CREATE TABLE IF NOT EXISTS local_sl_dictionary_values (
+        connection_id TEXT NOT NULL,
+        source_name TEXT NOT NULL,
+        column_name TEXT NOT NULL,
+        value TEXT NOT NULL,
+        value_lower TEXT NOT NULL,
+        cardinality INTEGER,
+        updated_at TEXT NOT NULL,
+        PRIMARY KEY (connection_id, source_name, column_name, value)
+      );
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS local_sl_dictionary_values_fts USING fts5(
+        connection_id UNINDEXED,
+        source_name UNINDEXED,
+        column_name UNINDEXED,
+        value
+      );
+    `);
+    }
+    async upsertSources(connectionId, sources) {
+        if (sources.length === 0) {
+            return;
+        }
+        const upsertRow = this.db.prepare(`
+      INSERT INTO local_sl_sources (
+        connection_id,
+        source_name,
+        search_text,
+        embedding_json,
+        content_hash,
+        updated_at
+      )
+      VALUES (
+        @connectionId,
+        @sourceName,
+        @searchText,
+        @embeddingJson,
+        @contentHash,
+        @updatedAt
+      )
+      ON CONFLICT(connection_id, source_name) DO UPDATE SET
+        search_text = excluded.search_text,
+        embedding_json = excluded.embedding_json,
+        content_hash = COALESCE(excluded.content_hash, local_sl_sources.content_hash),
+        updated_at = excluded.updated_at
+    `);
+        const deleteFts = this.db.prepare(`
+      DELETE FROM local_sl_sources_fts
+      WHERE connection_id = @connectionId
+        AND source_name = @sourceName
+    `);
+        const insertFts = this.db.prepare(`
+      INSERT INTO local_sl_sources_fts (connection_id, source_name, search_text)
+      VALUES (@connectionId, @sourceName, @searchText)
+    `);
+        const transaction = this.db.transaction((rows) => {
+            const updatedAt = new Date().toISOString();
+            for (const source of rows) {
+                const row = {
+                    connectionId,
+                    sourceName: source.sourceName,
+                    searchText: source.searchText,
+                    embeddingJson: source.embedding ? JSON.stringify(source.embedding) : null,
+                    contentHash: source.contentHash ?? null,
+                    updatedAt,
+                };
+                upsertRow.run(row);
+                deleteFts.run(row);
+                insertFts.run(row);
+            }
+        });
+        transaction(sources);
+    }
+    async getExistingSearchTexts(connectionId) {
+        const rows = this.db
+            .prepare(`
+        SELECT source_name, search_text, embedding_json
+        FROM local_sl_sources
+        WHERE connection_id = ?
+        ORDER BY source_name ASC
+      `)
+            .all(connectionId);
+        return new Map(rows.map((row) => [row.source_name, { searchText: row.search_text, hasEmbedding: row.embedding_json !== null }]));
+    }
+    async deleteStale(connectionId, keepNames) {
+        if (keepNames.length === 0) {
+            await this.deleteByConnection(connectionId);
+            return;
+        }
+        const placeholders = keepNames.map(() => '?').join(', ');
+        const stale = this.db
+            .prepare(`
+        SELECT source_name
+        FROM local_sl_sources
+        WHERE connection_id = ?
+          AND source_name NOT IN (${placeholders})
+      `)
+            .all(connectionId, ...keepNames);
+        const deleteFts = this.db.prepare(`
+      DELETE FROM local_sl_sources_fts
+      WHERE connection_id = ?
+        AND source_name = ?
+    `);
+        const deleteRow = this.db.prepare(`
+      DELETE FROM local_sl_sources
+      WHERE connection_id = ?
+        AND source_name = ?
+    `);
+        const remove = this.db.transaction((sourceNames) => {
+            for (const sourceName of sourceNames) {
+                deleteFts.run(connectionId, sourceName);
+                deleteRow.run(connectionId, sourceName);
+            }
+        });
+        remove(stale.map((row) => row.source_name));
+    }
+    async deleteByConnection(connectionId) {
+        const remove = this.db.transaction(() => {
+            this.db.prepare('DELETE FROM local_sl_sources_fts WHERE connection_id = ?').run(connectionId);
+            this.db.prepare('DELETE FROM local_sl_sources WHERE connection_id = ?').run(connectionId);
+        });
+        remove();
+    }
+    async deleteByConnectionAndName(connectionId, sourceName) {
+        this.deleteByConnectionAndNameSync(connectionId, sourceName);
+    }
+    async replaceDictionaryEntries(connectionId, entries) {
+        const remove = this.db.transaction(() => {
+            this.db.prepare('DELETE FROM local_sl_dictionary_values_fts WHERE connection_id = ?').run(connectionId);
+            this.db.prepare('DELETE FROM local_sl_dictionary_values WHERE connection_id = ?').run(connectionId);
+        });
+        const insertRow = this.db.prepare(`
+      INSERT INTO local_sl_dictionary_values (
+        connection_id,
+        source_name,
+        column_name,
+        value,
+        value_lower,
+        cardinality,
+        updated_at
+      )
+      VALUES (
+        @connectionId,
+        @sourceName,
+        @columnName,
+        @value,
+        @valueLower,
+        @cardinality,
+        @updatedAt
+      )
+    `);
+        const insertFts = this.db.prepare(`
+      INSERT INTO local_sl_dictionary_values_fts (connection_id, source_name, column_name, value)
+      VALUES (@connectionId, @sourceName, @columnName, @value)
+    `);
+        const write = this.db.transaction((rows) => {
+            const updatedAt = new Date().toISOString();
+            for (const entry of rows.filter((candidate) => candidate.connectionId === connectionId)) {
+                const row = {
+                    connectionId: entry.connectionId,
+                    sourceName: entry.sourceName,
+                    columnName: entry.columnName,
+                    value: entry.value,
+                    valueLower: entry.value.toLowerCase(),
+                    cardinality: entry.cardinality,
+                    updatedAt,
+                };
+                insertRow.run(row);
+                insertFts.run(row);
+            }
+        });
+        remove();
+        write(entries);
+    }
+    async searchLexicalCandidates(input) {
+        const ftsQuery = normalizeFtsQuery(input.queryText);
+        if (!ftsQuery) {
+            return [];
+        }
+        const connectionIds = [...new Set(input.connectionIds ?? [])].sort();
+        const connectionPredicate = connectionIds.length > 0 ? `AND connection_id IN (${connectionIds.map(() => '?').join(', ')})` : '';
+        const rows = this.db
+            .prepare(`
+        SELECT connection_id, source_name, bm25(local_sl_sources_fts) AS rank
+        FROM local_sl_sources_fts
+        WHERE local_sl_sources_fts MATCH ?
+          ${connectionPredicate}
+        ORDER BY rank ASC, connection_id ASC, source_name ASC
+        LIMIT ?
+      `)
+            .all(ftsQuery, ...connectionIds, Math.max(1, input.limit));
+        return rows.map((row, index) => ({
+            id: candidateId(row.connection_id, row.source_name),
+            connectionId: row.connection_id,
+            sourceName: row.source_name,
+            rank: index + 1,
+            rawScore: Number(row.rank),
+        }));
+    }
+    async searchSemanticCandidates(input) {
+        const connectionIds = [...new Set(input.connectionIds ?? [])].sort();
+        const connectionPredicate = connectionIds.length > 0 ? `WHERE connection_id IN (${connectionIds.map(() => '?').join(', ')})` : '';
+        const rows = this.db
+            .prepare(`
+        SELECT connection_id, source_name, embedding_json
+        FROM local_sl_sources
+        ${connectionPredicate}
+        ORDER BY connection_id ASC, source_name ASC
+      `)
+            .all(...connectionIds);
+        return rows
+            .flatMap((row) => {
+            if (!row.embedding_json) {
+                return [];
+            }
+            try {
+                const embedding = JSON.parse(row.embedding_json);
+                if (!Array.isArray(embedding) || !embedding.every((value) => typeof value === 'number')) {
+                    return [];
+                }
+                return [
+                    {
+                        id: candidateId(row.connection_id, row.source_name),
+                        connectionId: row.connection_id,
+                        sourceName: row.source_name,
+                        rank: 0,
+                        rawScore: cosineSimilarity(input.queryEmbedding, embedding),
+                    },
+                ];
+            }
+            catch {
+                return [];
+            }
+        })
+            .sort((left, right) => right.rawScore - left.rawScore ||
+            left.connectionId.localeCompare(right.connectionId) ||
+            left.sourceName.localeCompare(right.sourceName))
+            .slice(0, Math.max(1, input.limit))
+            .map((candidate, index) => ({ ...candidate, rank: index + 1 }));
+    }
+    async searchDictionaryCandidates(input) {
+        const ftsQuery = normalizeFtsQuery(input.queryText);
+        const normalizedQuery = input.queryText.trim().toLowerCase();
+        if (!ftsQuery && !normalizedQuery) {
+            return [];
+        }
+        const connectionIds = [...new Set(input.connectionIds ?? [])].sort();
+        const connectionPredicate = connectionIds.length > 0 ? `AND connection_id IN (${connectionIds.map(() => '?').join(', ')})` : '';
+        const ftsRows = ftsQuery
+            ? this.db
+                .prepare(`
+            SELECT connection_id, source_name, column_name, value, bm25(local_sl_dictionary_values_fts) AS rank
+            FROM local_sl_dictionary_values_fts
+            WHERE local_sl_dictionary_values_fts MATCH ?
+              ${connectionPredicate}
+            ORDER BY rank ASC, connection_id ASC, source_name ASC, column_name ASC, value ASC
+            LIMIT ?
+          `)
+                .all(ftsQuery, ...connectionIds, Math.max(25, input.limit * 4))
+            : [];
+        const substringRows = normalizedQuery
+            ? this.db
+                .prepare(`
+            SELECT connection_id, source_name, column_name, value, NULL AS rank
+            FROM local_sl_dictionary_values
+            WHERE value_lower LIKE ?
+              ${connectionPredicate}
+            ORDER BY connection_id ASC, source_name ASC, column_name ASC, value ASC
+            LIMIT ?
+          `)
+                .all(`%${normalizedQuery}%`, ...connectionIds, Math.max(25, input.limit * 4))
+            : [];
+        const rowsByKey = new Map();
+        for (const row of [...ftsRows, ...substringRows]) {
+            const key = `${row.connection_id}/${row.source_name}/${row.column_name}/${row.value}`;
+            if (!rowsByKey.has(key)) {
+                rowsByKey.set(key, row);
+            }
+        }
+        const grouped = new Map();
+        for (const row of rowsByKey.values()) {
+            const key = candidateId(row.connection_id, row.source_name);
+            grouped.set(key, [...(grouped.get(key) ?? []), row]);
+        }
+        return [...grouped.entries()]
+            .map(([id, rows]) => {
+            const [first] = rows;
+            const byColumn = new Map();
+            for (const row of rows.sort((left, right) => left.column_name.localeCompare(right.column_name) || left.value.localeCompare(right.value))) {
+                byColumn.set(row.column_name, [...(byColumn.get(row.column_name) ?? []), row.value]);
+            }
+            const matches = [...byColumn.entries()].map(([column, values]) => ({ column, values: values.slice(0, 5) }));
+            return {
+                id,
+                connectionId: first?.connection_id ?? '',
+                sourceName: first?.source_name ?? '',
+                rank: 0,
+                rawScore: matches.reduce((total, match) => total + match.values.length, 0),
+                matches,
+            };
+        })
+            .sort((left, right) => right.rawScore - left.rawScore ||
+            right.matches.length - left.matches.length ||
+            left.connectionId.localeCompare(right.connectionId) ||
+            left.sourceName.localeCompare(right.sourceName))
+            .slice(0, Math.max(1, input.limit))
+            .map((candidate, index) => ({ ...candidate, rank: index + 1 }));
+    }
+    async search(connectionId, _queryEmbedding, queryText, limit, minRrfScore = 0) {
+        const ftsQuery = normalizeFtsQuery(queryText);
+        if (!ftsQuery) {
+            return [];
+        }
+        const rows = this.db
+            .prepare(`
+        SELECT source_name, bm25(local_sl_sources_fts) AS rank
+        FROM local_sl_sources_fts
+        WHERE connection_id = ?
+          AND local_sl_sources_fts MATCH ?
+        ORDER BY rank ASC, source_name ASC
+        LIMIT ?
+      `)
+            .all(connectionId, ftsQuery, Math.max(1, limit));
+        return rows
+            .map((row) => ({ sourceName: row.source_name, rrfScore: scoreFromRank(row.rank) }))
+            .filter((row) => row.rrfScore >= minRrfScore);
+    }
+    deleteByConnectionAndNameSync(connectionId, sourceName) {
+        const remove = this.db.transaction(() => {
+            this.db
+                .prepare(`
+          DELETE FROM local_sl_sources_fts
+          WHERE connection_id = ?
+            AND source_name = ?
+        `)
+                .run(connectionId, sourceName);
+            this.db
+                .prepare(`
+          DELETE FROM local_sl_sources
+          WHERE connection_id = ?
+            AND source_name = ?
+        `)
+                .run(connectionId, sourceName);
+        });
+        remove();
+    }
+}

package/node_modules/@ktx/context/dist/sl/sqlite-sl-sources-index.test.d.ts

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

package/node_modules/@ktx/context/dist/sl/sqlite-sl-sources-index.test.js

@@ -0,0 +1,139 @@
+import { access, mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { SqliteSlSourcesIndex } from './sqlite-sl-sources-index.js';
+describe('SqliteSlSourcesIndex', () => {
+    let tempDir;
+    let dbPath;
+    beforeEach(async () => {
+        tempDir = await mkdtemp(join(tmpdir(), 'ktx-sqlite-sl-index-'));
+        dbPath = join(tempDir, 'db.sqlite');
+    });
+    afterEach(async () => {
+        await rm(tempDir, { recursive: true, force: true });
+    });
+    it('creates SQLite tables and searches indexed source text', async () => {
+        const index = new SqliteSlSourcesIndex({ dbPath });
+        await index.upsertSources('warehouse', [
+            {
+                sourceName: 'orders',
+                searchText: 'orders table: public.orders measure: total_revenue sum(revenue) gross revenue',
+                embedding: null,
+            },
+            {
+                sourceName: 'tickets',
+                searchText: 'tickets table: public.tickets measure: ticket_count count(*) support queue',
+                embedding: null,
+            },
+        ]);
+        await expect(access(dbPath)).resolves.toBeUndefined();
+        expect(await index.search('warehouse', null, 'gross revenue', 10)).toEqual([
+            expect.objectContaining({
+                sourceName: 'orders',
+                rrfScore: expect.any(Number),
+            }),
+        ]);
+    });
+    it('reports existing search text and embedding presence', async () => {
+        const index = new SqliteSlSourcesIndex({ dbPath });
+        await index.upsertSources('warehouse', [
+            {
+                sourceName: 'orders',
+                searchText: 'orders gross revenue',
+                embedding: [0.1, 0.2, 0.3],
+            },
+            {
+                sourceName: 'tickets',
+                searchText: 'tickets support queue',
+                embedding: null,
+            },
+        ]);
+        await expect(index.getExistingSearchTexts('warehouse')).resolves.toEqual(new Map([
+            ['orders', { searchText: 'orders gross revenue', hasEmbedding: true }],
+            ['tickets', { searchText: 'tickets support queue', hasEmbedding: false }],
+        ]));
+    });
+    it('deletes stale, named, and connection-scoped rows from the FTS index', async () => {
+        const index = new SqliteSlSourcesIndex({ dbPath });
+        await index.upsertSources('warehouse', [
+            { sourceName: 'orders', searchText: 'orders revenue', embedding: null },
+            { sourceName: 'tickets', searchText: 'tickets support', embedding: null },
+        ]);
+        await index.upsertSources('finance', [{ sourceName: 'invoices', searchText: 'invoices revenue', embedding: null }]);
+        await index.deleteStale('warehouse', ['orders']);
+        expect(await index.search('warehouse', null, 'support', 10)).toEqual([]);
+        expect(await index.search('warehouse', null, 'revenue', 10)).toEqual([
+            expect.objectContaining({ sourceName: 'orders' }),
+        ]);
+        expect(await index.search('finance', null, 'revenue', 10)).toEqual([
+            expect.objectContaining({ sourceName: 'invoices' }),
+        ]);
+        await index.deleteByConnectionAndName('warehouse', 'orders');
+        expect(await index.search('warehouse', null, 'revenue', 10)).toEqual([]);
+        await index.deleteByConnection('finance');
+        expect(await index.search('finance', null, 'revenue', 10)).toEqual([]);
+    });
+    it('returns lane candidates with stable connection-scoped IDs', async () => {
+        const index = new SqliteSlSourcesIndex({ dbPath });
+        await index.upsertSources('warehouse', [
+            { sourceName: 'orders', searchText: 'orders gross revenue paid status', embedding: [1, 0] },
+        ]);
+        await index.upsertSources('finance', [
+            { sourceName: 'orders', searchText: 'finance orders invoices', embedding: [0, 1] },
+        ]);
+        await expect(index.searchLexicalCandidates({ queryText: 'gross revenue', limit: 25 })).resolves.toEqual([
+            expect.objectContaining({
+                id: 'warehouse/orders',
+                connectionId: 'warehouse',
+                sourceName: 'orders',
+                rank: 1,
+                rawScore: expect.any(Number),
+            }),
+        ]);
+        await expect(index.searchSemanticCandidates({ queryEmbedding: [0, 1], limit: 25 })).resolves.toEqual([
+            expect.objectContaining({ id: 'finance/orders', connectionId: 'finance', sourceName: 'orders', rank: 1 }),
+            expect.objectContaining({ id: 'warehouse/orders', connectionId: 'warehouse', sourceName: 'orders', rank: 2 }),
+        ]);
+    });
+    it('aggregates dictionary matches to one source-level lane candidate', async () => {
+        const index = new SqliteSlSourcesIndex({ dbPath });
+        await index.replaceDictionaryEntries('warehouse', [
+            { connectionId: 'warehouse', sourceName: 'orders', columnName: 'status', value: 'paid', cardinality: 3 },
+            { connectionId: 'warehouse', sourceName: 'orders', columnName: 'status', value: 'refunded', cardinality: 3 },
+            { connectionId: 'warehouse', sourceName: 'orders', columnName: 'channel', value: 'paid search', cardinality: 4 },
+            {
+                connectionId: 'warehouse',
+                sourceName: 'tickets',
+                columnName: 'priority',
+                value: 'paid support',
+                cardinality: 5,
+            },
+        ]);
+        await expect(index.searchDictionaryCandidates({ queryText: 'paid', limit: 25 })).resolves.toEqual([
+            expect.objectContaining({
+                id: 'warehouse/orders',
+                connectionId: 'warehouse',
+                sourceName: 'orders',
+                rank: 1,
+                matches: [
+                    { column: 'channel', values: ['paid search'] },
+                    { column: 'status', values: ['paid'] },
+                ],
+            }),
+            expect.objectContaining({
+                id: 'warehouse/tickets',
+                connectionId: 'warehouse',
+                sourceName: 'tickets',
+                rank: 2,
+                matches: [{ column: 'priority', values: ['paid support'] }],
+            }),
+        ]);
+    });
+    it('returns an empty result for blank or punctuation-only queries', async () => {
+        const index = new SqliteSlSourcesIndex({ dbPath });
+        await index.upsertSources('warehouse', [{ sourceName: 'orders', searchText: 'orders revenue', embedding: null }]);
+        expect(await index.search('warehouse', null, '   ', 10)).toEqual([]);
+        expect(await index.search('warehouse', null, '---', 10)).toEqual([]);
+    });
+});

package/node_modules/@ktx/context/dist/sl/tools/base-semantic-layer.tool.d.ts

@@ -0,0 +1,45 @@
+import type { ZodType } from 'zod';
+import type { GitAuthorResolverPort, ToolContext, ToolOutput } from '../../tools/index.js';
+import { BaseTool } from '../../tools/index.js';
+import { sourceDefinitionSchema } from '../schemas.js';
+import { SemanticLayerService } from '../semantic-layer.service.js';
+import { SlSearchService } from '../sl-search.service.js';
+export { sourceDefinitionSchema };
+export interface SemanticLayerStructured {
+    success: boolean;
+    sourceName: string;
+    yaml?: string;
+    commitHash?: string;
+    errors?: string[];
+    validationErrors?: string[];
+    validationWarnings?: string[];
+    actionRequiredWarnings?: string[];
+}
+export interface BaseSemanticLayerToolDeps {
+    semanticLayerService: SemanticLayerService;
+    slSearchService: SlSearchService;
+    authorResolver: GitAuthorResolverPort;
+}
+export declare abstract class BaseSemanticLayerTool<TInput extends ZodType = ZodType> extends BaseTool<TInput> {
+    protected readonly semanticLayerService: SemanticLayerService;
+    protected readonly slSearchService: SlSearchService;
+    protected readonly authorResolver: GitAuthorResolverPort;
+    constructor(deps: BaseSemanticLayerToolDeps);
+    protected readSourceYaml(connectionId: string, sourceName: string, context?: ToolContext): Promise<string | null>;
+    protected buildMarkdown(success: boolean, errors: string[], sourceName: string, extra?: {
+        yaml?: string;
+        commitHash?: string;
+        validationErrors?: string[];
+        validationWarnings?: string[];
+        actionRequiredWarnings?: string[];
+        editCount?: number;
+    }): string;
+    protected buildOutput(success: boolean, errors: string[], sourceName: string, extra?: {
+        yaml?: string;
+        commitHash?: string;
+        validationErrors?: string[];
+        validationWarnings?: string[];
+        actionRequiredWarnings?: string[];
+        editCount?: number;
+    }): ToolOutput<SemanticLayerStructured>;
+}

package/node_modules/@ktx/context/dist/sl/tools/base-semantic-layer.tool.js

@@ -0,0 +1,91 @@
+import { BaseTool } from '../../tools/index.js';
+import { sourceDefinitionSchema } from '../schemas.js';
+export { sourceDefinitionSchema };
+// ── Abstract base class ──
+export class BaseSemanticLayerTool extends BaseTool {
+    semanticLayerService;
+    slSearchService;
+    authorResolver;
+    constructor(deps) {
+        super();
+        this.semanticLayerService = deps.semanticLayerService;
+        this.slSearchService = deps.slSearchService;
+        this.authorResolver = deps.authorResolver;
+    }
+    async readSourceYaml(connectionId, sourceName, context) {
+        const semanticLayerService = context?.session?.semanticLayerService ?? this.semanticLayerService;
+        try {
+            const { content } = await semanticLayerService.readSourceFile(connectionId, sourceName);
+            return content;
+        }
+        catch {
+            return null;
+        }
+    }
+    buildMarkdown(success, errors, sourceName, extra) {
+        const parts = [];
+        if (success) {
+            const verb = extra?.editCount != null ? `applied ${extra.editCount} edit(s) to` : 'saved';
+            parts.push(`Source **${sourceName}** ${verb} successfully.`);
+        }
+        else {
+            parts.push(`Source **${sourceName}** update completed with ${errors.length} error(s):`);
+            for (const err of errors) {
+                parts.push(`- ${err}`);
+            }
+        }
+        if (extra?.commitHash) {
+            parts.push(`Commit: \`${extra.commitHash}\``);
+        }
+        if (extra?.actionRequiredWarnings && extra.actionRequiredWarnings.length > 0) {
+            parts.push('\n**Action required:**');
+            for (const warning of extra.actionRequiredWarnings) {
+                parts.push(`- ${warning}`);
+            }
+        }
+        if (extra?.validationErrors && extra.validationErrors.length > 0) {
+            parts.push('\n**Validation errors:**');
+            for (const ve of extra.validationErrors) {
+                parts.push(`- ${ve}`);
+            }
+        }
+        if (extra?.validationWarnings && extra.validationWarnings.length > 0) {
+            parts.push('\n**Validation warnings:**');
+            for (const vw of extra.validationWarnings) {
+                parts.push(`- ${vw}`);
+            }
+        }
+        if (extra?.yaml) {
+            const yaml = extra.yaml;
+            const MAX_YAML = 2000;
+            if (yaml.length > MAX_YAML) {
+                parts.push(`\n**YAML** (${yaml.length} chars, truncated):\n\`\`\`yaml\n${yaml.slice(0, MAX_YAML)}...\n\`\`\``);
+            }
+            else {
+                parts.push(`\n**YAML**:\n\`\`\`yaml\n${yaml}\n\`\`\``);
+            }
+        }
+        return parts.join('\n');
+    }
+    buildOutput(success, errors, sourceName, extra) {
+        return {
+            markdown: this.buildMarkdown(success, errors, sourceName, extra),
+            structured: {
+                success,
+                sourceName,
+                yaml: extra?.yaml,
+                commitHash: extra?.commitHash,
+                ...(errors.length > 0 ? { errors } : {}),
+                ...(extra?.validationErrors && extra.validationErrors.length > 0
+                    ? { validationErrors: extra.validationErrors }
+                    : {}),
+                ...(extra?.validationWarnings && extra.validationWarnings.length > 0
+                    ? { validationWarnings: extra.validationWarnings }
+                    : {}),
+                ...(extra?.actionRequiredWarnings && extra.actionRequiredWarnings.length > 0
+                    ? { actionRequiredWarnings: extra.actionRequiredWarnings }
+                    : {}),
+            },
+        };
+    }
+}

package/node_modules/@ktx/context/dist/sl/tools/connection-id-schema.d.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export declare const slToolConnectionIdSchema: z.ZodString;