clawvault 2.6.0 → 3.0.0

package/dist/commands/link.d.cts

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

package/dist/commands/link.js

@@ -17,6 +17,7 @@ import {
 import {
   buildOrUpdateMemoryGraphIndex
 } from "../chunk-ZZA73MFY.js";
+import "../chunk-3RG5ZIWI.js";
 
 // src/commands/link.ts
 import * as fs from "fs";

package/dist/commands/migrate-observations.cjs

@@ -0,0 +1,362 @@
+"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/migrate-observations.ts
+var migrate_observations_exports = {};
+__export(migrate_observations_exports, {
+  migrateObservations: () => migrateObservations,
+  migrateObservationsCommand: () => migrateObservationsCommand,
+  registerMigrateObservationsCommand: () => registerMigrateObservationsCommand
+});
+module.exports = __toCommonJS(migrate_observations_exports);
+var fs3 = __toESM(require("fs"), 1);
+
+// src/lib/config.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+function findNearestVaultPath(startPath = process.cwd()) {
+  let current = path.resolve(startPath);
+  while (true) {
+    if (fs.existsSync(path.join(current, ".clawvault.json"))) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function resolveVaultPath(options = {}) {
+  if (options.explicitPath) {
+    return path.resolve(options.explicitPath);
+  }
+  if (process.env.CLAWVAULT_PATH) {
+    return path.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/ledger.ts
+var fs2 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+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 walkThreeLevelDateTree(rootPath, extension) {
+  if (!fs2.existsSync(rootPath)) {
+    return [];
+  }
+  const results = [];
+  for (const yearEntry of fs2.readdirSync(rootPath, { withFileTypes: true })) {
+    if (!yearEntry.isDirectory() || !YEAR_RE.test(yearEntry.name)) continue;
+    const yearDir = path2.join(rootPath, yearEntry.name);
+    for (const monthEntry of fs2.readdirSync(yearDir, { withFileTypes: true })) {
+      if (!monthEntry.isDirectory() || !MONTH_RE.test(monthEntry.name)) continue;
+      const monthDir = path2.join(yearDir, monthEntry.name);
+      for (const dayEntry of fs2.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: path2.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 getLedgerRoot(vaultPath) {
+  return path2.join(path2.resolve(vaultPath), "ledger");
+}
+function getObservationsRoot(vaultPath) {
+  return path2.join(getLedgerRoot(vaultPath), "observations");
+}
+function getArchiveObservationsRoot(vaultPath) {
+  return path2.join(getLedgerRoot(vaultPath), "archive", "observations");
+}
+function getLegacyObservationsRoot(vaultPath) {
+  return path2.join(path2.resolve(vaultPath), "observations");
+}
+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 (!fs2.existsSync(legacyRoot)) {
+    return [];
+  }
+  return fs2.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: path2.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));
+}
+
+// src/lib/observation-format.ts
+var DATE_HEADING_RE = /^##\s+(\d{4}-\d{2}-\d{2})\s*$/;
+var SCORED_LINE_RE = /^(?:-\s*)?\[(decision|preference|fact|commitment|task|todo|commitment-unresolved|milestone|lesson|relationship|project)\|c=(0(?:\.\d+)?|1(?:\.0+)?)\|i=(0(?:\.\d+)?|1(?:\.0+)?)\]\s+(.+)$/i;
+var EMOJI_LINE_RE = /^(?:-\s*)?(🔴|🟡|🟢)\s+(\d{2}:\d{2})?\s*(.+)$/u;
+var DECISION_RE = /\b(decis(?:ion|ions)?|decid(?:e|ed|ing)|chose|selected|opted|went with|picked)\b/i;
+var PREFERENCE_RE = /\b(prefer(?:ence|s|red)?|likes?|dislikes?|default to|always use|never use|enjoys?|loves?|favou?rite|fan of|interested in|go-to|tend(?:s)? to use|passionate about|hobby|hobbies|(?:I|my|our)\s+(?:own|have|use|got|bought|drive|wear|eat|drink|cook|play|watch|read|listen)|(?:I(?:'m| am))\s+(?:a |an |into |allergic|vegetarian|vegan|gluten|lactose|trying to|learning)|usually|every (?:morning|evening|night|day|week)|routine)\b/i;
+var COMMITMENT_RE = /\b(commit(?:ment|ted)?|promised|deadline|due|scheduled|will deliver|agreed to)\b/i;
+var TODO_RE = /(?:\btodo:\s*|\bwe need to\b|\bdon't forget(?: to)?\b|\bremember to\b|\bmake sure to\b)/i;
+var COMMITMENT_TASK_RE = /\b(?:i'?ll|i will|let me|(?:i'?m\s+)?going to|plan to|should)\b/i;
+var UNRESOLVED_RE = /\b(?:need to figure out|tbd|to be determined)\b/i;
+var DEADLINE_RE = /\b(?:by\s+(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday|tomorrow)|before\s+the\s+\w+|deadline is)\b/i;
+var MILESTONE_RE = /\b(released?|shipped|launched|merged|published|milestone|v\d+\.\d+)\b/i;
+var LESSON_RE = /\b(learn(?:ed|ing|t)|lesson|insight|realized|discovered|never again)\b/i;
+var RELATIONSHIP_RE = /\b(talked to|met with|spoke with|asked|client|partner|teammate|colleague)\b/i;
+var PROJECT_RE = /\b(project|feature|service|repo|api|roadmap|sprint)\b/i;
+function clamp01(value) {
+  if (!Number.isFinite(value)) return 0;
+  if (value < 0) return 0;
+  if (value > 1) return 1;
+  return value;
+}
+function scoreFromLegacyPriority(priority) {
+  if (priority === "\u{1F534}") return 0.9;
+  if (priority === "\u{1F7E1}") return 0.6;
+  return 0.2;
+}
+function confidenceFromLegacyPriority(priority) {
+  if (priority === "\u{1F534}") return 0.9;
+  if (priority === "\u{1F7E1}") return 0.8;
+  return 0.7;
+}
+function inferObservationType(content) {
+  if (DECISION_RE.test(content)) return "decision";
+  if (UNRESOLVED_RE.test(content)) return "commitment-unresolved";
+  if (TODO_RE.test(content)) return "todo";
+  if (PREFERENCE_RE.test(content)) return "preference";
+  if (COMMITMENT_TASK_RE.test(content) || DEADLINE_RE.test(content)) return "task";
+  if (COMMITMENT_RE.test(content)) return "commitment";
+  if (MILESTONE_RE.test(content)) return "milestone";
+  if (LESSON_RE.test(content)) return "lesson";
+  if (RELATIONSHIP_RE.test(content)) return "relationship";
+  if (PROJECT_RE.test(content)) return "project";
+  return "fact";
+}
+function formatScore(value) {
+  return clamp01(value).toFixed(2);
+}
+function parseObservationLine(line, date) {
+  const scored = line.match(SCORED_LINE_RE);
+  if (scored) {
+    return {
+      date,
+      type: scored[1].toLowerCase(),
+      confidence: clamp01(Number.parseFloat(scored[2])),
+      importance: clamp01(Number.parseFloat(scored[3])),
+      content: scored[4].trim(),
+      format: "scored",
+      rawLine: line
+    };
+  }
+  const emoji = line.match(EMOJI_LINE_RE);
+  if (!emoji) {
+    return null;
+  }
+  const priority = emoji[1];
+  const time = emoji[2]?.trim();
+  const text = emoji[3].trim();
+  const content = time ? `${time} ${text}` : text;
+  return {
+    date,
+    type: inferObservationType(content),
+    confidence: confidenceFromLegacyPriority(priority),
+    importance: scoreFromLegacyPriority(priority),
+    content,
+    format: "emoji",
+    priority,
+    time,
+    rawLine: line
+  };
+}
+function renderScoredObservationLine(record) {
+  return `- [${record.type}|c=${formatScore(record.confidence)}|i=${formatScore(record.importance)}] ${record.content.trim()}`;
+}
+
+// src/commands/migrate-observations.ts
+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 = fs3.readFileSync(entry.path, "utf-8");
+    const { converted, changed } = convertObservationMarkdown(raw);
+    if (!changed) {
+      continue;
+    }
+    migrated += 1;
+    if (dryRun) {
+      continue;
+    }
+    const backupPath = toBackupPath(entry.path);
+    if (!fs3.existsSync(backupPath)) {
+      fs3.copyFileSync(entry.path, backupPath);
+      backups += 1;
+    }
+    fs3.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
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  migrateObservations,
+  migrateObservationsCommand,
+  registerMigrateObservationsCommand
+});

package/dist/commands/migrate-observations.d.cts

@@ -0,0 +1,19 @@
+import { Command } from 'commander';
+
+interface MigrateObservationsOptions {
+    vaultPath?: string;
+    dryRun?: boolean;
+}
+interface MigrateObservationsResult {
+    scanned: number;
+    migrated: number;
+    backups: number;
+    dryRun: boolean;
+}
+declare function migrateObservations(vaultPath: string, options?: {
+    dryRun?: boolean;
+}): MigrateObservationsResult;
+declare function migrateObservationsCommand(options: MigrateObservationsOptions): Promise<void>;
+declare function registerMigrateObservationsCommand(program: Command): void;
+
+export { type MigrateObservationsOptions, type MigrateObservationsResult, migrateObservations, migrateObservationsCommand, registerMigrateObservationsCommand };

package/dist/commands/migrate-observations.js

@@ -2,10 +2,11 @@ import {
   migrateObservations,
   migrateObservationsCommand,
   registerMigrateObservationsCommand
-} from "../chunk-VXEOHTSL.js";
-import "../chunk-FHFUXL6G.js";
+} from "../chunk-C7OK5WKP.js";
 import "../chunk-MXSSG3QU.js";
+import "../chunk-QK3UCXWL.js";
 import "../chunk-Z2XBWN7A.js";
+import "../chunk-3RG5ZIWI.js";
 export {
   migrateObservations,
   migrateObservationsCommand,