clawvault 2.4.4 → 2.4.6

package/bin/clawvault.js

@@ -16,6 +16,9 @@ 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 { registerConfigCommands } from './register-config-commands.js';
+import { registerRouteCommands } from './register-route-commands.js';
+import { registerKanbanCommands } from './register-kanban-commands.js';
 
 import { registerTaskCommands } from './register-task-commands.js';
 
@@ -91,8 +94,14 @@ registerTaskCommands(program, {
   chalk,
   resolveVaultPath
 });
+registerKanbanCommands(program, {
+  chalk,
+  resolveVaultPath
+});
 
 registerTailscaleCommands(program, { chalk });
+registerConfigCommands(program, { chalk, resolveVaultPath });
+registerRouteCommands(program, { chalk, resolveVaultPath });
 
 // Parse and run
 program.parse();

package/bin/command-registration.test.js

@@ -9,6 +9,8 @@ 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 { registerConfigCommands } from './register-config-commands.js';
+import { registerRouteCommands } from './register-route-commands.js';
 import {
   chalkStub,
   createGetVaultStub,
@@ -107,6 +109,14 @@ describe('CLI command registration modules', () => {
       runQmd: async () => {}
     });
     registerTemplateCommands(program, { chalk: chalkStub });
+    registerConfigCommands(program, {
+      chalk: chalkStub,
+      resolveVaultPath: stubResolveVaultPath
+    });
+    registerRouteCommands(program, {
+      chalk: chalkStub,
+      resolveVaultPath: stubResolveVaultPath
+    });
 
     const names = listCommandNames(program);
     expect(names).toEqual(expect.arrayContaining([
@@ -129,7 +139,9 @@ describe('CLI command registration modules', () => {
       'sleep',
       'handoff',
       'recap',
-      'template'
+      'template',
+      'config',
+      'route'
     ]));
 
     const templateCommand = program.commands.find((command) => command.name() === 'template');

package/bin/help-contract.test.js

@@ -12,6 +12,8 @@ describe('CLI help contract', () => {
     expect(help).toContain('replay');
     expect(help).toContain('repair-session');
     expect(help).toContain('template');
+    expect(help).toContain('config');
+    expect(help).toContain('route');
   });
 
   it('documents context auto profile and compat strict options', () => {

package/bin/register-config-commands.js

@@ -0,0 +1,153 @@
+/**
+ * Runtime config command registrations backed by .clawvault.json.
+ */
+
+function stringifyValue(value) {
+  if (Array.isArray(value)) {
+    if (value.every((item) => typeof item === 'string' || typeof item === 'number' || typeof item === 'boolean')) {
+      return value.join(', ');
+    }
+    return JSON.stringify(value);
+  }
+  if (value && typeof value === 'object') {
+    return JSON.stringify(value);
+  }
+  if (value === null || value === undefined) {
+    return '(unset)';
+  }
+  return String(value);
+}
+
+function flattenConfig(value, prefix = '') {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return [{ key: prefix || '(root)', value: stringifyValue(value) }];
+  }
+
+  const rows = [];
+  const keys = Object.keys(value).sort((left, right) => left.localeCompare(right));
+  for (const key of keys) {
+    const next = prefix ? `${prefix}.${key}` : key;
+    const entry = value[key];
+    if (entry && typeof entry === 'object' && !Array.isArray(entry)) {
+      rows.push(...flattenConfig(entry, next));
+      continue;
+    }
+    rows.push({ key: next, value: stringifyValue(entry) });
+  }
+  return rows;
+}
+
+function printTable(rows) {
+  if (rows.length === 0) {
+    console.log('No config values found.');
+    return;
+  }
+  const keyWidth = Math.max(
+    'KEY'.length,
+    ...rows.map((row) => row.key.length)
+  );
+  const valueWidth = Math.max(
+    'VALUE'.length,
+    ...rows.map((row) => row.value.length)
+  );
+  const header = `${'KEY'.padEnd(keyWidth)}  ${'VALUE'.padEnd(valueWidth)}`;
+  const divider = `${'-'.repeat(keyWidth)}  ${'-'.repeat(valueWidth)}`;
+  console.log(header);
+  console.log(divider);
+  for (const row of rows) {
+    console.log(`${row.key.padEnd(keyWidth)}  ${row.value}`);
+  }
+}
+
+function normalizeConfigKey(key) {
+  return String(key || '').trim();
+}
+
+export function registerConfigCommands(program, { chalk, resolveVaultPath }) {
+  const config = program
+    .command('config')
+    .description('Read and modify runtime config');
+
+  config
+    .command('get <key>')
+    .description('Read a runtime config value (dot-notation supported)')
+    .option('-v, --vault <path>', 'Vault path')
+    .action(async (key, options) => {
+      try {
+        const { getConfigValue, SUPPORTED_CONFIG_KEYS } = await import('../dist/index.js');
+        const normalizedKey = normalizeConfigKey(key);
+        if (!SUPPORTED_CONFIG_KEYS.includes(normalizedKey)) {
+          throw new Error(`Unsupported config key: ${normalizedKey}`);
+        }
+
+        const value = getConfigValue(resolveVaultPath(options.vault), normalizedKey);
+        if (Array.isArray(value)) {
+          console.log(value.join(','));
+          return;
+        }
+        if (value && typeof value === 'object') {
+          console.log(JSON.stringify(value, null, 2));
+          return;
+        }
+        console.log(value === undefined || value === null ? '' : String(value));
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  config
+    .command('set <key> <value>')
+    .description('Set a runtime config value')
+    .option('-v, --vault <path>', 'Vault path')
+    .action(async (key, value, options) => {
+      try {
+        const { setConfigValue, SUPPORTED_CONFIG_KEYS } = await import('../dist/index.js');
+        const normalizedKey = normalizeConfigKey(key);
+        if (!SUPPORTED_CONFIG_KEYS.includes(normalizedKey)) {
+          throw new Error(`Unsupported config key: ${normalizedKey}`);
+        }
+        const result = setConfigValue(resolveVaultPath(options.vault), normalizedKey, value);
+        console.log(chalk.green(`✓ Updated ${normalizedKey}`));
+        console.log(chalk.dim(`  Value: ${stringifyValue(result.value)}`));
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  config
+    .command('list')
+    .description('List all config values')
+    .option('-v, --vault <path>', 'Vault path')
+    .action(async (options) => {
+      try {
+        const { listConfig } = await import('../dist/index.js');
+        const values = listConfig(resolveVaultPath(options.vault));
+        const rows = flattenConfig(values);
+        printTable(rows);
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  config
+    .command('reset')
+    .description('Reset runtime config values to defaults')
+    .option('--confirm', 'Confirm reset')
+    .option('-v, --vault <path>', 'Vault path')
+    .action(async (options) => {
+      try {
+        if (!options.confirm) {
+          throw new Error('Refusing to reset config without --confirm.');
+        }
+        const { resetConfig } = await import('../dist/index.js');
+        resetConfig(resolveVaultPath(options.vault));
+        console.log(chalk.green('✓ Config reset to defaults'));
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+}

package/bin/register-config-route-commands.test.js

@@ -0,0 +1,114 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Command } from 'commander';
+import { registerConfigCommands } from './register-config-commands.js';
+import { registerRouteCommands } from './register-route-commands.js';
+import { chalkStub } from './test-helpers/cli-command-fixtures.js';
+
+const {
+  getConfigValueMock,
+  setConfigValueMock,
+  listConfigMock,
+  resetConfigMock,
+  addRouteRuleMock,
+  listRouteRulesMock,
+  removeRouteRuleMock,
+  testRouteRuleMock
+} = vi.hoisted(() => ({
+  getConfigValueMock: vi.fn(),
+  setConfigValueMock: vi.fn(),
+  listConfigMock: vi.fn(),
+  resetConfigMock: vi.fn(),
+  addRouteRuleMock: vi.fn(),
+  listRouteRulesMock: vi.fn(),
+  removeRouteRuleMock: vi.fn(),
+  testRouteRuleMock: vi.fn()
+}));
+
+vi.mock('../dist/index.js', () => ({
+  SUPPORTED_CONFIG_KEYS: [
+    'name',
+    'categories',
+    'theme',
+    'observe.model',
+    'observe.provider',
+    'context.maxResults',
+    'context.defaultProfile',
+    'graph.maxHops'
+  ],
+  getConfigValue: getConfigValueMock,
+  setConfigValue: setConfigValueMock,
+  listConfig: listConfigMock,
+  resetConfig: resetConfigMock,
+  addRouteRule: addRouteRuleMock,
+  listRouteRules: listRouteRulesMock,
+  removeRouteRule: removeRouteRuleMock,
+  testRouteRule: testRouteRuleMock
+}));
+
+function buildProgram() {
+  const program = new Command();
+  const resolveVaultPath = (value) => value ?? '/vault';
+  registerConfigCommands(program, { chalk: chalkStub, resolveVaultPath });
+  registerRouteCommands(program, { chalk: chalkStub, resolveVaultPath });
+  return program;
+}
+
+async function runCommand(args) {
+  const program = buildProgram();
+  await program.parseAsync(args, { from: 'user' });
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  getConfigValueMock.mockReturnValue('demo-vault');
+  setConfigValueMock.mockReturnValue({ value: 'demo-vault' });
+  listConfigMock.mockReturnValue({ name: 'demo-vault', context: { maxResults: 5 } });
+  resetConfigMock.mockReturnValue(undefined);
+  addRouteRuleMock.mockReturnValue({ pattern: 'Pedro', target: 'people/pedro', priority: 1 });
+  listRouteRulesMock.mockReturnValue([{ pattern: 'Pedro', target: 'people/pedro', priority: 1 }]);
+  removeRouteRuleMock.mockReturnValue(true);
+  testRouteRuleMock.mockReturnValue({ pattern: 'Pedro', target: 'people/pedro', priority: 1 });
+});
+
+describe('config and route command registrations', () => {
+  it('executes config get/set/list subcommands', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      await runCommand(['config', 'get', 'name']);
+      expect(getConfigValueMock).toHaveBeenCalledWith('/vault', 'name');
+
+      await runCommand(['config', 'set', 'categories', 'people,projects']);
+      expect(setConfigValueMock).toHaveBeenCalledWith('/vault', 'categories', 'people,projects');
+
+      await runCommand(['config', 'list']);
+      expect(listConfigMock).toHaveBeenCalledWith('/vault');
+
+      const output = logSpy.mock.calls.map((call) => call.join(' ')).join('\n');
+      expect(output).toContain('context.maxResults');
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+
+  it('executes route add/remove/test subcommands', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      await runCommand(['route', 'add', 'Pedro', 'people/pedro']);
+      expect(addRouteRuleMock).toHaveBeenCalledWith('/vault', 'Pedro', 'people/pedro');
+
+      await runCommand(['route', 'remove', 'Pedro']);
+      expect(removeRouteRuleMock).toHaveBeenCalledWith('/vault', 'Pedro');
+
+      await runCommand(['route', 'test', 'Talked to Pedro']);
+      expect(testRouteRuleMock).toHaveBeenCalledWith('/vault', 'Talked to Pedro');
+
+      await runCommand(['route', 'list']);
+      expect(listRouteRulesMock).toHaveBeenCalledWith('/vault');
+
+      const output = logSpy.mock.calls.map((call) => call.join(' ')).join('\n');
+      expect(output).toContain('Route matched');
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+});

package/bin/register-kanban-commands.js

@@ -0,0 +1,56 @@
+/**
+ * Kanban command registrations for ClawVault.
+ */
+
+export function registerKanbanCommands(
+  program,
+  { chalk, resolveVaultPath }
+) {
+  const kanbanCmd = program
+    .command('kanban')
+    .description('Sync Obsidian Kanban boards with task frontmatter');
+
+  kanbanCmd
+    .command('sync')
+    .description('Generate and sync an Obsidian Kanban board from tasks')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--output <path>', 'Board markdown path (default: Board.md)')
+    .option('--group-by <field>', 'Grouping field (status, priority, project, owner)')
+    .option('--filter-project <project>', 'Only include tasks from a project')
+    .option('--filter-owner <owner>', 'Only include tasks for an owner')
+    .option('--include-done', 'Include done tasks')
+    .action(async (options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { kanbanCommand } = await import('../dist/commands/kanban.js');
+        await kanbanCommand(vaultPath, 'sync', {
+          output: options.output,
+          groupBy: options.groupBy,
+          filterProject: options.filterProject,
+          filterOwner: options.filterOwner,
+          includeDone: options.includeDone
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  kanbanCmd
+    .command('import')
+    .description('Import lane state from an Obsidian Kanban board into tasks')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--output <path>', 'Board markdown path (default: Board.md)')
+    .action(async (options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { kanbanCommand } = await import('../dist/commands/kanban.js');
+        await kanbanCommand(vaultPath, 'import', {
+          output: options.output
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+}

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

@@ -0,0 +1,83 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Command } from 'commander';
+import { registerKanbanCommands } from './register-kanban-commands.js';
+import { chalkStub } from './test-helpers/cli-command-fixtures.js';
+
+const { kanbanCommandMock } = vi.hoisted(() => ({
+  kanbanCommandMock: vi.fn()
+}));
+
+vi.mock('../dist/commands/kanban.js', () => ({
+  kanbanCommand: kanbanCommandMock
+}));
+
+function buildProgram() {
+  const program = new Command();
+  registerKanbanCommands(program, {
+    chalk: chalkStub,
+    resolveVaultPath: (value) => value ?? '/vault'
+  });
+  return program;
+}
+
+async function runCommand(args) {
+  const program = buildProgram();
+  await program.parseAsync(args, { from: 'user' });
+}
+
+describe('register-kanban-commands', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('registers sync and import subcommands with expected options', () => {
+    const program = buildProgram();
+    const kanbanCommand = program.commands.find((command) => command.name() === 'kanban');
+    expect(kanbanCommand).toBeDefined();
+
+    const syncCommand = kanbanCommand?.commands.find((command) => command.name() === 'sync');
+    expect(syncCommand).toBeDefined();
+    const syncFlags = syncCommand?.options.map((option) => option.flags) ?? [];
+    expect(syncFlags).toEqual(expect.arrayContaining([
+      '--output <path>',
+      '--group-by <field>',
+      '--filter-project <project>',
+      '--filter-owner <owner>',
+      '--include-done'
+    ]));
+
+    const importCommand = kanbanCommand?.commands.find((command) => command.name() === 'import');
+    expect(importCommand).toBeDefined();
+    const importFlags = importCommand?.options.map((option) => option.flags) ?? [];
+    expect(importFlags).toEqual(expect.arrayContaining(['--output <path>']));
+  });
+
+  it('dispatches sync and import actions to the kanban command handler', async () => {
+    await runCommand([
+      'kanban',
+      'sync',
+      '--group-by',
+      'priority',
+      '--output',
+      'Board.md',
+      '--filter-project',
+      'apollo',
+      '--filter-owner',
+      'alice',
+      '--include-done'
+    ]);
+
+    expect(kanbanCommandMock).toHaveBeenCalledWith('/vault', 'sync', {
+      output: 'Board.md',
+      groupBy: 'priority',
+      filterProject: 'apollo',
+      filterOwner: 'alice',
+      includeDone: true
+    });
+
+    await runCommand(['kanban', 'import', '--output', 'Board.md']);
+    expect(kanbanCommandMock).toHaveBeenCalledWith('/vault', 'import', {
+      output: 'Board.md'
+    });
+  });
+});

package/bin/register-resilience-commands.js

@@ -45,13 +45,48 @@ export function registerResilienceCommands(program, { chalk, resolveVaultPath })
     .command('recover')
     .description('Check for context death and recover state')
     .option('--clear', 'Clear the dirty death flag after recovery')
+    .option('--check', 'Check dirty death flag without clearing it')
+    .option('--list', 'List saved checkpoints (newest first)')
     .option('--verbose', 'Show full checkpoint and handoff content')
     .option('-v, --vault <path>', 'Vault path')
     .option('--json', 'Output as JSON')
     .action(async (options) => {
       try {
-        const { recover, formatRecoveryInfo } = await import('../dist/commands/recover.js');
-        const info = await recover(resolveVaultPath(options.vault), {
+        if (options.check && options.list) {
+          throw new Error('--check and --list cannot be used together.');
+        }
+
+        const {
+          recover,
+          formatRecoveryInfo,
+          checkRecoveryStatus,
+          formatRecoveryCheckStatus,
+          listCheckpoints,
+          formatCheckpointList
+        } = await import('../dist/commands/recover.js');
+        const vaultPath = resolveVaultPath(options.vault);
+
+        if (options.check) {
+          const status = await checkRecoveryStatus(vaultPath);
+          if (options.json) {
+            console.log(JSON.stringify(status, null, 2));
+          } else {
+            console.log(formatRecoveryCheckStatus(status));
+          }
+          return;
+        }
+
+        if (options.list) {
+          const checkpoints = listCheckpoints(vaultPath);
+          if (options.json) {
+            console.log(JSON.stringify(checkpoints, null, 2));
+          } else {
+            console.log(formatCheckpointList(checkpoints));
+          }
+          return;
+        }
+
+        const info = await recover(vaultPath, {
           clearFlag: options.clear,
           verbose: options.verbose
         });

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

@@ -0,0 +1,81 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Command } from 'commander';
+import { registerResilienceCommands } from './register-resilience-commands.js';
+import { chalkStub } from './test-helpers/cli-command-fixtures.js';
+
+const {
+  recoverMock,
+  formatRecoveryInfoMock,
+  checkRecoveryStatusMock,
+  formatRecoveryCheckStatusMock,
+  listCheckpointsMock,
+  formatCheckpointListMock
+} = vi.hoisted(() => ({
+  recoverMock: vi.fn(),
+  formatRecoveryInfoMock: vi.fn(),
+  checkRecoveryStatusMock: vi.fn(),
+  formatRecoveryCheckStatusMock: vi.fn(),
+  listCheckpointsMock: vi.fn(),
+  formatCheckpointListMock: vi.fn()
+}));
+
+vi.mock('../dist/commands/recover.js', () => ({
+  recover: recoverMock,
+  formatRecoveryInfo: formatRecoveryInfoMock,
+  checkRecoveryStatus: checkRecoveryStatusMock,
+  formatRecoveryCheckStatus: formatRecoveryCheckStatusMock,
+  listCheckpoints: listCheckpointsMock,
+  formatCheckpointList: formatCheckpointListMock
+}));
+
+function buildProgram() {
+  const program = new Command();
+  registerResilienceCommands(program, {
+    chalk: chalkStub,
+    resolveVaultPath: (value) => value ?? '/vault'
+  });
+  return program;
+}
+
+async function runCommand(args) {
+  const program = buildProgram();
+  await program.parseAsync(args, { from: 'user' });
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  recoverMock.mockResolvedValue({ died: false });
+  formatRecoveryInfoMock.mockReturnValue('recover');
+  checkRecoveryStatusMock.mockResolvedValue({ died: false, deathTime: null, checkpoint: null });
+  formatRecoveryCheckStatusMock.mockReturnValue('check');
+  listCheckpointsMock.mockReturnValue([]);
+  formatCheckpointListMock.mockReturnValue('list');
+});
+
+describe('register-resilience-commands', () => {
+  it('routes recover --check through check helpers', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      await runCommand(['recover', '--check']);
+      expect(checkRecoveryStatusMock).toHaveBeenCalledWith('/vault');
+      expect(formatRecoveryCheckStatusMock).toHaveBeenCalled();
+      expect(recoverMock).not.toHaveBeenCalled();
+      expect(logSpy).toHaveBeenCalledWith('check');
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+
+  it('routes recover --list through checkpoint listing helpers', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      await runCommand(['recover', '--list']);
+      expect(listCheckpointsMock).toHaveBeenCalledWith('/vault');
+      expect(formatCheckpointListMock).toHaveBeenCalled();
+      expect(recoverMock).not.toHaveBeenCalled();
+      expect(logSpy).toHaveBeenCalledWith('list');
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+});