@cad0p/napkin 0.8.1

package/dist/core/crud.js

@@ -0,0 +1,119 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { loadConfig } from "../utils/config.js";
+import { listFiles, resolveFile } from "../utils/files.js";
+import { parseFrontmatter } from "../utils/frontmatter.js";
+export function readFile(vaultPath, fileRef) {
+    const resolved = resolveFile(vaultPath, fileRef);
+    if (!resolved) {
+        throw new Error(`File not found: ${fileRef}`);
+    }
+    const content = fs.readFileSync(path.join(vaultPath, resolved), "utf-8");
+    return { path: resolved, content };
+}
+export function createFile(v, opts) {
+    let targetPath;
+    if (opts.path) {
+        targetPath = opts.path.endsWith(".md") ? opts.path : `${opts.path}.md`;
+    }
+    else {
+        const name = opts.name || "Untitled";
+        targetPath = `${name}.md`;
+    }
+    const fullPath = path.join(v.contentPath, targetPath);
+    if (fs.existsSync(fullPath) && !opts.overwrite) {
+        throw new Error(`File already exists: ${targetPath}. Use --overwrite to replace.`);
+    }
+    let content = opts.content || "";
+    if (opts.template) {
+        const config = loadConfig(v.configPath);
+        const templateRef = resolveFile(v.contentPath, opts.template) ||
+            resolveFile(v.contentPath, `${config.templates.folder}/${opts.template}`);
+        if (templateRef) {
+            content = fs.readFileSync(path.join(v.contentPath, templateRef), "utf-8");
+        }
+        else {
+            const tmplFiles = listFiles(v.contentPath, {
+                folder: config.templates.folder,
+                ext: "md",
+            }).map((f) => path.basename(f, ".md"));
+            throw new Error(`Template not found: ${opts.template}. Available: ${tmplFiles.slice(0, 3).join(", ")}`);
+        }
+    }
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    fs.writeFileSync(fullPath, content);
+    return { path: targetPath, created: true };
+}
+export function appendFile(vaultPath, fileRef, content, inline) {
+    const resolved = resolveFile(vaultPath, fileRef);
+    if (!resolved) {
+        throw new Error(`File not found: ${fileRef}`);
+    }
+    const fullPath = path.join(vaultPath, resolved);
+    const existing = fs.readFileSync(fullPath, "utf-8");
+    const separator = inline ? "" : "\n";
+    fs.writeFileSync(fullPath, existing + separator + content);
+    return resolved;
+}
+export function prependFile(vaultPath, fileRef, content, inline) {
+    const resolved = resolveFile(vaultPath, fileRef);
+    if (!resolved) {
+        throw new Error(`File not found: ${fileRef}`);
+    }
+    const fullPath = path.join(vaultPath, resolved);
+    const existing = fs.readFileSync(fullPath, "utf-8");
+    const separator = inline ? "" : "\n";
+    const { properties, body, raw } = parseFrontmatter(existing);
+    if (Object.keys(properties).length > 0) {
+        const frontmatter = `---\n${raw}\n---\n`;
+        fs.writeFileSync(fullPath, frontmatter + content + separator + body);
+    }
+    else {
+        fs.writeFileSync(fullPath, content + separator + existing);
+    }
+    return resolved;
+}
+export function moveFile(vaultPath, fileRef, destination) {
+    const resolved = resolveFile(vaultPath, fileRef);
+    if (!resolved) {
+        throw new Error(`File not found: ${fileRef}`);
+    }
+    let destPath = destination;
+    if (!destPath.endsWith(".md")) {
+        destPath = path.join(destPath, path.basename(resolved));
+    }
+    const srcFull = path.join(vaultPath, resolved);
+    const destFull = path.join(vaultPath, destPath);
+    fs.mkdirSync(path.dirname(destFull), { recursive: true });
+    fs.renameSync(srcFull, destFull);
+    return { from: resolved, to: destPath };
+}
+export function renameFile(vaultPath, fileRef, newName) {
+    const resolved = resolveFile(vaultPath, fileRef);
+    if (!resolved) {
+        throw new Error(`File not found: ${fileRef}`);
+    }
+    const name = newName.endsWith(".md") ? newName : `${newName}.md`;
+    const destPath = path.join(path.dirname(resolved), name);
+    const srcFull = path.join(vaultPath, resolved);
+    const destFull = path.join(vaultPath, destPath);
+    fs.renameSync(srcFull, destFull);
+    return { from: resolved, to: destPath };
+}
+export function deleteFile(vaultPath, fileRef, permanent) {
+    const resolved = resolveFile(vaultPath, fileRef);
+    if (!resolved) {
+        throw new Error(`File not found: ${fileRef}`);
+    }
+    const fullPath = path.join(vaultPath, resolved);
+    if (permanent) {
+        fs.unlinkSync(fullPath);
+    }
+    else {
+        const trashDir = path.join(vaultPath, ".trash");
+        fs.mkdirSync(trashDir, { recursive: true });
+        const trashPath = path.join(trashDir, path.basename(resolved));
+        fs.renameSync(fullPath, trashPath);
+    }
+    return { path: resolved, deleted: true, permanent: !!permanent };
+}

