clawvault 1.1.0

package/dist/chunk-4KDZZW4X.js

@@ -0,0 +1,13 @@
+// src/lib/config.ts
+import * as path from "path";
+function getVaultPath() {
+  const vaultPath = process.env.CLAWVAULT_PATH;
+  if (!vaultPath) {
+    throw new Error("CLAWVAULT_PATH environment variable not set");
+  }
+  return path.resolve(vaultPath);
+}
+
+export {
+  getVaultPath
+};

package/dist/chunk-4XJDHIKE.js

@@ -0,0 +1,103 @@
+import {
+  getSortedAliases
+} from "./chunk-J7ZWCI2C.js";
+
+// 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 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 lines = content.split("\n");
+  let charPos = 0;
+  const lineStarts = [];
+  for (const line of lines) {
+    lineStarts.push(charPos);
+    charPos += line.length + 1;
+  }
+  function getLineNumber(pos) {
+    for (let i = lineStarts.length - 1; i >= 0; i--) {
+      if (pos >= lineStarts[i]) return i + 1;
+    }
+    return 1;
+  }
+  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;
+}
+
+export {
+  autoLink,
+  dryRunLink
+};

package/dist/chunk-J7ZWCI2C.js

@@ -0,0 +1,49 @@
+// src/lib/entity-index.ts
+import * as fs from "fs";
+import * as path from "path";
+import matter from "gray-matter";
+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 } = matter(content);
+      const relativePath = `${folder}/${file.replace(".md", "")}`;
+      const baseName = file.replace(".md", "");
+      const aliases = [baseName];
+      if (frontmatter.title && frontmatter.title.toLowerCase() !== baseName.toLowerCase()) {
+        aliases.push(frontmatter.title);
+      }
+      if (Array.isArray(frontmatter.aliases)) {
+        aliases.push(...frontmatter.aliases);
+      }
+      for (const alias of aliases) {
+        const key = alias.toLowerCase();
+        if (!entries.has(key)) {
+          entries.set(key, relativePath);
+        }
+      }
+      byPath.set(relativePath, { path: relativePath, aliases });
+    }
+  }
+  return { entries, byPath };
+}
+function getSortedAliases(index) {
+  const result = [];
+  for (const [alias, path2] of index.entries) {
+    result.push({ alias, path: path2 });
+  }
+  result.sort((a, b) => b.alias.length - a.alias.length);
+  return result;
+}
+
+export {
+  buildEntityIndex,
+  getSortedAliases
+};

package/dist/chunk-NITF7AHR.js

