clawvault 3.0.0 → 3.2.0

package/dist/chunk-MFM6K7PU.js

@@ -1,374 +0,0 @@
-import {
-  classifyText,
-  generateFrontmatter,
-  getSchema,
-  serializeFrontmatter,
-  validateFrontmatter
-} from "./chunk-GQSLDZTS.js";
-import {
-  __require
-} from "./chunk-3RG5ZIWI.js";
-
-// src/plugin/vault.ts
-import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync } from "fs";
-import { join } from "path";
-function writeVaultFile(vaultPath, options) {
-  const errors = [];
-  const primitiveType = options.primitiveType ?? classifyText(options.content ?? options.title ?? "").primitiveType;
-  const schema = getSchema(primitiveType);
-  const frontmatter = generateFrontmatter(primitiveType, {
-    title: options.title,
-    extraFields: options.extraFields,
-    source: options.source,
-    sessionId: options.sessionId
-  });
-  const validation = validateFrontmatter(primitiveType, frontmatter);
-  if (!validation.valid) {
-    errors.push(...validation.errors);
-  }
-  const directory = options.directory ?? getDefaultDirectory(vaultPath, primitiveType);
-  if (!existsSync(directory)) {
-    mkdirSync(directory, { recursive: true });
-  }
-  const filename = options.filename ?? generateFilename(primitiveType, options.title, frontmatter);
-  const filePath = join(directory, filename);
-  const fileExists = existsSync(filePath);
-  if (fileExists && !options.overwrite) {
-    return updateVaultFile(filePath, frontmatter, options.content, primitiveType, errors);
-  }
-  const fileContent = buildFileContent(frontmatter, options.content, schema);
-  try {
-    writeFileSync(filePath, fileContent, "utf-8");
-    return {
-      success: errors.length === 0,
-      path: filePath,
-      primitiveType,
-      errors,
-      created: true,
-      updated: false
-    };
-  } catch (err) {
-    errors.push(`Failed to write file: ${String(err)}`);
-    return {
-      success: false,
-      path: filePath,
-      primitiveType,
-      errors,
-      created: false,
-      updated: false
-    };
-  }
-}
-function updateVaultFile(filePath, newFrontmatter, newContent, primitiveType, errors) {
-  try {
-    const existingContent = readFileSync(filePath, "utf-8");
-    const parsed = parseExistingFile(existingContent);
-    if (!parsed) {
-      errors.push("Failed to parse existing file");
-      return {
-        success: false,
-        path: filePath,
-        primitiveType,
-        errors,
-        created: false,
-        updated: false
-      };
-    }
-    const mergedFrontmatter = {
-      ...parsed.frontmatter,
-      ...newFrontmatter,
-      updated: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    if (parsed.frontmatter.created) {
-      mergedFrontmatter.created = parsed.frontmatter.created;
-    }
-    const content = newContent ?? parsed.body;
-    const schema = getSchema(primitiveType);
-    const fileContent = buildFileContent(mergedFrontmatter, content, schema);
-    writeFileSync(filePath, fileContent, "utf-8");
-    return {
-      success: errors.length === 0,
-      path: filePath,
-      primitiveType,
-      errors,
-      created: false,
-      updated: true
-    };
-  } catch (err) {
-    errors.push(`Failed to update file: ${String(err)}`);
-    return {
-      success: false,
-      path: filePath,
-      primitiveType,
-      errors,
-      created: false,
-      updated: false
-    };
-  }
-}
-function parseExistingFile(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-  if (!match) return null;
-  try {
-    const frontmatter = parseSimpleYaml(match[1]);
-    return { frontmatter, body: match[2] };
-  } catch {
-    return null;
-  }
-}
-function parseSimpleYaml(yaml) {
-  const result = {};
-  const lines = yaml.split("\n");
-  for (const line of lines) {
-    if (!line.trim() || line.trim().startsWith("#")) continue;
-    const colonIndex = line.indexOf(":");
-    if (colonIndex === -1) continue;
-    const key = line.slice(0, colonIndex).trim();
-    const valueStr = line.slice(colonIndex + 1).trim();
-    if (valueStr === "" || valueStr.startsWith("|") || valueStr.startsWith(">")) continue;
-    result[key] = parseYamlValue(valueStr);
-  }
-  return result;
-}
-function parseYamlValue(value) {
-  if (value === "" || value === "null" || value === "~") return null;
-  if (value === "true") return true;
-  if (value === "false") return false;
-  if (/^-?\d+$/.test(value)) return parseInt(value, 10);
-  if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
-  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-    return value.slice(1, -1);
-  }
-  return value;
-}
-function getDefaultDirectory(vaultPath, primitiveType) {
-  const directoryMap = {
-    task: "tasks",
-    project: "projects",
-    decision: "decisions",
-    person: "people",
-    lesson: "lessons",
-    trigger: "triggers",
-    run: "runs",
-    checkpoint: "checkpoints",
-    handoff: "handoffs",
-    "daily-note": "daily",
-    daily: "daily",
-    party: "parties",
-    workspace: "workspaces",
-    memory_event: "memory"
-  };
-  const subdir = directoryMap[primitiveType] ?? "notes";
-  return join(vaultPath, subdir);
-}
-function generateFilename(primitiveType, title, frontmatter) {
-  const now = /* @__PURE__ */ new Date();
-  const dateStr = now.toISOString().split("T")[0];
-  const timeStr = now.toISOString().slice(11, 19).replace(/:/g, "");
-  if (title) {
-    const slug = slugify(title);
-    return `${dateStr}-${slug}.md`;
-  }
-  switch (primitiveType) {
-    case "daily-note":
-    case "daily":
-      return `${dateStr}.md`;
-    case "memory_event":
-      return `${dateStr}-${timeStr}.md`;
-    case "run":
-      return `run-${dateStr}-${timeStr}.md`;
-    case "checkpoint":
-      return `checkpoint-${dateStr}-${timeStr}.md`;
-    case "handoff":
-      return `handoff-${dateStr}-${timeStr}.md`;
-    default:
-      return `${primitiveType}-${dateStr}-${timeStr}.md`;
-  }
-}
-function slugify(text) {
-  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
-}
-function buildFileContent(frontmatter, content, schema) {
-  const parts = [];
-  parts.push(serializeFrontmatter(frontmatter));
-  parts.push("");
-  const title = frontmatter.title || frontmatter.summary;
-  if (title) {
-    parts.push(`# ${title}`);
-    parts.push("");
-  }
-  if (content) {
-    parts.push(content);
-  } else if (schema?.bodyTemplate) {
-    let body = schema.bodyTemplate;
-    body = body.replace(/\{\{title\}\}/g, String(title || "Untitled"));
-    body = body.replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0]);
-    body = body.replace(/\{\{datetime\}\}/g, (/* @__PURE__ */ new Date()).toISOString());
-    body = body.replace(/\{\{links_line\}\}/g, "");
-    body = body.replace(/\{\{content\}\}/g, "");
-    parts.push(body.trim());
-  }
-  return parts.join("\n");
-}
-function writeObservation(vaultPath, observation, options = {}) {
-  return writeVaultFile(vaultPath, {
-    primitiveType: observation.primitiveType,
-    title: observation.text.slice(0, 80),
-    content: observation.text,
-    extraFields: {
-      type: observation.primitiveType === "memory_event" ? observation.category : observation.primitiveType,
-      confidence: observation.confidence,
-      tags: observation.tags,
-      observed_at: observation.extractedAt.toISOString()
-    },
-    source: options.source ?? "openclaw",
-    sessionId: options.sessionId
-  });
-}
-function writeObservations(vaultPath, observations, options = {}) {
-  return observations.map((obs) => writeObservation(vaultPath, obs, options));
-}
-function appendToLedger(vaultPath, entry) {
-  const dateStr = entry.timestamp.toISOString().slice(0, 10);
-  const ledgerDir = join(vaultPath, "ledger");
-  if (!existsSync(ledgerDir)) {
-    mkdirSync(ledgerDir, { recursive: true });
-  }
-  const ledgerFile = join(ledgerDir, `${dateStr}.md`);
-  const timeStr = entry.timestamp.toISOString().slice(11, 19);
-  const parts = [`[${timeStr}]`];
-  if (entry.category) parts.push(`[${entry.category}]`);
-  if (entry.actor) parts.push(`(${entry.actor})`);
-  parts.push(entry.content);
-  const line = `
-- ${parts.join(" ")}`;
-  if (!existsSync(ledgerFile)) {
-    const frontmatter = serializeFrontmatter({
-      type: "ledger",
-      date: dateStr,
-      created: entry.timestamp.toISOString()
-    });
-    writeFileSync(ledgerFile, `${frontmatter}
-
-# Observation Ledger \u2014 ${dateStr}
-${line}`, "utf-8");
-  } else {
-    appendFileSync(ledgerFile, line, "utf-8");
-  }
-}
-function appendObservationToLedger(vaultPath, observation, actor) {
-  appendToLedger(vaultPath, {
-    timestamp: observation.extractedAt,
-    category: observation.category,
-    actor,
-    content: observation.text,
-    primitiveType: observation.primitiveType,
-    tags: observation.tags
-  });
-}
-function batchWriteObservations(vaultPath, observations, options = {}) {
-  const results = [];
-  let successful = 0;
-  let failed = 0;
-  const writeLedger = options.writeLedger ?? true;
-  const writeFiles = options.writeFiles ?? false;
-  for (const observation of observations) {
-    if (writeLedger) {
-      try {
-        appendObservationToLedger(vaultPath, observation, options.actor);
-      } catch {
-      }
-    }
-    if (writeFiles) {
-      const result = writeObservation(vaultPath, observation, {
-        source: options.source,
-        sessionId: options.sessionId
-      });
-      results.push(result);
-      if (result.success) {
-        successful++;
-      } else {
-        failed++;
-      }
-    } else {
-      successful++;
-      results.push({
-        success: true,
-        path: join(vaultPath, "ledger", `${observation.extractedAt.toISOString().slice(0, 10)}.md`),
-        primitiveType: observation.primitiveType,
-        errors: [],
-        created: false,
-        updated: true
-      });
-    }
-  }
-  return {
-    total: observations.length,
-    successful,
-    failed,
-    results
-  };
-}
-function ensureVaultStructure(vaultPath) {
-  const directories = [
-    "tasks",
-    "projects",
-    "decisions",
-    "people",
-    "lessons",
-    "memory",
-    "ledger",
-    "daily"
-  ];
-  for (const dir of directories) {
-    const fullPath = join(vaultPath, dir);
-    if (!existsSync(fullPath)) {
-      mkdirSync(fullPath, { recursive: true });
-    }
-  }
-}
-function getVaultStats(vaultPath) {
-  const directories = [];
-  const primitiveTypes = {};
-  let fileCount = 0;
-  const { readdirSync, statSync } = __require("fs");
-  function scanDir(dir, depth = 0) {
-    if (depth > 2) return;
-    try {
-      const entries = readdirSync(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
-        const fullPath = join(dir, entry.name);
-        if (entry.isDirectory()) {
-          directories.push(fullPath.replace(vaultPath + "/", ""));
-          scanDir(fullPath, depth + 1);
-        } else if (entry.name.endsWith(".md")) {
-          fileCount++;
-          try {
-            const content = readFileSync(fullPath, "utf-8");
-            const match = content.match(/^---\n[\s\S]*?type:\s*(\S+)/);
-            if (match) {
-              const type = match[1];
-              primitiveTypes[type] = (primitiveTypes[type] ?? 0) + 1;
-            }
-          } catch {
-          }
-        }
-      }
-    } catch {
-    }
-  }
-  scanDir(vaultPath);
-  return { directories, fileCount, primitiveTypes };
-}
-
-export {
-  writeVaultFile,
-  writeObservation,
-  writeObservations,
-  appendToLedger,
-  appendObservationToLedger,
-  batchWriteObservations,
-  ensureVaultStructure,
-  getVaultStats
-};