package/dist/core/daily.d.ts

@@ -0,0 +1,12 @@
+import type { VaultInfo } from "../utils/vault.js";
+export declare function getDailyPath(configPath: string, date?: Date): string;
+export declare function ensureDaily(v: VaultInfo): {
+    path: string;
+    created: boolean;
+};
+export declare function readDaily(v: VaultInfo): {
+    path: string;
+    content: string;
+};
+export declare function appendDaily(v: VaultInfo, content: string, inline?: boolean): string;
+export declare function prependDaily(v: VaultInfo, content: string, inline?: boolean): string;

package/dist/core/daily.js

@@ -0,0 +1,102 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { loadConfig } from "../utils/config.js";
+import { parseFrontmatter } from "../utils/frontmatter.js";
+function getDailyConfig(configPath) {
+    const config = loadConfig(configPath);
+    return {
+        folder: config.daily.folder,
+        format: config.daily.format,
+        template: `${config.templates.folder}/Daily Note`,
+    };
+}
+function formatDate(date, format) {
+    const days = [
+        "Sunday",
+        "Monday",
+        "Tuesday",
+        "Wednesday",
+        "Thursday",
+        "Friday",
+        "Saturday",
+    ];
+    const shortDays = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+    return format
+        .replace(/YYYY/g, String(date.getFullYear()))
+        .replace(/YY/g, String(date.getFullYear()).slice(-2))
+        .replace(/MM/g, String(date.getMonth() + 1).padStart(2, "0"))
+        .replace(/M/g, String(date.getMonth() + 1))
+        .replace(/DD/g, String(date.getDate()).padStart(2, "0"))
+        .replace(/D/g, String(date.getDate()))
+        .replace(/dddd/g, days[date.getDay()])
+        .replace(/ddd/g, shortDays[date.getDay()])
+        .replace(/HH/g, String(date.getHours()).padStart(2, "0"))
+        .replace(/H/g, String(date.getHours()))
+        .replace(/mm/g, String(date.getMinutes()).padStart(2, "0"))
+        .replace(/ss/g, String(date.getSeconds()).padStart(2, "0"));
+}
+export function getDailyPath(configPath, date) {
+    const config = getDailyConfig(configPath);
+    const d = date || new Date();
+    const filename = formatDate(d, config.format);
+    const folder = config.folder || "";
+    return folder ? `${folder}/${filename}.md` : `${filename}.md`;
+}
+export function ensureDaily(v) {
+    const dp = getDailyPath(v.configPath);
+    const fullPath = path.join(v.contentPath, dp);
+    if (!fs.existsSync(fullPath)) {
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+        const config = getDailyConfig(v.configPath);
+        let content = "";
+        if (config.template) {
+            const templatePath = path.join(v.contentPath, `${config.template}.md`);
+            if (fs.existsSync(templatePath)) {
+                content = fs.readFileSync(templatePath, "utf-8");
+            }
+        }
+        fs.writeFileSync(fullPath, content);
+        return { path: dp, created: true };
+    }
+    return { path: dp, created: false };
+}
+export function readDaily(v) {
+    const dp = getDailyPath(v.configPath);
+    const fullPath = path.join(v.contentPath, dp);
+    if (!fs.existsSync(fullPath)) {
+        throw new Error(`Daily note not found: ${dp}`);
+    }
+    const content = fs.readFileSync(fullPath, "utf-8");
+    return { path: dp, content };
+}
+export function appendDaily(v, content, inline) {
+    const dp = getDailyPath(v.configPath);
+    const fullPath = path.join(v.contentPath, dp);
+    if (!fs.existsSync(fullPath)) {
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+        fs.writeFileSync(fullPath, "");
+    }
+    const existing = fs.readFileSync(fullPath, "utf-8");
+    const separator = inline ? "" : "\n";
+    fs.writeFileSync(fullPath, existing + separator + content);
+    return dp;
+}
+export function prependDaily(v, content, inline) {
+    const dp = getDailyPath(v.configPath);
+    const fullPath = path.join(v.contentPath, dp);
+    if (!fs.existsSync(fullPath)) {
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+        fs.writeFileSync(fullPath, "");
+    }
+    const existing = fs.readFileSync(fullPath, "utf-8");
+    const separator = inline ? "" : "\n";
+    const { properties, body, raw } = parseFrontmatter(existing);
+    if (Object.keys(properties).length > 0) {
+        const frontmatter = `---\n${raw}\n---\n`;
+        fs.writeFileSync(fullPath, frontmatter + content + separator + body);
+    }
+    else {
+        fs.writeFileSync(fullPath, content + separator + existing);
+    }
+    return dp;
+}

