bluera-knowledge 0.14.0 → 0.14.1

package/src/cli/commands/store.ts

@@ -1,229 +0,0 @@
-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';
-import type { GlobalOptions } from '../program.js';
-
-export function createStoreCommand(getOptions: () => GlobalOptions): Command {
-  const store = new Command('store').description(
-    'Manage knowledge stores (collections of indexed documents)'
-  );
-
-  store
-    .command('list')
-    .description('Show all stores with their type (file/repo/web) and ID')
-    .option('-t, --type <type>', 'Filter by type: file, repo, or web')
-    .action(async (options: { type?: StoreType }) => {
-      const globalOpts = getOptions();
-      const services = await createServices(globalOpts.config, globalOpts.dataDir);
-      try {
-        const stores = await services.store.list(options.type);
-
-        if (globalOpts.format === 'json') {
-          console.log(JSON.stringify(stores, null, 2));
-        } else if (globalOpts.quiet === true) {
-          // Quiet mode: just list store names, one per line
-          for (const s of stores) {
-            console.log(s.name);
-          }
-        } else {
-          if (stores.length === 0) {
-            console.log('No stores found.');
-          } else {
-            console.log('\nStores:\n');
-            for (const s of stores) {
-              console.log(`  ${s.name} (${s.type}) - ${s.id}`);
-            }
-            console.log('');
-          }
-        }
-      } finally {
-        await destroyServices(services);
-      }
-    });
-
-  store
-    .command('create <name>')
-    .description('Create a new store pointing to a local path or URL')
-    .requiredOption(
-      '-t, --type <type>',
-      '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(
-      async (
-        name: string,
-        options: {
-          type: StoreType;
-          source: string;
-          branch?: string;
-          description?: string;
-          tags?: string;
-        }
-      ) => {
-        const globalOpts = getOptions();
-        const services = await createServices(globalOpts.config, globalOpts.dataDir);
-        let exitCode = 0;
-        try {
-          // Detect if source is a URL (for repo stores that should clone from remote)
-          const isUrl =
-            options.source.startsWith('http://') || options.source.startsWith('https://');
-          const result = await services.store.create({
-            name,
-            type: options.type,
-            path:
-              options.type === 'file' || (options.type === 'repo' && !isUrl)
-                ? options.source
-                : undefined,
-            url:
-              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()),
-          });
-
-          if (result.success) {
-            if (globalOpts.format === 'json') {
-              console.log(JSON.stringify(result.data, null, 2));
-            } else {
-              console.log(`\nCreated store: ${result.data.name} (${result.data.id})\n`);
-            }
-          } else {
-            console.error(`Error: ${result.error.message}`);
-            exitCode = 1;
-          }
-        } finally {
-          await destroyServices(services);
-        }
-        if (exitCode !== 0) {
-          // Set exit code and let Node.js exit naturally after event loop drains
-          // Using process.exit() causes mutex crashes from native code (LanceDB, tree-sitter)
-          process.exitCode = exitCode;
-        }
-      }
-    );
-
-  store
-    .command('info <store>')
-    .description('Show store details: ID, type, path/URL, timestamps')
-    .action(async (storeIdOrName: string) => {
-      const globalOpts = getOptions();
-      const services = await createServices(globalOpts.config, globalOpts.dataDir);
-      let exitCode = 0;
-      storeInfo: try {
-        const s = await services.store.getByIdOrName(storeIdOrName);
-
-        if (s === undefined) {
-          console.error(`Error: Store not found: ${storeIdOrName}`);
-          exitCode = 3;
-          break storeInfo;
-        }
-
-        if (globalOpts.format === 'json') {
-          console.log(JSON.stringify(s, null, 2));
-        } else {
-          console.log(`\nStore: ${s.name}`);
-          console.log(`  ID: ${s.id}`);
-          console.log(`  Type: ${s.type}`);
-          if ('path' in s) console.log(`  Path: ${s.path}`);
-          if ('url' in s && s.url !== undefined) console.log(`  URL: ${s.url}`);
-          if (s.description !== undefined) console.log(`  Description: ${s.description}`);
-          console.log(`  Created: ${s.createdAt.toISOString()}`);
-          console.log(`  Updated: ${s.updatedAt.toISOString()}`);
-          console.log('');
-        }
-      } finally {
-        await destroyServices(services);
-      }
-      if (exitCode !== 0) {
-        // Set exit code and let Node.js exit naturally after event loop drains
-        // Using process.exit() causes mutex crashes from native code (LanceDB, tree-sitter)
-        process.exitCode = exitCode;
-      }
-    });
-
-  store
-    .command('delete <store>')
-    .description('Remove store and its indexed documents from LanceDB')
-    .option('-f, --force', 'Delete without confirmation prompt')
-    .option('-y, --yes', 'Alias for --force')
-    .action(async (storeIdOrName: string, options: { force?: boolean; yes?: boolean }) => {
-      const globalOpts = getOptions();
-      const services = await createServices(globalOpts.config, globalOpts.dataDir);
-      let exitCode = 0;
-      storeDelete: try {
-        const s = await services.store.getByIdOrName(storeIdOrName);
-
-        if (s === undefined) {
-          console.error(`Error: Store not found: ${storeIdOrName}`);
-          exitCode = 3;
-          break storeDelete;
-        }
-
-        // Require --force or -y in non-TTY mode, prompt in TTY mode
-        const skipConfirmation = options.force === true || options.yes === true;
-        if (!skipConfirmation) {
-          if (!process.stdin.isTTY) {
-            console.error(
-              'Error: Use --force or -y to delete without confirmation in non-interactive mode'
-            );
-            exitCode = 1;
-            break storeDelete;
-          }
-          // Interactive confirmation
-          const readline = await import('node:readline');
-          const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-          });
-          const answer = await new Promise<string>((resolve) => {
-            rl.question(`Delete store "${s.name}"? [y/N] `, resolve);
-          });
-          rl.close();
-          if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== 'yes') {
-            console.log('Cancelled.');
-            // exitCode stays 0 for user-initiated cancellation
-            break storeDelete;
-          }
-        }
-
-        // 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) {
-          console.log(`Deleted store: ${s.name}`);
-        } else {
-          console.error(`Error: ${result.error.message}`);
-          exitCode = 1;
-        }
-      } finally {
-        await destroyServices(services);
-      }
-      if (exitCode !== 0) {
-        // Set exit code and let Node.js exit naturally after event loop drains
-        // Using process.exit() causes mutex crashes from native code (LanceDB, tree-sitter)
-        process.exitCode = exitCode;
-      }
-    });
-
-  return store;
-}

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