@@ -0,0 +1,95 @@
+// src/commands/checkpoint.ts
+import * as fs from "fs";
+import * as path from "path";
+var CLAWVAULT_DIR = ".clawvault";
+var CHECKPOINT_FILE = "last-checkpoint.json";
+var SESSION_STATE_FILE = "session-state.json";
+var DIRTY_DEATH_FLAG = "dirty-death.flag";
+var pendingCheckpoint = null;
+var pendingData = null;
+function ensureClawvaultDir(vaultPath) {
+  const dir = path.join(vaultPath, CLAWVAULT_DIR);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function writeCheckpointToDisk(dir, data) {
+  const checkpointPath = path.join(dir, CHECKPOINT_FILE);
+  fs.writeFileSync(checkpointPath, JSON.stringify(data, null, 2));
+  const flagPath = path.join(dir, DIRTY_DEATH_FLAG);
+  fs.writeFileSync(flagPath, data.timestamp);
+}
+async function flush() {
+  if (pendingCheckpoint) {
+    clearTimeout(pendingCheckpoint);
+    pendingCheckpoint = null;
+  }
+  if (!pendingData) return null;
+  const { dir, data } = pendingData;
+  pendingData = null;
+  writeCheckpointToDisk(dir, data);
+  return data;
+}
+async function checkpoint(options) {
+  const dir = ensureClawvaultDir(options.vaultPath);
+  const data = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    workingOn: options.workingOn || null,
+    focus: options.focus || null,
+    blocked: options.blocked || null
+  };
+  const sessionStatePath = path.join(dir, SESSION_STATE_FILE);
+  if (fs.existsSync(sessionStatePath)) {
+    try {
+      const sessionState = JSON.parse(fs.readFileSync(sessionStatePath, "utf-8"));
+      data.sessionId = sessionState.sessionId;
+    } catch {
+    }
+  }
+  pendingData = { dir, data };
+  if (pendingCheckpoint) clearTimeout(pendingCheckpoint);
+  pendingCheckpoint = setTimeout(() => {
+    void flush();
+  }, 1e3);
+  return data;
+}
+async function clearDirtyFlag(vaultPath) {
+  const flagPath = path.join(vaultPath, CLAWVAULT_DIR, DIRTY_DEATH_FLAG);
+  if (fs.existsSync(flagPath)) {
+    fs.unlinkSync(flagPath);
+  }
+}
+async function checkDirtyDeath(vaultPath) {
+  const dir = path.join(vaultPath, CLAWVAULT_DIR);
+  const flagPath = path.join(dir, DIRTY_DEATH_FLAG);
+  const checkpointPath = path.join(dir, CHECKPOINT_FILE);
+  if (!fs.existsSync(flagPath)) {
+    return { died: false, checkpoint: null, deathTime: null };
+  }
+  const deathTime = fs.readFileSync(flagPath, "utf-8").trim();
+  let checkpoint2 = null;
+  if (fs.existsSync(checkpointPath)) {
+    try {
+      checkpoint2 = JSON.parse(fs.readFileSync(checkpointPath, "utf-8"));
+    } catch {
+    }
+  }
+  return { died: true, checkpoint: checkpoint2, deathTime };
+}
+async function setSessionState(vaultPath, sessionId) {
+  const dir = ensureClawvaultDir(vaultPath);
+  const sessionStatePath = path.join(dir, SESSION_STATE_FILE);
+  fs.writeFileSync(sessionStatePath, JSON.stringify({
+    sessionId,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }, null, 2));
+}
+
+export {
+  flush,
+  checkpoint,
+  clearDirtyFlag,
+  checkDirtyDeath,
+  setSessionState
+};

package/dist/commands/checkpoint.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Quick checkpoint command - fast state save for context death resilience
+ */
+interface CheckpointOptions {
+    workingOn?: string;
+    focus?: string;
+    blocked?: string;
+    vaultPath: string;
+}
+interface CheckpointData {
+    timestamp: string;
+    workingOn: string | null;
+    focus: string | null;
+    blocked: string | null;
+    sessionId?: string;
+}
+declare function flush(): Promise<CheckpointData | null>;
+declare function checkpoint(options: CheckpointOptions): Promise<CheckpointData>;
+declare function clearDirtyFlag(vaultPath: string): Promise<void>;
+declare function checkDirtyDeath(vaultPath: string): Promise<{
+    died: boolean;
+    checkpoint: CheckpointData | null;
+    deathTime: string | null;
+}>;
+declare function setSessionState(vaultPath: string, sessionId: string): Promise<void>;
+
+export { type CheckpointData, type CheckpointOptions, checkDirtyDeath, checkpoint, clearDirtyFlag, flush, setSessionState };

package/dist/commands/checkpoint.js

@@ -0,0 +1,14 @@
+import {
+  checkDirtyDeath,
+  checkpoint,
+  clearDirtyFlag,
+  flush,
+  setSessionState
+} from "../chunk-NITF7AHR.js";
+export {
+  checkDirtyDeath,
+  checkpoint,
+  clearDirtyFlag,
+  flush,
+  setSessionState
+};

package/dist/commands/entities.d.ts

@@ -0,0 +1,6 @@
+interface EntitiesOptions {
+    json?: boolean;
+}
+declare function entitiesCommand(options: EntitiesOptions): Promise<void>;
+
+export { entitiesCommand };

package/dist/commands/entities.js

