@cad0p/napkin 0.8.1

package/dist/utils/formula.js

@@ -0,0 +1,462 @@
+import Jexl from "jexl";
+// All known transforms (methods that Obsidian calls with dot syntax)
+const TRANSFORMS = new Set([
+    // Any
+    "isTruthy",
+    "isType",
+    "toString",
+    // Number
+    "abs",
+    "ceil",
+    "floor",
+    "round",
+    "toFixed",
+    "isEmpty",
+    // String
+    "contains",
+    "containsAll",
+    "containsAny",
+    "startsWith",
+    "endsWith",
+    "lower",
+    "title",
+    "trim",
+    "replace",
+    "repeat",
+    "reverse",
+    "slice",
+    "split",
+    // Date
+    "format",
+    "date",
+    "time",
+    "relative",
+    // List
+    "filter",
+    "map",
+    "reduce",
+    "flat",
+    "join",
+    "sort",
+    "unique",
+    // File
+    "asLink",
+    "hasLink",
+    "hasTag",
+    "hasProperty",
+    "inFolder",
+    // Link
+    "asFile",
+    "linksTo",
+    // Object
+    "keys",
+    "values",
+    // Regex
+    "matches",
+]);
+/**
+ * Transform Obsidian expression syntax to jexl syntax.
+ * Converts .method(args) to |method(args) for known transforms.
+ * Also remaps if() to _if() since if is reserved.
+ */
+export function obsidianToJexl(expr) {
+    // Replace if( with _if( — but not inside strings
+    let result = expr;
+    // Handle if() function calls (not inside quotes)
+    result = result.replace(/\bif\s*\(/g, "_if(");
+    // Convert .method( to |method( for known transforms
+    // Must be careful not to convert property access like file.name
+    for (const t of TRANSFORMS) {
+        // Match .transform( but not when preceded by a quote (inside string)
+        const regex = new RegExp(`\\.${t}\\(`, "g");
+        result = result.replace(regex, `|${t}(`);
+    }
+    // Handle .length (property, not function call) — convert to |_length
+    result = result.replace(/\.length\b(?!\s*\()/g, "|_length");
+    // Handle .isEmpty() with no args — it's already converted above if it matches
+    // Handle .year, .month, .day, .hour, .minute, .second, .millisecond on dates
+    for (const field of [
+        "year",
+        "month",
+        "day",
+        "hour",
+        "minute",
+        "second",
+        "millisecond",
+        "days",
+        "hours",
+        "minutes",
+        "seconds",
+        "milliseconds",
+    ]) {
+        const regex = new RegExp(`\\.${field}\\b(?!\\s*\\()`, "g");
+        result = result.replace(regex, `|_${field}`);
+    }
+    return result;
+}
+/**
+ * Create a configured jexl instance with all Obsidian Bases functions.
+ */
+export function createFormulaEngine() {
+    const jexl = new Jexl.Jexl();
+    // === Global functions ===
+    jexl.addFunction("_if", (cond, trueVal, falseVal) => cond ? trueVal : (falseVal ?? null));
+    jexl.addFunction("now", () => Date.now());
+    jexl.addFunction("today", () => {
+        const d = new Date();
+        d.setHours(0, 0, 0, 0);
+        return d.getTime();
+    });
+    jexl.addFunction("date", (s) => new Date(s).getTime());
+    jexl.addFunction("duration", (s) => parseDurationMs(s));
+    jexl.addFunction("min", (...args) => Math.min(...args));
+    jexl.addFunction("max", (...args) => Math.max(...args));
+    jexl.addFunction("number", (v) => {
+        if (typeof v === "boolean")
+            return v ? 1 : 0;
+        return Number(v);
+    });
+    jexl.addFunction("list", (v) => (Array.isArray(v) ? v : [v]));
+    jexl.addFunction("link", (path, display) => display || path);
+    jexl.addFunction("icon", (name) => `[${name}]`);
+    // === Number transforms ===
+    jexl.addTransform("abs", (v) => Math.abs(v));
+    jexl.addTransform("ceil", (v) => Math.ceil(v));
+    jexl.addTransform("floor", (v) => Math.floor(v));
+    jexl.addTransform("round", (v, digits) => {
+        const f = 10 ** (digits || 0);
+        return Math.round(v * f) / f;
+    });
+    jexl.addTransform("toFixed", (v, precision) => Number(v).toFixed(precision));
+    // === String transforms ===
+    jexl.addTransform("contains", (v, sub) => {
+        if (Array.isArray(v))
+            return v.includes(sub);
+        return String(v).includes(String(sub));
+    });
+    jexl.addTransform("containsAll", (v, ...subs) => {
+        if (Array.isArray(v))
+            return subs.every((s) => v.includes(s));
+        const s = String(v);
+        return subs.every((sub) => s.includes(String(sub)));
+    });
+    jexl.addTransform("containsAny", (v, ...subs) => {
+        if (Array.isArray(v))
+            return subs.some((s) => v.includes(s));
+        const s = String(v);
+        return subs.some((sub) => s.includes(String(sub)));
+    });
+    jexl.addTransform("startsWith", (v, q) => String(v).startsWith(q));
+    jexl.addTransform("endsWith", (v, q) => String(v).endsWith(q));
+    jexl.addTransform("lower", (v) => String(v).toLowerCase());
+    jexl.addTransform("title", (v) => String(v).replace(/\b\w/g, (c) => c.toUpperCase()));
+    jexl.addTransform("trim", (v) => String(v).trim());
+    jexl.addTransform("replace", (v, pat, rep) => String(v).replace(pat, rep));
+    jexl.addTransform("repeat", (v, n) => String(v).repeat(n));
+    jexl.addTransform("reverse", (v) => {
+        if (Array.isArray(v))
+            return [...v].reverse();
+        return String(v).split("").reverse().join("");
+    });
+    jexl.addTransform("slice", (v, start, end) => {
+        if (Array.isArray(v))
+            return v.slice(start, end);
+        return String(v).slice(start, end);
+    });
+    jexl.addTransform("split", (v, sep, n) => {
+        const parts = String(v).split(sep);
+        return n ? parts.slice(0, n) : parts;
+    });
+    jexl.addTransform("toString", (v) => String(v));
+    // === Date transforms ===
+    jexl.addTransform("format", (v, fmt) => {
+        const d = new Date(v);
+        return fmt
+            .replace("YYYY", String(d.getFullYear()))
+            .replace("MM", String(d.getMonth() + 1).padStart(2, "0"))
+            .replace("DD", String(d.getDate()).padStart(2, "0"))
+            .replace("HH", String(d.getHours()).padStart(2, "0"))
+            .replace("mm", String(d.getMinutes()).padStart(2, "0"))
+            .replace("ss", String(d.getSeconds()).padStart(2, "0"));
+    });
+    jexl.addTransform("date", (v) => {
+        const d = new Date(v);
+        d.setHours(0, 0, 0, 0);
+        return d.getTime();
+    });
+    jexl.addTransform("time", (v) => {
+        const d = new Date(v);
+        return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}:${String(d.getSeconds()).padStart(2, "0")}`;
+    });
+    jexl.addTransform("relative", (v) => {
+        const diff = Date.now() - v;
+        const abs = Math.abs(diff);
+        const ago = diff > 0;
+        if (abs < 60000)
+            return "just now";
+        if (abs < 3600000) {
+            const m = Math.floor(abs / 60000);
+            return ago
+                ? `${m} minute${m > 1 ? "s" : ""} ago`
+                : `in ${m} minute${m > 1 ? "s" : ""}`;
+        }
+        if (abs < 86400000) {
+            const h = Math.floor(abs / 3600000);
+            return ago
+                ? `${h} hour${h > 1 ? "s" : ""} ago`
+                : `in ${h} hour${h > 1 ? "s" : ""}`;
+        }
+        const d = Math.floor(abs / 86400000);
+        return ago
+            ? `${d} day${d > 1 ? "s" : ""} ago`
+            : `in ${d} day${d > 1 ? "s" : ""}`;
+    });
+    // === Date field transforms (act as property access) ===
+    jexl.addTransform("_year", (v) => new Date(v).getFullYear());
+    jexl.addTransform("_month", (v) => new Date(v).getMonth() + 1);
+    jexl.addTransform("_day", (v) => new Date(v).getDate());
+    jexl.addTransform("_hour", (v) => new Date(v).getHours());
+    jexl.addTransform("_minute", (v) => new Date(v).getMinutes());
+    jexl.addTransform("_second", (v) => new Date(v).getSeconds());
+    jexl.addTransform("_millisecond", (v) => new Date(v).getMilliseconds());
+    // === Duration field transforms ===
+    jexl.addTransform("_days", (v) => v / 86400000);
+    jexl.addTransform("_hours", (v) => v / 3600000);
+    jexl.addTransform("_minutes", (v) => v / 60000);
+    jexl.addTransform("_seconds", (v) => v / 1000);
+    jexl.addTransform("_milliseconds", (v) => v);
+    // === List transforms ===
+    jexl.addTransform("join", (v, sep) => Array.isArray(v) ? v.join(sep) : String(v));
+    jexl.addTransform("sort", (v) => Array.isArray(v) ? [...v].sort() : v);
+    jexl.addTransform("unique", (v) => Array.isArray(v) ? [...new Set(v)] : v);
+    jexl.addTransform("flat", (v) => Array.isArray(v) ? v.flat() : v);
+    // === Any transforms ===
+    jexl.addTransform("isEmpty", (v) => {
+        if (v === null || v === undefined || v === "")
+            return true;
+        if (Array.isArray(v))
+            return v.length === 0;
+        if (typeof v === "object")
+            return Object.keys(v).length === 0;
+        return false;
+    });
+    jexl.addTransform("isTruthy", (v) => !!v);
+    jexl.addTransform("isType", (v, type) => {
+        if (type === "string")
+            return typeof v === "string";
+        if (type === "number")
+            return typeof v === "number";
+        if (type === "boolean")
+            return typeof v === "boolean";
+        if (type === "list")
+            return Array.isArray(v);
+        return false;
+    });
+    jexl.addTransform("_length", (v) => {
+        if (typeof v === "string")
+            return v.length;
+        if (Array.isArray(v))
+            return v.length;
+        return 0;
+    });
+    // === Object transforms ===
+    jexl.addTransform("keys", (v) => v && typeof v === "object" && !Array.isArray(v) ? Object.keys(v) : []);
+    jexl.addTransform("values", (v) => v && typeof v === "object" && !Array.isArray(v) ? Object.values(v) : []);
+    // === File-like transforms (operate on context objects) ===
+    jexl.addTransform("hasTag", (file, ...tags) => {
+        if (!file?.tags)
+            return false;
+        return tags.some((t) => file.tags?.some((ft) => ft === t || ft.startsWith(`${t}/`)));
+    });
+    jexl.addTransform("hasLink", (file, target) => {
+        if (!file?.links)
+            return false;
+        return file.links.includes(target);
+    });
+    jexl.addTransform("hasProperty", (file, name) => {
+        if (!file?.properties)
+            return false;
+        return name in file.properties;
+    });
+    jexl.addTransform("inFolder", (file, folder) => {
+        if (!file?.folder)
+            return false;
+        return file.folder === folder || file.folder.startsWith(`${folder}/`);
+    });
+    jexl.addTransform("asLink", (file, display) => display || file?.name || "");
+    // === Regex ===
+    jexl.addTransform("matches", (pattern, target) => {
+        try {
+            return new RegExp(pattern).test(target);
+        }
+        catch {
+            return false;
+        }
+    });
+    return jexl;
+}
+/**
+ * Build a context object for formula evaluation from a database row.
+ */
+export function buildFormulaContext(columns, row, formulaResults = {}, thisFile) {
+    const ctx = {};
+    const file = {};
+    const note = {};
+    for (let i = 0; i < columns.length; i++) {
+        const col = columns[i];
+        const val = row[i];
+        // File metadata columns
+        if ([
+            "path",
+            "name",
+            "basename",
+            "folder",
+            "ext",
+            "size",
+            "ctime",
+            "mtime",
+        ].includes(col)) {
+            file[col] = val;
+        }
+        else if (col === "tags") {
+            try {
+                file.tags = JSON.parse(val);
+            }
+            catch {
+                file.tags = [];
+            }
+        }
+        else if (col === "links") {
+            try {
+                file.links = JSON.parse(val);
+            }
+            catch {
+                file.links = [];
+            }
+        }
+        else if (col === "backlinks") {
+            try {
+                file.backlinks = JSON.parse(val);
+            }
+            catch {
+                file.backlinks = [];
+            }
+        }
+        else if (col === "embeds") {
+            try {
+                file.embeds = JSON.parse(val);
+            }
+            catch {
+                file.embeds = [];
+            }
+        }
+        else if (col === "file_properties") {
+            try {
+                file.properties = JSON.parse(val);
+            }
+            catch {
+                file.properties = {};
+            }
+        }
+        else {
+            // Frontmatter properties (already stripped of prop_ prefix by queryBase)
+            // Try to parse JSON values (lists, objects)
+            let parsed = val;
+            if (typeof val === "string") {
+                try {
+                    const p = JSON.parse(val);
+                    if (typeof p === "object")
+                        parsed = p;
+                }
+                catch {
+                    /* keep as string */
+                }
+            }
+            note[col] = parsed;
+            ctx[col] = parsed; // bare property access shorthand
+        }
+    }
+    // Add formula results
+    const formula = { ...formulaResults };
+    ctx.formula = formula;
+    ctx.file = file;
+    ctx.note = note;
+    if (thisFile)
+        ctx.this = { file: thisFile };
+    return ctx;
+}
+/**
+ * Evaluate all formulas for a single row.
+ * Handles formula dependencies (formula referencing another formula).
+ */
+export async function evaluateFormulas(engine, formulas, columns, row, thisFile) {
+    const results = {};
+    const remaining = { ...formulas };
+    let iterations = 0;
+    const maxIterations = Object.keys(formulas).length + 1;
+    while (Object.keys(remaining).length > 0 && iterations < maxIterations) {
+        iterations++;
+        let resolved = false;
+        for (const [name, expr] of Object.entries(remaining)) {
+            // Check if this formula depends on unresolved formulas
+            const deps = Object.keys(remaining).filter((k) => k !== name && expr.includes(`formula.${k}`));
+            if (deps.length > 0)
+                continue;
+            const ctx = buildFormulaContext(columns, row, results, thisFile);
+            try {
+                const jexlExpr = obsidianToJexl(expr);
+                results[name] = await engine.eval(jexlExpr, ctx);
+            }
+            catch {
+                results[name] = null;
+            }
+            delete remaining[name];
+            resolved = true;
+        }
+        if (!resolved)
+            break; // Circular dependency, bail
+    }
+    // Any remaining (circular deps) get null
+    for (const name of Object.keys(remaining)) {
+        results[name] = null;
+    }
+    return results;
+}
+function parseDurationMs(dur) {
+    const match = dur.match(/^(\d+)\s*(y|year|years|M|month|months|d|day|days|w|week|weeks|h|hour|hours|m|minute|minutes|s|second|seconds)$/);
+    if (!match)
+        return 0;
+    const n = Number.parseInt(match[1], 10);
+    switch (match[2]) {
+        case "y":
+        case "year":
+        case "years":
+            return n * 365.25 * 24 * 60 * 60 * 1000;
+        case "M":
+        case "month":
+        case "months":
+            return n * 30.44 * 24 * 60 * 60 * 1000;
+        case "w":
+        case "week":
+        case "weeks":
+            return n * 7 * 24 * 60 * 60 * 1000;
+        case "d":
+        case "day":
+        case "days":
+            return n * 24 * 60 * 60 * 1000;
+        case "h":
+        case "hour":
+        case "hours":
+            return n * 60 * 60 * 1000;
+        case "m":
+        case "minute":
+        case "minutes":
+            return n * 60 * 1000;
+        case "s":
+        case "second":
+        case "seconds":
+            return n * 1000;
+        default:
+            return 0;
+    }
+}

package/dist/utils/frontmatter.d.ts

@@ -0,0 +1,17 @@
+export interface ParsedFrontmatter {
+    properties: Record<string, unknown>;
+    body: string;
+    raw: string;
+}
+/**
+ * Parse YAML frontmatter from markdown content.
+ */
+export declare function parseFrontmatter(content: string): ParsedFrontmatter;
+/**
+ * Set a property in frontmatter, creating the --- block if needed.
+ */
+export declare function setProperty(content: string, name: string, value: unknown): string;
+/**
+ * Remove a property from frontmatter.
+ */
+export declare function removeProperty(content: string, name: string): string;

package/dist/utils/frontmatter.js

@@ -0,0 +1,34 @@
+import matter from "gray-matter";
+/**
+ * Parse YAML frontmatter from markdown content.
+ */
+export function parseFrontmatter(content) {
+    const result = matter(content);
+    return {
+        properties: result.data,
+        body: result.content,
+        raw: result.matter,
+    };
+}
+/**
+ * Set a property in frontmatter, creating the --- block if needed.
+ */
+export function setProperty(content, name, value) {
+    const result = matter(content);
+    const data = { ...result.data, [name]: value };
+    return matter.stringify(result.content, data);
+}
+/**
+ * Remove a property from frontmatter.
+ */
+export function removeProperty(content, name) {
+    const result = matter(content);
+    const data = { ...result.data };
+    delete data[name];
+    // If no properties left, return just the body
+    if (Object.keys(data).length === 0) {
+        const body = result.content;
+        return body.startsWith("\n") ? body.slice(1) : body;
+    }
+    return matter.stringify(result.content, data);
+}

package/dist/utils/markdown.d.ts

@@ -0,0 +1,31 @@
+export interface Heading {
+    level: number;
+    text: string;
+    line: number;
+}
+export interface Task {
+    line: number;
+    status: string;
+    text: string;
+    done: boolean;
+}
+export interface LinkInfo {
+    outgoing: string[];
+    wikilinks: string[];
+}
+/**
+ * Extract headings from markdown content.
+ */
+export declare function extractHeadings(content: string): Heading[];
+/**
+ * Extract tasks (checkboxes) from markdown content.
+ */
+export declare function extractTasks(content: string): Task[];
+/**
+ * Extract tags from markdown content (both inline #tags and frontmatter tags).
+ */
+export declare function extractTags(content: string): string[];
+/**
+ * Extract links from markdown content.
+ */
+export declare function extractLinks(content: string): LinkInfo;

package/dist/utils/markdown.js

@@ -0,0 +1,80 @@
+/**
+ * Extract headings from markdown content.
+ */
+export function extractHeadings(content) {
+    const headings = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const match = lines[i].match(/^(#{1,6})\s+(.+)$/);
+        if (match) {
+            headings.push({
+                level: match[1].length,
+                text: match[2].trim(),
+                line: i + 1,
+            });
+        }
+    }
+    return headings;
+}
+/**
+ * Extract tasks (checkboxes) from markdown content.
+ */
+export function extractTasks(content) {
+    const tasks = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const match = lines[i].match(/^[\s]*[-*]\s+\[(.)\]\s+(.*)$/);
+        if (match) {
+            const status = match[1];
+            tasks.push({
+                line: i + 1,
+                status,
+                text: match[2].trim(),
+                done: status === "x" || status === "X",
+            });
+        }
+    }
+    return tasks;
+}
+/**
+ * Extract tags from markdown content (both inline #tags and frontmatter tags).
+ */
+export function extractTags(content) {
+    const tags = new Set();
+    // Inline tags: #tag (not inside code blocks or links)
+    const tagRegex = /(?:^|\s)#([a-zA-Z][\w/-]*)/g;
+    for (let match = tagRegex.exec(content); match !== null; match = tagRegex.exec(content)) {
+        tags.add(match[1]);
+    }
+    return [...tags].sort();
+}
+/**
+ * Extract links from markdown content.
+ */
+export function extractLinks(content) {
+    const wikilinks = [];
+    const outgoing = [];
+    // Wikilinks: [[target]] or [[target|alias]]
+    const wikiRegex = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
+    for (let match = wikiRegex.exec(content); match !== null; match = wikiRegex.exec(content)) {
+        const target = match[1].trim();
+        // Strip heading/block refs
+        const clean = target.split("#")[0].trim();
+        if (clean) {
+            wikilinks.push(clean);
+            outgoing.push(clean);
+        }
+    }
+    // Markdown links: [text](url)
+    const mdRegex = /\[([^\]]*)\]\(([^)]+)\)/g;
+    for (let match = mdRegex.exec(content); match !== null; match = mdRegex.exec(content)) {
+        const url = match[2].trim();
+        // Only internal links (not http/https/mailto)
+        if (!url.match(/^(https?|mailto|obsidian):\/\//)) {
+            const clean = decodeURIComponent(url.split("#")[0].trim());
+            if (clean)
+                outgoing.push(clean);
+        }
+    }
+    return { outgoing, wikilinks };
+}

package/dist/utils/output.d.ts

@@ -0,0 +1,28 @@
+export interface OutputOptions {
+    json?: boolean;
+    quiet?: boolean;
+}
+export declare const success: (msg: string) => void;
+export declare const info: (msg: string) => void;
+export declare const warn: (msg: string) => void;
+export declare const error: (msg: string) => void;
+export declare const errorWithHint: (msg: string, hint: string) => void;
+/**
+ * Standard "file not found" error with suggestions.
+ * Import suggestFile where needed and pass results here.
+ */
+export declare function fileNotFound(ref: string, suggestions?: string[]): void;
+export declare const bold: (s: string) => string;
+export declare const dim: (s: string) => string;
+export declare const cmd: (s: string) => string;
+export declare const bullet: (msg: string) => void;
+export declare const bulletDim: (msg: string) => void;
+export declare const hint: (msg: string) => void;
+export declare const nextStep: (command: string) => void;
+export declare const header: (title: string) => void;
+export declare function jsonOutput(data: object): void;
+export declare function output(options: OutputOptions, handlers: {
+    json?: () => object;
+    quiet?: () => void;
+    human: () => void;
+}): void;