clawvault 3.5.0 → 3.5.2

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-project-commands.test.js

@@ -0,0 +1,206 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Command } from 'commander';
+import { registerProjectCommands } from './register-project-commands.js';
+import { chalkStub } from './test-helpers/cli-command-fixtures.js';
+
+const { projectCommandMock } = vi.hoisted(() => ({
+  projectCommandMock: vi.fn()
+}));
+
+vi.mock('../dist/commands/project.js', () => ({
+  projectCommand: projectCommandMock
+}));
+
+function buildProgram() {
+  const program = new Command();
+  registerProjectCommands(program, {
+    chalk: chalkStub,
+    resolveVaultPath: (value) => value ?? '/vault'
+  });
+  return program;
+}
+
+async function runCommand(args) {
+  const program = buildProgram();
+  await program.parseAsync(args, { from: 'user' });
+}
+
+describe('register-project-commands', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('registers add/update/archive/list/show/tasks/board subcommands', () => {
+    const program = buildProgram();
+    const projectCommand = program.commands.find((command) => command.name() === 'project');
+    expect(projectCommand).toBeDefined();
+
+    const subcommandNames = projectCommand?.commands.map((command) => command.name()) ?? [];
+    expect(subcommandNames).toEqual(expect.arrayContaining([
+      'add',
+      'update',
+      'archive',
+      'list',
+      'show',
+      'tasks',
+      'board'
+    ]));
+
+    const addCommand = projectCommand?.commands.find((command) => command.name() === 'add');
+    const addFlags = addCommand?.options.map((option) => option.flags) ?? [];
+    expect(addFlags).toEqual(expect.arrayContaining([
+      '--owner <owner>',
+      '--status <status>',
+      '--team <team>',
+      '--client <client>',
+      '--tags <tags>',
+      '--description <description>',
+      '--deadline <date>',
+      '--repo <url>',
+      '--url <url>'
+    ]));
+
+    const listCommand = projectCommand?.commands.find((command) => command.name() === 'list');
+    const listFlags = listCommand?.options.map((option) => option.flags) ?? [];
+    expect(listFlags).toEqual(expect.arrayContaining([
+      '--status <status>',
+      '--owner <owner>',
+      '--client <client>',
+      '--tag <tag>',
+      '--json'
+    ]));
+
+    const boardCommand = projectCommand?.commands.find((command) => command.name() === 'board');
+    const boardFlags = boardCommand?.options.map((option) => option.flags) ?? [];
+    expect(boardFlags).toEqual(expect.arrayContaining([
+      '--output <path>',
+      '--group-by <field>'
+    ]));
+
+    expect(listCommand?.description()).toContain('archived projects are hidden');
+
+    const boardGroupByOption = boardCommand?.options.find((option) => option.flags === '--group-by <field>');
+    expect(boardGroupByOption?.description).toContain('default: status');
+  });
+
+  it('dispatches project subcommands to project command handler', async () => {
+    await runCommand([
+      'project',
+      'add',
+      'Apollo Launch',
+      '--owner',
+      'alice',
+      '--status',
+      'active',
+      '--team',
+      'alice,bob',
+      '--client',
+      'Acme',
+      '--tags',
+      'platform,release',
+      '--description',
+      'Launch project',
+      '--deadline',
+      '2026-03-01',
+      '--repo',
+      'https://github.com/acme/apollo',
+      '--url',
+      'https://apollo.acme.dev'
+    ]);
+    expect(projectCommandMock).toHaveBeenCalledWith('/vault', 'add', {
+      title: 'Apollo Launch',
+      options: {
+        owner: 'alice',
+        status: 'active',
+        team: ['alice', 'bob'],
+        client: 'Acme',
+        tags: ['platform', 'release'],
+        description: 'Launch project',
+        deadline: '2026-03-01',
+        repo: 'https://github.com/acme/apollo',
+        url: 'https://apollo.acme.dev'
+      }
+    });
+
+    await runCommand([
+      'project',
+      'update',
+      'apollo-launch',
+      '--status',
+      'paused',
+      '--owner',
+      'carol',
+      '--team',
+      'carol,dave',
+      '--client',
+      'Acme',
+      '--tags',
+      'ops',
+      '--description',
+      'Paused pending review',
+      '--deadline',
+      '2026-03-10',
+      '--repo',
+      'https://github.com/acme/apollo-v2',
+      '--url',
+      'https://staging.acme.dev'
+    ]);
+    expect(projectCommandMock).toHaveBeenCalledWith('/vault', 'update', {
+      slug: 'apollo-launch',
+      options: {
+        status: 'paused',
+        owner: 'carol',
+        team: ['carol', 'dave'],
+        client: 'Acme',
+        tags: ['ops'],
+        description: 'Paused pending review',
+        deadline: '2026-03-10',
+        repo: 'https://github.com/acme/apollo-v2',
+        url: 'https://staging.acme.dev'
+      }
+    });
+
+    await runCommand(['project', 'archive', 'apollo-launch', '--reason', 'Client offboarded']);
+    expect(projectCommandMock).toHaveBeenCalledWith('/vault', 'archive', {
+      slug: 'apollo-launch',
+      options: {
+        reason: 'Client offboarded'
+      }
+    });
+
+    await runCommand(['project', 'list', '--status', 'active', '--owner', 'alice', '--client', 'Acme', '--tag', 'platform', '--json']);
+    expect(projectCommandMock).toHaveBeenCalledWith('/vault', 'list', {
+      options: {
+        status: 'active',
+        owner: 'alice',
+        client: 'Acme',
+        tag: 'platform',
+        json: true
+      }
+    });
+
+    await runCommand(['project', 'show', 'apollo-launch']);
+    expect(projectCommandMock).toHaveBeenCalledWith('/vault', 'show', {
+      slug: 'apollo-launch',
+      options: {
+        json: undefined
+      }
+    });
+
+    await runCommand(['project', 'tasks', 'apollo-launch', '--json']);
+    expect(projectCommandMock).toHaveBeenCalledWith('/vault', 'tasks', {
+      slug: 'apollo-launch',
+      options: {
+        json: true
+      }
+    });
+
+    await runCommand(['project', 'board', '--output', 'Projects-Board.md', '--group-by', 'client']);
+    expect(projectCommandMock).toHaveBeenCalledWith('/vault', 'board', {
+      options: {
+        output: 'Projects-Board.md',
+        groupBy: 'client'
+      }
+    });
+  });
+});

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

