clawvault 2.1.1 → 2.2.0

package/dist/chunk-P5EPF6MB.js

@@ -0,0 +1,182 @@
+// src/observer/session-parser.ts
+import * as fs from "fs";
+import * as path from "path";
+var JSONL_SAMPLE_LIMIT = 20;
+var MARKDOWN_SIGNAL_RE = /^(#{1,6}\s|[-*+]\s|>\s)/;
+var MARKDOWN_INLINE_RE = /(\[[^\]]+\]\([^)]+\)|[*_`~])/;
+function normalizeText(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function extractText(value) {
+  if (typeof value === "string") {
+    return normalizeText(value);
+  }
+  if (Array.isArray(value)) {
+    const parts = [];
+    for (const part of value) {
+      const extracted = extractText(part);
+      if (extracted) {
+        parts.push(extracted);
+      }
+    }
+    return normalizeText(parts.join(" "));
+  }
+  if (!value || typeof value !== "object") {
+    return "";
+  }
+  const record = value;
+  if (typeof record.text === "string") {
+    return normalizeText(record.text);
+  }
+  if (typeof record.content === "string") {
+    return normalizeText(record.content);
+  }
+  return "";
+}
+function normalizeRole(role) {
+  if (typeof role !== "string") {
+    return "";
+  }
+  const normalized = role.trim().toLowerCase();
+  if (!normalized) {
+    return "";
+  }
+  return normalized;
+}
+function isLikelyJsonMessage(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const record = value;
+  if ("role" in record && "content" in record) {
+    return true;
+  }
+  if (record.type === "message" && record.message && typeof record.message === "object") {
+    return true;
+  }
+  return false;
+}
+function parseJsonLine(line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return "";
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return "";
+  }
+  const entry = parsed;
+  if ("role" in entry && "content" in entry) {
+    const role = normalizeRole(entry.role);
+    const content = extractText(entry.content);
+    if (!content) return "";
+    return role ? `${role}: ${content}` : content;
+  }
+  if (entry.type === "message" && entry.message && typeof entry.message === "object") {
+    const message = entry.message;
+    const role = normalizeRole(message.role);
+    const content = extractText(message.content);
+    if (!content) return "";
+    return role ? `${role}: ${content}` : content;
+  }
+  return "";
+}
+function parseJsonLines(raw) {
+  const messages = [];
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const parsed = parseJsonLine(trimmed);
+    if (parsed) {
+      messages.push(parsed);
+    }
+  }
+  return messages;
+}
+function stripMarkdownSyntax(text) {
+  return normalizeText(
+    text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/[*_`~]/g, "").replace(/<[^>]+>/g, "")
+  );
+}
+function normalizeMarkdownLine(line) {
+  return stripMarkdownSyntax(
+    line.replace(/^>\s*/, "").replace(/^[-*+]\s+/, "").replace(/^#{1,6}\s+/, "")
+  );
+}
+function parseMarkdown(raw) {
+  const withoutCodeBlocks = raw.replace(/```[\s\S]*?```/g, " ");
+  const blocks = withoutCodeBlocks.split(/\r?\n\s*\r?\n/).map((block) => block.trim()).filter(Boolean);
+  const messages = [];
+  for (const block of blocks) {
+    const lines = block.split(/\r?\n/).map((line) => normalizeMarkdownLine(line)).filter(Boolean);
+    if (lines.length === 0) {
+      continue;
+    }
+    const joined = stripMarkdownSyntax(lines.join(" "));
+    if (!joined) continue;
+    const roleMatch = /^(user|assistant|system|tool)\s*:?\s*(.+)$/i.exec(joined);
+    if (roleMatch) {
+      const role = normalizeRole(roleMatch[1]);
+      const content = normalizeText(roleMatch[2]);
+      if (content) {
+        messages.push(`${role}: ${content}`);
+      }
+      continue;
+    }
+    messages.push(joined);
+  }
+  return messages;
+}
+function parsePlainText(raw) {
+  return raw.split(/\r?\n/).map((line) => normalizeText(line)).filter(Boolean);
+}
+function detectSessionFormat(raw, filePath) {
+  const nonEmptyLines = raw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (nonEmptyLines.length === 0) {
+    return "plain";
+  }
+  const sample = nonEmptyLines.slice(0, JSONL_SAMPLE_LIMIT);
+  const jsonHits = sample.filter((line) => {
+    try {
+      const parsed = JSON.parse(line);
+      return isLikelyJsonMessage(parsed);
+    } catch {
+      return false;
+    }
+  }).length;
+  if (jsonHits >= Math.max(1, Math.ceil(sample.length * 0.6))) {
+    return "jsonl";
+  }
+  const ext = path.extname(filePath).toLowerCase();
+  if (ext === ".md" || ext === ".markdown") {
+    return "markdown";
+  }
+  const markdownSignals = sample.filter((line) => MARKDOWN_SIGNAL_RE.test(line) || MARKDOWN_INLINE_RE.test(line)).length;
+  if (markdownSignals >= Math.max(2, Math.ceil(sample.length * 0.4))) {
+    return "markdown";
+  }
+  return "plain";
+}
+function parseSessionFile(filePath) {
+  const resolved = path.resolve(filePath);
+  const raw = fs.readFileSync(resolved, "utf-8");
+  const format = detectSessionFormat(raw, resolved);
+  if (format === "jsonl") {
+    const parsed = parseJsonLines(raw);
+    if (parsed.length > 0) {
+      return parsed;
+    }
+  }
+  if (format === "markdown") {
+    const parsed = parseMarkdown(raw);
+    if (parsed.length > 0) {
+      return parsed;
+    }
+  }
+  return parsePlainText(raw);
+}
+
+export {
+  parseSessionFile
+};

package/dist/chunk-VR5NE7PZ.js

@@ -0,0 +1,45 @@
+import {
+  archiveObservations
+} from "./chunk-MQUJNOHK.js";
+import {
+  resolveVaultPath
+} from "./chunk-MXSSG3QU.js";
+
+// src/commands/archive.ts
+function parsePositiveInteger(raw, label) {
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`Invalid ${label}: ${raw}`);
+  }
+  return parsed;
+}
+async function archiveCommand(options) {
+  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
+  const result = archiveObservations(vaultPath, {
+    olderThanDays: options.olderThan,
+    dryRun: options.dryRun
+  });
+  if (result.archived === 0) {
+    console.log("No observations matched archive criteria.");
+    return;
+  }
+  if (result.dryRun) {
+    console.log(`Dry run: ${result.archived} observation file(s) would be archived.`);
+    return;
+  }
+  console.log(`Archived ${result.archived} observation file(s).`);
+}
+function registerArchiveCommand(program) {
+  program.command("archive").description("Archive old observations into ledger/archive").option("--older-than <days>", "Archive observations older than this many days", "14").option("--dry-run", "Show archive candidates without moving files").option("-v, --vault <path>", "Vault path").action(async (rawOptions) => {
+    await archiveCommand({
+      vaultPath: rawOptions.vault,
+      olderThan: parsePositiveInteger(rawOptions.olderThan, "older-than"),
+      dryRun: rawOptions.dryRun
+    });
+  });
+}
+
+export {
+  archiveCommand,
+  registerArchiveCommand
+};

