@cad0p/napkin 0.8.1

package/dist/commands/links.js

@@ -0,0 +1,119 @@
+import { Napkin } from "../sdk.js";
+import { EXIT_NOT_FOUND, EXIT_USER_ERROR } from "../utils/exit-codes.js";
+import { suggestFile } from "../utils/files.js";
+import { dim, error, fileNotFound, output, } from "../utils/output.js";
+export async function backlinks(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    if (!opts.file) {
+        error("No file specified. Use --file <name>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    let links;
+    try {
+        links = n.linksBack(opts.file);
+    }
+    catch (e) {
+        const msg = e.message;
+        if (msg.startsWith("File not found:")) {
+            fileNotFound(opts.file, suggestFile(n.vault.contentPath, opts.file));
+            process.exit(EXIT_NOT_FOUND);
+        }
+        throw e;
+    }
+    output(opts, {
+        json: () => (opts.total ? { total: links.length } : { backlinks: links }),
+        human: () => {
+            if (opts.total)
+                console.log(links.length);
+            else
+                for (const l of links)
+                    console.log(l);
+        },
+    });
+}
+export async function links(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    if (!opts.file) {
+        error("No file specified. Use --file <name>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    let outgoing;
+    try {
+        outgoing = n.linksOut(opts.file);
+    }
+    catch (e) {
+        const msg = e.message;
+        if (msg.startsWith("File not found:")) {
+            fileNotFound(opts.file, suggestFile(n.vault.contentPath, opts.file));
+            process.exit(EXIT_NOT_FOUND);
+        }
+        throw e;
+    }
+    output(opts, {
+        json: () => (opts.total ? { total: outgoing.length } : { links: outgoing }),
+        human: () => {
+            if (opts.total)
+                console.log(outgoing.length);
+            else
+                for (const l of outgoing)
+                    console.log(l);
+        },
+    });
+}
+export async function unresolvedLinks(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    const entries = n.linksUnresolved();
+    output(opts, {
+        json: () => {
+            if (opts.total)
+                return { total: entries.length };
+            if (opts.counts || opts.verbose)
+                return {
+                    unresolved: Object.fromEntries(entries.map(([k, v]) => [k, opts.verbose ? v : v.length])),
+                };
+            return { unresolved: entries.map(([k]) => k) };
+        },
+        human: () => {
+            if (opts.total) {
+                console.log(entries.length);
+            }
+            else {
+                for (const [target, sources] of entries) {
+                    console.log(opts.counts ? `${target}\t${sources.length}` : target);
+                    if (opts.verbose) {
+                        for (const s of sources)
+                            console.log(`  ${dim(s)}`);
+                    }
+                }
+            }
+        },
+    });
+}
+export async function orphans(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    const result = n.orphans();
+    output(opts, {
+        json: () => (opts.total ? { total: result.length } : { orphans: result }),
+        human: () => {
+            if (opts.total)
+                console.log(result.length);
+            else
+                for (const f of result)
+                    console.log(f);
+        },
+    });
+}
+export async function deadends(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    const result = n.deadends();
+    output(opts, {
+        json: () => (opts.total ? { total: result.length } : { deadends: result }),
+        human: () => {
+            if (opts.total)
+                console.log(result.length);
+            else
+                for (const f of result)
+                    console.log(f);
+        },
+    });
+}

package/dist/commands/outline.d.ts

@@ -0,0 +1,7 @@
+import { type OutputOptions } from "../utils/output.js";
+export declare function outline(opts: OutputOptions & {
+    vault?: string;
+    file?: string;
+    format?: string;
+    total?: boolean;
+}): Promise<void>;

package/dist/commands/outline.js

@@ -0,0 +1,48 @@
+import { Napkin } from "../sdk.js";
+import { EXIT_NOT_FOUND, EXIT_USER_ERROR } from "../utils/exit-codes.js";
+import { suggestFile } from "../utils/files.js";
+import { error, fileNotFound, output, } from "../utils/output.js";
+export async function outline(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    if (!opts.file) {
+        error("No file specified. Use --file <name>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    let headings;
+    try {
+        headings = n.outline(opts.file);
+    }
+    catch (e) {
+        const msg = e.message;
+        if (msg.startsWith("File not found:")) {
+            fileNotFound(opts.file, suggestFile(n.vault.contentPath, opts.file));
+            process.exit(EXIT_NOT_FOUND);
+        }
+        throw e;
+    }
+    output(opts, {
+        json: () => (opts.total ? { total: headings.length } : { headings }),
+        human: () => {
+            if (opts.total) {
+                console.log(headings.length);
+                return;
+            }
+            const fmt = opts.format || "tree";
+            if (fmt === "json") {
+                console.log(JSON.stringify(headings, null, 2));
+            }
+            else if (fmt === "md") {
+                for (const h of headings) {
+                    console.log(`${"#".repeat(h.level)} ${h.text}`);
+                }
+            }
+            else {
+                // tree format
+                for (const h of headings) {
+                    const indent = "  ".repeat(h.level - 1);
+                    console.log(`${indent}${h.text}`);
+                }
+            }
+        },
+    });
+}

package/dist/commands/overview.d.ts

@@ -0,0 +1,6 @@
+import { type OutputOptions } from "../utils/output.js";
+export declare function overview(opts: OutputOptions & {
+    vault?: string;
+    depth?: string;
+    keywords?: string;
+}): Promise<void>;

package/dist/commands/overview.js

@@ -0,0 +1,40 @@
+import { Napkin } from "../sdk.js";
+import { bold, dim, output, warn, } from "../utils/output.js";
+export async function overview(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    const result = n.overview({
+        depth: opts.depth ? Number.parseInt(opts.depth, 10) : undefined,
+        keywords: opts.keywords ? Number.parseInt(opts.keywords, 10) : undefined,
+    });
+    for (const w of result.warnings ?? []) {
+        warn(w);
+    }
+    output(opts, {
+        json: () => result,
+        human: () => {
+            console.log(dim("WORKFLOW: overview (you are here) → search <query> → read <file>"));
+            console.log("");
+            if (result.context) {
+                console.log(bold("CONTEXT"));
+                console.log(result.context);
+                console.log("");
+            }
+            if (result.overview.length === 0) {
+                console.log("Empty vault");
+                return;
+            }
+            for (const f of result.overview) {
+                console.log(bold(f.path === "/" ? "./" : `${f.path}/`));
+                if (f.keywords.length > 0) {
+                    console.log(`  ${dim("keywords:")} ${f.keywords.join(", ")}`);
+                }
+                if (f.tags.length > 0) {
+                    console.log(`  ${dim("tags:")} ${f.tags.map((t) => `#${t}`).join(", ")}`);
+                }
+                console.log(`  ${dim("notes:")} ${f.notes}`);
+            }
+            console.log("");
+            console.log(dim("HINT: Use napkin search <query> to find specific content. Use napkin read <file> to open a file."));
+        },
+    });
+}

package/dist/commands/properties.d.ts

@@ -0,0 +1,24 @@
+import { type OutputOptions } from "../utils/output.js";
+export declare function properties(opts: OutputOptions & {
+    vault?: string;
+    file?: string;
+    counts?: boolean;
+    total?: boolean;
+    sort?: string;
+}): Promise<void>;
+export declare function propertySet(opts: OutputOptions & {
+    vault?: string;
+    file?: string;
+    name?: string;
+    value?: string;
+}): Promise<void>;
+export declare function propertyRemove(opts: OutputOptions & {
+    vault?: string;
+    file?: string;
+    name?: string;
+}): Promise<void>;
+export declare function propertyRead(opts: OutputOptions & {
+    vault?: string;
+    file?: string;
+    name?: string;
+}): Promise<void>;

package/dist/commands/properties.js

@@ -0,0 +1,115 @@
+import { Napkin } from "../sdk.js";
+import { EXIT_NOT_FOUND, EXIT_USER_ERROR } from "../utils/exit-codes.js";
+import { suggestFile } from "../utils/files.js";
+import { error, fileNotFound, output, success, } from "../utils/output.js";
+export async function properties(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    const propCounts = n.properties(opts.file);
+    const entries = [...propCounts.entries()];
+    if (opts.sort === "count") {
+        entries.sort((a, b) => b[1] - a[1]);
+    }
+    else {
+        entries.sort((a, b) => a[0].localeCompare(b[0]));
+    }
+    output(opts, {
+        json: () => {
+            if (opts.total)
+                return { total: entries.length };
+            if (opts.counts)
+                return { properties: Object.fromEntries(entries) };
+            return { properties: entries.map(([p]) => p) };
+        },
+        human: () => {
+            if (opts.total) {
+                console.log(entries.length);
+            }
+            else {
+                for (const [prop, count] of entries) {
+                    console.log(opts.counts ? `${prop}\t${count}` : prop);
+                }
+            }
+        },
+    });
+}
+export async function propertySet(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    if (!opts.name || opts.value === undefined) {
+        error("Usage: property:set --name <name> --value <value> --file <file>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    if (!opts.file) {
+        error("No file specified. Use --file <name>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    let result;
+    try {
+        result = n.propertySet(opts.file, opts.name, opts.value);
+    }
+    catch (e) {
+        const msg = e.message;
+        if (msg.startsWith("File not found:")) {
+            fileNotFound(opts.file, suggestFile(n.vault.contentPath, opts.file));
+            process.exit(EXIT_NOT_FOUND);
+        }
+        throw e;
+    }
+    output(opts, {
+        json: () => result,
+        human: () => success(`Set ${result.property} = ${opts.value} on ${result.path}`),
+    });
+}
+export async function propertyRemove(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    if (!opts.name) {
+        error("No property name specified. Use --name <name>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    if (!opts.file) {
+        error("No file specified. Use --file <name>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    let result;
+    try {
+        result = n.propertyRemove(opts.file, opts.name);
+    }
+    catch (e) {
+        const msg = e.message;
+        if (msg.startsWith("File not found:")) {
+            fileNotFound(opts.file, suggestFile(n.vault.contentPath, opts.file));
+            process.exit(EXIT_NOT_FOUND);
+        }
+        throw e;
+    }
+    output(opts, {
+        json: () => result,
+        human: () => success(`Removed ${result.removed} from ${result.path}`),
+    });
+}
+export async function propertyRead(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    if (!opts.name) {
+        error("No property name specified. Use --name <name>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    if (!opts.file) {
+        error("No file specified. Use --file <name>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    let result;
+    try {
+        result = n.propertyGet(opts.file, opts.name);
+    }
+    catch (e) {
+        const msg = e.message;
+        if (msg.startsWith("File not found:")) {
+            fileNotFound(opts.file, suggestFile(n.vault.contentPath, opts.file));
+            process.exit(EXIT_NOT_FOUND);
+        }
+        throw e;
+    }
+    output(opts, {
+        json: () => result,
+        human: () => console.log(result.value !== null ? String(result.value) : ""),
+    });
+}

package/dist/commands/search.d.ts

@@ -0,0 +1,13 @@
+import { type OutputOptions } from "../utils/output.js";
+interface SearchOpts extends OutputOptions {
+    vault?: string;
+    query?: string;
+    path?: string;
+    limit?: string;
+    total?: boolean;
+    snippetLines?: string;
+    snippets?: boolean;
+    score?: boolean;
+}
+export declare function search(opts: SearchOpts): Promise<void>;
+export {};

package/dist/commands/search.js

@@ -0,0 +1,48 @@
+import { Napkin } from "../sdk.js";
+import { EXIT_USER_ERROR } from "../utils/exit-codes.js";
+import { bold, dim, error, output, } from "../utils/output.js";
+export async function search(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    if (!opts.query) {
+        error("No query specified. Use --query <text>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    const top = n.search(opts.query, {
+        path: opts.path,
+        limit: opts.limit ? Number.parseInt(opts.limit, 10) : undefined,
+        snippetLines: opts.snippetLines
+            ? Number.parseInt(opts.snippetLines, 10)
+            : undefined,
+        snippets: opts.snippets,
+    });
+    output(opts, {
+        json: () => {
+            if (opts.total)
+                return { total: top.length };
+            const mapResult = (r) => {
+                const { score: _score, snippets, ...rest } = r;
+                const out = { ...rest };
+                if (opts.score)
+                    out.score = r.score;
+                if (opts.snippets !== false)
+                    out.snippets = snippets;
+                return out;
+            };
+            return { results: top.map(mapResult) };
+        },
+        human: () => {
+            if (opts.total) {
+                console.log(top.length);
+                return;
+            }
+            for (const r of top) {
+                console.log(`${bold(r.file)} ${dim(`(${opts.score ? `score: ${r.score}, ` : ""}links: ${r.links}, modified: ${r.modified})`)}`);
+                for (const s of r.snippets) {
+                    console.log(`  ${dim(`${s.line}:`)} ${s.text}`);
+                }
+            }
+            console.log("");
+            console.log(dim("HINT: Use napkin read <file> to open a full file. Use napkin outline --file <file> to see its structure."));
+        },
+    });
+}

package/dist/commands/tags.d.ts

@@ -0,0 +1,13 @@
+import { type OutputOptions } from "../utils/output.js";
+export declare function tags(opts: OutputOptions & {
+    vault?: string;
+    file?: string;
+    counts?: boolean;
+    total?: boolean;
+    sort?: string;
+}): Promise<void>;
+export declare function tag(opts: OutputOptions & {
+    vault?: string;
+    name?: string;
+    verbose?: boolean;
+}): Promise<void>;

package/dist/commands/tags.js

@@ -0,0 +1,51 @@
+import { Napkin } from "../sdk.js";
+import { EXIT_USER_ERROR } from "../utils/exit-codes.js";
+import { bold, dim, error, output, } from "../utils/output.js";
+export async function tags(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    const { tagCounts } = n.tags(opts.file);
+    const entries = [...tagCounts.entries()];
+    if (opts.sort === "count") {
+        entries.sort((a, b) => b[1] - a[1]);
+    }
+    else {
+        entries.sort((a, b) => a[0].localeCompare(b[0]));
+    }
+    output(opts, {
+        json: () => {
+            if (opts.total)
+                return { total: entries.length };
+            if (opts.counts)
+                return { tags: Object.fromEntries(entries) };
+            return { tags: entries.map(([t]) => t) };
+        },
+        human: () => {
+            if (opts.total) {
+                console.log(entries.length);
+            }
+            else {
+                for (const [tag, count] of entries) {
+                    console.log(opts.counts ? `${tag}\t${count}` : tag);
+                }
+            }
+        },
+    });
+}
+export async function tag(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    if (!opts.name) {
+        error("No tag name specified. Use --name <tag>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    const { tag: _tag, count, files } = n.tagInfo(opts.name);
+    output(opts, {
+        json: () => ({ tag: opts.name, count, ...(opts.verbose ? { files } : {}) }),
+        human: () => {
+            console.log(`${bold(opts.name)}  ${count} occurrence${count !== 1 ? "s" : ""}`);
+            if (opts.verbose) {
+                for (const f of files)
+                    console.log(`  ${dim(f)}`);
+            }
+        },
+    });
+}

package/dist/commands/tasks.d.ts

@@ -0,0 +1,22 @@
+import { type OutputOptions } from "../utils/output.js";
+export declare function tasks(opts: OutputOptions & {
+    vault?: string;
+    file?: string;
+    done?: boolean;
+    todo?: boolean;
+    total?: boolean;
+    verbose?: boolean;
+    daily?: boolean;
+    status?: string;
+}): Promise<void>;
+export declare function task(opts: OutputOptions & {
+    vault?: string;
+    file?: string;
+    line?: string;
+    ref?: string;
+    toggle?: boolean;
+    done?: boolean;
+    todo?: boolean;
+    status?: string;
+    daily?: boolean;
+}): Promise<void>;

package/dist/commands/tasks.js

@@ -0,0 +1,106 @@
+import { resolveTaskLocation } from "../core/tasks.js";
+import { Napkin } from "../sdk.js";
+import { EXIT_NOT_FOUND, EXIT_USER_ERROR } from "../utils/exit-codes.js";
+import { suggestFile } from "../utils/files.js";
+import { bold, dim, error, fileNotFound, output, } from "../utils/output.js";
+export async function tasks(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    const result = n.tasks({
+        file: opts.file,
+        daily: opts.daily,
+        done: opts.done,
+        todo: opts.todo,
+        status: opts.status,
+    });
+    output(opts, {
+        json: () => (opts.total ? { total: result.length } : { tasks: result }),
+        human: () => {
+            if (opts.total) {
+                console.log(result.length);
+            }
+            else if (opts.verbose) {
+                const byFile = new Map();
+                for (const t of result) {
+                    if (!byFile.has(t.file))
+                        byFile.set(t.file, []);
+                    byFile.get(t.file)?.push(t);
+                }
+                for (const [file, tasks] of byFile) {
+                    console.log(bold(file));
+                    for (const t of tasks) {
+                        console.log(`  ${dim(`${t.line}:`)} [${t.status}] ${t.text}`);
+                    }
+                }
+            }
+            else {
+                for (const t of result) {
+                    console.log(`[${t.status}] ${t.text}`);
+                }
+            }
+        },
+    });
+}
+export async function task(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    let filePath;
+    let lineNum;
+    try {
+        ({ filePath, lineNum } = resolveTaskLocation(n.vault, opts));
+    }
+    catch (e) {
+        const msg = e.message;
+        if (msg.includes("File not found")) {
+            const ref = opts.ref?.split(":")[0] || opts.file || "";
+            fileNotFound(ref, suggestFile(n.vault.contentPath, ref));
+            process.exit(EXIT_NOT_FOUND);
+        }
+        error(msg);
+        process.exit(EXIT_USER_ERROR);
+    }
+    let taskInfo;
+    try {
+        taskInfo = n.taskShow(filePath, lineNum);
+    }
+    catch (e) {
+        const msg = e.message;
+        error(msg);
+        process.exit(msg.includes("is not a task") ? EXIT_USER_ERROR : EXIT_NOT_FOUND);
+    }
+    const { currentStatus } = taskInfo;
+    const isMutating = opts.toggle || opts.done || opts.todo || opts.status;
+    if (isMutating) {
+        let newStatus;
+        if (opts.status)
+            newStatus = opts.status;
+        else if (opts.done)
+            newStatus = "x";
+        else if (opts.todo)
+            newStatus = " ";
+        else if (opts.toggle)
+            newStatus = currentStatus === " " ? "x" : " ";
+        else
+            newStatus = currentStatus;
+        const result = n.taskUpdate(filePath, lineNum, newStatus);
+        output(opts, {
+            json: () => result,
+            human: () => console.log(`[${result.status}] ${result.text}`),
+        });
+    }
+    else {
+        output(opts, {
+            json: () => ({
+                file: filePath,
+                line: lineNum,
+                status: currentStatus,
+                text: taskInfo.text,
+                done: currentStatus === "x" || currentStatus === "X",
+            }),
+            human: () => {
+                console.log(`${dim("file")}    ${filePath}`);
+                console.log(`${dim("line")}    ${lineNum}`);
+                console.log(`${dim("status")}  [${currentStatus}]`);
+                console.log(`${dim("text")}    ${taskInfo.text}`);
+            },
+        });
+    }
+}

package/dist/commands/templates.d.ts

@@ -0,0 +1,16 @@
+import { type OutputOptions } from "../utils/output.js";
+export declare function templates(opts: OutputOptions & {
+    vault?: string;
+    total?: boolean;
+}): Promise<void>;
+export declare function templateRead(opts: OutputOptions & {
+    vault?: string;
+    name?: string;
+    resolve?: boolean;
+    title?: string;
+}): Promise<void>;
+export declare function templateInsert(opts: OutputOptions & {
+    vault?: string;
+    name?: string;
+    file?: string;
+}): Promise<void>;