bluera-knowledge 0.9.43 → 0.10.1

package/dist/index.js

@@ -1,10 +1,14 @@
 #!/usr/bin/env node
 import {
+  StoreDefinitionService,
+  isFileStoreDefinition,
+  isRepoStoreDefinition,
+  isWebStoreDefinition,
   runMCPServer
-} from "./chunk-CUHYSPRV.js";
+} from "./chunk-DP5XBPQV.js";
 import {
   IntelligentCrawler
-} from "./chunk-MQE32YY6.js";
+} from "./chunk-6U45VP5Z.js";
 import {
   ASTParser,
   ChunkingService,
@@ -16,7 +20,7 @@ import {
   err,
   extractRepoName,
   ok
-} from "./chunk-DWAIT2OD.js";
+} from "./chunk-UE4ZIJYA.js";
 import "./chunk-6FHWC36B.js";
 
 // src/index.ts
@@ -34,7 +38,7 @@ function createCrawlCommand(getOptions) {
   ).option(
     "--extract <instruction>",
     'Natural language instruction for what to extract (e.g., "extract API references")'
-  ).option("--simple", "Use simple BFS mode instead of intelligent crawling").option("--max-pages <number>", "Maximum number of pages to crawl", "50").option("--headless", "Use headless browser for JavaScript-rendered sites").action(
+  ).option("--simple", "Use simple BFS mode instead of intelligent crawling").option("--max-pages <number>", "Maximum number of pages to crawl", "50").option("--fast", "Use fast axios-only mode (may fail on JavaScript-heavy sites)").action(
     async (url, storeIdOrName, cmdOptions) => {
       const globalOpts = getOptions();
       const services = await createServices(globalOpts.config, globalOpts.dataDir);
@@ -105,7 +109,8 @@ function createCrawlCommand(getOptions) {
           ...cmdOptions.extract !== void 0 && { extractInstruction: cmdOptions.extract },
           maxPages,
           ...cmdOptions.simple !== void 0 && { simple: cmdOptions.simple },
-          useHeadless: cmdOptions.headless ?? false
+          useHeadless: !(cmdOptions.fast ?? false)
+          // Default true (headless), --fast disables
         })) {
           const contentToProcess = result.extracted ?? result.markdown;
           const chunks = webChunker.chunk(contentToProcess, `${result.url}.md`);
@@ -1530,11 +1535,214 @@ Store: ${s.name}`);
   return store;
 }
 
+// src/cli/commands/sync.ts
+import { Command as Command9 } from "commander";
+async function createStoreFromDefinition(def, defService, storeService) {
+  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)
+    };
+  }
+}
+function createSyncCommand(getOptions) {
+  const sync = new Command9("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) => {
+    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 = {
+        created: [],
+        skipped: [],
+        failed: [],
+        orphans: [],
+        pruned: [],
+        dryRun: options.dryRun === true,
+        wouldCreate: [],
+        wouldPrune: []
+      };
+      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 });
+        }
+      }
+      for (const store of existingStores) {
+        if (!definedNames.has(store.name)) {
+          result.orphans.push(store.name);
+        }
+      }
+      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 !== void 0) {
+              const deleteResult = await services.store.delete(store.id, {
+                skipDefinitionSync: true
+              });
+              if (deleteResult.success) {
+                result.pruned.push(orphanName);
+              }
+            }
+          }
+        }
+      }
+      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, quiet) {
+  if (quiet) {
+    for (const name of result.created) {
+      console.log(`created: ${name}`);
+    }
+    for (const name of result.pruned) {
+      console.log(`pruned: ${name}`);
+    }
+    for (const name of result.wouldCreate) {
+      console.log(`would create: ${name}`);
+    }
+    for (const name of result.wouldPrune) {
+      console.log(`would prune: ${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}`);
+    }
+  }
+  console.log("");
+}
+
 // src/cli/program.ts
 import { readFileSync } from "fs";
 import { dirname, join as join3 } from "path";
 import { fileURLToPath } from "url";
-import { Command as Command9 } from "commander";
+import { Command as Command10 } from "commander";
 function getVersion() {
   const __filename2 = fileURLToPath(import.meta.url);
   const __dirname2 = dirname(__filename2);
@@ -1544,7 +1752,7 @@ function getVersion() {
 }
 var version = getVersion();
 function createProgram() {
-  const program2 = new Command9();
+  const program2 = new Command10();
   program2.name("bluera-knowledge").description("CLI tool for managing knowledge stores with semantic search").version(version);
   program2.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 program2;
@@ -1619,6 +1827,7 @@ program.addCommand(createIndexCommand(() => getGlobalOptions(program)));
 program.addCommand(createServeCommand(() => getGlobalOptions(program)));
 program.addCommand(createCrawlCommand(() => getGlobalOptions(program)));
 program.addCommand(createSetupCommand(() => getGlobalOptions(program)));
+program.addCommand(createSyncCommand(() => getGlobalOptions(program)));
 program.addCommand(createMCPCommand(() => getGlobalOptions(program)));
 if (process.argv.length <= 2) {
   printFullHelp(program);