@@ -0,0 +1,44 @@
+import {
+  getVaultPath
+} from "../chunk-4KDZZW4X.js";
+import {
+  buildEntityIndex
+} from "../chunk-J7ZWCI2C.js";
+
+// src/commands/entities.ts
+async function entitiesCommand(options) {
+  const vaultPath = getVaultPath();
+  const index = buildEntityIndex(vaultPath);
+  if (options.json) {
+    const output = {};
+    for (const [path, entry] of index.byPath) {
+      output[path] = entry.aliases;
+    }
+    console.log(JSON.stringify(output, null, 2));
+    return;
+  }
+  const byFolder = {};
+  for (const [path, entry] of index.byPath) {
+    const folder = path.split("/")[0];
+    if (!byFolder[folder]) byFolder[folder] = [];
+    byFolder[folder].push({ path, aliases: entry.aliases });
+  }
+  console.log("\u{1F4DA} Linkable Entities\n");
+  for (const [folder, entities] of Object.entries(byFolder)) {
+    console.log(`## ${folder}/`);
+    for (const entity of entities) {
+      const name = entity.path.split("/")[1];
+      const otherAliases = entity.aliases.filter((a) => a.toLowerCase() !== name.toLowerCase());
+      if (otherAliases.length > 0) {
+        console.log(`  - ${name} (${otherAliases.join(", ")})`);
+      } else {
+        console.log(`  - ${name}`);
+      }
+    }
+    console.log();
+  }
+  console.log(`Total: ${index.byPath.size} entities, ${index.entries.size} linkable aliases`);
+}
+export {
+  entitiesCommand
+};

package/dist/commands/link.d.ts

@@ -0,0 +1,7 @@
+interface LinkOptions {
+    all?: boolean;
+    dryRun?: boolean;
+}
+declare function linkCommand(file: string | undefined, options: LinkOptions): Promise<void>;
+
+export { linkCommand };

package/dist/commands/link.js