package/dist/chunk-WZI3OAE5.js

@@ -0,0 +1,111 @@
+import {
+  DATE_HEADING_RE,
+  parseObservationLine,
+  renderScoredObservationLine
+} from "./chunk-K6XHCUFL.js";
+import {
+  listObservationFiles
+} from "./chunk-Z2XBWN7A.js";
+import {
+  resolveVaultPath
+} from "./chunk-MXSSG3QU.js";
+
+// src/commands/migrate-observations.ts
+import * as fs from "fs";
+function toBackupPath(filePath) {
+  if (filePath.toLowerCase().endsWith(".md")) {
+    return `${filePath.slice(0, -3)}.emoji-backup.md`;
+  }
+  return `${filePath}.emoji-backup`;
+}
+function convertObservationMarkdown(markdown) {
+  const lines = markdown.split(/\r?\n/);
+  let currentDate = "";
+  let changed = false;
+  const nextLines = lines.map((line) => {
+    const heading = line.match(DATE_HEADING_RE);
+    if (heading) {
+      currentDate = heading[1];
+      return line;
+    }
+    if (!currentDate) {
+      return line;
+    }
+    const parsed = parseObservationLine(line.trim(), currentDate);
+    if (!parsed || parsed.format !== "emoji") {
+      return line;
+    }
+    changed = true;
+    return renderScoredObservationLine({
+      type: parsed.type,
+      confidence: parsed.confidence,
+      importance: parsed.importance,
+      content: parsed.content
+    });
+  });
+  return {
+    converted: nextLines.join("\n"),
+    changed
+  };
+}
+function migrateObservations(vaultPath, options = {}) {
+  const dryRun = options.dryRun ?? false;
+  const files = listObservationFiles(vaultPath, {
+    includeLegacy: true,
+    includeArchive: false,
+    dedupeByDate: false
+  });
+  let migrated = 0;
+  let backups = 0;
+  for (const entry of files) {
+    const raw = fs.readFileSync(entry.path, "utf-8");
+    const { converted, changed } = convertObservationMarkdown(raw);
+    if (!changed) {
+      continue;
+    }
+    migrated += 1;
+    if (dryRun) {
+      continue;
+    }
+    const backupPath = toBackupPath(entry.path);
+    if (!fs.existsSync(backupPath)) {
+      fs.copyFileSync(entry.path, backupPath);
+      backups += 1;
+    }
+    fs.writeFileSync(entry.path, `${converted.trim()}
+`, "utf-8");
+  }
+  return {
+    scanned: files.length,
+    migrated,
+    backups,
+    dryRun
+  };
+}
+async function migrateObservationsCommand(options) {
+  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
+  const result = migrateObservations(vaultPath, { dryRun: options.dryRun });
+  if (result.migrated === 0) {
+    console.log("No emoji observations found for migration.");
+    return;
+  }
+  if (result.dryRun) {
+    console.log(`Dry run: ${result.migrated} file(s) would be migrated.`);
+    return;
+  }
+  console.log(`Migrated ${result.migrated} file(s); created ${result.backups} backup(s).`);
+}
+function registerMigrateObservationsCommand(program) {
+  program.command("migrate-observations").description("Convert legacy emoji observations to scored format with backups").option("--dry-run", "Preview migration without writing files").option("-v, --vault <path>", "Vault path").action(async (rawOptions) => {
+    await migrateObservationsCommand({
+      vaultPath: rawOptions.vault,
+      dryRun: rawOptions.dryRun
+    });
+  });
+}
+
+export {
+  migrateObservations,
+  migrateObservationsCommand,
+  registerMigrateObservationsCommand
+};

