clawvault 2.4.5 → 2.4.7

package/bin/clawvault.js

@@ -18,6 +18,8 @@ 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 { registerProjectCommands } from './register-project-commands.js';
 
 import { registerTaskCommands } from './register-task-commands.js';
 
@@ -93,6 +95,14 @@ registerTaskCommands(program, {
   chalk,
   resolveVaultPath
 });
+registerKanbanCommands(program, {
+  chalk,
+  resolveVaultPath
+});
+registerProjectCommands(program, {
+  chalk,
+  resolveVaultPath
+});
 
 registerTailscaleCommands(program, { chalk });
 registerConfigCommands(program, { chalk, resolveVaultPath });

package/bin/command-registration.test.js

@@ -49,7 +49,7 @@ describe('CLI command registration modules', () => {
     });
 
     const names = listCommandNames(program);
-    expect(names).toEqual(expect.arrayContaining(['search', 'vsearch', 'context', 'observe', 'reflect', 'session-recap']));
+    expect(names).toEqual(expect.arrayContaining(['search', 'vsearch', 'context', 'inject', 'observe', 'reflect', 'session-recap']));
 
     const contextCommand = program.commands.find((command) => command.name() === 'context');
     const profileOption = contextCommand?.options.find((option) => option.flags.includes('--profile <profile>'));

package/bin/help-contract.test.js