package/dist/core/files.d.ts

@@ -0,0 +1,15 @@
+import { type FileInfo } from "../utils/files.js";
+export type { FileInfo };
+export interface FolderInfo {
+    path: string;
+    files: number;
+    folders: number;
+    size: number;
+}
+export declare function getFileInfoResolved(vaultPath: string, fileRef: string): FileInfo;
+export declare function getFileList(vaultPath: string, opts?: {
+    folder?: string;
+    ext?: string;
+}): string[];
+export declare function getFolderList(vaultPath: string, parentFolder?: string): string[];
+export declare function getFolderInfo(vaultPath: string, folderPath: string): FolderInfo;

package/dist/core/files.js

@@ -0,0 +1,30 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getFileInfo, listFiles, listFolders, resolveFile, } from "../utils/files.js";
+export function getFileInfoResolved(vaultPath, fileRef) {
+    const resolved = resolveFile(vaultPath, fileRef);
+    if (!resolved) {
+        throw new Error(`File not found: ${fileRef}`);
+    }
+    return getFileInfo(vaultPath, resolved);
+}
+export function getFileList(vaultPath, opts) {
+    return listFiles(vaultPath, opts);
+}
+export function getFolderList(vaultPath, parentFolder) {
+    return listFolders(vaultPath, parentFolder);
+}
+export function getFolderInfo(vaultPath, folderPath) {
+    const fullPath = path.join(vaultPath, folderPath);
+    if (!fs.existsSync(fullPath) || !fs.statSync(fullPath).isDirectory()) {
+        throw new Error(`Folder not found: ${folderPath}`);
+    }
+    const fileCount = listFiles(vaultPath, { folder: folderPath }).length;
+    const folderCount = listFolders(vaultPath, folderPath).length;
+    let size = 0;
+    const allFiles = listFiles(vaultPath, { folder: folderPath });
+    for (const f of allFiles) {
+        size += fs.statSync(path.join(vaultPath, f)).size;
+    }
+    return { path: folderPath, files: fileCount, folders: folderCount, size };
+}

package/dist/core/init.d.ts

@@ -0,0 +1,31 @@
+export interface InitResult {
+    status: string;
+    path: string;
+    napkin?: boolean;
+    configCreated?: boolean;
+    siblingLayout?: boolean;
+    template?: string | null;
+    files?: string[];
+}
+export interface TemplateInfo {
+    name: string;
+    description: string;
+    dirs: string[];
+}
+export declare function initVault(opts: {
+    path?: string;
+    template?: string;
+}): InitResult;
+export interface ScaffoldResult {
+    path: string;
+    created: boolean;
+    template: string;
+    files: string[];
+}
+export declare function scaffoldVault(targetPath: string, template?: string): ScaffoldResult;
+export interface AddTemplateResult {
+    template: string;
+    files: string[];
+}
+export declare function addTemplate(targetPath: string, template: string): AddTemplateResult;
+export declare function getInitTemplates(): TemplateInfo[];

package/dist/core/init.js

