clawvault 2.2.1 → 2.3.1

package/bin/clawvault.js

@@ -16,6 +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,
@@ -82,5 +86,13 @@ registerVaultOperationsCommands(program, {
   path
 });
 
+
+registerTaskCommands(program, {
+  chalk,
+  resolveVaultPath
+});
+
+registerTailscaleCommands(program, { chalk });
+
 // Parse and run
 program.parse();

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

@@ -0,0 +1,257 @@
+/**
+ * Task tracking command registrations for ClawVault
+ * Registers task, backlog, blocked, and canvas commands
+ */
+
+export function registerTaskCommands(
+  program,
+  { chalk, resolveVaultPath }
+) {
+  // === TASK ===
+  const taskCmd = program
+    .command('task')
+    .description('Task management');
+
+  // task add
+  taskCmd
+    .command('add <title>')
+    .description('Add a new task')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--owner <owner>', 'Task owner')
+    .option('--project <project>', 'Project name')
+    .option('--priority <priority>', 'Priority (critical, high, medium, low)')
+    .option('--due <date>', 'Due date (YYYY-MM-DD)')
+    .action(async (title, options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { taskCommand } = await import('../dist/commands/task.js');
+        await taskCommand(vaultPath, 'add', {
+          title,
+          options: {
+            owner: options.owner,
+            project: options.project,
+            priority: options.priority,
+            due: options.due
+          }
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  // task list
+  taskCmd
+    .command('list')
+    .description('List tasks')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--owner <owner>', 'Filter by owner')
+    .option('--project <project>', 'Filter by project')
+    .option('--status <status>', 'Filter by status (open, in-progress, blocked, done)')
+    .option('--priority <priority>', 'Filter by priority')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { taskCommand } = await import('../dist/commands/task.js');
+        await taskCommand(vaultPath, 'list', {
+          options: {
+            owner: options.owner,
+            project: options.project,
+            status: options.status,
+            priority: options.priority,
+            json: options.json
+          }
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  // task update
+  taskCmd
+    .command('update <slug>')
+    .description('Update a task')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--status <status>', 'New status')
+    .option('--owner <owner>', 'New owner')
+    .option('--project <project>', 'New project')
+    .option('--priority <priority>', 'New priority')
+    .option('--blocked-by <blocker>', 'What is blocking this task')
+    .option('--due <date>', 'New due date')
+    .action(async (slug, options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { taskCommand } = await import('../dist/commands/task.js');
+        await taskCommand(vaultPath, 'update', {
+          slug,
+          options: {
+            status: options.status,
+            owner: options.owner,
+            project: options.project,
+            priority: options.priority,
+            blockedBy: options.blockedBy,
+            due: options.due
+          }
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  // task done
+  taskCmd
+    .command('done <slug>')
+    .description('Mark a task as done')
+    .option('-v, --vault <path>', 'Vault path')
+    .action(async (slug, options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { taskCommand } = await import('../dist/commands/task.js');
+        await taskCommand(vaultPath, 'done', { slug });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  // task show
+  taskCmd
+    .command('show <slug>')
+    .description('Show task details')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--json', 'Output as JSON')
+    .action(async (slug, options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { taskCommand } = await import('../dist/commands/task.js');
+        await taskCommand(vaultPath, 'show', {
+          slug,
+          options: { json: options.json }
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  // === BACKLOG ===
+  const backlogCmd = program
+    .command('backlog')
+    .description('Backlog management');
+
+  // backlog add (also supports "backlog <title>" shorthand)
+  backlogCmd
+    .command('add <title>')
+    .description('Add item to backlog')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--source <source>', 'Source of the idea')
+    .option('--project <project>', 'Project name')
+    .action(async (title, options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { backlogCommand } = await import('../dist/commands/backlog.js');
+        await backlogCommand(vaultPath, 'add', {
+          title,
+          options: {
+            source: options.source,
+            project: options.project
+          }
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  // backlog list
+  backlogCmd
+    .command('list')
+    .description('List backlog items')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--project <project>', 'Filter by project')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { backlogCommand } = await import('../dist/commands/backlog.js');
+        await backlogCommand(vaultPath, 'list', {
+          options: {
+            project: options.project,
+            json: options.json
+          }
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  // backlog promote
+  backlogCmd
+    .command('promote <slug>')
+    .description('Promote backlog item to task')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--owner <owner>', 'Task owner')
+    .option('--priority <priority>', 'Task priority')
+    .option('--due <date>', 'Due date')
+    .action(async (slug, options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { backlogCommand } = await import('../dist/commands/backlog.js');
+        await backlogCommand(vaultPath, 'promote', {
+          slug,
+          options: {
+            owner: options.owner,
+            priority: options.priority,
+            due: options.due
+          }
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  // === BLOCKED ===
+  program
+    .command('blocked')
+    .description('View blocked tasks')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--project <project>', 'Filter by project')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { blockedCommand } = await import('../dist/commands/blocked.js');
+        await blockedCommand(vaultPath, {
+          project: options.project,
+          json: options.json
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  // === CANVAS ===
+  program
+    .command('canvas')
+    .description('Generate Obsidian canvas dashboard')
+    .option('-v, --vault <path>', 'Vault path')
+    .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/dist/{chunk-2HM7ZI4X.js → chunk-2AYPFUGX.js}

@@ -14,7 +14,7 @@ import {
   getObservationPath,
   getRawTranscriptPath,
   toDateKey
-} from "./chunk-Z2XBWN7A.js";
+} from "./chunk-NAMFB7ZA.js";
 
 // src/observer/compressor.ts
 var CRITICAL_RE = /(?:\b(?:decision|decided|chose|chosen|selected|picked|opted|switched to)\s*:?|\bdecid(?:e|ed|ing|ion)\b|\berror\b|\bfail(?:ed|ure|ing)?\b|\bblock(?:ed|er)?\b|\bbreaking(?:\s+change)?s?\b|\bcritical\b|\b\w+\s+chosen\s+(?:for|over|as)\b|\bpublish(?:ed)?\b.*@?\d+\.\d+|\bmerge[d]?\s+(?:PR|pull\s+request)\b|\bshipped\b|\breleased?\b.*v?\d+\.\d+|\bsigned\b.*\b(?:contract|agreement|deal)\b|\bpricing\b.*\$|\bdemo\b.*\b(?:completed?|done|finished)\b|\bmeeting\b.*\b(?:completed?|done|finished)\b|\bstrategy\b.*\b(?:pivot|change|shift)\b)/i;