clawvault 2.2.1 → 2.3.0

package/bin/clawvault.js

@@ -16,6 +16,7 @@ import { registerResilienceCommands } from './register-resilience-commands.js';
 import { registerSessionLifecycleCommands } from './register-session-lifecycle-commands.js';
 import { registerTemplateCommands } from './register-template-commands.js';
 import { registerVaultOperationsCommands } from './register-vault-operations-commands.js';
+import { registerTaskCommands } from './register-task-commands.js';
 import {
   getVault,
   resolveVaultPath,
@@ -82,5 +83,10 @@ registerVaultOperationsCommands(program, {
   path
 });
 
+registerTaskCommands(program, {
+  chalk,
+  resolveVaultPath
+});
+
 // Parse and run
 program.parse();

package/bin/register-task-commands.js

@@ -0,0 +1,257 @@
+/**
+ * Task tracking command registrations for ClawVault
+ * Registers task, backlog, blocked, and canvas commands
+ */
+
+export function registerTaskCommands(
+  program,
+  { chalk, resolveVaultPath }
+) {
+  // === TASK ===
+  const taskCmd = program
+    .command('task')
+    .description('Task management');
+
+  // task add
+  taskCmd
+    .command('add <title>')
+    .description('Add a new task')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--owner <owner>', 'Task owner')
+    .option('--project <project>', 'Project name')
+    .option('--priority <priority>', 'Priority (critical, high, medium, low)')
+    .option('--due <date>', 'Due date (YYYY-MM-DD)')
+    .action(async (title, options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { taskCommand } = await import('../dist/commands/task.js');
+        await taskCommand(vaultPath, 'add', {
+          title,
+          options: {
+            owner: options.owner,
+            project: options.project,
+            priority: options.priority,
+            due: options.due
+          }
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  // task list
+  taskCmd
+    .command('list')
+    .description('List tasks')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--owner <owner>', 'Filter by owner')
+    .option('--project <project>', 'Filter by project')
+    .option('--status <status>', 'Filter by status (open, in-progress, blocked, done)')
+    .option('--priority <priority>', 'Filter by priority')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { taskCommand } = await import('../dist/commands/task.js');
+        await taskCommand(vaultPath, 'list', {
+          options: {
+            owner: options.owner,
+            project: options.project,
+            status: options.status,
+            priority: options.priority,
+            json: options.json
+          }
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  // task update
+  taskCmd
+    .command('update <slug>')
+    .description('Update a task')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--status <status>', 'New status')
+    .option('--owner <owner>', 'New owner')
+    .option('--project <project>', 'New project')
+    .option('--priority <priority>', 'New priority')
+    .option('--blocked-by <blocker>', 'What is blocking this task')
+    .option('--due <date>', 'New due date')
+    .action(async (slug, options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { taskCommand } = await import('../dist/commands/task.js');
+        await taskCommand(vaultPath, 'update', {
+          slug,
+          options: {
+            status: options.status,
+            owner: options.owner,
+            project: options.project,
+            priority: options.priority,
+            blockedBy: options.blockedBy,
+            due: options.due
+          }
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  // task done
+  taskCmd
+    .command('done <slug>')
+    .description('Mark a task as done')
+    .option('-v, --vault <path>', 'Vault path')
+    .action(async (slug, options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { taskCommand } = await import('../dist/commands/task.js');
+        await taskCommand(vaultPath, 'done', { slug });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  // task show
+  taskCmd
+    .command('show <slug>')
+    .description('Show task details')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--json', 'Output as JSON')
+    .action(async (slug, options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { taskCommand } = await import('../dist/commands/task.js');
+        await taskCommand(vaultPath, 'show', {
+          slug,
+          options: { json: options.json }
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  // === BACKLOG ===
+  const backlogCmd = program
+    .command('backlog')
+    .description('Backlog management');
+
+  // backlog add (also supports "backlog <title>" shorthand)
+  backlogCmd
+    .command('add <title>')
+    .description('Add item to backlog')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--source <source>', 'Source of the idea')
+    .option('--project <project>', 'Project name')
+    .action(async (title, options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { backlogCommand } = await import('../dist/commands/backlog.js');
+        await backlogCommand(vaultPath, 'add', {
+          title,
+          options: {
+            source: options.source,
+            project: options.project
+          }
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  // backlog list
+  backlogCmd
+    .command('list')
+    .description('List backlog items')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--project <project>', 'Filter by project')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { backlogCommand } = await import('../dist/commands/backlog.js');
+        await backlogCommand(vaultPath, 'list', {
+          options: {
+            project: options.project,
+            json: options.json
+          }
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  // backlog promote
+  backlogCmd
+    .command('promote <slug>')
+    .description('Promote backlog item to task')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--owner <owner>', 'Task owner')
+    .option('--priority <priority>', 'Task priority')
+    .option('--due <date>', 'Due date')
+    .action(async (slug, options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { backlogCommand } = await import('../dist/commands/backlog.js');
+        await backlogCommand(vaultPath, 'promote', {
+          slug,
+          options: {
+            owner: options.owner,
+            priority: options.priority,
+            due: options.due
+          }
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  // === BLOCKED ===
+  program
+    .command('blocked')
+    .description('View blocked tasks')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--project <project>', 'Filter by project')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { blockedCommand } = await import('../dist/commands/blocked.js');
+        await blockedCommand(vaultPath, {
+          project: options.project,
+          json: options.json
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  // === CANVAS ===
+  program
+    .command('canvas')
+    .description('Generate Obsidian canvas dashboard')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--output <path>', 'Output file path (default: dashboard.canvas)')
+    .action(async (options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { canvasCommand } = await import('../dist/commands/canvas.js');
+        await canvasCommand(vaultPath, {
+          output: options.output
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+}

package/dist/chunk-MDIH26GC.js

@@ -0,0 +1,183 @@
+// src/lib/canvas-layout.ts
+import * as crypto from "crypto";
+var CANVAS_COLORS = {
+  RED: "1",
+  // Critical, blocked
+  ORANGE: "2",
+  // High priority
+  YELLOW: "3",
+  // Medium priority
+  GREEN: "4",
+  // Done, success
+  CYAN: "5",
+  // Stats
+  PURPLE: "6"
+  // Knowledge graph
+};
+var LAYOUT = {
+  LEFT_COLUMN_X: 0,
+  LEFT_COLUMN_WIDTH: 500,
+  RIGHT_COLUMN_X: 550,
+  RIGHT_COLUMN_WIDTH: 450,
+  GROUP_PADDING: 20,
+  NODE_SPACING: 15,
+  GROUP_SPACING: 50,
+  DEFAULT_NODE_WIDTH: 280,
+  DEFAULT_NODE_HEIGHT: 80,
+  FILE_NODE_HEIGHT: 60,
+  SMALL_NODE_HEIGHT: 50,
+  GROUP_HEADER_HEIGHT: 40
+};
+function generateId() {
+  return crypto.randomBytes(8).toString("hex");
+}
+function createTextNode(x, y, width, height, text, color) {
+  const node = {
+    id: generateId(),
+    type: "text",
+    x,
+    y,
+    width,
+    height,
+    text
+  };
+  if (color) node.color = color;
+  return node;
+}
+function createFileNode(x, y, width, height, file, color) {
+  const node = {
+    id: generateId(),
+    type: "file",
+    x,
+    y,
+    width,
+    height,
+    file
+  };
+  if (color) node.color = color;
+  return node;
+}
+function createGroupNode(x, y, width, height, label, color) {
+  const node = {
+    id: generateId(),
+    type: "group",
+    x,
+    y,
+    width,
+    height,
+    label
+  };
+  if (color) node.color = color;
+  return node;
+}
+function createEdge(fromNode, fromSide, toNode, toSide, label, color) {
+  const edge = {
+    id: generateId(),
+    fromNode,
+    fromSide,
+    toNode,
+    toSide
+  };
+  if (label) edge.label = label;
+  if (color) edge.color = color;
+  return edge;
+}
+function stackNodesVertically(nodes, startX, startY, spacing = LAYOUT.NODE_SPACING) {
+  let currentY = startY;
+  const positionedNodes = [];
+  for (const node of nodes) {
+    positionedNodes.push({
+      ...node,
+      x: startX,
+      y: currentY
+    });
+    currentY += node.height + spacing;
+  }
+  return {
+    nodes: positionedNodes,
+    totalHeight: currentY - startY - spacing
+  };
+}
+function createGroupWithNodes(groupX, groupY, groupWidth, label, childNodes, color) {
+  const padding = LAYOUT.GROUP_PADDING;
+  const headerHeight = LAYOUT.GROUP_HEADER_HEIGHT;
+  const stacked = stackNodesVertically(
+    childNodes,
+    groupX + padding,
+    groupY + headerHeight + padding
+  );
+  const groupHeight = headerHeight + padding * 2 + stacked.totalHeight + LAYOUT.NODE_SPACING;
+  const group = createGroupNode(groupX, groupY, groupWidth, groupHeight, label, color);
+  return {
+    group,
+    nodes: stacked.nodes
+  };
+}
+function getPriorityColor(priority) {
+  switch (priority) {
+    case "critical":
+      return CANVAS_COLORS.RED;
+    case "high":
+      return CANVAS_COLORS.ORANGE;
+    case "medium":
+      return CANVAS_COLORS.YELLOW;
+    default:
+      return void 0;
+  }
+}
+function truncateText(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars - 3) + "...";
+}
+function formatCanvasText(lines) {
+  return lines.join("\n");
+}
+function calculateColumnHeight(groups) {
+  let height = 0;
+  for (let i = 0; i < groups.length; i++) {
+    height += groups[i].group.height;
+    if (i < groups.length - 1) {
+      height += LAYOUT.GROUP_SPACING;
+    }
+  }
+  return height;
+}
+function positionGroupsVertically(groups, startY = 0) {
+  let currentY = startY;
+  const positioned = [];
+  for (const { group, nodes } of groups) {
+    const yOffset = currentY - group.y;
+    positioned.push({
+      group: { ...group, y: currentY },
+      nodes: nodes.map((n) => ({ ...n, y: n.y + yOffset }))
+    });
+    currentY += group.height + LAYOUT.GROUP_SPACING;
+  }
+  return positioned;
+}
+function flattenGroups(groups) {
+  const nodes = [];
+  for (const { group, nodes: childNodes } of groups) {
+    nodes.push(group);
+    nodes.push(...childNodes);
+  }
+  return nodes;
+}
+
+export {
+  CANVAS_COLORS,
+  LAYOUT,
+  generateId,
+  createTextNode,
+  createFileNode,
+  createGroupNode,
+  createEdge,
+  stackNodesVertically,
+  createGroupWithNodes,
+  getPriorityColor,
+  truncateText,
+  formatCanvasText,
+  calculateColumnHeight,
+  positionGroupsVertically,
+  flattenGroups
+};