@kaelio/ktx 0.1.1 → 0.2.0

package/dist/io/print-list.test.js

@@ -60,13 +60,13 @@ describe('printList — plain mode', () => {
             mode: 'plain',
             command: 'sl search',
             emptyMessage: 'No sources matched "foo"',
-            emptyHint: 'Run `ktx sl list` to see available sources.',
+            emptyHint: 'Run `ktx sl` to see available sources.',
             unit: 'source',
             io: r.io,
         });
         expect(r.out()).toBe('');
         expect(r.err()).toBe('No sources matched "foo"\n' +
-            'Run `ktx sl list` to see available sources.\n');
+            'Run `ktx sl` to see available sources.\n');
     });
 });
 describe('printList — json mode', () => {
@@ -162,13 +162,13 @@ describe('printList — pretty mode', () => {
             mode: 'pretty',
             command: 'sl search',
             emptyMessage: 'No sources matched "foo"',
-            emptyHint: 'Run `ktx sl list` to see available sources.',
+            emptyHint: 'Run `ktx sl` to see available sources.',
             unit: 'source',
             io: r.io,
         });
         const out = stripAnsi(r.out());
         expect(out).toContain('No sources matched "foo"');
-        expect(out).toContain('Run `ktx sl list` to see available sources.');
+        expect(out).toContain('Run `ktx sl` to see available sources.');
     });
     it('singularizes the footer when there is one row', () => {
         const r = recorder();

package/dist/knowledge.js

@@ -74,7 +74,7 @@ export async function runKtxKnowledge(args, io = process, deps = {}) {
             }
             const mode = resolveOutputMode({ explicit: args.output, json: args.json, io });
             let emptyMessage = `No local wiki pages matched "${args.query}"`;
-            let emptyHint = 'Run `ktx wiki list` to inspect available pages.';
+            let emptyHint = 'Run `ktx wiki` to inspect available pages.';
             if (results.length === 0 && mode !== 'json') {
                 const pages = await listLocalKnowledgePages(project, { userId: args.userId });
                 if (pages.length === 0) {

package/dist/managed-python-command.js

@@ -12,8 +12,8 @@ export function runtimeInstallPolicyFromFlags(options) {
 }
 export function managedRuntimeInstallCommand(feature) {
     return feature === 'local-embeddings'
-        ? 'ktx dev runtime install --feature local-embeddings --yes'
-        : 'ktx dev runtime install --yes';
+        ? 'ktx admin runtime install --feature local-embeddings --yes'
+        : 'ktx admin runtime install --yes';
 }
 function installPrompt(feature) {
     const label = feature === 'local-embeddings' ? 'local embeddings Python runtime' : 'core Python runtime';

package/dist/managed-python-command.test.js

@@ -98,8 +98,8 @@ function makeSpinnerEvents() {
 }
 describe('managedRuntimeInstallCommand', () => {
     it('prints the exact command for each managed runtime feature', () => {
-        expect(managedRuntimeInstallCommand('core')).toBe('ktx dev runtime install --yes');
-        expect(managedRuntimeInstallCommand('local-embeddings')).toBe('ktx dev runtime install --feature local-embeddings --yes');
+        expect(managedRuntimeInstallCommand('core')).toBe('ktx admin runtime install --yes');
+        expect(managedRuntimeInstallCommand('local-embeddings')).toBe('ktx admin runtime install --feature local-embeddings --yes');
     });
 });
 describe('runtimeInstallPolicyFromFlags', () => {
@@ -177,7 +177,7 @@ describe('createManagedPythonSemanticLayerComputePort', () => {
             io: io.io,
             readStatus: vi.fn(async () => missingStatus()),
             installRuntime,
-        })).rejects.toThrow('KTX Python runtime is required for this command. Run: ktx dev runtime install --yes');
+        })).rejects.toThrow('KTX Python runtime is required for this command. Run: ktx admin runtime install --yes');
         expect(installRuntime).not.toHaveBeenCalled();
     });
     it('installs the core runtime without prompting when policy is auto', async () => {

package/dist/managed-python-runtime.d.ts

@@ -112,7 +112,7 @@ export interface ManagedPythonRuntimeDoctorCheck {
     detail: string;
     fix?: string;
 }
-export declare const MISSING_UV_RUNTIME_INSTALL_MESSAGE = "uv is required to install the KTX Python runtime. KTX does not download uv automatically. Install uv, make sure it is on PATH, and retry: ktx dev runtime install --yes";
+export declare const MISSING_UV_RUNTIME_INSTALL_MESSAGE = "uv is required to install the KTX Python runtime. KTX does not download uv automatically. Install uv, make sure it is on PATH, and retry: ktx admin runtime install --yes";
 export declare function managedPythonRuntimeLayout(options: ManagedPythonRuntimeLayoutOptions): ManagedPythonRuntimeLayout;
 export declare function managedPythonDaemonLayout(options: ManagedPythonDaemonLayoutOptions): ManagedPythonDaemonLayout;
 export declare function verifyRuntimeAsset(input: {

package/dist/managed-python-runtime.js

@@ -32,7 +32,7 @@ const installedRuntimeManifestSchema = z.object({
     }),
     installLog: z.string().min(1),
 });
-export const MISSING_UV_RUNTIME_INSTALL_MESSAGE = 'uv is required to install the KTX Python runtime. KTX does not download uv automatically. Install uv, make sure it is on PATH, and retry: ktx dev runtime install --yes';
+export const MISSING_UV_RUNTIME_INSTALL_MESSAGE = 'uv is required to install the KTX Python runtime. KTX does not download uv automatically. Install uv, make sure it is on PATH, and retry: ktx admin runtime install --yes';
 function defaultAssetDir() {
     return fileURLToPath(new URL('../assets/python/', import.meta.url));
 }
@@ -331,7 +331,7 @@ export async function doctorManagedPythonRuntime(options) {
             id: 'uv',
             label: 'uv',
             detail: error instanceof Error ? error.message : String(error),
-            fix: 'Install uv, make sure it is on PATH, and run: ktx dev runtime install --yes',
+            fix: 'Install uv, make sure it is on PATH, and run: ktx admin runtime install --yes',
         }));
     }
     try {
@@ -351,7 +351,7 @@ export async function doctorManagedPythonRuntime(options) {
         id: 'runtime',
         label: 'Managed Python runtime',
         detail: status.detail,
-        ...(status.kind === 'ready' ? {} : { fix: 'Run: ktx dev runtime install --yes' }),
+        ...(status.kind === 'ready' ? {} : { fix: 'Run: ktx admin runtime install --yes' }),
     }));
     return checks;
 }

