clawvault 3.1.0 → 3.2.0

package/dist/commands/task.d.cts

@@ -1,97 +0,0 @@
-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/template.cjs

@@ -1,457 +0,0 @@
-"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

@@ -1,36 +0,0 @@
-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 };