clawvault 2.2.1 → 2.3.0

package/dist/commands/task.js

@@ -0,0 +1,189 @@
+import {
+  completeTask,
+  createTask,
+  getStatusDisplay,
+  getStatusIcon,
+  listTasks,
+  readTask,
+  updateTask
+} from "../chunk-NGVAEFT2.js";
+
+// src/commands/task.ts
+function taskAdd(vaultPath, title, options = {}) {
+  return createTask(vaultPath, title, {
+    owner: options.owner,
+    project: options.project,
+    priority: options.priority,
+    due: options.due,
+    content: options.content,
+    tags: options.tags
+  });
+}
+function taskList(vaultPath, options = {}) {
+  const filters = {};
+  if (options.status) filters.status = options.status;
+  if (options.owner) filters.owner = options.owner;
+  if (options.project) filters.project = options.project;
+  if (options.priority) filters.priority = options.priority;
+  if (!options.status) {
+    const allTasks = listTasks(vaultPath, filters);
+    return allTasks.filter((t) => t.frontmatter.status !== "done");
+  }
+  return listTasks(vaultPath, filters);
+}
+function taskUpdate(vaultPath, slug, options) {
+  return updateTask(vaultPath, slug, {
+    status: options.status,
+    owner: options.owner,
+    project: options.project,
+    priority: options.priority,
+    blocked_by: options.blockedBy,
+    due: options.due
+  });
+}
+function taskDone(vaultPath, slug) {
+  return completeTask(vaultPath, slug);
+}
+function taskShow(vaultPath, slug) {
+  return readTask(vaultPath, slug);
+}
+function formatTaskList(tasks) {
+  if (tasks.length === 0) {
+    return "No tasks found.\n";
+  }
+  const headers = ["STATUS", "OWNER", "PRIORITY", "PROJECT", "TITLE"];
+  const widths = [10, 12, 8, 16, 40];
+  let output = headers.map((h, i) => h.padEnd(widths[i])).join("  ") + "\n";
+  for (const task of tasks) {
+    const icon = getStatusIcon(task.frontmatter.status);
+    const statusDisplay = getStatusDisplay(task.frontmatter.status);
+    const status = `${icon} ${statusDisplay}`;
+    const owner = task.frontmatter.owner || "-";
+    const priority = task.frontmatter.priority || "low";
+    const project = task.frontmatter.project || "-";
+    const title = task.title.length > widths[4] ? task.title.slice(0, widths[4] - 3) + "..." : task.title;
+    const row = [
+      status.padEnd(widths[0]),
+      owner.padEnd(widths[1]),
+      priority.padEnd(widths[2]),
+      project.padEnd(widths[3]),
+      title
+    ];
+    output += row.join("  ") + "\n";
+  }
+  return output;
+}
+function formatTaskDetails(task) {
+  let output = "";
+  output += `# ${task.title}
+`;
+  output += "-".repeat(40) + "\n";
+  output += `Status: ${getStatusIcon(task.frontmatter.status)} ${getStatusDisplay(task.frontmatter.status)}
+`;
+  if (task.frontmatter.owner) {
+    output += `Owner: ${task.frontmatter.owner}
+`;
+  }
+  if (task.frontmatter.project) {
+    output += `Project: ${task.frontmatter.project}
+`;
+  }
+  if (task.frontmatter.priority) {
+    output += `Priority: ${task.frontmatter.priority}
+`;
+  }
+  if (task.frontmatter.due) {
+    output += `Due: ${task.frontmatter.due}
+`;
+  }
+  if (task.frontmatter.blocked_by) {
+    output += `Blocked by: ${task.frontmatter.blocked_by}
+`;
+  }
+  if (task.frontmatter.tags && task.frontmatter.tags.length > 0) {
+    output += `Tags: ${task.frontmatter.tags.join(", ")}
+`;
+  }
+  output += `Created: ${task.frontmatter.created}
+`;
+  output += `Updated: ${task.frontmatter.updated}
+`;
+  if (task.frontmatter.completed) {
+    output += `Completed: ${task.frontmatter.completed}
+`;
+  }
+  output += `File: ${task.path}
+`;
+  output += "-".repeat(40) + "\n";
+  const contentWithoutTitle = task.content.replace(/^#\s+.+\n/, "").trim();
+  if (contentWithoutTitle) {
+    output += "\n" + contentWithoutTitle + "\n";
+  }
+  return output;
+}
+async function taskCommand(vaultPath, action, args) {
+  const options = args.options || {};
+  switch (action) {
+    case "add": {
+      if (!args.title) {
+        throw new Error("Title is required for task add");
+      }
+      const task = taskAdd(vaultPath, args.title, options);
+      console.log(`\u2713 Created task: ${task.slug}`);
+      console.log(`  Path: ${task.path}`);
+      break;
+    }
+    case "list": {
+      const tasks = taskList(vaultPath, options);
+      if (options.json) {
+        console.log(JSON.stringify(tasks, null, 2));
+      } else {
+        console.log(formatTaskList(tasks));
+      }
+      break;
+    }
+    case "update": {
+      if (!args.slug) {
+        throw new Error("Task slug is required for update");
+      }
+      const task = taskUpdate(vaultPath, args.slug, options);
+      console.log(`\u2713 Updated task: ${task.slug}`);
+      break;
+    }
+    case "done": {
+      if (!args.slug) {
+        throw new Error("Task slug is required for done");
+      }
+      const task = taskDone(vaultPath, args.slug);
+      console.log(`\u2713 Completed task: ${task.slug}`);
+      break;
+    }
+    case "show": {
+      if (!args.slug) {
+        throw new Error("Task slug is required for show");
+      }
+      const task = taskShow(vaultPath, args.slug);
+      if (!task) {
+        throw new Error(`Task not found: ${args.slug}`);
+      }
+      if (options.json) {
+        console.log(JSON.stringify(task, null, 2));
+      } else {
+        console.log(formatTaskDetails(task));
+      }
+      break;
+    }
+    default:
+      throw new Error(`Unknown task action: ${action}`);
+  }
+}
+export {
+  formatTaskDetails,
+  formatTaskList,
+  taskAdd,
+  taskCommand,
+  taskDone,
+  taskList,
+  taskShow,
+  taskUpdate
+};

package/dist/commands/wake.js

@@ -1,21 +1,21 @@
 import {
   recover
-} from "../chunk-MILVYUPK.js";
+} from "../chunk-IWYZAXKJ.js";
+import "../chunk-7ZRP733D.js";
 import {
   clearDirtyFlag
 } from "../chunk-MZZJLQNQ.js";
