clawvault 2.6.0 → 3.0.0

package/dist/inject-Bzi5E-By.d.ts

@@ -0,0 +1,137 @@
+import { Command } from 'commander';
+
+declare const MEMORY_GRAPH_SCHEMA_VERSION = 1;
+type NodeCategory = 'note' | 'daily' | 'observation' | 'handoff' | 'decision' | 'lesson' | 'project' | 'person' | 'commitment' | 'tag' | 'unresolved';
+type MemoryGraphNodeType = NodeCategory;
+type MemoryGraphEdgeType = 'wiki_link' | 'tag' | 'frontmatter_relation';
+interface MemoryGraphNode {
+    id: string;
+    title: string;
+    type: MemoryGraphNodeType;
+    category: string;
+    path: string | null;
+    tags: string[];
+    missing: boolean;
+    degree: number;
+    modifiedAt: string | null;
+}
+interface MemoryGraphEdge {
+    id: string;
+    source: string;
+    target: string;
+    type: MemoryGraphEdgeType;
+    label?: string;
+}
+interface MemoryGraphStats {
+    generatedAt: string;
+    nodeCount: number;
+    edgeCount: number;
+    nodeTypeCounts: Record<string, number>;
+    edgeTypeCounts: Record<string, number>;
+}
+interface MemoryGraph {
+    schemaVersion: number;
+    nodes: MemoryGraphNode[];
+    edges: MemoryGraphEdge[];
+    stats: MemoryGraphStats;
+}
+interface MemoryGraphFileFragment {
+    relativePath: string;
+    mtimeMs: number;
+    nodes: MemoryGraphNode[];
+    edges: MemoryGraphEdge[];
+}
+interface MemoryGraphIndex {
+    schemaVersion: number;
+    vaultPath: string;
+    generatedAt: string;
+    files: Record<string, MemoryGraphFileFragment>;
+    graph: MemoryGraph;
+}
+interface BuildGraphIndexOptions {
+    forceFull?: boolean;
+}
+declare function loadMemoryGraphIndex(vaultPath: string): MemoryGraphIndex | null;
+declare function buildOrUpdateMemoryGraphIndex(vaultPathInput: string, options?: BuildGraphIndexOptions): Promise<MemoryGraphIndex>;
+declare function getMemoryGraph(vaultPath: string, options?: {
+    refresh?: boolean;
+}): Promise<MemoryGraph>;
+
+type LlmProvider = 'anthropic' | 'openai' | 'gemini';
+interface LlmCompletionOptions {
+    prompt: string;
+    provider?: LlmProvider | null;
+    model?: string;
+    systemPrompt?: string;
+    temperature?: number;
+    maxTokens?: number;
+    fetchImpl?: typeof fetch;
+}
+declare function resolveLlmProvider(fetchImpl?: typeof fetch): Promise<LlmProvider | null>;
+declare function requestLlmCompletion(options: LlmCompletionOptions): Promise<string>;
+
+declare const INJECTABLE_CATEGORIES: readonly ["rules", "decisions", "preferences"];
+type InjectSourceCategory = (typeof INJECTABLE_CATEGORIES)[number];
+type InjectMatchSource = 'trigger' | 'keyword' | 'entity' | 'graph_1hop' | 'llm_intent';
+interface InjectableItem {
+    id: string;
+    category: InjectSourceCategory;
+    relativePath: string;
+    title: string;
+    content: string;
+    triggers: string[];
+    scope: string[];
+    priority: number;
+    searchKeywords: string[];
+    noteNodeId: string;
+}
+interface InjectMatchReason {
+    source: InjectMatchSource;
+    value: string;
+    weight: number;
+}
+interface InjectMatch {
+    item: InjectableItem;
+    score: number;
+    deterministicScore: number;
+    llmScore: number | null;
+    reasons: InjectMatchReason[];
+}
+interface InjectResult {
+    message: string;
+    generatedAt: string;
+    deterministicMs: number;
+    llmProvider: LlmProvider | null;
+    usedLlm: boolean;
+    matches: InjectMatch[];
+}
+interface InjectRuntimeOptions {
+    maxResults?: number;
+    useLlm?: boolean;
+    scope?: string | string[];
+    model?: string;
+    fetchImpl?: typeof fetch;
+}
+declare function indexInjectableItems(vaultPathInput: string): InjectableItem[];
+declare function deterministicInjectMatches(params: {
+    message: string;
+    items: InjectableItem[];
+    graph: MemoryGraph;
+    scope?: string | string[];
+}): InjectMatch[];
+declare function runPromptInjection(vaultPathInput: string, message: string, options?: InjectRuntimeOptions): Promise<InjectResult>;
+
+type InjectFormat = 'markdown' | 'json';
+interface InjectCommandOptions {
+    vaultPath: string;
+    maxResults?: number;
+    useLlm?: boolean;
+    scope?: string | string[];
+    format?: InjectFormat;
+    model?: string;
+}
+declare function buildInjectionResult(message: string, options: InjectCommandOptions): Promise<InjectResult>;
+declare function injectCommand(message: string, options: InjectCommandOptions): Promise<void>;
+declare function registerInjectCommand(program: Command): void;
+
+export { runPromptInjection as A, type InjectCommandOptions as I, type LlmCompletionOptions as L, MEMORY_GRAPH_SCHEMA_VERSION as M, type InjectFormat as a, type InjectMatch as b, type InjectMatchReason as c, type InjectMatchSource as d, type InjectResult as e, type InjectRuntimeOptions as f, type InjectSourceCategory as g, type InjectableItem as h, type LlmProvider as i, type MemoryGraph as j, type MemoryGraphEdge as k, type MemoryGraphEdgeType as l, type MemoryGraphIndex as m, type MemoryGraphNode as n, type MemoryGraphNodeType as o, type MemoryGraphStats as p, buildInjectionResult as q, buildOrUpdateMemoryGraphIndex as r, deterministicInjectMatches as s, getMemoryGraph as t, indexInjectableItems as u, injectCommand as v, loadMemoryGraphIndex as w, registerInjectCommand as x, requestLlmCompletion as y, resolveLlmProvider as z };

