bluera-knowledge 0.11.19 → 0.11.21

package/dist/mcp/server.js

@@ -1,8 +1,8 @@
 import {
   createMCPServer,
   runMCPServer
-} from "../chunk-VP4VZULK.js";
-import "../chunk-QEHSDQTL.js";
+} from "../chunk-CC6EGZ4D.js";
+import "../chunk-C4SYGLAI.js";
 import "../chunk-HRQD3MPH.js";
 export {
   createMCPServer,

package/dist/workers/background-worker-cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   IntelligentCrawler
-} from "../chunk-GOAOBPOA.js";
+} from "../chunk-QCSFBMYW.js";
 import {
   JobService,
   createDocumentId,
@@ -9,7 +9,7 @@ import {
   createServices,
   createStoreId,
   shutdownLogger
-} from "../chunk-QEHSDQTL.js";
+} from "../chunk-C4SYGLAI.js";
 import "../chunk-HRQD3MPH.js";
 
 // src/workers/background-worker.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bluera-knowledge",
-  "version": "0.11.19",
+  "version": "0.11.21",
   "description": "CLI tool for managing knowledge stores with semantic search",
   "type": "module",
   "bin": {

package/src/analysis/code-graph.test.ts

@@ -328,6 +328,36 @@ describe('CodeGraph', () => {
       expect(edgeTypes).toContain('calls');
     });
 
+    it('includes confidence in serialized edges', () => {
+      const graph = new CodeGraph();
+      const nodes: CodeNode[] = [
+        {
+          type: 'function',
+          name: 'fn',
+          exported: false,
+          startLine: 1,
+          endLine: 2,
+        },
+      ];
+
+      graph.addNodes(nodes, '/src/test.ts');
+      graph.addImport('/src/test.ts', 'module', ['util']); // confidence: 1.0
+      graph.analyzeCallRelationships('other();', '/src/test.ts', 'fn'); // confidence: 0.5
+
+      const json = graph.toJSON();
+
+      // All edges should have confidence property preserved
+      expect(json.edges.every((e) => typeof e.confidence === 'number')).toBe(true);
+
+      // Import edges have confidence 1.0
+      const importEdge = json.edges.find((e) => e.type === 'imports');
+      expect(importEdge?.confidence).toBe(1.0);
+
+      // Call edges from regex detection have confidence 0.5
+      const callEdge = json.edges.find((e) => e.type === 'calls');
+      expect(callEdge?.confidence).toBe(0.5);
+    });
+
     it('handles empty graph', () => {
       const graph = new CodeGraph();
       const json = graph.toJSON();

package/src/analysis/code-graph.ts

@@ -227,7 +227,10 @@ export class CodeGraph {
     return importPath;
   }
 
-  toJSON(): { nodes: GraphNode[]; edges: Array<{ from: string; to: string; type: string }> } {
+  toJSON(): {
+    nodes: GraphNode[];
+    edges: Array<{ from: string; to: string; type: string; confidence: number }>;
+  } {
     const allEdges: GraphEdge[] = [];
     for (const edges of this.edges.values()) {
       allEdges.push(...edges);
@@ -235,7 +238,12 @@ export class CodeGraph {
 
     return {
       nodes: Array.from(this.nodes.values()),
-      edges: allEdges.map((e) => ({ from: e.from, to: e.to, type: e.type })),
+      edges: allEdges.map((e) => ({
+        from: e.from,
+        to: e.to,
+        type: e.type,
+        confidence: e.confidence,
+      })),
     };
   }
 }

package/src/cli/commands/store.test.ts

@@ -17,8 +17,23 @@ interface MockStoreService {
   delete: MockInstance;
 }
 
+interface MockLanceService {
+  deleteStore: MockInstance;
+}
+
+interface MockCodeGraphService {
+  deleteGraph: MockInstance;
+}
+
+interface MockConfigService {
+  resolveDataDir: MockInstance;
+}
+
 interface MockServices {
   store: MockStoreService;
+  lance: MockLanceService;
+  codeGraph: MockCodeGraphService;
+  config: MockConfigService;
 }
 
 describe('store command execution', () => {
@@ -38,6 +53,15 @@ describe('store command execution', () => {
         create: vi.fn(),
         delete: vi.fn(),
       },
+      lance: {
+        deleteStore: vi.fn().mockResolvedValue(undefined),
+      },
+      codeGraph: {
+        deleteGraph: vi.fn().mockResolvedValue(undefined),
+      },
+      config: {
+        resolveDataDir: vi.fn().mockReturnValue('/tmp/test-data'),
+      },
     };
 
     vi.mocked(createServices).mockResolvedValue(mockServices);
@@ -366,6 +390,51 @@ describe('store command execution', () => {
       });
     });
 
+    it('creates repo store with branch option', async () => {
+      const mockStore: RepoStore = {
+        id: createStoreId('new-store-6'),
+        name: 'branched-repo',
+        type: 'repo',
+        path: '/path/to/cloned/repo',
+        url: 'https://github.com/user/repo',
+        branch: 'develop',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+
+      mockServices.store.create.mockResolvedValue({
+        success: true,
+        data: mockStore,
+      });
+
+      const command = createStoreCommand(getOptions);
+      const createCommand = command.commands.find((c) => c.name() === 'create');
+      const actionHandler = createCommand?._actionHandler;
+
+      createCommand.parseOptions([
+        '--type',
+        'repo',
+        '--source',
+        'https://github.com/user/repo',
+        '--branch',
+        'develop',
+      ]);
+      await actionHandler!(['branched-repo']);
+
+      expect(mockServices.store.create).toHaveBeenCalledWith({
+        name: 'branched-repo',
+        type: 'repo',
+        path: undefined,
+        url: 'https://github.com/user/repo',
+        branch: 'develop',
+        description: undefined,
+        tags: undefined,
+      });
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Created store: branched-repo')
+      );
+    });
+
     it('outputs JSON when format is json', async () => {
       const mockStore: FileStore = {
         id: createStoreId('new-store-5'),
@@ -860,6 +929,15 @@ describe('store command execution', () => {
       expect(tagsOption?.mandatory).toBe(false);
     });
 
+    it('create subcommand has --branch option for repo type', () => {
+      const command = createStoreCommand(getOptions);
+      const createCommand = command.commands.find((c) => c.name() === 'create');
+      const branchOption = createCommand?.options.find((o) => o.long === '--branch');
+
+      expect(branchOption).toBeDefined();
+      expect(branchOption?.mandatory).toBe(false);
+    });
+
     it('delete subcommand has force and yes options', () => {
       const command = createStoreCommand(getOptions);
       const deleteCommand = command.commands.find((c) => c.name() === 'delete');

package/src/cli/commands/store.ts

@@ -1,3 +1,5 @@
+import { rm } from 'node:fs/promises';
+import { join } from 'node:path';
 import { Command } from 'commander';
 import { createServices, destroyServices } from '../../services/index.js';
 import type { StoreType } from '../../types/store.js';
@@ -49,6 +51,7 @@ export function createStoreCommand(getOptions: () => GlobalOptions): Command {
       'Store type: file (local dir), repo (git), web (crawled site)'
     )
     .requiredOption('-s, --source <path>', 'Local path for file/repo stores, URL for web stores')
+    .option('-b, --branch <branch>', 'Git branch to clone (repo stores only)')
     .option('-d, --description <desc>', 'Optional description for the store')
     .option('--tags <tags>', 'Comma-separated tags for filtering')
     .action(
@@ -57,6 +60,7 @@ export function createStoreCommand(getOptions: () => GlobalOptions): Command {
         options: {
           type: StoreType;
           source: string;
+          branch?: string;
           description?: string;
           tags?: string;
         }
@@ -79,6 +83,7 @@ export function createStoreCommand(getOptions: () => GlobalOptions): Command {
               options.type === 'web' || (options.type === 'repo' && isUrl)
                 ? options.source
                 : undefined,
+            branch: options.type === 'repo' ? options.branch : undefined,
             description: options.description,
             tags: options.tags?.split(',').map((t) => t.trim()),
           });
@@ -188,6 +193,20 @@ export function createStoreCommand(getOptions: () => GlobalOptions): Command {
           }
         }
 
+        // Delete LanceDB table first (so searches don't return results for deleted store)
+        await services.lance.deleteStore(s.id);
+
+        // Delete code graph file
+        await services.codeGraph.deleteGraph(s.id);
+
+        // For repo stores cloned from URL, remove the cloned directory
+        if (s.type === 'repo' && 'url' in s && s.url !== undefined) {
+          const dataDir = services.config.resolveDataDir();
+          const repoPath = join(dataDir, 'repos', s.id);
+          await rm(repoPath, { recursive: true, force: true });
+        }
+
+        // Delete from registry last
         const result = await services.store.delete(s.id);
 
         if (result.success) {

package/src/cli/commands/sync.test.ts

@@ -49,6 +49,6 @@ describe('createSyncCommand', () => {
     expect(pruneOpt?.description).toContain('Remove');
 
     const reindexOpt = options.find((o) => o.long === '--reindex');
-    expect(reindexOpt?.description).toContain('index');
+    expect(reindexOpt?.description).toContain('Re-index');
   });
 });

package/src/cli/commands/sync.ts

@@ -1,11 +1,13 @@
 import { Command } from 'commander';
 import { createServices, destroyServices } from '../../services/index.js';
+import { JobService } from '../../services/job.service.js';
 import { StoreDefinitionService } from '../../services/store-definition.service.js';
 import {
   isFileStoreDefinition,
   isRepoStoreDefinition,
   isWebStoreDefinition,
 } from '../../types/store-definition.js';
+import { spawnBackgroundWorker } from '../../workers/spawn-worker.js';
 import type { StoreService } from '../../services/store.service.js';
 import type { StoreDefinition } from '../../types/store-definition.js';
 import type { GlobalOptions } from '../program.js';
@@ -19,6 +21,8 @@ interface SyncResult {
   dryRun: boolean;
   wouldCreate: string[];
   wouldPrune: string[];
+  reindexJobs: Array<{ store: string; jobId: string }>;
+  wouldReindex: string[];
 }
 
 /**
@@ -125,6 +129,8 @@ export function createSyncCommand(getOptions: () => GlobalOptions): Command {
           dryRun: options.dryRun === true,
           wouldCreate: [],
           wouldPrune: [],
+          reindexJobs: [],
+          wouldReindex: [],
         };
 
         // Process each definition
@@ -173,6 +179,29 @@ export function createSyncCommand(getOptions: () => GlobalOptions): Command {
           }
         }
 
+        // Re-index existing stores if requested
+        if (options.reindex === true && result.skipped.length > 0) {
+          if (options.dryRun === true) {
+            result.wouldReindex = [...result.skipped];
+          } else {
+            const dataDir = globalOpts.dataDir ?? services.config.resolveDataDir();
+            const jobService = new JobService(dataDir);
+
+            for (const storeName of result.skipped) {
+              const store = await services.store.getByName(storeName);
+              if (store !== undefined) {
+                const job = jobService.createJob({
+                  type: 'index',
+                  details: { storeId: store.id, storeName: store.name },
+                  message: `Re-indexing ${storeName}...`,
+                });
+                spawnBackgroundWorker(job.id, dataDir);
+                result.reindexJobs.push({ store: storeName, jobId: job.id });
+              }
+            }
+          }
+        }
+
         // Output result
         if (globalOpts.format === 'json') {
           console.log(JSON.stringify(result, null, 2));
@@ -189,19 +218,25 @@ export function createSyncCommand(getOptions: () => GlobalOptions): Command {
 
 function printHumanReadable(result: SyncResult, quiet: boolean): void {
   if (quiet) {
-    // Just print created/pruned store names
+    // Just print created/pruned/reindexed store names
     for (const name of result.created) {
       console.log(`created: ${name}`);
     }
     for (const name of result.pruned) {
       console.log(`pruned: ${name}`);
     }
+    for (const { store, jobId } of result.reindexJobs) {
+      console.log(`reindexing: ${store} (${jobId})`);
+    }
     for (const name of result.wouldCreate) {
       console.log(`would create: ${name}`);
     }
     for (const name of result.wouldPrune) {
       console.log(`would prune: ${name}`);
     }
+    for (const name of result.wouldReindex) {
+      console.log(`would reindex: ${name}`);
+    }
     return;
   }
 
@@ -260,5 +295,19 @@ function printHumanReadable(result: SyncResult, quiet: boolean): void {
     }
   }
 
+  if (result.reindexJobs.length > 0) {
+    console.log(`Reindexing started (${String(result.reindexJobs.length)}):`);
+    for (const { store, jobId } of result.reindexJobs) {
+      console.log(`  ↻ ${store} (Job: ${jobId})`);
+    }
+  }
+
+  if (result.wouldReindex.length > 0) {
+    console.log(`Would reindex (${String(result.wouldReindex.length)}):`);
+    for (const name of result.wouldReindex) {
+      console.log(`  ↻ ${name}`);
+    }
+  }
+
   console.log('');
 }

package/src/db/lance.test.ts

@@ -154,7 +154,7 @@ describe('LanceStore', () => {
   });
 
   describe('fullTextSearch error handling', () => {
-    it('returns empty array when FTS index does not exist', async () => {
+    it('throws error when FTS index does not exist', async () => {
       const newStoreId = createStoreId('no-fts-store');
       await store.initialize(newStoreId);
 
@@ -171,9 +171,8 @@ describe('LanceStore', () => {
 
       await store.addDocuments(newStoreId, [doc]);
 
-      // Don't create FTS index - should return empty array
-      const results = await store.fullTextSearch(newStoreId, 'test', 10);
-      expect(results).toEqual([]);
+      // Don't create FTS index - should throw error per CLAUDE.md "fail fast"
+      await expect(store.fullTextSearch(newStoreId, 'test', 10)).rejects.toThrow();
     });
   });
 

package/src/db/lance.ts

@@ -113,26 +113,21 @@ export class LanceStore {
   > {
     const table = await this.getTable(storeId);
 
-    try {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const results = (await table.search(query, 'fts').limit(limit).toArray()) as Array<{
+      id: string;
+      content: string;
+      metadata: string;
+      _score: number;
+    }>;
+
+    return results.map((r) => ({
+      id: createDocumentId(r.id),
+      content: r.content,
+      score: r._score,
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const results = (await table.search(query, 'fts').limit(limit).toArray()) as Array<{
-        id: string;
-        content: string;
-        metadata: string;
-        _score: number;
-      }>;
-
-      return results.map((r) => ({
-        id: createDocumentId(r.id),
-        content: r.content,
-        score: r._score,
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        metadata: JSON.parse(r.metadata) as DocumentMetadata,
-      }));
-    } catch {
-      // FTS index may not exist, return empty
-      return [];
-    }
+      metadata: JSON.parse(r.metadata) as DocumentMetadata,
+    }));
   }
 
   async deleteStore(storeId: StoreId): Promise<void> {

package/src/mcp/commands/sync.commands.test.ts

@@ -1,6 +1,5 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { z } from 'zod';
-import { rm, mkdtemp, mkdir, writeFile } from 'node:fs/promises';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { rm, mkdtemp, mkdir } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { syncCommands, handleStoresSync } from './sync.commands.js';
@@ -8,7 +7,11 @@ import { StoreService } from '../../services/store.service.js';
 import { StoreDefinitionService } from '../../services/store-definition.service.js';
 import type { HandlerContext } from '../types.js';
 import type { ServiceContainer } from '../../services/index.js';
-import type { StoreDefinitionsConfig } from '../../types/store-definition.js';
+
+// Mock spawnBackgroundWorker
+vi.mock('../../workers/spawn-worker.js', () => ({
+  spawnBackgroundWorker: vi.fn(),
+}));
 
 /**
  * Create a minimal mock service container for testing
@@ -45,11 +48,18 @@ describe('sync.commands', () => {
 
       // Valid with options
       const result2 = syncCmd?.argsSchema?.safeParse({
-        reindex: true,
         prune: true,
         dryRun: true,
       });
       expect(result2?.success).toBe(true);
+
+      // Valid with reindex option
+      const result3 = syncCmd?.argsSchema?.safeParse({
+        reindex: true,
+        prune: true,
+        dryRun: true,
+      });
+      expect(result3?.success).toBe(true);
     });
   });
 
@@ -69,7 +79,7 @@ describe('sync.commands', () => {
 
       context = {
         services: createMockServices(storeService),
-        options: { projectRoot },
+        options: { projectRoot, dataDir },
       };
     });
 
@@ -279,5 +289,83 @@ describe('sync.commands', () => {
         expect(response.orphans).toHaveLength(0);
       });
     });
+
+    describe('reindex mode', () => {
+      it('reports wouldReindex in dry run mode', async () => {
+        const docsDir = join(projectRoot, 'docs');
+        await mkdir(docsDir, { recursive: true });
+
+        // Create store (auto-adds definition)
+        await storeService.create({
+          name: 'existing-store',
+          type: 'file',
+          path: docsDir,
+        });
+
+        const result = await handleStoresSync({ reindex: true, dryRun: true }, context);
+        const response = JSON.parse(result.content[0].text);
+
+        expect(response.dryRun).toBe(true);
+        expect(response.wouldReindex).toContain('existing-store');
+        expect(response.reindexJobs).toBeUndefined();
+      });
+
+      it('starts reindex jobs for existing stores', async () => {
+        const docsDir = join(projectRoot, 'docs');
+        await mkdir(docsDir, { recursive: true });
+
+        // Create store (auto-adds definition)
+        await storeService.create({
+          name: 'reindex-store',
+          type: 'file',
+          path: docsDir,
+        });
+
+        const result = await handleStoresSync({ reindex: true }, context);
+        const response = JSON.parse(result.content[0].text);
+
+        expect(response.reindexJobs).toHaveLength(1);
+        expect(response.reindexJobs[0].store).toBe('reindex-store');
+        expect(response.reindexJobs[0].jobId).toMatch(/^job_/);
+      });
+
+      it('does not reindex if reindex flag is not set', async () => {
+        const docsDir = join(projectRoot, 'docs');
+        await mkdir(docsDir, { recursive: true });
+
+        await storeService.create({
+          name: 'no-reindex-store',
+          type: 'file',
+          path: docsDir,
+        });
+
+        const result = await handleStoresSync({}, context);
+        const response = JSON.parse(result.content[0].text);
+
+        expect(response.reindexJobs).toBeUndefined();
+        expect(response.wouldReindex).toBeUndefined();
+      });
+
+      it('throws error when dataDir is undefined during reindex', async () => {
+        const docsDir = join(projectRoot, 'docs');
+        await mkdir(docsDir, { recursive: true });
+
+        await storeService.create({
+          name: 'error-store',
+          type: 'file',
+          path: docsDir,
+        });
+
+        // Create context without dataDir
+        const contextWithoutDataDir: HandlerContext = {
+          services: createMockServices(storeService),
+          options: { projectRoot },
+        };
+
+        await expect(handleStoresSync({ reindex: true }, contextWithoutDataDir)).rejects.toThrow(
+          'dataDir is required for reindexing'
+        );
+      });
+    });
   });
 });

package/src/mcp/commands/sync.commands.ts

@@ -1,10 +1,12 @@
 import { z } from 'zod';
+import { JobService } from '../../services/job.service.js';
 import { StoreDefinitionService } from '../../services/store-definition.service.js';
 import {
   isFileStoreDefinition,
   isRepoStoreDefinition,
   isWebStoreDefinition,
 } from '../../types/store-definition.js';
+import { spawnBackgroundWorker } from '../../workers/spawn-worker.js';
 import type { CommandDefinition } from './registry.js';
 import type { StoreDefinition } from '../../types/store-definition.js';
 import type { HandlerContext, ToolResponse } from '../types.js';
@@ -13,9 +15,9 @@ import type { HandlerContext, ToolResponse } from '../types.js';
  * Arguments for stores:sync command
  */
 export interface SyncStoresArgs {
-  reindex?: boolean;
   prune?: boolean;
   dryRun?: boolean;
+  reindex?: boolean;
 }
 
 /**
@@ -30,6 +32,8 @@ interface SyncResult {
   dryRun?: boolean;
   wouldCreate?: string[];
   wouldPrune?: string[];
+  reindexJobs?: Array<{ store: string; jobId: string }>;
+  wouldReindex?: string[];
 }
 
 /**
@@ -39,7 +43,6 @@ interface SyncResult {
  * - Creates missing stores from definitions
  * - Reports stores not in definitions (orphans)
  * - Optionally prunes orphan stores
- * - Optionally re-indexes existing stores
  */
 export async function handleStoresSync(
   args: SyncStoresArgs,
@@ -119,6 +122,33 @@ export async function handleStoresSync(
     }
   }
 
+  // Re-index existing stores if requested
+  if (args.reindex === true && result.skipped.length > 0) {
+    if (args.dryRun === true) {
+      result.wouldReindex = [...result.skipped];
+    } else {
+      result.reindexJobs = [];
+      const dataDir = options.dataDir;
+      if (dataDir === undefined) {
+        throw new Error('dataDir is required for reindexing');
+      }
+      const jobService = new JobService(dataDir);
+
+      for (const storeName of result.skipped) {
+        const store = await services.store.getByName(storeName);
+        if (store !== undefined) {
+          const job = jobService.createJob({
+            type: 'index',
+            details: { storeId: store.id, storeName: store.name },
+            message: `Re-indexing ${storeName}...`,
+          });
+          spawnBackgroundWorker(job.id, dataDir);
+          result.reindexJobs.push({ store: storeName, jobId: job.id });
+        }
+      }
+    }
+  }
+
   return {
     content: [
       {
@@ -212,21 +242,21 @@ export const syncCommands: CommandDefinition[] = [
     name: 'stores:sync',
     description: 'Sync stores from definitions config (bootstrap on fresh clone)',
     argsSchema: z.object({
-      reindex: z.boolean().optional().describe('Re-index existing stores after sync'),
       prune: z.boolean().optional().describe('Remove stores not in definitions'),
       dryRun: z.boolean().optional().describe('Show what would happen without making changes'),
+      reindex: z.boolean().optional().describe('Re-index existing stores after sync'),
     }),
     handler: (args: Record<string, unknown>, context: HandlerContext): Promise<ToolResponse> => {
       const syncArgs: SyncStoresArgs = {};
-      if (typeof args['reindex'] === 'boolean') {
-        syncArgs.reindex = args['reindex'];
-      }
       if (typeof args['prune'] === 'boolean') {
         syncArgs.prune = args['prune'];
       }
       if (typeof args['dryRun'] === 'boolean') {
         syncArgs.dryRun = args['dryRun'];
       }
+      if (typeof args['reindex'] === 'boolean') {
+        syncArgs.reindex = args['reindex'];
+      }
       return handleStoresSync(syncArgs, context);
     },
   },