@drewpayment/mink 0.1.0 → 0.2.1

package/src/core/note-writer.ts

@@ -0,0 +1,203 @@
+import { join } from "path";
+import { existsSync, readFileSync } from "fs";
+import { atomicWriteText } from "./fs-utils";
+import { categoryToDir, vaultDailyDir, vaultTemplates } from "./vault";
+import { loadTemplate } from "./vault-templates";
+import type { NoteMetadata, NoteFrontmatter, NoteCategory } from "../types/note";
+
+export function slugifyTitle(title: string): string {
+  return title
+    .toLowerCase()
+    .replace(/[^a-z0-9\s-]/g, "")
+    .replace(/\s+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, 80);
+}
+
+export function generateFrontmatter(meta: {
+  created: string;
+  updated: string;
+  tags: string[];
+  category: NoteCategory;
+  sourceProject?: string;
+  aliases?: string[];
+  extra?: Record<string, unknown>;
+}): string {
+  const lines: string[] = ["---"];
+  lines.push(`created: "${meta.created}"`);
+  lines.push(`updated: "${meta.updated}"`);
+
+  if (meta.tags.length > 0) {
+    lines.push(`tags: [${meta.tags.join(", ")}]`);
+  } else {
+    lines.push("tags: []");
+  }
+
+  lines.push(`category: ${meta.category}`);
+
+  if (meta.sourceProject) {
+    lines.push(`source_project: ${meta.sourceProject}`);
+  }
+
+  if (meta.aliases && meta.aliases.length > 0) {
+    lines.push(`aliases: [${meta.aliases.join(", ")}]`);
+  }
+
+  if (meta.extra) {
+    for (const [key, value] of Object.entries(meta.extra)) {
+      lines.push(`${key}: ${JSON.stringify(value)}`);
+    }
+  }
+
+  lines.push("---");
+  return lines.join("\n");
+}
+
+export function createNote(meta: NoteMetadata): {
+  filePath: string;
+  content: string;
+} {
+  const now = meta.created || new Date().toISOString();
+  const slug = slugifyTitle(meta.title);
+  const dir = categoryToDir(meta.category, meta.projectSlug);
+  const filePath = join(dir, `${slug}.md`);
+
+  let content: string;
+
+  if (meta.template) {
+    const rendered = loadTemplate(vaultTemplates(), meta.template, {
+      title: meta.title,
+      body: meta.body,
+      created: now,
+      updated: now,
+      date: now.split("T")[0],
+    });
+    content = rendered ?? buildNoteContent(meta, now);
+  } else {
+    content = buildNoteContent(meta, now);
+  }
+
+  atomicWriteText(filePath, content);
+  return { filePath, content };
+}
+
+function buildNoteContent(meta: NoteMetadata, now: string): string {
+  const frontmatter = generateFrontmatter({
+    created: now,
+    updated: now,
+    tags: meta.tags,
+    category: meta.category,
+    sourceProject: meta.sourceProject,
+  });
+
+  return `${frontmatter}
+
+# ${meta.title}
+
+${meta.body}
+`;
+}
+
+export function appendToDaily(date: string, content: string): string {
+  const dir = vaultDailyDir();
+  const filePath = join(dir, `${date}.md`);
+
+  if (existsSync(filePath)) {
+    const existing = readFileSync(filePath, "utf-8");
+    const timestamp = new Date().toLocaleTimeString("en-US", {
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: false,
+    });
+    const updated = `${existing.trimEnd()}\n\n## ${timestamp}\n\n${content}\n`;
+    atomicWriteText(filePath, updated);
+  } else {
+    const now = new Date().toISOString();
+    const rendered = loadTemplate(vaultTemplates(), "daily-note", {
+      title: date,
+      date,
+      body: content,
+      created: now,
+      updated: now,
+    });
+    const noteContent =
+      rendered ??
+      `---
+created: "${now}"
+updated: "${now}"
+tags: [daily]
+category: areas
+---
+
+# ${date}
+
+${content}
+`;
+    atomicWriteText(filePath, noteContent);
+  }
+
+  return filePath;
+}
+
+export function ingestFile(
+  sourcePath: string,
+  meta: {
+    category: NoteCategory;
+    tags?: string[];
+    projectSlug?: string;
+    sourceProject?: string;
+  }
+): { filePath: string; content: string } {
+  const raw = readFileSync(sourcePath, "utf-8");
+  const now = new Date().toISOString();
+
+  // Extract title from first heading or filename
+  const headingMatch = raw.match(/^#\s+(.+)$/m);
+  const title =
+    headingMatch?.[1] ??
+    sourcePath
+      .split("/")
+      .pop()!
+      .replace(/\.md$/, "");
+
+  // Check if file already has frontmatter
+  const hasFrontmatter = raw.startsWith("---");
+  let content: string;
+
+  if (hasFrontmatter) {
+    // Preserve existing frontmatter, add missing fields
+    const endIdx = raw.indexOf("---", 3);
+    if (endIdx !== -1) {
+      const existingFm = raw.slice(0, endIdx + 3);
+      const body = raw.slice(endIdx + 3).trim();
+      // Add category if missing
+      if (!existingFm.includes("category:")) {
+        const updatedFm = existingFm.replace(
+          /---$/,
+          `category: ${meta.category}\n---`
+        );
+        content = `${updatedFm}\n\n${body}\n`;
+      } else {
+        content = raw;
+      }
+    } else {
+      content = raw;
+    }
+  } else {
+    const frontmatter = generateFrontmatter({
+      created: now,
+      updated: now,
+      tags: meta.tags ?? [],
+      category: meta.category,
+      sourceProject: meta.sourceProject,
+    });
+    content = `${frontmatter}\n\n${raw}`;
+  }
+
+  const slug = slugifyTitle(title);
+  const dir = categoryToDir(meta.category, meta.projectSlug);
+  const filePath = join(dir, `${slug}.md`);
+  atomicWriteText(filePath, content);
+  return { filePath, content };
+}

package/src/core/runtime.ts

@@ -0,0 +1,214 @@
+/**
+ * Cross-runtime utilities — Bun-first with Node.js fallbacks.
+ *
+ * Detects the runtime once at import time and exports helpers that
+ * abstract over Bun.serve / node:http, Bun.file / fs, and Bun.spawn / child_process.
+ */
+
+import { readFile, stat } from "fs/promises";
+import { spawn as nodeSpawn } from "child_process";
+
+export const isBun = typeof globalThis.Bun !== "undefined";
+
+// ── File helpers ──────────────────────────────────────────────────────────
+
+export interface RuntimeFile {
+  exists(): Promise<boolean>;
+  bytes(): Promise<Uint8Array>;
+}
+
+/**
+ * Returns a lightweight file handle with `.exists()` and `.bytes()`.
+ * Uses Bun.file when available, otherwise falls back to fs.
+ */
+export function runtimeFile(path: string): RuntimeFile {
+  if (isBun) {
+    const f = Bun.file(path);
+    return {
+      exists: () => f.exists(),
+      bytes: () => f.arrayBuffer().then((ab) => new Uint8Array(ab)),
+    };
+  }
+  return {
+    async exists() {
+      try {
+        await stat(path);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async bytes() {
+      return readFile(path);
+    },
+  };
+}
+
+// ── Spawn helper ──────────────────────────────────────────────────────────
+
+export interface SpawnOptions {
+  cwd?: string;
+  env?: Record<string, string | undefined>;
+  stdout?: "ignore" | "pipe";
+  stderr?: "ignore" | "pipe";
+  stdin?: "ignore";
+}
+
+export interface SpawnedProcess {
+  unref(): void;
+}
+
+/**
+ * Fire-and-forget process spawning. Uses Bun.spawn when available,
+ * otherwise child_process.spawn with detached + unref.
+ */
+export function runtimeSpawn(
+  cmd: string[],
+  opts: SpawnOptions = {}
+): SpawnedProcess {
+  if (isBun) {
+    const proc = Bun.spawn(cmd, {
+      cwd: opts.cwd,
+      env: opts.env,
+      stdout: opts.stdout ?? "ignore",
+      stderr: opts.stderr ?? "ignore",
+      stdin: opts.stdin ?? "ignore",
+    });
+    return { unref: () => proc.unref() };
+  }
+
+  const [bin, ...args] = cmd;
+  const proc = nodeSpawn(bin, args, {
+    cwd: opts.cwd,
+    env: opts.env as NodeJS.ProcessEnv,
+    stdio: [
+      opts.stdin ?? "ignore",
+      opts.stdout ?? "ignore",
+      opts.stderr ?? "ignore",
+    ],
+    detached: true,
+  });
+  proc.unref();
+  return { unref: () => {} };
+}
+
+// ── HTTP Server ───────────────────────────────────────────────────────────
+
+export interface RuntimeServer {
+  port: number;
+  stop(closeConnections?: boolean): void;
+}
+
+type FetchHandler = (req: Request) => Response | Promise<Response>;
+
+interface ServeOptions {
+  port: number;
+  hostname: string;
+  idleTimeout?: number;
+  fetch: FetchHandler;
+}
+
+/**
+ * Start an HTTP server using Bun.serve or node:http.
+ * The fetch handler uses standard Web API Request/Response in both runtimes.
+ */
+export async function runtimeServe(opts: ServeOptions): Promise<RuntimeServer> {
+  if (isBun) {
+    const server = Bun.serve({
+      port: opts.port,
+      hostname: opts.hostname,
+      idleTimeout: opts.idleTimeout ?? 0,
+      fetch: opts.fetch,
+    });
+    return {
+      port: server.port as number,
+      stop: (close) => server.stop(close),
+    };
+  }
+
+  // Node.js fallback using node:http
+  const { createServer } = await import("node:http");
+  const { Readable } = await import("node:stream");
+
+  return new Promise<RuntimeServer>((resolve) => {
+    const httpServer = createServer(async (req, res) => {
+      // Build a Web API Request from the Node IncomingMessage
+      const url = `http://${opts.hostname}:${opts.port}${req.url ?? "/"}`;
+      const headers = new Headers();
+      for (const [key, val] of Object.entries(req.headers)) {
+        if (val) headers.set(key, Array.isArray(val) ? val.join(", ") : val);
+      }
+
+      let body: BodyInit | null = null;
+      if (req.method !== "GET" && req.method !== "HEAD") {
+        const chunks: Buffer[] = [];
+        for await (const chunk of req) {
+          chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        }
+        body = Buffer.concat(chunks);
+      }
+
+      const request = new Request(url, {
+        method: req.method,
+        headers,
+        body,
+        // @ts-expect-error -- Node 18+ supports duplex on Request
+        duplex: body ? "half" : undefined,
+      });
+
+      try {
+        const response = await opts.fetch(request);
+
+        res.writeHead(response.status, Object.fromEntries(response.headers));
+
+        if (!response.body) {
+          res.end();
+          return;
+        }
+
+        // Stream the response body
+        const reader = response.body.getReader();
+        const nodeStream = new Readable({
+          async read() {
+            try {
+              const { done, value } = await reader.read();
+              if (done) {
+                this.push(null);
+              } else {
+                this.push(Buffer.from(value));
+              }
+            } catch {
+              this.push(null);
+            }
+          },
+        });
+
+        // Clean up SSE streams when client disconnects
+        res.on("close", () => {
+          reader.cancel().catch(() => {});
+          nodeStream.destroy();
+        });
+
+        nodeStream.pipe(res);
+      } catch (err) {
+        if (!res.headersSent) {
+          res.writeHead(500);
+          res.end(String(err));
+        }
+      }
+    });
+
+    httpServer.listen(opts.port, opts.hostname, () => {
+      const addr = httpServer.address();
+      const boundPort =
+        typeof addr === "object" && addr ? addr.port : opts.port;
+      resolve({
+        port: boundPort,
+        stop: (close) => {
+          if (close) httpServer.closeAllConnections();
+          httpServer.close();
+        },
+      });
+    });
+  });
+}

package/src/core/vault-templates.ts

@@ -0,0 +1,179 @@
+import { join } from "path";
+import { existsSync, writeFileSync, readFileSync, mkdirSync } from "fs";
+
+export const DEFAULT_TEMPLATES: Record<string, string> = {
+  "quick-capture": `---
+created: "{{created}}"
+updated: "{{updated}}"
+tags: []
+category: inbox
+---
+
+# {{title}}
+
+{{body}}
+`,
+
+  "daily-note": `---
+created: "{{created}}"
+updated: "{{updated}}"
+tags: [daily]
+category: areas
+---
+
+# {{date}}
+
+## Focus
+
+-
+
+## Notes
+
+-
+
+## Tasks
+
+- [ ]
+
+## Reflections
+
+`,
+
+  meeting: `---
+created: "{{created}}"
+updated: "{{updated}}"
+tags: [meeting]
+category: areas
+---
+
+# {{title}}
+
+**Date**: {{date}}
+**Attendees**:
+
+## Agenda
+
+-
+
+## Discussion
+
+-
+
+## Decisions
+
+-
+
+## Action Items
+
+- [ ]
+`,
+
+  project: `---
+created: "{{created}}"
+updated: "{{updated}}"
+tags: [project]
+category: projects
+status: active
+---
+
+# {{title}}
+
+## Overview
+
+{{body}}
+
+## Goals
+
+-
+
+## Key Decisions
+
+-
+
+## Links
+
+-
+`,
+
+  area: `---
+created: "{{created}}"
+updated: "{{updated}}"
+tags: [area]
+category: areas
+---
+
+# {{title}}
+
+## Purpose
+
+{{body}}
+
+## Standards
+
+-
+
+## Key Resources
+
+-
+`,
+
+  person: `---
+created: "{{created}}"
+updated: "{{updated}}"
+tags: [person]
+category: resources
+---
+
+# {{title}}
+
+## Role
+
+## Context
+
+## 1:1 Notes
+
+-
+
+## Key Projects
+
+-
+`,
+};
+
+export function seedTemplates(templatesDir: string): void {
+  mkdirSync(templatesDir, { recursive: true });
+  for (const [name, content] of Object.entries(DEFAULT_TEMPLATES)) {
+    const filePath = join(templatesDir, `${name}.md`);
+    if (!existsSync(filePath)) {
+      writeFileSync(filePath, content);
+    }
+  }
+}
+
+export function loadTemplate(
+  templatesDir: string,
+  templateName: string,
+  vars: Record<string, string>
+): string | null {
+  const filePath = join(templatesDir, `${templateName}.md`);
+  let content: string;
+  if (existsSync(filePath)) {
+    content = readFileSync(filePath, "utf-8");
+  } else if (DEFAULT_TEMPLATES[templateName]) {
+    content = DEFAULT_TEMPLATES[templateName];
+  } else {
+    return null;
+  }
+  return fillTemplate(content, vars);
+}
+
+export function fillTemplate(
+  template: string,
+  vars: Record<string, string>
+): string {
+  let result = template;
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replaceAll(`{{${key}}}`, value);
+  }
+  return result;
+}

package/src/core/vault.ts

@@ -0,0 +1,132 @@
+import { join } from "path";
+import { homedir } from "os";
+import { existsSync, mkdirSync } from "fs";
+import { resolveConfigValue } from "./global-config";
+import { safeReadJson } from "./fs-utils";
+import type { VaultManifest } from "../types/note";
+
+const DEFAULT_VAULT_PATH = join(homedir(), ".mink", "wiki");
+
+export function resolveVaultPath(): string {
+  const resolved = resolveConfigValue("wiki.path");
+  const raw = resolved.value;
+  if (raw.startsWith("~/")) {
+    return join(homedir(), raw.slice(2));
+  }
+  return raw;
+}
+
+export function vaultRoot(): string {
+  return resolveVaultPath();
+}
+
+export function vaultInbox(): string {
+  return join(resolveVaultPath(), "inbox");
+}
+
+export function vaultProjects(slug?: string): string {
+  const base = join(resolveVaultPath(), "projects");
+  return slug ? join(base, slug) : base;
+}
+
+export function vaultAreas(): string {
+  return join(resolveVaultPath(), "areas");
+}
+
+export function vaultDailyDir(): string {
+  return join(resolveVaultPath(), "areas", "daily");
+}
+
+export function vaultResources(): string {
+  return join(resolveVaultPath(), "resources");
+}
+
+export function vaultArchives(): string {
+  return join(resolveVaultPath(), "archives");
+}
+
+export function vaultTemplates(): string {
+  return join(resolveVaultPath(), "templates");
+}
+
+export function vaultPatterns(): string {
+  return join(resolveVaultPath(), "patterns");
+}
+
+export function vaultManifestPath(): string {
+  return join(resolveVaultPath(), ".mink-vault.json");
+}
+
+export function vaultIndexPath(): string {
+  return join(resolveVaultPath(), ".mink-index.json");
+}
+
+export function vaultMasterIndexPath(): string {
+  return join(resolveVaultPath(), "_index.md");
+}
+
+export function isVaultInitialized(): boolean {
+  return existsSync(vaultManifestPath());
+}
+
+export function isInsideVault(cwd: string): boolean {
+  const vault = resolveVaultPath();
+  const normalizedCwd = cwd.replace(/\/+$/, "");
+  const normalizedVault = vault.replace(/\/+$/, "");
+  return (
+    normalizedCwd === normalizedVault ||
+    normalizedCwd.startsWith(normalizedVault + "/")
+  );
+}
+
+export function isWikiEnabled(): boolean {
+  const resolved = resolveConfigValue("wiki.enabled");
+  return resolved.value === "true";
+}
+
+export function loadVaultManifest(): VaultManifest | null {
+  const raw = safeReadJson(vaultManifestPath());
+  if (raw === null || typeof raw !== "object") return null;
+  return raw as VaultManifest;
+}
+
+const VAULT_DIRS = [
+  "",
+  "inbox",
+  "projects",
+  "areas",
+  "areas/daily",
+  "resources",
+  "archives",
+  "templates",
+  "patterns",
+];
+
+export function ensureVaultStructure(): void {
+  const root = resolveVaultPath();
+  for (const dir of VAULT_DIRS) {
+    mkdirSync(join(root, dir), { recursive: true });
+  }
+}
+
+export function categoryToDir(
+  category: string,
+  projectSlug?: string
+): string {
+  const root = resolveVaultPath();
+  switch (category) {
+    case "projects":
+      return projectSlug
+        ? join(root, "projects", projectSlug)
+        : join(root, "projects");
+    case "areas":
+      return join(root, "areas");
+    case "resources":
+      return join(root, "resources");
+    case "archives":
+      return join(root, "archives");
+    case "inbox":
+    default:
+      return join(root, "inbox");
+  }
+}