package/dist/managed-python-runtime.test.js

@@ -402,7 +402,7 @@ describe('doctorManagedPythonRuntime', () => {
             ['asset', 'pass'],
             ['runtime', 'fail'],
         ]);
-        expect(checks[2]?.fix).toBe('Run: ktx dev runtime install --yes');
+        expect(checks[2]?.fix).toBe('Run: ktx admin runtime install --yes');
     });
     it('reports uv as a hard prerequisite when uv is missing', async () => {
         const { assetDir } = await writeAsset(tempDir, { label: 'core-wheel' });
@@ -420,7 +420,7 @@ describe('doctorManagedPythonRuntime', () => {
             label: 'uv',
             status: 'fail',
             detail: MISSING_UV_RUNTIME_INSTALL_MESSAGE,
-            fix: 'Install uv, make sure it is on PATH, and run: ktx dev runtime install --yes',
+            fix: 'Install uv, make sure it is on PATH, and run: ktx admin runtime install --yes',
         });
     });
 });

package/dist/memory-flow-tui.test.js

@@ -145,8 +145,8 @@ describe('MemoryFlowTuiApp', () => {
         expect(frame).toContain('order lifecycle');
         expect(frame).toContain('customer metrics');
         expect(frame).toContain('KTX finished ingesting your data');
-        expect(frame).toContain('ktx sl list');
-        expect(frame).toContain('ktx wiki list');
+        expect(frame).toContain('ktx sl');
+        expect(frame).toContain('ktx wiki');
         expect(frame).not.toContain('ktx serve --mcp stdio --user-id local');
         expect(frame).not.toContain(['ktx', 'ask'].join(' '));
         expect(frame).not.toContain(['ktx', 'mcp'].join(' '));

package/dist/next-steps.d.ts

@@ -1,6 +1,6 @@
 export declare const KTX_CONTEXT_BUILD_COMMANDS: readonly [{
-    readonly command: "ktx ingest --all";
-    readonly description: "Build or refresh agent-ready context from configured connections";
+    readonly command: "ktx ingest";
+    readonly description: "Build or refresh agent-ready context from all configured connections";
 }, {
     readonly command: "ktx status";
     readonly description: "Check setup and context readiness";
@@ -9,20 +9,20 @@ export declare const KTX_NEXT_STEP_DIRECT_COMMANDS: readonly [{
     readonly command: "ktx status --json";
     readonly description: "Verify project setup and context readiness";
 }, {
-    readonly command: "ktx sl list";
+    readonly command: "ktx sl";
     readonly description: "Inspect generated semantic-layer sources";
 }, {
-    readonly command: "ktx wiki list";
+    readonly command: "ktx wiki";
     readonly description: "Inspect generated wiki pages";
 }];
 export declare const KTX_NEXT_STEP_COMMANDS: readonly [{
     readonly command: "ktx status --json";
     readonly description: "Verify project setup and context readiness";
 }, {
-    readonly command: "ktx sl list";
+    readonly command: "ktx sl";
     readonly description: "Inspect generated semantic-layer sources";
 }, {
-    readonly command: "ktx wiki list";
+    readonly command: "ktx wiki";
     readonly description: "Inspect generated wiki pages";
 }];
 export declare const KTX_NEXT_STEP_COMMAND_WIDTH: number;

package/dist/next-steps.js

@@ -1,7 +1,7 @@
 export const KTX_CONTEXT_BUILD_COMMANDS = [
     {
-        command: 'ktx ingest --all',
-        description: 'Build or refresh agent-ready context from configured connections',
+        command: 'ktx ingest',
+        description: 'Build or refresh agent-ready context from all configured connections',
     },
     {
         command: 'ktx status',
@@ -14,11 +14,11 @@ export const KTX_NEXT_STEP_DIRECT_COMMANDS = [
         description: 'Verify project setup and context readiness',
     },
     {
-        command: 'ktx sl list',
+        command: 'ktx sl',
         description: 'Inspect generated semantic-layer sources',
     },
     {
-        command: 'ktx wiki list',
+        command: 'ktx wiki',
         description: 'Inspect generated wiki pages',
     },
 ];

package/dist/next-steps.test.js

@@ -4,8 +4,8 @@ describe('KTX demo next steps', () => {
     it('uses supported context-build commands before agent usage', () => {
         expect(KTX_CONTEXT_BUILD_COMMANDS).toEqual([
             {
-                command: 'ktx ingest --all',
-                description: 'Build or refresh agent-ready context from configured connections',
+                command: 'ktx ingest',
+                description: 'Build or refresh agent-ready context from all configured connections',
             },
             {
                 command: 'ktx status',
@@ -20,11 +20,11 @@ describe('KTX demo next steps', () => {
                 description: 'Verify project setup and context readiness',
             },
             {
-                command: 'ktx sl list',
+                command: 'ktx sl',
                 description: 'Inspect generated semantic-layer sources',
             },
             {
-                command: 'ktx wiki list',
+                command: 'ktx wiki',
                 description: 'Inspect generated wiki pages',
             },
         ]);
@@ -54,7 +54,7 @@ describe('KTX demo next steps', () => {
         }).join('\n');
         expect(rendered).toContain('Build KTX context next.');
         expect(rendered).toContain('Run ingest to build database schema context before context-source ingest.');
-        expect(rendered).toContain('ktx ingest --all');
+        expect(rendered).toContain('ktx ingest');
         expect(rendered).not.toContain('resume');
         expect(rendered).not.toContain('scan');
         expect(rendered).toContain('ktx status');

package/dist/print-command-tree.test.js

@@ -8,7 +8,7 @@ describe('renderKtxCommandTree', () => {
         const topLevel = lines
             .filter((line) => /^ {2}[├└]── \S/.test(line))
             .map((line) => line.replace(/^ {2}[├└]── /, '').trim().split(' ')[0]);
-        for (const expected of ['setup', 'connection', 'ingest', 'sl', 'mcp', 'dev']) {
+        for (const expected of ['setup', 'connection', 'ingest', 'sl', 'mcp', 'admin']) {
             expect(topLevel).toContain(expected);
         }
         expect(output).toContain('│   └── test [connectionId]');

package/dist/public-ingest.js

@@ -234,12 +234,10 @@ function targetForConnection(connectionId, connection, projectConfig, args, warn
     throw new Error(`Connection "${connectionId}" uses unsupported public ingest driver "${driver || 'unknown'}"`);
 }
 export function buildPublicIngestPlan(project, args) {
-    if (!args.all && !args.targetConnectionId) {
-        throw new Error('Context build requires a connection id or all targets');
-    }
+    const allConnections = args.all || !args.targetConnectionId;
     const entries = Object.entries(project.config.connections).sort(([a], [b]) => a.localeCompare(b));
-    const selected = args.all ? entries : entries.filter(([connectionId]) => connectionId === args.targetConnectionId);
-    if (!args.all && selected.length === 0) {
+    const selected = allConnections ? entries : entries.filter(([connectionId]) => connectionId === args.targetConnectionId);
+    if (!allConnections && selected.length === 0) {
         throw new Error(`Connection "${args.targetConnectionId}" is not configured in ktx.yaml`);
     }
     if (selected.length === 0) {

package/dist/public-ingest.test.js

@@ -109,9 +109,13 @@ describe('buildPublicIngestPlan', () => {
             warnings: [],
         });
     });
-    it('rejects bare non-interactive ingest until the interactive confirmation slice exists', () => {
-        const project = projectWithConnections({ warehouse: { driver: 'postgres' } });
-        expect(() => buildPublicIngestPlan(project, { projectDir: '/tmp/project', all: false })).toThrow('Context build requires a connection id or all targets');
+    it('treats a bare invocation (no connection id, no --all) as all configured connections', () => {
+        const project = projectWithConnections({
+            warehouse: { driver: 'postgres' },
+            docs: { driver: 'notion' },
+        });
+        const plan = buildPublicIngestPlan(project, { projectDir: '/tmp/project', all: false });
+        expect(plan.targets.map((target) => target.connectionId).sort()).toEqual(['docs', 'warehouse']);
     });
     it('resolves database depth from flags, stored context, and defaults', () => {
         const project = projectWithConnections({

package/dist/runtime.test.js

@@ -246,7 +246,7 @@ describe('runKtxRuntime', () => {
                     label: 'Managed Python runtime',
                     status: 'fail',
                     detail: 'No runtime manifest at /runtime/0.2.0/manifest.json',
-                    fix: 'Run: ktx dev runtime install --yes',
+                    fix: 'Run: ktx admin runtime install --yes',
                 },
             ]),
         };

package/dist/scan.test.js

@@ -287,8 +287,8 @@ describe('runKtxScan', () => {
         expect(io.stdout()).toContain('Report: raw-sources/warehouse/live-database/sync-1/scan-report.json');
         expect(io.stdout()).toContain('Next:\n');
         expect(io.stdout()).toContain('ktx status --project-dir ');
-        expect(io.stdout()).not.toContain('ktx dev scan status');
-        expect(io.stdout()).not.toContain('ktx dev scan report');
+        expect(io.stdout()).not.toContain('ktx admin scan status');
+        expect(io.stdout()).not.toContain('ktx admin scan report');
         expect(io.stdout()).not.toContain('\u001b[');
         expect(io.stdout()).not.toContain('✓');
         expect(io.stdout()).not.toContain('+1');

package/dist/setup-agents.js

@@ -426,8 +426,8 @@ function cliInstructionContent(input) {
         'Available commands:',
         '',
         `- \`${ktxCommandLine(input.launcher, ['status', ...jsonProjectDirArgs])}\``,
-        `- \`${ktxCommandLine(input.launcher, ['sl', 'list', ...jsonProjectDirArgs])}\``,
-        `- \`${ktxCommandLine(input.launcher, ['sl', 'search', '<text>', ...jsonProjectDirArgs, '--connection-id', '<id>'])}\``,
+        `- \`${ktxCommandLine(input.launcher, ['sl', ...jsonProjectDirArgs])}\``,
+        `- \`${ktxCommandLine(input.launcher, ['sl', '<text>', ...jsonProjectDirArgs, '--connection-id', '<id>'])}\``,
         `- \`${ktxCommandLine(input.launcher, [
             'sl',
             'query',
@@ -442,7 +442,7 @@ function cliInstructionContent(input) {
             '--max-rows',
             '100',
         ])}\``,
-        `- \`${ktxCommandLine(input.launcher, ['wiki', 'search', '<query>', ...jsonProjectDirArgs, '--limit', '10'])}\``,
+        `- \`${ktxCommandLine(input.launcher, ['wiki', '<query>', ...jsonProjectDirArgs, '--limit', '10'])}\``,
         '',
         'Use semantic-layer queries before direct database access. Do not print secrets or credential references.',
         '',

package/dist/setup-agents.test.js

@@ -149,7 +149,7 @@ describe('setup agents', () => {
         expect(skill).toContain(`--project-dir ${tempDir}`);
         expect(skill).toContain('must not print secrets');
         expect(skill).toContain('status --json');
-        expect(skill).toContain('sl list --json');
+        expect(skill).toContain('sl --json');
         expect(skill).toContain('sl query');
         expect(skill).toContain('--format json');
         expect(skill).not.toContain('sl query --json');

package/dist/setup-embeddings.js

@@ -209,7 +209,7 @@ function localEmbeddingSetupMessage(message, stderrTail = []) {
     const lines = [
         `Local embedding health check failed: ${message}`,
         'Local embeddings use the KTX-managed Python runtime.',
-        'Prepare the runtime with: ktx dev runtime start --feature local-embeddings',
+        'Prepare the runtime with: ktx admin runtime start --feature local-embeddings',
         'Use --yes with setup to install and start the runtime without prompting.',
         'The first run may download Python packages and the all-MiniLM-L6-v2 model.',
     ];

package/dist/setup-embeddings.test.js

@@ -225,7 +225,7 @@ describe('setup embeddings step', () => {
     it('fails non-interactive local setup when the managed local embeddings runtime is missing', async () => {
         const io = makeIo();
         const ensureLocalEmbeddings = vi.fn(async () => {
-            throw new Error('KTX Python runtime is required for this command. Run: ktx dev runtime install --feature local-embeddings --yes');
+            throw new Error('KTX Python runtime is required for this command. Run: ktx admin runtime install --feature local-embeddings --yes');
         });
         const result = await runKtxSetupEmbeddingsStep({
             projectDir: tempDir,
@@ -235,7 +235,7 @@ describe('setup embeddings step', () => {
             skipEmbeddings: false,
         }, io.io, { env: {}, ensureLocalEmbeddings });
         expect(result.status).toBe('failed');
-        expect(io.stderr()).toContain('KTX Python runtime is required for this command. Run: ktx dev runtime install --feature local-embeddings --yes');
+        expect(io.stderr()).toContain('KTX Python runtime is required for this command. Run: ktx admin runtime install --feature local-embeddings --yes');
     });
     it('does not persist embedding completion when the health check fails', async () => {
         const io = makeIo();
@@ -255,7 +255,7 @@ describe('setup embeddings step', () => {
         expect(await readFile(join(tempDir, 'ktx.yaml'), 'utf-8')).not.toContain('completed_steps:');
         expect(config.ingest.embeddings.backend).toBe('none');
         expect(io.stderr()).toContain('Local embedding health check failed: 401 invalid api key [redacted]');
-        expect(io.stderr()).toContain('Prepare the runtime with: ktx dev runtime start --feature local-embeddings');
+        expect(io.stderr()).toContain('Prepare the runtime with: ktx admin runtime start --feature local-embeddings');
         expect(io.stderr()).not.toContain('skip for now');
     });
     it('prints the recent daemon stderr tail when local embedding health check fails', async () => {

package/dist/setup-runtime.test.js

@@ -56,7 +56,7 @@ describe('runKtxSetupRuntimeStep', () => {
     it('fails fast when required runtime features cannot be installed in no-input mode', async () => {
         const io = makeIo();
         const ensureRuntime = vi.fn(async () => {
-            throw new Error('KTX Python runtime is required for this command. Run: ktx dev runtime install --yes');
+            throw new Error('KTX Python runtime is required for this command. Run: ktx admin runtime install --yes');
         });
         await expect(runKtxSetupRuntimeStep({
             projectDir: tempDir,
@@ -71,7 +71,7 @@ describe('runKtxSetupRuntimeStep', () => {
         })).resolves.toMatchObject({ status: 'failed' });
         expect(ensureRuntime).toHaveBeenCalledWith(expect.objectContaining({ installPolicy: 'never' }));
         expect((await readKtxSetupState(tempDir)).completed_steps).not.toContain('runtime');
-        expect(io.stderr()).toContain('ktx dev runtime install --yes');
+        expect(io.stderr()).toContain('ktx admin runtime install --yes');
     });
     it('starts the managed local embeddings daemon for configured sentence-transformers embeddings', async () => {
         const io = makeIo();

package/dist/sl.js

@@ -99,7 +99,7 @@ export async function runKtxSl(args, io = process, deps = {}) {
             await printSlSources({
                 rows: sources,
                 emptyMessage: `No semantic-layer sources matched "${args.query}" in ${project.projectDir}`,
-                emptyHint: 'Run `ktx sl list` to inspect available sources.',
+                emptyHint: 'Run `ktx sl` to inspect available sources.',
                 command: 'sl search',
                 output: args.output,
                 json: args.json,

package/dist/standalone-smoke.test.js

@@ -116,6 +116,10 @@ describe('standalone built ktx CLI smoke', () => {
         const init = await runSetupNewProject(projectDir);
         expectSetupStderr(init);
         expect(init.stdout).toContain(`Project: ${projectDir}`);
+        const reindex = await runBuiltCli(['--project-dir', projectDir, 'admin', 'reindex', '--output', 'plain']);
+        expect(reindex.code).toBe(0);
+        expect(reindex.stdout).toContain('reindex\t');
+        expect(reindex.stderr).toContain('wiki/global');
         const run = await runBuiltCli([
             'ingest',
             'run',
@@ -125,7 +129,7 @@ describe('standalone built ktx CLI smoke', () => {
             'fake',
         ]);
         expect(run).toMatchObject({ code: 1, stdout: '' });
-        expect(run.stderr).toContain("unknown option '--connection-id'");
+        expect(run.stderr).toContain("unknown option '--adapter'");
     });
     it('rejects the removed agent command through the built binary', async () => {
         const result = await runBuiltCli(['agent']);
@@ -235,7 +239,7 @@ describe('standalone built ktx CLI smoke', () => {
         ]);
         expect(add.code).toBe(1);
         expect(add.stdout).toBe('');
-        expect(add.stderr).toContain("unknown command 'add'");
+        expect(add.stderr).toMatch(/unknown (command|option)|too many arguments/);
         const yaml = await readFile(join(projectDir, 'ktx.yaml'), 'utf-8');
         expect(yaml).not.toContain('driver: notion');
         expect(yaml).not.toContain('auth_token_ref: env:NOTION_TOKEN');

package/node_modules/@ktx/context/dist/index-sync/index.d.ts

@@ -0,0 +1,2 @@
+export type { ReindexOptions, ReindexScopeResult, ReindexSummary, ReindexWorkResult } from './types.js';
+export { discoverReindexScopes, reindexLocalIndexes } from './reindex.js';

package/node_modules/@ktx/context/dist/index-sync/index.js

@@ -0,0 +1 @@
+export { discoverReindexScopes, reindexLocalIndexes } from './reindex.js';

package/node_modules/@ktx/context/dist/index-sync/reindex.d.ts

@@ -0,0 +1,20 @@
+import { type KtxLocalProject } from '../project/index.js';
+import type { ReindexOptions, ReindexSummary } from './types.js';
+type DiscoveredScope = {
+    kind: 'wiki';
+    scope: 'GLOBAL';
+    scopeId: null;
+    label: 'global';
+} | {
+    kind: 'wiki';
+    scope: 'USER';
+    scopeId: string;
+    label: `user/${string}`;
+} | {
+    kind: 'sl';
+    connectionId: string;
+    label: string;
+};
+export declare function discoverReindexScopes(project: KtxLocalProject): Promise<DiscoveredScope[]>;
+export declare function reindexLocalIndexes(project: KtxLocalProject, options: ReindexOptions): Promise<ReindexSummary>;
+export {};

package/node_modules/@ktx/context/dist/index-sync/reindex.js

@@ -0,0 +1,141 @@
+import { readdir, stat } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { ktxLocalStateDbPath } from '../project/index.js';
+import { loadLocalSlSourceRecords, SlSearchService, SqliteSlSourcesIndex } from '../sl/index.js';
+import { KnowledgeWikiService, SqliteKnowledgeIndex } from '../wiki/index.js';
+const ZERO = {
+    scanned: 0,
+    updated: 0,
+    deleted: 0,
+    embeddingsRecomputed: 0,
+    embeddingsFailed: 0,
+};
+async function directoryExists(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function childDirectories(path) {
+    try {
+        const entries = await readdir(path, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+}
+export async function discoverReindexScopes(project) {
+    const scopes = [];
+    if (await directoryExists(join(project.projectDir, 'wiki/global'))) {
+        scopes.push({ kind: 'wiki', scope: 'GLOBAL', scopeId: null, label: 'global' });
+    }
+    for (const userId of await childDirectories(join(project.projectDir, 'wiki/user'))) {
+        scopes.push({ kind: 'wiki', scope: 'USER', scopeId: userId, label: `user/${userId}` });
+    }
+    for (const connectionId of await childDirectories(join(project.projectDir, 'semantic-layer'))) {
+        if (connectionId !== '_schema') {
+            scopes.push({ kind: 'sl', connectionId, label: connectionId });
+        }
+    }
+    return scopes;
+}
+function errorMessage(error) {
+    if (!(error instanceof Error)) {
+        return String(error);
+    }
+    return error.name && error.name !== 'Error' ? `${error.name}: ${error.message}` : error.message;
+}
+function addTotals(left, right) {
+    return {
+        scanned: left.scanned + right.scanned,
+        updated: left.updated + right.updated,
+        deleted: left.deleted + right.deleted,
+        embeddingsRecomputed: left.embeddingsRecomputed + right.embeddingsRecomputed,
+        embeddingsFailed: left.embeddingsFailed + right.embeddingsFailed,
+    };
+}
+function durationSince(startedAt) {
+    return Number((process.hrtime.bigint() - startedAt) / 1000000n);
+}
+function embeddingFailureError(work) {
+    if (work.embeddingsFailed === 0) {
+        return undefined;
+    }
+    return `${work.embeddingsFailed} embedding recomputation${work.embeddingsFailed === 1 ? '' : 's'} failed`;
+}
+export async function reindexLocalIndexes(project, options) {
+    const startedAt = process.hrtime.bigint();
+    const dbPath = ktxLocalStateDbPath(project);
+    const scopes = await discoverReindexScopes(project);
+    const wikiIndex = new SqliteKnowledgeIndex({ dbPath });
+    const slIndex = new SqliteSlSourcesIndex({ dbPath });
+    const wikiService = new KnowledgeWikiService(project.fileStore, options.embeddingService, wikiIndex, project.git);
+    const slService = new SlSearchService(options.embeddingService, slIndex);
+    const results = [];
+    for (const scope of scopes) {
+        const scopeStartedAt = process.hrtime.bigint();
+        try {
+            let work;
+            if (scope.kind === 'wiki') {
+                if (options.force) {
+                    wikiIndex.clear(scope.scope, scope.scopeId);
+                }
+                work = await wikiService.syncIndex(scope.scope, scope.scopeId);
+                results.push({
+                    kind: 'wiki',
+                    label: scope.label,
+                    scope: scope.scope === 'GLOBAL' ? 'global' : 'user',
+                    scopeId: scope.scopeId,
+                    ...work,
+                    ...(options.force ? { deleted: 0 } : {}),
+                    ...(options.embeddingService && work.embeddingsFailed > 0 ? { error: embeddingFailureError(work) } : {}),
+                    durationMs: durationSince(scopeStartedAt),
+                });
+                continue;
+            }
+            if (options.force) {
+                await slIndex.clear(scope.connectionId);
+            }
+            const records = await loadLocalSlSourceRecords(project, { connectionId: scope.connectionId });
+            work = await slService.indexSources(scope.connectionId, records.map((record) => record.source));
+            results.push({
+                kind: 'sl',
+                label: scope.label,
+                connectionId: scope.connectionId,
+                ...work,
+                ...(options.force ? { deleted: 0 } : {}),
+                ...(options.embeddingService && work.embeddingsFailed > 0 ? { error: embeddingFailureError(work) } : {}),
+                durationMs: durationSince(scopeStartedAt),
+            });
+        }
+        catch (error) {
+            results.push({
+                kind: scope.kind,
+                label: scope.label,
+                ...(scope.kind === 'wiki'
+                    ? { scope: scope.scope === 'GLOBAL' ? 'global' : 'user', scopeId: scope.scopeId }
+                    : { connectionId: scope.connectionId }),
+                ...ZERO,
+                durationMs: durationSince(scopeStartedAt),
+                error: errorMessage(error),
+            });
+        }
+    }
+    return {
+        scopes: results,
+        totals: results.reduce(addTotals, ZERO),
+        dbPath: relative(project.projectDir, dbPath) || dbPath,
+        force: options.force,
+        embeddingsAvailable: options.embeddingService !== null,
+        durationMs: durationSince(startedAt),
+    };
+}

package/node_modules/@ktx/context/dist/index-sync/reindex.test.d.ts

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