clawvault 3.1.0 → 3.2.0

package/dist/commands/link.cjs

@@ -1,965 +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/link.ts
-var link_exports = {};
-__export(link_exports, {
-  linkCommand: () => linkCommand
-});
-module.exports = __toCommonJS(link_exports);
-var fs5 = __toESM(require("fs"), 1);
-var path5 = __toESM(require("path"), 1);
-
-// src/lib/entity-index.ts
-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, path6] of index.entries) {
-    result.push({ alias, path: path6 });
-  }
-  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: path6 } of sortedAliases) {
-    if (linkedEntities.has(path6)) 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() === path6.split("/").pop()?.toLowerCase() ? `[[${path6}]]` : `[[${path6}|${originalText}]]`;
-      result = result.substring(0, adjustedPos) + replacement + result.substring(adjustedPos + originalText.length);
-      offset += replacement.length - originalText.length;
-      linkedEntities.add(path6);
-      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: path6 } of sortedAliases) {
-    if (linkedEntities.has(path6)) 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: path6,
-        line: getLineNumber(match.index)
-      });
-      linkedEntities.add(path6);
-      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: path6 } of sortedAliases) {
-    if (seen.has(path6)) 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: path6,
-        line: getLineNumber(match.index)
-      });
-      seen.add(path6);
-      break;
-    }
-  }
-  return matches;
-}
-
-// src/lib/backlinks.ts
-var fs2 = __toESM(require("fs"), 1);
-var path2 = __toESM(require("path"), 1);
-var CLAWVAULT_DIR = ".clawvault";
-var BACKLINKS_FILE = "backlinks.json";
-var WIKI_LINK_REGEX = /\[\[([^\]]+)\]\]/g;
-function ensureClawvaultDir(vaultPath) {
-  const dir = path2.join(vaultPath, CLAWVAULT_DIR);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
-  }
-  return dir;
-}
-function toVaultId(vaultPath, filePath) {
-  const relative3 = path2.relative(vaultPath, filePath).replace(/\.md$/, "");
-  return relative3.split(path2.sep).join("/");
-}
-function normalizeLinkTarget(raw) {
-  let target = raw.trim();
-  if (!target) return "";
-  if (target.startsWith("[[") && target.endsWith("]]")) {
-    target = target.slice(2, -2);
-  }
-  const pipeIndex = target.indexOf("|");
-  if (pipeIndex !== -1) {
-    target = target.slice(0, pipeIndex);
-  }
-  if (target.startsWith("#")) return "";
-  const hashIndex = target.indexOf("#");
-  if (hashIndex !== -1) {
-    target = target.slice(0, hashIndex);
-  }
-  target = target.trim();
-  if (!target) return "";
-  if (target.endsWith(".md")) {
-    target = target.slice(0, -3);
-  }
-  if (target.startsWith("/")) {
-    target = target.slice(1);
-  }
-  return target.replace(/\\/g, "/");
-}
-function listMarkdownFiles(vaultPath) {
-  const files = [];
-  const skipDirs = /* @__PURE__ */ new Set(["archive", "templates", "node_modules"]);
-  function walk(dir) {
-    const entries = fs2.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path2.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        if (entry.name.startsWith(".") || skipDirs.has(entry.name)) continue;
-        walk(fullPath);
-      } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        files.push(fullPath);
-      }
-    }
-  }
-  walk(vaultPath);
-  return files;
-}
-function buildKnownIds(vaultPath, files) {
-  const ids = /* @__PURE__ */ new Set();
-  const idsLower = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    const id = toVaultId(vaultPath, file);
-    ids.add(id);
-    const lower = id.toLowerCase();
-    if (!idsLower.has(lower)) {
-      idsLower.set(lower, id);
-    }
-  }
-  return { ids, idsLower };
-}
-function resolveTarget(target, known, entityIndex) {
-  if (!target) return null;
-  if (known.ids.has(target)) return target;
-  const lower = target.toLowerCase();
-  if (known.idsLower.has(lower)) return known.idsLower.get(lower);
-  if (entityIndex?.entries.has(lower)) return entityIndex.entries.get(lower);
-  return null;
-}
-function scanVaultLinks(vaultPath, options = {}) {
-  const files = listMarkdownFiles(vaultPath);
-  const known = buildKnownIds(vaultPath, files);
-  const entityIndex = options.entityIndex ?? buildEntityIndex(vaultPath);
-  const backlinks = /* @__PURE__ */ new Map();
-  const orphans = [];
-  let linkCount = 0;
-  for (const file of files) {
-    const sourceId = toVaultId(vaultPath, file);
-    const content = fs2.readFileSync(file, "utf-8");
-    const matches = content.match(WIKI_LINK_REGEX) || [];
-    linkCount += matches.length;
-    for (const match of matches) {
-      const target = normalizeLinkTarget(match);
-      if (!target) continue;
-      const resolved = resolveTarget(target, known, entityIndex);
-      if (!resolved) {
-        orphans.push({ source: sourceId, target });
-        continue;
-      }
-      if (!backlinks.has(resolved)) {
-        backlinks.set(resolved, /* @__PURE__ */ new Set());
-      }
-      backlinks.get(resolved).add(sourceId);
-    }
-  }
-  const backlinksMap = /* @__PURE__ */ new Map();
-  for (const [target, sources] of backlinks) {
-    backlinksMap.set(target, [...sources].sort());
-  }
-  return { backlinks: backlinksMap, orphans, linkCount };
-}
-function writeBacklinksIndex(vaultPath, backlinks) {
-  const dir = ensureClawvaultDir(vaultPath);
-  const output = {};
-  const targets = [...backlinks.keys()].sort();
-  for (const target of targets) {
-    const sources = backlinks.get(target) || [];
-    output[target] = [...new Set(sources)].sort();
-  }
-  fs2.writeFileSync(path2.join(dir, BACKLINKS_FILE), JSON.stringify(output, null, 2));
-}
-function readBacklinksIndex(vaultPath) {
-  const filePath = path2.join(vaultPath, CLAWVAULT_DIR, BACKLINKS_FILE);
-  if (!fs2.existsSync(filePath)) return null;
-  try {
-    const raw = JSON.parse(fs2.readFileSync(filePath, "utf-8"));
-    const map = /* @__PURE__ */ new Map();
-    for (const [target, sources] of Object.entries(raw)) {
-      if (Array.isArray(sources)) {
-        map.set(target, sources);
-      }
-    }
-    return map;
-  } catch {
-    return null;
-  }
-}
-function rebuildBacklinksIndex(vaultPath, options = {}) {
-  const result = scanVaultLinks(vaultPath, options);
-  writeBacklinksIndex(vaultPath, result.backlinks);
-  return result;
-}
-
-// src/lib/config.ts
-var fs3 = __toESM(require("fs"), 1);
-var path3 = __toESM(require("path"), 1);
-function findNearestVaultPath(startPath = process.cwd()) {
-  let current = path3.resolve(startPath);
-  while (true) {
-    if (fs3.existsSync(path3.join(current, ".clawvault.json"))) {
-      return current;
-    }
-    const parent = path3.dirname(current);
-    if (parent === current) {
-      return null;
-    }
-    current = parent;
-  }
-}
-function resolveVaultPath(options = {}) {
-  if (options.explicitPath) {
-    return path3.resolve(options.explicitPath);
-  }
-  if (process.env.CLAWVAULT_PATH) {
-    return path3.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/lib/memory-graph.ts
-var fs4 = __toESM(require("fs"), 1);
-var path4 = __toESM(require("path"), 1);
-var import_gray_matter2 = __toESM(require("gray-matter"), 1);
-var import_glob = require("glob");
-var MEMORY_GRAPH_SCHEMA_VERSION = 1;
-var GRAPH_INDEX_RELATIVE_PATH = path4.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(path4.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 basename2 = noteKey.split("/").pop() ?? noteKey;
-  return basename2.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 ensureClawvaultDir2(vaultPath) {
-  const dirPath = path4.join(vaultPath, ".clawvault");
-  if (!fs4.existsSync(dirPath)) {
-    fs4.mkdirSync(dirPath, { recursive: true });
-  }
-  return dirPath;
-}
-function getGraphIndexPath(vaultPath) {
-  return path4.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 = path4.join(vaultPath, relativePath);
-  const raw = fs4.readFileSync(absolutePath, "utf-8");
-  const parsed = (0, import_gray_matter2.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(path4.resolve(vaultPath));
-  if (!fs4.existsSync(indexPath)) {
-    return null;
-  }
-  try {
-    const parsed = JSON.parse(fs4.readFileSync(indexPath, "utf-8"));
-    if (!isValidIndex(parsed)) {
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-async function buildOrUpdateMemoryGraphIndex(vaultPathInput, options = {}) {
-  const vaultPath = path4.resolve(vaultPathInput);
-  ensureClawvaultDir2(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 = path4.join(vaultPath, relativePath);
-    const stat = fs4.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
-  };
-  fs4.writeFileSync(getGraphIndexPath(vaultPath), JSON.stringify(nextIndex, null, 2));
-  return nextIndex;
-}
-
-// src/commands/link.ts
-async function linkCommand(file, options) {
-  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
-  const index = buildEntityIndex(vaultPath);
-  const suggestionIndex = filterIndex(index, /* @__PURE__ */ new Set(["people", "projects", "decisions"]));
-  const modeCount = [options.backlinks ? 1 : 0, options.orphans ? 1 : 0, options.rebuild ? 1 : 0].reduce((sum, value) => sum + value, 0);
-  if (modeCount > 1) {
-    console.error("Error: Use only one of --backlinks, --orphans, or --rebuild");
-    process.exit(1);
-  }
-  if (options.rebuild) {
-    const result = rebuildBacklinksIndex(vaultPath, { entityIndex: index });
-    const orphanSuffix = result.orphans.length > 0 ? `, ${result.orphans.length} orphan(s)` : "";
-    console.log(`\u2713 Rebuilt backlinks (${result.backlinks.size} targets, ${result.linkCount} links${orphanSuffix})`);
-    return;
-  }
-  if (options.backlinks) {
-    if (file) {
-      console.error("Error: Use --backlinks without a file argument");
-      process.exit(1);
-    }
-    const target = resolveBacklinkTarget(options.backlinks, vaultPath, index);
-    if (!target) {
-      console.error("Error: Invalid target for --backlinks");
-      process.exit(1);
-    }
-    const backlinks = readBacklinksIndex(vaultPath) ?? rebuildBacklinksIndex(vaultPath, { entityIndex: index }).backlinks;
-    const sources = backlinks.get(target) || [];
-    if (sources.length === 0) {
-      console.log(`No backlinks found for ${target}`);
-      return;
-    }
-    console.log(`Backlinks \u2192 ${target}`);
-    for (const source of sources.sort()) {
-      console.log(`  - ${source}`);
-    }
-    return;
-  }
-  if (options.orphans) {
-    if (file || options.all) {
-      console.error("Error: --orphans does not accept a file or --all");
-      process.exit(1);
-    }
-    const result = scanVaultLinks(vaultPath, { entityIndex: index });
-    if (result.orphans.length === 0) {
-      console.log("\u2713 No orphan links found");
-      return;
-    }
-    const orphans = result.orphans.slice().sort((a, b) => a.target.localeCompare(b.target) || a.source.localeCompare(b.source));
-    console.log(`\u26A0 ${orphans.length} orphan link(s) found`);
-    for (const orphan of orphans) {
-      console.log(`  - ${orphan.source} \u2192 [[${orphan.target}]]`);
-    }
-    return;
-  }
-  if (options.all) {
-    await linkAllFiles(vaultPath, index, suggestionIndex, options.dryRun);
-    if (!options.dryRun) {
-      await buildOrUpdateMemoryGraphIndex(vaultPath);
-    }
-    return;
-  }
-  if (!file) {
-    console.error("Error: Specify a file or use --all");
-    process.exit(1);
-  }
-  const filePath = path5.isAbsolute(file) ? file : path5.join(process.cwd(), file);
-  if (!fs5.existsSync(filePath)) {
-    console.error(`Error: File not found: ${filePath}`);
-    process.exit(1);
-  }
-  const linked = await linkFile(filePath, index, suggestionIndex, options.dryRun);
-  if (!options.dryRun && linked > 0) {
-    await buildOrUpdateMemoryGraphIndex(vaultPath);
-  }
-}
-function filterIndex(index, categories) {
-  const entries = /* @__PURE__ */ new Map();
-  const byPath = /* @__PURE__ */ new Map();
-  for (const [alias, targetPath] of index.entries) {
-    const category = targetPath.split("/")[0];
-    if (categories.has(category)) {
-      entries.set(alias, targetPath);
-    }
-  }
-  for (const [targetPath, entry] of index.byPath) {
-    const category = targetPath.split("/")[0];
-    if (categories.has(category)) {
-      byPath.set(targetPath, entry);
-    }
-  }
-  return { entries, byPath };
-}
-function resolveBacklinkTarget(input, vaultPath, index) {
-  let target = input.trim();
-  if (!target) return null;
-  if (target.startsWith("[[") && target.endsWith("]]")) {
-    target = target.slice(2, -2);
-  }
-  const pipeIndex = target.indexOf("|");
-  if (pipeIndex !== -1) {
-    target = target.slice(0, pipeIndex);
-  }
-  const hashIndex = target.indexOf("#");
-  if (hashIndex !== -1) {
-    target = target.slice(0, hashIndex);
-  }
-  target = target.trim();
-  if (!target) return null;
-  if (target.endsWith(".md")) {
-    target = target.slice(0, -3);
-  }
-  if (target.startsWith("/")) {
-    target = target.slice(1);
-  }
-  const candidate = path5.isAbsolute(target) ? target : path5.join(vaultPath, target);
-  const withExtension = candidate.endsWith(".md") ? candidate : `${candidate}.md`;
-  if (fs5.existsSync(candidate) && candidate.endsWith(".md")) {
-    return toVaultId2(vaultPath, candidate);
-  }
-  if (fs5.existsSync(withExtension)) {
-    return toVaultId2(vaultPath, withExtension);
-  }
-  const aliasKey = target.toLowerCase();
-  if (index.entries.has(aliasKey)) {
-    return index.entries.get(aliasKey);
-  }
-  return target.replace(/\\/g, "/");
-}
-function toVaultId2(vaultPath, filePath) {
-  const relative3 = path5.relative(vaultPath, filePath).replace(/\.md$/, "");
-  return relative3.split(path5.sep).join("/");
-}
-function logSuggestions(filePath, suggestions) {
-  if (suggestions.length === 0) return;
-  console.log(`
-\u{1F4A1} Suggested links in ${path5.basename(filePath)}`);
-  for (const suggestion of suggestions) {
-    console.log(`  Line ${suggestion.line}: "${suggestion.alias}" \u2192 [[${suggestion.path}]]`);
-  }
-}
-async function linkFile(filePath, index, suggestionIndex, dryRun) {
-  const content = fs5.readFileSync(filePath, "utf-8");
-  const linkedContent = autoLink(content, index);
-  const suggestions = findUnlinkedMentions(linkedContent, suggestionIndex);
-  if (dryRun) {
-    const matches = dryRunLink(content, index);
-    if (matches.length > 0) {
-      console.log(`
-\u{1F4C4} ${filePath}`);
-      for (const m of matches) {
-        console.log(`  Line ${m.line}: "${m.alias}" \u2192 [[${m.path}]]`);
-      }
-    }
-    logSuggestions(filePath, suggestions);
-    return matches.length;
-  }
-  if (linkedContent !== content) {
-    fs5.writeFileSync(filePath, linkedContent);
-    const matches = dryRunLink(content, index);
-    console.log(`\u2713 Linked ${matches.length} entities in ${path5.basename(filePath)}`);
-    logSuggestions(filePath, suggestions);
-    return matches.length;
-  }
-  logSuggestions(filePath, suggestions);
-  return 0;
-}
-async function linkAllFiles(vaultPath, index, suggestionIndex, dryRun) {
-  const files = [];
-  function walk(dir) {
-    const entries = fs5.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path5.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        if (!entry.name.startsWith(".") && entry.name !== "archive" && entry.name !== "templates") {
-          walk(fullPath);
-        }
-      } else if (entry.name.endsWith(".md")) {
-        files.push(fullPath);
-      }
-    }
-  }
-  walk(vaultPath);
-  let totalLinks = 0;
-  let filesModified = 0;
-  for (const file of files) {
-    const links = await linkFile(file, index, suggestionIndex, dryRun);
-    if (links > 0) {
-      totalLinks += links;
-      filesModified++;
-    }
-  }
-  console.log(`
-${dryRun ? "(dry run) " : ""}${totalLinks} links in ${filesModified} files`);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  linkCommand
-});