clawvault 2.3.0 → 2.4.0

package/bin/clawvault.js

@@ -16,7 +16,10 @@ import { registerResilienceCommands } from './register-resilience-commands.js';
 import { registerSessionLifecycleCommands } from './register-session-lifecycle-commands.js';
 import { registerTemplateCommands } from './register-template-commands.js';
 import { registerVaultOperationsCommands } from './register-vault-operations-commands.js';
+
 import { registerTaskCommands } from './register-task-commands.js';
+
+import { registerTailscaleCommands } from './register-tailscale-commands.js';
 import {
   getVault,
   resolveVaultPath,
@@ -83,10 +86,13 @@ registerVaultOperationsCommands(program, {
   path
 });
 
+
 registerTaskCommands(program, {
   chalk,
   resolveVaultPath
 });
 
+registerTailscaleCommands(program, { chalk });
+
 // Parse and run
 program.parse();

package/bin/register-core-commands.js

@@ -13,6 +13,13 @@ export function registerCoreCommands(
     .option('-n, --name <name>', 'Vault name')
     .option('--qmd', 'Set up qmd semantic search collection')
     .option('--qmd-collection <name>', 'qmd collection name (defaults to vault name)')
+    .option('--no-bases', 'Skip Obsidian Bases file generation')
+    .option('--no-tasks', 'Skip tasks/ and backlog/ directories')
+    .option('--no-graph', 'Skip initial graph build')
+    .option('--categories <list>', 'Comma-separated list of custom categories to create')
+    .option('--canvas <template>', 'Generate a canvas dashboard on init (default, brain, project-board, sprint)')
+    .option('--theme <style>', 'Graph color theme to apply (neural, minimal, none)', 'none')
+    .option('--minimal', 'Create minimal vault (memory categories only, no tasks/bases/graph)')
     .action(async (vaultPath, options) => {
       const targetPath = vaultPath || '.';
       console.log(chalk.cyan(`\n🐘 Initializing ClawVault at ${path.resolve(targetPath)}...\n`));
@@ -67,10 +74,26 @@ export function registerCoreCommands(
   program
     .command('setup')
     .description('Auto-discover and configure a ClawVault')
-    .action(async () => {
+    .option('--graph-colors', 'Set up graph color scheme for Obsidian')
+    .option('--no-graph-colors', 'Skip graph color configuration')
+    .option('--bases', 'Generate Obsidian Bases views for task management')
+    .option('--no-bases', 'Skip Bases file generation')
+    .option('--canvas [template]', 'Generate canvas dashboard (default, brain, project-board, sprint)')
+    .option('--no-canvas', 'Skip canvas generation')
+    .option('--theme <style>', 'Graph color theme (neural, minimal, none)', 'neural')
+    .option('--force', 'Overwrite existing configuration files')
+    .option('-v, --vault <path>', 'Vault path')
+    .action(async (options) => {
       try {
         const { setupCommand } = await import('../dist/commands/setup.js');
-        await setupCommand();
+        await setupCommand({
+          graphColors: options.graphColors,
+          bases: options.bases,
+          canvas: options.canvas,
+          theme: options.theme,
+          force: options.force,
+          vault: options.vault
+        });
       } catch (err) {
         console.error(chalk.red(`Error: ${err.message}`));
         process.exit(1);

package/bin/register-tailscale-commands.js

@@ -0,0 +1,106 @@
+/**
+ * Tailscale networking command registrations.
+ * Provides vault synchronization over Tailscale networks.
+ */
+
+export function registerTailscaleCommands(program, { chalk }) {
+  // === TAILSCALE-STATUS ===
+  program
+    .command('tailscale-status')
+    .alias('ts-status')
+    .description('Show Tailscale connection status and peers')
+    .option('--json', 'Output as JSON')
+    .option('--peers', 'Show all peers including offline')
+    .action(async (options) => {
+      try {
+        const { tailscaleStatusCommand } = await import('../dist/commands/tailscale.js');
+        await tailscaleStatusCommand({
+          json: options.json,
+          peers: options.peers
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  // === TAILSCALE-SYNC ===
+  program
+    .command('tailscale-sync')
+    .alias('ts-sync')
+    .description('Sync vault with a peer on the Tailscale network')
+    .requiredOption('--peer <hostname>', 'Peer hostname or IP to sync with')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--port <number>', 'Port on the peer (default: 8384)', parseInt)
+    .option('--direction <dir>', 'Sync direction: push, pull, or bidirectional', 'bidirectional')
+    .option('--dry-run', 'Show what would be synced without making changes')
+    .option('--delete-orphans', 'Delete files that exist locally but not on peer (pull only)')
+    .option('--categories <list>', 'Comma-separated list of categories to sync')
+    .option('--https', 'Use HTTPS for connection')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      try {
+        const { tailscaleSyncCommand } = await import('../dist/commands/tailscale.js');
+        await tailscaleSyncCommand({
+          peer: options.peer,
+          vaultPath: options.vault,
+          port: options.port,
+          direction: options.direction,
+          dryRun: options.dryRun,
+          deleteOrphans: options.deleteOrphans,
+          categories: options.categories?.split(',').map(c => c.trim()),
+          https: options.https,
+          json: options.json
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  // === TAILSCALE-SERVE ===
+  program
+    .command('tailscale-serve')
+    .alias('ts-serve')
+    .description('Serve vault for sync over Tailscale')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--port <number>', 'Port to serve on (default: 8384)', parseInt)
+    .option('--funnel', 'Expose via Tailscale Funnel (public internet)')
+    .option('--background', 'Run in background')
+    .option('--stop', 'Stop serving')
+    .action(async (options) => {
+      try {
+        const { tailscaleServeCommand } = await import('../dist/commands/tailscale.js');
+        await tailscaleServeCommand({
+          vaultPath: options.vault,
+          port: options.port,
+          funnel: options.funnel,
+          background: options.background,
+          stop: options.stop
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  // === TAILSCALE-DISCOVER ===
+  program
+    .command('tailscale-discover')
+    .alias('ts-discover')
+    .description('Discover ClawVault peers on the Tailscale network')
+    .option('--port <number>', 'Port to check (default: 8384)', parseInt)
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      try {
+        const { tailscaleDiscoverCommand } = await import('../dist/commands/tailscale.js');
+        await tailscaleDiscoverCommand({
+          port: options.port,
+          json: options.json
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+}

package/bin/register-task-commands.js

@@ -242,12 +242,28 @@ export function registerTaskCommands(
     .description('Generate Obsidian canvas dashboard')
     .option('-v, --vault <path>', 'Vault path')
     .option('--output <path>', 'Output file path (default: dashboard.canvas)')
+    .option('--template <id>', 'Canvas template ID (default, project-board, brain, sprint)')
+    .option('--project <project>', 'Project filter for template-aware canvases')
+    .option('--owner <owner>', 'Filter tasks by owner (agent name or human)')
+    .option('--width <pixels>', 'Canvas width in pixels', parseInt)
+    .option('--height <pixels>', 'Canvas height in pixels', parseInt)
+    .option('--include-done', 'Include completed tasks (default: limited)')
+    .option('--list-templates', 'List available canvas templates and exit')
     .action(async (options) => {
       try {
-        const vaultPath = resolveVaultPath(options.vault);
+        const vaultPath = options.listTemplates
+          ? (options.vault || '.')
+          : resolveVaultPath(options.vault);
         const { canvasCommand } = await import('../dist/commands/canvas.js');
         await canvasCommand(vaultPath, {
-          output: options.output
+          output: options.output,
+          template: options.template,
+          project: options.project,
+          owner: options.owner,
+          width: options.width,
+          height: options.height,
+          includeDone: options.includeDone,
+          listTemplates: options.listTemplates
         });
       } catch (err) {
         console.error(chalk.red(`Error: ${err.message}`));

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

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+import { Command } from 'commander';
+import { registerTaskCommands } from './register-task-commands.js';
+import { chalkStub, stubResolveVaultPath } from './test-helpers/cli-command-fixtures.js';
+
+describe('register-task-commands', () => {
+  it('adds canvas template and listing 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([
+      '--template <id>',
+      '--list-templates',
+      '--project <project>'
+    ]));
+  });
+});

package/dist/{chunk-SOTWYGH7.js → chunk-33GW63WK.js}

@@ -1,48 +1,17 @@
 import {
   ClawVault
-} from "./chunk-OTQW3OMC.js";
+} from "./chunk-Q3WBH4P4.js";
 import {
-  parseObservationMarkdown
-} from "./chunk-K6XHCUFL.js";
+  parseObservationLines,
+  readObservations
+} from "./chunk-L3DJ36BZ.js";
 import {
   getMemoryGraph
 } from "./chunk-ZZA73MFY.js";
-import {
-  listObservationFiles
-} from "./chunk-Z2XBWN7A.js";
 
 // src/commands/context.ts
 import * as path from "path";
 
-// src/lib/observation-reader.ts
-import * as fs from "fs";
-function readObservations(vaultPath, days = 7) {
-  const normalizedDays = Number.isFinite(days) ? Math.max(0, Math.floor(days)) : 0;
-  if (normalizedDays === 0) {
-    return "";
-  }
-  const files = listObservationFiles(vaultPath, {
-    includeLegacy: true,
-    includeArchive: false,
-    dedupeByDate: true
-  }).sort((left, right) => right.date.localeCompare(left.date)).slice(0, normalizedDays);
-  if (files.length === 0) {
-    return "";
-  }
-  return files.map((entry) => fs.readFileSync(entry.path, "utf-8").trim()).filter(Boolean).join("\n\n").trim();
-}
-function parseObservationLines(markdown) {
-  return parseObservationMarkdown(markdown).map((record) => ({
-    type: record.type,
-    confidence: record.confidence,
-    importance: record.importance,
-    content: record.content,
-    date: record.date,
-    format: record.format,
-    priority: record.priority
-  }));
-}
-
 // src/lib/token-counter.ts
 function estimateTokens(text) {
   if (!text) {