package/dist/chunk-Z2XBWN7A.js

@@ -0,0 +1,247 @@
+// src/lib/ledger.ts
+import * as fs from "fs";
+import * as path from "path";
+var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+var YEAR_RE = /^\d{4}$/;
+var MONTH_RE = /^(0[1-9]|1[0-2])$/;
+var DAY_FILE_RE = /^(0[1-9]|[12]\d|3[01])\.md$/;
+var RAW_DAY_FILE_RE = /^(0[1-9]|[12]\d|3[01])\.jsonl$/;
+function normalizeDateKey(date) {
+  if (typeof date === "string") {
+    if (!DATE_RE.test(date)) {
+      throw new Error(`Invalid date key: ${date}`);
+    }
+    return date;
+  }
+  return date.toISOString().slice(0, 10);
+}
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+function walkThreeLevelDateTree(rootPath, extension) {
+  if (!fs.existsSync(rootPath)) {
+    return [];
+  }
+  const results = [];
+  for (const yearEntry of fs.readdirSync(rootPath, { withFileTypes: true })) {
+    if (!yearEntry.isDirectory() || !YEAR_RE.test(yearEntry.name)) continue;
+    const yearDir = path.join(rootPath, yearEntry.name);
+    for (const monthEntry of fs.readdirSync(yearDir, { withFileTypes: true })) {
+      if (!monthEntry.isDirectory() || !MONTH_RE.test(monthEntry.name)) continue;
+      const monthDir = path.join(yearDir, monthEntry.name);
+      for (const dayEntry of fs.readdirSync(monthDir, { withFileTypes: true })) {
+        if (!dayEntry.isFile()) continue;
+        const matches = extension === ".md" ? DAY_FILE_RE.test(dayEntry.name) : RAW_DAY_FILE_RE.test(dayEntry.name);
+        if (!matches) continue;
+        const day = dayEntry.name.slice(0, extension.length * -1);
+        const date = `${yearEntry.name}-${monthEntry.name}-${day}`;
+        if (!DATE_RE.test(date)) continue;
+        results.push({
+          date,
+          absolutePath: path.join(monthDir, dayEntry.name)
+        });
+      }
+    }
+  }
+  return results;
+}
+function inDateRange(date, fromDate, toDate) {
+  if (fromDate && date < fromDate) {
+    return false;
+  }
+  if (toDate && date > toDate) {
+    return false;
+  }
+  return true;
+}
+function toDateKey(date) {
+  return date.toISOString().slice(0, 10);
+}
+function parseDateKey(date) {
+  if (!DATE_RE.test(date)) {
+    return null;
+  }
+  const parsed = /* @__PURE__ */ new Date(`${date}T00:00:00.000Z`);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function getLedgerRoot(vaultPath) {
+  return path.join(path.resolve(vaultPath), "ledger");
+}
+function getRawRoot(vaultPath) {
+  return path.join(getLedgerRoot(vaultPath), "raw");
+}
+function getRawSourceDir(vaultPath, source) {
+  return path.join(getRawRoot(vaultPath), source);
+}
+function getObservationsRoot(vaultPath) {
+  return path.join(getLedgerRoot(vaultPath), "observations");
+}
+function getReflectionsRoot(vaultPath) {
+  return path.join(getLedgerRoot(vaultPath), "reflections");
+}
+function getArchiveObservationsRoot(vaultPath) {
+  return path.join(getLedgerRoot(vaultPath), "archive", "observations");
+}
+function getLegacyObservationsRoot(vaultPath) {
+  return path.join(path.resolve(vaultPath), "observations");
+}
+function getObservationPath(vaultPath, date) {
+  const dateKey = normalizeDateKey(date);
+  const [year, month, day] = dateKey.split("-");
+  return path.join(getObservationsRoot(vaultPath), year, month, `${day}.md`);
+}
+function getArchiveObservationPath(vaultPath, date) {
+  const dateKey = normalizeDateKey(date);
+  const [year, month, day] = dateKey.split("-");
+  return path.join(getArchiveObservationsRoot(vaultPath), year, month, `${day}.md`);
+}
+function getLegacyObservationPath(vaultPath, date) {
+  const dateKey = normalizeDateKey(date);
+  return path.join(getLegacyObservationsRoot(vaultPath), `${dateKey}.md`);
+}
+function getRawTranscriptPath(vaultPath, source, date) {
+  const dateKey = normalizeDateKey(date);
+  const [year, month, day] = dateKey.split("-");
+  return path.join(getRawSourceDir(vaultPath, source), year, month, `${day}.jsonl`);
+}
+function ensureLedgerStructure(vaultPath) {
+  const root = getLedgerRoot(vaultPath);
+  const rawRoot = getRawRoot(vaultPath);
+  ensureDir(root);
+  ensureDir(rawRoot);
+  for (const source of ["openclaw", "chatgpt", "claude", "opencode"]) {
+    ensureDir(path.join(rawRoot, source));
+  }
+  ensureDir(getObservationsRoot(vaultPath));
+  ensureDir(getReflectionsRoot(vaultPath));
+  ensureDir(getArchiveObservationsRoot(vaultPath));
+}
+function listLedgerObservationFiles(vaultPath, options = {}) {
+  return walkThreeLevelDateTree(getObservationsRoot(vaultPath), ".md").filter((entry) => inDateRange(entry.date, options.fromDate, options.toDate)).map((entry) => ({
+    date: entry.date,
+    path: entry.absolutePath,
+    location: "ledger"
+  })).sort((left, right) => left.date.localeCompare(right.date));
+}
+function listArchiveObservationFiles(vaultPath, options = {}) {
+  return walkThreeLevelDateTree(getArchiveObservationsRoot(vaultPath), ".md").filter((entry) => inDateRange(entry.date, options.fromDate, options.toDate)).map((entry) => ({
+    date: entry.date,
+    path: entry.absolutePath,
+    location: "archive"
+  })).sort((left, right) => left.date.localeCompare(right.date));
+}
+function listLegacyObservationFiles(vaultPath, options = {}) {
+  const legacyRoot = getLegacyObservationsRoot(vaultPath);
+  if (!fs.existsSync(legacyRoot)) {
+    return [];
+  }
+  return fs.readdirSync(legacyRoot, { withFileTypes: true }).filter((entry) => entry.isFile() && DATE_RE.test(entry.name.replace(/\.md$/, "")) && entry.name.endsWith(".md")).map((entry) => {
+    const date = entry.name.replace(/\.md$/, "");
+    return {
+      date,
+      path: path.join(legacyRoot, entry.name),
+      location: "legacy"
+    };
+  }).filter((entry) => inDateRange(entry.date, options.fromDate, options.toDate)).sort((left, right) => left.date.localeCompare(right.date));
+}
+function listObservationFiles(vaultPath, options = {}) {
+  const includeLegacy = options.includeLegacy ?? true;
+  const includeArchive = options.includeArchive ?? false;
+  const dedupeByDate = options.dedupeByDate ?? true;
+  const files = [
+    ...listLedgerObservationFiles(vaultPath, options),
+    ...includeLegacy ? listLegacyObservationFiles(vaultPath, options) : [],
+    ...includeArchive ? listArchiveObservationFiles(vaultPath, options) : []
+  ];
+  if (!dedupeByDate) {
+    return files.sort((left, right) => left.date.localeCompare(right.date));
+  }
+  const byDate = /* @__PURE__ */ new Map();
+  const locationRank = {
+    ledger: 3,
+    legacy: 2,
+    archive: 1
+  };
+  for (const file of files) {
+    const existing = byDate.get(file.date);
+    if (!existing || locationRank[file.location] > locationRank[existing.location]) {
+      byDate.set(file.date, file);
+    }
+  }
+  return [...byDate.values()].sort((left, right) => left.date.localeCompare(right.date));
+}
+function listRawTranscriptFiles(vaultPath, options = {}) {
+  const rawRoot = getRawRoot(vaultPath);
+  if (!fs.existsSync(rawRoot)) {
+    return [];
+  }
+  const sources = options.source ? [options.source] : fs.readdirSync(rawRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  const files = [];
+  for (const source of sources) {
+    const sourceRoot = path.join(rawRoot, source);
+    const datedFiles = walkThreeLevelDateTree(sourceRoot, ".jsonl");
+    for (const entry of datedFiles) {
+      if (!inDateRange(entry.date, options.fromDate, options.toDate)) {
+        continue;
+      }
+      files.push({
+        source,
+        date: entry.date,
+        path: entry.absolutePath
+      });
+    }
+  }
+  return files.sort(
+    (left, right) => left.date === right.date ? left.path.localeCompare(right.path) : left.date.localeCompare(right.date)
+  );
+}
+function getIsoWeekMonday(date) {
+  const normalized = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+  const day = normalized.getUTCDay() || 7;
+  normalized.setUTCDate(normalized.getUTCDate() - day + 1);
+  return normalized;
+}
+function getIsoWeek(date) {
+  const monday = getIsoWeekMonday(date);
+  const thursday = new Date(monday);
+  thursday.setUTCDate(monday.getUTCDate() + 3);
+  const isoYear = thursday.getUTCFullYear();
+  const firstThursday = new Date(Date.UTC(isoYear, 0, 4));
+  const firstWeekMonday = getIsoWeekMonday(firstThursday);
+  const diffMs = monday.getTime() - firstWeekMonday.getTime();
+  const week = Math.floor(diffMs / (7 * 24 * 60 * 60 * 1e3)) + 1;
+  return { year: isoYear, week };
+}
+function formatIsoWeekKey(input) {
+  const weekInfo = input instanceof Date ? getIsoWeek(input) : input;
+  return `${weekInfo.year}-W${String(weekInfo.week).padStart(2, "0")}`;
+}
+function getIsoWeekRange(year, week) {
+  const januaryFourth = new Date(Date.UTC(year, 0, 4));
+  const firstWeekMonday = getIsoWeekMonday(januaryFourth);
+  const start = new Date(firstWeekMonday);
+  start.setUTCDate(firstWeekMonday.getUTCDate() + (week - 1) * 7);
+  const end = new Date(start);
+  end.setUTCDate(start.getUTCDate() + 6);
+  return { start, end };
+}
+function ensureParentDir(filePath) {
+  ensureDir(path.dirname(filePath));
+}
+
+export {
+  toDateKey,
+  parseDateKey,
+  getReflectionsRoot,
+  getObservationPath,
+  getArchiveObservationPath,
+  getLegacyObservationPath,
+  getRawTranscriptPath,
+  ensureLedgerStructure,
+  listObservationFiles,
+  listRawTranscriptFiles,
+  getIsoWeek,
+  formatIsoWeekKey,
+  getIsoWeekRange,
+  ensureParentDir
+};

package/dist/{chunk-O5V7SD5C.js → chunk-ZZA73MFY.js}

@@ -346,7 +346,7 @@ async function buildOrUpdateMemoryGraphIndex(vaultPathInput, options = {}) {
   const existing = options.forceFull ? null : loadMemoryGraphIndex(vaultPath);
   const markdownFiles = await glob("**/*.md", {
     cwd: vaultPath,
-    ignore: ["**/node_modules/**", "**/.git/**", "**/.obsidian/**", "**/.trash/**"]
+    ignore: ["**/node_modules/**", "**/.git/**", "**/.obsidian/**", "**/.trash/**", "**/ledger/archive/**"]
   });
   const normalizedFiles = markdownFiles.map(normalizeRelativePath).sort((a, b) => a.localeCompare(b));
   const registry = buildNoteRegistry(normalizedFiles);

package/dist/commands/archive.d.ts

@@ -0,0 +1,11 @@
+import { Command } from 'commander';
+
+interface ArchiveCommandOptions {
+    vaultPath?: string;
+    olderThan?: number;
+    dryRun?: boolean;
+}
+declare function archiveCommand(options: ArchiveCommandOptions): Promise<void>;
+declare function registerArchiveCommand(program: Command): void;
+
+export { type ArchiveCommandOptions, archiveCommand, registerArchiveCommand };

package/dist/commands/archive.js

@@ -0,0 +1,11 @@
+import {
+  archiveCommand,
+  registerArchiveCommand
+} from "../chunk-VR5NE7PZ.js";
+import "../chunk-MQUJNOHK.js";
+import "../chunk-Z2XBWN7A.js";
+import "../chunk-MXSSG3QU.js";
+export {
+  archiveCommand,
+  registerArchiveCommand
+};

package/dist/commands/context.d.ts

@@ -1,2 +1,2 @@
 import 'commander';
-export { C as ContextEntry, a as ContextFormat, b as ContextOptions, c as ContextProfile, e as ContextProfileOption, f as ContextResult, g as buildContext, h as contextCommand, i as formatContextMarkdown, r as registerContextCommand } from '../context-COo8oq1k.js';
+export { C as ContextEntry, a as ContextFormat, b as ContextOptions, c as ContextProfile, e as ContextProfileOption, f as ContextResult, g as buildContext, h as contextCommand, i as formatContextMarkdown, r as registerContextCommand } from '../context-BUGaWpyL.js';

package/dist/commands/context.js

@@ -3,10 +3,12 @@ import {
   contextCommand,
   formatContextMarkdown,
   registerContextCommand
-} from "../chunk-TBVI4N53.js";
-import "../chunk-QFBKWDYR.js";
-import "../chunk-MIIXBNO3.js";
-import "../chunk-O5V7SD5C.js";
+} from "../chunk-6RIHODNR.js";
+import "../chunk-K6XHCUFL.js";
+import "../chunk-Z2XBWN7A.js";
+import "../chunk-IFGDPIFI.js";
+import "../chunk-DHBDH4DN.js";
+import "../chunk-ZZA73MFY.js";
 export {
   buildContext,
   contextCommand,

package/dist/commands/doctor.js

@@ -1,3 +1,6 @@
+import {
+  scanVaultLinks
+} from "../chunk-4VQTUVH7.js";
 import {
   formatAge
 } from "../chunk-7ZRP733D.js";
@@ -7,17 +10,14 @@ import {
 import {
   ClawVault,
   findVault
-} from "../chunk-QFBKWDYR.js";
+} from "../chunk-IFGDPIFI.js";
 import {
   hasQmd
-} from "../chunk-MIIXBNO3.js";
-import {
-  scanVaultLinks
-} from "../chunk-4VQTUVH7.js";
+} from "../chunk-DHBDH4DN.js";
 import "../chunk-J7ZWCI2C.js";
 import {
   loadMemoryGraphIndex
-} from "../chunk-O5V7SD5C.js";
+} from "../chunk-ZZA73MFY.js";
 
 // src/commands/doctor.ts
 import * as fs from "fs";

package/dist/commands/graph.js

@@ -1,8 +1,8 @@
 import {
   graphCommand,
   graphSummary
-} from "../chunk-TXO34J3O.js";
-import "../chunk-O5V7SD5C.js";
+} from "../chunk-H7JW4L7H.js";
+import "../chunk-ZZA73MFY.js";
 import "../chunk-MXSSG3QU.js";
 export {
   graphCommand,

package/dist/commands/link.js

@@ -13,7 +13,7 @@ import {
 } from "../chunk-J7ZWCI2C.js";
 import {
   buildOrUpdateMemoryGraphIndex
-} from "../chunk-O5V7SD5C.js";
+} from "../chunk-ZZA73MFY.js";
 import {
   resolveVaultPath
 } from "../chunk-MXSSG3QU.js";