package/dist/lib/auto-linker.cjs

@@ -0,0 +1,176 @@
+"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/auto-linker.ts
+var auto_linker_exports = {};
+__export(auto_linker_exports, {
+  autoLink: () => autoLink,
+  dryRunLink: () => dryRunLink,
+  findUnlinkedMentions: () => findUnlinkedMentions
+});
+module.exports = __toCommonJS(auto_linker_exports);
+
+// src/lib/entity-index.ts
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+function getSortedAliases(index) {
+  const result = [];
+  for (const [alias, path] of index.entries) {
+    result.push({ alias, path });
+  }
+  result.sort((a, b) => b.alias.length - a.alias.length);
+  return result;
+}
+
+// src/lib/auto-linker.ts
+function findProtectedRanges(content) {
+  const ranges = [];
+  const fmMatch = content.match(/^---\n[\s\S]*?\n---/);
+  if (fmMatch) {
+    ranges.push({ start: 0, end: fmMatch[0].length });
+  }
+  const codeBlockRegex = /```[\s\S]*?```|~~~[\s\S]*?~~~/g;
+  let match;
+  while ((match = codeBlockRegex.exec(content)) !== null) {
+    ranges.push({ start: match.index, end: match.index + match[0].length });
+  }
+  const inlineCodeRegex = /`[^`]+`/g;
+  while ((match = inlineCodeRegex.exec(content)) !== null) {
+    ranges.push({ start: match.index, end: match.index + match[0].length });
+  }
+  const wikiLinkRegex = /\[\[[^\]]+\]\]/g;
+  while ((match = wikiLinkRegex.exec(content)) !== null) {
+    ranges.push({ start: match.index, end: match.index + match[0].length });
+  }
+  const urlRegex = /https?:\/\/[^\s)>\]]+/g;
+  while ((match = urlRegex.exec(content)) !== null) {
+    ranges.push({ start: match.index, end: match.index + match[0].length });
+  }
+  return ranges;
+}
+function isProtected(pos, ranges) {
+  return ranges.some((r) => pos >= r.start && pos < r.end);
+}
+function createLineLookup(content) {
+  const lines = content.split("\n");
+  let charPos = 0;
+  const lineStarts = [];
+  for (const line of lines) {
+    lineStarts.push(charPos);
+    charPos += line.length + 1;
+  }
+  return (pos) => {
+    for (let i = lineStarts.length - 1; i >= 0; i--) {
+      if (pos >= lineStarts[i]) return i + 1;
+    }
+    return 1;
+  };
+}
+function autoLink(content, index) {
+  const protectedRanges = findProtectedRanges(content);
+  const sortedAliases = getSortedAliases(index);
+  const linkedEntities = /* @__PURE__ */ new Set();
+  let result = content;
+  let offset = 0;
+  for (const { alias, path } of sortedAliases) {
+    if (linkedEntities.has(path)) continue;
+    const escapedAlias = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(`\\b${escapedAlias}\\b`, "gi");
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      const originalPos = match.index;
+      const adjustedPos = originalPos + offset;
+      if (isProtected(originalPos, protectedRanges)) continue;
+      const beforeMatch = result.substring(0, adjustedPos);
+      const openBrackets = (beforeMatch.match(/\[\[/g) || []).length;
+      const closeBrackets = (beforeMatch.match(/\]\]/g) || []).length;
+      if (openBrackets > closeBrackets) continue;
+      const originalText = match[0];
+      const replacement = originalText.toLowerCase() === path.split("/").pop()?.toLowerCase() ? `[[${path}]]` : `[[${path}|${originalText}]]`;
+      result = result.substring(0, adjustedPos) + replacement + result.substring(adjustedPos + originalText.length);
+      offset += replacement.length - originalText.length;
+      linkedEntities.add(path);
+      break;
+    }
+  }
+  return result;
+}
+function dryRunLink(content, index) {
+  const protectedRanges = findProtectedRanges(content);
+  const sortedAliases = getSortedAliases(index);
+  const linkedEntities = /* @__PURE__ */ new Set();
+  const matches = [];
+  const getLineNumber = createLineLookup(content);
+  for (const { alias, path } of sortedAliases) {
+    if (linkedEntities.has(path)) continue;
+    const escapedAlias = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(`\\b${escapedAlias}\\b`, "gi");
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      if (isProtected(match.index, protectedRanges)) continue;
+      matches.push({
+        alias: match[0],
+        path,
+        line: getLineNumber(match.index)
+      });
+      linkedEntities.add(path);
+      break;
+    }
+  }
+  return matches;
+}
+function findUnlinkedMentions(content, index) {
+  const protectedRanges = findProtectedRanges(content);
+  const sortedAliases = getSortedAliases(index);
+  const matches = [];
+  const seen = /* @__PURE__ */ new Set();
+  const getLineNumber = createLineLookup(content);
+  for (const { alias, path } of sortedAliases) {
+    if (seen.has(path)) continue;
+    const escapedAlias = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(`\\b${escapedAlias}\\b`, "gi");
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      if (isProtected(match.index, protectedRanges)) continue;
+      matches.push({
+        alias: match[0],
+        path,
+        line: getLineNumber(match.index)
+      });
+      seen.add(path);
+      break;
+    }
+  }
+  return matches;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  autoLink,
+  dryRunLink,
+  findUnlinkedMentions
+});

package/dist/lib/auto-linker.d.cts

@@ -0,0 +1,26 @@
+import { EntityIndex } from './entity-index.cjs';
+
+/**
+ * Auto-link entities in markdown content.
+ * Only links first occurrence of each entity.
+ * Skips protected ranges (frontmatter, code, existing links, URLs).
+ */
+declare function autoLink(content: string, index: EntityIndex): string;
+/**
+ * Show what would be linked (dry run)
+ */
+declare function dryRunLink(content: string, index: EntityIndex): Array<{
+    alias: string;
+    path: string;
+    line: number;
+}>;
+/**
+ * Find unlinked mentions of entities (suggested links).
+ */
+declare function findUnlinkedMentions(content: string, index: EntityIndex): Array<{
+    alias: string;
+    path: string;
+    line: number;
+}>;
+
+export { autoLink, dryRunLink, findUnlinkedMentions };

package/dist/lib/auto-linker.js

@@ -4,6 +4,7 @@ import {
   findUnlinkedMentions
 } from "../chunk-42MXU7A6.js";
 import "../chunk-J7ZWCI2C.js";
+import "../chunk-3RG5ZIWI.js";
 export {
   autoLink,
   dryRunLink,

package/dist/lib/canvas-layout.cjs

@@ -0,0 +1,136 @@
+"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/canvas-layout.ts
+var canvas_layout_exports = {};
+__export(canvas_layout_exports, {
+  CANVAS_COLORS: () => CANVAS_COLORS,
+  LAYOUT: () => LAYOUT,
+  createEdge: () => createEdge,
+  createFileNode: () => createFileNode,
+  createGroupNode: () => createGroupNode,
+  createGroupWithNodes: () => createGroupWithNodes,
+  createTextNode: () => createTextNode,
+  formatCanvasText: () => formatCanvasText,
+  generateId: () => generateId,
+  getPriorityColor: () => getPriorityColor,
+  stackNodesVertically: () => stackNodesVertically,
+  truncateText: () => truncateText
+});
+module.exports = __toCommonJS(canvas_layout_exports);
+var crypto = __toESM(require("crypto"), 1);
+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");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CANVAS_COLORS,
+  LAYOUT,
+  createEdge,
+  createFileNode,
+  createGroupNode,
+  createGroupWithNodes,
+  createTextNode,
+  formatCanvasText,
+  generateId,
+  getPriorityColor,
+  stackNodesVertically,
+  truncateText
+});

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

@@ -0,0 +1,31 @@
+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 GROUP_PADDING: 20;
+    readonly NODE_SPACING: 10;
+    readonly HEADER_HEIGHT: 40;
+};
+declare function generateId(): string;
+declare function createTextNode(x: number, y: number, width: number, height: number, text: string, color?: string): any;
+declare function createFileNode(x: number, y: number, width: number, height: number, file: string, color?: string): any;
+declare function createGroupNode(x: number, y: number, width: number, height: number, label: string, color?: string): any;
+declare function createEdge(fromNode: string, fromSide: string, toNode: string, toSide: string, label?: string, color?: string): any;
+declare function stackNodesVertically(nodes: any[], startX: number, startY: number, spacing: number): {
+    nodes: any[];
+    totalHeight: number;
+};
+declare function createGroupWithNodes(x: number, y: number, width: number, label: string, childNodes: any[], color?: string): {
+    group: any;
+    nodes: any[];
+};
+declare function getPriorityColor(priority: string | undefined): string | undefined;
+declare function truncateText(text: string, maxLength: number): string;
+declare function formatCanvasText(lines: string[]): string;
+
+export { CANVAS_COLORS, LAYOUT, createEdge, createFileNode, createGroupNode, createGroupWithNodes, createTextNode, formatCanvasText, generateId, getPriorityColor, stackNodesVertically, truncateText };

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

@@ -1,32 +1,3 @@
-/**
- * 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";
@@ -36,80 +7,25 @@ declare const CANVAS_COLORS: {
     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;
+    readonly NODE_SPACING: 10;
+    readonly 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[];
+declare function createTextNode(x: number, y: number, width: number, height: number, text: string, color?: string): any;
+declare function createFileNode(x: number, y: number, width: number, height: number, file: string, color?: string): any;
+declare function createGroupNode(x: number, y: number, width: number, height: number, label: string, color?: string): any;
+declare function createEdge(fromNode: string, fromSide: string, toNode: string, toSide: string, label?: string, color?: string): any;
+declare function stackNodesVertically(nodes: any[], startX: number, startY: number, spacing: number): {
+    nodes: any[];
     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 createGroupWithNodes(x: number, y: number, width: number, label: string, childNodes: any[], color?: string): {
+    group: any;
+    nodes: any[];
+};
+declare function getPriorityColor(priority: string | undefined): string | undefined;
+declare function truncateText(text: string, maxLength: number): string;
 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 };
+export { CANVAS_COLORS, LAYOUT, createEdge, createFileNode, createGroupNode, createGroupWithNodes, createTextNode, formatCanvasText, generateId, getPriorityColor, stackNodesVertically, truncateText };