+import {
+  ClawVault
+} from "../chunk-OTQW3OMC.js";
+import "../chunk-FDJIZKCW.js";
 import {
   parseObservationMarkdown
 } from "../chunk-K6XHCUFL.js";
+import "../chunk-ZZA73MFY.js";
 import {
   listObservationFiles
 } from "../chunk-Z2XBWN7A.js";
-import "../chunk-7ZRP733D.js";
-import {
-  ClawVault
-} from "../chunk-OTQW3OMC.js";
-import "../chunk-FDJIZKCW.js";
-import "../chunk-ZZA73MFY.js";
 
 // src/commands/wake.ts
 import * as fs from "fs";

package/dist/index.js

@@ -1,3 +1,19 @@
+import {
+  registerSyncBdCommand,
+  syncBdCommand
+} from "./chunk-MGDEINGP.js";
+import {
+  buildTemplateVariables,
+  renderTemplate
+} from "./chunk-7766SIJP.js";
+import {
+  reflectCommand,
+  registerReflectCommand
+} from "./chunk-GJEGPO7U.js";
+import {
+  registerReplayCommand,
+  replayCommand
+} from "./chunk-6BBTI7NV.js";
 import {
   buildSessionRecap,
   formatSessionRecapMarkdown,
@@ -7,47 +23,35 @@ import {
   setupCommand
 } from "./chunk-W463YRED.js";
 import {
-  registerSyncBdCommand,
-  syncBdCommand
-} from "./chunk-MGDEINGP.js";
+  runReflection
+} from "./chunk-GQVYQCY5.js";
 import {
-  buildTemplateVariables,
-  renderTemplate
-} from "./chunk-7766SIJP.js";
+  graphCommand,
+  graphSummary
+} from "./chunk-OZ7RIXTO.js";
 import {
   migrateObservations,
   migrateObservationsCommand,
   registerMigrateObservationsCommand
-} from "./chunk-WZI3OAE5.js";
+} from "./chunk-5WR6RRPX.js";
 import {
   SessionWatcher,
   observeCommand,
   registerObserveCommand
-} from "./chunk-LB6P4CD5.js";
+} from "./chunk-PTSEIWXZ.js";
+import "./chunk-HRLWZGMA.js";
 import {
   parseSessionFile
 } from "./chunk-P5EPF6MB.js";
 import {
   rebuildCommand,
   registerRebuildCommand
-} from "./chunk-73P7XCQM.js";
-import {
-  reflectCommand,
-  registerReflectCommand
-} from "./chunk-GJEGPO7U.js";
-import "./chunk-HRLWZGMA.js";
-import {
-  registerReplayCommand,
-  replayCommand
-} from "./chunk-L6NB43WV.js";
+} from "./chunk-DPS7NYIU.js";
 import {
   Compressor,
   Observer,
   Reflector
 } from "./chunk-2HM7ZI4X.js";
