@openparachute/vault 0.1.0

package/core/src/wikilinks.test.ts

@@ -0,0 +1,277 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import { Database } from "bun:sqlite";
+import { SqliteStore } from "./store.js";
+import { parseWikilinks, syncWikilinks, resolveWikilink, resolveUnresolvedWikilinks } from "./wikilinks.js";
+
+let store: SqliteStore;
+let db: Database;
+
+beforeEach(() => {
+  db = new Database(":memory:");
+  store = new SqliteStore(db);
+});
+
+// ---------------------------------------------------------------------------
+// Parser
+// ---------------------------------------------------------------------------
+
+describe("parseWikilinks", () => {
+  it("parses simple wikilinks", () => {
+    const links = parseWikilinks("Check out [[My Note]] for details.");
+    expect(links).toHaveLength(1);
+    expect(links[0].target).toBe("My Note");
+    expect(links[0].embed).toBe(false);
+  });
+
+  it("parses multiple wikilinks", () => {
+    const links = parseWikilinks("See [[Note A]] and [[Note B]].");
+    expect(links).toHaveLength(2);
+    expect(links[0].target).toBe("Note A");
+    expect(links[1].target).toBe("Note B");
+  });
+
+  it("parses aliased wikilinks", () => {
+    const links = parseWikilinks("See [[Real Name|display text]] here.");
+    expect(links).toHaveLength(1);
+    expect(links[0].target).toBe("Real Name");
+    expect(links[0].display).toBe("display text");
+  });
+
+  it("parses heading anchors", () => {
+    const links = parseWikilinks("See [[Note#Section One]].");
+    expect(links).toHaveLength(1);
+    expect(links[0].target).toBe("Note");
+    expect(links[0].anchor).toBe("Section One");
+  });
+
+  it("parses block references", () => {
+    const links = parseWikilinks("See [[Note#^abc123]].");
+    expect(links).toHaveLength(1);
+    expect(links[0].target).toBe("Note");
+    expect(links[0].blockRef).toBe("abc123");
+  });
+
+  it("parses heading + alias combo", () => {
+    const links = parseWikilinks("See [[Note#Heading|click here]].");
+    expect(links).toHaveLength(1);
+    expect(links[0].target).toBe("Note");
+    expect(links[0].anchor).toBe("Heading");
+    expect(links[0].display).toBe("click here");
+  });
+
+  it("parses embeds", () => {
+    const links = parseWikilinks("![[My Image]]");
+    expect(links).toHaveLength(1);
+    expect(links[0].target).toBe("My Image");
+    expect(links[0].embed).toBe(true);
+  });
+
+  it("parses nested paths", () => {
+    const links = parseWikilinks("See [[Projects/Parachute/README]].");
+    expect(links).toHaveLength(1);
+    expect(links[0].target).toBe("Projects/Parachute/README");
+  });
+
+  it("ignores wikilinks in code blocks", () => {
+    const content = `
+Some text [[Real Link]]
+
+\`\`\`
+[[Not A Link]]
+\`\`\`
+
+More text
+`;
+    const links = parseWikilinks(content);
+    expect(links).toHaveLength(1);
+    expect(links[0].target).toBe("Real Link");
+  });
+
+  it("ignores wikilinks in inline code", () => {
+    const links = parseWikilinks("Use `[[Not A Link]]` syntax for links.");
+    expect(links).toHaveLength(0);
+  });
+
+  it("handles empty content", () => {
+    expect(parseWikilinks("")).toHaveLength(0);
+  });
+
+  it("handles content with no wikilinks", () => {
+    expect(parseWikilinks("Just plain text.")).toHaveLength(0);
+  });
+
+  it("skips empty targets", () => {
+    const links = parseWikilinks("Empty [[]] link.");
+    expect(links).toHaveLength(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Resolution
+// ---------------------------------------------------------------------------
+
+describe("resolveWikilink", () => {
+  it("resolves exact path match", () => {
+    store.createNote("Target note", { path: "My Note" });
+    const id = resolveWikilink(db, "My Note");
+    expect(id).toBeTruthy();
+  });
+
+  it("resolves case-insensitively", () => {
+    const note = store.createNote("Target", { path: "My Note" });
+    const id = resolveWikilink(db, "my note");
+    expect(id).toBe(note.id);
+  });
+
+  it("resolves basename match", () => {
+    const note = store.createNote("Deep note", { path: "Projects/Parachute/README" });
+    const id = resolveWikilink(db, "README");
+    expect(id).toBe(note.id);
+  });
+
+  it("returns null for ambiguous basename", () => {
+    store.createNote("A", { path: "Folder1/README" });
+    store.createNote("B", { path: "Folder2/README" });
+    const id = resolveWikilink(db, "README");
+    expect(id).toBeNull();
+  });
+
+  it("returns null for unresolvable target", () => {
+    const id = resolveWikilink(db, "Nonexistent Note");
+    expect(id).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Sync
+// ---------------------------------------------------------------------------
+
+describe("syncWikilinks", () => {
+  it("creates links for resolved wikilinks", () => {
+    const target = store.createNote("Target", { path: "Target Note" });
+    const source = store.createNote("See [[Target Note]]");
+
+    const links = store.getLinks(source.id, { direction: "outbound" });
+    expect(links).toHaveLength(1);
+    expect(links[0].targetId).toBe(target.id);
+    expect(links[0].relationship).toBe("wikilink");
+  });
+
+  it("tracks unresolved wikilinks", () => {
+    const source = store.createNote("See [[Missing Note]]");
+
+    const links = store.getLinks(source.id, { direction: "outbound" });
+    expect(links).toHaveLength(0);
+
+    // Check unresolved table
+    const unresolved = db.prepare(
+      "SELECT * FROM unresolved_wikilinks WHERE source_id = ?",
+    ).all(source.id) as { source_id: string; target_path: string }[];
+    expect(unresolved).toHaveLength(1);
+    expect(unresolved[0].target_path).toBe("Missing Note");
+  });
+
+  it("resolves pending wikilinks when target note is created", () => {
+    const source = store.createNote("See [[Future Note]]");
+
+    // No link yet
+    expect(store.getLinks(source.id, { direction: "outbound" })).toHaveLength(0);
+
+    // Create the target note
+    const target = store.createNote("I exist now", { path: "Future Note" });
+
+    // Link should now exist
+    const links = store.getLinks(source.id, { direction: "outbound" });
+    expect(links).toHaveLength(1);
+    expect(links[0].targetId).toBe(target.id);
+  });
+
+  it("removes links when wikilinks are removed from content", () => {
+    const target = store.createNote("Target", { path: "Target" });
+    const source = store.createNote("See [[Target]]");
+
+    expect(store.getLinks(source.id, { direction: "outbound" })).toHaveLength(1);
+
+    // Update content to remove the wikilink
+    store.updateNote(source.id, { content: "No more links here." });
+
+    expect(store.getLinks(source.id, { direction: "outbound" })).toHaveLength(0);
+  });
+
+  it("adds new links when wikilinks are added to content", () => {
+    const a = store.createNote("A", { path: "Note A" });
+    const b = store.createNote("B", { path: "Note B" });
+    const source = store.createNote("See [[Note A]]");
+
+    expect(store.getLinks(source.id, { direction: "outbound" })).toHaveLength(1);
+
+    // Update to add another link
+    store.updateNote(source.id, { content: "See [[Note A]] and [[Note B]]" });
+
+    const links = store.getLinks(source.id, { direction: "outbound" });
+    expect(links).toHaveLength(2);
+  });
+
+  it("does not create self-links", () => {
+    const note = store.createNote("I link to [[Myself]]", { path: "Myself" });
+    const links = store.getLinks(note.id, { direction: "outbound" });
+    expect(links.filter((l) => l.relationship === "wikilink")).toHaveLength(0);
+  });
+
+  it("deduplicates multiple mentions of same target", () => {
+    const target = store.createNote("Target", { path: "Target" });
+    const source = store.createNote("See [[Target]] and again [[Target]]");
+
+    const links = store.getLinks(source.id, { direction: "outbound" })
+      .filter((l) => l.relationship === "wikilink");
+    expect(links).toHaveLength(1);
+  });
+
+  it("preserves non-wikilink links", () => {
+    const a = store.createNote("A", { id: "a", path: "Note A" });
+    const b = store.createNote("B", { id: "b", path: "Note B" });
+
+    // Manual semantic link
+    store.createLink("a", "b", "related-to");
+
+    // Create note with wikilink to B
+    const source = store.createNote("See [[Note B]]", { id: "source" });
+
+    // Update content to remove wikilink
+    store.updateNote("source", { content: "No links" });
+
+    // Semantic link between a and b should still exist
+    const links = store.getLinks("a", { direction: "outbound" });
+    expect(links.some((l) => l.relationship === "related-to")).toBe(true);
+  });
+
+  it("stores display text and anchor in link metadata", () => {
+    const target = store.createNote("Target", { path: "Target" });
+    const source = store.createNote("See [[Target#Introduction|intro]]");
+
+    const links = store.getLinks(source.id, { direction: "outbound" });
+    expect(links).toHaveLength(1);
+    expect(links[0].metadata?.display).toBe("intro");
+    expect(links[0].metadata?.anchor).toBe("Introduction");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Integration with path changes
+// ---------------------------------------------------------------------------
+
+describe("path-based resolution", () => {
+  it("resolves pending links when a note gets a path", () => {
+    const source = store.createNote("See [[Named Note]]");
+    expect(store.getLinks(source.id, { direction: "outbound" })).toHaveLength(0);
+
+    // Create a note without a path, then give it one
+    const target = store.createNote("Unnamed");
+    store.updateNote(target.id, { path: "Named Note" });
+
+    // The pending link should be resolved
+    const links = store.getLinks(source.id, { direction: "outbound" });
+    expect(links).toHaveLength(1);
+    expect(links[0].targetId).toBe(target.id);
+  });
+});

package/core/src/wikilinks.ts

@@ -0,0 +1,402 @@
+import { Database } from "bun:sqlite";
+import * as linkOps from "./links.js";
+
+// ---------------------------------------------------------------------------
+// Parser — extract [[wikilinks]] from markdown content
+// ---------------------------------------------------------------------------
+
+export interface ParsedWikilink {
+  /** Raw match text (e.g., "[[Note Name|Display]]") */
+  raw: string;
+  /** Target path/name (e.g., "Note Name") */
+  target: string;
+  /** Display text if aliased (e.g., "Display") */
+  display?: string;
+  /** Section anchor (e.g., "Heading" from [[Note#Heading]]) */
+  anchor?: string;
+  /** Block reference (e.g., "block-id" from [[Note#^block-id]]) */
+  blockRef?: string;
+  /** Whether this is an embed (![[...]]) */
+  embed: boolean;
+}
+
+/**
+ * Parse all [[wikilinks]] from markdown content.
+ *
+ * Handles:
+ *   [[Target]]
+ *   [[Target|Display Text]]
+ *   [[Target#Heading]]
+ *   [[Target#^block-id]]
+ *   [[Target#Heading|Display]]
+ *   ![[Target]] (embeds)
+ *
+ * Ignores wikilinks inside code blocks and inline code.
+ */
+export function parseWikilinks(content: string): ParsedWikilink[] {
+  // Strip code blocks and inline code to avoid false matches
+  const stripped = stripCode(content);
+
+  const results: ParsedWikilink[] = [];
+  // Match !?[[...]] — non-greedy, no newlines inside
+  const regex = /(!)?\[\[([^\[\]\n]+?)\]\]/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = regex.exec(stripped)) !== null) {
+    const embed = match[1] === "!";
+    const inner = match[2];
+
+    // Split on | for display text: [[target|display]]
+    const pipeIdx = inner.indexOf("|");
+    let targetPart: string;
+    let display: string | undefined;
+    if (pipeIdx !== -1) {
+      targetPart = inner.slice(0, pipeIdx);
+      display = inner.slice(pipeIdx + 1);
+    } else {
+      targetPart = inner;
+    }
+
+    // Split on # for anchor: [[target#heading]] or [[target#^block-id]]
+    let target: string;
+    let anchor: string | undefined;
+    let blockRef: string | undefined;
+    const hashIdx = targetPart.indexOf("#");
+    if (hashIdx !== -1) {
+      target = targetPart.slice(0, hashIdx);
+      const fragment = targetPart.slice(hashIdx + 1);
+      if (fragment.startsWith("^")) {
+        blockRef = fragment.slice(1);
+      } else {
+        anchor = fragment;
+      }
+    } else {
+      target = targetPart;
+    }
+
+    target = target.trim();
+    if (!target) continue;
+
+    results.push({
+      raw: match[0],
+      target,
+      display: display?.trim(),
+      anchor,
+      blockRef,
+      embed,
+    });
+  }
+
+  return results;
+}
+
+/**
+ * Strip fenced code blocks and inline code from content.
+ * Replaces them with spaces to preserve string positions.
+ */
+function stripCode(content: string): string {
+  // Replace fenced code blocks (``` ... ```)
+  let result = content.replace(/```[\s\S]*?```/g, (m) => " ".repeat(m.length));
+  // Replace inline code (` ... `)
+  result = result.replace(/`[^`\n]+`/g, (m) => " ".repeat(m.length));
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Resolution — match wikilink targets to notes by path
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve a wikilink target to a note ID.
+ *
+ * Resolution order:
+ * 1. Exact path match (case-insensitive)
+ * 2. Basename match — target matches the last segment of a path
+ *    (e.g., "README" matches "Projects/Parachute/README")
+ *    Only if there's exactly one match (ambiguous = unresolved)
+ */
+export function resolveWikilink(db: Database, target: string): string | null {
+  // 1. Exact match (case-insensitive)
+  const exact = db.prepare(
+    "SELECT id FROM notes WHERE path = ? COLLATE NOCASE",
+  ).get(target) as { id: string } | undefined;
+  if (exact) return exact.id;
+
+  // 2. Basename match — last path segment equals target
+  // e.g., target "README" matches path "Projects/Parachute/README"
+  const basename = db.prepare(`
+    SELECT id FROM notes
+    WHERE path IS NOT NULL
+      AND (
+        path = ? COLLATE NOCASE
+        OR path LIKE ? COLLATE NOCASE
+      )
+  `).all(target, `%/${target}`) as { id: string }[];
+
+  if (basename.length === 1) return basename[0].id;
+
+  // Ambiguous or no match
+  return null;
+}
+
+/** Result of a detailed wikilink resolution. */
+export interface WikilinkResolution {
+  resolved: boolean;
+  note_id?: string;
+  path?: string;
+  ambiguous?: boolean;
+  candidates: { note_id: string; path: string }[];
+}
+
+/**
+ * Resolve a wikilink target with full detail — single match, ambiguous, or unresolved.
+ */
+export function resolveWikilinkDetailed(db: Database, target: string): WikilinkResolution {
+  // 1. Exact match (case-insensitive)
+  const exact = db.prepare(
+    "SELECT id, path FROM notes WHERE path = ? COLLATE NOCASE",
+  ).get(target) as { id: string; path: string } | undefined;
+  if (exact) {
+    return { resolved: true, note_id: exact.id, path: exact.path, candidates: [] };
+  }
+
+  // 2. Basename match
+  const basename = db.prepare(`
+    SELECT id, path FROM notes
+    WHERE path IS NOT NULL
+      AND (
+        path = ? COLLATE NOCASE
+        OR path LIKE ? COLLATE NOCASE
+      )
+  `).all(target, `%/${target}`) as { id: string; path: string }[];
+
+  if (basename.length === 1) {
+    return { resolved: true, note_id: basename[0].id, path: basename[0].path, candidates: [] };
+  }
+
+  if (basename.length > 1) {
+    return {
+      resolved: false,
+      ambiguous: true,
+      candidates: basename.map((r) => ({ note_id: r.id, path: r.path })),
+    };
+  }
+
+  return { resolved: false, ambiguous: false, candidates: [] };
+}
+
+/** Entry from the unresolved_wikilinks table. */
+export interface UnresolvedWikilink {
+  source_id: string;
+  source_path?: string;
+  target_path: string;
+}
+
+/**
+ * List unresolved wikilinks across the vault.
+ */
+export function listUnresolvedWikilinks(db: Database, limit = 50): { unresolved: UnresolvedWikilink[]; count: number } {
+  let total: number;
+  let rows: { source_id: string; target_path: string }[];
+  try {
+    total = (db.prepare("SELECT COUNT(*) as c FROM unresolved_wikilinks").get() as { c: number }).c;
+    rows = db.prepare(
+      "SELECT source_id, target_path FROM unresolved_wikilinks ORDER BY source_id LIMIT ?",
+    ).all(limit) as { source_id: string; target_path: string }[];
+  } catch {
+    // Table doesn't exist yet
+    return { unresolved: [], count: 0 };
+  }
+
+  // Hydrate source paths
+  if (rows.length === 0) return { unresolved: [], count: total };
+
+  const sourceIds = [...new Set(rows.map((r) => r.source_id))];
+  const placeholders = sourceIds.map(() => "?").join(", ");
+  const pathRows = db.prepare(
+    `SELECT id, path FROM notes WHERE id IN (${placeholders})`,
+  ).all(...sourceIds) as { id: string; path: string | null }[];
+  const pathMap = new Map(pathRows.map((r) => [r.id, r.path]));
+
+  const unresolved: UnresolvedWikilink[] = rows.map((r) => ({
+    source_id: r.source_id,
+    source_path: pathMap.get(r.source_id) ?? undefined,
+    target_path: r.target_path,
+  }));
+
+  return { unresolved, count: total };
+}
+
+// ---------------------------------------------------------------------------
+// Sync — maintain wikilink-based links for a note
+// ---------------------------------------------------------------------------
+
+const WIKILINK_REL = "wikilink";
+
+/**
+ * Sync wikilink-based links for a note.
+ * Parses content for [[wikilinks]], resolves targets, creates/removes links.
+ *
+ * Returns counts of changes made.
+ */
+export function syncWikilinks(
+  db: Database,
+  noteId: string,
+  content: string,
+): { added: number; removed: number; unresolved: string[] } {
+  const parsed = parseWikilinks(content);
+
+  // Deduplicate by target (same target mentioned multiple times = one link)
+  const targetMap = new Map<string, ParsedWikilink>();
+  for (const wl of parsed) {
+    const key = wl.target.toLowerCase();
+    if (!targetMap.has(key)) {
+      targetMap.set(key, wl);
+    }
+  }
+
+  // Resolve each unique target
+  const resolvedLinks = new Map<string, { targetId: string; wl: ParsedWikilink }>();
+  const unresolved: string[] = [];
+
+  for (const [key, wl] of targetMap) {
+    const targetId = resolveWikilink(db, wl.target);
+    if (targetId && targetId !== noteId) {
+      // Don't create self-links
+      resolvedLinks.set(targetId, { targetId, wl });
+    } else if (!targetId) {
+      unresolved.push(wl.target);
+    }
+  }
+
+  // Get existing wikilink links from this note
+  const existing = linkOps.getLinks(db, noteId, { direction: "outbound" })
+    .filter((l) => l.relationship === WIKILINK_REL);
+
+  const existingTargets = new Set(existing.map((l) => l.targetId));
+  const desiredTargets = new Set(resolvedLinks.keys());
+
+  // Add new links
+  let added = 0;
+  for (const [targetId, { wl }] of resolvedLinks) {
+    if (!existingTargets.has(targetId)) {
+      const metadata: Record<string, unknown> = {};
+      if (wl.display) metadata.display = wl.display;
+      if (wl.anchor) metadata.anchor = wl.anchor;
+      if (wl.blockRef) metadata.block_ref = wl.blockRef;
+      if (wl.embed) metadata.embed = true;
+
+      linkOps.createLink(
+        db,
+        noteId,
+        targetId,
+        WIKILINK_REL,
+        Object.keys(metadata).length > 0 ? metadata : undefined,
+      );
+      added++;
+    }
+  }
+
+  // Remove stale links (wikilinks that were removed from content)
+  let removed = 0;
+  for (const link of existing) {
+    if (!desiredTargets.has(link.targetId)) {
+      linkOps.deleteLink(db, noteId, link.targetId, WIKILINK_REL);
+      removed++;
+    }
+  }
+
+  // Store unresolved wikilinks for later resolution
+  syncUnresolvedWikilinks(db, noteId, unresolved);
+
+  return { added, removed, unresolved };
+}
+
+// ---------------------------------------------------------------------------
+// Unresolved wikilinks — pending resolution when target notes are created
+// ---------------------------------------------------------------------------
+
+/**
+ * Ensure the unresolved_wikilinks table exists.
+ * Called lazily — only when we actually have unresolved links.
+ */
+export function ensureUnresolvedTable(db: Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS unresolved_wikilinks (
+      source_id TEXT NOT NULL REFERENCES notes(id) ON DELETE CASCADE,
+      target_path TEXT NOT NULL COLLATE NOCASE,
+      PRIMARY KEY (source_id, target_path)
+    )
+  `);
+}
+
+/**
+ * Update unresolved wikilinks for a note.
+ */
+function syncUnresolvedWikilinks(
+  db: Database,
+  noteId: string,
+  unresolvedPaths: string[],
+): void {
+  if (unresolvedPaths.length === 0) {
+    // Clean up any old unresolved entries for this note
+    try {
+      db.prepare("DELETE FROM unresolved_wikilinks WHERE source_id = ?").run(noteId);
+    } catch {
+      // Table may not exist yet — that's fine
+    }
+    return;
+  }
+
+  ensureUnresolvedTable(db);
+
+  // Replace all unresolved entries for this note
+  db.prepare("DELETE FROM unresolved_wikilinks WHERE source_id = ?").run(noteId);
+  const insert = db.prepare(
+    "INSERT OR IGNORE INTO unresolved_wikilinks (source_id, target_path) VALUES (?, ?)",
+  );
+  for (const path of unresolvedPaths) {
+    insert.run(noteId, path);
+  }
+}
+
+/**
+ * Try to resolve pending wikilinks that point to a given path.
+ * Called when a note is created or its path changes.
+ *
+ * Returns the number of links resolved.
+ */
+export function resolveUnresolvedWikilinks(
+  db: Database,
+  notePath: string,
+  noteId: string,
+): number {
+  let rows: { source_id: string }[];
+  try {
+    rows = db.prepare(`
+      SELECT source_id FROM unresolved_wikilinks
+      WHERE target_path = ? COLLATE NOCASE
+         OR ? LIKE '%/' || target_path
+    `).all(notePath, notePath) as { source_id: string }[];
+  } catch {
+    return 0; // Table doesn't exist
+  }
+
+  if (rows.length === 0) return 0;
+
+  let resolved = 0;
+  for (const row of rows) {
+    if (row.source_id === noteId) continue; // Skip self-links
+
+    // Create the wikilink
+    linkOps.createLink(db, row.source_id, noteId, WIKILINK_REL);
+    resolved++;
+
+    // Remove the unresolved entry
+    db.prepare(
+      "DELETE FROM unresolved_wikilinks WHERE source_id = ? AND (target_path = ? COLLATE NOCASE OR ? LIKE '%/' || target_path)",
+    ).run(row.source_id, notePath, notePath);
+  }
+
+  return resolved;
+}

package/deploy/parachute-vault.service

@@ -0,0 +1,20 @@
+[Unit]
+Description=Parachute Vault
+After=network.target
+
+[Service]
+Type=simple
+User=parachute
+WorkingDirectory=/opt/parachute-vault
+ExecStart=/usr/local/bin/bun src/server.ts
+Restart=on-failure
+RestartSec=5
+EnvironmentFile=/opt/parachute-vault/.env
+
+# Hardening
+NoNewPrivileges=true
+ProtectSystem=strict
+ReadWritePaths=/home/parachute/.parachute
+
+[Install]
+WantedBy=multi-user.target