@cad0p/napkin 0.8.1

package/dist/core/tasks.d.ts

@@ -0,0 +1,35 @@
+import { type Task } from "../utils/markdown.js";
+import type { VaultInfo } from "../utils/vault.js";
+export interface TaskWithFile extends Task {
+    file: string;
+}
+export interface TaskShowResult {
+    file: string;
+    line: number;
+    status: string;
+    text: string;
+    done?: boolean;
+}
+export declare function collectTasks(vault: VaultInfo, opts: {
+    file?: string;
+    daily?: boolean;
+}): TaskWithFile[];
+export declare function filterTasks(tasks: TaskWithFile[], opts: {
+    done?: boolean;
+    todo?: boolean;
+    status?: string;
+}): TaskWithFile[];
+export declare function resolveTaskLocation(vault: VaultInfo, opts: {
+    file?: string;
+    line?: string;
+    ref?: string;
+    daily?: boolean;
+}): {
+    filePath: string;
+    lineNum: number;
+};
+export declare function showTask(vaultPath: string, filePath: string, lineNum: number): {
+    currentStatus: string;
+    text: string;
+};
+export declare function updateTask(vaultPath: string, filePath: string, lineNum: number, newStatus: string): TaskShowResult;

package/dist/core/tasks.js

@@ -0,0 +1,97 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { listFiles, resolveFile } from "../utils/files.js";
+import { extractTasks } from "../utils/markdown.js";
+import { getDailyPath } from "./daily.js";
+export function collectTasks(vault, opts) {
+    let files;
+    if (opts.daily) {
+        const dp = getDailyPath(vault.configPath);
+        files = fs.existsSync(path.join(vault.contentPath, dp)) ? [dp] : [];
+    }
+    else if (opts.file) {
+        const r = resolveFile(vault.contentPath, opts.file);
+        files = r ? [r] : [];
+    }
+    else {
+        files = listFiles(vault.contentPath, { ext: "md" });
+    }
+    const results = [];
+    for (const file of files) {
+        const content = fs.readFileSync(path.join(vault.contentPath, file), "utf-8");
+        const tasks = extractTasks(content);
+        for (const t of tasks) {
+            results.push({ ...t, file });
+        }
+    }
+    return results;
+}
+export function filterTasks(tasks, opts) {
+    let result = tasks;
+    if (opts.done)
+        result = result.filter((t) => t.done);
+    if (opts.todo)
+        result = result.filter((t) => !t.done);
+    if (opts.status)
+        result = result.filter((t) => t.status === opts.status);
+    return result;
+}
+export function resolveTaskLocation(vault, opts) {
+    if (opts.ref) {
+        const parts = opts.ref.split(":");
+        if (parts.length !== 2) {
+            throw new Error("Invalid ref format. Use --ref <path:line>");
+        }
+        const resolved = resolveFile(vault.contentPath, parts[0]);
+        if (!resolved) {
+            throw new Error(`File not found: ${parts[0]}`);
+        }
+        return { filePath: resolved, lineNum: Number.parseInt(parts[1], 10) };
+    }
+    if (opts.daily) {
+        return {
+            filePath: getDailyPath(vault.configPath),
+            lineNum: Number.parseInt(opts.line || "0", 10),
+        };
+    }
+    if (!opts.file || !opts.line) {
+        throw new Error("Specify --file and --line, or --ref <path:line>");
+    }
+    const resolved = resolveFile(vault.contentPath, opts.file);
+    if (!resolved) {
+        throw new Error(`File not found: ${opts.file}`);
+    }
+    return { filePath: resolved, lineNum: Number.parseInt(opts.line, 10) };
+}
+function parseTask(vaultPath, filePath, lineNum) {
+    const fullPath = path.join(vaultPath, filePath);
+    if (!fs.existsSync(fullPath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    const content = fs.readFileSync(fullPath, "utf-8");
+    const lines = content.split("\n");
+    const targetLine = lines[lineNum - 1];
+    if (!targetLine) {
+        throw new Error(`Line ${lineNum} not found in ${filePath}`);
+    }
+    const taskMatch = targetLine.match(/^([\s]*[-*]\s+\[)(.)(].*)$/);
+    if (!taskMatch) {
+        throw new Error(`Line ${lineNum} is not a task`);
+    }
+    return { lines, taskMatch, fullPath };
+}
+export function showTask(vaultPath, filePath, lineNum) {
+    const { taskMatch } = parseTask(vaultPath, filePath, lineNum);
+    return { currentStatus: taskMatch[2], text: taskMatch[3].slice(2) };
+}
+export function updateTask(vaultPath, filePath, lineNum, newStatus) {
+    const { lines, taskMatch, fullPath } = parseTask(vaultPath, filePath, lineNum);
+    lines[lineNum - 1] = `${taskMatch[1]}${newStatus}${taskMatch[3]}`;
+    fs.writeFileSync(fullPath, lines.join("\n"));
+    return {
+        file: filePath,
+        line: lineNum,
+        status: newStatus,
+        text: taskMatch[3].slice(2),
+    };
+}

package/dist/core/templates.d.ts

@@ -0,0 +1,14 @@
+import type { VaultInfo } from "../utils/vault.js";
+export declare function listTemplates(v: VaultInfo): string[];
+export declare function readTemplate(v: VaultInfo, name: string, opts?: {
+    resolve?: boolean;
+    title?: string;
+}): {
+    template: string;
+    content: string;
+};
+export declare function insertTemplate(v: VaultInfo, templateName: string, fileRef: string): {
+    file: string;
+    template: string;
+    inserted: boolean;
+};

package/dist/core/templates.js

@@ -0,0 +1,55 @@
+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";
+function getTemplateFolder(configPath) {
+    const config = loadConfig(configPath);
+    return config.templates.folder;
+}
+export function listTemplates(v) {
+    const folder = getTemplateFolder(v.configPath);
+    return listFiles(v.contentPath, { folder, ext: "md" }).map((f) => path.basename(f, ".md"));
+}
+function resolveVariables(content, title) {
+    const now = new Date();
+    const dateStr = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+    const timeStr = `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}`;
+    return content
+        .replace(/\{\{date\}\}/g, dateStr)
+        .replace(/\{\{time\}\}/g, timeStr)
+        .replace(/\{\{title\}\}/g, title || "Untitled");
+}
+export function readTemplate(v, name, opts) {
+    const folder = getTemplateFolder(v.configPath);
+    const resolved = resolveFile(v.contentPath, `${folder}/${name}`) ||
+        resolveFile(v.contentPath, name);
+    if (!resolved) {
+        const templateFiles = listFiles(v.contentPath, { folder, ext: "md" }).map((f) => path.basename(f, ".md"));
+        throw new Error(`Template not found: ${name}. Available: ${templateFiles.slice(0, 3).join(", ")}`);
+    }
+    let content = fs.readFileSync(path.join(v.contentPath, resolved), "utf-8");
+    if (opts?.resolve) {
+        content = resolveVariables(content, opts.title);
+    }
+    return { template: name, content };
+}
+export function insertTemplate(v, templateName, fileRef) {
+    const folder = getTemplateFolder(v.configPath);
+    const templateResolved = resolveFile(v.contentPath, `${folder}/${templateName}`) ||
+        resolveFile(v.contentPath, templateName);
+    if (!templateResolved) {
+        const templateFiles = listFiles(v.contentPath, { folder, ext: "md" }).map((f) => path.basename(f, ".md"));
+        throw new Error(`Template not found: ${templateName}. Available: ${templateFiles.slice(0, 3).join(", ")}`);
+    }
+    const targetResolved = resolveFile(v.contentPath, fileRef);
+    if (!targetResolved) {
+        throw new Error(`File not found: ${fileRef}`);
+    }
+    const title = path.basename(targetResolved, ".md");
+    let templateContent = fs.readFileSync(path.join(v.contentPath, templateResolved), "utf-8");
+    templateContent = resolveVariables(templateContent, title);
+    const targetPath = path.join(v.contentPath, targetResolved);
+    const existing = fs.readFileSync(targetPath, "utf-8");
+    fs.writeFileSync(targetPath, existing + templateContent);
+    return { file: targetResolved, template: templateName, inserted: true };
+}

package/dist/core/vault.d.ts

@@ -0,0 +1,10 @@
+import type { VaultInfo } from "../utils/vault.js";
+export interface VaultMetadata {
+    name: string;
+    path: string;
+    files: number;
+    folders: number;
+    size: number;
+}
+export declare function formatSize(bytes: number): string;
+export declare function getVaultMetadata(v: VaultInfo): VaultMetadata;

package/dist/core/vault.js

@@ -0,0 +1,37 @@
+import * as fs from "node:fs";
+import { listFiles, listFolders, walkDir } from "../utils/files.js";
+function getVaultSize(vaultPath) {
+    let total = 0;
+    walkDir(vaultPath, {
+        onEntry: (fullPath, _entry, kind) => {
+            if (kind !== "file")
+                return;
+            try {
+                total += fs.statSync(fullPath).size;
+            }
+            catch {
+                // Entry disappeared between readdir and stat — skip.
+            }
+        },
+    });
+    return total;
+}
+export function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+export function getVaultMetadata(v) {
+    const files = listFiles(v.contentPath);
+    const folders = listFolders(v.contentPath);
+    const size = getVaultSize(v.contentPath);
+    return {
+        name: v.name,
+        path: v.contentPath,
+        files: files.length,
+        folders: folders.length,
+        size,
+    };
+}

package/dist/core/wordcount.d.ts

@@ -0,0 +1,5 @@
+export interface WordCount {
+    words: number;
+    characters: number;
+}
+export declare function getWordCount(vaultPath: string, fileRef: string): WordCount;

package/dist/core/wordcount.js

@@ -0,0 +1,16 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { resolveFile } from "../utils/files.js";
+import { parseFrontmatter } from "../utils/frontmatter.js";
+export function getWordCount(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 { body } = parseFrontmatter(content);
+    const text = body.trim();
+    const words = text ? text.split(/\s+/).length : 0;
+    const characters = text.length;
+    return { words, characters };
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export type { AliasEntry } from "./core/aliases.js";
+export type { BaseQueryResult, BaseView } from "./core/bases.js";
+export type { Bookmark } from "./core/bookmarks.js";
+export type { Canvas, CanvasEdge, CanvasNode } from "./core/canvas.js";
+export type { CreateOptions, CreateResult, DeleteResult, MoveResult, ReadResult, } from "./core/crud.js";
+export type { FileInfo, FolderInfo } from "./core/files.js";
+export type { AddTemplateResult, ScaffoldResult, TemplateInfo, } from "./core/init.js";
+export type { OverviewFolder, VaultOverview } from "./core/overview.js";
+export type { SearchOptions, SearchResult } from "./core/search.js";
+export type { TagInfo } from "./core/tags.js";
+export type { TaskShowResult, TaskWithFile } from "./core/tasks.js";
+export type { VaultMetadata } from "./core/vault.js";
+export type { WordCount } from "./core/wordcount.js";
+export { Napkin } from "./sdk.js";
+export type { VaultTemplate } from "./templates/types.js";
+export type { Heading } from "./utils/markdown.js";
+export type { VaultInfo } from "./utils/vault.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { Napkin } from "./sdk.js";

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};