@kaelio/ktx 0.1.0 → 0.2.0

package/node_modules/@ktx/context/dist/sl/sl-search.service.test.js

@@ -192,4 +192,65 @@ describe('SlSearchService', () => {
             },
         ]);
     });
+    it('indexSources reports stats and supports lexical-only indexing', async () => {
+        const repository = {
+            upsertSources: vi.fn().mockResolvedValue(undefined),
+            getExistingSearchTexts: vi.fn().mockResolvedValue(new Map([
+                ['old_source', { searchText: 'old source', hasEmbedding: true }],
+            ])),
+            deleteStale: vi.fn().mockResolvedValue(1),
+            deleteByConnection: vi.fn().mockResolvedValue(0),
+            deleteByConnectionAndName: vi.fn(),
+            search: vi.fn(),
+        };
+        const service = new SlSearchService(null, repository);
+        const source = {
+            name: 'orders',
+            table: 'public.orders',
+            grain: ['id'],
+            columns: [{ name: 'id', type: 'number' }],
+            joins: [],
+            measures: [],
+        };
+        await expect(service.indexSources('warehouse', [source])).resolves.toEqual({
+            scanned: 1,
+            updated: 1,
+            deleted: 1,
+            embeddingsRecomputed: 0,
+            embeddingsFailed: 0,
+        });
+        expect(repository.upsertSources).toHaveBeenCalledWith('warehouse', [
+            expect.objectContaining({ sourceName: 'orders', embedding: null }),
+        ]);
+    });
+    it('does not update unchanged lexical-only SL rows on repeated sync', async () => {
+        const repository = {
+            upsertSources: vi.fn().mockResolvedValue(undefined),
+            getExistingSearchTexts: vi.fn().mockResolvedValue(new Map([
+                ['orders', { searchText: 'orders. table: public.orders. id (number)', hasEmbedding: false }],
+            ])),
+            deleteStale: vi.fn().mockResolvedValue(0),
+            deleteByConnection: vi.fn().mockResolvedValue(0),
+            deleteByConnectionAndName: vi.fn(),
+            search: vi.fn(),
+        };
+        const service = new SlSearchService(null, repository);
+        const source = {
+            name: 'orders',
+            table: 'public.orders',
+            grain: ['id'],
+            columns: [{ name: 'id', type: 'number' }],
+            joins: [],
+            measures: [],
+        };
+        await expect(service.indexSources('warehouse', [source])).resolves.toEqual({
+            scanned: 1,
+            updated: 0,
+            deleted: 0,
+            embeddingsRecomputed: 0,
+            embeddingsFailed: 0,
+        });
+        expect(repository.upsertSources).toHaveBeenCalledWith('warehouse', []);
+        expect(repository.deleteStale).toHaveBeenCalledWith('warehouse', ['orders']);
+    });
 });

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

@@ -28,9 +28,10 @@ export declare class SqliteSlSourcesIndex implements SlSourcesIndexPort {
         searchText: string;
         hasEmbedding: boolean;
     }>>;
-    deleteStale(connectionId: string, keepNames: string[]): Promise<void>;
-    deleteByConnection(connectionId: string): Promise<void>;
-    deleteByConnectionAndName(connectionId: string, sourceName: string): Promise<void>;
+    deleteStale(connectionId: string, keepNames: string[]): Promise<number>;
+    deleteByConnection(connectionId: string): Promise<number>;
+    clear(connectionId: string): Promise<number>;
+    deleteByConnectionAndName(connectionId: string, sourceName: string): Promise<number>;
     replaceDictionaryEntries(connectionId: string, entries: SlDictionaryEntry[]): Promise<void>;
     searchLexicalCandidates(input: {
         connectionIds?: readonly string[];

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

@@ -144,8 +144,7 @@ export class SqliteSlSourcesIndex {
     }
     async deleteStale(connectionId, keepNames) {
         if (keepNames.length === 0) {
-            await this.deleteByConnection(connectionId);
-            return;
+            return this.deleteByConnection(connectionId);
         }
         const placeholders = keepNames.map(() => '?').join(', ');
         const stale = this.db
@@ -173,16 +172,26 @@ export class SqliteSlSourcesIndex {
             }
         });
         remove(stale.map((row) => row.source_name));
+        return stale.length;
     }
     async deleteByConnection(connectionId) {
+        return this.clear(connectionId);
+    }
+    async clear(connectionId) {
+        const rows = this.db
+            .prepare('SELECT source_name FROM local_sl_sources WHERE connection_id = ?')
+            .all(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);
+            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);
         });
         remove();
