@drewpayment/mink 0.1.0 → 0.2.1

package/src/core/dashboard-server.ts

@@ -1,6 +1,6 @@
 import { watch, type FSWatcher } from "fs";
 import { existsSync } from "fs";
-import { basename, join, extname } from "path";
+import { basename, dirname, join, extname } from "path";
 import { projectDir, designCapturesDir } from "./paths";
 import {
   loadOverview,
@@ -17,6 +17,7 @@ import {
 } from "./dashboard-api";
 import { listRegisteredProjects, getProjectMeta } from "./project-registry";
 import { generateProjectId } from "./project-id";
+import { runtimeFile, runtimeServe, runtimeSpawn } from "./runtime";
 import type { StateFileId, StateChangeEvent } from "../types/dashboard";
 import type { RegisteredProject } from "./project-registry";
 
@@ -262,10 +263,10 @@ export interface DashboardServer {
   close(): void;
 }
 
-export function startDashboardServer(
+export async function startDashboardServer(
   cwd: string,
   options: { port?: number; hostname?: string; open?: boolean } = {}
-): DashboardServer {
+): Promise<DashboardServer> {
   const port = options.port ?? 4040;
   const hostname = options.hostname ?? "127.0.0.1";
 
@@ -295,13 +296,15 @@ export function startDashboardServer(
   });
 
   // Resolve the Next.js static build directory
-  const dashboardOutDir = join(
-    import.meta.dir,
-    "..",
-    "..",
-    "dashboard",
-    "out"
-  );
+  // Walk up from import.meta.url to find the package root (where package.json lives).
+  // From source: src/core/ → ../../  From compiled bundle: dist/ → ../
+  const __dir = dirname(new URL(import.meta.url).pathname);
+  let pkgRoot = __dir;
+  while (pkgRoot !== dirname(pkgRoot)) {
+    if (existsSync(join(pkgRoot, "package.json"))) break;
+    pkgRoot = dirname(pkgRoot);
+  }
+  const dashboardOutDir = join(pkgRoot, "dashboard", "out");
   const dashboardBuilt = existsSync(join(dashboardOutDir, "index.html"));
   let clientIdCounter = 0;
 
@@ -311,7 +314,20 @@ export function startDashboardServer(
     );
   }
 
-  const server = Bun.serve({
+  async function serveFile(
+    filePath: string,
+    contentType: string
+  ): Promise<Response | null> {
+    const file = runtimeFile(filePath);
+    if (await file.exists()) {
+      return new Response(await file.bytes() as unknown as BodyInit, {
+        headers: { "Content-Type": contentType },
+      });
+    }
+    return null;
+  }
+
+  const server = await runtimeServe({
     port,
     hostname,
     idleTimeout: 0, // Disable idle timeout — SSE connections are long-lived
@@ -343,30 +359,24 @@ export function startDashboardServer(
             return jsonResponse({ error: "Forbidden" }, 403);
           }
 
-          const file = Bun.file(filePath);
-          if (await file.exists()) {
-            const ext = extname(filePath);
-            const contentType = MIME_TYPES[ext] || "application/octet-stream";
-            return new Response(file, {
-              headers: { "Content-Type": contentType },
-            });
-          }
+          const ext = extname(filePath);
+          const contentType = MIME_TYPES[ext] || "application/octet-stream";
+          const served = await serveFile(filePath, contentType);
+          if (served) return served;
 
           // Client-side routing fallback: try {pathname}.html then index.html
-          const htmlFile = Bun.file(filePath + ".html");
-          if (await htmlFile.exists()) {
-            return new Response(htmlFile, {
-              headers: { "Content-Type": "text/html; charset=utf-8" },
-            });
-          }
+          const htmlServed = await serveFile(
+            filePath + ".html",
+            "text/html; charset=utf-8"
+          );
+          if (htmlServed) return htmlServed;
 
           // SPA fallback — serve index.html for unmatched routes
-          const indexFile = Bun.file(join(dashboardOutDir, "index.html"));
-          if (await indexFile.exists()) {
-            return new Response(indexFile, {
-              headers: { "Content-Type": "text/html; charset=utf-8" },
-            });
-          }
+          const indexServed = await serveFile(
+            join(dashboardOutDir, "index.html"),
+            "text/html; charset=utf-8"
+          );
+          if (indexServed) return indexServed;
         }
       }
 
@@ -376,8 +386,6 @@ export function startDashboardServer(
         const stream = new ReadableStream<Uint8Array>({
           start(controller) {
             sseManager.addClient(clientId, controller);
-            // Send initial comment immediately to establish the stream
-            // and prevent Bun from treating it as idle/complete
             controller.enqueue(encoder.encode(": connected\nretry: 3000\n\n"));
           },
           cancel() {
@@ -435,15 +443,11 @@ export function startDashboardServer(
               return jsonResponse({ error: "Invalid filename" }, 400);
             }
             const imgPath = join(designCapturesDir(resolvedCwd), filename);
-            const file = Bun.file(imgPath);
-            if (await file.exists()) {
-              return new Response(file, {
-                headers: {
-                  "Content-Type": "image/jpeg",
-                  "Cache-Control": "public, max-age=60",
-                  "Access-Control-Allow-Origin": "*",
-                },
-              });
+            const served = await serveFile(imgPath, "image/jpeg");
+            if (served) {
+              served.headers.set("Cache-Control", "public, max-age=60");
+              served.headers.set("Access-Control-Allow-Origin", "*");
+              return served;
             }
             return jsonResponse({ error: "Image not found" }, 404);
           }
@@ -558,12 +562,7 @@ export function startDashboardServer(
           : platform === "win32"
             ? ["cmd", "/c", "start", serverUrl]
             : ["xdg-open", serverUrl];
-      const proc = Bun.spawn(cmd, {
-        stdout: "ignore",
-        stderr: "ignore",
-        stdin: "ignore",
-      });
-      proc.unref();
+      runtimeSpawn(cmd).unref();
     } catch {
       // Browser open is best-effort
     }

package/src/core/note-index.ts

@@ -0,0 +1,262 @@
+import { join } from "path";
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { atomicWriteJson, safeReadJson } from "./fs-utils";
+import { vaultIndexPath, resolveVaultPath } from "./vault";
+import type { VaultIndex, VaultIndexEntry, NoteCategory } from "../types/note";
+
+export function createEmptyVaultIndex(): VaultIndex {
+  return {
+    lastScanTimestamp: "",
+    totalNotes: 0,
+    entries: {},
+  };
+}
+
+export function loadVaultIndex(): VaultIndex {
+  const raw = safeReadJson(vaultIndexPath());
+  if (raw === null || typeof raw !== "object") return createEmptyVaultIndex();
+  const obj = raw as Record<string, unknown>;
+  if (typeof obj.entries !== "object" || obj.entries === null) {
+    return createEmptyVaultIndex();
+  }
+  return raw as VaultIndex;
+}
+
+export function saveVaultIndex(index: VaultIndex): void {
+  atomicWriteJson(vaultIndexPath(), index);
+}
+
+export function updateVaultEntry(
+  index: VaultIndex,
+  entry: VaultIndexEntry
+): void {
+  index.entries[entry.filePath] = entry;
+  index.totalNotes = Object.keys(index.entries).length;
+}
+
+export function removeVaultEntry(
+  index: VaultIndex,
+  filePath: string
+): void {
+  delete index.entries[filePath];
+  index.totalNotes = Object.keys(index.entries).length;
+}
+
+export function extractNoteTitle(content: string): string {
+  // Try first heading
+  const match = content.match(/^#\s+(.+)$/m);
+  if (match) return match[1].trim();
+  // Try frontmatter title
+  const fmMatch = content.match(/^title:\s*["']?(.+?)["']?\s*$/m);
+  if (fmMatch) return fmMatch[1].trim();
+  // First non-empty line after frontmatter
+  const lines = content.split("\n");
+  let pastFrontmatter = !content.startsWith("---");
+  let fmDashCount = 0;
+  for (const line of lines) {
+    if (!pastFrontmatter) {
+      if (line.trim() === "---") fmDashCount++;
+      if (fmDashCount >= 2) pastFrontmatter = true;
+      continue;
+    }
+    const trimmed = line.trim();
+    if (trimmed && !trimmed.startsWith("#")) return trimmed;
+  }
+  return "Untitled";
+}
+
+export function extractNoteTags(content: string): string[] {
+  // Parse tags from frontmatter
+  const fmMatch = content.match(/^tags:\s*\[(.+)\]/m);
+  if (fmMatch) {
+    return fmMatch[1]
+      .split(",")
+      .map((t) => t.trim().replace(/["']/g, ""))
+      .filter(Boolean);
+  }
+  // Try multiline tags
+  const lines = content.split("\n");
+  const tagsIdx = lines.findIndex((l) => l.startsWith("tags:"));
+  if (tagsIdx === -1) return [];
+  const tags: string[] = [];
+  for (let i = tagsIdx + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.match(/^\s+-\s+/)) {
+      tags.push(line.replace(/^\s+-\s+/, "").trim().replace(/["']/g, ""));
+    } else {
+      break;
+    }
+  }
+  return tags;
+}
+
+export function extractNoteCategory(content: string): NoteCategory {
+  const match = content.match(/^category:\s*(.+)$/m);
+  if (match) {
+    const cat = match[1].trim().replace(/["']/g, "") as NoteCategory;
+    if (
+      ["inbox", "projects", "areas", "resources", "archives"].includes(cat)
+    ) {
+      return cat;
+    }
+  }
+  return "inbox";
+}
+
+function estimateTokens(content: string): number {
+  return Math.ceil(content.length / 3.75);
+}
+
+export function buildEntryFromContent(
+  filePath: string,
+  content: string,
+  lastModified: string
+): VaultIndexEntry {
+  const title = extractNoteTitle(content);
+  const tags = extractNoteTags(content);
+  const category = extractNoteCategory(content);
+  // Description: first non-heading, non-frontmatter line
+  let description = "";
+  const lines = content.split("\n");
+  let pastFrontmatter = !content.startsWith("---");
+  let seenFmEnd = false;
+  for (const line of lines) {
+    if (!pastFrontmatter) {
+      if (line === "---" && seenFmEnd) pastFrontmatter = true;
+      if (line === "---") seenFmEnd = true;
+      continue;
+    }
+    const trimmed = line.trim();
+    if (trimmed && !trimmed.startsWith("#")) {
+      description = trimmed.slice(0, 120);
+      break;
+    }
+  }
+
+  return {
+    filePath,
+    title,
+    description,
+    tags,
+    category,
+    estimatedTokens: estimateTokens(content),
+    lastModified,
+  };
+}
+
+export function updateVaultIndexForFile(
+  filePath: string,
+  content: string
+): void {
+  const index = loadVaultIndex();
+  const root = resolveVaultPath();
+  const relativePath = filePath.startsWith(root)
+    ? filePath.slice(root.length + 1)
+    : filePath;
+  const entry = buildEntryFromContent(
+    relativePath,
+    content,
+    new Date().toISOString()
+  );
+  updateVaultEntry(index, entry);
+  index.lastScanTimestamp = new Date().toISOString();
+  saveVaultIndex(index);
+}
+
+export function rebuildVaultIndex(): VaultIndex {
+  const root = resolveVaultPath();
+  const index = createEmptyVaultIndex();
+  const files = collectAllMarkdown(root);
+
+  for (const file of files) {
+    try {
+      const content = readFileSync(file.absolutePath, "utf-8");
+      const entry = buildEntryFromContent(
+        file.relativePath,
+        content,
+        new Date(file.mtimeMs).toISOString()
+      );
+      updateVaultEntry(index, entry);
+    } catch {
+      // Skip unreadable files
+    }
+  }
+
+  index.lastScanTimestamp = new Date().toISOString();
+  saveVaultIndex(index);
+  return index;
+}
+
+export function searchVaultIndex(
+  term: string
+): VaultIndexEntry[] {
+  const index = loadVaultIndex();
+  const lower = term.toLowerCase();
+  return Object.values(index.entries).filter(
+    (e) =>
+      e.title.toLowerCase().includes(lower) ||
+      e.description.toLowerCase().includes(lower) ||
+      e.tags.some((t) => t.toLowerCase().includes(lower)) ||
+      e.filePath.toLowerCase().includes(lower)
+  );
+}
+
+export function getVaultTags(): string[] {
+  const index = loadVaultIndex();
+  const tags = new Set<string>();
+  for (const entry of Object.values(index.entries)) {
+    for (const tag of entry.tags) {
+      tags.add(tag);
+    }
+  }
+  return [...tags].sort();
+}
+
+export function getRecentNotes(n: number): VaultIndexEntry[] {
+  const index = loadVaultIndex();
+  return Object.values(index.entries)
+    .sort((a, b) => b.lastModified.localeCompare(a.lastModified))
+    .slice(0, n);
+}
+
+interface ScannedMarkdown {
+  absolutePath: string;
+  relativePath: string;
+  mtimeMs: number;
+}
+
+const VAULT_EXCLUDES = new Set([
+  ".obsidian",
+  ".git",
+  ".mink-vault.json",
+  ".mink-index.json",
+  "node_modules",
+]);
+
+function collectAllMarkdown(rootPath: string): ScannedMarkdown[] {
+  const files: ScannedMarkdown[] = [];
+  function walk(dir: string) {
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (VAULT_EXCLUDES.has(entry.name)) continue;
+        if (entry.name.startsWith(".")) continue;
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          walk(fullPath);
+        } else if (entry.name.endsWith(".md")) {
+          const stat = statSync(fullPath);
+          files.push({
+            absolutePath: fullPath,
+            relativePath: fullPath.slice(rootPath.length + 1),
+            mtimeMs: stat.mtimeMs,
+          });
+        }
+      }
+    } catch {
+      // Skip unreadable dirs
+    }
+  }
+  walk(rootPath);
+  return files;
+}

package/src/core/note-linker.ts

@@ -0,0 +1,161 @@
+import { join } from "path";
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { atomicWriteText, safeAppendText } from "./fs-utils";
+import { vaultRoot, vaultMasterIndexPath } from "./vault";
+import type { VaultIndex } from "../types/note";
+
+const WIKILINK_RE = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
+
+export function extractWikilinks(content: string): string[] {
+  const links: string[] = [];
+  let match: RegExpExecArray | null;
+  const re = new RegExp(WIKILINK_RE.source, "g");
+  while ((match = re.exec(content)) !== null) {
+    links.push(match[1].trim());
+  }
+  return [...new Set(links)];
+}
+
+export function insertWikilinks(
+  content: string,
+  targets: string[]
+): string {
+  let result = content;
+  for (const target of targets) {
+    // Don't insert if already a wikilink
+    if (result.includes(`[[${target}]]`)) continue;
+    // Don't insert inside frontmatter
+    const fmEnd = findFrontmatterEnd(result);
+    const body = result.slice(fmEnd);
+    // Replace first occurrence of the target text (case-insensitive, word boundary)
+    const re = new RegExp(`\\b(${escapeRegex(target)})\\b`, "i");
+    const replaced = body.replace(re, `[[$1]]`);
+    if (replaced !== body) {
+      result = result.slice(0, fmEnd) + replaced;
+    }
+  }
+  return result;
+}
+
+export function addBacklink(
+  targetNotePath: string,
+  sourceTitle: string
+): void {
+  if (!existsSync(targetNotePath)) return;
+  const content = readFileSync(targetNotePath, "utf-8");
+
+  // Don't add duplicate backlinks
+  if (content.includes(`[[${sourceTitle}]]`)) return;
+
+  const backlinkSection = "\n\n## Backlinks\n";
+  const backlinkEntry = `- [[${sourceTitle}]]\n`;
+
+  if (content.includes("## Backlinks")) {
+    // Append to existing backlinks section
+    const idx = content.indexOf("## Backlinks");
+    const sectionEnd = content.indexOf("\n## ", idx + 1);
+    const insertAt = sectionEnd === -1 ? content.length : sectionEnd;
+    const updated =
+      content.slice(0, insertAt).trimEnd() +
+      "\n" +
+      backlinkEntry +
+      (sectionEnd === -1 ? "" : content.slice(sectionEnd));
+    atomicWriteText(targetNotePath, updated);
+  } else {
+    safeAppendText(targetNotePath, backlinkSection + backlinkEntry);
+  }
+}
+
+export function updateMasterIndex(vaultRootPath: string): void {
+  const now = new Date().toISOString().split("T")[0];
+  const sections: string[] = [
+    `---`,
+    `updated: "${new Date().toISOString()}"`,
+    `---`,
+    ``,
+    `# Knowledge Base`,
+    ``,
+    `> Last updated: ${now}`,
+    ``,
+  ];
+
+  const categories = [
+    { name: "Inbox", dir: "inbox", emoji: "" },
+    { name: "Projects", dir: "projects", emoji: "" },
+    { name: "Areas", dir: "areas", emoji: "" },
+    { name: "Resources", dir: "resources", emoji: "" },
+    { name: "Archives", dir: "archives", emoji: "" },
+    { name: "Patterns", dir: "patterns", emoji: "" },
+  ];
+
+  for (const cat of categories) {
+    const dirPath = join(vaultRootPath, cat.dir);
+    if (!existsSync(dirPath)) continue;
+
+    const files = collectMarkdownFiles(dirPath, vaultRootPath);
+    if (files.length === 0 && cat.dir !== "inbox") continue;
+
+    sections.push(`## ${cat.name}`);
+    sections.push("");
+
+    if (files.length === 0) {
+      sections.push("*No notes yet.*");
+    } else {
+      // Show up to 20 most recent
+      const sorted = files
+        .sort((a, b) => b.mtime - a.mtime)
+        .slice(0, 20);
+      for (const file of sorted) {
+        sections.push(`- [[${file.title}]]`);
+      }
+      if (files.length > 20) {
+        sections.push(`- *...and ${files.length - 20} more*`);
+      }
+    }
+    sections.push("");
+  }
+
+  const indexPath = vaultMasterIndexPath();
+  atomicWriteText(indexPath, sections.join("\n"));
+}
+
+interface CollectedFile {
+  title: string;
+  relativePath: string;
+  mtime: number;
+}
+
+function collectMarkdownFiles(
+  dirPath: string,
+  rootPath: string
+): CollectedFile[] {
+  const files: CollectedFile[] = [];
+  try {
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...collectMarkdownFiles(fullPath, rootPath));
+      } else if (entry.name.endsWith(".md") && !entry.name.startsWith("_")) {
+        const stat = statSync(fullPath);
+        const title = entry.name.replace(/\.md$/, "");
+        const relativePath = fullPath.slice(rootPath.length + 1);
+        files.push({ title, relativePath, mtime: stat.mtimeMs });
+      }
+    }
+  } catch {
+    // Directory might not exist or be readable
+  }
+  return files;
+}
+
+function findFrontmatterEnd(content: string): number {
+  if (!content.startsWith("---")) return 0;
+  const endIdx = content.indexOf("---", 3);
+  if (endIdx === -1) return 0;
+  return endIdx + 3;
+}
+
+function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}