clawvault 2.6.0 → 3.0.0

package/dist/commands/doctor.d.cts

@@ -0,0 +1,21 @@
+type DoctorStatus = 'ok' | 'warn' | 'error';
+interface DoctorCheck {
+    label: string;
+    status: DoctorStatus;
+    detail?: string;
+    hint?: string;
+}
+interface DoctorReport {
+    vaultPath?: string;
+    qmdCollection?: string;
+    qmdRoot?: string;
+    checks: DoctorCheck[];
+    warnings: number;
+    errors: number;
+}
+declare function doctor(options?: string | {
+    vaultPath?: string;
+    fix?: boolean;
+}): Promise<DoctorReport>;
+
+export { type DoctorCheck, type DoctorReport, type DoctorStatus, doctor };

package/dist/commands/doctor.d.ts

@@ -7,10 +7,15 @@ interface DoctorCheck {
 }
 interface DoctorReport {
     vaultPath?: string;
+    qmdCollection?: string;
+    qmdRoot?: string;
     checks: DoctorCheck[];
     warnings: number;
     errors: number;
 }
-declare function doctor(vaultPath?: string): Promise<DoctorReport>;
+declare function doctor(options?: string | {
+    vaultPath?: string;
+    fix?: boolean;
+}): Promise<DoctorReport>;
 
 export { type DoctorCheck, type DoctorReport, type DoctorStatus, doctor };

package/dist/commands/doctor.js

@@ -1,24 +1,26 @@
 import {
   doctor
-} from "../chunk-UEOUADMO.js";
+} from "../chunk-YKTA5JOJ.js";
 import "../chunk-7ZRP733D.js";
 import "../chunk-4VQTUVH7.js";
 import "../chunk-J7ZWCI2C.js";
-import "../chunk-IEVLHNLU.js";
+import "../chunk-LNJA2UGL.js";
+import "../chunk-3NSBOUT3.js";
+import "../chunk-62YTUT6J.js";
 import "../chunk-HRLWZGMA.js";
-import "../chunk-Q2J5YTUF.js";
-import "../chunk-AZYOKJYC.js";
-import "../chunk-KL4NAOMO.js";
-import "../chunk-FHFUXL6G.js";
-import "../chunk-MAKNAHAW.js";
 import "../chunk-ITPEXLHA.js";
+import "../chunk-PAH27GSN.js";
+import "../chunk-N2AXRYLC.js";
+import "../chunk-LYHGEHXG.js";
+import "../chunk-7766SIJP.js";
+import "../chunk-3D6BCTP6.js";
+import "../chunk-WGRQ6HDV.js";
+import "../chunk-K234IDRJ.js";
 import "../chunk-2CDEETQN.js";
 import "../chunk-ZZA73MFY.js";
+import "../chunk-QK3UCXWL.js";
 import "../chunk-Z2XBWN7A.js";
-import "../chunk-QWQ3TIKS.js";
-import "../chunk-MFAWT5O5.js";
-import "../chunk-7766SIJP.js";
-import "../chunk-QVMXF7FY.js";
+import "../chunk-3RG5ZIWI.js";
 export {
   doctor
 };

package/dist/commands/embed.cjs