@@ -6,6 +6,7 @@ describe('CLI help contract', () => {
     const help = registerAllCommandModules().helpInformation();
     expect(help).toContain('init');
     expect(help).toContain('context');
+    expect(help).toContain('inject');
     expect(help).toContain('compat');
     expect(help).toContain('graph');
     expect(help).toContain('reflect');

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

@@ -31,9 +31,16 @@ vi.mock('../dist/index.js', () => ({
     'theme',
     'observe.model',
     'observe.provider',
+    'observer.compression.provider',
+    'observer.compression.model',
+    'observer.compression.baseUrl',
+    'observer.compression.apiKey',
     'context.maxResults',
     'context.defaultProfile',
-    'graph.maxHops'
+    'graph.maxHops',
+    'inject.maxResults',
+    'inject.useLlm',
+    'inject.scope'
   ],
   getConfigValue: getConfigValueMock,
   setConfigValue: setConfigValueMock,

package/bin/register-core-commands.js

@@ -17,7 +17,7 @@ export function registerCoreCommands(
     .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('--canvas', 'Generate a vault status canvas dashboard on init')
     .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) => {
@@ -106,7 +106,7 @@ export function registerCoreCommands(
             await setupCommand({
               graphColors: false,
               bases: false,
-              canvas: options.canvas === true ? 'default' : options.canvas,
+              canvas: true,
               theme: 'none',
               vault: resolvedPath
             });
@@ -138,7 +138,7 @@ export function registerCoreCommands(
     .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('--canvas', 'Generate vault status canvas dashboard')
     .option('--no-canvas', 'Skip canvas generation')
     .option('--theme <style>', 'Graph color theme (neural, minimal, none)', 'neural')
     .option('--force', 'Overwrite existing configuration files')

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

@@ -0,0 +1,209 @@
+/**
+ * Project command registrations for ClawVault
+ * Registers project add/update/archive/list/show/tasks/board commands
+ */
+
+function parseCsvList(value) {
+  if (!value) return undefined;
+  const items = String(value)
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+  return items.length > 0 ? items : undefined;
+}
+
+export function registerProjectCommands(
+  program,
+  { chalk, resolveVaultPath }
+) {
+  const projectCmd = program
+    .command('project')
+    .description('Project management');
+
+  projectCmd
+    .command('add <title>')
+    .description('Add a new project')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--owner <owner>', 'Project owner')
+    .option('--status <status>', 'Project status (active, paused, completed, archived)')
+    .option('--team <team>', 'Comma-separated team members')
+    .option('--client <client>', 'Client name')
+    .option('--tags <tags>', 'Comma-separated tags')
+    .option('--description <description>', 'One-line project summary')
+    .option('--deadline <date>', 'Deadline (YYYY-MM-DD)')
+    .option('--repo <url>', 'Repository URL')
+    .option('--url <url>', 'Production URL')
+    .action(async (title, options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { projectCommand } = await import('../dist/commands/project.js');
+        await projectCommand(vaultPath, 'add', {
+          title,
+          options: {
+            owner: options.owner,
+            status: options.status,
+            team: parseCsvList(options.team),
+            client: options.client,
+            tags: parseCsvList(options.tags),
+            description: options.description,
+            deadline: options.deadline,
+            repo: options.repo,
+            url: options.url
+          }
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  projectCmd
+    .command('update <slug>')
+    .description('Update a project')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--status <status>', 'Project status (active, paused, completed, archived)')
+    .option('--owner <owner>', 'Project owner')
+    .option('--team <team>', 'Comma-separated team members')
+    .option('--client <client>', 'Client name')
+    .option('--tags <tags>', 'Comma-separated tags')
+    .option('--description <description>', 'One-line project summary')
+    .option('--deadline <date>', 'Deadline (YYYY-MM-DD)')
+    .option('--repo <url>', 'Repository URL')
+    .option('--url <url>', 'Production URL')
+    .action(async (slug, options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { projectCommand } = await import('../dist/commands/project.js');
+        await projectCommand(vaultPath, 'update', {
+          slug,
+          options: {
+            status: options.status,
+            owner: options.owner,
+            team: parseCsvList(options.team),
+            client: options.client,
+            tags: parseCsvList(options.tags),
+            description: options.description,
+            deadline: options.deadline,
+            repo: options.repo,
+            url: options.url
+          }
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  projectCmd
+    .command('archive <slug>')
+    .description('Archive a project')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--reason <reason>', 'Reason for archiving')
+    .action(async (slug, options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { projectCommand } = await import('../dist/commands/project.js');
+        await projectCommand(vaultPath, 'archive', {
+          slug,
+          options: {
+            reason: options.reason
+          }
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  projectCmd
+    .command('list')
+    .description('List projects')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--status <status>', 'Filter by status')
+    .option('--owner <owner>', 'Filter by owner')
+    .option('--client <client>', 'Filter by client')
+    .option('--tag <tag>', 'Filter by tag')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { projectCommand } = await import('../dist/commands/project.js');
+        await projectCommand(vaultPath, 'list', {
+          options: {
+            status: options.status,
+            owner: options.owner,
+            client: options.client,
+            tag: options.tag,
+            json: options.json
+          }
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  projectCmd
+    .command('show <slug>')
+    .description('Show project details')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--json', 'Output as JSON')
+    .action(async (slug, options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { projectCommand } = await import('../dist/commands/project.js');
+        await projectCommand(vaultPath, 'show', {
+          slug,
+          options: {
+            json: options.json
+          }
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  projectCmd
+    .command('tasks <slug>')
+    .description('List tasks for a project')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--json', 'Output as JSON')
+    .action(async (slug, options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { projectCommand } = await import('../dist/commands/project.js');
+        await projectCommand(vaultPath, 'tasks', {
+          slug,
+          options: {
+            json: options.json
+          }
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  projectCmd
+    .command('board')
+    .description('Generate project kanban board')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--output <path>', 'Board markdown path (default: Projects-Board.md)')
+    .option('--group-by <field>', 'Grouping field (status, owner, client)')
+    .action(async (options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { projectCommand } = await import('../dist/commands/project.js');
+        await projectCommand(vaultPath, 'board', {
+          options: {
+            output: options.output,
+            groupBy: options.groupBy
+          }
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+}

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

@@ -0,0 +1,201 @@
+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>'
+    ]));
+  });
+
+  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.js

@@ -168,6 +168,46 @@ export function registerQueryCommands(
       }
     });
 
+  // === INJECT ===
+  program
+    .command('inject <message>')
+    .description('Inject relevant rules, decisions, and preferences for prompt context')
+    .option('-n, --max-results <n>', 'Maximum injected items')
+    .option('--scope <scope>', 'Comma-separated scope filter override')
+    .option('--enable-llm', 'Enable optional LLM fuzzy intent matching')
+    .option('--disable-llm', 'Disable optional LLM fuzzy intent matching')
+    .option('--format <format>', 'Output format (markdown|json)', 'markdown')
+    .option('--model <model>', 'Override LLM model when fuzzy matching is enabled')
+    .option('-v, --vault <path>', 'Vault path')
+    .action(async (message, options) => {
+      try {
+        const parsedMaxResults = options.maxResults
+          ? Number.parseInt(options.maxResults, 10)
+          : undefined;
+        if (options.maxResults && (!Number.isFinite(parsedMaxResults) || parsedMaxResults <= 0)) {
+          throw new Error(`Invalid --max-results value: ${options.maxResults}`);
+        }
+        const useLlm = options.enableLlm
+          ? true
+          : options.disableLlm
+            ? false
+            : undefined;
+
+        const { injectCommand } = await import('../dist/commands/inject.js');
+        await injectCommand(message, {
+          vaultPath: resolveVaultPath(options.vault),
+          maxResults: parsedMaxResults,
+          useLlm,
+          scope: options.scope,
+          format: options.format === 'json' ? 'json' : 'markdown',
+          model: options.model
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
   // === OBSERVE ===
   program
     .command('observe')