pagedex 0.0.0-stage → 0.1.0

package/dist/favicon.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" fill="none">
+  <rect x="2" y="2" width="60" height="60" rx="16" fill="#181a20" stroke="#8b5cf6" stroke-opacity="0.5" stroke-width="2.5" />
+  <path d="M15 18H25L32 37L26.5 48L15 18Z" fill="#a78bfa" />
+  <path d="M49 18H39L32 37V48H37.5L49 18Z" fill="#7c3aed" />
+  <path d="M26.5 48L32 37L37.5 48H26.5Z" fill="#ede9fe" />
+  <circle cx="32" cy="23.5" r="3.2" fill="#eceef2" />
+</svg>

package/dist/index.html

@@ -0,0 +1,22 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="color-scheme" content="dark light" />
+    <meta name="theme-color" content="#111216" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <link rel="icon" type="image/png" sizes="32x32" href="/favicon-32x32.png" />
+    <link rel="icon" href="/favicon.ico" sizes="any" />
+    <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png" />
+    <title>Vault</title>
+    <script type="module" crossorigin src="/assets/index-B9GrzXPf.js"></script>
+    <link rel="modulepreload" crossorigin href="/assets/vendor-react-E4kvVwMA.js">
+    <link rel="modulepreload" crossorigin href="/assets/vendor-markdown-C94ubdL7.js">
+    <link rel="modulepreload" crossorigin href="/assets/vendor-hljs-B8we2J8a.js">
+    <link rel="stylesheet" crossorigin href="/assets/index-D21lvsqQ.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/dist/vault-logo.svg

@@ -0,0 +1,15 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" fill="none">
+  <!-- App squircle -->
+  <rect x="2" y="2" width="60" height="60" rx="15" fill="#181a20" stroke="#8b5cf6" stroke-opacity="0.45" stroke-width="2" />
+
+  <!-- Subtle inner vault ring -->
+  <circle cx="32" cy="32" r="21" stroke="#8b5cf6" stroke-opacity="0.18" stroke-width="1.5" />
+
+  <!-- Geometric Vault 'V' facets -->
+  <path d="M16 19H25.5L32 36.5L26.5 47L16 19Z" fill="#a78bfa" />
+  <path d="M48 19H38.5L32 36.5V47H37.5L48 19Z" fill="#7c3aed" />
+  <path d="M26.5 47L32 36.5L37.5 47H26.5Z" fill="#ddd6fe" />
+
+  <!-- Keyhole / lock pin -->
+  <circle cx="32" cy="23.5" r="3" fill="#eceef2" />
+</svg>

package/dist/vault-mark.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+  <rect x="2.5" y="2.5" width="19" height="19" rx="5" stroke="currentColor" stroke-width="1.75" />
+  <path d="M7.2 7.5L12 17L16.8 7.5" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+  <circle cx="12" cy="8.5" r="1.35" fill="currentColor" />
+</svg>

package/package.json

@@ -1,6 +1,50 @@
 {
   "name": "pagedex",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Local-first Markdown knowledge viewer, editor, Git bridge, and MCP v2 server for any directory.",
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=22.5.0"
+  },
+  "bin": {
+    "pagedex": "./bin/pagedex.js"
+  },
+  "files": [
+    "bin/",
+    "src/server/",
+    "dist/",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "node src/server/dev.js",
+    "dev:server": "node --no-warnings --watch src/server/index.js",
+    "dev:client": "vite",
+    "build": "vite build",
+    "start": "node --no-warnings src/server/index.js",
+    "prepublishOnly": "vite build",
+    "test": "node --no-warnings --test test/*.test.js",
+    "smoke": "node --no-warnings test/smoke.js all",
+    "smoke:api": "node --no-warnings test/smoke.js api",
+    "smoke:mcp": "node --no-warnings test/smoke.js mcp"
+  },
+  "dependencies": {
+    "@hono/node-server": "^1.14.0",
+    "@modelcontextprotocol/client": "^2.4.0",
+    "@modelcontextprotocol/server": "^2.4.0",
+    "@tiptap/pm": "^3.34.0",
+    "@tiptap/react": "^3.34.0",
+    "@tiptap/starter-kit": "^3.34.0",
+    "highlight.js": "^11.12.0",
+    "hono": "^4.7.0",
+    "marked": "^15.0.0",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "tiptap-markdown": "^0.9.0",
+    "zod": "^4.6.7"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-react": "^4.4.0",
+    "vite": "^6.3.0"
+  }
+}

