clawvault 3.0.0 → 3.2.0

package/bin/register-query-commands.js

@@ -9,13 +9,15 @@ export function registerQueryCommands(
     getVault,
     resolveVaultPath,
     QmdUnavailableError,
-    printQmdMissing
+    QmdConfigurationError,
+    printQmdMissing,
+    printQmdConfigError
   }
 ) {
   // === SEARCH ===
   program
     .command('search <query>')
-    .description('Search the vault via qmd (BM25)')
+    .description('Search the vault via qmd (BM25), optionally with semantic hybrid search')
     .option('-n, --limit <n>', 'Max results (default: 10)', '10')
     .option('-c, --category <category>', 'Filter by category')
     .option('--tags <tags>', 'Filter by tags (comma-separated)')
@@ -23,20 +25,57 @@ export function registerQueryCommands(
     .option('--full', 'Include full content in results')
     .option('-v, --vault <path>', 'Vault path')
     .option('--json', 'Output as JSON')
+    .option('--semantic', 'Enable hybrid search (BM25 + semantic with RRF)')
+    .option('--rebuild-embeddings', 'Rebuild the embedding cache before searching')
     .action(async (query, options) => {
       try {
+        const vaultPath = resolveVaultPath(options.vault);
         const vault = await getVault(options.vault);
 
-        const results = await vault.find(query, {
-          limit: parseInt(options.limit, 10),
+        // Handle --rebuild-embeddings flag
+        if (options.rebuildEmbeddings) {
+          const { rebuildEmbeddingsForVault } = await import('../dist/commands/rebuild-embeddings.js');
+          console.log(chalk.cyan('Rebuilding embedding cache...'));
+          const stats = await rebuildEmbeddingsForVault(vaultPath, { 
+            onProgress: (current, total) => {
+              process.stdout.write(`\r  Embedding ${current}/${total} documents...`);
+            }
+          });
+          console.log(chalk.green(`\n  Done. ${stats.total} embeddings (${stats.added} new, ${stats.skipped} cached)`));
+          console.log();
+        }
+
+        // Get BM25 results
+        const bm25Results = await vault.find(query, {
+          limit: options.semantic ? 50 : parseInt(options.limit, 10),
           category: options.category,
           tags: options.tags?.split(',').map((value) => value.trim()),
           fullContent: options.full,
           temporalBoost: options.recent
         });
 
+        let results = bm25Results;
+        let searchMode = 'BM25';
+
+        // Apply hybrid search if --semantic flag is set
+        if (options.semantic) {
+          const { EmbeddingCache, hybridSearch } = await import('../dist/lib/hybrid-search.js');
+          const cache = new EmbeddingCache(vaultPath);
+          cache.load();
+
+          if (cache.size === 0) {
+            console.log(chalk.yellow('Warning: No embeddings found. Run with --rebuild-embeddings to build the cache.'));
+          } else {
+            results = await hybridSearch(query, bm25Results, cache, {
+              topK: parseInt(options.limit, 10),
+              rrfK: 60
+            });
+            searchMode = 'Hybrid (BM25 + Semantic)';
+          }
+        }
+
         if (options.json) {
-          console.log(JSON.stringify(results, null, 2));
+          console.log(JSON.stringify({ searchMode, results }, null, 2));
           return;
         }
 
@@ -45,7 +84,8 @@ export function registerQueryCommands(
           return;
         }
 
-        console.log(chalk.cyan(`\n🔍 Found ${results.length} result(s) for "${query}":\n`));
+        const icon = options.semantic ? '🔍🧠' : '🔍';
+        console.log(chalk.cyan(`\n${icon} Found ${results.length} result(s) for "${query}" [${searchMode}]:\n`));
 
         for (const result of results) {
           const scoreBar = '█'.repeat(Math.round(result.score * 10)).padEnd(10, '░');
@@ -62,6 +102,10 @@ export function registerQueryCommands(
           printQmdMissing();
           process.exit(1);
         }
+        if (err instanceof QmdConfigurationError) {
+          printQmdConfigError(err);
+          process.exit(1);
+        }
         console.error(chalk.red(`Error: ${err.message}`));
         process.exit(1);
       }
@@ -117,6 +161,10 @@ export function registerQueryCommands(
           printQmdMissing();
           process.exit(1);
         }
+        if (err instanceof QmdConfigurationError) {
+          printQmdConfigError(err);
+          process.exit(1);
+        }
         console.error(chalk.red(`Error: ${err.message}`));
         process.exit(1);
       }
@@ -163,6 +211,10 @@ export function registerQueryCommands(
           printQmdMissing();
           process.exit(1);
         }
+        if (err instanceof QmdConfigurationError) {
+          printQmdConfigError(err);
+          process.exit(1);
+        }
         console.error(chalk.red(`Error: ${err.message}`));
         process.exit(1);
       }
@@ -292,29 +344,6 @@ export function registerQueryCommands(
       }
     });
 
-  // === REWEAVE ===
-  program
-    .command('reweave')
-    .description('Backward memory consolidation — detect and mark superseded observations')
-    .option('--since <date>', 'Only check observations since this date (YYYY-MM-DD)')
-    .option('--dry-run', 'Show what would be superseded without writing')
-    .option('--threshold <n>', 'Entity similarity threshold (0-1, default 0.3)', '0.3')
-    .option('-v, --vault <path>', 'Vault path')
-    .action(async (options) => {
-      try {
-        const { reweaveCommand } = await import('../dist/commands/reweave.js');
-        await reweaveCommand({
-          vaultPath: resolveVaultPath(options.vault),
-          since: options.since,
-          dryRun: options.dryRun,
-          threshold: parseFloat(options.threshold),
-        });
-      } catch (err) {
-        console.error(chalk.red(`Error: ${err.message}`));
-        process.exit(1);
-      }
-    });
-
   // === SESSION-RECAP ===
   program
     .command('session-recap <sessionKey>')

package/bin/register-task-commands.js

@@ -1,6 +1,6 @@
 /**
  * Task tracking command registrations for ClawVault
- * Registers task, backlog, and blocked commands
+ * Registers task, backlog, blocked, and canvas commands
  */
 
 function parseCsvList(value) {
@@ -328,4 +328,21 @@ export function registerTaskCommands(
     });
 
   // === CANVAS ===
+  program
+    .command('canvas')
+    .description('Generate an Obsidian canvas dashboard file')
+    .option('-v, --vault <path>', 'Vault path (default: find nearest)')
+    .option('--output <path>', 'Output file path (default: dashboard.canvas)')
+    .action(async (options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { canvasCommand } = await import('../dist/commands/canvas.js');
+        await canvasCommand(vaultPath, {
+          output: options.output
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
 }

package/bin/register-task-commands.test.js

@@ -50,4 +50,20 @@ describe('register-task-commands', () => {
     ]));
   });
 
+  it('adds simplified canvas flags', () => {
+    const program = new Command();
+    registerTaskCommands(program, {
+      chalk: chalkStub,
+      resolveVaultPath: stubResolveVaultPath
+    });
+
+    const canvasCommand = program.commands.find((command) => command.name() === 'canvas');
+    expect(canvasCommand).toBeDefined();
+
+    const optionFlags = canvasCommand?.options.map((option) => option.flags) ?? [];
+    expect(optionFlags).toEqual(expect.arrayContaining([
+      '-v, --vault <path>',
+      '--output <path>'
+    ]));
+  });
 });

package/bin/register-vault-operations-commands.js

@@ -1,5 +1,5 @@
 /**
- * Vault operation command registrations (browse/sync/reindex/remember/shell-init).
+ * Vault operation command registrations (browse/sync/reindex/remember/shell-init/dashboard).
  */
 
 import { validatePathWithinBase } from './command-runtime.js';
@@ -269,4 +269,32 @@ export function registerVaultOperationsCommands(
       }
     });
 
+  // === DASHBOARD ===
+  program
+    .command('dashboard')
+    .description('Run the local vault graph dashboard server')
+    .option('-p, --port <port>', 'Dashboard port (default: 3377)', '3377')
+    .option('-v, --vault <path>', 'Vault path')
+    .action(async (options) => {
+      try {
+        const parsedPort = Number.parseInt(options.port, 10);
+        if (Number.isNaN(parsedPort)) {
+          console.error(chalk.red(`Error: Invalid port: ${options.port}`));
+          process.exit(1);
+        }
+
+        const vaultPath = options.vault
+          ? path.resolve(options.vault)
+          : resolveVaultPath(undefined);
+
+        const { startDashboard } = await import('../dashboard/server.js');
+        await startDashboard({
+          port: parsedPort,
+          vaultPath
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
 }