clawvault 2.1.2 → 2.2.1

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-I5X6J4FX.js";
+import "../chunk-K6XHCUFL.js";
+import "../chunk-Z2XBWN7A.js";
+import "../chunk-OTQW3OMC.js";
+import "../chunk-FDJIZKCW.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-OTQW3OMC.js";
 import {
   hasQmd
-} from "../chunk-MIIXBNO3.js";
-import {
-  scanVaultLinks
-} from "../chunk-4VQTUVH7.js";
+} from "../chunk-FDJIZKCW.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";

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

@@ -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

@@ -0,0 +1,13 @@
+import {
+  migrateObservations,
+  migrateObservationsCommand,
+  registerMigrateObservationsCommand
+} from "../chunk-WZI3OAE5.js";
+import "../chunk-K6XHCUFL.js";
+import "../chunk-Z2XBWN7A.js";
+import "../chunk-MXSSG3QU.js";
+export {
+  migrateObservations,
+  migrateObservationsCommand,
+  registerMigrateObservationsCommand
+};

package/dist/commands/observe.js

@@ -1,9 +1,12 @@
 import {
   observeCommand,
   registerObserveCommand
-} from "../chunk-FEQ2CQ3Y.js";
+} from "../chunk-LB6P4CD5.js";
+import "../chunk-P5EPF6MB.js";
 import "../chunk-HRLWZGMA.js";
-import "../chunk-5MQB7B37.js";
+import "../chunk-2HM7ZI4X.js";
+import "../chunk-K6XHCUFL.js";
+import "../chunk-Z2XBWN7A.js";
 import "../chunk-MXSSG3QU.js";
 export {
   observeCommand,

package/dist/commands/rebuild.d.ts

@@ -0,0 +1,11 @@
+import { Command } from 'commander';
+
+interface RebuildCommandOptions {
+    vaultPath?: string;
+    from?: string;
+    to?: string;
+}
+declare function rebuildCommand(options: RebuildCommandOptions): Promise<void>;
+declare function registerRebuildCommand(program: Command): void;
+
+export { type RebuildCommandOptions, rebuildCommand, registerRebuildCommand };

package/dist/commands/rebuild.js

@@ -0,0 +1,12 @@
+import {
+  rebuildCommand,
+  registerRebuildCommand
+} from "../chunk-73P7XCQM.js";
+import "../chunk-2HM7ZI4X.js";
+import "../chunk-K6XHCUFL.js";
+import "../chunk-Z2XBWN7A.js";
+import "../chunk-MXSSG3QU.js";
+export {
+  rebuildCommand,
+  registerRebuildCommand
+};

package/dist/commands/reflect.d.ts

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

package/dist/commands/reflect.js

@@ -0,0 +1,13 @@
+import {
+  reflectCommand,
+  registerReflectCommand
+} from "../chunk-GJEGPO7U.js";
+import "../chunk-GQVYQCY5.js";
+import "../chunk-MQUJNOHK.js";
+import "../chunk-K6XHCUFL.js";
+import "../chunk-Z2XBWN7A.js";
+import "../chunk-MXSSG3QU.js";
+export {
+  reflectCommand,
+  registerReflectCommand
+};

package/dist/commands/replay.d.ts

@@ -0,0 +1,16 @@
+import { Command } from 'commander';
+
+type ReplaySource = 'chatgpt' | 'claude' | 'opencode' | 'openclaw';
+
+interface ReplayCommandOptions {
+    source: ReplaySource;
+    inputPath: string;
+    from?: string;
+    to?: string;
+    dryRun?: boolean;
+    vaultPath?: string;
+}
+declare function replayCommand(options: ReplayCommandOptions): Promise<void>;
+declare function registerReplayCommand(program: Command): void;
+
+export { type ReplayCommandOptions, registerReplayCommand, replayCommand };

package/dist/commands/replay.js

@@ -0,0 +1,14 @@
+import {
+  registerReplayCommand,
+  replayCommand
+} from "../chunk-L6NB43WV.js";
+import "../chunk-2HM7ZI4X.js";
+import "../chunk-GQVYQCY5.js";
+import "../chunk-MQUJNOHK.js";
+import "../chunk-K6XHCUFL.js";
+import "../chunk-Z2XBWN7A.js";
+import "../chunk-MXSSG3QU.js";
+export {
+  registerReplayCommand,
+  replayCommand
+};

package/dist/commands/setup.js

@@ -1,7 +1,7 @@
 import {
   setupCommand
-} from "../chunk-PIJGYMQZ.js";
-import "../chunk-MIIXBNO3.js";
+} from "../chunk-W463YRED.js";
+import "../chunk-FDJIZKCW.js";
 export {
   setupCommand
 };