@@ -0,0 +1,119 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { TEMPLATES } from "../templates/index.js";
+import { DEFAULT_CONFIG, saveConfig, } from "../utils/config.js";
+function scaffoldTemplate(targetDir, template) {
+    const created = [];
+    for (const dir of template.dirs) {
+        const dirPath = path.join(targetDir, dir);
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+            created.push(`${dir}/`);
+        }
+    }
+    for (const [filePath, content] of Object.entries(template.files)) {
+        const fullPath = path.join(targetDir, filePath);
+        if (!fs.existsSync(fullPath)) {
+            fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+            fs.writeFileSync(fullPath, content);
+            created.push(filePath);
+        }
+    }
+    const napkinPath = path.join(targetDir, "NAPKIN.md");
+    if (!fs.existsSync(napkinPath)) {
+        fs.writeFileSync(napkinPath, template.napkinMd);
+        created.push("NAPKIN.md");
+    }
+    return created;
+}
+export function initVault(opts) {
+    if (!opts.path) {
+        throw new Error("No path specified for vault initialization");
+    }
+    const targetDir = path.resolve(opts.path);
+    const napkinDir = path.join(targetDir, ".napkin");
+    const obsidianDir = path.join(targetDir, ".obsidian");
+    const hasExistingObsidian = fs.existsSync(obsidianDir) && fs.statSync(obsidianDir).isDirectory();
+    const napkinExists = fs.existsSync(napkinDir);
+    const configExists = fs.existsSync(path.join(napkinDir, "config.json"));
+    if (napkinExists && configExists && !opts.template) {
+        return { status: "exists", path: napkinDir };
+    }
+    if (opts.template && !TEMPLATES[opts.template]) {
+        throw new Error(`Unknown template: ${opts.template}. Available: ${Object.keys(TEMPLATES).join(", ")}`);
+    }
+    if (!napkinExists) {
+        fs.mkdirSync(napkinDir, { recursive: true });
+    }
+    if (!fs.existsSync(path.join(napkinDir, "config.json"))) {
+        const config = {
+            ...DEFAULT_CONFIG,
+            vault: { root: "..", obsidian: "../.obsidian" },
+        };
+        saveConfig(napkinDir, config, hasExistingObsidian ? obsidianDir : undefined);
+    }
+    const contentRoot = targetDir;
+    let templateFiles = [];
+    if (opts.template) {
+        templateFiles = scaffoldTemplate(contentRoot, TEMPLATES[opts.template]);
+    }
+    return {
+        status: "created",
+        path: napkinDir,
+        napkin: !napkinExists,
+        configCreated: !configExists,
+        siblingLayout: hasExistingObsidian,
+        template: opts.template || null,
+        files: templateFiles,
+    };
+}
+export function scaffoldVault(targetPath, template) {
+    const resolved = path.resolve(targetPath);
+    const napkinDir = path.join(resolved, ".napkin");
+    const obsidianDir = path.join(resolved, ".obsidian");
+    const hasExistingObsidian = fs.existsSync(obsidianDir) && fs.statSync(obsidianDir).isDirectory();
+    const napkinExisted = fs.existsSync(napkinDir);
+    if (!napkinExisted) {
+        fs.mkdirSync(napkinDir, { recursive: true });
+    }
+    if (!fs.existsSync(path.join(napkinDir, "config.json"))) {
+        const config = {
+            ...DEFAULT_CONFIG,
+            vault: { root: "..", obsidian: "../.obsidian" },
+        };
+        saveConfig(napkinDir, config, hasExistingObsidian ? obsidianDir : undefined);
+    }
+    const contentRoot = resolved;
+    let files = [];
+    if (template) {
+        if (!TEMPLATES[template]) {
+            throw new Error(`Unknown template: ${template}. Available: ${Object.keys(TEMPLATES).join(", ")}`);
+        }
+        files = scaffoldTemplate(contentRoot, TEMPLATES[template]);
+    }
+    return {
+        path: napkinDir,
+        created: !napkinExisted,
+        template: template || "",
+        files,
+    };
+}
+export function addTemplate(targetPath, template) {
+    const resolved = path.resolve(targetPath);
+    const napkinDir = path.join(resolved, ".napkin");
+    if (!fs.existsSync(path.join(napkinDir, "config.json"))) {
+        throw new Error("Vault not initialized. Run scaffold first.");
+    }
+    if (!TEMPLATES[template]) {
+        throw new Error(`Unknown template: ${template}. Available: ${Object.keys(TEMPLATES).join(", ")}`);
+    }
+    const files = scaffoldTemplate(resolved, TEMPLATES[template]);
+    return { template, files };
+}
+export function getInitTemplates() {
+    return Object.values(TEMPLATES).map((t) => ({
+        name: t.name,
+        description: t.description,
+        dirs: t.dirs,
+    }));
+}

