clawvault 2.4.6 → 2.5.0

package/dist/chunk-5GZFTAL7.js

@@ -0,0 +1,340 @@
+import {
+  listTasks,
+  slugify
+} from "./chunk-IOALNTAN.js";
+
+// src/lib/project-utils.ts
+import * as fs from "fs";
+import * as path from "path";
+import matter from "gray-matter";
+function extractTitle(content) {
+  const match = content.match(/^#\s+(.+)$/m);
+  return match ? match[1].trim() : "";
+}
+function isDateSlug(slug) {
+  return /^\d{4}-\d{2}-\d{2}$/.test(slug);
+}
+function normalizeStringArray(value) {
+  return value.map((item) => item.trim()).filter(Boolean);
+}
+function getProjectsDir(vaultPath) {
+  return path.join(path.resolve(vaultPath), "projects");
+}
+function ensureProjectsDir(vaultPath) {
+  const projectsDir = getProjectsDir(vaultPath);
+  if (!fs.existsSync(projectsDir)) {
+    fs.mkdirSync(projectsDir, { recursive: true });
+  }
+}
+function getProjectPath(vaultPath, slug) {
+  return path.join(getProjectsDir(vaultPath), `${slug}.md`);
+}
+function parseProjectDateValue(filePath) {
+  const filename = path.basename(filePath, ".md");
+  if (/^\d{4}-\d{2}-\d{2}$/.test(filename)) {
+    const dateTs = Date.parse(`${filename}T00:00:00.000Z`);
+    if (!Number.isNaN(dateTs)) {
+      return dateTs;
+    }
+  }
+  return fs.statSync(filePath).mtime.getTime();
+}
+function parseSortableTimestamp(value) {
+  if (!value) return 0;
+  const timestamp = Date.parse(value);
+  return Number.isNaN(timestamp) ? 0 : timestamp;
+}
+function normalizeProjectStatus(value) {
+  if (value === "active" || value === "paused" || value === "completed" || value === "archived") {
+    return value;
+  }
+  return "active";
+}
+function normalizeProjectFrontmatter(frontmatter) {
+  const normalizedCreated = typeof frontmatter.created === "string" && frontmatter.created ? frontmatter.created : (/* @__PURE__ */ new Date(0)).toISOString();
+  const normalizedUpdated = typeof frontmatter.updated === "string" && frontmatter.updated ? frontmatter.updated : normalizedCreated;
+  const normalized = {
+    ...frontmatter,
+    type: "project",
+    status: normalizeProjectStatus(frontmatter.status),
+    created: normalizedCreated,
+    updated: normalizedUpdated
+  };
+  if (normalized.team) {
+    const team = normalizeStringArray(normalized.team);
+    if (team.length === 0) {
+      delete normalized.team;
+    } else {
+      normalized.team = team;
+    }
+  }
+  if (normalized.tags) {
+    const tags = normalizeStringArray(normalized.tags);
+    if (tags.length === 0) {
+      delete normalized.tags;
+    } else {
+      normalized.tags = tags;
+    }
+  }
+  return normalized;
+}
+function listProjects(vaultPath, filters) {
+  const projectsDir = getProjectsDir(vaultPath);
+  if (!fs.existsSync(projectsDir)) {
+    return [];
+  }
+  const projects = [];
+  const entries = fs.readdirSync(projectsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) {
+      continue;
+    }
+    const slug = entry.name.replace(/\.md$/, "");
+    if (isDateSlug(slug)) {
+      continue;
+    }
+    const project = readProject(vaultPath, slug);
+    if (!project) continue;
+    if (filters) {
+      if (filters.status && project.frontmatter.status !== filters.status) continue;
+      if (filters.owner && project.frontmatter.owner !== filters.owner) continue;
+      if (filters.client && project.frontmatter.client !== filters.client) continue;
+      if (filters.tag) {
+        const tags = project.frontmatter.tags || [];
+        const hasTag = tags.some((tag) => tag.toLowerCase() === filters.tag?.toLowerCase());
+        if (!hasTag) continue;
+      }
+    }
+    projects.push(project);
+  }
+  return projects.sort((left, right) => {
+    const rightTime = parseSortableTimestamp(right.frontmatter.updated || right.frontmatter.created);
+    const leftTime = parseSortableTimestamp(left.frontmatter.updated || left.frontmatter.created);
+    return rightTime - leftTime;
+  });
+}
+function readProject(vaultPath, slug) {
+  if (!slug || isDateSlug(slug) || slug.includes(path.sep)) {
+    return null;
+  }
+  const projectPath = getProjectPath(vaultPath, slug);
+  if (!fs.existsSync(projectPath)) {
+    return null;
+  }
+  try {
+    const raw = fs.readFileSync(projectPath, "utf-8");
+    const { data, content } = matter(raw);
+    if (data.type !== "project") {
+      return null;
+    }
+    const frontmatter = normalizeProjectFrontmatter(data);
+    const title = extractTitle(content) || slug;
+    return {
+      slug,
+      title,
+      content,
+      frontmatter
+    };
+  } catch {
+    return null;
+  }
+}
+function createProject(vaultPath, title, options = {}) {
+  ensureProjectsDir(vaultPath);
+  const slug = slugify(title);
+  const projectPath = getProjectPath(vaultPath, slug);
+  if (fs.existsSync(projectPath)) {
+    throw new Error(`Project already exists: ${slug}`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const frontmatter = {
+    type: "project",
+    status: options.status ?? "active",
+    created: now,
+    updated: now
+  };
+  if (options.owner) frontmatter.owner = options.owner;
+  if (options.team && options.team.length > 0) {
+    const team = normalizeStringArray(options.team);
+    if (team.length > 0) frontmatter.team = team;
+  }
+  if (options.client) frontmatter.client = options.client;
+  if (options.tags && options.tags.length > 0) {
+    const tags = normalizeStringArray(options.tags);
+    if (tags.length > 0) frontmatter.tags = tags;
+  }
+  if (options.description) frontmatter.description = options.description;
+  if (options.started) frontmatter.started = options.started;
+  if (options.deadline) frontmatter.deadline = options.deadline;
+  if (options.repo) frontmatter.repo = options.repo;
+  if (options.url) frontmatter.url = options.url;
+  if (options.completed) frontmatter.completed = options.completed;
+  if (options.reason) frontmatter.reason = options.reason;
+  let content = `# ${title}
+`;
+  const wikiLinks = /* @__PURE__ */ new Set();
+  if (options.owner) wikiLinks.add(options.owner);
+  if (options.client) wikiLinks.add(options.client);
+  for (const member of options.team || []) {
+    const trimmed = member.trim();
+    if (trimmed) wikiLinks.add(trimmed);
+  }
+  if (wikiLinks.size > 0) {
+    content += `
+${Array.from(wikiLinks).map((link) => `[[${link}]]`).join(" | ")}
+`;
+  }
+  if (options.content) {
+    content += `
+${options.content}
+`;
+  }
+  const fileContent = matter.stringify(content, frontmatter);
+  fs.writeFileSync(projectPath, fileContent);
+  return {
+    slug,
+    title,
+    content,
+    frontmatter
+  };
+}
+function updateProject(vaultPath, slug, updates) {
+  const project = readProject(vaultPath, slug);
+  if (!project) {
+    throw new Error(`Project not found: ${slug}`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const nextFrontmatter = {
+    ...project.frontmatter,
+    type: "project",
+    updated: now
+  };
+  if (updates.status !== void 0) {
+    nextFrontmatter.status = updates.status;
+    if (updates.status === "completed" && !updates.completed && !nextFrontmatter.completed) {
+      nextFrontmatter.completed = now;
+    }
+  }
+  if (updates.owner !== void 0) {
+    if (updates.owner === null || updates.owner.trim() === "") {
+      delete nextFrontmatter.owner;
+    } else {
+      nextFrontmatter.owner = updates.owner;
+    }
+  }
+  if (updates.team !== void 0) {
+    if (updates.team === null) {
+      delete nextFrontmatter.team;
+    } else {
+      const team = normalizeStringArray(updates.team);
+      if (team.length === 0) {
+        delete nextFrontmatter.team;
+      } else {
+        nextFrontmatter.team = team;
+      }
+    }
+  }
+  if (updates.client !== void 0) {
+    if (updates.client === null || updates.client.trim() === "") {
+      delete nextFrontmatter.client;
+    } else {
+      nextFrontmatter.client = updates.client;
+    }
+  }
+  if (updates.tags !== void 0) {
+    if (updates.tags === null) {
+      delete nextFrontmatter.tags;
+    } else {
+      const tags = normalizeStringArray(updates.tags);
+      if (tags.length === 0) {
+        delete nextFrontmatter.tags;
+      } else {
+        nextFrontmatter.tags = tags;
+      }
+    }
+  }
+  if (updates.description !== void 0) {
+    if (updates.description === null || updates.description.trim() === "") {
+      delete nextFrontmatter.description;
+    } else {
+      nextFrontmatter.description = updates.description;
+    }
+  }
+  if (updates.started !== void 0) {
+    if (updates.started === null || updates.started.trim() === "") {
+      delete nextFrontmatter.started;
+    } else {
+      nextFrontmatter.started = updates.started;
+    }
+  }
+  if (updates.deadline !== void 0) {
+    if (updates.deadline === null || updates.deadline.trim() === "") {
+      delete nextFrontmatter.deadline;
+    } else {
+      nextFrontmatter.deadline = updates.deadline;
+    }
+  }
+  if (updates.repo !== void 0) {
+    if (updates.repo === null || updates.repo.trim() === "") {
+      delete nextFrontmatter.repo;
+    } else {
+      nextFrontmatter.repo = updates.repo;
+    }
+  }
+  if (updates.url !== void 0) {
+    if (updates.url === null || updates.url.trim() === "") {
+      delete nextFrontmatter.url;
+    } else {
+      nextFrontmatter.url = updates.url;
+    }
+  }
+  if (updates.completed !== void 0) {
+    if (updates.completed === null || updates.completed.trim() === "") {
+      delete nextFrontmatter.completed;
+    } else {
+      nextFrontmatter.completed = updates.completed;
+    }
+  }
+  if (updates.reason !== void 0) {
+    if (updates.reason === null || updates.reason.trim() === "") {
+      delete nextFrontmatter.reason;
+    } else {
+      nextFrontmatter.reason = updates.reason;
+    }
+  }
+  const projectPath = getProjectPath(vaultPath, slug);
+  fs.writeFileSync(projectPath, matter.stringify(project.content, nextFrontmatter));
+  return {
+    ...project,
+    frontmatter: nextFrontmatter
+  };
+}
+function archiveProject(vaultPath, slug, reason) {
+  return updateProject(vaultPath, slug, {
+    status: "archived",
+    reason: reason ?? null,
+    completed: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function getProjectTasks(vaultPath, slug) {
+  return listTasks(vaultPath, { project: slug });
+}
+function getProjectActivity(vaultPath, slug) {
+  const projectActivityDir = path.join(getProjectsDir(vaultPath), slug);
+  if (!fs.existsSync(projectActivityDir) || !fs.statSync(projectActivityDir).isDirectory()) {
+    return [];
+  }
+  const entries = fs.readdirSync(projectActivityDir, { withFileTypes: true });
+  const files = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => path.join(projectActivityDir, entry.name));
+  return files.sort((left, right) => parseProjectDateValue(right) - parseProjectDateValue(left));
+}
+
+export {
+  listProjects,
+  readProject,
+  createProject,
+  updateProject,
+  archiveProject,
+  getProjectTasks,
+  getProjectActivity
+};

package/dist/{chunk-P2ZH6AN5.js → chunk-6RQPD7X6.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-6B3JWM7J.js";
 import {
   DEFAULT_CATEGORIES
-} from "./chunk-3PJIGGWV.js";
+} from "./chunk-2CDEETQN.js";
 
 // src/commands/setup.ts
 import * as fs from "fs";
@@ -327,10 +327,9 @@ async function setupCommand(options = {}) {
     }
   }
   if (doCanvas) {
-    const templateId = typeof options.canvas === "string" ? options.canvas : "default";
     try {
       const { canvasCommand } = await import("./commands/canvas.js");
-      await canvasCommand(target.vaultPath, { template: templateId });
+      await canvasCommand(target.vaultPath);
     } catch (err) {
       console.log(`\u26A0 Canvas generation failed: ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -353,7 +352,7 @@ async function setupCommand(options = {}) {
   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 brain          # Generate brain architecture canvas");
+  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");
 }

package/dist/{chunk-HNMFXFYP.js → chunk-7OHQFMJK.js}

@@ -10,7 +10,7 @@ import {
 import {
   DEFAULT_CATEGORIES,
   TYPE_TO_CATEGORY
-} from "./chunk-3PJIGGWV.js";
+} from "./chunk-2CDEETQN.js";
 import {
   buildOrUpdateMemoryGraphIndex
 } from "./chunk-ZZA73MFY.js";
@@ -851,6 +851,7 @@ clawvault wake                        # restore context on startup
       facts: "Raw information, data points, things that are true",
       feelings: "Emotional states, reactions, energy levels",
       decisions: "Choices made with context and reasoning",
+      rules: "Injectable operational constraints, guardrails, and runbooks",
       lessons: "What I learned, insights, patterns observed",
       commitments: "Promises, goals, obligations to fulfill",
       preferences: "Likes, dislikes, how I want things",

package/dist/{chunk-FKQJB6XC.js → chunk-C3PF7WBA.js}

@@ -1,9 +1,9 @@
 import {
   runReflection
-} from "./chunk-AHGUJG76.js";
+} from "./chunk-KCCHROBR.js";
 import {
   Observer
-} from "./chunk-H6WQUUNK.js";
+} from "./chunk-TMZMN7OS.js";
 import {
   resolveVaultPath
 } from "./chunk-MXSSG3QU.js";

package/dist/{chunk-JXY6T5R7.js → chunk-FW465EEA.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-FHFUXL6G.js";
 import {
   listObservationFiles
-} from "./chunk-NAMFB7ZA.js";
+} from "./chunk-Z2XBWN7A.js";
 
 // src/commands/migrate-observations.ts
 import * as fs from "fs";

package/dist/{chunk-BI6SGGZP.js → chunk-G3OQJ2NQ.js}

@@ -1,6 +1,6 @@
 import {
   runReflection
-} from "./chunk-AHGUJG76.js";
+} from "./chunk-KCCHROBR.js";
 import {
   resolveVaultPath
 } from "./chunk-MXSSG3QU.js";