@drewpayment/mink 0.1.0 → 0.2.0

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, "\\$&");
+}

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 };
+}