@cad0p/napkin 0.8.1

package/dist/commands/templates.js

@@ -0,0 +1,70 @@
+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 templates(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    const files = n.templates();
+    output(opts, {
+        json: () => (opts.total ? { total: files.length } : { templates: files }),
+        human: () => {
+            if (opts.total)
+                console.log(files.length);
+            else
+                for (const f of files)
+                    console.log(f);
+        },
+    });
+}
+export async function templateRead(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    if (!opts.name) {
+        error("No template name specified. Use --name <template>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    let result;
+    try {
+        result = n.templateRead(opts.name, {
+            resolve: opts.resolve,
+            title: opts.title,
+        });
+    }
+    catch (e) {
+        error(e.message);
+        process.exit(EXIT_NOT_FOUND);
+    }
+    output(opts, {
+        json: () => result,
+        human: () => console.log(result.content),
+    });
+}
+export async function templateInsert(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    const templateName = opts.name;
+    const targetFile = opts.file;
+    if (!templateName) {
+        error("No template name specified. Use --name <template>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    if (!targetFile) {
+        error("No target file specified. Use --file <name>");
+        process.exit(EXIT_USER_ERROR);
+    }
+    let result;
+    try {
+        result = n.templateInsert(templateName, targetFile);
+    }
+    catch (e) {
+        if (e.message.includes("File not found")) {
+            fileNotFound(targetFile, suggestFile(n.vault.contentPath, targetFile));
+        }
+        else {
+            error(e.message);
+        }
+        process.exit(EXIT_NOT_FOUND);
+    }
+    output(opts, {
+        json: () => result,
+        human: () => success(`Inserted template "${result.template}" into ${result.file}`),
+    });
+}

package/dist/commands/vault.d.ts

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

package/dist/commands/vault.js

@@ -0,0 +1,17 @@
+import { formatSize } from "../core/vault.js";
+import { Napkin } from "../sdk.js";
+import { bold, dim, output } from "../utils/output.js";
+export async function vault(opts) {
+    const n = new Napkin(opts.vault || process.cwd());
+    const meta = n.info();
+    output(opts, {
+        json: () => meta,
+        human: () => {
+            console.log(`${dim("name")}       ${bold(meta.name)}`);
+            console.log(`${dim("path")}       ${meta.path}`);
+            console.log(`${dim("files")}      ${meta.files}`);
+            console.log(`${dim("folders")}    ${meta.folders}`);
+            console.log(`${dim("size")}       ${formatSize(meta.size)}`);
+        },
+    });
+}

package/dist/commands/wordcount.d.ts

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

package/dist/commands/wordcount.js

@@ -0,0 +1,43 @@
+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 wordcount(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.wordcount(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;
+    }
+    const { words, characters } = result;
+    output(opts, {
+        json: () => {
+            if (opts.words)
+                return { words };
+            if (opts.characters)
+                return { characters };
+            return { words, characters };
+        },
+        human: () => {
+            if (opts.words)
+                console.log(words);
+            else if (opts.characters)
+                console.log(characters);
+            else {
+                console.log(`${dim("words")}       ${words}`);
+                console.log(`${dim("characters")}  ${characters}`);
+            }
+        },
+    });
+}

package/dist/core/aliases.d.ts

@@ -0,0 +1,5 @@
+export interface AliasEntry {
+    alias: string;
+    file: string;
+}
+export declare function collectAliases(vaultPath: string, fileFilter?: string): AliasEntry[];

package/dist/core/aliases.js

@@ -0,0 +1,26 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { listFiles, resolveFile } from "../utils/files.js";
+import { parseFrontmatter } from "../utils/frontmatter.js";
+export function collectAliases(vaultPath, fileFilter) {
+    const files = fileFilter
+        ? (() => {
+            const r = resolveFile(vaultPath, fileFilter);
+            return r ? [r] : [];
+        })()
+        : listFiles(vaultPath, { ext: "md" });
+    const results = [];
+    for (const file of files) {
+        const content = fs.readFileSync(path.join(vaultPath, file), "utf-8");
+        const { properties } = parseFrontmatter(content);
+        const aliases = properties.aliases;
+        if (Array.isArray(aliases)) {
+            for (const a of aliases)
+                results.push({ alias: String(a), file });
+        }
+        else if (typeof aliases === "string" && aliases) {
+            results.push({ alias: aliases, file });
+        }
+    }
+    return results;
+}

package/dist/core/bases.d.ts

@@ -0,0 +1,29 @@
+export interface BaseView {
+    name: string;
+    type: string;
+}
+export interface BaseQueryResult {
+    columns: string[];
+    rows: unknown[][];
+    displayNames?: Record<string, string>;
+    groups?: {
+        key: string;
+        rows: unknown[][];
+    }[];
+    summaries?: Record<string, unknown>;
+}
+export declare function listBases(vaultPath: string): string[];
+export declare function resolveBaseFile(vaultPath: string, opts: {
+    file?: string;
+    path?: string;
+}): string | null;
+export declare function getBaseViews(vaultPath: string, baseFile: string): BaseView[];
+export declare function queryBaseFile(vaultPath: string, baseFile: string, viewName?: string): Promise<BaseQueryResult>;
+export declare function createBaseItem(vaultPath: string, opts: {
+    name: string;
+    path?: string;
+    content?: string;
+}): {
+    path: string;
+    created: boolean;
+};

package/dist/core/bases.js

@@ -0,0 +1,67 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { buildDatabase, parseBaseFile, queryBase } from "../utils/bases.js";
+import { listFiles } from "../utils/files.js";
+export function listBases(vaultPath) {
+    return listFiles(vaultPath).filter((f) => f.endsWith(".base"));
+}
+export function resolveBaseFile(vaultPath, opts) {
+    if (opts.path) {
+        const p = opts.path.endsWith(".base") ? opts.path : `${opts.path}.base`;
+        if (fs.existsSync(path.join(vaultPath, p)))
+            return p;
+        return null;
+    }
+    if (opts.file) {
+        const allFiles = listFiles(vaultPath).filter((f) => f.endsWith(".base"));
+        const target = opts.file.toLowerCase();
+        for (const f of allFiles) {
+            const basename = path.basename(f, ".base").toLowerCase();
+            if (basename === target)
+                return f;
+        }
+        const withExt = opts.file.endsWith(".base")
+            ? opts.file
+            : `${opts.file}.base`;
+        if (fs.existsSync(path.join(vaultPath, withExt)))
+            return withExt;
+        return null;
+    }
+    return null;
+}
+export function getBaseViews(vaultPath, baseFile) {
+    const content = fs.readFileSync(path.join(vaultPath, baseFile), "utf-8");
+    const config = parseBaseFile(content);
+    return (config.views || []).map((view) => ({
+        name: view.name || "(unnamed)",
+        type: view.type,
+    }));
+}
+export async function queryBaseFile(vaultPath, baseFile, viewName) {
+    const content = fs.readFileSync(path.join(vaultPath, baseFile), "utf-8");
+    const config = parseBaseFile(content);
+    const db = await buildDatabase(vaultPath);
+    try {
+        const thisFile = {
+            name: path.basename(baseFile),
+            path: baseFile,
+            folder: path.dirname(baseFile),
+        };
+        const result = await queryBase(db, config, viewName, thisFile);
+        return result;
+    }
+    finally {
+        db.close();
+    }
+}
+export function createBaseItem(vaultPath, opts) {
+    const targetPath = opts.path
+        ? opts.path.endsWith(".md")
+            ? opts.path
+            : `${opts.path}/${opts.name}.md`
+        : `${opts.name}.md`;
+    const fullPath = path.join(vaultPath, targetPath);
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    fs.writeFileSync(fullPath, opts.content || "");
+    return { path: targetPath, created: true };
+}

package/dist/core/bookmarks.d.ts

@@ -0,0 +1,14 @@
+export interface Bookmark {
+    type: string;
+    title?: string;
+    path?: string;
+    query?: string;
+    url?: string;
+    subpath?: string;
+    items?: Bookmark[];
+}
+export declare function readBookmarks(obsidianPath: string): Bookmark[];
+export declare function flattenBookmarks(items: Bookmark[]): Bookmark[];
+export declare function addBookmark(obsidianPath: string, entry: Bookmark): {
+    added: Bookmark;
+};

package/dist/core/bookmarks.js

@@ -0,0 +1,34 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+export function readBookmarks(obsidianPath) {
+    const configPath = path.join(obsidianPath, "bookmarks.json");
+    try {
+        const content = fs.readFileSync(configPath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return [];
+    }
+}
+function writeBookmarks(obsidianPath, bookmarks) {
+    const configPath = path.join(obsidianPath, "bookmarks.json");
+    fs.writeFileSync(configPath, JSON.stringify(bookmarks, null, 2));
+}
+export function flattenBookmarks(items) {
+    const result = [];
+    for (const item of items) {
+        if (item.type === "group" && item.items) {
+            result.push(...flattenBookmarks(item.items));
+        }
+        else {
+            result.push(item);
+        }
+    }
+    return result;
+}
+export function addBookmark(obsidianPath, entry) {
+    const items = readBookmarks(obsidianPath);
+    items.push(entry);
+    writeBookmarks(obsidianPath, items);
+    return { added: entry };
+}

package/dist/core/canvas.d.ts

@@ -0,0 +1,74 @@
+export interface CanvasNode {
+    id: string;
+    type: "text" | "file" | "link" | "group";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    text?: string;
+    file?: string;
+    subpath?: string;
+    url?: string;
+    label?: string;
+    color?: string;
+    background?: string;
+    backgroundStyle?: string;
+}
+export interface CanvasEdge {
+    id: string;
+    fromNode: string;
+    fromSide?: string;
+    fromEnd?: string;
+    toNode: string;
+    toSide?: string;
+    toEnd?: string;
+    color?: string;
+    label?: string;
+}
+export interface Canvas {
+    nodes: CanvasNode[];
+    edges: CanvasEdge[];
+}
+export declare function resolveCanvas(vaultPath: string, fileRef: string): {
+    canvas: Canvas;
+    filePath: string;
+};
+export declare function listCanvases(vaultPath: string): string[];
+export declare function createCanvas(vaultPath: string, fileName: string, folder?: string): {
+    path: string;
+    created: boolean;
+};
+export declare function addCanvasNode(vaultPath: string, fileRef: string, opts: {
+    type?: string;
+    text?: string;
+    noteFile?: string;
+    subpath?: string;
+    url?: string;
+    label?: string;
+    x?: string;
+    y?: string;
+    width?: string;
+    height?: string;
+    color?: string;
+}): {
+    id: string;
+    type: string;
+    added: boolean;
+};
+export declare function addCanvasEdge(vaultPath: string, fileRef: string, opts: {
+    from: string;
+    to: string;
+    fromSide?: string;
+    toSide?: string;
+    label?: string;
+    color?: string;
+}): {
+    id: string;
+    from: string;
+    to: string;
+    added: boolean;
+};
+export declare function removeCanvasNode(vaultPath: string, fileRef: string, nodeId: string): {
+    id: string;
+    removed: boolean;
+};

package/dist/core/canvas.js

@@ -0,0 +1,125 @@
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { listFiles } from "../utils/files.js";
+function genId() {
+    return crypto.randomBytes(8).toString("hex");
+}
+export function resolveCanvas(vaultPath, fileRef) {
+    let filePath = fileRef;
+    if (!filePath.endsWith(".canvas"))
+        filePath = `${filePath}.canvas`;
+    const fullPath = path.join(vaultPath, filePath);
+    if (!fs.existsSync(fullPath)) {
+        const all = listFiles(vaultPath).filter((f) => f.endsWith(".canvas"));
+        const target = fileRef.toLowerCase().replace(/\.canvas$/, "");
+        const found = all.find((f) => path.basename(f, ".canvas").toLowerCase() === target);
+        if (!found) {
+            throw new Error(`Canvas not found: ${fileRef}`);
+        }
+        filePath = found;
+    }
+    const content = fs.readFileSync(path.join(vaultPath, filePath), "utf-8");
+    const canvas = JSON.parse(content);
+    canvas.nodes = canvas.nodes || [];
+    canvas.edges = canvas.edges || [];
+    return { canvas, filePath };
+}
+function writeCanvas(vaultPath, filePath, canvas) {
+    fs.writeFileSync(path.join(vaultPath, filePath), JSON.stringify(canvas, null, 2));
+}
+export function listCanvases(vaultPath) {
+    return listFiles(vaultPath).filter((f) => f.endsWith(".canvas"));
+}
+export function createCanvas(vaultPath, fileName, folder) {
+    const name = fileName.endsWith(".canvas") ? fileName : `${fileName}.canvas`;
+    const targetPath = folder ? `${folder}/${name}` : name;
+    const fullPath = path.join(vaultPath, targetPath);
+    if (fs.existsSync(fullPath)) {
+        throw new Error(`Canvas already exists: ${targetPath}`);
+    }
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    const canvas = { nodes: [], edges: [] };
+    writeCanvas(vaultPath, targetPath, canvas);
+    return { path: targetPath, created: true };
+}
+export function addCanvasNode(vaultPath, fileRef, opts) {
+    const nodeType = (opts.type || "text");
+    if (!["text", "file", "link", "group"].includes(nodeType)) {
+        throw new Error("Invalid node type. Use: text, file, link, or group");
+    }
+    const { canvas, filePath } = resolveCanvas(vaultPath, fileRef);
+    const maxX = canvas.nodes.reduce((max, n) => Math.max(max, n.x + n.width), 0);
+    const node = {
+        id: genId(),
+        type: nodeType,
+        x: opts.x
+            ? Number.parseInt(opts.x, 10)
+            : canvas.nodes.length > 0
+                ? maxX + 50
+                : 0,
+        y: opts.y ? Number.parseInt(opts.y, 10) : 0,
+        width: opts.width
+            ? Number.parseInt(opts.width, 10)
+            : nodeType === "group"
+                ? 600
+                : 300,
+        height: opts.height
+            ? Number.parseInt(opts.height, 10)
+            : nodeType === "group"
+                ? 400
+                : 150,
+    };
+    if (nodeType === "text")
+        node.text = opts.text || "";
+    if (nodeType === "file") {
+        node.file = opts.noteFile || "";
+        if (opts.subpath)
+            node.subpath = opts.subpath;
+    }
+    if (nodeType === "link")
+        node.url = opts.url || "";
+    if (nodeType === "group")
+        node.label = opts.label || "";
+    if (opts.color)
+        node.color = opts.color;
+    canvas.nodes.push(node);
+    writeCanvas(vaultPath, filePath, canvas);
+    return { id: node.id, type: node.type, added: true };
+}
+export function addCanvasEdge(vaultPath, fileRef, opts) {
+    const { canvas, filePath } = resolveCanvas(vaultPath, fileRef);
+    const findNode = (ref) => canvas.nodes.find((n) => n.id === ref || n.id.startsWith(ref));
+    const fromNode = findNode(opts.from);
+    const toNode = findNode(opts.to);
+    if (!fromNode)
+        throw new Error(`Node not found: ${opts.from}`);
+    if (!toNode)
+        throw new Error(`Node not found: ${opts.to}`);
+    const edge = {
+        id: genId(),
+        fromNode: fromNode.id,
+        toNode: toNode.id,
+    };
+    if (opts.fromSide)
+        edge.fromSide = opts.fromSide;
+    if (opts.toSide)
+        edge.toSide = opts.toSide;
+    if (opts.label)
+        edge.label = opts.label;
+    if (opts.color)
+        edge.color = opts.color;
+    canvas.edges.push(edge);
+    writeCanvas(vaultPath, filePath, canvas);
+    return { id: edge.id, from: edge.fromNode, to: edge.toNode, added: true };
+}
+export function removeCanvasNode(vaultPath, fileRef, nodeId) {
+    const { canvas, filePath } = resolveCanvas(vaultPath, fileRef);
+    const node = canvas.nodes.find((n) => n.id === nodeId || n.id.startsWith(nodeId));
+    if (!node)
+        throw new Error(`Node not found: ${nodeId}`);
+    canvas.nodes = canvas.nodes.filter((n) => n.id !== node.id);
+    canvas.edges = canvas.edges.filter((e) => e.fromNode !== node.id && e.toNode !== node.id);
+    writeCanvas(vaultPath, filePath, canvas);
+    return { id: node.id, removed: true };
+}

package/dist/core/config.d.ts

@@ -0,0 +1,7 @@
+import { loadConfig } from "../utils/config.js";
+export { loadConfig };
+export declare function getConfigValue(configPath: string, key: string): unknown;
+export declare function setConfigValue(configPath: string, key: string, rawValue: string): {
+    config: Record<string, unknown>;
+    parsed: unknown;
+};

package/dist/core/config.js

@@ -0,0 +1,35 @@
+import { loadConfig, updateConfig } from "../utils/config.js";
+export { loadConfig };
+export function getConfigValue(configPath, key) {
+    const config = loadConfig(configPath);
+    const parts = key.split(".");
+    let value = config;
+    for (const part of parts) {
+        if (value && typeof value === "object" && part in value) {
+            value = value[part];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return value;
+}
+export function setConfigValue(configPath, key, rawValue) {
+    const parts = key.split(".");
+    const obj = {};
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        current[parts[i]] = {};
+        current = current[parts[i]];
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(rawValue);
+    }
+    catch {
+        parsed = rawValue;
+    }
+    current[parts[parts.length - 1]] = parsed;
+    const updated = updateConfig(configPath, obj);
+    return { config: updated, parsed };
+}

package/dist/core/crud.d.ts

@@ -0,0 +1,32 @@
+import type { VaultInfo } from "../utils/vault.js";
+export interface ReadResult {
+    path: string;
+    content: string;
+}
+export interface CreateOptions {
+    name?: string;
+    path?: string;
+    content?: string;
+    template?: string;
+    overwrite?: boolean;
+}
+export interface CreateResult {
+    path: string;
+    created: boolean;
+}
+export interface MoveResult {
+    from: string;
+    to: string;
+}
+export interface DeleteResult {
+    path: string;
+    deleted: boolean;
+    permanent: boolean;
+}
+export declare function readFile(vaultPath: string, fileRef: string): ReadResult;
+export declare function createFile(v: VaultInfo, opts: CreateOptions): CreateResult;
+export declare function appendFile(vaultPath: string, fileRef: string, content: string, inline?: boolean): string;
+export declare function prependFile(vaultPath: string, fileRef: string, content: string, inline?: boolean): string;
+export declare function moveFile(vaultPath: string, fileRef: string, destination: string): MoveResult;
+export declare function renameFile(vaultPath: string, fileRef: string, newName: string): MoveResult;
+export declare function deleteFile(vaultPath: string, fileRef: string, permanent?: boolean): DeleteResult;