clawvault 3.0.0 → 3.2.0

package/dist/cli/index.d.cts

@@ -1,5 +0,0 @@
-import { Command } from 'commander';
-
-declare function registerCliCommands(program: Command): Command;
-
-export { registerCliCommands };

package/dist/commands/archive.cjs

@@ -1,287 +0,0 @@
-"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/archive.ts
-var archive_exports = {};
-__export(archive_exports, {
-  archiveCommand: () => archiveCommand,
-  registerArchiveCommand: () => registerArchiveCommand
-});
-module.exports = __toCommonJS(archive_exports);
-
-// 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/observer/archive.ts
-var fs3 = __toESM(require("fs"), 1);
-
-// 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 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) {
-  fs2.mkdirSync(dirPath, { recursive: true });
-}
-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 getArchiveObservationPath(vaultPath, date) {
-  const dateKey = normalizeDateKey(date);
-  const [year, month, day] = dateKey.split("-");
-  return path2.join(getArchiveObservationsRoot(vaultPath), year, month, `${day}.md`);
-}
-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));
-}
-function ensureParentDir(filePath) {
-  ensureDir(path2.dirname(filePath));
-}
-
-// src/observer/archive.ts
-function archiveObservations(vaultPath, options = {}) {
-  const olderThanDays = Number.isFinite(options.olderThanDays) ? Math.max(1, Math.floor(options.olderThanDays)) : 14;
-  const dryRun = options.dryRun ?? false;
-  const now = options.now ?? (() => /* @__PURE__ */ new Date());
-  const today = new Date(now());
-  today.setUTCHours(0, 0, 0, 0);
-  const cutoff = new Date(today);
-  cutoff.setUTCDate(today.getUTCDate() - olderThanDays);
-  const cutoffKey = cutoff.toISOString().slice(0, 10);
-  const files = listObservationFiles(vaultPath, {
-    includeLegacy: true,
-    includeArchive: false,
-    dedupeByDate: true
-  });
-  let archived = 0;
-  let skipped = 0;
-  const archivedDates = [];
-  for (const file of files) {
-    if (file.date >= cutoffKey) {
-      continue;
-    }
-    const archivePath = getArchiveObservationPath(vaultPath, file.date);
-    if (dryRun) {
-      archived += 1;
-      archivedDates.push(file.date);
-      continue;
-    }
-    ensureParentDir(archivePath);
-    fs3.copyFileSync(file.path, archivePath);
-    if (file.path !== archivePath) {
-      fs3.rmSync(file.path, { force: true });
-    } else {
-      skipped += 1;
-      continue;
-    }
-    archived += 1;
-    archivedDates.push(file.date);
-  }
-  return {
-    scanned: files.length,
-    archived,
-    skipped,
-    dryRun,
-    archivedDates
-  };
-}
-
-// 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
-    });
-  });
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  archiveCommand,
-  registerArchiveCommand
-});

package/dist/commands/archive.d.cts

@@ -1,11 +0,0 @@
-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 };