@@ -1,54 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { createSyncCommand } from './sync.js';
-import type { GlobalOptions } from '../program.js';
-
-describe('createSyncCommand', () => {
-  function createTestOptions(): GlobalOptions {
-    return {
-      dataDir: '/tmp/test-data',
-      projectRoot: '/tmp/test-project',
-      format: 'table',
-    };
-  }
-
-  it('creates sync command with correct name and description', () => {
-    const cmd = createSyncCommand(createTestOptions);
-    expect(cmd.name()).toBe('sync');
-    expect(cmd.description()).toContain('Sync');
-  });
-
-  it('has --dry-run option', () => {
-    const cmd = createSyncCommand(createTestOptions);
-    const options = cmd.options;
-    const dryRunOpt = options.find((o) => o.long === '--dry-run');
-    expect(dryRunOpt).toBeDefined();
-  });
-
-  it('has --prune option', () => {
-    const cmd = createSyncCommand(createTestOptions);
-    const options = cmd.options;
-    const pruneOpt = options.find((o) => o.long === '--prune');
-    expect(pruneOpt).toBeDefined();
-  });
-
-  it('has --reindex option', () => {
-    const cmd = createSyncCommand(createTestOptions);
-    const options = cmd.options;
-    const reindexOpt = options.find((o) => o.long === '--reindex');
-    expect(reindexOpt).toBeDefined();
-  });
-
-  it('has correct option descriptions', () => {
-    const cmd = createSyncCommand(createTestOptions);
-    const options = cmd.options;
-
-    const dryRunOpt = options.find((o) => o.long === '--dry-run');
-    expect(dryRunOpt?.description).toContain('without making changes');
-
-    const pruneOpt = options.find((o) => o.long === '--prune');
-    expect(pruneOpt?.description).toContain('Remove');
-
-    const reindexOpt = options.find((o) => o.long === '--reindex');
-    expect(reindexOpt?.description).toContain('Re-index');
-  });
-});

package/src/cli/commands/sync.ts