package/dist/core/links.d.ts

@@ -0,0 +1,11 @@
+export interface VaultLinks {
+    outgoing: Map<string, string[]>;
+    incoming: Map<string, string[]>;
+    unresolved: Map<string, string[]>;
+}
+export declare function buildLinkIndex(vaultPath: string): VaultLinks;
+export declare function getBacklinks(vaultPath: string, fileRef: string): string[];
+export declare function getOutgoingLinks(vaultPath: string, fileRef: string): string[];
+export declare function getUnresolvedLinks(vaultPath: string): [string, string[]][];
+export declare function getOrphans(vaultPath: string): string[];
+export declare function getDeadends(vaultPath: string): string[];

package/dist/core/links.js

@@ -0,0 +1,66 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { listFiles, resolveFile } from "../utils/files.js";
+import { extractLinks } from "../utils/markdown.js";
+export function buildLinkIndex(vaultPath) {
+    const files = listFiles(vaultPath, { ext: "md" });
+    const outgoing = new Map();
+    const incoming = new Map();
+    const unresolved = new Map();
+    for (const f of files)
+        incoming.set(f, []);
+    for (const file of files) {
+        const content = fs.readFileSync(path.join(vaultPath, file), "utf-8");
+        const links = extractLinks(content);
+        outgoing.set(file, links.outgoing);
+        for (const target of links.wikilinks) {
+            const resolved = resolveFile(vaultPath, target);
+            if (resolved) {
+                if (!incoming.has(resolved))
+                    incoming.set(resolved, []);
+                incoming.get(resolved)?.push(file);
+            }
+            else {
+                if (!unresolved.has(target))
+                    unresolved.set(target, []);
+                unresolved.get(target)?.push(file);
+            }
+        }
+    }
+    return { outgoing, incoming, unresolved };
+}
+export function getBacklinks(vaultPath, fileRef) {
+    const resolved = resolveFile(vaultPath, fileRef);
+    if (!resolved) {
+        throw new Error(`File not found: ${fileRef}`);
+    }
+    const { incoming } = buildLinkIndex(vaultPath);
+    return incoming.get(resolved) || [];
+}
+export function getOutgoingLinks(vaultPath, fileRef) {
+    const resolved = resolveFile(vaultPath, fileRef);
+    if (!resolved) {
+        throw new Error(`File not found: ${fileRef}`);
+    }
+    const content = fs.readFileSync(path.join(vaultPath, resolved), "utf-8");
+    const { outgoing } = extractLinks(content);
+    return outgoing;
+}
+export function getUnresolvedLinks(vaultPath) {
+    const { unresolved } = buildLinkIndex(vaultPath);
+    return [...unresolved.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+}
+export function getOrphans(vaultPath) {
+    const { incoming } = buildLinkIndex(vaultPath);
+    return [...incoming.entries()]
+        .filter(([_, links]) => links.length === 0)
+        .map(([file]) => file)
+        .sort();
+}
+export function getDeadends(vaultPath) {
+    const { outgoing } = buildLinkIndex(vaultPath);
+    return [...outgoing.entries()]
+        .filter(([_, links]) => links.length === 0)
+        .map(([file]) => file)
+        .sort();
+}

package/dist/core/outline.d.ts

@@ -0,0 +1,3 @@
+import { type Heading } from "../utils/markdown.js";
+export type { Heading };
+export declare function getOutline(vaultPath: string, fileRef: string): Heading[];

package/dist/core/outline.js

@@ -0,0 +1,12 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { resolveFile } from "../utils/files.js";
+import { extractHeadings } from "../utils/markdown.js";
+export function getOutline(vaultPath, fileRef) {
+    const resolved = resolveFile(vaultPath, fileRef);
+    if (!resolved) {
+        throw new Error(`File not found: ${fileRef}`);
+    }
+    const content = fs.readFileSync(path.join(vaultPath, resolved), "utf-8");
+    return extractHeadings(content);
+}

package/dist/core/overview.d.ts

@@ -0,0 +1,15 @@
+export interface OverviewFolder {
+    path: string;
+    notes: number;
+    keywords: string[];
+    tags: string[];
+}
+export interface VaultOverview {
+    context?: string;
+    overview: OverviewFolder[];
+    warnings?: string[];
+}
+export declare function getOverview(contentPath: string, configPath: string, opts?: {
+    depth?: number;
+    keywords?: number;
+}): VaultOverview;