clawvault 2.5.4 → 2.6.0

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

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

@@ -1,72 +1,75 @@
-/**
- * Template command registrations split from main CLI entrypoint.
- */
-
-export function registerTemplateCommands(program, { chalk }) {
-  const template = program
-    .command('template')
-    .description('Manage document templates');
-
-  template
-    .command('list')
-    .description('List available templates')
-    .option('-v, --vault <path>', 'Vault path')
-    .action(async (options) => {
-      try {
-        const { listTemplates } = await import('../dist/commands/template.js');
-        const templates = listTemplates({ vaultPath: options.vault });
-        if (templates.length === 0) {
-          console.log(chalk.yellow('No templates found.'));
-          return;
-        }
-        console.log(chalk.cyan('\n📄 Templates:\n'));
-        for (const name of templates) {
-          console.log(`- ${name}`);
-        }
-        console.log();
-      } catch (err) {
-        console.error(chalk.red(`Error: ${err.message}`));
-        process.exit(1);
-      }
-    });
-
-  template
-    .command('create <name>')
-    .description('Create a file from a template')
-    .option('-t, --title <title>', 'Document title')
-    .option('-v, --vault <path>', 'Vault path')
-    .action(async (name, options) => {
-      try {
-        const { createFromTemplate } = await import('../dist/commands/template.js');
-        const result = createFromTemplate(name, {
-          title: options.title,
-          vaultPath: options.vault
-        });
-        console.log(chalk.green(`✓ Created from template: ${name}`));
-        console.log(chalk.dim(`  Output: ${result.outputPath}`));
-      } catch (err) {
-        console.error(chalk.red(`Error: ${err.message}`));
-        process.exit(1);
-      }
-    });
-
-  template
-    .command('add <file>')
-    .description('Add a custom template')
-    .requiredOption('--name <name>', 'Template name')
-    .option('-v, --vault <path>', 'Vault path')
-    .action(async (file, options) => {
-      try {
-        const { addTemplate } = await import('../dist/commands/template.js');
-        const result = addTemplate(file, {
-          name: options.name,
-          vaultPath: options.vault
-        });
-        console.log(chalk.green(`✓ Template added: ${result.name}`));
-        console.log(chalk.dim(`  Path: ${result.templatePath}`));
-      } catch (err) {
-        console.error(chalk.red(`Error: ${err.message}`));
-        process.exit(1);
-      }
-    });
-}
+/**
+ * Template command registrations split from main CLI entrypoint.
+ */
+
+export function registerTemplateCommands(program, { chalk }) {
+  const template = program
+    .command('template')
+    .description('Manage document templates');
+
+  template
+    .command('list')
+    .description('List available templates')
+    .option('-v, --vault <path>', 'Vault path')
+    .action(async (options) => {
+      try {
+        const { listTemplateDefinitions } = await import('../dist/commands/template.js');
+        const templates = listTemplateDefinitions({ vaultPath: options.vault });
+        if (templates.length === 0) {
+          console.log(chalk.yellow('No templates found.'));
+          return;
+        }
+        console.log(chalk.cyan('\n📄 Templates:\n'));
+        for (const templateDef of templates) {
+          const fieldSummary = templateDef.fields.length > 0
+            ? ` (${templateDef.fields.join(', ')})`
+            : '';
+          console.log(`- ${templateDef.name}${fieldSummary}`);
+        }
+        console.log();
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  template
+    .command('create <name>')
+    .description('Create a file from a template')
+    .option('-t, --title <title>', 'Document title')
+    .option('-v, --vault <path>', 'Vault path')
+    .action(async (name, options) => {
+      try {
+        const { createFromTemplate } = await import('../dist/commands/template.js');
+        const result = createFromTemplate(name, {
+          title: options.title,
+          vaultPath: options.vault
+        });
+        console.log(chalk.green(`✓ Created from template: ${name}`));
+        console.log(chalk.dim(`  Output: ${result.outputPath}`));
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  template
+    .command('add <file>')
+    .description('Add a custom template')
+    .requiredOption('--name <name>', 'Template name')
+    .option('-v, --vault <path>', 'Vault path')
+    .action(async (file, options) => {
+      try {
+        const { addTemplate } = await import('../dist/commands/template.js');
+        const result = addTemplate(file, {
+          name: options.name,
+          vaultPath: options.vault
+        });
+        console.log(chalk.green(`✓ Template added: ${result.name}`));
+        console.log(chalk.dim(`  Path: ${result.templatePath}`));
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+}

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