clawvault 2.6.0 → 3.0.0

package/dist/lib/canvas-layout.js

@@ -1,34 +1,92 @@
-import {
-  CANVAS_COLORS,
-  LAYOUT,
-  calculateColumnHeight,
-  createEdge,
-  createFileNode,
-  createGroupNode,
-  createGroupWithNodes,
-  createTextNode,
-  flattenGroups,
-  formatCanvasText,
-  generateId,
-  getPriorityColor,
-  positionGroupsVertically,
-  stackNodesVertically,
-  truncateText
-} from "../chunk-MDIH26GC.js";
+import "../chunk-3RG5ZIWI.js";
+
+// src/lib/canvas-layout.ts
+import * as crypto from "crypto";
+var CANVAS_COLORS = {
+  RED: "1",
+  ORANGE: "2",
+  YELLOW: "3",
+  GREEN: "4",
+  CYAN: "5",
+  PURPLE: "6"
+};
+var LAYOUT = {
+  GROUP_PADDING: 20,
+  NODE_SPACING: 10,
+  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 !== void 0) 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 !== void 0) 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 !== void 0) node.color = color;
+  return node;
+}
+function createEdge(fromNode, fromSide, toNode, toSide, label, color) {
+  const edge = { id: generateId(), fromNode, fromSide, toNode, toSide };
+  if (label !== void 0) edge.label = label;
+  if (color !== void 0) edge.color = color;
+  return edge;
+}
+function stackNodesVertically(nodes, startX, startY, spacing) {
+  let currentY = startY;
+  const positioned = nodes.map((node) => {
+    const n = { ...node, x: startX, y: currentY };
+    currentY += node.height + spacing;
+    return n;
+  });
+  return { nodes: positioned, totalHeight: currentY - startY - spacing };
+}
+function createGroupWithNodes(x, y, width, label, childNodes, color) {
+  const padding = LAYOUT.GROUP_PADDING;
+  const headerHeight = LAYOUT.HEADER_HEIGHT;
+  const spacing = LAYOUT.NODE_SPACING;
+  const { nodes, totalHeight } = stackNodesVertically(childNodes, x + padding, y + headerHeight, spacing);
+  const groupHeight = headerHeight + totalHeight + padding;
+  const group = createGroupNode(x, y, width, Math.max(groupHeight, 100), label, color);
+  return { group, 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, maxLength) {
+  if (text.length <= maxLength) return text;
+  return text.slice(0, maxLength - 3) + "...";
+}
+function formatCanvasText(lines) {
+  return lines.join("\n");
+}
 export {
   CANVAS_COLORS,
   LAYOUT,
-  calculateColumnHeight,
   createEdge,
   createFileNode,
   createGroupNode,
   createGroupWithNodes,
   createTextNode,
-  flattenGroups,
   formatCanvasText,
   generateId,
   getPriorityColor,
-  positionGroupsVertically,
   stackNodesVertically,
   truncateText
 };

package/dist/lib/config.cjs

@@ -0,0 +1,78 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/config.ts
+var config_exports = {};
+__export(config_exports, {
+  findNearestVaultPath: () => findNearestVaultPath,
+  getVaultPath: () => getVaultPath,
+  resolveVaultPath: () => resolveVaultPath
+});
+module.exports = __toCommonJS(config_exports);
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+function getVaultPath() {
+  const vaultPath = process.env.CLAWVAULT_PATH;
+  if (!vaultPath) {
+    throw new Error("CLAWVAULT_PATH environment variable not set");
+  }
+  return path.resolve(vaultPath);
+}
+function findNearestVaultPath(startPath = process.cwd()) {
+  let current = path.resolve(startPath);
+  while (true) {
+    if (fs.existsSync(path.join(current, ".clawvault.json"))) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function resolveVaultPath(options = {}) {
+  if (options.explicitPath) {
+    return path.resolve(options.explicitPath);
+  }
+  if (process.env.CLAWVAULT_PATH) {
+    return path.resolve(process.env.CLAWVAULT_PATH);
+  }
+  const discovered = findNearestVaultPath(options.cwd ?? process.cwd());
+  if (discovered) {
+    return discovered;
+  }
+  throw new Error("No vault path found. Set CLAWVAULT_PATH, use --vault, or run inside a vault.");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findNearestVaultPath,
+  getVaultPath,
+  resolveVaultPath
+});

package/dist/lib/config.d.cts

@@ -0,0 +1,11 @@
+/**
+ * Get the vault path from CLAWVAULT_PATH env var or throw
+ */
+declare function getVaultPath(): string;
+declare function findNearestVaultPath(startPath?: string): string | null;
+declare function resolveVaultPath(options?: {
+    explicitPath?: string;
+    cwd?: string;
+}): string;
+
+export { findNearestVaultPath, getVaultPath, resolveVaultPath };

package/dist/lib/config.js

@@ -3,6 +3,7 @@ import {
   getVaultPath,
   resolveVaultPath
 } from "../chunk-MXSSG3QU.js";
+import "../chunk-3RG5ZIWI.js";
 export {
   findNearestVaultPath,
   getVaultPath,

package/dist/lib/entity-index.cjs

@@ -0,0 +1,84 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/entity-index.ts
+var entity_index_exports = {};
+__export(entity_index_exports, {
+  buildEntityIndex: () => buildEntityIndex,
+  getSortedAliases: () => getSortedAliases
+});
+module.exports = __toCommonJS(entity_index_exports);
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+function buildEntityIndex(vaultPath) {
+  const entries = /* @__PURE__ */ new Map();
+  const byPath = /* @__PURE__ */ new Map();
+  const entityFolders = ["people", "projects", "agents", "lessons", "decisions", "commitments"];
+  for (const folder of entityFolders) {
+    const folderPath = path.join(vaultPath, folder);
+    if (!fs.existsSync(folderPath)) continue;
+    const files = fs.readdirSync(folderPath).filter((f) => f.endsWith(".md"));
+    for (const file of files) {
+      const filePath = path.join(folderPath, file);
+      const content = fs.readFileSync(filePath, "utf-8");
+      const { data: frontmatter } = (0, import_gray_matter.default)(content);
+      const relativePath = `${folder}/${file.replace(".md", "")}`;
+      const baseName = file.replace(".md", "");
+      const aliases = [baseName];
+      if (frontmatter.title && frontmatter.title.toLowerCase() !== baseName.toLowerCase()) {
+        aliases.push(frontmatter.title);
+      }
+      if (Array.isArray(frontmatter.aliases)) {
+        aliases.push(...frontmatter.aliases);
+      }
+      for (const alias of aliases) {
+        const key = alias.toLowerCase();
+        if (!entries.has(key)) {
+          entries.set(key, relativePath);
+        }
+      }
+      byPath.set(relativePath, { path: relativePath, aliases });
+    }
+  }
+  return { entries, byPath };
+}
+function getSortedAliases(index) {
+  const result = [];
+  for (const [alias, path2] of index.entries) {
+    result.push({ alias, path: path2 });
+  }
+  result.sort((a, b) => b.alias.length - a.alias.length);
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildEntityIndex,
+  getSortedAliases
+});

package/dist/lib/entity-index.d.cts

@@ -0,0 +1,26 @@
+interface EntityEntry {
+    path: string;
+    aliases: string[];
+}
+interface EntityIndex {
+    entries: Map<string, string>;
+    byPath: Map<string, EntityEntry>;
+}
+/**
+ * Build an entity index from all markdown files in the vault.
+ * Extracts linkable names from:
+ * - Filename (without .md)
+ * - Frontmatter `title` field
+ * - Frontmatter `aliases` array
+ */
+declare function buildEntityIndex(vaultPath: string): EntityIndex;
+/**
+ * Get all entities sorted by alias length (longest first)
+ * This ensures "Justin Dukes" is matched before "Justin"
+ */
+declare function getSortedAliases(index: EntityIndex): Array<{
+    alias: string;
+    path: string;
+}>;
+
+export { type EntityEntry, type EntityIndex, buildEntityIndex, getSortedAliases };

package/dist/lib/entity-index.js

@@ -2,6 +2,7 @@ import {
   buildEntityIndex,
   getSortedAliases
 } from "../chunk-J7ZWCI2C.js";
+import "../chunk-3RG5ZIWI.js";
 export {
   buildEntityIndex,
   getSortedAliases