@@ -0,0 +1,232 @@
+"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/embed.ts
+var embed_exports = {};
+__export(embed_exports, {
+  embedCommand: () => embedCommand,
+  registerEmbedCommand: () => registerEmbedCommand
+});
+module.exports = __toCommonJS(embed_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/lib/search.ts
+var import_child_process = require("child_process");
+var QMD_INSTALL_COMMAND = "bun install -g github:tobi/qmd";
+var QMD_NOT_INSTALLED_MESSAGE = `ClawVault requires qmd. Install: ${QMD_INSTALL_COMMAND}`;
+var QMD_INDEX_ENV_VAR = "CLAWVAULT_QMD_INDEX";
+var QmdUnavailableError = class extends Error {
+  constructor(message = QMD_NOT_INSTALLED_MESSAGE) {
+    super(message);
+    this.name = "QmdUnavailableError";
+  }
+};
+function resolveQmdIndexName(indexName) {
+  const explicit = indexName?.trim();
+  if (explicit) {
+    return explicit;
+  }
+  const fromEnv = process.env[QMD_INDEX_ENV_VAR]?.trim();
+  return fromEnv || void 0;
+}
+function withQmdIndexArgs(args, indexName) {
+  if (args.includes("--index")) {
+    return [...args];
+  }
+  const resolvedIndexName = resolveQmdIndexName(indexName);
+  if (!resolvedIndexName) {
+    return [...args];
+  }
+  return ["--index", resolvedIndexName, ...args];
+}
+function ensureQmdAvailable() {
+  if (!hasQmd()) {
+    throw new QmdUnavailableError();
+  }
+}
+function hasQmd() {
+  const result = (0, import_child_process.spawnSync)("qmd", ["--version"], { stdio: "ignore" });
+  return !result.error;
+}
+function qmdEmbed(collection, indexName) {
+  ensureQmdAvailable();
+  const args = ["embed"];
+  if (collection) {
+    args.push("-c", collection);
+  }
+  (0, import_child_process.execFileSync)("qmd", withQmdIndexArgs(args, indexName), { stdio: "inherit" });
+}
+var MONTH_NAMES = {
+  january: 1,
+  february: 2,
+  march: 3,
+  april: 4,
+  may: 5,
+  june: 6,
+  july: 7,
+  august: 8,
+  september: 9,
+  october: 10,
+  november: 11,
+  december: 12,
+  jan: 1,
+  feb: 2,
+  mar: 3,
+  apr: 4,
+  jun: 6,
+  jul: 7,
+  aug: 8,
+  sep: 9,
+  sept: 9,
+  oct: 10,
+  nov: 11,
+  dec: 12
+};
+var MONTH_RE_PART = Object.keys(MONTH_NAMES).join("|");
+var DATE_MONTH_DAY_YEAR_RE = new RegExp(
+  `\\b(${MONTH_RE_PART})\\s+(\\d{1,2})(?:st|nd|rd|th)?,?\\s*(\\d{4})\\b`,
+  "gi"
+);
+var DATE_DAY_MONTH_YEAR_RE = new RegExp(
+  `\\b(\\d{1,2})(?:st|nd|rd|th)?\\s+(${MONTH_RE_PART}),?\\s*(\\d{4})\\b`,
+  "gi"
+);
+var DATE_MONTH_DAY_RE = new RegExp(
+  `\\b(${MONTH_RE_PART})\\s+(\\d{1,2})(?:st|nd|rd|th)?\\b`,
+  "gi"
+);
+
+// src/lib/vault-qmd-config.ts
+var fs2 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+var CONFIG_FILE = ".clawvault.json";
+function readTrimmedString(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function loadVaultQmdConfig(vaultPath) {
+  const resolvedVaultPath = path2.resolve(vaultPath);
+  const fallbackName = path2.basename(resolvedVaultPath);
+  const fallbackRoot = resolvedVaultPath;
+  const configPath = path2.join(resolvedVaultPath, CONFIG_FILE);
+  if (!fs2.existsSync(configPath)) {
+    return {
+      vaultPath: resolvedVaultPath,
+      qmdCollection: fallbackName,
+      qmdRoot: fallbackRoot
+    };
+  }
+  try {
+    const raw = JSON.parse(fs2.readFileSync(configPath, "utf-8"));
+    const configuredName = readTrimmedString(raw.name) ?? fallbackName;
+    const qmdCollection = readTrimmedString(raw.qmdCollection) ?? configuredName;
+    const rawRoot = readTrimmedString(raw.qmdRoot) ?? fallbackRoot;
+    const qmdRoot = path2.isAbsolute(rawRoot) ? path2.resolve(rawRoot) : path2.resolve(resolvedVaultPath, rawRoot);
+    return {
+      vaultPath: resolvedVaultPath,
+      qmdCollection,
+      qmdRoot
+    };
+  } catch {
+    return {
+      vaultPath: resolvedVaultPath,
+      qmdCollection: fallbackName,
+      qmdRoot: fallbackRoot
+    };
+  }
+}
+
+// src/commands/embed.ts
+async function embedCommand(options = {}) {
+  if (!hasQmd()) {
+    throw new QmdUnavailableError();
+  }
+  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
+  const qmdConfig = loadVaultQmdConfig(vaultPath);
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (!options.quiet) {
+    console.log(
+      `Embedding pending documents for collection "${qmdConfig.qmdCollection}" (root: ${qmdConfig.qmdRoot})...`
+    );
+  }
+  qmdEmbed(qmdConfig.qmdCollection);
+  const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (!options.quiet) {
+    console.log(`\u2713 Embedding complete for "${qmdConfig.qmdCollection}"`);
+  }
+  return {
+    vaultPath,
+    qmdCollection: qmdConfig.qmdCollection,
+    qmdRoot: qmdConfig.qmdRoot,
+    startedAt,
+    finishedAt
+  };
+}
+function registerEmbedCommand(program) {
+  program.command("embed").description("Run qmd embedding for pending vault documents").option("-v, --vault <path>", "Vault path").action(async (rawOptions) => {
+    await embedCommand({
+      vaultPath: rawOptions.vault
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  embedCommand,
+  registerEmbedCommand
+});

package/dist/commands/embed.d.cts

@@ -0,0 +1,17 @@
+import { Command } from 'commander';
+
+interface EmbedCommandOptions {
+    vaultPath?: string;
+    quiet?: boolean;
+}
+interface EmbedCommandResult {
+    vaultPath: string;
+    qmdCollection: string;
+    qmdRoot: string;
+    startedAt: string;
+    finishedAt: string;
+}
+declare function embedCommand(options?: EmbedCommandOptions): Promise<EmbedCommandResult>;
+declare function registerEmbedCommand(program: Command): void;
+
+export { type EmbedCommandOptions, type EmbedCommandResult, embedCommand, registerEmbedCommand };

package/dist/commands/embed.js

@@ -1,9 +1,12 @@
 import {
   embedCommand,
   registerEmbedCommand
-} from "../chunk-4QYGFWRM.js";
-import "../chunk-MAKNAHAW.js";
+} from "../chunk-7R7O6STJ.js";
 import "../chunk-MXSSG3QU.js";
+import "../chunk-K234IDRJ.js";
+import "../chunk-QK3UCXWL.js";
+import "../chunk-Z2XBWN7A.js";
+import "../chunk-3RG5ZIWI.js";
 export {
   embedCommand,
   registerEmbedCommand

package/dist/commands/entities.cjs

@@ -0,0 +1,141 @@
+"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/entities.ts
+var entities_exports = {};
+__export(entities_exports, {
+  entitiesCommand: () => entitiesCommand
+});
+module.exports = __toCommonJS(entities_exports);
+
+// src/lib/entity-index.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+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 } = (0, import_gray_matter.default)(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 };
+}
+
+// src/lib/config.ts
+var fs2 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+function findNearestVaultPath(startPath = process.cwd()) {
+  let current = path2.resolve(startPath);
+  while (true) {
+    if (fs2.existsSync(path2.join(current, ".clawvault.json"))) {
+      return current;
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function resolveVaultPath(options = {}) {
+  if (options.explicitPath) {
+    return path2.resolve(options.explicitPath);
+  }
+  if (process.env.CLAWVAULT_PATH) {
+    return path2.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/commands/entities.ts
+async function entitiesCommand(options) {
+  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
+  const index = buildEntityIndex(vaultPath);
+  if (options.json) {
+    const output = {};
+    for (const [path3, entry] of index.byPath) {
+      output[path3] = entry.aliases;
+    }
+    console.log(JSON.stringify(output, null, 2));
+    return;
+  }
+  const byFolder = {};
+  for (const [path3, entry] of index.byPath) {
+    const folder = path3.split("/")[0];
+    if (!byFolder[folder]) byFolder[folder] = [];
+    byFolder[folder].push({ path: path3, 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`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  entitiesCommand
+});

package/dist/commands/entities.d.cts

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

package/dist/commands/entities.js

@@ -4,6 +4,7 @@ import {
 import {
   resolveVaultPath
 } from "../chunk-MXSSG3QU.js";
+import "../chunk-3RG5ZIWI.js";
 
 // src/commands/entities.ts
 async function entitiesCommand(options) {