@@ -0,0 +1,80 @@
+import { describe, expect, it } from 'vitest';
+import { Command } from 'commander';
+import { registerQueryCommands } from './register-query-commands.js';
+import {
+  chalkStub,
+  createGetVaultStub,
+  stubResolveVaultPath
+} from './test-helpers/cli-command-fixtures.js';
+
+function buildProgram() {
+  const program = new Command();
+  registerQueryCommands(program, {
+    chalk: chalkStub,
+    getVault: createGetVaultStub({ find: async () => [], vsearch: async () => [] }),
+    resolveVaultPath: stubResolveVaultPath,
+    QmdUnavailableError: class extends Error {},
+    printQmdMissing: () => {}
+  });
+  return program;
+}
+
+describe('register-query-commands', () => {
+  it('registers recall command with strategy options', () => {
+    const program = buildProgram();
+    const recallCommand = program.commands.find((command) => command.name() === 'recall');
+    expect(recallCommand).toBeDefined();
+
+    const flags = recallCommand?.options.map((option) => option.flags) ?? [];
+    expect(flags).toEqual(expect.arrayContaining([
+      '-n, --limit <n>',
+      '--strategy <strategy>',
+      '--json',
+      '--no-sources',
+      '-v, --vault <path>'
+    ]));
+  });
+
+  it('documents inject command options and config-backed defaults', () => {
+    const program = buildProgram();
+    const injectCommand = program.commands.find((command) => command.name() === 'inject');
+    expect(injectCommand).toBeDefined();
+
+    const injectFlags = injectCommand?.options.map((option) => option.flags) ?? [];
+    expect(injectFlags).toEqual(expect.arrayContaining([
+      '-n, --max-results <n>',
+      '--scope <scope>',
+      '--enable-llm',
+      '--disable-llm',
+      '--format <format>',
+      '--model <model>',
+      '-v, --vault <path>'
+    ]));
+
+    const maxResultsOption = injectCommand?.options.find((option) => option.flags === '-n, --max-results <n>');
+    const scopeOption = injectCommand?.options.find((option) => option.flags === '--scope <scope>');
+    const formatOption = injectCommand?.options.find((option) => option.flags === '--format <format>');
+    expect(maxResultsOption?.description).toContain('inject.maxResults');
+    expect(scopeOption?.description).toContain('inject.scope');
+    expect(formatOption?.description).toContain('default: markdown');
+  });
+
+  it('documents observe extraction toggles and threshold defaults', () => {
+    const program = buildProgram();
+    const observeCommand = program.commands.find((command) => command.name() === 'observe');
+    expect(observeCommand).toBeDefined();
+
+    const observeFlags = observeCommand?.options.map((option) => option.flags) ?? [];
+    expect(observeFlags).toEqual(expect.arrayContaining([
+      '--extract-tasks',
+      '--no-extract-tasks',
+      '--threshold <n>',
+      '--reflect-threshold <n>'
+    ]));
+
+    const thresholdOption = observeCommand?.options.find((option) => option.flags === '--threshold <n>');
+    const reflectThresholdOption = observeCommand?.options.find((option) => option.flags === '--reflect-threshold <n>');
+    expect(thresholdOption?.description).toContain('default: 30000');
+    expect(reflectThresholdOption?.description).toContain('default: 40000');
+  });
+});

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();
+    }
+  });
+});

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

