@openparachute/vault 0.1.0

package/core/src/obsidian.test.ts

@@ -0,0 +1,380 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import { Database } from "bun:sqlite";
+import { SqliteStore } from "./store.js";
+import {
+  parseFrontmatter,
+  extractInlineTags,
+  parseObsidianVault,
+  toObsidianMarkdown,
+  exportFilePath,
+} from "./obsidian.js";
+import { mkdirSync, writeFileSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+// ---------------------------------------------------------------------------
+// Frontmatter parsing
+// ---------------------------------------------------------------------------
+
+describe("parseFrontmatter", () => {
+  it("parses simple key-value pairs", () => {
+    const raw = `---
+title: My Note
+author: Aaron
+---
+Note content here.`;
+
+    const { frontmatter, content } = parseFrontmatter(raw);
+    expect(frontmatter.title).toBe("My Note");
+    expect(frontmatter.author).toBe("Aaron");
+    expect(content).toBe("Note content here.");
+  });
+
+  it("parses array tags", () => {
+    const raw = `---
+tags:
+  - daily
+  - voice
+---
+Content`;
+
+    const { frontmatter } = parseFrontmatter(raw);
+    expect(frontmatter.tags).toEqual(["daily", "voice"]);
+  });
+
+  it("parses inline array tags", () => {
+    const raw = `---
+tags: [daily, voice, project]
+---
+Content`;
+
+    const { frontmatter } = parseFrontmatter(raw);
+    expect(frontmatter.tags).toEqual(["daily", "voice", "project"]);
+  });
+
+  it("parses numbers and booleans", () => {
+    const raw = `---
+priority: 3
+draft: true
+rating: 4.5
+---
+Content`;
+
+    const { frontmatter } = parseFrontmatter(raw);
+    expect(frontmatter.priority).toBe(3);
+    expect(frontmatter.draft).toBe(true);
+    expect(frontmatter.rating).toBe(4.5);
+  });
+
+  it("handles quoted strings", () => {
+    const raw = `---
+title: "My Title"
+subtitle: 'Sub Title'
+---
+Content`;
+
+    const { frontmatter } = parseFrontmatter(raw);
+    expect(frontmatter.title).toBe("My Title");
+    expect(frontmatter.subtitle).toBe("Sub Title");
+  });
+
+  it("returns empty frontmatter when none exists", () => {
+    const raw = "Just content, no frontmatter.";
+    const { frontmatter, content } = parseFrontmatter(raw);
+    expect(frontmatter).toEqual({});
+    expect(content).toBe("Just content, no frontmatter.");
+  });
+
+  it("handles empty frontmatter block", () => {
+    const raw = `---
+---
+Content`;
+
+    const { frontmatter, content } = parseFrontmatter(raw);
+    expect(Object.keys(frontmatter)).toHaveLength(0);
+    expect(content).toBe("Content");
+  });
+
+  it("treats empty values as empty strings, not arrays", () => {
+    const raw = `---
+description:
+title: My Note
+---
+Content`;
+
+    const { frontmatter } = parseFrontmatter(raw);
+    expect(frontmatter.description).toBe("");
+    expect(frontmatter.title).toBe("My Note");
+  });
+
+  it("does not match keys with spaces", () => {
+    const raw = `---
+valid-key: yes
+another_key: also yes
+---
+Content`;
+
+    const { frontmatter } = parseFrontmatter(raw);
+    expect(frontmatter["valid-key"]).toBe("yes");
+    expect(frontmatter["another_key"]).toBe("also yes");
+  });
+
+  it("handles date values as strings", () => {
+    const raw = `---
+date: 2026-04-05
+---
+Content`;
+
+    const { frontmatter } = parseFrontmatter(raw);
+    // Date-like strings should be kept as strings
+    expect(typeof frontmatter.date).toBe("string");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Inline tag extraction
+// ---------------------------------------------------------------------------
+
+describe("extractInlineTags", () => {
+  it("extracts simple tags", () => {
+    const tags = extractInlineTags("Some text #daily and #voice here.");
+    expect(tags).toContain("daily");
+    expect(tags).toContain("voice");
+  });
+
+  it("extracts nested tags", () => {
+    const tags = extractInlineTags("Tagged #projects/parachute here.");
+    expect(tags).toContain("projects/parachute");
+  });
+
+  it("ignores tags in code blocks", () => {
+    const content = `
+Some text #real-tag
+
+\`\`\`
+#not-a-tag
+\`\`\`
+`;
+    const tags = extractInlineTags(content);
+    expect(tags).toContain("real-tag");
+    expect(tags).not.toContain("not-a-tag");
+  });
+
+  it("ignores tags in inline code", () => {
+    const tags = extractInlineTags("Use `#not-a-tag` for tagging. #real-tag");
+    expect(tags).not.toContain("not-a-tag");
+    expect(tags).toContain("real-tag");
+  });
+
+  it("deduplicates tags", () => {
+    const tags = extractInlineTags("#daily notes #daily logs");
+    expect(tags.filter((t) => t === "daily")).toHaveLength(1);
+  });
+
+  it("lowercases tags", () => {
+    const tags = extractInlineTags("#Daily #VOICE");
+    expect(tags).toContain("daily");
+    expect(tags).toContain("voice");
+  });
+
+  it("handles tags at start of line", () => {
+    const tags = extractInlineTags("#first-tag\nSome text");
+    expect(tags).toContain("first-tag");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Full vault parsing (with temp directory)
+// ---------------------------------------------------------------------------
+
+describe("parseObsidianVault", () => {
+  const tmpBase = join(tmpdir(), "parachute-test-obsidian");
+
+  beforeEach(() => {
+    try { rmSync(tmpBase, { recursive: true }); } catch {}
+    mkdirSync(tmpBase, { recursive: true });
+  });
+
+  it("parses a simple vault", () => {
+    writeFileSync(join(tmpBase, "Note One.md"), `---
+tags: [daily]
+---
+Hello world.`);
+    writeFileSync(join(tmpBase, "Note Two.md"), "Plain note. #voice");
+
+    const { notes, errors } = parseObsidianVault(tmpBase);
+    expect(errors).toHaveLength(0);
+    expect(notes).toHaveLength(2);
+
+    const one = notes.find((n) => n.path === "Note One");
+    expect(one).toBeTruthy();
+    expect(one!.tags).toContain("daily");
+    expect(one!.content).toBe("Hello world.");
+
+    const two = notes.find((n) => n.path === "Note Two");
+    expect(two).toBeTruthy();
+    expect(two!.tags).toContain("voice");
+  });
+
+  it("handles nested directories", () => {
+    mkdirSync(join(tmpBase, "Projects", "Parachute"), { recursive: true });
+    writeFileSync(join(tmpBase, "Projects", "Parachute", "README.md"), "# Parachute");
+
+    const { notes } = parseObsidianVault(tmpBase);
+    expect(notes).toHaveLength(1);
+    expect(notes[0].path).toBe("Projects/Parachute/README");
+  });
+
+  it("skips .obsidian directory", () => {
+    mkdirSync(join(tmpBase, ".obsidian"), { recursive: true });
+    writeFileSync(join(tmpBase, ".obsidian", "app.json"), "{}");
+    writeFileSync(join(tmpBase, "Real Note.md"), "Content");
+
+    const { notes } = parseObsidianVault(tmpBase);
+    expect(notes).toHaveLength(1);
+    expect(notes[0].path).toBe("Real Note");
+  });
+
+  it("merges frontmatter and inline tags", () => {
+    writeFileSync(join(tmpBase, "Mixed.md"), `---
+tags: [project]
+---
+Some text #daily here.`);
+
+    const { notes } = parseObsidianVault(tmpBase);
+    expect(notes[0].tags).toContain("project");
+    expect(notes[0].tags).toContain("daily");
+  });
+
+  it("preserves non-tag frontmatter as metadata", () => {
+    writeFileSync(join(tmpBase, "Rich.md"), `---
+tags: [daily]
+status: draft
+priority: 3
+---
+Content`);
+
+    const { notes } = parseObsidianVault(tmpBase);
+    expect(notes[0].frontmatter.status).toBe("draft");
+    expect(notes[0].frontmatter.priority).toBe(3);
+    // tags should be removed from frontmatter (they go to tags table)
+    expect(notes[0].frontmatter.tags).toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Export
+// ---------------------------------------------------------------------------
+
+describe("toObsidianMarkdown", () => {
+  it("generates markdown with frontmatter", () => {
+    const md = toObsidianMarkdown({
+      id: "test-id",
+      path: "My Note",
+      content: "Hello world.",
+      tags: ["daily", "voice"],
+      metadata: { status: "draft" },
+      createdAt: "2026-04-05T12:00:00Z",
+    });
+
+    expect(md).toContain("---");
+    expect(md).toContain("tags:");
+    expect(md).toContain("  - daily");
+    expect(md).toContain("  - voice");
+    expect(md).toContain("status: draft");
+    expect(md).toContain("Hello world.");
+  });
+
+  it("skips frontmatter when no metadata or tags", () => {
+    const md = toObsidianMarkdown({
+      id: "test-id",
+      content: "Just content.",
+      createdAt: "2026-04-05T12:00:00Z",
+    });
+
+    expect(md).not.toContain("---");
+    expect(md).toBe("Just content.");
+  });
+});
+
+describe("exportFilePath", () => {
+  it("uses note path with .md extension", () => {
+    expect(exportFilePath({
+      id: "test", path: "Projects/README", content: "", createdAt: "2026-04-05T12:00:00Z",
+    })).toBe("Projects/README.md");
+  });
+
+  it("generates path from date for pathless notes", () => {
+    expect(exportFilePath({
+      id: "abc123", content: "", createdAt: "2026-04-05T12:00:00Z",
+    })).toBe("2026-04-05/abc123.md");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Round-trip: import → export
+// ---------------------------------------------------------------------------
+
+describe("round-trip", () => {
+  const tmpBase = join(tmpdir(), "parachute-test-roundtrip");
+  let store: SqliteStore;
+
+  beforeEach(() => {
+    try { rmSync(tmpBase, { recursive: true }); } catch {}
+    mkdirSync(tmpBase, { recursive: true });
+    store = new SqliteStore(new Database(":memory:"));
+  });
+
+  it("preserves content through import → vault → export", () => {
+    // Create source files
+    writeFileSync(join(tmpBase, "Note.md"), `---
+tags: [daily]
+status: active
+---
+Hello world.`);
+
+    // Parse
+    const { notes } = parseObsidianVault(tmpBase);
+    expect(notes).toHaveLength(1);
+
+    // Import into vault
+    const note = store.createNote(notes[0].content, {
+      path: notes[0].path,
+      tags: notes[0].tags,
+      metadata: notes[0].frontmatter,
+    });
+
+    expect(note.content).toBe("Hello world.");
+    expect(note.path).toBe("Note");
+    expect(note.tags).toContain("daily");
+    expect(note.metadata?.status).toBe("active");
+
+    // Export back
+    const md = toObsidianMarkdown(note);
+    expect(md).toContain("tags:");
+    expect(md).toContain("  - daily");
+    expect(md).toContain("status: active");
+    expect(md).toContain("Hello world.");
+  });
+
+  it("resolves wikilinks during import", () => {
+    writeFileSync(join(tmpBase, "A.md"), "See [[B]] for details.");
+    writeFileSync(join(tmpBase, "B.md"), "I am note B.");
+
+    const { notes } = parseObsidianVault(tmpBase);
+
+    // Import all notes
+    for (const n of notes) {
+      store.createNote(n.content, {
+        path: n.path,
+        tags: n.tags.length > 0 ? n.tags : undefined,
+      });
+    }
+
+    // Check that A links to B
+    const noteA = store.getNoteByPath("A")!;
+    const noteB = store.getNoteByPath("B")!;
+    const links = store.getLinks(noteA.id, { direction: "outbound" });
+    expect(links.some((l) => l.targetId === noteB.id && l.relationship === "wikilink")).toBe(true);
+  });
+});

package/core/src/obsidian.ts

@@ -0,0 +1,322 @@
+/**
+ * Obsidian vault parser — reads .md files and extracts notes, tags, links.
+ *
+ * Handles:
+ *   - YAML frontmatter → note.metadata
+ *   - Inline #tags and frontmatter tags → tags table
+ *   - [[wikilinks]] → handled by wikilinks.ts on note creation
+ *   - File path → note.path
+ */
+
+import { readdirSync, readFileSync, statSync } from "fs";
+import { join, relative, extname, basename } from "path";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface ObsidianNote {
+  /** Relative path without .md extension (e.g., "Projects/Parachute/README") */
+  path: string;
+  /** Raw markdown content (frontmatter stripped) */
+  content: string;
+  /** Parsed YAML frontmatter */
+  frontmatter: Record<string, unknown>;
+  /** Tags from both frontmatter and inline #tags */
+  tags: string[];
+}
+
+export interface ImportStats {
+  files: number;
+  imported: number;
+  skipped: number;
+  tags: number;
+  errors: { path: string; error: string }[];
+}
+
+// ---------------------------------------------------------------------------
+// Frontmatter parsing
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse YAML frontmatter from markdown content.
+ * Returns { frontmatter, content } where content has frontmatter stripped.
+ *
+ * Uses a simple parser — no dependency on a YAML library.
+ * Handles common frontmatter patterns: strings, arrays, numbers, booleans.
+ */
+export function parseFrontmatter(raw: string): {
+  frontmatter: Record<string, unknown>;
+  content: string;
+} {
+  if (!raw.startsWith("---")) {
+    return { frontmatter: {}, content: raw };
+  }
+
+  const endIdx = raw.indexOf("\n---", 3);
+  if (endIdx === -1) {
+    return { frontmatter: {}, content: raw };
+  }
+
+  const yamlBlock = raw.slice(4, endIdx); // skip opening "---\n"
+  const content = raw.slice(endIdx + 4).replace(/^\n/, ""); // skip closing "---\n"
+
+  const frontmatter: Record<string, unknown> = {};
+  let currentKey = "";
+  let currentArray: string[] | null = null;
+
+  for (const line of yamlBlock.split("\n")) {
+    // Array item (continuation of previous key)
+    if (currentArray !== null && /^\s+-\s+/.test(line)) {
+      const val = line.replace(/^\s+-\s+/, "").trim();
+      currentArray.push(unquote(val));
+      continue;
+    }
+
+    // If we were building an array, save it (or save empty string if no items found)
+    if (currentArray !== null) {
+      frontmatter[currentKey] = currentArray.length > 0 ? currentArray : "";
+      currentArray = null;
+    }
+
+    // Key: value pair — keys must be YAML-valid (word chars and hyphens, no spaces)
+    const kvMatch = line.match(/^([\w][\w-]*):\s*(.*)/);
+    if (kvMatch) {
+      const key = kvMatch[1];
+      const value = kvMatch[2].trim();
+
+      if (value === "[]") {
+        frontmatter[key] = [];
+      } else if (value === "") {
+        // Empty value: could be start of array (next lines are "- item")
+        // or genuinely empty string. We start array accumulation and
+        // handle the empty case when a non-array line follows.
+        currentKey = key;
+        currentArray = [];
+      } else if (value.startsWith("[") && value.endsWith("]")) {
+        // Inline array: [item1, item2]
+        const items = value.slice(1, -1).split(",").map((s) => unquote(s.trim())).filter(Boolean);
+        frontmatter[key] = items;
+      } else {
+        frontmatter[key] = parseValue(value);
+      }
+    }
+  }
+
+  // Save any trailing array (or empty string if no items)
+  if (currentArray !== null) {
+    frontmatter[currentKey] = currentArray.length > 0 ? currentArray : "";
+  }
+
+  return { frontmatter, content };
+}
+
+function unquote(s: string): string {
+  if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+
+function parseValue(s: string): unknown {
+  s = unquote(s);
+  if (s === "true") return true;
+  if (s === "false") return false;
+  if (s === "null") return null;
+  if (/^-?\d+$/.test(s)) return parseInt(s, 10);
+  if (/^-?\d+\.\d+$/.test(s)) return parseFloat(s);
+  return s;
+}
+
+// ---------------------------------------------------------------------------
+// Tag extraction
+// ---------------------------------------------------------------------------
+
+/** Extract inline #tags from markdown content. Excludes tags in code blocks. */
+export function extractInlineTags(content: string): string[] {
+  // Strip code blocks and inline code
+  let stripped = content.replace(/```[\s\S]*?```/g, "");
+  stripped = stripped.replace(/`[^`\n]+`/g, "");
+
+  const tags = new Set<string>();
+  // Match #tag and #nested/tag — must be preceded by whitespace or start of line
+  const regex = /(?:^|\s)#([\w][\w/-]*[\w]|[\w])/gm;
+  let match: RegExpExecArray | null;
+  while ((match = regex.exec(stripped)) !== null) {
+    tags.add(match[1].toLowerCase());
+  }
+  return [...tags];
+}
+
+/** Extract tags from frontmatter (handles both array and string formats). */
+function extractFrontmatterTags(frontmatter: Record<string, unknown>): string[] {
+  const raw = frontmatter.tags;
+  if (!raw) return [];
+  if (Array.isArray(raw)) return raw.map((t) => String(t).toLowerCase().trim()).filter(Boolean);
+  if (typeof raw === "string") return raw.split(",").map((t) => t.toLowerCase().trim()).filter(Boolean);
+  return [];
+}
+
+// ---------------------------------------------------------------------------
+// Directory walking
+// ---------------------------------------------------------------------------
+
+/** Recursively list all .md files in a directory, excluding .obsidian/ and hidden dirs. */
+export function walkMarkdownFiles(dir: string): string[] {
+  const results: string[] = [];
+
+  function walk(current: string) {
+    for (const entry of readdirSync(current)) {
+      // Skip hidden directories and .obsidian config
+      if (entry.startsWith(".")) continue;
+      if (entry === "node_modules") continue;
+
+      const full = join(current, entry);
+      const stat = statSync(full);
+
+      if (stat.isDirectory()) {
+        walk(full);
+      } else if (stat.isFile() && extname(entry).toLowerCase() === ".md") {
+        results.push(full);
+      }
+    }
+  }
+
+  walk(dir);
+  return results.sort();
+}
+
+// ---------------------------------------------------------------------------
+// Parse a single file
+// ---------------------------------------------------------------------------
+
+export function parseObsidianFile(filePath: string, vaultRoot: string): ObsidianNote {
+  const raw = readFileSync(filePath, "utf-8");
+  const { frontmatter, content } = parseFrontmatter(raw);
+
+  // Path: relative to vault root, without .md extension
+  const rel = relative(vaultRoot, filePath);
+  const path = rel.replace(/\.md$/i, "");
+
+  // Merge tags from frontmatter and inline
+  const fmTags = extractFrontmatterTags(frontmatter);
+  const inlineTags = extractInlineTags(content);
+  const allTags = [...new Set([...fmTags, ...inlineTags])];
+
+  // Remove tags from metadata (they go to the tags table)
+  const metadata = { ...frontmatter };
+  delete metadata.tags;
+
+  return {
+    path,
+    content,
+    frontmatter: metadata,
+    tags: allTags,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Import an Obsidian vault
+// ---------------------------------------------------------------------------
+
+export interface ImportOptions {
+  /** Override vault name to import into */
+  vault?: string;
+  /** Dry run — don't actually import */
+  dryRun?: boolean;
+}
+
+/**
+ * Parse an entire Obsidian vault directory into ObsidianNote objects.
+ * Does not write to the database — caller handles that.
+ */
+export function parseObsidianVault(vaultPath: string): {
+  notes: ObsidianNote[];
+  errors: { path: string; error: string }[];
+} {
+  const files = walkMarkdownFiles(vaultPath);
+  const notes: ObsidianNote[] = [];
+  const errors: { path: string; error: string }[] = [];
+
+  for (const file of files) {
+    try {
+      const note = parseObsidianFile(file, vaultPath);
+      notes.push(note);
+    } catch (err) {
+      errors.push({
+        path: relative(vaultPath, file),
+        error: err instanceof Error ? err.message : "parse error",
+      });
+    }
+  }
+
+  return { notes, errors };
+}
+
+// ---------------------------------------------------------------------------
+// Export to Obsidian format
+// ---------------------------------------------------------------------------
+
+export interface ExportableNote {
+  path?: string;
+  id: string;
+  content: string;
+  metadata?: Record<string, unknown>;
+  tags?: string[];
+  createdAt: string;
+}
+
+/**
+ * Convert a vault note to Obsidian-compatible markdown with YAML frontmatter.
+ */
+export function toObsidianMarkdown(note: ExportableNote): string {
+  const fm: Record<string, unknown> = {};
+
+  // Add tags to frontmatter
+  if (note.tags && note.tags.length > 0) {
+    fm.tags = note.tags;
+  }
+
+  // Add metadata fields (excluding internal ones)
+  if (note.metadata) {
+    for (const [key, value] of Object.entries(note.metadata)) {
+      if (key === "tags") continue; // already handled
+      fm[key] = value;
+    }
+  }
+
+  // Build frontmatter string
+  let result = "";
+  if (Object.keys(fm).length > 0) {
+    result += "---\n";
+    for (const [key, value] of Object.entries(fm)) {
+      if (Array.isArray(value)) {
+        result += `${key}:\n`;
+        for (const item of value) {
+          result += `  - ${item}\n`;
+        }
+      } else if (typeof value === "object" && value !== null) {
+        result += `${key}: ${JSON.stringify(value)}\n`;
+      } else {
+        result += `${key}: ${value}\n`;
+      }
+    }
+    result += "---\n";
+  }
+
+  result += note.content;
+  return result;
+}
+
+/**
+ * Determine the file path for an exported note.
+ * Notes with paths use the path; pathless notes use date/id.
+ */
+export function exportFilePath(note: ExportableNote): string {
+  if (note.path) {
+    return note.path + ".md";
+  }
+  // Fallback: use date prefix + truncated id
+  const date = note.createdAt.split("T")[0];
+  return `${date}/${note.id}.md`;
+}