@cad0p/napkin 0.8.1

package/dist/commands/canvas.js

@@ -0,0 +1,186 @@
+import { Napkin } from "../sdk.js";
+import { EXIT_NOT_FOUND, EXIT_USER_ERROR } from "../utils/exit-codes.js";
+import { bold, dim, error, output, success, } from "../utils/output.js";
+export async function canvases(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    const files = n.canvases();
+    output(opts, {
+        json: () => (opts.total ? { total: files.length } : { canvases: files }),
+        human: () => {
+            if (opts.total) {
+                console.log(files.length);
+            }
+            else if (files.length === 0) {
+                console.log("No .canvas files found");
+            }
+            else {
+                for (const f of files)
+                    console.log(f);
+            }
+        },
+    });
+}
+export async function canvasRead(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 canvas;
+    let filePath;
+    try {
+        ({ canvas, filePath } = n.canvasRead(opts.file));
+    }
+    catch (e) {
+        error(e.message);
+        process.exit(EXIT_NOT_FOUND);
+    }
+    output(opts, {
+        json: () => ({ path: filePath, ...canvas }),
+        human: () => {
+            console.log(bold(filePath));
+            console.log(`${canvas.nodes.length} nodes, ${canvas.edges.length} edges`);
+            console.log();
+            for (const node of canvas.nodes) {
+                const desc = node.type === "text"
+                    ? (node.text?.split("\n")[0] || "").slice(0, 60)
+                    : node.type === "file"
+                        ? node.file
+                        : node.type === "link"
+                            ? node.url
+                            : node.type === "group"
+                                ? node.label || "(unnamed group)"
+                                : "";
+                console.log(`  ${dim(node.id.slice(0, 8))}  ${node.type.padEnd(6)} ${desc}`);
+            }
+            if (canvas.edges.length > 0) {
+                console.log();
+                for (const edge of canvas.edges) {
+                    const label = edge.label ? ` "${edge.label}"` : "";
+                    console.log(`  ${dim(edge.id.slice(0, 8))}  ${edge.fromNode.slice(0, 8)} → ${edge.toNode.slice(0, 8)}${label}`);
+                }
+            }
+        },
+    });
+}
+export async function canvasNodes(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 canvas;
+    try {
+        ({ canvas } = n.canvasRead(opts.file));
+    }
+    catch (e) {
+        error(e.message);
+        process.exit(EXIT_NOT_FOUND);
+    }
+    let nodes = canvas.nodes;
+    if (opts.type) {
+        nodes = nodes.filter((n) => n.type === opts.type);
+    }
+    output(opts, {
+        json: () => ({ nodes }),
+        human: () => {
+            for (const node of nodes) {
+                const desc = node.type === "text"
+                    ? (node.text?.split("\n")[0] || "").slice(0, 60)
+                    : node.type === "file"
+                        ? node.file
+                        : node.type === "link"
+                            ? node.url
+                            : node.label || "";
+                console.log(`${node.id}  ${node.type.padEnd(6)} ${desc}`);
+            }
+        },
+    });
+}
+export async function canvasCreate(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    if (!opts.file) {
+        error("No file name specified. Use --file <name>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    let result;
+    try {
+        result = n.canvasCreate(opts.file, opts.path);
+    }
+    catch (e) {
+        error(e.message);
+        process.exit(EXIT_USER_ERROR);
+    }
+    output(opts, {
+        json: () => result,
+        human: () => success(`Created ${result.path}`),
+    });
+}
+export async function canvasAddNode(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    if (!opts.file) {
+        error("No canvas file specified. Use --file <name>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    let result;
+    try {
+        result = n.canvasAddNode(opts.file, opts);
+    }
+    catch (e) {
+        error(e.message);
+        process.exit(EXIT_NOT_FOUND);
+    }
+    output(opts, {
+        json: () => result,
+        human: () => success(`Added ${result.type} node ${result.id}`),
+    });
+}
+export async function canvasAddEdge(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    if (!opts.file) {
+        error("No canvas file specified. Use --file <name>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    if (!opts.from || !opts.to) {
+        error("Both --from and --to node IDs required");
+        process.exit(EXIT_USER_ERROR);
+    }
+    let result;
+    try {
+        result = n.canvasAddEdge(opts.file, {
+            from: opts.from,
+            to: opts.to,
+            fromSide: opts.fromSide,
+            toSide: opts.toSide,
+            label: opts.label,
+            color: opts.color,
+        });
+    }
+    catch (e) {
+        error(e.message);
+        process.exit(EXIT_NOT_FOUND);
+    }
+    output(opts, {
+        json: () => result,
+        human: () => success(`Added edge ${result.from.slice(0, 8)} → ${result.to.slice(0, 8)}`),
+    });
+}
+export async function canvasRemoveNode(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    if (!opts.file || !opts.id) {
+        error("Both --file and --id required");
+        process.exit(EXIT_USER_ERROR);
+    }
+    let result;
+    try {
+        result = n.canvasRemoveNode(opts.file, opts.id);
+    }
+    catch (e) {
+        error(e.message);
+        process.exit(EXIT_NOT_FOUND);
+    }
+    output(opts, {
+        json: () => result,
+        human: () => success(`Removed node ${result.id}`),
+    });
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,13 @@
+import { type OutputOptions } from "../utils/output.js";
+export declare function configShow(opts: OutputOptions & {
+    vault?: string;
+}): Promise<void>;
+export declare function configSet(opts: OutputOptions & {
+    vault?: string;
+    key?: string;
+    value?: string;
+}): Promise<void>;
+export declare function configGet(opts: OutputOptions & {
+    vault?: string;
+    key?: string;
+}): Promise<void>;

package/dist/commands/config.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 configShow(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    const config = n.config();
+    output(opts, {
+        json: () => config,
+        human: () => {
+            console.log(JSON.stringify(config, null, 2));
+        },
+    });
+}
+export async function configSet(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    if (!opts.key || opts.value === undefined) {
+        error("Usage: napkin config set --key <path> --value <value>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    const { config: updated, parsed } = n.configSet(opts.key, opts.value);
+    output(opts, {
+        json: () => updated,
+        human: () => {
+            console.log(`${dim("set")} ${bold(opts.key)} = ${JSON.stringify(parsed)}`);
+        },
+    });
+}
+export async function configGet(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    if (!opts.key) {
+        error("Usage: napkin config get --key <path>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    const value = n.configGet(opts.key);
+    output(opts, {
+        json: () => ({ key: opts.key, value }),
+        human: () => {
+            if (value === undefined) {
+                console.log(dim("(not set)"));
+            }
+            else {
+                console.log(typeof value === "object"
+                    ? JSON.stringify(value, null, 2)
+                    : String(value));
+            }
+        },
+    });
+}

package/dist/commands/crud.d.ts

@@ -0,0 +1,40 @@
+import { type OutputOptions } from "../utils/output.js";
+export declare function read(fileRef: string | undefined, opts: OutputOptions & {
+    vault?: string;
+}): Promise<void>;
+export declare function create(opts: OutputOptions & {
+    vault?: string;
+    name?: string;
+    path?: string;
+    content?: string;
+    template?: string;
+    overwrite?: boolean;
+    open?: boolean;
+}): Promise<void>;
+export declare function append(opts: OutputOptions & {
+    vault?: string;
+    file?: string;
+    content?: string;
+    inline?: boolean;
+}): Promise<void>;
+export declare function prepend(opts: OutputOptions & {
+    vault?: string;
+    file?: string;
+    content?: string;
+    inline?: boolean;
+}): Promise<void>;
+export declare function move(opts: OutputOptions & {
+    vault?: string;
+    file?: string;
+    to?: string;
+}): Promise<void>;
+export declare function rename(opts: OutputOptions & {
+    vault?: string;
+    file?: string;
+    name?: string;
+}): Promise<void>;
+export declare function del(opts: OutputOptions & {
+    vault?: string;
+    file?: string;
+    permanent?: boolean;
+}): Promise<void>;

package/dist/commands/crud.js

@@ -0,0 +1,195 @@
+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 read(fileRef, opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    if (!fileRef) {
+        error("No file specified. Usage: napkin read <file>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    let result;
+    try {
+        result = n.read(fileRef);
+    }
+    catch (e) {
+        const msg = e.message;
+        if (msg.startsWith("File not found:")) {
+            fileNotFound(fileRef, suggestFile(n.vault.contentPath, fileRef));
+            process.exit(EXIT_NOT_FOUND);
+        }
+        throw e;
+    }
+    output(opts, {
+        json: () => result,
+        human: () => console.log(result.content),
+    });
+}
+export async function create(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    let result;
+    try {
+        result = n.create({
+            name: opts.name,
+            path: opts.path,
+            content: opts.content,
+            template: opts.template,
+            overwrite: opts.overwrite,
+        });
+    }
+    catch (e) {
+        error(e.message);
+        process.exit(EXIT_USER_ERROR);
+    }
+    output(opts, {
+        json: () => result,
+        human: () => success(`Created ${result.path}`),
+    });
+}
+async function readStdin() {
+    if (process.stdin.isTTY)
+        return undefined;
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    const result = Buffer.concat(chunks).toString("utf-8").trimEnd();
+    return result || undefined;
+}
+export async function append(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    if (!opts.file) {
+        error("No file specified. Use: napkin append <file> [content]");
+        process.exit(EXIT_USER_ERROR);
+    }
+    if (!opts.content) {
+        opts.content = await readStdin();
+    }
+    if (!opts.content) {
+        error("No content specified. Use: napkin append <file> <content>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    let resolved;
+    try {
+        resolved = n.append(opts.file, opts.content, opts.inline);
+    }
+    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: () => ({ path: resolved, appended: true }),
+        human: () => success(`Appended to ${resolved}`),
+    });
+}
+export async function prepend(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    if (!opts.file) {
+        error("No file specified. Use: napkin prepend <file> [content]");
+        process.exit(EXIT_USER_ERROR);
+    }
+    if (!opts.content) {
+        opts.content = await readStdin();
+    }
+    if (!opts.content) {
+        error("No content specified. Use: napkin prepend <file> <content>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    let resolved;
+    try {
+        resolved = n.prepend(opts.file, opts.content, opts.inline);
+    }
+    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: () => ({ path: resolved, prepended: true }),
+        human: () => success(`Prepended to ${resolved}`),
+    });
+}
+export async function move(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    if (!opts.file) {
+        error("No file specified. Use --file <name>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    if (!opts.to) {
+        error("No destination specified. Use --to <path>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    let result;
+    try {
+        result = n.move(opts.file, opts.to);
+    }
+    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(`Moved ${result.from} → ${result.to}`),
+    });
+}
+export async function rename(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    if (!opts.file) {
+        error("No file specified. Use --file <name>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    if (!opts.name) {
+        error("No new name specified. Use --name <name>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    let result;
+    try {
+        result = n.rename(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(`Renamed ${result.from} → ${result.to}`),
+    });
+}
+export async function del(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 result;
+    try {
+        result = n.delete(opts.file, opts.permanent);
+    }
+    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(`Deleted ${result.path}${result.permanent ? " (permanent)" : " (moved to .trash)"}`),
+    });
+}

package/dist/commands/daily.d.ts

@@ -0,0 +1,20 @@
+import { type OutputOptions } from "../utils/output.js";
+export declare function daily(opts: OutputOptions & {
+    vault?: string;
+}): Promise<void>;
+export declare function dailyPath(opts: OutputOptions & {
+    vault?: string;
+}): Promise<void>;
+export declare function dailyRead(opts: OutputOptions & {
+    vault?: string;
+}): Promise<void>;
+export declare function dailyAppend(opts: OutputOptions & {
+    vault?: string;
+    content?: string;
+    inline?: boolean;
+}): Promise<void>;
+export declare function dailyPrepend(opts: OutputOptions & {
+    vault?: string;
+    content?: string;
+    inline?: boolean;
+}): Promise<void>;

package/dist/commands/daily.js

@@ -0,0 +1,58 @@
+import { Napkin } from "../sdk.js";
+import { EXIT_NOT_FOUND, EXIT_USER_ERROR } from "../utils/exit-codes.js";
+import { error, output, success } from "../utils/output.js";
+export async function daily(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    const result = n.dailyEnsure();
+    output(opts, {
+        json: () => result,
+        human: () => success(`Daily note: ${result.path}`),
+    });
+}
+export async function dailyPath(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    const dp = n.dailyPath();
+    output(opts, {
+        json: () => ({ path: dp }),
+        human: () => console.log(dp),
+    });
+}
+export async function dailyRead(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    let result;
+    try {
+        result = n.dailyRead();
+    }
+    catch (e) {
+        error(e.message);
+        process.exit(EXIT_NOT_FOUND);
+    }
+    output(opts, {
+        json: () => result,
+        human: () => console.log(result.content),
+    });
+}
+export async function dailyAppend(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    if (!opts.content) {
+        error("No content specified. Use --content <text>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    const dp = n.dailyAppend(opts.content, opts.inline);
+    output(opts, {
+        json: () => ({ path: dp, appended: true }),
+        human: () => success(`Appended to ${dp}`),
+    });
+}
+export async function dailyPrepend(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    if (!opts.content) {
+        error("No content specified. Use --content <text>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    const dp = n.dailyPrepend(opts.content, opts.inline);
+    output(opts, {
+        json: () => ({ path: dp, prepended: true }),
+        human: () => success(`Prepended to ${dp}`),
+    });
+}

package/dist/commands/files.d.ts

@@ -0,0 +1,23 @@
+import { type OutputOptions } from "../utils/output.js";
+export declare function file(fileRef: string | undefined, opts: OutputOptions & {
+    vault?: string;
+}): Promise<void>;
+export declare function files(opts: OutputOptions & {
+    vault?: string;
+    folder?: string;
+    ext?: string;
+    total?: boolean;
+}): Promise<void>;
+export declare function folders(opts: OutputOptions & {
+    vault?: string;
+    folder?: string;
+    total?: boolean;
+}): Promise<void>;
+export declare function folder(folderPath: string | undefined, opts: OutputOptions & {
+    vault?: string;
+    info?: string;
+}): Promise<void>;
+export declare function open(fileRef: string | undefined, opts: OutputOptions & {
+    vault?: string;
+    newtab?: boolean;
+}): Promise<void>;