clawvault 3.4.0 → 3.5.0

package/bin/help-contract.test.js

@@ -1,55 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { registerAllCommandModules } from './test-helpers/cli-command-fixtures.js';
-
-describe('CLI help contract', () => {
-  it('includes expected high-level command surface', () => {
-    const help = registerAllCommandModules().helpInformation();
-    expect(help).toContain('init');
-    expect(help).toContain('context');
-    expect(help).toContain('recall');
-    expect(help).toContain('inject');
-    expect(help).toContain('doctor');
-    expect(help).toContain('benchmark');
-    expect(help).toContain('maintain');
-    expect(help).toContain('embed');
-    expect(help).toContain('inbox');
-    expect(help).toContain('patch');
-    expect(help).toContain('compat');
-    expect(help).toContain('graph');
-    expect(help).toContain('reflect');
-    expect(help).toContain('replay');
-    expect(help).toContain('repair-session');
-    expect(help).toContain('project');
-    expect(help).toContain('template');
-    expect(help).toContain('config');
-    expect(help).toContain('route');
-    expect(help).toContain('entity');
-  });
-
-  it('documents context/compat/inject/project help details', () => {
-    const program = registerAllCommandModules();
-    const contextHelp = program.commands.find((command) => command.name() === 'context')?.helpInformation() ?? '';
-    const compatHelp = program.commands.find((command) => command.name() === 'compat')?.helpInformation() ?? '';
-    const injectHelp = program.commands.find((command) => command.name() === 'inject')?.helpInformation() ?? '';
-    const projectCommand = program.commands.find((command) => command.name() === 'project');
-    const projectListHelp = projectCommand?.commands.find((command) => command.name() === 'list')?.helpInformation() ?? '';
-    const projectBoardHelp = projectCommand?.commands.find((command) => command.name() === 'board')?.helpInformation() ?? '';
-    expect(contextHelp).toContain('--profile <profile>');
-    expect(contextHelp).toContain('auto');
-    expect(compatHelp).toContain('--strict');
-    expect(injectHelp).toContain('inject.maxResults');
-    expect(injectHelp).toContain('inject.scope');
-    expect(projectListHelp).toContain('archived projects are hidden');
-    expect(projectBoardHelp).toContain('default: status');
-  });
-
-  it('does not advertise removed workgraph commands', () => {
-    const program = registerAllCommandModules();
-    const names = program.commands.map((command) => command.name());
-
-    expect(names).not.toContain('wg');
-    expect(names).not.toContain('thread');
-    expect(names).not.toContain('primitive');
-    expect(names).not.toContain('ledger');
-  });
-});

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

@@ -1,121 +0,0 @@
-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',
-    'observer.compression.provider',
-    'observer.compression.model',
-    'observer.compression.baseUrl',
-    'observer.compression.apiKey',
-    'context.maxResults',
-    'context.defaultProfile',
-    'graph.maxHops',
-    'inject.maxResults',
-    'inject.useLlm',
-    'inject.scope'
-  ],
-  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-core-commands.test.js

@@ -1,80 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { Command } from 'commander';
-import * as fs from 'fs';
-import * as path from 'path';
-import { registerCoreCommands } from './register-core-commands.js';
-import { chalkStub } from './test-helpers/cli-command-fixtures.js';
-
-function buildProgram(patchImpl) {
-  const program = new Command();
-  registerCoreCommands(program, {
-    chalk: chalkStub,
-    path,
-    fs,
-    createVault: async () => ({ getCategories: () => [], getQmdRoot: () => '', getQmdCollection: () => '' }),
-    getVault: async () => ({ patch: patchImpl }),
-    runQmd: async () => {}
-  });
-  return program;
-}
-
-describe('register-core-commands patch command', () => {
-  it('exposes patch command mode flags', () => {
-    const program = buildProgram(async () => ({ id: 'decisions/example', path: '/vault/decisions/example.md' }));
-    const patchCommand = program.commands.find((command) => command.name() === 'patch');
-    expect(patchCommand).toBeDefined();
-    const optionFlags = patchCommand?.options.map((option) => option.flags) ?? [];
-    expect(optionFlags).toEqual(expect.arrayContaining([
-      '--append <text>',
-      '--replace <text>',
-      '--with <text>',
-      '--section <heading>',
-      '--content <text>',
-      '-v, --vault <path>'
-    ]));
-  });
-
-  it('forwards append mode payload to vault.patch', async () => {
-    const patchMock = vi.fn(async () => ({ id: 'decisions/example', path: '/vault/decisions/example.md' }));
-    const program = buildProgram(patchMock);
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-    try {
-      await program.parseAsync(['patch', 'decisions/example', '--append', 'new line'], { from: 'user' });
-      expect(patchMock).toHaveBeenCalledWith({
-        idOrPath: 'decisions/example',
-        mode: 'append',
-        append: 'new line'
-      });
-      expect(errorSpy).not.toHaveBeenCalled();
-    } finally {
-      logSpy.mockRestore();
-      errorSpy.mockRestore();
-    }
-  });
-
-  it('forwards section/content mode payload to vault.patch', async () => {
-    const patchMock = vi.fn(async () => ({ id: 'decisions/example', path: '/vault/decisions/example.md' }));
-    const program = buildProgram(patchMock);
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-    try {
-      await program.parseAsync(
-        ['patch', 'decisions/example', '--section', 'Notes', '--content', 'updated notes'],
-        { from: 'user' }
-      );
-      expect(patchMock).toHaveBeenCalledWith({
-        idOrPath: 'decisions/example',
-        mode: 'content',
-        content: 'updated notes',
-        section: 'Notes'
-      });
-      expect(errorSpy).not.toHaveBeenCalled();
-    } finally {
-      logSpy.mockRestore();
-      errorSpy.mockRestore();
-    }
-  });
-});

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

@@ -1,83 +0,0 @@
-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

@@ -1,206 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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');
-  });
-});