clawvault 2.2.1 → 2.3.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
+};

package/dist/{chunk-Z2XBWN7A.js → chunk-NAMFB7ZA.js}

@@ -232,6 +232,8 @@ function ensureParentDir(filePath) {
 export {
   toDateKey,
   parseDateKey,
+  getLedgerRoot,
+  getRawRoot,
   getReflectionsRoot,
   getObservationPath,
   getArchiveObservationPath,

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