package/dist/commands/sleep.d.ts

@@ -13,6 +13,7 @@ interface SleepOptions {
     index?: boolean;
     git?: boolean;
     sessionTranscript?: string;
+    reflect?: boolean;
     prompt?: PromptFn;
     cwd?: string;
 }

package/dist/commands/sleep.js

@@ -1,17 +1,25 @@
 import {
-  Observer,
   parseSessionFile
-} from "../chunk-5MQB7B37.js";
+} from "../chunk-P5EPF6MB.js";
+import {
+  Observer
+} from "../chunk-2HM7ZI4X.js";
+import {
+  runReflection
+} from "../chunk-GQVYQCY5.js";
+import "../chunk-MQUJNOHK.js";
 import {
   clearDirtyFlag
 } from "../chunk-MZZJLQNQ.js";
+import "../chunk-K6XHCUFL.js";
+import "../chunk-Z2XBWN7A.js";
 import {
   ClawVault
-} from "../chunk-QFBKWDYR.js";
+} from "../chunk-OTQW3OMC.js";
 import {
   qmdUpdate
-} from "../chunk-MIIXBNO3.js";
-import "../chunk-O5V7SD5C.js";
+} from "../chunk-FDJIZKCW.js";
+import "../chunk-ZZA73MFY.js";
 
 // src/commands/sleep.ts
 import * as fs from "fs";
@@ -177,12 +185,27 @@ async function sleep(options) {
     if (transcriptPath) {
       const observer = new Observer(vault.getPath());
       const messages = parseSessionFile(transcriptPath);
-      await observer.processMessages(messages);
+      const transcriptStat = fs.statSync(transcriptPath);
+      await observer.processMessages(messages, {
+        source: "openclaw",
+        transcriptId: path.basename(transcriptPath),
+        timestamp: transcriptStat.mtime
+      });
       const { routingSummary } = await observer.flush();
       observationRoutingSummary = routingSummary || void 0;
     }
   } catch {
   }
+  if (options.reflect) {
+    try {
+      await runReflection({
+        vaultPath: vault.getPath(),
+        days: 14,
+        dryRun: false
+      });
+    } catch {
+    }
+  }
   return { handoff, document, git, observationRoutingSummary };
 }
 export {

package/dist/commands/status.js

@@ -1,20 +1,20 @@
+import {
+  scanVaultLinks
+} from "../chunk-4VQTUVH7.js";
 import {
   formatAge
 } from "../chunk-7ZRP733D.js";
 import {
   ClawVault
-} from "../chunk-QFBKWDYR.js";
+} from "../chunk-OTQW3OMC.js";
 import {
   QmdUnavailableError,
   hasQmd
-} from "../chunk-MIIXBNO3.js";
-import {
-  scanVaultLinks
-} from "../chunk-4VQTUVH7.js";
+} from "../chunk-FDJIZKCW.js";
 import "../chunk-J7ZWCI2C.js";
 import {
   loadMemoryGraphIndex
-} from "../chunk-O5V7SD5C.js";
+} from "../chunk-ZZA73MFY.js";
 
 // src/commands/status.ts
 import * as fs from "fs";

package/dist/commands/sync-bd.d.ts

@@ -0,0 +1,10 @@
+import { Command } from 'commander';
+
+interface SyncBdCommandOptions {
+    vaultPath?: string;
+    dryRun?: boolean;
+}
+declare function syncBdCommand(options: SyncBdCommandOptions): Promise<void>;
+declare function registerSyncBdCommand(program: Command): void;
+
+export { type SyncBdCommandOptions, registerSyncBdCommand, syncBdCommand };

package/dist/commands/sync-bd.js

@@ -0,0 +1,9 @@
+import {
+  registerSyncBdCommand,
+  syncBdCommand
+} from "../chunk-MGDEINGP.js";
+import "../chunk-MXSSG3QU.js";
+export {
+  registerSyncBdCommand,
+  syncBdCommand
+};