package/src/server/dev.js

@@ -0,0 +1,14 @@
+import { spawn } from 'node:child_process';
+
+const procs = [
+  spawn('node', ['--watch', 'src/server/index.js'], { stdio: 'inherit' }),
+  spawn('pnpm', ['exec', 'vite'], { stdio: 'inherit' })
+];
+
+function shutdown() {
+  for (const p of procs) p.kill('SIGTERM');
+  process.exit(0);
+}
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);

package/src/server/fs-ops.js

@@ -0,0 +1,120 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { VAULT_ROOT, isProtectedPath, resolveSafe } from './paths.js';
+import { invalidateVaultCache, removeVaultCacheFile, updateVaultCacheFile } from './vault-cache.js';
+
+export function writeNote(relPath, content, { append = false } = {}) {
+  if (!relPath || isProtectedPath(relPath)) return null;
+  const full = resolveSafe(relPath);
+  if (!full || full === VAULT_ROOT) return null;
+  fs.mkdirSync(path.dirname(full), { recursive: true });
+  if (append && fs.existsSync(full)) {
+    fs.appendFileSync(full, String(content ?? ''), 'utf8');
+  } else {
+    fs.writeFileSync(full, String(content ?? ''), 'utf8');
+  }
+  const clean = relPath.replace(/^\/+/, '');
+  updateVaultCacheFile(clean);
+  return { path: clean, bytes: Buffer.byteLength(String(content ?? ''), 'utf8') };
+}
+
+export function editNote(relPath, target, replacement, { replaceAll = false } = {}) {
+  if (!relPath || isProtectedPath(relPath) || typeof target !== 'string' || !target) {
+    return { error: 'Invalid path or empty target' };
+  }
+  const full = resolveSafe(relPath);
+  if (!full || !fs.existsSync(full) || !fs.statSync(full).isFile()) {
+    return { error: 'File not found' };
+  }
+  const current = fs.readFileSync(full, 'utf8');
+  if (!current.includes(target)) {
+    return { error: 'Target not found in file' };
+  }
+  const count = current.split(target).length - 1;
+  if (count > 1 && !replaceAll) {
+    return { error: `Target matched ${count} times; pass replaceAll: true or more context` };
+  }
+  const next = replaceAll ? current.split(target).join(String(replacement ?? '')) : current.replace(target, String(replacement ?? ''));
+  const clean = relPath.replace(/^\/+/, '');
+  fs.writeFileSync(full, next, 'utf8');
+  updateVaultCacheFile(clean);
+  return {
+    path: clean,
+    replacements: replaceAll ? count : 1,
+    bytes: Buffer.byteLength(next, 'utf8')
+  };
+}
+
+export function deleteNote(relPath) {
+  if (!relPath || isProtectedPath(relPath)) return null;
+  const full = resolveSafe(relPath);
+  if (!full || !fs.existsSync(full) || !fs.statSync(full).isFile()) return null;
+  fs.unlinkSync(full);
+  const clean = relPath.replace(/^\/+/, '');
+  removeVaultCacheFile(clean);
+  return { deleted: true, path: clean };
+}
+
+export function renameNote(oldPath, newPath) {
+  if (!oldPath || !newPath || isProtectedPath(oldPath) || isProtectedPath(newPath)) {
+    return { error: 'Invalid or protected path' };
+  }
+  const cleanOld = oldPath.replace(/^\/+/, '');
+  const cleanNew = newPath.replace(/^\/+/, '');
+  const srcFull = resolveSafe(cleanOld);
+  const dstFull = resolveSafe(cleanNew);
+  if (!srcFull || !dstFull || srcFull === VAULT_ROOT || dstFull === VAULT_ROOT) {
+    return { error: 'Invalid path' };
+  }
+  if (!fs.existsSync(srcFull) || !fs.statSync(srcFull).isFile()) {
+    return { error: 'Source file not found' };
+  }
+  if (fs.existsSync(dstFull)) {
+    return { error: 'Destination already exists' };
+  }
+  fs.mkdirSync(path.dirname(dstFull), { recursive: true });
+  fs.renameSync(srcFull, dstFull);
+  removeVaultCacheFile(cleanOld);
+  updateVaultCacheFile(cleanNew);
+  return { ok: true, oldPath: cleanOld, newPath: cleanNew };
+}
+
+export function renameDir(oldPath, newPath) {
+  if (!oldPath || !newPath || isProtectedPath(oldPath) || isProtectedPath(newPath)) {
+    return { error: 'Invalid or protected path' };
+  }
+  const cleanOld = oldPath.replace(/^\/+|\/+$/g, '');
+  const cleanNew = newPath.replace(/^\/+|\/+$/g, '');
+  if (!cleanOld || !cleanNew) {
+    return { error: 'Invalid path' };
+  }
+  const srcFull = resolveSafe(cleanOld);
+  const dstFull = resolveSafe(cleanNew);
+  if (!srcFull || !dstFull || srcFull === VAULT_ROOT || dstFull === VAULT_ROOT) {
+    return { error: 'Invalid path' };
+  }
+  if (!fs.existsSync(srcFull) || !fs.statSync(srcFull).isDirectory()) {
+    return { error: 'Source folder not found' };
+  }
+  if (dstFull === srcFull || dstFull.startsWith(srcFull + path.sep)) {
+    return { error: 'Cannot move a folder into itself' };
+  }
+  if (fs.existsSync(dstFull)) {
+    return { error: 'Destination already exists' };
+  }
+  fs.mkdirSync(path.dirname(dstFull), { recursive: true });
+  fs.renameSync(srcFull, dstFull);
+  invalidateVaultCache();
+  return { ok: true, oldPath: cleanOld, newPath: cleanNew };
+}
+
+export function writeBinaryFile(relPath, buffer) {
+  if (!relPath || isProtectedPath(relPath)) return null;
+  const clean = relPath.replace(/^\/+/, '');
+  const full = resolveSafe(clean);
+  if (!full || full === VAULT_ROOT) return null;
+  fs.mkdirSync(path.dirname(full), { recursive: true });
+  fs.writeFileSync(full, buffer);
+  updateVaultCacheFile(clean);
+  return { path: clean, bytes: buffer.length };
+}

