clawvault 2.2.1 → 2.3.0

package/dist/chunk-NGVAEFT2.js

@@ -0,0 +1,352 @@
+// src/lib/task-utils.ts
+import * as fs from "fs";
+import * as path from "path";
+import matter from "gray-matter";
+function slugify(text) {
+  return text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").trim();
+}
+function getTasksDir(vaultPath) {
+  return path.join(path.resolve(vaultPath), "tasks");
+}
+function getBacklogDir(vaultPath) {
+  return path.join(path.resolve(vaultPath), "backlog");
+}
+function ensureTasksDir(vaultPath) {
+  const tasksDir = getTasksDir(vaultPath);
+  if (!fs.existsSync(tasksDir)) {
+    fs.mkdirSync(tasksDir, { recursive: true });
+  }
+}
+function ensureBacklogDir(vaultPath) {
+  const backlogDir = getBacklogDir(vaultPath);
+  if (!fs.existsSync(backlogDir)) {
+    fs.mkdirSync(backlogDir, { recursive: true });
+  }
+}
+function getTaskPath(vaultPath, slug) {
+  return path.join(getTasksDir(vaultPath), `${slug}.md`);
+}
+function getBacklogPath(vaultPath, slug) {
+  return path.join(getBacklogDir(vaultPath), `${slug}.md`);
+}
+function extractTitle(content) {
+  const match = content.match(/^#\s+(.+)$/m);
+  return match ? match[1].trim() : "";
+}
+function readTask(vaultPath, slug) {
+  const taskPath = getTaskPath(vaultPath, slug);
+  if (!fs.existsSync(taskPath)) {
+    return null;
+  }
+  try {
+    const raw = fs.readFileSync(taskPath, "utf-8");
+    const { data, content } = matter(raw);
+    const title = extractTitle(content) || slug;
+    return {
+      slug,
+      title,
+      content,
+      frontmatter: data,
+      path: taskPath
+    };
+  } catch {
+    return null;
+  }
+}
+function readBacklogItem(vaultPath, slug) {
+  const backlogPath = getBacklogPath(vaultPath, slug);
+  if (!fs.existsSync(backlogPath)) {
+    return null;
+  }
+  try {
+    const raw = fs.readFileSync(backlogPath, "utf-8");
+    const { data, content } = matter(raw);
+    const title = extractTitle(content) || slug;
+    return {
+      slug,
+      title,
+      content,
+      frontmatter: data,
+      path: backlogPath
+    };
+  } catch {
+    return null;
+  }
+}
+function listTasks(vaultPath, filters) {
+  const tasksDir = getTasksDir(vaultPath);
+  if (!fs.existsSync(tasksDir)) {
+    return [];
+  }
+  const tasks = [];
+  const entries = fs.readdirSync(tasksDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) {
+      continue;
+    }
+    const slug = entry.name.replace(/\.md$/, "");
+    const task = readTask(vaultPath, slug);
+    if (!task) continue;
+    if (filters) {
+      if (filters.status && task.frontmatter.status !== filters.status) continue;
+      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;
+    }
+    tasks.push(task);
+  }
+  const priorityOrder = {
+    critical: 0,
+    high: 1,
+    medium: 2,
+    low: 3
+  };
+  return tasks.sort((a, b) => {
+    const aPriority = priorityOrder[a.frontmatter.priority || "low"];
+    const bPriority = priorityOrder[b.frontmatter.priority || "low"];
+    if (aPriority !== bPriority) {
+      return aPriority - bPriority;
+    }
+    return new Date(b.frontmatter.created).getTime() - new Date(a.frontmatter.created).getTime();
+  });
+}
+function listBacklogItems(vaultPath, filters) {
+  const backlogDir = getBacklogDir(vaultPath);
+  if (!fs.existsSync(backlogDir)) {
+    return [];
+  }
+  const items = [];
+  const entries = fs.readdirSync(backlogDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) {
+      continue;
+    }
+    const slug = entry.name.replace(/\.md$/, "");
+    const item = readBacklogItem(vaultPath, slug);
+    if (!item) continue;
+    if (filters) {
+      if (filters.project && item.frontmatter.project !== filters.project) continue;
+      if (filters.source && item.frontmatter.source !== filters.source) continue;
+    }
+    items.push(item);
+  }
+  return items.sort((a, b) => {
+    return new Date(b.frontmatter.created).getTime() - new Date(a.frontmatter.created).getTime();
+  });
+}
+function createTask(vaultPath, title, options = {}) {
+  ensureTasksDir(vaultPath);
+  const slug = slugify(title);
+  const taskPath = getTaskPath(vaultPath, slug);
+  if (fs.existsSync(taskPath)) {
+    throw new Error(`Task already exists: ${slug}`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const frontmatter = {
+    status: "open",
+    created: now,
+    updated: now
+  };
+  if (options.owner) frontmatter.owner = options.owner;
+  if (options.project) frontmatter.project = options.project;
+  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;
+  let content = `# ${title}
+`;
+  const links = [];
+  if (options.owner) links.push(`[[${options.owner}]]`);
+  if (options.project) links.push(`[[${options.project}]]`);
+  if (links.length > 0) {
+    content += `
+${links.join(" | ")}
+`;
+  }
+  if (options.content) {
+    content += `
+${options.content}
+`;
+  }
+  const fileContent = matter.stringify(content, frontmatter);
+  fs.writeFileSync(taskPath, fileContent);
+  return {
+    slug,
+    title,
+    content,
+    frontmatter,
+    path: taskPath
+  };
+}
+function updateTask(vaultPath, slug, updates) {
+  const task = readTask(vaultPath, slug);
+  if (!task) {
+    throw new Error(`Task not found: ${slug}`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const newFrontmatter = {
+    ...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.blocked_by !== void 0) {
+    newFrontmatter.blocked_by = updates.blocked_by;
+  } else if (updates.status && updates.status !== "blocked") {
+    delete newFrontmatter.blocked_by;
+  }
+  const fileContent = matter.stringify(task.content, newFrontmatter);
+  fs.writeFileSync(task.path, fileContent);
+  return {
+    ...task,
+    frontmatter: newFrontmatter
+  };
+}
+function completeTask(vaultPath, slug) {
+  const task = readTask(vaultPath, slug);
+  if (!task) {
+    throw new Error(`Task not found: ${slug}`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const newFrontmatter = {
+    ...task.frontmatter,
+    status: "done",
+    updated: now,
+    completed: now
+  };
+  delete newFrontmatter.blocked_by;
+  const fileContent = matter.stringify(task.content, newFrontmatter);
+  fs.writeFileSync(task.path, fileContent);
+  return {
+    ...task,
+    frontmatter: newFrontmatter
+  };
+}
+function createBacklogItem(vaultPath, title, options = {}) {
+  ensureBacklogDir(vaultPath);
+  const slug = slugify(title);
+  const backlogPath = getBacklogPath(vaultPath, slug);
+  if (fs.existsSync(backlogPath)) {
+    throw new Error(`Backlog item already exists: ${slug}`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const frontmatter = {
+    created: now
+  };
+  if (options.source) frontmatter.source = options.source;
+  if (options.project) frontmatter.project = options.project;
+  if (options.tags && options.tags.length > 0) frontmatter.tags = options.tags;
+  let content = `# ${title}
+`;
+  const links = [];
+  if (options.source) links.push(`[[${options.source}]]`);
+  if (options.project) links.push(`[[${options.project}]]`);
+  if (links.length > 0) {
+    content += `
+${links.join(" | ")}
+`;
+  }
+  if (options.content) {
+    content += `
+${options.content}
+`;
+  }
+  const fileContent = matter.stringify(content, frontmatter);
+  fs.writeFileSync(backlogPath, fileContent);
+  return {
+    slug,
+    title,
+    content,
+    frontmatter,
+    path: backlogPath
+  };
+}
+function promoteBacklogItem(vaultPath, slug, options = {}) {
+  const backlogItem = readBacklogItem(vaultPath, slug);
+  if (!backlogItem) {
+    throw new Error(`Backlog item not found: ${slug}`);
+  }
+  const task = createTask(vaultPath, backlogItem.title, {
+    owner: options.owner,
+    project: backlogItem.frontmatter.project,
+    priority: options.priority,
+    due: options.due,
+    content: backlogItem.content.replace(/^#\s+.+\n/, "").trim(),
+    // Remove title from content
+    tags: backlogItem.frontmatter.tags
+  });
+  fs.unlinkSync(backlogItem.path);
+  return task;
+}
+function getBlockedTasks(vaultPath, project) {
+  const filters = { status: "blocked" };
+  if (project) filters.project = project;
+  return listTasks(vaultPath, filters);
+}
+function getActiveTasks(vaultPath, filters) {
+  const allTasks = listTasks(vaultPath, filters);
+  return allTasks.filter((t) => t.frontmatter.status === "open" || t.frontmatter.status === "in-progress");
+}
+function getRecentlyCompletedTasks(vaultPath, limit = 10) {
+  const allTasks = listTasks(vaultPath, { status: "done" });
+  return allTasks.filter((t) => t.frontmatter.completed).sort((a, b) => {
+    const aCompleted = new Date(a.frontmatter.completed || 0).getTime();
+    const bCompleted = new Date(b.frontmatter.completed || 0).getTime();
+    return bCompleted - aCompleted;
+  }).slice(0, limit);
+}
+function getStatusIcon(status) {
+  switch (status) {
+    case "in-progress":
+      return "\u25CF";
+    case "blocked":
+      return "\u25A0";
+    case "open":
+      return "\u25CB";
+    case "done":
+      return "\u2713";
+    default:
+      return "\u25CB";
+  }
+}
+function getStatusDisplay(status) {
+  switch (status) {
+    case "in-progress":
+      return "active";
+    case "blocked":
+      return "blocked";
+    case "open":
+      return "open";
+    case "done":
+      return "done";
+    default:
+      return status;
+  }
+}
+
+export {
+  slugify,
+  getTasksDir,
+  getBacklogDir,
+  ensureTasksDir,
+  ensureBacklogDir,
+  getTaskPath,
+  getBacklogPath,
+  readTask,
+  readBacklogItem,
+  listTasks,
+  listBacklogItems,
+  createTask,
+  updateTask,
+  completeTask,
+  createBacklogItem,
+  promoteBacklogItem,
+  getBlockedTasks,
+  getActiveTasks,
+  getRecentlyCompletedTasks,
+  getStatusIcon,
+  getStatusDisplay
+};

package/dist/commands/archive.js

@@ -3,8 +3,8 @@ import {
   registerArchiveCommand
 } from "../chunk-VR5NE7PZ.js";
 import "../chunk-MQUJNOHK.js";
-import "../chunk-Z2XBWN7A.js";
 import "../chunk-MXSSG3QU.js";
+import "../chunk-Z2XBWN7A.js";
 export {
   archiveCommand,
   registerArchiveCommand

package/dist/commands/backlog.d.ts

@@ -0,0 +1,53 @@
+import { TaskPriority, BacklogItem, Task } from '../lib/task-utils.js';
+
+/**
+ * Backlog command for ClawVault
+ * Manages backlog add/list/promote operations
+ */
+
+interface BacklogAddOptions {
+    source?: string;
+    project?: string;
+    content?: string;
+    tags?: string[];
+}
+interface BacklogListOptions {
+    project?: string;
+    json?: boolean;
+}
+interface BacklogPromoteOptions {
+    owner?: string;
+    priority?: TaskPriority;
+    due?: string;
+}
+/**
+ * Add a new backlog item
+ */
+declare function backlogAdd(vaultPath: string, title: string, options?: BacklogAddOptions): BacklogItem;
+/**
+ * List backlog items with optional filters
+ */
+declare function backlogList(vaultPath: string, options?: BacklogListOptions): BacklogItem[];
+/**
+ * Promote a backlog item to a task
+ */
+declare function backlogPromote(vaultPath: string, slug: string, options?: BacklogPromoteOptions): Task;
+/**
+ * Format backlog list for terminal display
+ */
+declare function formatBacklogList(items: BacklogItem[]): string;
+/**
+ * Format backlog item details for display
+ */
+declare function formatBacklogDetails(item: BacklogItem): string;
+/**
+ * Backlog command handler for CLI
+ * Note: The CLI uses "clawvault backlog <title>" as shorthand for add
+ */
+declare function backlogCommand(vaultPath: string, action: 'add' | 'list' | 'promote', args: {
+    title?: string;
+    slug?: string;
+    options?: BacklogAddOptions & BacklogListOptions & BacklogPromoteOptions;
+}): Promise<void>;
+
+export { type BacklogAddOptions, type BacklogListOptions, type BacklogPromoteOptions, backlogAdd, backlogCommand, backlogList, backlogPromote, formatBacklogDetails, formatBacklogList };

package/dist/commands/backlog.js

@@ -0,0 +1,119 @@
+import {
+  createBacklogItem,
+  listBacklogItems,
+  promoteBacklogItem
+} from "../chunk-NGVAEFT2.js";
+
+// src/commands/backlog.ts
+function backlogAdd(vaultPath, title, options = {}) {
+  return createBacklogItem(vaultPath, title, {
+    source: options.source,
+    project: options.project,
+    content: options.content,
+    tags: options.tags
+  });
+}
+function backlogList(vaultPath, options = {}) {
+  const filters = {};
+  if (options.project) filters.project = options.project;
+  return listBacklogItems(vaultPath, filters);
+}
+function backlogPromote(vaultPath, slug, options = {}) {
+  return promoteBacklogItem(vaultPath, slug, {
+    owner: options.owner,
+    priority: options.priority,
+    due: options.due
+  });
+}
+function formatBacklogList(items) {
+  if (items.length === 0) {
+    return "No backlog items found.\n";
+  }
+  const headers = ["SOURCE", "PROJECT", "CREATED", "TITLE"];
+  const widths = [12, 16, 12, 40];
+  let output = headers.map((h, i) => h.padEnd(widths[i])).join("  ") + "\n";
+  for (const item of items) {
+    const source = item.frontmatter.source || "-";
+    const project = item.frontmatter.project || "-";
+    const created = item.frontmatter.created.split("T")[0];
+    const title = item.title.length > widths[3] ? item.title.slice(0, widths[3] - 3) + "..." : item.title;
+    const row = [
+      source.padEnd(widths[0]),
+      project.padEnd(widths[1]),
+      created.padEnd(widths[2]),
+      title
+    ];
+    output += row.join("  ") + "\n";
+  }
+  return output;
+}
+function formatBacklogDetails(item) {
+  let output = "";
+  output += `# ${item.title}
+`;
+  output += "-".repeat(40) + "\n";
+  if (item.frontmatter.source) {
+    output += `Source: ${item.frontmatter.source}
+`;
+  }
+  if (item.frontmatter.project) {
+    output += `Project: ${item.frontmatter.project}
+`;
+  }
+  if (item.frontmatter.tags && item.frontmatter.tags.length > 0) {
+    output += `Tags: ${item.frontmatter.tags.join(", ")}
+`;
+  }
+  output += `Created: ${item.frontmatter.created}
+`;
+  output += `File: ${item.path}
+`;
+  output += "-".repeat(40) + "\n";
+  const contentWithoutTitle = item.content.replace(/^#\s+.+\n/, "").trim();
+  if (contentWithoutTitle) {
+    output += "\n" + contentWithoutTitle + "\n";
+  }
+  return output;
+}
+async function backlogCommand(vaultPath, action, args) {
+  const options = args.options || {};
+  switch (action) {
+    case "add": {
+      if (!args.title) {
+        throw new Error("Title is required for backlog add");
+      }
+      const item = backlogAdd(vaultPath, args.title, options);
+      console.log(`\u2713 Added to backlog: ${item.slug}`);
+      console.log(`  Path: ${item.path}`);
+      break;
+    }
+    case "list": {
+      const items = backlogList(vaultPath, options);
+      if (options.json) {
+        console.log(JSON.stringify(items, null, 2));
+      } else {
+        console.log(formatBacklogList(items));
+      }
+      break;
+    }
+    case "promote": {
+      if (!args.slug) {
+        throw new Error("Backlog item slug is required for promote");
+      }
+      const task = backlogPromote(vaultPath, args.slug, options);
+      console.log(`\u2713 Promoted to task: ${task.slug}`);
+      console.log(`  Path: ${task.path}`);
+      break;
+    }
+    default:
+      throw new Error(`Unknown backlog action: ${action}`);
+  }
+}
+export {
+  backlogAdd,
+  backlogCommand,
+  backlogList,
+  backlogPromote,
+  formatBacklogDetails,
+  formatBacklogList
+};

package/dist/commands/blocked.d.ts

@@ -0,0 +1,25 @@
+import { Task } from '../lib/task-utils.js';
+
+/**
+ * Blocked command for ClawVault
+ * Quick view of blocked tasks
+ */
+
+interface BlockedOptions {
+    project?: string;
+    json?: boolean;
+}
+/**
+ * Get blocked tasks
+ */
+declare function blockedList(vaultPath: string, options?: BlockedOptions): Task[];
+/**
+ * Format blocked tasks for terminal display
+ */
+declare function formatBlockedList(tasks: Task[]): string;
+/**
+ * Blocked command handler for CLI
+ */
+declare function blockedCommand(vaultPath: string, options?: BlockedOptions): Promise<void>;
+
+export { type BlockedOptions, blockedCommand, blockedList, formatBlockedList };

package/dist/commands/blocked.js

@@ -0,0 +1,43 @@
+import {
+  getBlockedTasks
+} from "../chunk-NGVAEFT2.js";
+
+// src/commands/blocked.ts
+function blockedList(vaultPath, options = {}) {
+  return getBlockedTasks(vaultPath, options.project);
+}
+function formatBlockedList(tasks) {
+  if (tasks.length === 0) {
+    return "No blocked tasks.\n";
+  }
+  let output = `BLOCKED TASKS (${tasks.length})
+
+`;
+  for (const task of tasks) {
+    const owner = task.frontmatter.owner || "unassigned";
+    const project = task.frontmatter.project || "no project";
+    const blockedBy = task.frontmatter.blocked_by || "unknown";
+    const updatedDate = task.frontmatter.updated.split("T")[0];
+    output += `\u25A0 ${task.title} (${owner}, ${project})
+`;
+    output += `  Blocked by: ${blockedBy}
+`;
+    output += `  Since: ${updatedDate}
+`;
+    output += "\n";
+  }
+  return output;
+}
+async function blockedCommand(vaultPath, options = {}) {
+  const tasks = blockedList(vaultPath, options);
+  if (options.json) {
+    console.log(JSON.stringify(tasks, null, 2));
+  } else {
+    console.log(formatBlockedList(tasks));
+  }
+}
+export {
+  blockedCommand,
+  blockedList,
+  formatBlockedList
+};

package/dist/commands/canvas.d.ts

@@ -0,0 +1,20 @@
+import { Canvas } from '../lib/canvas-layout.js';
+
+/**
+ * Canvas command for ClawVault
+ * Generates an Obsidian JSON Canvas dashboard
+ */
+
+interface CanvasOptions {
+    output?: string;
+}
+/**
+ * Generate the canvas dashboard
+ */
+declare function generateCanvas(vaultPath: string): Canvas;
+/**
+ * Canvas command handler for CLI
+ */
+declare function canvasCommand(vaultPath: string, options?: CanvasOptions): Promise<void>;
+
+export { type CanvasOptions, canvasCommand, generateCanvas };