clawvault 2.1.2 → 2.2.1

package/dist/{chunk-QFBKWDYR.js → chunk-OTQW3OMC.js}

@@ -8,10 +8,10 @@ import {
   hasQmd,
   qmdEmbed,
   qmdUpdate
-} from "./chunk-MIIXBNO3.js";
+} from "./chunk-FDJIZKCW.js";
 import {
   buildOrUpdateMemoryGraphIndex
-} from "./chunk-O5V7SD5C.js";
+} from "./chunk-ZZA73MFY.js";
 
 // src/lib/vault.ts
 import * as fs from "fs";
@@ -58,11 +58,19 @@ var ClawVault = class {
         fs.mkdirSync(catPath, { recursive: true });
       }
     }
+    const ledgerDirs = ["ledger/raw", "ledger/observations", "ledger/reflections"];
+    for (const dir of ledgerDirs) {
+      const dirPath = path.join(vaultPath, dir);
+      if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+      }
+    }
     await this.createTemplates();
     const readmePath = path.join(vaultPath, "README.md");
     if (!fs.existsSync(readmePath)) {
       fs.writeFileSync(readmePath, this.generateReadme());
     }
+    await this.createWelcomeNote();
     const configPath = path.join(vaultPath, CONFIG_FILE);
     const meta = {
       name: this.config.name,
@@ -111,7 +119,7 @@ var ClawVault = class {
     this.search.clear();
     const files = await glob("**/*.md", {
       cwd: this.config.path,
-      ignore: ["**/node_modules/**", "**/.*"]
+      ignore: ["**/node_modules/**", "**/.*", "**/ledger/archive/**"]
     });
     for (const file of files) {
       const doc = await this.loadDocument(file);
@@ -628,6 +636,51 @@ var ClawVault = class {
       }
     }
   }
+  async createWelcomeNote() {
+    const inboxPath = path.join(this.config.path, "inbox", "welcome.md");
+    if (fs.existsSync(inboxPath)) return;
+    const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const content = `---
+title: "Welcome to ${this.config.name}"
+date: ${now}
+type: fact
+tags: [welcome, getting-started]
+---
+
+# Welcome to ${this.config.name}
+
+Your vault is ready. Here's what you can do:
+
+## Quick Start
+
+- **Capture a thought:** \`clawvault capture "your note here"\`
+- **Store structured memory:** \`clawvault store --category decisions --title "My Choice" --content "..."\`
+- **Search your vault:** \`clawvault search "query"\`
+- **See your knowledge graph:** \`clawvault graph\`
+- **Get context for a topic:** \`clawvault context "topic"\`
+
+## Vault Structure
+
+Your vault organizes memories by type \u2014 decisions, lessons, people, projects, and more.
+Each category is a folder. Each memory is a markdown file with frontmatter.
+
+## Observational Memory
+
+When connected to an AI agent (like OpenClaw), your vault can automatically observe
+conversations and extract important memories \u2014 decisions, lessons, commitments \u2014 without
+manual effort.
+
+## Wiki-Links
+
+Use \`[[double brackets]]\` to link between notes. Your memory graph tracks these
+connections, building a knowledge network that grows with you.
+
+---
+
+*Delete this file anytime. It's just here to say hello.*
+`;
+    fs.writeFileSync(inboxPath, content);
+  }
   async syncMemoryGraphIndex(options = {}) {
     try {
       await buildOrUpdateMemoryGraphIndex(this.config.path, options);
@@ -635,29 +688,51 @@ var ClawVault = class {
     }
   }
   generateReadme() {
-    return `# ${this.config.name} \u{1F418}
+    const coreCategories = this.config.categories.filter((c) => !["templates", "tasks", "backlog"].includes(c));
+    const workCategories = this.config.categories.filter((c) => ["tasks", "backlog"].includes(c));
+    return `# ${this.config.name}
 
 An elephant never forgets.
 
 ## Structure
 
-${this.config.categories.map((c) => `- \`/${c}/\` \u2014 ${this.getCategoryDescription(c)}`).join("\n")}
+### Memory Categories
+${coreCategories.map((c) => `- \`${c}/\` \u2014 ${this.getCategoryDescription(c)}`).join("\n")}
 
-## Quick Search
+### Work Tracking
+${workCategories.map((c) => `- \`${c}/\` \u2014 ${this.getCategoryDescription(c)}`).join("\n")}
+
+### Observational Memory
+- \`ledger/raw/\` \u2014 Raw session transcripts (source of truth)
+- \`ledger/observations/\` \u2014 Compressed observations with importance scores
+- \`ledger/reflections/\` \u2014 Weekly reflection summaries
+
+## Quick Reference
 
 \`\`\`bash
+# Capture a thought
+clawvault capture "important insight about X"
+
+# Store structured memory
+clawvault store --category decisions --title "Choice" --content "We chose X because..."
+
+# Search
 clawvault search "query"
-\`\`\`
+clawvault vsearch "semantic query"    # vector search
 
-## Quick Capture
+# Knowledge graph
+clawvault graph                       # vault stats
+clawvault context "topic"             # graph-aware context retrieval
 
-\`\`\`bash
-clawvault store --category inbox --title "note" --content "..."
+# Session lifecycle
+clawvault checkpoint --working-on "task"
+clawvault sleep "what I did" --next "what's next"
+clawvault wake                        # restore context on startup
 \`\`\`
 
 ---
 
-*Managed by [ClawVault](https://github.com/Versatly/clawvault)*
+*Managed by [ClawVault](https://clawvault.dev)*
 `;
   }
   getCategoryDescription(category) {
@@ -677,7 +752,11 @@ clawvault store --category inbox --title "note" --content "..."
       goals: "Long-term and short-term objectives",
       patterns: "Recurring behaviors (\u2192 lessons)",
       inbox: "Quick capture \u2192 process later",
-      templates: "Templates for each document type"
+      templates: "Templates for each document type",
+      agents: "Other agents \u2014 capabilities, trust levels, coordination notes",
+      research: "Deep dives, analysis, reference material",
+      tasks: "Active work items with status and context",
+      backlog: "Future work \u2014 ideas and tasks not yet started"
     };
     return descriptions[category] || category;
   }

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-PIJGYMQZ.js → chunk-W463YRED.js}

@@ -1,7 +1,7 @@
 import {
   DEFAULT_CATEGORIES,
   hasQmd
-} from "./chunk-MIIXBNO3.js";
+} from "./chunk-FDJIZKCW.js";
 
 // src/commands/setup.ts
 import * as fs from "fs";

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
+};