clawvault 3.1.0 → 3.2.1

package/dist/{chunk-LNJA2UGL.js → chunk-PI4WMLMG.js}

@@ -1,6 +1,6 @@
 import {
   Observer
-} from "./chunk-3NSBOUT3.js";
+} from "./chunk-Y3TIJEBP.js";
 import {
   getSessionsDir
 } from "./chunk-HRLWZGMA.js";
@@ -18,11 +18,6 @@ var AGENT_ID_RE = /^[a-zA-Z0-9_-]{1,100}$/;
 var SESSION_ID_RE = /^[a-zA-Z0-9._-]{1,200}$/;
 var CURSOR_FILE_NAME = "observe-cursors.json";
 var STALE_CURSOR_THRESHOLD_MS = 12 * 60 * 60 * 1e3;
-function formatBytes(bytes) {
-  if (bytes >= ONE_MIB) return `${(bytes / ONE_MIB).toFixed(1)}MB`;
-  if (bytes >= ONE_KIB) return `${Math.round(bytes / ONE_KIB)}KB`;
-  return `${bytes}B`;
-}
 function isFiniteNonNegative(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0;
 }
@@ -158,12 +153,7 @@ function getObserverStaleness(vaultPath, options = {}) {
     if (!sessionStat.isFile()) {
       continue;
     }
-    const newBytes = sessionStat.size - cursor.lastFileSize;
-    if (newBytes <= 0) {
-      continue;
-    }
-    const processThreshold = getScaledObservationThresholdBytes(sessionStat.size);
-    if (newBytes < processThreshold) {
+    if (cursor.lastFileSize >= sessionStat.size) {
       continue;
     }
     staleCount += 1;
@@ -191,32 +181,8 @@ function loadSessionIndex(sessionsDir) {
     return {};
   }
 }
-function findMostRecentResetFile(sessionsDir, sessionId) {
-  const prefix = `${sessionId}.jsonl.reset.`;
-  try {
-    const files = fs.readdirSync(sessionsDir).filter((f) => f.startsWith(prefix)).sort().reverse();
-    return files.length > 0 ? path.join(sessionsDir, files[0]) : null;
-  } catch {
-    return null;
-  }
-}
 function resolveTranscriptPath(sessionsDir, sessionId) {
-  const mainPath = path.join(sessionsDir, `${sessionId}.jsonl`);
-  try {
-    const stat = fs.statSync(mainPath);
-    if (stat.size < 100) {
-      const resetFile = findMostRecentResetFile(sessionsDir, sessionId);
-      if (resetFile) {
-        return resetFile;
-      }
-    }
-  } catch {
-    const resetFile = findMostRecentResetFile(sessionsDir, sessionId);
-    if (resetFile) {
-      return resetFile;
-    }
-  }
-  return mainPath;
+  return path.join(sessionsDir, `${sessionId}.jsonl`);
 }
 function discoverSessionDescriptors(sessionsDir, fallbackAgentId) {
   const descriptors = [];
@@ -293,21 +259,6 @@ function normalizeRole(role) {
   }
   return role.trim().toLowerCase();
 }
-function summarizeContentArray(content) {
-  const parts = [];
-  for (const block of content) {
-    if (!block || typeof block !== "object") continue;
-    const b = block;
-    if (b.type === "text" && typeof b.text === "string") {
-      const text = normalizeWhitespace(b.text);
-      if (text) parts.push(text);
-    } else if (b.type === "toolCall") {
-      const toolName = typeof b.name === "string" ? b.name : "tool";
-      parts.push(`[tool: ${toolName}]`);
-    }
-  }
-  return parts.join(" ");
-}
 function parseOpenClawJsonLine(line) {
   if (!line.trim()) {
     return "";
@@ -324,38 +275,14 @@ function parseOpenClawJsonLine(line) {
   const entry = parsed;
   if ("role" in entry && "content" in entry) {
     const role = normalizeRole(entry.role);
-    if (role === "system") return "";
-    if (role === "toolresult") {
-      const output = extractContentText(entry.content);
-      const preview = output.slice(0, 80) || "ok";
-      return `[tool_result \u2192 ${preview}]`;
-    }
-    const raw = entry.content;
-    let content;
-    if (Array.isArray(raw)) {
-      content = summarizeContentArray(raw);
-    } else {
-      content = extractContentText(raw);
-    }
+    const content = extractContentText(entry.content);
     if (!content) return "";
     return role ? `${role}: ${content}` : content;
   }
   if (entry.type === "message" && entry.message && typeof entry.message === "object") {
     const message = entry.message;
     const role = normalizeRole(message.role);
-    if (role === "system") return "";
-    if (role === "toolresult") {
-      const output = extractContentText(message.content);
-      const preview = output.slice(0, 80) || "ok";
-      return `[tool_result \u2192 ${preview}]`;
-    }
-    const raw = message.content;
-    let content;
-    if (Array.isArray(raw)) {
-      content = summarizeContentArray(raw);
-    } else {
-      content = extractContentText(raw);
-    }
+    const content = extractContentText(message.content);
     if (!content) return "";
     return role ? `${role}: ${content}` : content;
   }
@@ -518,9 +445,7 @@ async function observeActiveSessions(options, dependencies = {}) {
   const now = dependencies.now ?? (() => /* @__PURE__ */ new Date());
   const cursors = loadObserveCursorStore(vaultPath);
   const descriptors = discoverSessionDescriptors(sessionsDir, agentId);
-  const allCandidates = selectCandidates(descriptors, cursors, options.minNewBytes);
-  allCandidates.sort((a, b) => b.newBytes - a.newBytes);
-  const candidates = options.maxSessions != null && options.maxSessions > 0 ? allCandidates.slice(0, options.maxSessions) : allCandidates;
+  const candidates = selectCandidates(descriptors, cursors, options.minNewBytes);
   if (dryRun || candidates.length === 0) {
     return {
       agentId,
@@ -550,9 +475,7 @@ async function observeActiveSessions(options, dependencies = {}) {
   let observedNewBytes = 0;
   const routedCounts = {};
   const failedSessions = [];
-  for (let i = 0; i < candidates.length; i += 1) {
-    const candidate = candidates[i];
-    console.log(`[observer] processing session ${i + 1}/${candidates.length}: ${candidate.sessionKey} (${formatBytes(candidate.newBytes)} new)`);
+  for (const candidate of candidates) {
     try {
       const observer = observerFactory(vaultPath, observerOptions);
       const { messages, nextOffset } = await readIncrementalMessages(candidate.filePath, candidate.startOffset);

package/dist/chunk-QMHPQYUV.js

@@ -0,0 +1,363 @@
+import {
+  hasQmd,
+  withQmdIndexArgs
+} from "./chunk-5PJ4STIC.js";
+import {
+  DEFAULT_CATEGORIES
+} from "./chunk-2CDEETQN.js";
+
+// src/commands/setup.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { execFileSync } from "child_process";
+var CONFIG_FILE = ".clawvault.json";
+function resolveVaultTarget(vaultOverride) {
+  if (vaultOverride) {
+    const vaultPath = path.resolve(vaultOverride);
+    return { vaultPath, source: "--vault flag", existed: fs.existsSync(vaultPath) };
+  }
+  const envPath = process.env.CLAWVAULT_PATH?.trim();
+  const home = os.homedir();
+  if (envPath) {
+    const vaultPath = path.resolve(envPath);
+    return { vaultPath, source: "CLAWVAULT_PATH", existed: fs.existsSync(vaultPath) };
+  }
+  const candidates = [
+    { vaultPath: path.join(home, ".openclaw", "workspace", "memory"), source: "OpenClaw default" },
+    { vaultPath: path.resolve(process.cwd(), "memory"), source: "./memory" },
+    { vaultPath: path.join(home, "memory"), source: "~/memory" }
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate.vaultPath)) {
+      return { ...candidate, existed: true };
+    }
+  }
+  const fallback = candidates[0];
+  return { ...fallback, existed: false };
+}
+function ensureVaultStructure(vaultPath) {
+  fs.mkdirSync(vaultPath, { recursive: true });
+  for (const category of DEFAULT_CATEGORIES) {
+    fs.mkdirSync(path.join(vaultPath, category), { recursive: true });
+  }
+  const configPath = path.join(vaultPath, CONFIG_FILE);
+  if (fs.existsSync(configPath)) return false;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const name = path.basename(vaultPath);
+  const meta = {
+    name,
+    version: "1.0.0",
+    created: now,
+    lastUpdated: now,
+    categories: DEFAULT_CATEGORIES,
+    documentCount: 0,
+    qmdCollection: name,
+    qmdRoot: vaultPath
+  };
+  fs.writeFileSync(configPath, JSON.stringify(meta, null, 2));
+  return true;
+}
+function writeBases(vaultPath, force) {
+  const basesFiles = {
+    "all-tasks.base": `filters:
+  and:
+    - file.inFolder("tasks")
+    - status != "done"
+formulas:
+  age: (now() - file.ctime).days
+  status_icon: if(status == "blocked", "\u{1F534}", if(status == "in-progress", "\u{1F528}", if(status == "open", "\u26AA", "\u2705")))
+views:
+  - type: table
+    name: All Active Tasks
+    groupBy:
+      property: status
+      direction: ASC
+    order:
+      - formula.status_icon
+      - file.name
+      - status
+      - owner
+      - project
+      - priority
+      - blocked_by
+      - formula.age
+  - type: cards
+    name: Task Board
+    groupBy:
+      property: status
+      direction: ASC
+    order:
+      - file.name
+      - owner
+      - project
+      - priority`,
+    "blocked.base": `filters:
+  and:
+    - file.inFolder("tasks")
+    - status == "blocked"
+formulas:
+  days_blocked: (now() - file.ctime).days
+views:
+  - type: table
+    name: Blocked Tasks
+    order:
+      - file.name
+      - owner
+      - project
+      - blocked_by
+      - formula.days_blocked
+      - priority`,
+    "by-project.base": `filters:
+  and:
+    - file.inFolder("tasks")
+    - status != "done"
+formulas:
+  status_icon: if(status == "blocked", "\u{1F534}", if(status == "in-progress", "\u{1F528}", "\u26AA"))
+views:
+  - type: table
+    name: By Project
+    groupBy:
+      property: project
+      direction: ASC
+    order:
+      - formula.status_icon
+      - file.name
+      - status
+      - owner
+      - priority
+  - type: cards
+    name: Project Cards
+    groupBy:
+      property: project
+      direction: ASC
+    order:
+      - file.name
+      - owner
+      - status`,
+    "by-owner.base": `filters:
+  and:
+    - file.inFolder("tasks")
+    - status != "done"
+views:
+  - type: table
+    name: By Owner
+    groupBy:
+      property: owner
+      direction: ASC
+    order:
+      - file.name
+      - status
+      - project
+      - priority`,
+    "backlog.base": `filters:
+  and:
+    - file.inFolder("backlog")
+views:
+  - type: table
+    name: Backlog
+    order:
+      - file.name
+      - source
+      - project
+      - file.ctime`
+  };
+  let written = 0;
+  for (const [filename, content] of Object.entries(basesFiles)) {
+    const filePath = path.join(vaultPath, filename);
+    if (force || !fs.existsSync(filePath)) {
+      fs.writeFileSync(filePath, content);
+      written++;
+    }
+  }
+  return written;
+}
+var NEURAL_GRAPH_CSS = `/* ClawVault Graph Colors \u2014 Neural Neural Style */
+/* Auto-generated by \`clawvault setup --theme neural\` */
+
+body.theme-dark .graph-view .graph-view-container { background-color: #0a0a0a; }
+
+body.theme-dark .graph-view .node.tag-person circle { fill: #00b4d8 !important; }
+body.theme-dark .graph-view .node.tag-project circle { fill: #2d6a4f !important; }
+body.theme-dark .graph-view .node.tag-decision circle { fill: #e8590c !important; }
+body.theme-dark .graph-view .node.tag-lesson circle { fill: #fcc419 !important; }
+body.theme-dark .graph-view .node.tag-commitment circle { fill: #e03131 !important; }
+body.theme-dark .graph-view .node.tag-task circle { fill: #22b8cf !important; }
+body.theme-dark .graph-view .node.tag-observation circle { fill: #7950f2 !important; }
+body.theme-dark .graph-view .node.tag-handoff circle { fill: #845ef7 !important; }
+body.theme-dark .graph-view .node.tag-daily circle { fill: #495057 !important; }
+
+body.theme-dark .graph-view .node.is-focused circle {
+  fill: #e8a430 !important; stroke: #e8a430 !important;
+  stroke-width: 3px; filter: drop-shadow(0 0 6px #e8a430);
+}
+
+body.theme-dark .graph-view .link { stroke: rgba(45, 200, 120, 0.15) !important; }
+body.theme-dark .graph-view .link.is-focused { stroke: rgba(45, 200, 120, 0.6) !important; }
+body.theme-dark .graph-view .node text { fill: #c1c2c5 !important; font-size: 0.8em; }
+`;
+var MINIMAL_GRAPH_CSS = `/* ClawVault Graph Colors \u2014 Minimal */
+/* Auto-generated by \`clawvault setup --theme minimal\` */
+
+body.theme-dark .graph-view .node.tag-person circle { fill: #4a90e8 !important; }
+body.theme-dark .graph-view .node.tag-project circle { fill: #4ae85d !important; }
+body.theme-dark .graph-view .node.tag-decision circle { fill: #e85d4a !important; }
+body.theme-dark .graph-view .node.tag-lesson circle { fill: #9b59b6 !important; }
+body.theme-dark .graph-view .node.tag-task circle { fill: #e8a430 !important; }
+`;
+var NEURAL_COLOR_GROUPS = [
+  { query: "path:people", color: { a: 1, rgb: 47316 } },
+  { query: "path:projects", color: { a: 1, rgb: 2976335 } },
+  { query: "path:decisions", color: { a: 1, rgb: 15227916 } },
+  { query: "path:lessons", color: { a: 1, rgb: 16565273 } },
+  { query: "path:tasks", color: { a: 1, rgb: 2275535 } },
+  { query: "path:commitments", color: { a: 1, rgb: 14680369 } },
+  { query: "path:backlog", color: { a: 1, rgb: 9806262 } },
+  { query: "path:inbox", color: { a: 1, rgb: 15964178 } },
+  { query: "path:handoffs", color: { a: 1, rgb: 8675063 } },
+  { query: "path:ledger", color: { a: 1, rgb: 7950066 } }
+];
+var MINIMAL_COLOR_GROUPS = [
+  { query: "path:people", color: { a: 1, rgb: 4886760 } },
+  { query: "path:projects", color: { a: 1, rgb: 4909149 } },
+  { query: "path:decisions", color: { a: 1, rgb: 15228234 } },
+  { query: "path:lessons", color: { a: 1, rgb: 10181046 } },
+  { query: "path:tasks", color: { a: 1, rgb: 15246384 } }
+];
+function writeGraphColors(vaultPath, theme, force) {
+  const obsidianDir = path.join(vaultPath, ".obsidian");
+  if (!fs.existsSync(obsidianDir)) {
+    return false;
+  }
+  const snippetsDir = path.join(obsidianDir, "snippets");
+  fs.mkdirSync(snippetsDir, { recursive: true });
+  const snippetName = "clawvault-graph";
+  const snippetPath = path.join(snippetsDir, `${snippetName}.css`);
+  if (!force && fs.existsSync(snippetPath)) {
+    return false;
+  }
+  const css = theme === "neural" ? NEURAL_GRAPH_CSS : MINIMAL_GRAPH_CSS;
+  fs.writeFileSync(snippetPath, css);
+  const appearancePath = path.join(obsidianDir, "appearance.json");
+  let appearance = {};
+  if (fs.existsSync(appearancePath)) {
+    try {
+      appearance = JSON.parse(fs.readFileSync(appearancePath, "utf-8"));
+    } catch {
+    }
+  }
+  const snippets = appearance.enabledCssSnippets || [];
+  if (!snippets.includes(snippetName)) {
+    snippets.push(snippetName);
+    appearance.enabledCssSnippets = snippets;
+    fs.writeFileSync(appearancePath, JSON.stringify(appearance, null, 2));
+  }
+  const graphPath = path.join(obsidianDir, "graph.json");
+  let graphConfig = {};
+  if (fs.existsSync(graphPath)) {
+    try {
+      graphConfig = JSON.parse(fs.readFileSync(graphPath, "utf-8"));
+    } catch {
+    }
+  }
+  graphConfig.colorGroups = theme === "neural" ? NEURAL_COLOR_GROUPS : MINIMAL_COLOR_GROUPS;
+  if (theme === "neural") {
+    graphConfig.showTags = false;
+    graphConfig.showAttachments = false;
+    graphConfig.nodeSizeMultiplier = 1.2;
+    graphConfig.lineSizeMultiplier = 0.8;
+    graphConfig.textFadeMultiplier = 0;
+    graphConfig.repelStrength = 10;
+    graphConfig.linkDistance = 250;
+    graphConfig.centerStrength = 0.5;
+  }
+  fs.writeFileSync(graphPath, JSON.stringify(graphConfig, null, 2));
+  return true;
+}
+function getQmdConfig(vaultPath) {
+  const configPath = path.join(vaultPath, CONFIG_FILE);
+  if (fs.existsSync(configPath)) {
+    try {
+      const meta = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      return {
+        collection: meta.qmdCollection || meta.name || path.basename(vaultPath),
+        root: meta.qmdRoot || vaultPath
+      };
+    } catch {
+      return { collection: path.basename(vaultPath), root: vaultPath };
+    }
+  }
+  return { collection: path.basename(vaultPath), root: vaultPath };
+}
+async function setupCommand(options = {}) {
+  const target = resolveVaultTarget(options.vault);
+  if (target.existed && !fs.statSync(target.vaultPath).isDirectory()) {
+    throw new Error(`Vault path is not a directory: ${target.vaultPath}`);
+  }
+  if (!target.existed) fs.mkdirSync(target.vaultPath, { recursive: true });
+  console.log(`${target.existed ? "Found" : "Created"} vault path (${target.source}): ${target.vaultPath}`);
+  const initialized = ensureVaultStructure(target.vaultPath);
+  console.log(initialized ? "\u2713 Initialized vault structure." : "\u2713 Vault structure already present.");
+  const force = options.force ?? false;
+  const theme = options.theme ?? "neural";
+  const explicitFlags = options.graphColors !== void 0 || options.bases !== void 0 || options.canvas !== void 0;
+  const doGraphColors = explicitFlags ? options.graphColors !== false : true;
+  const doBases = explicitFlags ? options.bases !== false : true;
+  const doCanvas = explicitFlags ? options.canvas !== void 0 && options.canvas !== false : false;
+  if (doGraphColors && theme !== "none") {
+    const wrote = writeGraphColors(target.vaultPath, theme, force);
+    if (wrote) {
+      console.log(`\u2713 Graph colors configured (${theme} theme)`);
+    } else {
+      const obsidianDir = path.join(target.vaultPath, ".obsidian");
+      if (!fs.existsSync(obsidianDir)) {
+        console.log("\u2298 No .obsidian directory \u2014 skipping graph colors (not an Obsidian vault)");
+      } else {
+        console.log("\u2298 Graph colors already exist (use --force to overwrite)");
+      }
+    }
+  } else if (doGraphColors && theme === "none") {
+    console.log("\u2298 Graph colors skipped (--theme none)");
+  }
+  if (doBases) {
+    const count = writeBases(target.vaultPath, force);
+    if (count > 0) {
+      console.log(`\u2713 Created ${count} Obsidian Bases view${count > 1 ? "s" : ""}`);
+    } else {
+      console.log("\u2298 Bases views already exist (use --force to overwrite)");
+    }
+  }
+  if (doCanvas) {
+    try {
+      const { canvasCommand } = await import("./commands/canvas.js");
+      await canvasCommand(target.vaultPath);
+    } catch (err) {
+      console.log(`\u26A0 Canvas generation failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  if (hasQmd()) {
+    const { collection, root } = getQmdConfig(target.vaultPath);
+    try {
+      execFileSync("qmd", withQmdIndexArgs(["collection", "add", root, "--name", collection, "--mask", "**/*.md"], options.qmdIndexName), {
+        stdio: "ignore"
+      });
+      console.log(`\u2713 qmd collection ready: ${collection}`);
+    } catch {
+      console.log("\u2298 qmd collection already exists.");
+    }
+  } else {
+    console.log("\u2298 qmd not found \u2014 skipping semantic search setup.");
+  }
+  console.log("\nTip: add this to your shell config:");
+  console.log(`  export CLAWVAULT_PATH="${target.vaultPath}"`);
+  console.log("\nCustomize further:");
+  console.log("  clawvault setup --theme neural     # Neural neural graph colors");
+  console.log("  clawvault setup --theme minimal        # Subtle category colors");
+  console.log("  clawvault setup --canvas                # Generate vault status canvas");
+  console.log("  clawvault setup --no-bases --no-graph-colors  # Structure only");
+  console.log("  clawvault setup --force                 # Overwrite existing configs");
+}
+
+export {
+  setupCommand
+};