clawvault 2.4.6 → 2.5.0

package/bin/clawvault.js

@@ -19,6 +19,7 @@ import { registerVaultOperationsCommands } from './register-vault-operations-com
 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';
 
@@ -98,6 +99,10 @@ 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-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')

package/bin/register-task-commands.js

@@ -333,28 +333,12 @@ export function registerTaskCommands(
     .description('Generate Obsidian canvas dashboard')
     .option('-v, --vault <path>', 'Vault path')
     .option('--output <path>', 'Output file path (default: dashboard.canvas)')
-    .option('--template <id>', 'Canvas template ID (default, project-board, brain, sprint)')
-    .option('--project <project>', 'Project filter for template-aware canvases')
-    .option('--owner <owner>', 'Filter tasks by owner (agent name or human)')
-    .option('--width <pixels>', 'Canvas width in pixels', parseInt)
-    .option('--height <pixels>', 'Canvas height in pixels', parseInt)
-    .option('--include-done', 'Include completed tasks (default: limited)')
-    .option('--list-templates', 'List available canvas templates and exit')
     .action(async (options) => {
       try {
-        const vaultPath = options.listTemplates
-          ? (options.vault || '.')
-          : resolveVaultPath(options.vault);
+        const vaultPath = resolveVaultPath(options.vault);
         const { canvasCommand } = await import('../dist/commands/canvas.js');
         await canvasCommand(vaultPath, {
-          output: options.output,
-          template: options.template,
-          project: options.project,
-          owner: options.owner,
-          width: options.width,
-          height: options.height,
-          includeDone: options.includeDone,
-          listTemplates: options.listTemplates
+          output: options.output
         });
       } catch (err) {
         console.error(chalk.red(`Error: ${err.message}`));

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

@@ -50,7 +50,7 @@ describe('register-task-commands', () => {
     ]));
   });
 
-  it('adds canvas template and listing flags', () => {
+  it('adds simplified canvas flags', () => {
     const program = new Command();
     registerTaskCommands(program, {
       chalk: chalkStub,
@@ -62,9 +62,8 @@ describe('register-task-commands', () => {
 
     const optionFlags = canvasCommand?.options.map((option) => option.flags) ?? [];
     expect(optionFlags).toEqual(expect.arrayContaining([
-      '--template <id>',
-      '--list-templates',
-      '--project <project>'
+      '-v, --vault <path>',
+      '--output <path>'
     ]));
   });
 });

package/bin/test-helpers/cli-command-fixtures.js

@@ -12,6 +12,7 @@ import { registerConfigCommands } from '../register-config-commands.js';
 import { registerRouteCommands } from '../register-route-commands.js';
 import { registerTaskCommands } from '../register-task-commands.js';
 import { registerKanbanCommands } from '../register-kanban-commands.js';
+import { registerProjectCommands } from '../register-project-commands.js';
 
 export const chalkStub = {
   cyan: (value) => value,
@@ -109,6 +110,10 @@ export function registerAllCommandModules(program = new Command()) {
     chalk: chalkStub,
     resolveVaultPath: stubResolveVaultPath
   });
+  registerProjectCommands(program, {
+    chalk: chalkStub,
+    resolveVaultPath: stubResolveVaultPath
+  });
 
   return program;
 }

package/dist/{chunk-3PJIGGWV.js → chunk-2CDEETQN.js}

@@ -1,5 +1,6 @@
 // src/types.ts
 var DEFAULT_CATEGORIES = [
+  "rules",
   "preferences",
   "decisions",
   "patterns",

package/dist/{chunk-FD2ZA65C.js → chunk-2RK2AG32.js}

@@ -1,18 +1,18 @@
-import {
-  getSessionsDir
-} from "./chunk-HRLWZGMA.js";
 import {
   parseSessionFile
 } from "./chunk-P5EPF6MB.js";
 import {
   Observer
-} from "./chunk-H6WQUUNK.js";
+} from "./chunk-TMZMN7OS.js";
+import {
+  getSessionsDir
+} from "./chunk-HRLWZGMA.js";
 import {
   resolveVaultPath
 } from "./chunk-MXSSG3QU.js";
 import {
   getObservationPath
-} from "./chunk-NAMFB7ZA.js";
+} from "./chunk-Z2XBWN7A.js";
 
 // src/commands/observe.ts
 import * as fs3 from "fs";