@@ -0,0 +1,85 @@
+import {
+  autoLink,
+  dryRunLink
+} from "../chunk-4XJDHIKE.js";
+import {
+  getVaultPath
+} from "../chunk-4KDZZW4X.js";
+import {
+  buildEntityIndex
+} from "../chunk-J7ZWCI2C.js";
+
+// src/commands/link.ts
+import * as fs from "fs";
+import * as path from "path";
+async function linkCommand(file, options) {
+  const vaultPath = getVaultPath();
+  const index = buildEntityIndex(vaultPath);
+  if (options.all) {
+    await linkAllFiles(vaultPath, index, options.dryRun);
+    return;
+  }
+  if (!file) {
+    console.error("Error: Specify a file or use --all");
+    process.exit(1);
+  }
+  const filePath = path.isAbsolute(file) ? file : path.join(process.cwd(), file);
+  if (!fs.existsSync(filePath)) {
+    console.error(`Error: File not found: ${filePath}`);
+    process.exit(1);
+  }
+  await linkFile(filePath, index, options.dryRun);
+}
+async function linkFile(filePath, index, dryRun) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  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}]]`);
+      }
+    }
+    return matches.length;
+  }
+  const linked = autoLink(content, index);
+  if (linked !== content) {
+    fs.writeFileSync(filePath, linked);
+    const matches = dryRunLink(content, index);
+    console.log(`\u2713 Linked ${matches.length} entities in ${path.basename(filePath)}`);
+    return matches.length;
+  }
+  return 0;
+}
+async function linkAllFiles(vaultPath, index, dryRun) {
+  const files = [];
+  function walk(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.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, dryRun);
+    if (links > 0) {
+      totalLinks += links;
+      filesModified++;
+    }
+  }
+  console.log(`
+${dryRun ? "(dry run) " : ""}${totalLinks} links in ${filesModified} files`);
+}
+export {
+  linkCommand
+};

package/dist/commands/recover.d.ts

@@ -0,0 +1,21 @@
+import { CheckpointData } from './checkpoint.js';
+
+/**
+ * Recovery command - detect dirty death and provide recovery info
+ */
+
+interface RecoveryInfo {
+    died: boolean;
+    deathTime: string | null;
+    checkpoint: CheckpointData | null;
+    handoffPath: string | null;
+    handoffContent: string | null;
+    recoveryMessage: string;
+}
+declare function recover(vaultPath: string, clearFlag?: boolean): Promise<RecoveryInfo>;
+/**
+ * Format recovery info for CLI output
+ */
+declare function formatRecoveryInfo(info: RecoveryInfo): string;
+
+export { type RecoveryInfo, formatRecoveryInfo, recover };

package/dist/commands/recover.js

@@ -0,0 +1,108 @@
+import {
+  checkDirtyDeath,
+  clearDirtyFlag
+} from "../chunk-NITF7AHR.js";
+
+// src/commands/recover.ts
+import * as fs from "fs";
+import * as path from "path";
+async function recover(vaultPath, clearFlag = false) {
+  const { died, checkpoint, deathTime } = await checkDirtyDeath(vaultPath);
+  if (!died) {
+    return {
+      died: false,
+      deathTime: null,
+      checkpoint: null,
+      handoffPath: null,
+      handoffContent: null,
+      recoveryMessage: "No context death detected. Clean startup."
+    };
+  }
+  const handoffsDir = path.join(vaultPath, "handoffs");
+  let handoffPath = null;
+  let handoffContent = null;
+  if (fs.existsSync(handoffsDir)) {
+    const files = fs.readdirSync(handoffsDir).filter((f) => f.startsWith("handoff-") && f.endsWith(".md")).sort().reverse();
+    if (files.length > 0) {
+      handoffPath = path.join(handoffsDir, files[0]);
+      handoffContent = fs.readFileSync(handoffPath, "utf-8");
+    }
+  }
+  let message = "\u26A0\uFE0F **CONTEXT DEATH DETECTED**\n\n";
+  message += `Your previous session died at ${deathTime}.
+
+`;
+  if (checkpoint) {
+    message += "**Last known state:**\n";
+    if (checkpoint.workingOn) {
+      message += `- Working on: ${checkpoint.workingOn}
+`;
+    }
+    if (checkpoint.focus) {
+      message += `- Focus: ${checkpoint.focus}
+`;
+    }
+    if (checkpoint.blocked) {
+      message += `- Blocked: ${checkpoint.blocked}
+`;
+    }
+    message += "\n";
+  }
+  if (handoffPath) {
+    message += `**Last handoff:** ${path.basename(handoffPath)}
+`;
+    message += "Review and resume from where you left off.\n";
+  } else {
+    message += "**No handoff found.** You may have lost context.\n";
+  }
+  if (clearFlag) {
+    await clearDirtyFlag(vaultPath);
+  }
+  return {
+    died: true,
+    deathTime,
+    checkpoint,
+    handoffPath,
+    handoffContent,
+    recoveryMessage: message
+  };
+}
+function formatRecoveryInfo(info) {
+  if (!info.died) {
+    return "\u2713 Clean startup - no context death detected.";
+  }
+  let output = "\n\u26A0\uFE0F  CONTEXT DEATH DETECTED\n";
+  output += "\u2550".repeat(40) + "\n\n";
+  output += `Death time: ${info.deathTime}
+
+`;
+  if (info.checkpoint) {
+    output += "Last checkpoint:\n";
+    if (info.checkpoint.workingOn) {
+      output += `  \u2022 Working on: ${info.checkpoint.workingOn}
+`;
+    }
+    if (info.checkpoint.focus) {
+      output += `  \u2022 Focus: ${info.checkpoint.focus}
+`;
+    }
+    if (info.checkpoint.blocked) {
+      output += `  \u2022 Blocked: ${info.checkpoint.blocked}
+`;
+    }
+    output += "\n";
+  }
+  if (info.handoffPath) {
+    output += `Last handoff: ${path.basename(info.handoffPath)}
+`;
+  } else {
+    output += "No handoff found - context may be lost.\n";
+  }
+  output += "\n" + "\u2550".repeat(40) + "\n";
+  output += "Run `clawvault recap` to see full context.\n";
+  return output;
+}
+export {
+  formatRecoveryInfo,
+  recover
+};