clawvault 2.6.1 → 3.0.0

package/dist/commands/task.d.cts

@@ -0,0 +1,97 @@
+import { TaskPriority, TaskStatus, Task } from '../lib/task-utils.cjs';
+
+/**
+ * Task command for ClawVault
+ * Manages task add/list/update/done/show operations
+ */
+
+interface TaskAddOptions {
+    owner?: string;
+    project?: string;
+    priority?: TaskPriority;
+    due?: string;
+    content?: string;
+    tags?: string[];
+    description?: string;
+    estimate?: string;
+    parent?: string;
+    dependsOn?: string[];
+}
+interface TaskListOptions {
+    status?: TaskStatus;
+    owner?: string;
+    project?: string;
+    priority?: TaskPriority;
+    due?: boolean;
+    tag?: string;
+    overdue?: boolean;
+    json?: boolean;
+}
+interface TaskUpdateOptions {
+    status?: TaskStatus;
+    owner?: string | null;
+    project?: string | null;
+    priority?: TaskPriority | null;
+    blockedBy?: string | null;
+    due?: string | null;
+    tags?: string[] | null;
+    description?: string | null;
+    estimate?: string | null;
+    parent?: string | null;
+    dependsOn?: string[] | null;
+    confidence?: number;
+    reason?: string | null;
+}
+interface TaskTransitionsOptions {
+    agent?: string;
+    failed?: boolean;
+    json?: boolean;
+}
+interface TaskShowOptions {
+    json?: boolean;
+}
+/**
+ * Add a new task
+ */
+declare function taskAdd(vaultPath: string, title: string, options?: TaskAddOptions): Task;
+/**
+ * List tasks with optional filters
+ */
+declare function taskList(vaultPath: string, options?: TaskListOptions): Task[];
+/**
+ * Update a task
+ */
+declare function taskUpdate(vaultPath: string, slug: string, options: TaskUpdateOptions): Task;
+/**
+ * Mark a task as done
+ */
+declare function taskDone(vaultPath: string, slug: string, options?: {
+    confidence?: number;
+    reason?: string;
+}): Task;
+/**
+ * Query task transitions
+ */
+declare function taskTransitions(vaultPath: string, taskId?: string, options?: TaskTransitionsOptions): string;
+/**
+ * Show task details
+ */
+declare function taskShow(vaultPath: string, slug: string): Task | null;
+/**
+ * Format task list as terminal table
+ */
+declare function formatTaskList(tasks: Task[]): string;
+/**
+ * Format task details for display
+ */
+declare function formatTaskDetails(task: Task): string;
+/**
+ * Task command handler for CLI
+ */
+declare function taskCommand(vaultPath: string, action: 'add' | 'list' | 'update' | 'done' | 'show' | 'transitions', args: {
+    title?: string;
+    slug?: string;
+    options?: TaskAddOptions & TaskListOptions & TaskUpdateOptions & TaskShowOptions & TaskTransitionsOptions;
+}): Promise<void>;
+
+export { type TaskAddOptions, type TaskListOptions, type TaskShowOptions, type TaskTransitionsOptions, type TaskUpdateOptions, formatTaskDetails, formatTaskList, taskAdd, taskCommand, taskDone, taskList, taskShow, taskTransitions, taskUpdate };

package/dist/commands/task.js

@@ -8,10 +8,11 @@ import {
   taskShow,
   taskTransitions,
   taskUpdate
-} from "../chunk-R2MIW5G7.js";
-import "../chunk-QWQ3TIKS.js";
-import "../chunk-MFAWT5O5.js";
+} from "../chunk-3DHXQHYG.js";
+import "../chunk-N2AXRYLC.js";
+import "../chunk-LYHGEHXG.js";
 import "../chunk-7766SIJP.js";