-import {
-  runReflection
-} from "./chunk-GQVYQCY5.js";
 import {
   archiveCommand,
   registerArchiveCommand
@@ -55,6 +59,16 @@ import {
 import {
   archiveObservations
 } from "./chunk-MQUJNOHK.js";
+import {
+  findNearestVaultPath,
+  getVaultPath,
+  resolveVaultPath
+} from "./chunk-MXSSG3QU.js";
+import {
+  checkOpenClawCompatibility,
+  compatCommand,
+  compatibilityExitCode
+} from "./chunk-PAYUH64O.js";
 import {
   buildContext,
   contextCommand,
@@ -63,14 +77,7 @@ import {
   normalizeContextProfileInput,
   registerContextCommand,
   resolveContextProfile
-} from "./chunk-I5X6J4FX.js";
-import "./chunk-K6XHCUFL.js";
-import "./chunk-Z2XBWN7A.js";
-import {
-  checkOpenClawCompatibility,
-  compatCommand,
-  compatibilityExitCode
-} from "./chunk-PAYUH64O.js";
+} from "./chunk-SOTWYGH7.js";
 import {
   ClawVault,
   createVault,
@@ -91,21 +98,14 @@ import {
   qmdEmbed,
   qmdUpdate
 } from "./chunk-FDJIZKCW.js";
-import {
-  graphCommand,
-  graphSummary
-} from "./chunk-H7JW4L7H.js";
+import "./chunk-K6XHCUFL.js";
 import {
   MEMORY_GRAPH_SCHEMA_VERSION,
   buildOrUpdateMemoryGraphIndex,
   getMemoryGraph,
   loadMemoryGraphIndex
 } from "./chunk-ZZA73MFY.js";
-import {
-  findNearestVaultPath,
-  getVaultPath,
-  resolveVaultPath
-} from "./chunk-MXSSG3QU.js";
+import "./chunk-Z2XBWN7A.js";
 
 // src/index.ts
 import * as fs from "fs";

package/dist/lib/canvas-layout.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Canvas layout utilities for ClawVault
+ * Handles JSON Canvas generation with proper positioning and grouping
+ */
+interface CanvasNode {
+    id: string;
+    type: 'text' | 'file' | 'group';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    text?: string;
+    file?: string;
+    label?: string;
+    color?: string;
+}
+interface CanvasEdge {
+    id: string;
+    fromNode: string;
+    fromSide: 'top' | 'right' | 'bottom' | 'left';
+    toNode: string;
+    toSide: 'top' | 'right' | 'bottom' | 'left';
+    label?: string;
+    color?: string;
+}
+interface Canvas {
+    nodes: CanvasNode[];
+    edges: CanvasEdge[];
+}
+declare const CANVAS_COLORS: {
+    readonly RED: "1";
+    readonly ORANGE: "2";
+    readonly YELLOW: "3";
+    readonly GREEN: "4";
+    readonly CYAN: "5";
+    readonly PURPLE: "6";
+};
+declare const LAYOUT: {
+    readonly LEFT_COLUMN_X: 0;
+    readonly LEFT_COLUMN_WIDTH: 500;
+    readonly RIGHT_COLUMN_X: 550;
+    readonly RIGHT_COLUMN_WIDTH: 450;
+    readonly GROUP_PADDING: 20;
+    readonly NODE_SPACING: 15;
+    readonly GROUP_SPACING: 50;
+    readonly DEFAULT_NODE_WIDTH: 280;
+    readonly DEFAULT_NODE_HEIGHT: 80;
+    readonly FILE_NODE_HEIGHT: 60;
+    readonly SMALL_NODE_HEIGHT: 50;
+    readonly GROUP_HEADER_HEIGHT: 40;
+};
+/**
+ * Generate a 16-character lowercase hex ID
+ */
+declare function generateId(): string;
+/**
+ * Create a text node
+ */
+declare function createTextNode(x: number, y: number, width: number, height: number, text: string, color?: string): CanvasNode;
+/**
+ * Create a file node
+ */
+declare function createFileNode(x: number, y: number, width: number, height: number, file: string, color?: string): CanvasNode;
+/**
+ * Create a group node
+ */
+declare function createGroupNode(x: number, y: number, width: number, height: number, label: string, color?: string): CanvasNode;
+/**
+ * Create an edge between nodes
+ */
+declare function createEdge(fromNode: string, fromSide: 'top' | 'right' | 'bottom' | 'left', toNode: string, toSide: 'top' | 'right' | 'bottom' | 'left', label?: string, color?: string): CanvasEdge;
+/**
+ * Layout helper for vertical stacking of nodes within a group
+ */
+interface StackedLayout {
+    nodes: CanvasNode[];
+    totalHeight: number;
+}
+declare function stackNodesVertically(nodes: CanvasNode[], startX: number, startY: number, spacing?: number): StackedLayout;
+/**
+ * Create a group with contained nodes
+ * Returns the group node and positioned child nodes
+ */
+interface GroupWithNodes {
+    group: CanvasNode;
+    nodes: CanvasNode[];
+}
+declare function createGroupWithNodes(groupX: number, groupY: number, groupWidth: number, label: string, childNodes: CanvasNode[], color?: string): GroupWithNodes;
+/**
+ * Get priority color for a task
+ */
+declare function getPriorityColor(priority?: string): string | undefined;
+/**
+ * Truncate text to fit within a certain width (approximate)
+ */
+declare function truncateText(text: string, maxChars: number): string;
+/**
+ * Format markdown text for canvas node
+ * Replaces newlines with \n for JSON Canvas spec
+ */
+declare function formatCanvasText(lines: string[]): string;
+/**
+ * Calculate the total height needed for a column of groups
+ */
+declare function calculateColumnHeight(groups: GroupWithNodes[]): number;
+/**
+ * Position groups vertically in a column
+ */
+declare function positionGroupsVertically(groups: GroupWithNodes[], startY?: number): GroupWithNodes[];
+/**
+ * Flatten groups and nodes into a single array
+ */
+declare function flattenGroups(groups: GroupWithNodes[]): CanvasNode[];
+
+export { CANVAS_COLORS, type Canvas, type CanvasEdge, type CanvasNode, type GroupWithNodes, LAYOUT, type StackedLayout, calculateColumnHeight, createEdge, createFileNode, createGroupNode, createGroupWithNodes, createTextNode, flattenGroups, formatCanvasText, generateId, getPriorityColor, positionGroupsVertically, stackNodesVertically, truncateText };

package/dist/lib/canvas-layout.js

@@ -0,0 +1,34 @@
+import {
+  CANVAS_COLORS,
+  LAYOUT,
+  calculateColumnHeight,
+  createEdge,
+  createFileNode,
+  createGroupNode,
+  createGroupWithNodes,
+  createTextNode,
+  flattenGroups,
+  formatCanvasText,
+  generateId,
+  getPriorityColor,
+  positionGroupsVertically,
+  stackNodesVertically,
+  truncateText
+} from "../chunk-MDIH26GC.js";
+export {
+  CANVAS_COLORS,
+  LAYOUT,
+  calculateColumnHeight,
+  createEdge,
+  createFileNode,
+  createGroupNode,
+  createGroupWithNodes,
+  createTextNode,
+  flattenGroups,
+  formatCanvasText,
+  generateId,
+  getPriorityColor,
+  positionGroupsVertically,
+  stackNodesVertically,
+  truncateText
+};

package/dist/lib/task-utils.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Task utilities for ClawVault task tracking
+ * Handles task and backlog file read/write/query operations
+ */
+type TaskStatus = 'open' | 'in-progress' | 'blocked' | 'done';
+type TaskPriority = 'critical' | 'high' | 'medium' | 'low';
+interface TaskFrontmatter {
+    status: TaskStatus;
+    owner?: string;
+    project?: string;
+    priority?: TaskPriority;
+    blocked_by?: string;
+    due?: string;
+    created: string;
+    updated: string;
+    completed?: string;
+    tags?: string[];
+}
+interface Task {
+    slug: string;
+    title: string;
+    content: string;
+    frontmatter: TaskFrontmatter;
+    path: string;
+}
+interface BacklogFrontmatter {
+    source?: string;
+    project?: string;
+    created: string;
+    tags?: string[];
+}
+interface BacklogItem {
+    slug: string;
+    title: string;
+    content: string;
+    frontmatter: BacklogFrontmatter;
+    path: string;
+}
+interface TaskFilterOptions {
+    status?: TaskStatus;
+    owner?: string;
+    project?: string;
+    priority?: TaskPriority;
+}
+interface BacklogFilterOptions {
+    project?: string;
+    source?: string;
+}
+/**
+ * Slugify a title for use as filename
+ * Deterministic: same title = same slug
+ */
+declare function slugify(text: string): string;
+/**
+ * Get the tasks directory path
+ */
+declare function getTasksDir(vaultPath: string): string;
+/**
+ * Get the backlog directory path
+ */
+declare function getBacklogDir(vaultPath: string): string;
+/**
+ * Ensure the tasks directory exists
+ */
+declare function ensureTasksDir(vaultPath: string): void;
+/**
+ * Ensure the backlog directory exists
+ */
+declare function ensureBacklogDir(vaultPath: string): void;
+/**
+ * Get task file path from slug
+ */
+declare function getTaskPath(vaultPath: string, slug: string): string;
+/**
+ * Get backlog file path from slug
+ */
+declare function getBacklogPath(vaultPath: string, slug: string): string;
+/**
+ * Read a task file and parse it
+ */
+declare function readTask(vaultPath: string, slug: string): Task | null;
+/**
+ * Read a backlog item file and parse it
+ */
+declare function readBacklogItem(vaultPath: string, slug: string): BacklogItem | null;
+/**
+ * List all tasks in the vault
+ */
+declare function listTasks(vaultPath: string, filters?: TaskFilterOptions): Task[];
+/**
+ * List all backlog items in the vault
+ */
+declare function listBacklogItems(vaultPath: string, filters?: BacklogFilterOptions): BacklogItem[];
+/**
+ * Create a new task
+ */
+declare function createTask(vaultPath: string, title: string, options?: {
+    owner?: string;
+    project?: string;
+    priority?: TaskPriority;
+    due?: string;
+    content?: string;
+    tags?: string[];
+}): Task;
+/**
+ * Update an existing task
+ */
+declare function updateTask(vaultPath: string, slug: string, updates: {
+    status?: TaskStatus;
+    owner?: string;
+    project?: string;
+    priority?: TaskPriority;
+    blocked_by?: string;
+    due?: string;
+    tags?: string[];
+}): Task;
+/**
+ * Mark a task as done
+ */
+declare function completeTask(vaultPath: string, slug: string): Task;
+/**
+ * Create a new backlog item
+ */
+declare function createBacklogItem(vaultPath: string, title: string, options?: {
+    source?: string;
+    project?: string;
+    content?: string;
+    tags?: string[];
+}): BacklogItem;
+/**
+ * Promote a backlog item to a task
+ */
+declare function promoteBacklogItem(vaultPath: string, slug: string, options?: {
+    owner?: string;
+    priority?: TaskPriority;
+    due?: string;
+}): Task;
+/**
+ * Get blocked tasks
+ */
+declare function getBlockedTasks(vaultPath: string, project?: string): Task[];
+/**
+ * Get active tasks (open or in-progress)
+ */
+declare function getActiveTasks(vaultPath: string, filters?: Omit<TaskFilterOptions, 'status'>): Task[];
+/**
+ * Get recently completed tasks
+ */
+declare function getRecentlyCompletedTasks(vaultPath: string, limit?: number): Task[];
+/**
+ * Format task status icon
+ */
+declare function getStatusIcon(status: TaskStatus): string;
+/**
+ * Format task status display name
+ */
+declare function getStatusDisplay(status: TaskStatus): string;
+
+export { type BacklogFilterOptions, type BacklogFrontmatter, type BacklogItem, type Task, type TaskFilterOptions, type TaskFrontmatter, type TaskPriority, type TaskStatus, completeTask, createBacklogItem, createTask, ensureBacklogDir, ensureTasksDir, getActiveTasks, getBacklogDir, getBacklogPath, getBlockedTasks, getRecentlyCompletedTasks, getStatusDisplay, getStatusIcon, getTaskPath, getTasksDir, listBacklogItems, listTasks, promoteBacklogItem, readBacklogItem, readTask, slugify, updateTask };

package/dist/lib/task-utils.js

@@ -0,0 +1,46 @@
+import {
+  completeTask,
+  createBacklogItem,
+  createTask,
+  ensureBacklogDir,
+  ensureTasksDir,
+  getActiveTasks,
+  getBacklogDir,
+  getBacklogPath,
+  getBlockedTasks,
+  getRecentlyCompletedTasks,
+  getStatusDisplay,
+  getStatusIcon,
+  getTaskPath,
+  getTasksDir,
+  listBacklogItems,
+  listTasks,
+  promoteBacklogItem,
+  readBacklogItem,
+  readTask,
+  slugify,
+  updateTask
+} from "../chunk-NGVAEFT2.js";
+export {
+  completeTask,
+  createBacklogItem,
+  createTask,
+  ensureBacklogDir,
+  ensureTasksDir,
+  getActiveTasks,
+  getBacklogDir,
+  getBacklogPath,
+  getBlockedTasks,
+  getRecentlyCompletedTasks,
+  getStatusDisplay,
+  getStatusIcon,
+  getTaskPath,
+  getTasksDir,
+  listBacklogItems,
+  listTasks,
+  promoteBacklogItem,
+  readBacklogItem,
+  readTask,
+  slugify,
+  updateTask
+};