@@ -0,0 +1,69 @@
+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 enriched task add/list/update options', () => {
+    const program = new Command();
+    registerTaskCommands(program, {
+      chalk: chalkStub,
+      resolveVaultPath: stubResolveVaultPath
+    });
+
+    const taskCommand = program.commands.find((command) => command.name() === 'task');
+    expect(taskCommand).toBeDefined();
+
+    const addCommand = taskCommand?.commands.find((command) => command.name() === 'add');
+    const addFlags = addCommand?.options.map((option) => option.flags) ?? [];
+    expect(addFlags).toEqual(expect.arrayContaining([
+      '--due <date>',
+      '--tags <tags>',
+      '--description <description>',
+      '--estimate <estimate>',
+      '--parent <slug>',
+      '--depends-on <slugs>'
+    ]));
+
+    const listCommand = taskCommand?.commands.find((command) => command.name() === 'list');
+    const listFlags = listCommand?.options.map((option) => option.flags) ?? [];
+    expect(listFlags).toEqual(expect.arrayContaining([
+      '--due',
+      '--tag <tag>',
+      '--overdue'
+    ]));
+
+    const updateCommand = taskCommand?.commands.find((command) => command.name() === 'update');
+    const updateFlags = updateCommand?.options.map((option) => option.flags) ?? [];
+    expect(updateFlags).toEqual(expect.arrayContaining([
+      '--tags <tags>',
+      '--description <description>',
+      '--estimate <estimate>',
+      '--parent <slug>',
+      '--depends-on <slugs>',
+      '--clear-due',
+      '--clear-tags',
+      '--clear-description',
+      '--clear-estimate',
+      '--clear-parent',
+      '--clear-depends-on'
+    ]));
+  });
+
+  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-template-commands.test.js

@@ -0,0 +1,87 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Command } from 'commander';
+import { registerTemplateCommands } from './register-template-commands.js';
+import { chalkStub } from './test-helpers/cli-command-fixtures.js';
+
+const {
+  listTemplateDefinitionsMock,
+  createFromTemplateMock,
+  addTemplateMock
+} = vi.hoisted(() => ({
+  listTemplateDefinitionsMock: vi.fn(),
+  createFromTemplateMock: vi.fn(),
+  addTemplateMock: vi.fn()
+}));
+
+vi.mock('../dist/commands/template.js', () => ({
+  listTemplateDefinitions: listTemplateDefinitionsMock,
+  createFromTemplate: createFromTemplateMock,
+  addTemplate: addTemplateMock
+}));
+
+function buildProgram() {
+  const program = new Command();
+  registerTemplateCommands(program, { chalk: chalkStub });
+  return program;
+}
+
+async function runCommand(args) {
+  const program = buildProgram();
+  await program.parseAsync(args, { from: 'user' });
+}
+
+describe('register-template-commands', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    listTemplateDefinitionsMock.mockReturnValue([]);
+  });
+
+  it('registers list/create/add template subcommands', () => {
+    const program = buildProgram();
+    const templateCommand = program.commands.find((command) => command.name() === 'template');
+    expect(templateCommand).toBeDefined();
+    expect(templateCommand?.commands.map((command) => command.name())).toEqual(
+      expect.arrayContaining(['list', 'create', 'add'])
+    );
+  });
+
+  it('prints template fields in list output', async () => {
+    listTemplateDefinitionsMock.mockReturnValue([
+      { name: 'task', fields: ['status', 'owner'] },
+      { name: 'project', fields: ['status', 'client'] }
+    ]);
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      await runCommand(['template', 'list']);
+      expect(logSpy).toHaveBeenCalledWith('- task (status, owner)');
+      expect(logSpy).toHaveBeenCalledWith('- project (status, client)');
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+
+  it('dispatches create and add operations to template command handlers', async () => {
+    createFromTemplateMock.mockReturnValue({
+      outputPath: '/tmp/task.md',
+      templatePath: '/templates/task.md',
+      variables: { title: 'Task', type: 'task', date: '2026-02-16', datetime: '2026-02-16T00:00:00.000Z' }
+    });
+    addTemplateMock.mockReturnValue({
+      templatePath: '/vault/templates/custom.md',
+      name: 'custom'
+    });
+
+    await runCommand(['template', 'create', 'task', '--title', 'Ship It']);
+    expect(createFromTemplateMock).toHaveBeenCalledWith('task', {
+      title: 'Ship It',
+      vaultPath: undefined
+    });
+
+    await runCommand(['template', 'add', 'source.md', '--name', 'custom']);
+    expect(addTemplateMock).toHaveBeenCalledWith('source.md', {
+      name: 'custom',
+      vaultPath: undefined
+    });
+  });
+});