+        return rows.length;
     }
     async deleteByConnectionAndName(connectionId, sourceName) {
-        this.deleteByConnectionAndNameSync(connectionId, sourceName);
+        return this.deleteByConnectionAndNameSync(connectionId, sourceName);
     }
     async replaceDictionaryEntries(connectionId, entries) {
         const remove = this.db.transaction(() => {
@@ -406,14 +415,15 @@ export class SqliteSlSourcesIndex {
             AND source_name = ?
         `)
                 .run(connectionId, sourceName);
-            this.db
+            const result = this.db
                 .prepare(`
           DELETE FROM local_sl_sources
           WHERE connection_id = ?
             AND source_name = ?
         `)
                 .run(connectionId, sourceName);
+            return Number(result.changes);
         });
-        remove();
+        return remove();
     }
 }

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

@@ -86,6 +86,30 @@ describe('SqliteSlSourcesIndex', () => {
         await index.deleteByConnection('finance');
         expect(await index.search('finance', null, 'revenue', 10)).toEqual([]);
     });
+    it('clear removes sources and dictionary rows for one connection only', async () => {
+        const index = new SqliteSlSourcesIndex({ dbPath });
+        await index.upsertSources('warehouse', [
+            { sourceName: 'orders', searchText: 'orders revenue paid', embedding: null },
+        ]);
+        await index.upsertSources('finance', [
+            { sourceName: 'invoices', searchText: 'invoices revenue paid', embedding: null },
+        ]);
+        await index.replaceDictionaryEntries('warehouse', [
+            { connectionId: 'warehouse', sourceName: 'orders', columnName: 'status', value: 'paid', cardinality: 1 },
+        ]);
+        await index.replaceDictionaryEntries('finance', [
+            { connectionId: 'finance', sourceName: 'invoices', columnName: 'status', value: 'paid', cardinality: 1 },
+        ]);
+        await expect(index.clear('warehouse')).resolves.toBe(1);
+        expect(await index.search('warehouse', null, 'revenue', 10)).toEqual([]);
+        expect(await index.search('finance', null, 'revenue', 10)).toEqual([
+            expect.objectContaining({ sourceName: 'invoices' }),
+        ]);
+        await expect(index.searchDictionaryCandidates({ connectionIds: ['warehouse'], queryText: 'paid', limit: 10 }))
+            .resolves.toEqual([]);
+        await expect(index.searchDictionaryCandidates({ connectionIds: ['finance'], queryText: 'paid', limit: 10 }))
+            .resolves.toEqual([expect.objectContaining({ connectionId: 'finance', sourceName: 'invoices' })]);
+    });
     it('returns lane candidates with stable connection-scoped IDs', async () => {
         const index = new SqliteSlSourcesIndex({ dbPath });
         await index.upsertSources('warehouse', [

package/node_modules/@ktx/context/dist/wiki/knowledge-wiki.service.d.ts

@@ -1,4 +1,5 @@
 import type { KtxEmbeddingPort, KtxFileStorePort, KtxLogger } from '../core/index.js';
+import type { ReindexWorkResult } from '../index-sync/types.js';
 import type { KnowledgeGitDiffPort, KnowledgeIndexPort } from './ports.js';
 import type { WikiFrontmatter, WikiPage, WikiPageWithScope } from './types.js';
 export type { WikiFrontmatter };
@@ -9,7 +10,7 @@ export declare class KnowledgeWikiService {
     private readonly gitService;
     private readonly logger;
     private isWorktreeScoped;
-    constructor(configService: KtxFileStorePort, embeddingService: KtxEmbeddingPort, pagesRepository: KnowledgeIndexPort, gitService: KnowledgeGitDiffPort, logger?: KtxLogger);
+    constructor(configService: KtxFileStorePort, embeddingService: KtxEmbeddingPort | null, pagesRepository: KnowledgeIndexPort, gitService: KnowledgeGitDiffPort, logger?: KtxLogger);
     /**
      * Return a clone of this service whose disk writes go through a worktree-scoped
      * ConfigService AND whose DB-index writes are no-ops. Used by memory-agent
@@ -56,7 +57,7 @@ export declare class KnowledgeWikiService {
      * Full sync: load all pages from disk for a scope, reindex changed pages, clean stale entries.
      * Mirrors SlSearchService.indexSources() pattern.
      */
-    syncIndex(scope: string, scopeId?: string | null): Promise<void>;
+    syncIndex(scope: string, scopeId?: string | null): Promise<ReindexWorkResult>;
     /**
      * Delete a page from the DB index (after file deletion).
      */

package/node_modules/@ktx/context/dist/wiki/knowledge-wiki.service.js

@@ -172,11 +172,13 @@ export class KnowledgeWikiService {
         }
         const searchText = buildKnowledgeSearchText(pageKey, frontmatter.summary, content, frontmatter.tags);
         let embedding = null;
-        try {
-            embedding = await this.embeddingService.computeEmbedding(searchText);
-        }
-        catch (err) {
-            this.logger.warn(`Embedding failed for page "${pageKey}": ${err instanceof Error ? err.message : String(err)}`);
+        if (this.embeddingService) {
+            try {
+                embedding = await this.embeddingService.computeEmbedding(searchText);
+            }
+            catch (err) {
+                this.logger.warn(`Embedding failed for page "${pageKey}": ${err instanceof Error ? err.message : String(err)}`);
+            }
         }
         await this.pagesRepository.upsertPage({
             scope,
@@ -196,11 +198,17 @@ export class KnowledgeWikiService {
      */
     async syncIndex(scope, scopeId) {
         const pageKeys = await this.listPageKeys(scope, scopeId);
+        const existing = await this.pagesRepository.getExistingSearchTexts(scope, scopeId ?? null);
         if (pageKeys.length === 0) {
-            await this.pagesRepository.deleteByScope(scope, scopeId ?? null);
-            return;
+            const deleted = await this.pagesRepository.deleteByScope(scope, scopeId ?? null);
+            return {
+                scanned: 0,
+                updated: 0,
+                deleted,
+                embeddingsRecomputed: 0,
+                embeddingsFailed: 0,
+            };
         }
-        // Load and parse all pages
         const pages = [];
         for (const key of pageKeys) {
             const page = await this.readPage(scope, scopeId, key);
@@ -209,52 +217,53 @@ export class KnowledgeWikiService {
                 pages.push({ pageKey: key, frontmatter: page.frontmatter, content: page.content, searchText });
             }
         }
-        // Detect changes
-        const existing = await this.pagesRepository.getExistingSearchTexts(scope, scopeId ?? null);
-        const changedPages = pages.filter((p) => {
-            const ex = existing.get(p.pageKey);
-            return !ex || ex.searchText !== p.searchText || !ex.hasEmbedding;
+        const embeddingService = this.embeddingService;
+        const changedPages = pages.filter((page) => {
+            const previous = existing.get(page.pageKey);
+            return (!previous ||
+                previous.searchText !== page.searchText ||
+                (embeddingService !== null && !previous.hasEmbedding));
         });
-        if (changedPages.length === 0) {
-            // Still clean up stale
-            await this.pagesRepository.deleteStale(scope, scopeId ?? null, pageKeys);
-            this.logger.log(`Wiki sync ${scope}: all ${pages.length} pages up to date`);
-            return;
-        }
-        // Compute embeddings for changed pages (batched)
-        const changedTexts = changedPages.map((p) => p.searchText);
-        let embeddings;
-        try {
-            const batchSize = this.embeddingService.maxBatchSize;
-            const all = [];
-            for (let i = 0; i < changedTexts.length; i += batchSize) {
-                const batch = changedTexts.slice(i, i + batchSize);
-                const batchEmb = await this.embeddingService.computeEmbeddingsBulk(batch);
-                all.push(...batchEmb);
+        let embeddings = changedPages.map(() => null);
+        let embeddingsRecomputed = 0;
+        let embeddingsFailed = 0;
+        if (embeddingService && changedPages.length > 0) {
+            try {
+                const changedTexts = changedPages.map((page) => page.searchText);
+                const all = [];
+                for (let i = 0; i < changedTexts.length; i += embeddingService.maxBatchSize) {
+                    const batch = changedTexts.slice(i, i + embeddingService.maxBatchSize);
+                    all.push(...(await embeddingService.computeEmbeddingsBulk(batch)));
+                }
+                embeddings = all;
+                embeddingsRecomputed = all.length;
+            }
+            catch (err) {
+                this.logger.warn(`Embedding batch failed during sync: ${err instanceof Error ? err.message : String(err)}`);
+                embeddingsFailed = changedPages.length;
             }
-            embeddings = all;
-        }
-        catch (err) {
-            this.logger.warn(`Embedding batch failed during sync: ${err instanceof Error ? err.message : String(err)}`);
-            embeddings = changedPages.map(() => null);
         }
-        // Upsert changed pages
-        for (let i = 0; i < changedPages.length; i++) {
-            const p = changedPages[i];
+        for (let i = 0; i < changedPages.length; i += 1) {
+            const page = changedPages[i];
             await this.pagesRepository.upsertPage({
                 scope,
                 scopeId: scopeId ?? null,
-                pageKey: p.pageKey,
-                summary: p.frontmatter.summary,
-                usageMode: p.frontmatter.usage_mode,
-                sortOrder: p.frontmatter.sort_order ?? 0,
-                searchText: p.searchText,
-                embedding: embeddings[i],
+                pageKey: page.pageKey,
+                summary: page.frontmatter.summary,
+                usageMode: page.frontmatter.usage_mode,
+                sortOrder: page.frontmatter.sort_order ?? 0,
+                searchText: page.searchText,
+                embedding: embeddings[i] ?? null,
             });
         }
-        // Clean stale entries
-        await this.pagesRepository.deleteStale(scope, scopeId ?? null, pageKeys);
-        this.logger.log(`Wiki sync ${scope}: ${changedPages.length}/${pages.length} reindexed, ${pages.length - changedPages.length} unchanged`);
+        const deleted = await this.pagesRepository.deleteStale(scope, scopeId ?? null, pageKeys);
+        return {
+            scanned: pages.length,
+            updated: changedPages.length,
+            deleted,
+            embeddingsRecomputed,
+            embeddingsFailed,
+        };
     }
     /**
      * Delete a page from the DB index (after file deletion).
@@ -297,11 +306,13 @@ export class KnowledgeWikiService {
             const parsed = this.parsePage(content);
             const searchText = buildKnowledgeSearchText(parsedPath.pageKey, parsed.frontmatter.summary, parsed.content, parsed.frontmatter.tags);
             let embedding = null;
-            try {
-                embedding = await this.embeddingService.computeEmbedding(searchText);
-            }
-            catch (err) {
-                this.logger.warn(`[wiki.sync] embedding failed for ${parsedPath.pageKey}: ${err instanceof Error ? err.message : String(err)}`);
+            if (this.embeddingService) {
+                try {
+                    embedding = await this.embeddingService.computeEmbedding(searchText);
+                }
+                catch (err) {
+                    this.logger.warn(`[wiki.sync] embedding failed for ${parsedPath.pageKey}: ${err instanceof Error ? err.message : String(err)}`);
+                }
             }
             const contentHash = createHash('sha256').update(content).digest('hex');
             upserts.push({

package/node_modules/@ktx/context/dist/wiki/knowledge-wiki.service.test.js

@@ -3,9 +3,9 @@ import { KnowledgeWikiService } from './knowledge-wiki.service.js';
 function makeService() {
     const pagesRepository = {
         upsertPage: vi.fn().mockResolvedValue(undefined),
-        deleteByKey: vi.fn().mockResolvedValue(undefined),
-        deleteByScope: vi.fn().mockResolvedValue(undefined),
-        deleteStale: vi.fn().mockResolvedValue(undefined),
+        deleteByKey: vi.fn().mockResolvedValue(0),
+        deleteByScope: vi.fn().mockResolvedValue(0),
+        deleteStale: vi.fn().mockResolvedValue(0),
         getExistingSearchTexts: vi.fn().mockResolvedValue(new Map()),
         applyDiffTransactional: vi.fn().mockResolvedValue(undefined),
     };
@@ -41,6 +41,62 @@ function makeService() {
     return { service, pagesRepository, embeddingService, configService, gitService, logger };
 }
 const fm = { summary: 'sum', usage_mode: 'auto' };
+describe('KnowledgeWikiService.syncIndex result stats', () => {
+    it('reports scanned, updated, deleted, and embedding counts', async () => {
+        const { service, pagesRepository, embeddingService, configService } = makeService();
+        configService.listFiles.mockResolvedValue({ files: ['wiki/global/revenue.md'] });
+        configService.readFile.mockResolvedValue({
+            content: '---\nsummary: Revenue\nusage_mode: auto\ntags:\n  - finance\n---\n\nPaid orders.\n',
+        });
+        pagesRepository.getExistingSearchTexts.mockResolvedValue(new Map([
+            ['old-page', { searchText: 'old', hasEmbedding: true }],
+        ]));
+        embeddingService.computeEmbeddingsBulk.mockResolvedValue([[0.1, 0.2, 0.3]]);
+        pagesRepository.deleteStale.mockResolvedValue(1);
+        await expect(service.syncIndex('GLOBAL', null)).resolves.toEqual({
+            scanned: 1,
+            updated: 1,
+            deleted: 1,
+            embeddingsRecomputed: 1,
+            embeddingsFailed: 0,
+        });
+    });
+    it('indexes lexical rows when embeddings are not configured', async () => {
+        const { pagesRepository, configService, gitService, logger } = makeService();
+        const service = new KnowledgeWikiService(configService, null, pagesRepository, gitService, logger);
+        configService.listFiles.mockResolvedValue({ files: ['wiki/global/revenue.md'] });
+        configService.readFile.mockResolvedValue({
+            content: '---\nsummary: Revenue\nusage_mode: auto\n---\n\nPaid orders.\n',
+        });
+        pagesRepository.getExistingSearchTexts.mockResolvedValue(new Map());
+        pagesRepository.deleteStale.mockResolvedValue(0);
+        const result = await service.syncIndex('GLOBAL', null);
+        expect(result.embeddingsRecomputed).toBe(0);
+        expect(result.embeddingsFailed).toBe(0);
+        expect(pagesRepository.upsertPage).toHaveBeenCalledWith(expect.objectContaining({ pageKey: 'revenue', embedding: null }));
+    });
+    it('does not update unchanged lexical-only wiki rows on repeated sync', async () => {
+        const { pagesRepository, configService, gitService, logger } = makeService();
+        const service = new KnowledgeWikiService(configService, null, pagesRepository, gitService, logger);
+        configService.listFiles.mockResolvedValue({ files: ['wiki/global/revenue.md'] });
+        configService.readFile.mockResolvedValue({
+            content: '---\nsummary: Revenue\nusage_mode: auto\n---\n\nPaid orders.\n',
+        });
+        pagesRepository.getExistingSearchTexts.mockResolvedValue(new Map([
+            ['revenue', { searchText: 'revenue\nRevenue\nPaid orders.', hasEmbedding: false }],
+        ]));
+        pagesRepository.deleteStale.mockResolvedValue(0);
+        await expect(service.syncIndex('GLOBAL', null)).resolves.toEqual({
+            scanned: 1,
+            updated: 0,
+            deleted: 0,
+            embeddingsRecomputed: 0,
+            embeddingsFailed: 0,
+        });
+        expect(pagesRepository.upsertPage).not.toHaveBeenCalled();
+        expect(pagesRepository.deleteStale).toHaveBeenCalledWith('GLOBAL', null, ['revenue']);
+    });
+});
 describe('KnowledgeWikiService.forWorktree isolation', () => {
     it('syncSinglePage in worktree scope does not call pagesRepository.upsertPage', async () => {
         const { service, pagesRepository, embeddingService } = makeService();

package/node_modules/@ktx/context/dist/wiki/ports.d.ts

@@ -34,9 +34,9 @@ export interface KnowledgeIndexPort {
         searchText: string;
         hasEmbedding: boolean;
     }>>;
-    deleteStale(scope: string, scopeId: string | null, keepKeys: string[]): Promise<void>;
-    deleteByScope(scope: string, scopeId: string | null): Promise<void>;
-    deleteByKey(scope: string, scopeId: string | null, pageKey: string): Promise<void>;
+    deleteStale(scope: string, scopeId: string | null, keepKeys: string[]): Promise<number>;
+    deleteByScope(scope: string, scopeId: string | null): Promise<number>;
+    deleteByKey(scope: string, scopeId: string | null, pageKey: string): Promise<number>;
     findPageByKey(scope: string, scopeId: string | null, pageKey: string): Promise<{
         id?: string;
         page_key: string;

package/node_modules/@ktx/context/dist/wiki/sqlite-knowledge-index.d.ts

@@ -1,4 +1,5 @@
 import type { LocalKnowledgeScope } from './local-knowledge.js';
+import type { KnowledgeIndexPageListing, UpsertPageParams } from './ports.js';
 export interface SqliteKnowledgeIndexOptions {
     dbPath: string;
 }
@@ -6,6 +7,7 @@ export interface SqliteKnowledgeIndexPage {
     path: string;
     key: string;
     scope: LocalKnowledgeScope;
+    scopeId?: string | null;
     summary: string;
     content: string;
     tags: string[];
@@ -40,4 +42,35 @@ export declare class SqliteKnowledgeIndex {
         limit: number;
     }): WikiSqliteLaneCandidate[];
     search(query: string, limit: number): SqliteKnowledgeIndexSearchResult[];
+    private pathForPage;
+    upsertPage(params: UpsertPageParams): Promise<void>;
+    getExistingSearchTexts(scope: string, scopeId: string | null): Promise<Map<string, {
+        searchText: string;
+        hasEmbedding: boolean;
+    }>>;
+    deleteStale(scope: string, scopeId: string | null, keepKeys: string[]): Promise<number>;
+    deleteByScope(scope: string, scopeId: string | null): Promise<number>;
+    deleteByKey(scope: string, scopeId: string | null, pageKey: string): Promise<number>;
+    clear(scope: string, scopeId: string | null): number;
+    applyDiffTransactional(params: {
+        runId: string;
+        upserts: UpsertPageParams[];
+        deletes: Array<{
+            scope: string;
+            scopeId: string | null;
+            pageKey: string;
+        }>;
+    }): Promise<void>;
+    findPageByKey(scope: string, scopeId: string | null, pageKey: string): Promise<{
+        id?: string;
+        page_key: string;
+    } | null>;
+    listPagesForUser(userId: string): Promise<KnowledgeIndexPageListing[]>;
+    getUserPageCount(userId: string): Promise<number>;
+    incrementUsageCount(): Promise<void>;
+    searchRRF(userId: string, _embedding: number[] | null, queryText: string, limit: number): Promise<Array<{
+        pageKey: string;
+        summary: string;
+        rrfScore: number;
+    }>>;
 }