package/dist/chunk-MXSSG3QU.js

@@ -1,42 +0,0 @@
-// src/lib/config.ts
-import * as fs from "fs";
-import * as path from "path";
-function getVaultPath() {
-  const vaultPath = process.env.CLAWVAULT_PATH;
-  if (!vaultPath) {
-    throw new Error("CLAWVAULT_PATH environment variable not set");
-  }
-  return path.resolve(vaultPath);
-}
-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.");
-}
-
-export {
-  getVaultPath,
-  findNearestVaultPath,
-  resolveVaultPath
-};

package/dist/chunk-PAH27GSN.js

@@ -1,108 +0,0 @@
-// src/lib/claude-credentials.ts
-import { execFileSync } from "child_process";
-import { existsSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-var CLAUDE_CODE_SERVICE = "Claude Code-credentials";
-var CLAUDE_CODE_ACCOUNT = "Claude Code";
-var OAUTH_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
-var TOKEN_REFRESH_URL = "https://console.anthropic.com/v1/oauth/token";
-var EXPIRY_BUFFER_MS = 5 * 60 * 1e3;
-function readClaudeCliCredentials(opts) {
-  if (process.platform === "darwin") {
-    try {
-      const raw = execFileSync(
-        "security",
-        ["find-generic-password", "-s", CLAUDE_CODE_SERVICE, "-w"],
-        { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
-      ).trim();
-      const parsed = parseCredentialsJson(raw);
-      if (parsed) return parsed;
-    } catch {
-    }
-  }
-  const home = opts?.homeDir ?? homedir();
-  const credFile = join(home, ".claude", ".credentials.json");
-  if (!existsSync(credFile)) {
-    return null;
-  }
-  try {
-    const raw = readFileSync(credFile, "utf8");
-    return parseCredentialsJson(raw);
-  } catch {
-    return null;
-  }
-}
-function parseCredentialsJson(raw) {
-  try {
-    const parsed = JSON.parse(raw);
-    const oauth = parsed.claudeAiOauth;
-    if (oauth && typeof oauth.accessToken === "string" && typeof oauth.refreshToken === "string" && typeof oauth.expiresAt === "number") {
-      return {
-        accessToken: oauth.accessToken,
-        refreshToken: oauth.refreshToken,
-        expiresAt: oauth.expiresAt
-      };
-    }
-  } catch {
-  }
-  return null;
-}
-async function refreshClaudeOAuthToken(refreshToken, fetchImpl) {
-  const f = fetchImpl ?? fetch;
-  const response = await f(TOKEN_REFRESH_URL, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({
-      grant_type: "refresh_token",
-      client_id: OAUTH_CLIENT_ID,
-      refresh_token: refreshToken
-    })
-  });
-  if (!response.ok) {
-    throw new Error(`OAuth token refresh failed (${response.status})`);
-  }
-  const data = await response.json();
-  return {
-    accessToken: data.access_token,
-    refreshToken: data.refresh_token,
-    expiresAt: Date.now() + data.expires_in * 1e3
-  };
-}
-function writeClaudeCliCredentials(cred, opts) {
-  const payload = JSON.stringify({ claudeAiOauth: cred });
-  if (process.platform === "darwin") {
-    try {
-      execFileSync(
-        "security",
-        ["add-generic-password", "-U", "-s", CLAUDE_CODE_SERVICE, "-a", CLAUDE_CODE_ACCOUNT, "-w", payload],
-        { stdio: "ignore" }
-      );
-      return;
-    } catch {
-    }
-  }
-  const home = opts?.homeDir ?? homedir();
-  const credFile = join(home, ".claude", ".credentials.json");
-  writeFileSync(credFile, payload, "utf8");
-}
-async function resolveClaudeOAuthToken(opts) {
-  const cred = readClaudeCliCredentials(opts);
-  if (!cred) {
-    return null;
-  }
-  if (cred.expiresAt < Date.now() + EXPIRY_BUFFER_MS) {
-    try {
-      const refreshed = await refreshClaudeOAuthToken(cred.refreshToken, opts?.fetchImpl);
-      writeClaudeCliCredentials(refreshed, opts);
-      return refreshed.accessToken;
-    } catch {
-      return cred.accessToken;
-    }
-  }
-  return cred.accessToken;
-}
-
-export {
-  resolveClaudeOAuthToken
-};