clawvault 3.1.0 → 3.2.1

package/dist/commands/graph.cjs

@@ -1,501 +0,0 @@
-"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/commands/graph.ts
-var graph_exports = {};
-__export(graph_exports, {
-  graphCommand: () => graphCommand,
-  graphSummary: () => graphSummary
-});
-module.exports = __toCommonJS(graph_exports);
-
-// src/lib/memory-graph.ts
-var fs = __toESM(require("fs"), 1);
-var path = __toESM(require("path"), 1);
-var import_gray_matter = __toESM(require("gray-matter"), 1);
-var import_glob = require("glob");
-var MEMORY_GRAPH_SCHEMA_VERSION = 1;
-var GRAPH_INDEX_RELATIVE_PATH = path.join(".clawvault", "graph-index.json");
-var WIKI_LINK_RE = /\[\[([^\]]+)\]\]/g;
-var HASH_TAG_RE = /(^|\s)#([\w-]+)/g;
-var FRONTMATTER_RELATION_FIELDS = [
-  "related",
-  "depends_on",
-  "dependsOn",
-  "blocked_by",
-  "blocks",
-  "owner",
-  "project",
-  "people",
-  "links"
-];
-function normalizeRelativePath(value) {
-  return value.split(path.sep).join("/").replace(/^\.\//, "").replace(/^\/+/, "");
-}
-function toNoteKey(relativePath) {
-  const normalized = normalizeRelativePath(relativePath);
-  return normalized.toLowerCase().endsWith(".md") ? normalized.slice(0, -3) : normalized;
-}
-function toNoteNodeId(noteKey) {
-  return `note:${noteKey}`;
-}
-function toTagNodeId(tag) {
-  return `tag:${tag.toLowerCase()}`;
-}
-function normalizeUnresolvedKey(raw) {
-  const normalized = raw.trim().toLowerCase().replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "").replace(/\.md$/, "").replace(/[^a-z0-9/_-]+/g, "-").replace(/\/+/g, "/").replace(/-+/g, "-").replace(/^[-/]+|[-/]+$/g, "");
-  return normalized || "unknown";
-}
-function toUnresolvedNodeId(raw) {
-  return `unresolved:${normalizeUnresolvedKey(raw)}`;
-}
-function titleFromNoteKey(noteKey) {
-  const basename = noteKey.split("/").pop() ?? noteKey;
-  return basename.replace(/[-_]+/g, " ").replace(/\s+/g, " ").trim().replace(/\b\w/g, (char) => char.toUpperCase());
-}
-function inferNodeType(relativePath, frontmatter) {
-  const normalized = normalizeRelativePath(relativePath).toLowerCase();
-  const category = normalized.split("/")[0] ?? "note";
-  const explicitType = typeof frontmatter.type === "string" ? frontmatter.type.toLowerCase() : "";
-  if (category.includes("daily") || explicitType === "daily") return "daily";
-  if (category === "observations" || explicitType === "observation") return "observation";
-  if (category === "handoffs" || explicitType === "handoff") return "handoff";
-  if (category === "decisions" || explicitType === "decision") return "decision";
-  if (category === "lessons" || explicitType === "lesson") return "lesson";
-  if (category === "projects" || explicitType === "project") return "project";
-  if (category === "people" || explicitType === "person") return "person";
-  if (category === "commitments" || explicitType === "commitment") return "commitment";
-  return "note";
-}
-function ensureClawvaultDir(vaultPath) {
-  const dirPath = path.join(vaultPath, ".clawvault");
-  if (!fs.existsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true });
-  }
-  return dirPath;
-}
-function getGraphIndexPath(vaultPath) {
-  return path.join(vaultPath, GRAPH_INDEX_RELATIVE_PATH);
-}
-function normalizeWikiTarget(target) {
-  let value = target.trim();
-  if (!value) return "";
-  const pipeIndex = value.indexOf("|");
-  if (pipeIndex >= 0) {
-    value = value.slice(0, pipeIndex);
-  }
-  const hashIndex = value.indexOf("#");
-  if (hashIndex >= 0) {
-    value = value.slice(0, hashIndex);
-  }
-  value = value.trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
-  if (value.toLowerCase().endsWith(".md")) {
-    value = value.slice(0, -3);
-  }
-  return value.trim();
-}
-function collectTags(frontmatter, markdownContent) {
-  const tags = /* @__PURE__ */ new Set();
-  const fmTags = frontmatter.tags;
-  if (Array.isArray(fmTags)) {
-    for (const tag of fmTags) {
-      if (typeof tag === "string" && tag.trim()) tags.add(tag.trim().toLowerCase());
-    }
-  } else if (typeof fmTags === "string") {
-    for (const token of fmTags.split(",")) {
-      const normalized = token.trim().toLowerCase();
-      if (normalized) tags.add(normalized);
-    }
-  }
-  const markdownMatches = markdownContent.matchAll(HASH_TAG_RE);
-  for (const match of markdownMatches) {
-    const tag = match[2]?.trim().toLowerCase();
-    if (tag) tags.add(tag);
-  }
-  return [...tags].sort((a, b) => a.localeCompare(b));
-}
-function extractWikiTargets(markdownContent) {
-  const targets = /* @__PURE__ */ new Set();
-  for (const match of markdownContent.matchAll(WIKI_LINK_RE)) {
-    const candidate = match[1];
-    if (!candidate) continue;
-    const normalized = normalizeWikiTarget(candidate);
-    if (normalized) targets.add(normalized);
-  }
-  return [...targets];
-}
-function toStringArray(value) {
-  if (typeof value === "string") {
-    return value.split(",").map((entry) => entry.trim()).filter(Boolean);
-  }
-  if (Array.isArray(value)) {
-    return value.flatMap((entry) => typeof entry === "string" ? entry.split(",") : []).map((entry) => entry.trim()).filter(Boolean);
-  }
-  return [];
-}
-function extractFrontmatterRelations(frontmatter) {
-  const relations = [];
-  for (const field of FRONTMATTER_RELATION_FIELDS) {
-    const raw = frontmatter[field];
-    for (const value of toStringArray(raw)) {
-      const normalized = normalizeWikiTarget(value);
-      if (normalized) relations.push({ field, target: normalized });
-    }
-  }
-  return relations;
-}
-function buildNoteRegistry(relativePaths) {
-  const byLowerPath = /* @__PURE__ */ new Map();
-  const byLowerBasename = /* @__PURE__ */ new Map();
-  for (const relativePath of relativePaths) {
-    const noteKey = toNoteKey(relativePath);
-    const lowerKey = noteKey.toLowerCase();
-    if (!byLowerPath.has(lowerKey)) {
-      byLowerPath.set(lowerKey, noteKey);
-    }
-    const base = noteKey.split("/").pop() ?? noteKey;
-    const lowerBase = base.toLowerCase();
-    const existing = byLowerBasename.get(lowerBase) ?? [];
-    existing.push(noteKey);
-    byLowerBasename.set(lowerBase, existing);
-  }
-  return { byLowerPath, byLowerBasename };
-}
-function resolveTargetNodeId(rawTarget, registry) {
-  const normalized = normalizeWikiTarget(rawTarget);
-  if (!normalized) {
-    return toUnresolvedNodeId(rawTarget);
-  }
-  const lowerTarget = normalized.toLowerCase();
-  const direct = registry.byLowerPath.get(lowerTarget);
-  if (direct) {
-    return toNoteNodeId(direct);
-  }
-  if (!normalized.includes("/")) {
-    const basenameMatches = registry.byLowerBasename.get(lowerTarget) ?? [];
-    if (basenameMatches.length === 1) {
-      return toNoteNodeId(basenameMatches[0]);
-    }
-  }
-  return toUnresolvedNodeId(normalized);
-}
-function createEdgeId(type, source, target, label) {
-  const suffix = label ? `:${label}` : "";
-  return `${type}:${source}->${target}${suffix}`;
-}
-function buildFragmentNode(id, title, type, category, pathValue, tags, missing, modifiedAt) {
-  return {
-    id,
-    title,
-    type,
-    category,
-    path: pathValue,
-    tags,
-    missing,
-    degree: 0,
-    modifiedAt
-  };
-}
-function parseFileFragment(vaultPath, relativePath, mtimeMs, registry) {
-  const absolutePath = path.join(vaultPath, relativePath);
-  const raw = fs.readFileSync(absolutePath, "utf-8");
-  const parsed = (0, import_gray_matter.default)(raw);
-  const frontmatter = parsed.data ?? {};
-  const noteKey = toNoteKey(relativePath);
-  const noteNodeId = toNoteNodeId(noteKey);
-  const noteType = inferNodeType(relativePath, frontmatter);
-  const tags = collectTags(frontmatter, parsed.content);
-  const modifiedAt = new Date(mtimeMs).toISOString();
-  const nodes = /* @__PURE__ */ new Map();
-  const edges = /* @__PURE__ */ new Map();
-  nodes.set(
-    noteNodeId,
-    buildFragmentNode(
-      noteNodeId,
-      typeof frontmatter.title === "string" && frontmatter.title.trim() ? frontmatter.title.trim() : titleFromNoteKey(noteKey),
-      noteType,
-      noteType,
-      normalizeRelativePath(relativePath),
-      tags,
-      false,
-      modifiedAt
-    )
-  );
-  for (const tag of tags) {
-    const tagNodeId = toTagNodeId(tag);
-    if (!nodes.has(tagNodeId)) {
-      nodes.set(tagNodeId, buildFragmentNode(tagNodeId, `#${tag}`, "tag", "tag", null, [], false, null));
-    }
-    const edgeId = createEdgeId("tag", noteNodeId, tagNodeId);
-    edges.set(edgeId, {
-      id: edgeId,
-      source: noteNodeId,
-      target: tagNodeId,
-      type: "tag"
-    });
-  }
-  const wikiTargets = extractWikiTargets(parsed.content);
-  for (const target of wikiTargets) {
-    const targetNodeId = resolveTargetNodeId(target, registry);
-    if (targetNodeId.startsWith("unresolved:") && !nodes.has(targetNodeId)) {
-      nodes.set(
-        targetNodeId,
-        buildFragmentNode(targetNodeId, titleFromNoteKey(normalizeUnresolvedKey(target)), "unresolved", "unresolved", null, [], true, null)
-      );
-    }
-    const edgeId = createEdgeId("wiki_link", noteNodeId, targetNodeId);
-    edges.set(edgeId, {
-      id: edgeId,
-      source: noteNodeId,
-      target: targetNodeId,
-      type: "wiki_link"
-    });
-  }
-  for (const relation of extractFrontmatterRelations(frontmatter)) {
-    const targetNodeId = resolveTargetNodeId(relation.target, registry);
-    if (targetNodeId.startsWith("unresolved:") && !nodes.has(targetNodeId)) {
-      nodes.set(
-        targetNodeId,
-        buildFragmentNode(
-          targetNodeId,
-          titleFromNoteKey(normalizeUnresolvedKey(relation.target)),
-          "unresolved",
-          "unresolved",
-          null,
-          [],
-          true,
-          null
-        )
-      );
-    }
-    const edgeId = createEdgeId("frontmatter_relation", noteNodeId, targetNodeId, relation.field);
-    edges.set(edgeId, {
-      id: edgeId,
-      source: noteNodeId,
-      target: targetNodeId,
-      type: "frontmatter_relation",
-      label: relation.field
-    });
-  }
-  return {
-    relativePath: normalizeRelativePath(relativePath),
-    mtimeMs,
-    nodes: [...nodes.values()],
-    edges: [...edges.values()]
-  };
-}
-function combineFragments(fragments, generatedAt) {
-  const nodes = /* @__PURE__ */ new Map();
-  const edges = /* @__PURE__ */ new Map();
-  for (const fragment of Object.values(fragments)) {
-    for (const node of fragment.nodes) {
-      const existing = nodes.get(node.id);
-      if (!existing) {
-        nodes.set(node.id, { ...node, degree: 0 });
-      } else if (node.modifiedAt && (!existing.modifiedAt || node.modifiedAt > existing.modifiedAt)) {
-        nodes.set(node.id, { ...existing, ...node, degree: 0 });
-      }
-    }
-    for (const edge of fragment.edges) {
-      edges.set(edge.id, edge);
-    }
-  }
-  const degreeByNode = /* @__PURE__ */ new Map();
-  for (const edge of edges.values()) {
-    degreeByNode.set(edge.source, (degreeByNode.get(edge.source) ?? 0) + 1);
-    degreeByNode.set(edge.target, (degreeByNode.get(edge.target) ?? 0) + 1);
-  }
-  for (const node of nodes.values()) {
-    node.degree = degreeByNode.get(node.id) ?? 0;
-  }
-  const nodeTypeCounts = {};
-  for (const node of nodes.values()) {
-    nodeTypeCounts[node.type] = (nodeTypeCounts[node.type] ?? 0) + 1;
-  }
-  const edgeTypeCounts = {};
-  for (const edge of edges.values()) {
-    edgeTypeCounts[edge.type] = (edgeTypeCounts[edge.type] ?? 0) + 1;
-  }
-  const sortedNodes = [...nodes.values()].sort((a, b) => a.id.localeCompare(b.id));
-  const sortedEdges = [...edges.values()].sort((a, b) => a.id.localeCompare(b.id));
-  return {
-    schemaVersion: MEMORY_GRAPH_SCHEMA_VERSION,
-    nodes: sortedNodes,
-    edges: sortedEdges,
-    stats: {
-      generatedAt,
-      nodeCount: sortedNodes.length,
-      edgeCount: sortedEdges.length,
-      nodeTypeCounts,
-      edgeTypeCounts
-    }
-  };
-}
-function isValidIndex(index) {
-  if (!index || typeof index !== "object") return false;
-  const typed = index;
-  return typed.schemaVersion === MEMORY_GRAPH_SCHEMA_VERSION && typeof typed.vaultPath === "string" && typeof typed.generatedAt === "string" && Boolean(typed.files && typeof typed.files === "object") && Boolean(typed.graph && typeof typed.graph === "object");
-}
-function loadMemoryGraphIndex(vaultPath) {
-  const indexPath = getGraphIndexPath(path.resolve(vaultPath));
-  if (!fs.existsSync(indexPath)) {
-    return null;
-  }
-  try {
-    const parsed = JSON.parse(fs.readFileSync(indexPath, "utf-8"));
-    if (!isValidIndex(parsed)) {
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-async function buildOrUpdateMemoryGraphIndex(vaultPathInput, options = {}) {
-  const vaultPath = path.resolve(vaultPathInput);
-  ensureClawvaultDir(vaultPath);
-  const existing = options.forceFull ? null : loadMemoryGraphIndex(vaultPath);
-  const markdownFiles = await (0, import_glob.glob)("**/*.md", {
-    cwd: vaultPath,
-    ignore: ["**/node_modules/**", "**/.git/**", "**/.obsidian/**", "**/.trash/**", "**/ledger/archive/**"]
-  });
-  const normalizedFiles = markdownFiles.map(normalizeRelativePath).sort((a, b) => a.localeCompare(b));
-  const registry = buildNoteRegistry(normalizedFiles);
-  const nextFragments = {};
-  const existingFragments = existing?.files ?? {};
-  const currentFileSet = new Set(normalizedFiles);
-  for (const relativePath of normalizedFiles) {
-    const absolutePath = path.join(vaultPath, relativePath);
-    const stat = fs.statSync(absolutePath);
-    const existingFragment = existingFragments[relativePath];
-    if (!options.forceFull && existingFragment && existingFragment.mtimeMs === stat.mtimeMs) {
-      nextFragments[relativePath] = existingFragment;
-      continue;
-    }
-    nextFragments[relativePath] = parseFileFragment(vaultPath, relativePath, stat.mtimeMs, registry);
-  }
-  for (const [relativePath, fragment] of Object.entries(existingFragments)) {
-    if (!currentFileSet.has(relativePath)) {
-      continue;
-    }
-    if (!nextFragments[relativePath]) {
-      nextFragments[relativePath] = fragment;
-    }
-  }
-  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const graph = combineFragments(nextFragments, generatedAt);
-  const nextIndex = {
-    schemaVersion: MEMORY_GRAPH_SCHEMA_VERSION,
-    vaultPath,
-    generatedAt,
-    files: nextFragments,
-    graph
-  };
-  fs.writeFileSync(getGraphIndexPath(vaultPath), JSON.stringify(nextIndex, null, 2));
-  return nextIndex;
-}
-
-// src/lib/config.ts
-var fs2 = __toESM(require("fs"), 1);
-var path2 = __toESM(require("path"), 1);
-function findNearestVaultPath(startPath = process.cwd()) {
-  let current = path2.resolve(startPath);
-  while (true) {
-    if (fs2.existsSync(path2.join(current, ".clawvault.json"))) {
-      return current;
-    }
-    const parent = path2.dirname(current);
-    if (parent === current) {
-      return null;
-    }
-    current = parent;
-  }
-}
-function resolveVaultPath(options = {}) {
-  if (options.explicitPath) {
-    return path2.resolve(options.explicitPath);
-  }
-  if (process.env.CLAWVAULT_PATH) {
-    return path2.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.");
-}
-
-// src/commands/graph.ts
-function formatGraphSummary(summary) {
-  const lines = [];
-  lines.push("Memory Graph Summary");
-  lines.push("-".repeat(34));
-  lines.push(`Schema version: ${summary.schemaVersion}`);
-  lines.push(`Generated at: ${summary.generatedAt}`);
-  lines.push(`Files indexed: ${summary.fileCount}`);
-  lines.push(`Nodes: ${summary.nodeCount}`);
-  lines.push(`Edges: ${summary.edgeCount}`);
-  lines.push("");
-  lines.push("Node types:");
-  for (const [type, count] of Object.entries(summary.nodeTypeCounts).sort((a, b) => a[0].localeCompare(b[0]))) {
-    lines.push(`  - ${type}: ${count}`);
-  }
-  lines.push("");
-  lines.push("Edge types:");
-  for (const [type, count] of Object.entries(summary.edgeTypeCounts).sort((a, b) => a[0].localeCompare(b[0]))) {
-    lines.push(`  - ${type}: ${count}`);
-  }
-  return lines.join("\n");
-}
-async function graphSummary(options = {}) {
-  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
-  const index = options.refresh ? await buildOrUpdateMemoryGraphIndex(vaultPath) : loadMemoryGraphIndex(vaultPath) ?? await buildOrUpdateMemoryGraphIndex(vaultPath);
-  return {
-    schemaVersion: index.schemaVersion,
-    generatedAt: index.generatedAt,
-    nodeCount: index.graph.stats.nodeCount,
-    edgeCount: index.graph.stats.edgeCount,
-    nodeTypeCounts: index.graph.stats.nodeTypeCounts,
-    edgeTypeCounts: index.graph.stats.edgeTypeCounts,
-    fileCount: Object.keys(index.files).length
-  };
-}
-async function graphCommand(options = {}) {
-  const summary = await graphSummary(options);
-  if (options.json) {
-    console.log(JSON.stringify(summary, null, 2));
-    return;
-  }
-  console.log(formatGraphSummary(summary));
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  graphCommand,
-  graphSummary
-});

package/dist/commands/graph.d.cts

@@ -1,21 +0,0 @@
-interface GraphSummary {
-    schemaVersion: number;
-    generatedAt: string;
-    nodeCount: number;
-    edgeCount: number;
-    nodeTypeCounts: Record<string, number>;
-    edgeTypeCounts: Record<string, number>;
-    fileCount: number;
-}
-declare function graphSummary(options?: {
-    vaultPath?: string;
-    refresh?: boolean;
-    json?: boolean;
-}): Promise<GraphSummary>;
-declare function graphCommand(options?: {
-    vaultPath?: string;
-    refresh?: boolean;
-    json?: boolean;
-}): Promise<void>;
-
-export { type GraphSummary, graphCommand, graphSummary };