bluera-knowledge 0.9.21

package/src/cli/commands/setup.ts

@@ -0,0 +1,153 @@
+import { Command } from 'commander';
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import ora from 'ora';
+import { createServices, destroyServices } from '../../services/index.js';
+import { DEFAULT_REPOS, type DefaultRepo } from '../../defaults/repos.js';
+import type { GlobalOptions } from '../program.js';
+
+const DEFAULT_REPOS_DIR = join(homedir(), '.bluera', 'bluera-knowledge', 'repos');
+
+export function createSetupCommand(getOptions: () => GlobalOptions): Command {
+  const setup = new Command('setup')
+    .description('Quick-start with pre-configured Claude/Anthropic documentation repos');
+
+  setup
+    .command('repos')
+    .description('Clone repos to ~/.bluera/bluera-knowledge/repos/, create stores, index all content')
+    .option('--repos-dir <path>', 'Clone destination (default: ~/.bluera/bluera-knowledge/repos/)', DEFAULT_REPOS_DIR)
+    .option('--skip-clone', 'Don\'t clone; assume repos already exist locally')
+    .option('--skip-index', 'Clone and create stores but don\'t index yet')
+    .option('--only <names>', 'Only process matching repos (comma-separated, partial match)')
+    .option('--list', 'Print available repos without cloning/indexing')
+    .action(async (options: {
+      reposDir: string;
+      skipClone?: boolean;
+      skipIndex?: boolean;
+      only?: string;
+      list?: boolean;
+    }) => {
+      const globalOpts = getOptions();
+
+      // List mode: just show available repos
+      if (options.list === true) {
+        console.log('\nDefault repositories:\n');
+        for (const repo of DEFAULT_REPOS) {
+          console.log(`  ${repo.name}`);
+          console.log(`    URL: ${repo.url}`);
+          console.log(`    Description: ${repo.description}`);
+          console.log(`    Tags: ${repo.tags.join(', ')}`);
+          console.log('');
+        }
+        return;
+      }
+
+      const services = await createServices(globalOpts.config, globalOpts.dataDir);
+      try {
+        // Filter repos if --only specified
+        let repos: readonly DefaultRepo[] = DEFAULT_REPOS;
+        if (options.only !== undefined && options.only !== '') {
+          const onlyNames = options.only.split(',').map(n => n.trim().toLowerCase());
+          repos = DEFAULT_REPOS.filter(r =>
+            onlyNames.some(n => r.name.toLowerCase().includes(n))
+          );
+          if (repos.length === 0) {
+            console.error(`No repos matched: ${options.only}`);
+            console.log('Available repos:', DEFAULT_REPOS.map(r => r.name).join(', '));
+            process.exit(1);
+          }
+        }
+
+        console.log(`\nSetting up ${String(repos.length)} repositories...\n`);
+
+        // Ensure repos directory exists
+        await mkdir(options.reposDir, { recursive: true });
+
+        for (const repo of repos) {
+          const repoPath = join(options.reposDir, repo.name);
+          const spinner = ora(`Processing ${repo.name}`).start();
+
+          try {
+            // Step 1: Clone if needed
+            if (options.skipClone !== true) {
+              if (existsSync(repoPath)) {
+                spinner.text = `${repo.name}: Already cloned, pulling latest...`;
+                const pullResult = spawnSync('git', ['pull', '--ff-only'], { cwd: repoPath, stdio: 'pipe' });
+                if (pullResult.status !== 0) {
+                  // Pull failed (maybe diverged), that's okay
+                  spinner.text = `${repo.name}: Pull skipped (local changes)`;
+                }
+              } else {
+                spinner.text = `${repo.name}: Cloning...`;
+                const cloneResult = spawnSync('git', ['clone', repo.url, repoPath], { stdio: 'pipe' });
+                if (cloneResult.status !== 0) {
+                  const errorMessage = cloneResult.stderr.length > 0
+                    ? cloneResult.stderr.toString()
+                    : 'Git clone failed';
+                  throw new Error(errorMessage);
+                }
+              }
+            }
+
+            // Step 2: Create store if needed
+            spinner.text = `${repo.name}: Creating store...`;
+            const existingStore = await services.store.getByIdOrName(repo.name);
+
+            let storeId: string;
+            if (existingStore) {
+              storeId = existingStore.id;
+              spinner.text = `${repo.name}: Store already exists`;
+            } else {
+              const result = await services.store.create({
+                name: repo.name,
+                type: 'repo',
+                path: repoPath,
+                description: repo.description,
+                tags: repo.tags,
+              });
+
+              if (!result.success) {
+                throw new Error(result.error instanceof Error ? result.error.message : String(result.error));
+              }
+              storeId = result.data.id;
+            }
+
+            // Step 3: Index if needed
+            if (options.skipIndex !== true) {
+              spinner.text = `${repo.name}: Indexing...`;
+              const store = await services.store.getByIdOrName(storeId);
+              if (store) {
+                await services.lance.initialize(store.id);
+                const indexResult = await services.index.indexStore(store, (event) => {
+                  if (event.type === 'progress') {
+                    spinner.text = `${repo.name}: Indexing ${String(event.current)}/${String(event.total)} files`;
+                  }
+                });
+
+                if (indexResult.success) {
+                  spinner.succeed(
+                    `${repo.name}: ${String(indexResult.data.documentsIndexed)} docs, ${String(indexResult.data.chunksCreated)} chunks`
+                  );
+                } else {
+                  throw new Error(indexResult.error instanceof Error ? indexResult.error.message : String(indexResult.error));
+                }
+              }
+            } else {
+              spinner.succeed(`${repo.name}: Ready (indexing skipped)`);
+            }
+          } catch (error) {
+            spinner.fail(`${repo.name}: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        }
+
+        console.log('\nSetup complete! Use "bluera-knowledge search <query>" to search.\n');
+      } finally {
+        await destroyServices(services);
+      }
+    });
+
+  return setup;
+}