clawvault 2.4.5 → 2.4.6

package/bin/clawvault.js

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

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

@@ -3,6 +3,20 @@
  * Registers task, backlog, blocked, and canvas 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;
+}
+
+function clearableValue(value, shouldClear) {
+  if (shouldClear) return null;
+  return value;
+}
+
 export function registerTaskCommands(
   program,
   { chalk, resolveVaultPath }
@@ -21,6 +35,11 @@ export function registerTaskCommands(
     .option('--project <project>', 'Project name')
     .option('--priority <priority>', 'Priority (critical, high, medium, low)')
     .option('--due <date>', 'Due date (YYYY-MM-DD)')
+    .option('--tags <tags>', 'Comma-separated tags')
+    .option('--description <description>', 'One-line task summary')
+    .option('--estimate <estimate>', 'Estimate (for example: 2h, 1d, 1w)')
+    .option('--parent <slug>', 'Parent task slug')
+    .option('--depends-on <slugs>', 'Comma-separated dependency slugs')
     .action(async (title, options) => {
       try {
         const vaultPath = resolveVaultPath(options.vault);
@@ -31,7 +50,12 @@ export function registerTaskCommands(
             owner: options.owner,
             project: options.project,
             priority: options.priority,
-            due: options.due
+            due: options.due,
+            tags: parseCsvList(options.tags),
+            description: options.description,
+            estimate: options.estimate,
+            parent: options.parent,
+            dependsOn: parseCsvList(options.dependsOn)
           }
         });
       } catch (err) {
@@ -49,6 +73,9 @@ export function registerTaskCommands(
     .option('--project <project>', 'Filter by project')
     .option('--status <status>', 'Filter by status (open, in-progress, blocked, done)')
     .option('--priority <priority>', 'Filter by priority')
+    .option('--due', 'Show only tasks with due dates (sorted by due date)')
+    .option('--tag <tag>', 'Filter by tag')
+    .option('--overdue', 'Show overdue tasks that are not done')
     .option('--json', 'Output as JSON')
     .action(async (options) => {
       try {
@@ -60,6 +87,9 @@ export function registerTaskCommands(
             project: options.project,
             status: options.status,
             priority: options.priority,
+            due: options.due,
+            tag: options.tag,
+            overdue: options.overdue,
             json: options.json
           }
         });
@@ -76,12 +106,28 @@ export function registerTaskCommands(
     .option('-v, --vault <path>', 'Vault path')
     .option('--status <status>', 'New status')
     .option('--owner <owner>', 'New owner')
+    .option('--clear-owner', 'Clear owner')
     .option('--project <project>', 'New project')
+    .option('--clear-project', 'Clear project')
     .option('--priority <priority>', 'New priority')
+    .option('--clear-priority', 'Clear priority')
     .option('--blocked-by <blocker>', 'What is blocking this task')
+    .option('--clear-blocked-by', 'Clear blocked-by field')
     .option('--due <date>', 'New due date')
+    .option('--clear-due', 'Clear due date')
+    .option('--tags <tags>', 'Comma-separated tags')
+    .option('--clear-tags', 'Clear tags')
+    .option('--description <description>', 'One-line task summary')
+    .option('--clear-description', 'Clear description')
+    .option('--estimate <estimate>', 'Estimate (for example: 2h, 1d, 1w)')
+    .option('--clear-estimate', 'Clear estimate')
+    .option('--parent <slug>', 'Parent task slug')
+    .option('--clear-parent', 'Clear parent task')
+    .option('--depends-on <slugs>', 'Comma-separated dependency slugs')
+    .option('--clear-depends-on', 'Clear dependencies')
     .option('--confidence <value>', 'Transition confidence (0-1)', parseFloat)
     .option('--reason <reason>', 'Reason for status change')
+    .option('--clear-reason', 'Clear reason')
     .action(async (slug, options) => {
       try {
         const vaultPath = resolveVaultPath(options.vault);
@@ -90,13 +136,18 @@ export function registerTaskCommands(
           slug,
           options: {
             status: options.status,
-            owner: options.owner,
-            project: options.project,
-            priority: options.priority,
-            blockedBy: options.blockedBy,
-            due: options.due,
+            owner: clearableValue(options.owner, options.clearOwner),
+            project: clearableValue(options.project, options.clearProject),
+            priority: clearableValue(options.priority, options.clearPriority),
+            blockedBy: clearableValue(options.blockedBy, options.clearBlockedBy),
+            due: clearableValue(options.due, options.clearDue),
+            tags: options.clearTags ? null : parseCsvList(options.tags),
+            description: clearableValue(options.description, options.clearDescription),
+            estimate: clearableValue(options.estimate, options.clearEstimate),
+            parent: clearableValue(options.parent, options.clearParent),
+            dependsOn: options.clearDependsOn ? null : parseCsvList(options.dependsOn),
             confidence: options.confidence,
-            reason: options.reason
+            reason: clearableValue(options.reason, options.clearReason)
           }
         });
       } catch (err) {

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

@@ -4,6 +4,52 @@ 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 canvas template and listing flags', () => {
     const program = new Command();
     registerTaskCommands(program, {

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

@@ -10,6 +10,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 { registerTaskCommands } from '../register-task-commands.js';
+import { registerKanbanCommands } from '../register-kanban-commands.js';
 
 export const chalkStub = {
   cyan: (value) => value,
@@ -99,6 +101,14 @@ export function registerAllCommandModules(program = new Command()) {
     chalk: chalkStub,
     resolveVaultPath: stubResolveVaultPath
   });
+  registerTaskCommands(program, {
+    chalk: chalkStub,
+    resolveVaultPath: stubResolveVaultPath
+  });
+  registerKanbanCommands(program, {
+    chalk: chalkStub,
+    resolveVaultPath: stubResolveVaultPath
+  });
 
   return program;
 }

package/dist/{chunk-DEFBIVQ3.js → chunk-6QLRSPLZ.js}

@@ -33,6 +33,16 @@ function extractTitle(content) {
   const match = content.match(/^#\s+(.+)$/m);
   return match ? match[1].trim() : "";
 }
+function parseDueDate(value) {
+  if (!value) return null;
+  const timestamp = Date.parse(value);
+  if (Number.isNaN(timestamp)) return null;
+  return timestamp;
+}
+function startOfToday() {
+  const now = /* @__PURE__ */ new Date();
+  return new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+}
 function readTask(vaultPath, slug) {
   const taskPath = getTaskPath(vaultPath, slug);
   if (!fs.existsSync(taskPath)) {
@@ -80,6 +90,7 @@ function listTasks(vaultPath, filters) {
   }
   const tasks = [];
   const entries = fs.readdirSync(tasksDir, { withFileTypes: true });
+  const today = startOfToday();
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) {
       continue;
@@ -92,6 +103,16 @@ function listTasks(vaultPath, filters) {
       if (filters.owner && task.frontmatter.owner !== filters.owner) continue;
       if (filters.project && task.frontmatter.project !== filters.project) continue;
       if (filters.priority && task.frontmatter.priority !== filters.priority) continue;
+      if (filters.due && !task.frontmatter.due) continue;
+      if (filters.tag) {
+        const tags = task.frontmatter.tags || [];
+        const hasTag = tags.some((tag) => tag.toLowerCase() === filters.tag?.toLowerCase());
+        if (!hasTag) continue;
+      }
+      if (filters.overdue) {
+        const dueTime = parseDueDate(task.frontmatter.due);
+        if (task.frontmatter.status === "done" || dueTime === null || dueTime >= today) continue;
+      }
     }
     tasks.push(task);
   }
@@ -101,6 +122,18 @@ function listTasks(vaultPath, filters) {
     medium: 2,
     low: 3
   };
+  if (filters?.due || filters?.overdue) {
+    return tasks.sort((a, b) => {
+      const aDue = parseDueDate(a.frontmatter.due);
+      const bDue = parseDueDate(b.frontmatter.due);
+      if (aDue !== null && bDue !== null && aDue !== bDue) {
+        return aDue - bDue;
+      }
+      if (aDue !== null && bDue === null) return -1;
+      if (aDue === null && bDue !== null) return 1;
+      return new Date(b.frontmatter.created).getTime() - new Date(a.frontmatter.created).getTime();
+    });
+  }
   return tasks.sort((a, b) => {
     const aPriority = priorityOrder[a.frontmatter.priority || "low"];
     const bPriority = priorityOrder[b.frontmatter.priority || "low"];
@@ -153,6 +186,10 @@ function createTask(vaultPath, title, options = {}) {
   if (options.priority) frontmatter.priority = options.priority;
   if (options.due) frontmatter.due = options.due;
   if (options.tags && options.tags.length > 0) frontmatter.tags = options.tags;
+  if (options.description) frontmatter.description = options.description;
+  if (options.estimate) frontmatter.estimate = options.estimate;
+  if (options.parent) frontmatter.parent = options.parent;
+  if (options.depends_on && options.depends_on.length > 0) frontmatter.depends_on = options.depends_on;
   let content = `# ${title}
 `;
   const links = [];
@@ -188,14 +225,129 @@ function updateTask(vaultPath, slug, updates) {
     ...task.frontmatter,
     updated: now
   };
-  if (updates.status !== void 0) newFrontmatter.status = updates.status;
-  if (updates.owner !== void 0) newFrontmatter.owner = updates.owner;
-  if (updates.project !== void 0) newFrontmatter.project = updates.project;
-  if (updates.priority !== void 0) newFrontmatter.priority = updates.priority;
-  if (updates.due !== void 0) newFrontmatter.due = updates.due;
-  if (updates.tags !== void 0) newFrontmatter.tags = updates.tags;
+  if (updates.status !== void 0) {
+    newFrontmatter.status = updates.status;
+    if (updates.status === "done" && !newFrontmatter.completed) {
+      newFrontmatter.completed = now;
+    }
+    if (updates.status !== "done") {
+      delete newFrontmatter.completed;
+    }
+  }
+  if (updates.source !== void 0) {
+    if (updates.source === null || updates.source.trim() === "") {
+      delete newFrontmatter.source;
+    } else {
+      newFrontmatter.source = updates.source;
+    }
+  }
+  if (updates.owner !== void 0) {
+    if (updates.owner === null || updates.owner.trim() === "") {
+      delete newFrontmatter.owner;
+    } else {
+      newFrontmatter.owner = updates.owner;
+    }
+  }
+  if (updates.project !== void 0) {
+    if (updates.project === null || updates.project.trim() === "") {
+      delete newFrontmatter.project;
+    } else {
+      newFrontmatter.project = updates.project;
+    }
+  }
+  if (updates.priority !== void 0) {
+    if (updates.priority === null) {
+      delete newFrontmatter.priority;
+    } else {
+      newFrontmatter.priority = updates.priority;
+    }
+  }
+  if (updates.due !== void 0) {
+    if (updates.due === null || updates.due.trim() === "") {
+      delete newFrontmatter.due;
+    } else {
+      newFrontmatter.due = updates.due;
+    }
+  }
+  if (updates.tags !== void 0) {
+    if (updates.tags === null) {
+      delete newFrontmatter.tags;
+    } else {
+      const normalizedTags = updates.tags.map((tag) => tag.trim()).filter(Boolean);
+      if (normalizedTags.length === 0) {
+        delete newFrontmatter.tags;
+      } else {
+        newFrontmatter.tags = normalizedTags;
+      }
+    }
+  }
+  if (updates.completed !== void 0) {
+    if (updates.completed === null || updates.completed.trim() === "") {
+      delete newFrontmatter.completed;
+    } else {
+      newFrontmatter.completed = updates.completed;
+    }
+  }
+  if (updates.escalation !== void 0) {
+    if (updates.escalation === null) {
+      delete newFrontmatter.escalation;
+    } else {
+      newFrontmatter.escalation = updates.escalation;
+    }
+  }
+  if (updates.confidence !== void 0) {
+    if (updates.confidence === null) {
+      delete newFrontmatter.confidence;
+    } else {
+      newFrontmatter.confidence = updates.confidence;
+    }
+  }
+  if (updates.reason !== void 0) {
+    if (updates.reason === null || updates.reason.trim() === "") {
+      delete newFrontmatter.reason;
+    } else {
+      newFrontmatter.reason = updates.reason;
+    }
+  }
+  if (updates.description !== void 0) {
+    if (updates.description === null || updates.description.trim() === "") {
+      delete newFrontmatter.description;
+    } else {
+      newFrontmatter.description = updates.description;
+    }
+  }
+  if (updates.estimate !== void 0) {
+    if (updates.estimate === null || updates.estimate.trim() === "") {
+      delete newFrontmatter.estimate;
+    } else {
+      newFrontmatter.estimate = updates.estimate;
+    }
+  }
+  if (updates.parent !== void 0) {
+    if (updates.parent === null || updates.parent.trim() === "") {
+      delete newFrontmatter.parent;
+    } else {
+      newFrontmatter.parent = updates.parent;
+    }
+  }
+  if (updates.depends_on !== void 0) {
+    if (updates.depends_on === null) {
+      delete newFrontmatter.depends_on;
+    } else {
+      const normalizedDeps = updates.depends_on.map((dep) => dep.trim()).filter(Boolean);
+      if (normalizedDeps.length === 0) {
+        delete newFrontmatter.depends_on;
+      } else {
+        newFrontmatter.depends_on = normalizedDeps;
+      }
+    }
+  }
   if (updates.blocked_by !== void 0) {
-    newFrontmatter.blocked_by = updates.blocked_by;
+    if (updates.blocked_by === null || updates.blocked_by.trim() === "") {
+      delete newFrontmatter.blocked_by;
+    } else {
+      newFrontmatter.blocked_by = updates.blocked_by;
+    }
   } else if (updates.status && updates.status !== "blocked") {
     delete newFrontmatter.blocked_by;
   }
@@ -310,6 +462,15 @@ function getActiveTasks(vaultPath, filters) {
   const allTasks = listTasks(vaultPath, filters);
   return allTasks.filter((t) => t.frontmatter.status === "open" || t.frontmatter.status === "in-progress");
 }
+function listSubtasks(vaultPath, parentSlug) {
+  return listTasks(vaultPath).filter((task) => task.frontmatter.parent === parentSlug);
+}
+function listDependentTasks(vaultPath, dependencySlug) {
+  return listTasks(vaultPath).filter((task) => {
+    const dependencies = task.frontmatter.depends_on || [];
+    return dependencies.includes(dependencySlug);
+  });
+}
 function getRecentlyCompletedTasks(vaultPath, limit = 10) {
   const allTasks = listTasks(vaultPath, { status: "done" });
   return allTasks.filter((t) => t.frontmatter.completed).sort((a, b) => {
@@ -367,6 +528,8 @@ export {
   promoteBacklogItem,
   getBlockedTasks,
   getActiveTasks,
+  listSubtasks,
+  listDependentTasks,
   getRecentlyCompletedTasks,
   getStatusIcon,
   getStatusDisplay

package/dist/{chunk-B3SMJZIZ.js → chunk-FD2ZA65C.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-P5EPF6MB.js";
 import {
   Observer
-} from "./chunk-RXEIQ3KQ.js";
+} from "./chunk-H6WQUUNK.js";
 import {
   resolveVaultPath
 } from "./chunk-MXSSG3QU.js";

package/dist/{chunk-4JJL47IJ.js → chunk-FKQJB6XC.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-AHGUJG76.js";
 import {
   Observer
-} from "./chunk-RXEIQ3KQ.js";
+} from "./chunk-H6WQUUNK.js";
 import {
   resolveVaultPath
 } from "./chunk-MXSSG3QU.js";

package/dist/{chunk-RXEIQ3KQ.js → chunk-H6WQUUNK.js}

@@ -4,7 +4,7 @@ import {
   listTasks,
   updateBacklogItem,
   updateTask
-} from "./chunk-DEFBIVQ3.js";
+} from "./chunk-6QLRSPLZ.js";
 import {
   DEFAULT_CATEGORIES
 } from "./chunk-3PJIGGWV.js";

package/dist/{chunk-U2ONVV7N.js → chunk-JTO7NZLS.js}

@@ -1,6 +1,6 @@
 import {
   Observer
-} from "./chunk-RXEIQ3KQ.js";
+} from "./chunk-H6WQUUNK.js";
 import {
   resolveVaultPath
 } from "./chunk-MXSSG3QU.js";