@kaelio/ktx 0.1.1 → 0.3.0

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

@@ -58,6 +58,7 @@ export class SqliteKnowledgeIndex {
         path TEXT PRIMARY KEY,
         key TEXT NOT NULL,
         scope TEXT NOT NULL,
+        scope_id TEXT,
         summary TEXT NOT NULL,
         content TEXT NOT NULL,
         tags TEXT NOT NULL,
@@ -81,6 +82,9 @@ export class SqliteKnowledgeIndex {
         if (!columnNames.has('embedding_json')) {
             this.db.exec('ALTER TABLE knowledge_pages ADD COLUMN embedding_json TEXT');
         }
+        if (!columnNames.has('scope_id')) {
+            this.db.exec('ALTER TABLE knowledge_pages ADD COLUMN scope_id TEXT');
+        }
     }
     sync(pages) {
         const keepPaths = pages.map((page) => page.path);
@@ -91,11 +95,12 @@ export class SqliteKnowledgeIndex {
             ? this.db.prepare('DELETE FROM knowledge_pages_fts')
             : this.db.prepare(`DELETE FROM knowledge_pages_fts WHERE path NOT IN (${keepPaths.map(() => '?').join(', ')})`);
         const upsertPage = this.db.prepare(`
-      INSERT INTO knowledge_pages (path, key, scope, summary, content, tags, search_text, embedding_json)
-      VALUES (@path, @key, @scope, @summary, @content, @tags, @searchText, @embeddingJson)
+      INSERT INTO knowledge_pages (path, key, scope, scope_id, summary, content, tags, search_text, embedding_json)
+      VALUES (@path, @key, @scope, @scopeId, @summary, @content, @tags, @searchText, @embeddingJson)
       ON CONFLICT(path) DO UPDATE SET
         key = excluded.key,
         scope = excluded.scope,
+        scope_id = excluded.scope_id,
         summary = excluded.summary,
         content = excluded.content,
         tags = excluded.tags,
@@ -116,6 +121,7 @@ export class SqliteKnowledgeIndex {
                     path: page.path,
                     key: page.key,
                     scope: page.scope,
+                    scopeId: page.scopeId ?? null,
                     summary: page.summary,
                     content: searchText,
                     tags: page.tags.join(' '),
@@ -205,4 +211,151 @@ export class SqliteKnowledgeIndex {
             score: scoreFromRank(row.rawScore),
         }));
     }
+    pathForPage(scope, scopeId, pageKey) {
+        return scope === 'GLOBAL' ? `wiki/global/${pageKey}.md` : `wiki/user/${scopeId ?? 'local'}/${pageKey}.md`;
+    }
+    async upsertPage(params) {
+        const path = this.pathForPage(params.scope, params.scopeId, params.pageKey);
+        const row = {
+            path,
+            key: params.pageKey,
+            scope: params.scope,
+            scopeId: params.scopeId,
+            summary: params.summary,
+            content: params.searchText,
+            tags: '',
+            searchText: params.searchText,
+            embeddingJson: params.embedding && params.embedding.length > 0 ? JSON.stringify(params.embedding) : null,
+        };
+        const write = this.db.transaction(() => {
+            this.db
+                .prepare(`
+          INSERT INTO knowledge_pages (path, key, scope, scope_id, summary, content, tags, search_text, embedding_json)
+          VALUES (@path, @key, @scope, @scopeId, @summary, @content, @tags, @searchText, @embeddingJson)
+          ON CONFLICT(path) DO UPDATE SET
+            key = excluded.key,
+            scope = excluded.scope,
+            scope_id = excluded.scope_id,
+            summary = excluded.summary,
+            content = excluded.content,
+            tags = excluded.tags,
+            search_text = excluded.search_text,
+            embedding_json = excluded.embedding_json
+        `)
+                .run(row);
+            this.db.prepare('DELETE FROM knowledge_pages_fts WHERE path = @path').run(row);
+            this.db
+                .prepare(`
+          INSERT INTO knowledge_pages_fts (path, key, summary, content, tags)
+          VALUES (@path, @key, @summary, @content, @tags)
+        `)
+                .run(row);
+        });
+        write();
+    }
+    async getExistingSearchTexts(scope, scopeId) {
+        const rows = this.db
+            .prepare(`
+        SELECT key, search_text, embedding_json
+        FROM knowledge_pages
+        WHERE scope = ?
+          AND scope_id IS ?
+        ORDER BY key ASC
+      `)
+            .all(scope, scopeId);
+        return new Map(rows.map((row) => [row.key, { searchText: row.search_text, hasEmbedding: row.embedding_json !== null }]));
+    }
+    async deleteStale(scope, scopeId, keepKeys) {
+        if (keepKeys.length === 0) {
+            return this.deleteByScope(scope, scopeId);
+        }
+        const placeholders = keepKeys.map(() => '?').join(', ');
+        const stale = this.db
+            .prepare(`
+        SELECT key
+        FROM knowledge_pages
+        WHERE scope = ?
+          AND scope_id IS ?
+          AND key NOT IN (${placeholders})
+      `)
+            .all(scope, scopeId, ...keepKeys);
+        for (const row of stale) {
+            await this.deleteByKey(scope, scopeId, row.key);
+        }
+        return stale.length;
+    }
+    async deleteByScope(scope, scopeId) {
+        return this.clear(scope, scopeId);
+    }
+    async deleteByKey(scope, scopeId, pageKey) {
+        const path = this.pathForPage(scope, scopeId, pageKey);
+        const remove = this.db.transaction(() => {
+            this.db.prepare('DELETE FROM knowledge_pages_fts WHERE path = ?').run(path);
+            const result = this.db.prepare('DELETE FROM knowledge_pages WHERE path = ?').run(path);
+            return Number(result.changes);
+        });
+        return remove();
+    }
+    clear(scope, scopeId) {
+        const rows = this.db
+            .prepare('SELECT path FROM knowledge_pages WHERE scope = ? AND scope_id IS ?')
+            .all(scope, scopeId);
+        const remove = this.db.transaction((paths) => {
+            for (const path of paths) {
+                this.db.prepare('DELETE FROM knowledge_pages_fts WHERE path = ?').run(path);
+                this.db.prepare('DELETE FROM knowledge_pages WHERE path = ?').run(path);
+            }
+        });
+        remove(rows.map((row) => row.path));
+        return rows.length;
+    }
+    async applyDiffTransactional(params) {
+        void params.runId;
+        for (const page of params.upserts) {
+            await this.upsertPage(page);
+        }
+        for (const page of params.deletes) {
+            await this.deleteByKey(page.scope, page.scopeId, page.pageKey);
+        }
+    }
+    async findPageByKey(scope, scopeId, pageKey) {
+        const path = this.pathForPage(scope, scopeId, pageKey);
+        const row = this.db.prepare('SELECT path, key FROM knowledge_pages WHERE path = ?').get(path);
+        return row ? { id: row.path, page_key: row.key } : null;
+    }
+    async listPagesForUser(userId) {
+        const rows = this.db
+            .prepare(`
+        SELECT path, key, scope, scope_id, summary, tags
+        FROM knowledge_pages
+        WHERE scope = 'GLOBAL'
+           OR (scope = 'USER' AND scope_id = ?)
+        ORDER BY scope ASC, key ASC
+      `)
+            .all(userId);
+        return rows.map((row) => ({
+            id: row.path,
+            page_key: row.key,
+            summary: row.summary,
+            scope: row.scope,
+            scope_id: row.scope_id,
+            tags: row.tags.split(/\s+/).filter(Boolean),
+        }));
+    }
+    async getUserPageCount(userId) {
+        const row = this.db
+            .prepare("SELECT COUNT(*) AS count FROM knowledge_pages WHERE scope = 'USER' AND scope_id = ?")
+            .get(userId);
+        return row.count;
+    }
+    async incrementUsageCount() { }
+    async searchRRF(userId, _embedding, queryText, limit) {
+        const allowedPages = new Map((await this.listPagesForUser(userId)).map((page) => [page.id, page]));
+        return this.search(queryText, limit)
+            .map((row) => {
+            const page = allowedPages.get(row.path);
+            return page ? { pageKey: page.page_key, summary: page.summary, rrfScore: row.score } : null;
+        })
+            .filter((row) => row !== null);
+    }
 }

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

@@ -54,6 +54,32 @@ describe('SqliteKnowledgeIndex', () => {
         index.rebuild([page()]);
         expect(index.search('churn', 10)).toEqual([]);
     });
+    it('clear removes one wiki scope and leaves other scopes intact', async () => {
+        const index = new SqliteKnowledgeIndex({ dbPath });
+        index.sync([
+            page({ path: 'wiki/global/revenue.md', key: 'revenue', scope: 'GLOBAL', scopeId: null }),
+            page({
+                path: 'wiki/user/local/revenue.md',
+                key: 'revenue',
+                scope: 'USER',
+                scopeId: 'local',
+                summary: 'Local revenue',
+                content: 'Local revenue notes.',
+            }),
+            page({
+                path: 'wiki/user/alex/revenue.md',
+                key: 'revenue',
+                scope: 'USER',
+                scopeId: 'alex',
+                summary: 'Alex revenue',
+                content: 'Alex revenue notes.',
+            }),
+        ]);
+        expect(index.clear('USER', 'local')).toBe(1);
+        expect(index.search('Local', 10)).toEqual([]);
+        expect(index.search('Alex', 10)).toEqual([expect.objectContaining({ path: 'wiki/user/alex/revenue.md' })]);
+        expect(index.search('definition', 10)).toEqual([expect.objectContaining({ path: 'wiki/global/revenue.md' })]);
+    });
     it('exposes existing search text and embedding state for incremental refresh', () => {
         const index = new SqliteKnowledgeIndex({ dbPath });
         index.sync([page({ path: 'wiki/global/revenue.md', key: 'revenue', embedding: [1, 0] })]);

package/node_modules/@ktx/context/package.json

@@ -46,6 +46,11 @@
       "import": "./dist/ingest/metabase-mapping.js",
       "default": "./dist/ingest/metabase-mapping.js"
     },
+    "./index-sync": {
+      "types": "./dist/index-sync/index.d.ts",
+      "import": "./dist/index-sync/index.js",
+      "default": "./dist/index-sync/index.js"
+    },
     "./scan": {
       "types": "./dist/scan/index.d.ts",
       "import": "./dist/scan/index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaelio/ktx",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Standalone KTX context layer for database agents",
   "private": false,
   "type": "module",

package/node_modules/@ktx/context/dist/ingest/adapters/historic-sql/post-processor.d.ts

@@ -1,4 +0,0 @@
-import type { IngestBundlePostProcessorInput, IngestBundlePostProcessorPort, IngestBundlePostProcessorResult } from '../../ports.js';
-export declare class HistoricSqlProjectionPostProcessor implements IngestBundlePostProcessorPort {
-    run(input: IngestBundlePostProcessorInput): Promise<IngestBundlePostProcessorResult>;
-}

package/node_modules/@ktx/context/dist/ingest/adapters/historic-sql/post-processor.js

@@ -1,38 +0,0 @@
-import { createSimpleGit } from '../../../core/git-env.js';
-import { projectHistoricSqlEvidence } from './projection.js';
-async function commitProjectionChanges(workdir) {
-    const git = createSimpleGit(workdir);
-    if (!(await git.checkIsRepo().catch(() => false))) {
-        return;
-    }
-    const status = await git.status();
-    const paths = status.files
-        .map((file) => file.path)
-        .filter((path) => path.startsWith('semantic-layer/') || path.startsWith('wiki/global/historic-sql'));
-    if (paths.length === 0) {
-        return;
-    }
-    await git.add(paths);
-    const staged = await git.diff(['--cached', '--name-only']);
-    if (!staged.trim()) {
-        return;
-    }
-    await git.commit('Project historic SQL evidence', { '--author': 'System User <system@example.com>' });
-}
-export class HistoricSqlProjectionPostProcessor {
-    async run(input) {
-        const projection = await projectHistoricSqlEvidence({
-            workdir: input.workdir,
-            connectionId: input.connectionId,
-            syncId: input.syncId,
-            runId: input.runId,
-        });
-        await commitProjectionChanges(input.workdir);
-        return {
-            result: projection,
-            warnings: projection.warnings,
-            errors: [],
-            touchedSources: projection.touchedSources,
-        };
-    }
-}

package/node_modules/@ktx/context/dist/ingest/adapters/historic-sql/post-processor.test.js

@@ -1,63 +0,0 @@
-import { mkdir, mkdtemp, readFile, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import YAML from 'yaml';
-import { describe, expect, it } from 'vitest';
-import { HistoricSqlProjectionPostProcessor } from './post-processor.js';
-async function tempWorkdir() {
-    return mkdtemp(join(tmpdir(), 'historic-sql-post-processor-'));
-}
-async function writeJson(root, relPath, value) {
-    const target = join(root, relPath);
-    await mkdir(join(target, '..'), { recursive: true });
-    await writeFile(target, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
-}
-describe('HistoricSqlProjectionPostProcessor', () => {
-    it('projects current run evidence before the ingest squash commit', async () => {
-        const workdir = await tempWorkdir();
-        await mkdir(join(workdir, 'semantic-layer/warehouse/_schema'), { recursive: true });
-        await writeFile(join(workdir, 'semantic-layer/warehouse/_schema/public.yaml'), YAML.stringify({ tables: { orders: { table: 'public.orders', columns: [{ name: 'id', type: 'string' }] } } }), 'utf-8');
-        await writeJson(workdir, 'raw-sources/warehouse/historic-sql/sync-1/manifest.json', {
-            source: 'historic-sql',
-            connectionId: 'warehouse',
-            dialect: 'postgres',
-            fetchedAt: '2026-05-11T00:00:00.000Z',
-            windowStart: '2026-02-10T00:00:00.000Z',
-            windowEnd: '2026-05-11T00:00:00.000Z',
-            snapshotRowCount: 1,
-            touchedTableCount: 1,
-            parseFailures: 0,
-            warnings: [],
-            probeWarnings: [],
-            staleArchiveAfterDays: 90,
-        });
-        await writeJson(workdir, 'raw-sources/warehouse/historic-sql/sync-1/tables/public.orders.json', { table: 'public.orders' });
-        await writeJson(workdir, '.ktx/ingest-evidence/historic-sql/run-1/orders.json', {
-            kind: 'table_usage',
-            connectionId: 'warehouse',
-            table: 'public.orders',
-            rawPath: 'tables/public.orders.json',
-            usage: {
-                narrative: 'Orders are repeatedly queried by lifecycle status.',
-                frequencyTier: 'high',
-                commonFilters: ['status'],
-                commonJoins: [],
-                staleSince: null,
-            },
-        });
-        const result = await new HistoricSqlProjectionPostProcessor().run({
-            connectionId: 'warehouse',
-            sourceKey: 'historic-sql',
-            syncId: 'sync-1',
-            jobId: 'job-1',
-            runId: 'run-1',
-            workdir,
-            parseArtifacts: null,
-        });
-        expect(result.errors).toEqual([]);
-        expect(result.warnings).toEqual([]);
-        expect(result.touchedSources).toEqual([{ connectionId: 'warehouse', sourceName: 'orders' }]);
-        expect(result.result).toMatchObject({ tableUsageMerged: 1 });
-        await expect(readFile(join(workdir, 'semantic-layer/warehouse/_schema/public.yaml'), 'utf-8')).resolves.toContain('Orders are repeatedly queried by lifecycle status.');
-    });
-});