+import "../chunk-3RG5ZIWI.js";
 export {
   formatTaskDetails,
   formatTaskList,

package/dist/commands/template.cjs

@@ -0,0 +1,457 @@
+"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/template.ts
+var template_exports = {};
+__export(template_exports, {
+  addTemplate: () => addTemplate,
+  createFromTemplate: () => createFromTemplate,
+  listTemplateDefinitions: () => listTemplateDefinitions2,
+  listTemplates: () => listTemplates
+});
+module.exports = __toCommonJS(template_exports);
+var fs2 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+
+// src/lib/template-engine.ts
+function buildTemplateVariables(input = {}, now = /* @__PURE__ */ new Date()) {
+  const datetime = input.datetime ?? now.toISOString();
+  const date = input.date ?? datetime.split("T")[0];
+  return {
+    title: input.title ?? "",
+    type: input.type ?? "",
+    date,
+    datetime
+  };
+}
+function renderTemplate(template, variables) {
+  return template.replace(/\{\{\s*([a-zA-Z0-9_-]+)\s*\}\}/g, (match, key) => {
+    const value = variables[key];
+    return value !== void 0 ? String(value) : match;
+  });
+}
+
+// src/lib/primitive-templates.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var import_url = require("url");
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+var import_meta = {};
+var TEMPLATE_EXTENSION = ".md";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeTemplateName(name) {
+  const base = path.basename(name, path.extname(name));
+  return base.trim();
+}
+function resolveBuiltinTemplatesDir(override) {
+  if (override) {
+    const resolved = path.resolve(override);
+    return fs.existsSync(resolved) && fs.statSync(resolved).isDirectory() ? resolved : null;
+  }
+  const moduleDir = path.dirname((0, import_url.fileURLToPath)(import_meta.url));
+  const candidates = [
+    path.resolve(moduleDir, "../templates"),
+    path.resolve(moduleDir, "../../templates")
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function listTemplateFiles(dir, ignore) {
+  const entries = /* @__PURE__ */ new Map();
+  if (!fs.existsSync(dir)) return entries;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith(TEMPLATE_EXTENSION)) continue;
+    const name = normalizeTemplateName(entry.name);
+    if (!name) continue;
+    if (ignore?.has(name)) continue;
+    entries.set(name, path.join(dir, entry.name));
+  }
+  return entries;
+}
+function buildTemplateIndex(options = {}) {
+  const index = /* @__PURE__ */ new Map();
+  const builtinDir = resolveBuiltinTemplatesDir(options.builtinDir);
+  if (builtinDir) {
+    for (const [name, filePath] of listTemplateFiles(builtinDir, options.ignoreBuiltinNames)) {
+      index.set(name, filePath);
+    }
+  }
+  if (options.vaultPath) {
+    const vaultTemplatesDir = path.join(path.resolve(options.vaultPath), "templates");
+    for (const [name, filePath] of listTemplateFiles(vaultTemplatesDir)) {
+      index.set(name, filePath);
+    }
+  }
+  return index;
+}
+function inferFieldType(defaultValue) {
+  if (Array.isArray(defaultValue)) {
+    const uniqueItemTypes = [...new Set(defaultValue.map((value) => typeof value))];
+    if (uniqueItemTypes.length === 1 && uniqueItemTypes[0] === "string") {
+      return "string[]";
+    }
+    return "array";
+  }
+  switch (typeof defaultValue) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "object":
+      if (defaultValue === null) return "string";
+      return "object";
+    default:
+      return "string";
+  }
+}
+function normalizeFieldDefinition(rawField) {
+  if (!isRecord(rawField)) {
+    return {
+      type: inferFieldType(rawField),
+      default: rawField
+    };
+  }
+  const rawType = typeof rawField.type === "string" ? rawField.type.trim() : "";
+  const normalized = {
+    type: rawType || inferFieldType(rawField.default)
+  };
+  if (typeof rawField.description === "string" && rawField.description.trim()) {
+    normalized.description = rawField.description.trim();
+  }
+  if (typeof rawField.required === "boolean") {
+    normalized.required = rawField.required;
+  }
+  if (Object.prototype.hasOwnProperty.call(rawField, "default")) {
+    normalized.default = rawField.default;
+  }
+  if (Array.isArray(rawField.enum)) {
+    normalized.enum = rawField.enum;
+  }
+  return normalized;
+}
+function normalizeFieldDefinitions(rawFields) {
+  const normalized = {};
+  for (const [fieldName, rawField] of Object.entries(rawFields)) {
+    const normalizedName = String(fieldName).trim();
+    if (!normalizedName) continue;
+    normalized[normalizedName] = normalizeFieldDefinition(rawField);
+  }
+  return normalized;
+}
+function extractSchemaDefinition(frontmatter) {
+  const primitive = typeof frontmatter.primitive === "string" ? frontmatter.primitive.trim() : "";
+  const description = typeof frontmatter.description === "string" ? frontmatter.description.trim() : void 0;
+  if (primitive && isRecord(frontmatter.fields)) {
+    return {
+      primitive,
+      description,
+      fields: frontmatter.fields
+    };
+  }
+  const containerCandidates = [frontmatter.schema, frontmatter.template];
+  for (const candidate of containerCandidates) {
+    if (!isRecord(candidate)) continue;
+    const nestedPrimitive = typeof candidate.primitive === "string" ? candidate.primitive.trim() : primitive;
+    if (!nestedPrimitive || !isRecord(candidate.fields)) continue;
+    const nestedDescription = typeof candidate.description === "string" ? candidate.description.trim() : description;
+    return {
+      primitive: nestedPrimitive,
+      description: nestedDescription,
+      fields: candidate.fields
+    };
+  }
+  return null;
+}
+function inferLegacyFieldDefinitions(frontmatter) {
+  const normalized = {};
+  const ignoredKeys = /* @__PURE__ */ new Set(["primitive", "fields", "schema", "template"]);
+  for (const [key, value] of Object.entries(frontmatter)) {
+    if (ignoredKeys.has(key)) continue;
+    normalized[key] = {
+      type: inferFieldType(value),
+      default: value
+    };
+  }
+  return normalized;
+}
+function parseTemplateDefinition(rawTemplate, templateName, sourcePath) {
+  const normalizedName = normalizeTemplateName(templateName);
+  const { data, content } = (0, import_gray_matter.default)(rawTemplate);
+  const frontmatter = isRecord(data) ? data : {};
+  const extractedSchema = extractSchemaDefinition(frontmatter);
+  if (extractedSchema) {
+    return {
+      name: normalizedName,
+      primitive: extractedSchema.primitive,
+      description: extractedSchema.description,
+      fields: normalizeFieldDefinitions(extractedSchema.fields),
+      body: content,
+      format: "schema",
+      sourcePath
+    };
+  }
+  return {
+    name: normalizedName,
+    primitive: normalizedName,
+    description: typeof frontmatter.description === "string" ? frontmatter.description.trim() : void 0,
+    fields: inferLegacyFieldDefinitions(frontmatter),
+    body: content,
+    format: "legacy",
+    sourcePath
+  };
+}
+function readTemplateDefinitionFromPath(filePath, templateName) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    return parseTemplateDefinition(raw, templateName, filePath);
+  } catch {
+    return null;
+  }
+}
+function listTemplateDefinitions(options = {}) {
+  const index = buildTemplateIndex(options);
+  const entries = [];
+  for (const [name, filePath] of [...index.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+    const definition = readTemplateDefinitionFromPath(filePath, name);
+    if (!definition) continue;
+    entries.push({
+      ...definition,
+      path: filePath
+    });
+  }
+  return entries;
+}
+function resolveInterpolatedValue(value, variables) {
+  if (typeof value === "string") {
+    return renderTemplate(value, variables);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => resolveInterpolatedValue(item, variables));
+  }
+  if (isRecord(value)) {
+    const resolved = {};
+    for (const [key, nested] of Object.entries(value)) {
+      resolved[key] = resolveInterpolatedValue(nested, variables);
+    }
+    return resolved;
+  }
+  return value;
+}
+function pruneFrontmatter(frontmatter, options) {
+  const dropEmptyStrings = options.dropEmptyStrings ?? true;
+  const dropEmptyArrays = options.dropEmptyArrays ?? true;
+  const pruned = {};
+  for (const [key, value] of Object.entries(frontmatter)) {
+    if (value === void 0 || value === null) continue;
+    if (dropEmptyStrings && typeof value === "string" && value.trim() === "") continue;
+    if (dropEmptyArrays && Array.isArray(value) && value.length === 0) continue;
+    pruned[key] = value;
+  }
+  return pruned;
+}
+function buildFrontmatterFromTemplate(definition, variables, overrides = {}, options = {}) {
+  const frontmatter = {};
+  for (const [fieldName, schema] of Object.entries(definition.fields)) {
+    if (!Object.prototype.hasOwnProperty.call(schema, "default")) continue;
+    frontmatter[fieldName] = resolveInterpolatedValue(schema.default, variables);
+  }
+  for (const [fieldName, value] of Object.entries(overrides)) {
+    if (value === void 0) continue;
+    if (value === null) {
+      delete frontmatter[fieldName];
+      continue;
+    }
+    frontmatter[fieldName] = value;
+  }
+  if (!options.pruneEmpty) {
+    return frontmatter;
+  }
+  return pruneFrontmatter(frontmatter, options);
+}
+function renderDocumentFromTemplate(definition, options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const variables = {
+    ...buildTemplateVariables(
+      {
+        title: options.title ?? "",
+        type: options.type ?? definition.primitive
+      },
+      now
+    ),
+    ...options.variables ?? {}
+  };
+  const frontmatter = buildFrontmatterFromTemplate(
+    definition,
+    variables,
+    options.overrides,
+    options.frontmatter
+  );
+  const content = renderTemplate(definition.body, variables);
+  const markdown = import_gray_matter.default.stringify(content, frontmatter);
+  return {
+    frontmatter,
+    content,
+    markdown,
+    variables
+  };
+}
+
+// src/commands/template.ts
+var VAULT_CONFIG_FILE = ".clawvault.json";
+var TEMPLATE_LIST_IGNORED_BUILTINS = /* @__PURE__ */ new Set(["daily"]);
+function findVaultRoot(start) {
+  let current = path2.resolve(start);
+  while (true) {
+    if (fs2.existsSync(path2.join(current, VAULT_CONFIG_FILE))) {
+      return current;
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function resolveVaultPath(options) {
+  if (options.vaultPath) {
+    return path2.resolve(options.vaultPath);
+  }
+  const envPath = process.env.CLAWVAULT_PATH;
+  if (envPath) {
+    return path2.resolve(envPath);
+  }
+  const cwd = options.cwd ?? process.cwd();
+  return findVaultRoot(cwd);
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").trim();
+}
+function buildTemplateIndexForContext(options) {
+  const vaultPath = resolveVaultPath(options) ?? void 0;
+  return buildTemplateIndex({
+    vaultPath,
+    builtinDir: options.builtinDir,
+    ignoreBuiltinNames: TEMPLATE_LIST_IGNORED_BUILTINS
+  });
+}
+function listTemplateDefinitions2(options = {}) {
+  const vaultPath = resolveVaultPath(options) ?? void 0;
+  return listTemplateDefinitions({
+    vaultPath,
+    builtinDir: options.builtinDir,
+    ignoreBuiltinNames: TEMPLATE_LIST_IGNORED_BUILTINS
+  }).map((definition) => ({
+    name: definition.name,
+    primitive: definition.primitive,
+    description: definition.description,
+    fields: Object.keys(definition.fields),
+    path: definition.path,
+    format: definition.format
+  }));
+}
+function listTemplates(options = {}) {
+  return listTemplateDefinitions2(options).map((definition) => definition.name);
+}
+function createFromTemplate(name, options = {}) {
+  const templateName = normalizeTemplateName(name);
+  if (!templateName) {
+    throw new Error("Template name is required.");
+  }
+  const index = buildTemplateIndexForContext(options);
+  const templatePath = index.get(templateName);
+  if (!templatePath) {
+    const available = [...index.keys()].sort();
+    const hint = available.length > 0 ? ` Available: ${available.join(", ")}` : "";
+    throw new Error(`Template not found: ${templateName}.${hint}`);
+  }
+  const raw = fs2.readFileSync(templatePath, "utf-8");
+  const now = /* @__PURE__ */ new Date();
+  const date = now.toISOString().split("T")[0];
+  const type = options.type ?? templateName;
+  const title = options.title ?? `${type} ${date}`.trim();
+  const variables = buildTemplateVariables({ title, type, date }, now);
+  const parsedTemplate = parseTemplateDefinition(raw, templateName, templatePath);
+  const rendered = parsedTemplate.format === "schema" ? renderDocumentFromTemplate(parsedTemplate, {
+    title,
+    type,
+    now,
+    variables: {
+      ...variables,
+      content: "",
+      links_line: "",
+      owner_link: "",
+      project_link: "",
+      team_links_line: ""
+    }
+  }).markdown : renderTemplate(raw, variables);
+  const cwd = options.cwd ?? process.cwd();
+  const slug = slugify(title) || slugify(templateName) || `template-${date}`;
+  const outputPath = path2.join(cwd, `${slug}${TEMPLATE_EXTENSION}`);
+  if (fs2.existsSync(outputPath)) {
+    throw new Error(`File already exists: ${outputPath}`);
+  }
+  fs2.writeFileSync(outputPath, rendered);
+  return { outputPath, templatePath, variables };
+}
+function addTemplate(file, options) {
+  const name = normalizeTemplateName(options.name);
+  if (!name) {
+    throw new Error("Template name is required.");
+  }
+  const vaultPath = resolveVaultPath(options);
+  if (!vaultPath) {
+    throw new Error("No vault found. Set CLAWVAULT_PATH or use --vault.");
+  }
+  const cwd = options.cwd ?? process.cwd();
+  const sourcePath = path2.resolve(cwd, file);
+  if (!fs2.existsSync(sourcePath) || !fs2.statSync(sourcePath).isFile()) {
+    throw new Error(`Template file not found: ${sourcePath}`);
+  }
+  const templatesDir = path2.join(vaultPath, "templates");
+  fs2.mkdirSync(templatesDir, { recursive: true });
+  const targetPath = path2.join(templatesDir, `${name}${TEMPLATE_EXTENSION}`);
+  if (fs2.existsSync(targetPath) && !options.overwrite) {
+    throw new Error(`Template already exists: ${targetPath}`);
+  }
+  fs2.copyFileSync(sourcePath, targetPath);
+  return { templatePath: targetPath, name };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addTemplate,
+  createFromTemplate,
+  listTemplateDefinitions,
+  listTemplates
+});

package/dist/commands/template.d.cts

@@ -0,0 +1,36 @@
+import { TemplateVariables } from '../lib/template-engine.cjs';
+
+interface TemplateCommandContext {
+    vaultPath?: string;
+    cwd?: string;
+    builtinDir?: string;
+}
+interface TemplateCreateOptions extends TemplateCommandContext {
+    title?: string;
+    type?: string;
+}
+interface TemplateAddOptions extends TemplateCommandContext {
+    name: string;
+    overwrite?: boolean;
+}
+interface TemplateDefinitionInfo {
+    name: string;
+    primitive: string;
+    description?: string;
+    fields: string[];
+    path: string;
+    format: 'schema' | 'legacy';
+}
+declare function listTemplateDefinitions(options?: TemplateCommandContext): TemplateDefinitionInfo[];
+declare function listTemplates(options?: TemplateCommandContext): string[];
+declare function createFromTemplate(name: string, options?: TemplateCreateOptions): {
+    outputPath: string;
+    templatePath: string;
+    variables: TemplateVariables;
+};
+declare function addTemplate(file: string, options: TemplateAddOptions): {
+    templatePath: string;
+    name: string;
+};
+
+export { type TemplateAddOptions, type TemplateCommandContext, type TemplateCreateOptions, type TemplateDefinitionInfo, addTemplate, createFromTemplate, listTemplateDefinitions, listTemplates };

package/dist/commands/template.js

@@ -5,11 +5,12 @@ import {
   normalizeTemplateName,
   parseTemplateDefinition,
   renderDocumentFromTemplate
-} from "../chunk-MFAWT5O5.js";
+} from "../chunk-LYHGEHXG.js";
 import {
   buildTemplateVariables,
   renderTemplate
 } from "../chunk-7766SIJP.js";
+import "../chunk-3RG5ZIWI.js";
 
 // src/commands/template.ts
 import * as fs from "fs";