@@ -1,313 +0,0 @@
-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';
-
-interface SyncResult {
-  created: string[];
-  skipped: string[];
-  failed: Array<{ name: string; error: string }>;
-  orphans: string[];
-  pruned: string[];
-  dryRun: boolean;
-  wouldCreate: string[];
-  wouldPrune: string[];
-  reindexJobs: Array<{ store: string; jobId: string }>;
-  wouldReindex: string[];
-}
-
-/**
- * Create a store from a definition
- */
-async function createStoreFromDefinition(
-  def: StoreDefinition,
-  defService: StoreDefinitionService,
-  storeService: StoreService
-): Promise<{ success: true } | { success: false; error: string }> {
-  try {
-    if (isFileStoreDefinition(def)) {
-      const resolvedPath = defService.resolvePath(def.path);
-      const createResult = await storeService.create(
-        {
-          name: def.name,
-          type: 'file',
-          path: resolvedPath,
-          description: def.description,
-          tags: def.tags,
-        },
-        { skipDefinitionSync: true }
-      );
-      if (!createResult.success) {
-        return { success: false, error: createResult.error.message };
-      }
-      return { success: true };
-    }
-
-    if (isRepoStoreDefinition(def)) {
-      const createResult = await storeService.create(
-        {
-          name: def.name,
-          type: 'repo',
-          url: def.url,
-          branch: def.branch,
-          depth: def.depth,
-          description: def.description,
-          tags: def.tags,
-        },
-        { skipDefinitionSync: true }
-      );
-      if (!createResult.success) {
-        return { success: false, error: createResult.error.message };
-      }
-      return { success: true };
-    }
-
-    if (isWebStoreDefinition(def)) {
-      const createResult = await storeService.create(
-        {
-          name: def.name,
-          type: 'web',
-          url: def.url,
-          depth: def.depth,
-          description: def.description,
-          tags: def.tags,
-        },
-        { skipDefinitionSync: true }
-      );
-      if (!createResult.success) {
-        return { success: false, error: createResult.error.message };
-      }
-      return { success: true };
-    }
-
-    return { success: false, error: 'Unknown store definition type' };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error),
-    };
-  }
-}
-
-export function createSyncCommand(getOptions: () => GlobalOptions): Command {
-  const sync = new Command('sync').description(
-    'Sync stores from definitions config (bootstrap on fresh clone)'
-  );
-
-  sync
-    .option('--dry-run', 'Show what would happen without making changes')
-    .option('--prune', 'Remove stores not in definitions')
-    .option('--reindex', 'Re-index existing stores after sync')
-    .action(async (options: { dryRun?: boolean; prune?: boolean; reindex?: boolean }) => {
-      const globalOpts = getOptions();
-      const projectRoot = globalOpts.projectRoot ?? process.cwd();
-
-      const defService = new StoreDefinitionService(projectRoot);
-      const services = await createServices(globalOpts.config, globalOpts.dataDir, projectRoot);
-
-      try {
-        const config = await defService.load();
-        const existingStores = await services.store.list();
-        const existingNames = new Set(existingStores.map((s) => s.name));
-        const definedNames = new Set(config.stores.map((d) => d.name));
-
-        const result: SyncResult = {
-          created: [],
-          skipped: [],
-          failed: [],
-          orphans: [],
-          pruned: [],
-          dryRun: options.dryRun === true,
-          wouldCreate: [],
-          wouldPrune: [],
-          reindexJobs: [],
-          wouldReindex: [],
-        };
-
-        // Process each definition
-        for (const def of config.stores) {
-          if (existingNames.has(def.name)) {
-            result.skipped.push(def.name);
-            continue;
-          }
-
-          if (options.dryRun === true) {
-            result.wouldCreate.push(def.name);
-            continue;
-          }
-
-          const createResult = await createStoreFromDefinition(def, defService, services.store);
-          if (createResult.success) {
-            result.created.push(def.name);
-          } else {
-            result.failed.push({ name: def.name, error: createResult.error });
-          }
-        }
-
-        // Find orphans
-        for (const store of existingStores) {
-          if (!definedNames.has(store.name)) {
-            result.orphans.push(store.name);
-          }
-        }
-
-        // Prune orphans if requested
-        if (options.prune === true && result.orphans.length > 0) {
-          if (options.dryRun === true) {
-            result.wouldPrune = [...result.orphans];
-          } else {
-            for (const orphanName of result.orphans) {
-              const store = await services.store.getByName(orphanName);
-              if (store !== undefined) {
-                const deleteResult = await services.store.delete(store.id, {
-                  skipDefinitionSync: true,
-                });
-                if (deleteResult.success) {
-                  result.pruned.push(orphanName);
-                }
-              }
-            }
-          }
-        }
-
-        // 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));
-        } else {
-          printHumanReadable(result, globalOpts.quiet === true);
-        }
-      } finally {
-        await destroyServices(services);
-      }
-    });
-
-  return sync;
-}
-
-function printHumanReadable(result: SyncResult, quiet: boolean): void {
-  if (quiet) {
-    // 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;
-  }
-
-  if (result.dryRun) {
-    console.log('\n[DRY RUN] No changes made.\n');
-  } else {
-    console.log('\nSync completed.\n');
-  }
-
-  if (result.created.length > 0) {
-    console.log(`Created (${String(result.created.length)}):`);
-    for (const name of result.created) {
-      console.log(`  + ${name}`);
-    }
-  }
-
-  if (result.wouldCreate.length > 0) {
-    console.log(`Would create (${String(result.wouldCreate.length)}):`);
-    for (const name of result.wouldCreate) {
-      console.log(`  + ${name}`);
-    }
-  }
-
-  if (result.skipped.length > 0) {
-    console.log(`Skipped (already exist) (${String(result.skipped.length)}):`);
-    for (const name of result.skipped) {
-      console.log(`  - ${name}`);
-    }
-  }
-
-  if (result.failed.length > 0) {
-    console.log(`Failed (${String(result.failed.length)}):`);
-    for (const { name, error } of result.failed) {
-      console.log(`  ! ${name}: ${error}`);
-    }
-  }
-
-  if (result.orphans.length > 0) {
-    console.log(`Orphans (not in definitions) (${String(result.orphans.length)}):`);
-    for (const name of result.orphans) {
-      console.log(`  ? ${name}`);
-    }
-  }
-
-  if (result.pruned.length > 0) {
-    console.log(`Pruned (${String(result.pruned.length)}):`);
-    for (const name of result.pruned) {
-      console.log(`  x ${name}`);
-    }
-  }
-
-  if (result.wouldPrune.length > 0) {
-    console.log(`Would prune (${String(result.wouldPrune.length)}):`);
-    for (const name of result.wouldPrune) {
-      console.log(`  x ${name}`);
-    }
-  }
-
-  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/cli/index.ts

@@ -1,8 +0,0 @@
-export { createProgram, getGlobalOptions, type GlobalOptions } from './program.js';
-export { createStoreCommand } from './commands/store.js';
-export { createSearchCommand } from './commands/search.js';
-export { createIndexCommand } from './commands/index-cmd.js';
-export { createServeCommand } from './commands/serve.js';
-export { createCrawlCommand } from './commands/crawl.js';
-export { createSetupCommand } from './commands/setup.js';
-export { createSyncCommand } from './commands/sync.js';

package/src/cli/program.ts

@@ -1,59 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { Command } from 'commander';
-
-interface PackageJson {
-  version: string;
-}
-
-function getVersion(): string {
-  const __filename = fileURLToPath(import.meta.url);
-  const __dirname = dirname(__filename);
-  const content = readFileSync(join(__dirname, '../package.json'), 'utf-8');
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-  const pkg: PackageJson = JSON.parse(content);
-  return pkg.version;
-}
-
-const version = getVersion();
-
-export function createProgram(): Command {
-  const program = new Command();
-
-  program
-    .name('bluera-knowledge')
-    .description('CLI tool for managing knowledge stores with semantic search')
-    .version(version);
-
-  program
-    .option('-c, --config <path>', 'Path to config file')
-    .option('-d, --data-dir <path>', 'Data directory')
-    .option('-p, --project-root <path>', 'Project root directory (for resolving relative paths)')
-    .option('-f, --format <format>', 'Output format: json | table | plain', 'table')
-    .option('-q, --quiet', 'Suppress non-essential output')
-    .option('-v, --verbose', 'Enable verbose logging');
-
-  return program;
-}
-
-export interface GlobalOptions {
-  config?: string | undefined;
-  dataDir?: string | undefined;
-  projectRoot?: string | undefined;
-  format: 'json' | 'table' | 'plain';
-  quiet?: boolean | undefined;
-  verbose?: boolean | undefined;
-}
-
-export function getGlobalOptions(program: Command): GlobalOptions {
-  const opts = program.opts<GlobalOptions>();
-  return {
-    config: opts.config,
-    dataDir: opts.dataDir,
-    projectRoot: opts.projectRoot,
-    format: opts.format,
-    quiet: opts.quiet,
-    verbose: opts.verbose,
-  };
-}