package/src/server/git.js

@@ -0,0 +1,217 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { VAULT_ROOT, isImagePath, isProtectedPath, resolveSafe } from './paths.js';
+import { removeVaultCacheFile, updateVaultCacheFile } from './vault-cache.js';
+
+export function getGitChanges() {
+  try {
+    const out = execFileSync('git', ['status', '--porcelain', '-uall'], {
+      cwd: VAULT_ROOT,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore']
+    });
+    const changes = out
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => {
+        const rawCode = line.slice(0, 2).trim() || 'M';
+        let filePath = line.slice(3).trim();
+        if (filePath.includes(' -> ')) filePath = filePath.split(' -> ').pop();
+        if (filePath.startsWith('"') && filePath.endsWith('"')) {
+          filePath = filePath.slice(1, -1);
+        }
+        const status = rawCode === '??' ? 'U' : rawCode[0];
+        let mtimeMs = 0;
+        if (status !== 'D') {
+          try {
+            mtimeMs = fs.statSync(path.join(VAULT_ROOT, filePath)).mtimeMs;
+          } catch {
+            mtimeMs = 0;
+          }
+        }
+        return { status, path: filePath, mtimeMs };
+      })
+      .filter((c) => c.path && !isProtectedPath(c.path));
+    return { isGit: true, changes };
+  } catch {
+    return { isGit: false, changes: [] };
+  }
+}
+
+export function gitCommitAndPush({ message, files = [], push = false }) {
+  const msg = String(message || '').trim();
+  if (!msg) return { error: 'Commit message is required' };
+  try {
+    const safeFiles = Array.isArray(files)
+      ? files.filter((f) => typeof f === 'string' && f && !isProtectedPath(f) && resolveSafe(f))
+      : [];
+    if (safeFiles.length > 0) {
+      execFileSync('git', ['add', '--', ...safeFiles], { cwd: VAULT_ROOT, encoding: 'utf8' });
+    } else {
+      execFileSync('git', ['add', '-A'], { cwd: VAULT_ROOT, encoding: 'utf8' });
+    }
+    const commitOut = execFileSync('git', ['commit', '-m', msg], { cwd: VAULT_ROOT, encoding: 'utf8' });
+    let pushOut = '';
+    if (push) {
+      pushOut = execFileSync('git', ['push'], { cwd: VAULT_ROOT, encoding: 'utf8' });
+    }
+    return { ok: true, output: [commitOut, pushOut].filter(Boolean).join('\n').trim() };
+  } catch (err) {
+    const detail = err?.stderr?.toString?.() || err?.stdout?.toString?.() || err.message;
+    return { error: detail.trim() || 'Git command failed' };
+  }
+}
+
+function parseUnifiedDiff(raw) {
+  const lines = raw.split('\n');
+  const fileHeaders = [];
+  const hunks = [];
+  let current = null;
+  let oldLn = 0;
+  let newLn = 0;
+
+  for (const line of lines) {
+    if (line.startsWith('diff --git') || line.startsWith('index ') || line.startsWith('--- ') || line.startsWith('+++ ')) {
+      fileHeaders.push(line);
+      continue;
+    }
+    const hm = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/);
+    if (hm) {
+      oldLn = Number(hm[1]);
+      newLn = Number(hm[3]);
+      current = {
+        header: line,
+        oldStart: oldLn,
+        newStart: newLn,
+        lines: []
+      };
+      hunks.push(current);
+      continue;
+    }
+    if (!current) continue;
+    if (line.startsWith('+')) {
+      current.lines.push({ type: 'add', text: line.slice(1), oldLine: null, newLine: newLn++ });
+    } else if (line.startsWith('-')) {
+      current.lines.push({ type: 'del', text: line.slice(1), oldLine: oldLn++, newLine: null });
+    } else if (line.startsWith(' ')) {
+      current.lines.push({ type: 'context', text: line.slice(1), oldLine: oldLn++, newLine: newLn++ });
+    }
+  }
+  return { fileHeaders, hunks };
+}
+
+export function getGitDiff(relPath) {
+  if (!relPath || isProtectedPath(relPath) || !resolveSafe(relPath)) {
+    return { error: 'Invalid or protected path' };
+  }
+  const cleanPath = relPath.replace(/^\/+/, '');
+  try {
+    let raw = execFileSync('git', ['diff', '--no-color', '-U3', '--', cleanPath], {
+      cwd: VAULT_ROOT,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+    let untracked = false;
+    if (!raw.trim()) {
+      const st = execFileSync('git', ['status', '--porcelain', '--', cleanPath], {
+        cwd: VAULT_ROOT,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore']
+      });
+      if (st.startsWith('??')) {
+        untracked = true;
+        const full = resolveSafe(cleanPath);
+        if (full && fs.existsSync(full) && !isImagePath(cleanPath)) {
+          const textLines = fs.readFileSync(full, 'utf8').split('\n');
+          if (textLines.at(-1) === '') textLines.pop();
+          raw = [
+            `--- /dev/null`,
+            `+++ b/${cleanPath}`,
+            `@@ -0,0 +1,${textLines.length} @@`,
+            ...textLines.map((l) => `+${l}`)
+          ].join('\n');
+        }
+      }
+    }
+    const { fileHeaders, hunks } = parseUnifiedDiff(raw);
+    return { path: cleanPath, untracked, fileHeaders, hunks, raw };
+  } catch (err) {
+    return { error: err?.stderr?.toString?.() || err.message };
+  }
+}
+
+export function discardGitChange({ path: relPath, hunkIndex, lineIndex }) {
+  if (!relPath || isProtectedPath(relPath)) return { error: 'Invalid or protected path' };
+  const cleanPath = relPath.replace(/^\/+/, '');
+  const full = resolveSafe(cleanPath);
+  if (!full) return { error: 'Invalid path' };
+
+  try {
+    if (hunkIndex === undefined || hunkIndex === null) {
+      const st = execFileSync('git', ['status', '--porcelain', '--', cleanPath], {
+        cwd: VAULT_ROOT,
+        encoding: 'utf8'
+      });
+      if (st.startsWith('??')) {
+        if (fs.existsSync(full)) fs.unlinkSync(full);
+        removeVaultCacheFile(cleanPath);
+        return { ok: true, path: cleanPath, discarded: 'untracked' };
+      }
+      execFileSync('git', ['checkout', '--', cleanPath], { cwd: VAULT_ROOT, encoding: 'utf8' });
+      updateVaultCacheFile(cleanPath);
+      return { ok: true, path: cleanPath, discarded: 'file' };
+    }
+
+    const diff = getGitDiff(cleanPath);
+    if (diff.error) return diff;
+    if (diff.untracked) return { error: 'Cannot discard single lines on an untracked file; discard whole file instead' };
+
+    const hunk = diff.hunks[Number(hunkIndex)];
+    if (!hunk) return { error: 'Hunk not found' };
+
+    const rawText = fs.readFileSync(full, 'utf8');
+    const hadTrailingNewline = rawText.endsWith('\n');
+    const fileLines = rawText.split('\n');
+    if (hadTrailingNewline) fileLines.pop();
+
+    if (lineIndex === undefined || lineIndex === null) {
+      const startIdx = hunk.newStart === 0 ? 0 : hunk.newStart - 1;
+      const deleteCount = hunk.lines.filter((l) => l.type === 'context' || l.type === 'add').length;
+      const restoreLines = hunk.lines
+        .filter((l) => l.type === 'context' || l.type === 'del')
+        .map((l) => l.text);
+      fileLines.splice(startIdx, deleteCount, ...restoreLines);
+      const out = fileLines.join('\n') + (hadTrailingNewline ? '\n' : '');
+      fs.writeFileSync(full, out, 'utf8');
+      updateVaultCacheFile(cleanPath);
+      return { ok: true, path: cleanPath, discarded: 'hunk' };
+    }
+
+    const targetIdx = Number(lineIndex);
+    const targetLine = hunk.lines[targetIdx];
+    if (!targetLine || targetLine.type === 'context') {
+      return { error: 'Line is not a change' };
+    }
+
+    if (targetLine.type === 'add') {
+      fileLines.splice(targetLine.newLine - 1, 1);
+    } else {
+      let insertAt = hunk.newStart === 0 ? 0 : hunk.newStart - 1;
+      for (let i = targetIdx - 1; i >= 0; i--) {
+        if (hunk.lines[i].newLine !== null) {
+          insertAt = hunk.lines[i].newLine;
+          break;
+        }
+      }
+      fileLines.splice(insertAt, 0, targetLine.text);
+    }
+
+    const out = fileLines.join('\n') + (hadTrailingNewline ? '\n' : '');
+    fs.writeFileSync(full, out, 'utf8');
+    updateVaultCacheFile(cleanPath);
+    return { ok: true, path: cleanPath, discarded: 'line' };
+  } catch (err) {
+    return { error: err?.stderr?.toString?.() || err.message };
+  }
+}

package/src/server/index.js

@@ -0,0 +1,43 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { Hono } from 'hono';
+import { serve } from '@hono/node-server';
+import { serveStatic } from '@hono/node-server/serve-static';
+import { getCachedVault } from './vault.js';
+import { syncIndex } from './search-index.js';
+import { handleMcpRequest } from './mcp.js';
+import { registerFileRoutes } from './routes/files.js';
+import { registerGitRoutes } from './routes/git.js';
+import { registerEventRoutes, startVaultWatcher } from './routes/events.js';
+
+const HOST = process.env.HOST || '127.0.0.1';
+const PORT = Number(process.env.PORT || 4321);
+
+try {
+  syncIndex();
+  getCachedVault();
+} catch (err) {
+  console.warn('search index init warning:', err.message);
+}
+
+startVaultWatcher();
+
+const app = new Hono();
+
+registerFileRoutes(app);
+registerGitRoutes(app);
+registerEventRoutes(app);
+
+// MCP endpoint (Streamable HTTP)
+app.all('/mcp', (c) => handleMcpRequest(c.req.raw));
+
+// Serve built React app in production (dist/)
+const distDir = path.resolve(import.meta.dirname, '../../dist');
+if (fs.existsSync(distDir)) {
+  const relDist = path.relative(process.cwd(), distDir) || '.';
+  app.use('/*', serveStatic({ root: relDist }));
+}
+
+serve({ fetch: app.fetch, hostname: HOST, port: PORT }, () => {
+  console.log(`Pagedex listening on http://${HOST}:${PORT} (root: ${process.env.PAGEDEX_ROOT || process.env.VAULT_ROOT || process.cwd()})`);
+});