pathnote 0.1.0 → 0.2.1

package/README.md

@@ -1,8 +1,8 @@
 # Pathnote
 
-See which notes your AI searched, read and wrote, live on your note graph.
+See which files your AI searched, read and wrote, live on a map of your folders.
 
-Pathnote is an MCP server for a folder of markdown notes (an Obsidian vault works as is) plus a local viewer page. While Claude, Cursor or another MCP client works in your notes, the viewer draws the path: search hits, the notes it read in order, and the notes it wrote, linked to the notes they came from. Every note the AI creates or edits can be undone from the viewer.
+Pathnote is an MCP server for the folders you choose (notes, an Obsidian vault, project folders) plus a local viewer page. The viewer draws the folders as a tree, with `[[wikilinks]]` between markdown notes. While Claude, Cursor or another MCP client works, it draws the path on top: the files it searched, the folders and files it opened in order, and the files it wrote, linked to the files they came from. Every file the AI creates, edits or moves can be undone from the viewer.
 
 Free, MIT licensed. Runs entirely on your computer; nothing is sent anywhere by Pathnote.
 
@@ -18,59 +18,70 @@ npx -y pathnote --sample ~/pathnote-sample
 
 ### Claude Desktop
 
-Settings → Developer → Edit Config, and add Pathnote to `mcpServers`:
+Quit Claude Desktop first (⌘Q). It rewrites its config file while running, so edits made with it open can be lost. Then add Pathnote to `mcpServers` in `~/Library/Application Support/Claude/claude_desktop_config.json`. List as many folders as you like:
 
 ```json
 {
   "mcpServers": {
     "pathnote": {
       "command": "npx",
-      "args": ["-y", "pathnote", "/Users/you/pathnote-sample"]
+      "args": ["-y", "pathnote", "/Users/you/pathnote-sample", "/Users/you/Projects"]
     }
   }
 }
 ```
 
-Restart Claude Desktop, open http://127.0.0.1:4747 in your browser, and ask Claude something like:
+Open Claude Desktop again and ask Claude something like the line below. The map opens in your browser as soon as Claude starts looking (http://127.0.0.1:4747).
 
 > Go through the meeting notes and customer interviews and write next quarter's priorities as a new note.
 
 ### Claude Code
 
 ```bash
-claude mcp add pathnote -- npx -y pathnote ~/pathnote-sample
+claude mcp add pathnote -- npx -y pathnote ~/pathnote-sample ~/Projects
 ```
 
 ### Cursor and other MCP clients
 
-Use the same command: `npx -y pathnote <your notes folder>`.
+Use the same command: `npx -y pathnote <folder> [<folder> ...]`.
 
 ## The viewer
 
 - http://127.0.0.1:4747 (the next free port if 4747 is taken; the address is printed to the client's MCP log).
-- Several AI sessions on the same folder all report to one viewer.
-- To keep the viewer open while clients come and go: `npx pathnote <folder> --viewer`.
-- **Undo** puts a note back the way it was before the AI changed it. If you edited the note yourself afterwards, Pathnote leaves it alone and says so.
-- **Clear path** clears the drawing, not your notes.
+- It opens in your browser by itself the first time the AI uses Pathnote, unless a viewer page is already open. Add `--no-open` (or set `PATHNOTE_NO_OPEN=1`) to turn that off.
+- Drag to move, scroll to zoom. File names appear as you zoom in.
+- Several AI sessions on the same folders all report to one viewer.
+- To keep the viewer open while clients come and go: `npx pathnote <folders> --viewer`.
+- **Undo** puts a file back the way it was before the AI changed it. If you edited it yourself afterwards, Pathnote leaves it alone and says so.
+- **Clear path** clears the drawing, not your files.
 
 ## Tools the AI gets
 
 | Tool | What it does |
 |---|---|
-| `list_notes` | Every note path in the folder |
-| `search_vault` | Notes matching some words, with a snippet each |
-| `read_note` | Full text of one note |
-| `write_note` | Create a note or replace its text (undoable) |
-| `edit_note` | Replace one exact piece of text in a note (undoable) |
+| `list_files` | The connected folders, or what is inside one folder |
+| `search_files` | Text files and documents matching some words, with a snippet each |
+| `read_file` | A text file as is (up to 2 MB); PDF, Word, PowerPoint, Excel and Hangul (.hwpx) files as their text; pictures (PNG, JPEG, GIF, WebP, HEIC) as images the AI can see (up to 50 MB) |
+| `write_file` | Create a text file or replace its text (undoable). Documents and pictures are never written |
+| `edit_file` | Replace one exact piece of text in a file (undoable) |
+| `move_file` | Move or rename a file or folder of any type, creating missing folders; never overwrites (undoable) |
 
 Each tool takes an optional `reason`, a short sentence the viewer shows next to the step.
 
 ## What Pathnote touches
 
-- Only `.md` files inside the folder you give it. Paths outside it, and `.obsidian`, `.git` and `.trash`, are refused.
-- The text of each note before the AI changed it is kept in `~/.pathnote/` so it can be undone. Delete that folder to clear the history.
+- Only files inside the folders you list. Anything outside them is refused, including through symlinks.
+- Old Hangul `.hwp` files and other binary formats can't be read. Scanned PDFs without a text layer come back empty.
+- Skipped: hidden files and folders, `.git`, `node_modules`, build output, and files that usually hold secrets (`.env`, `*.pem`, `*.p8`, `*.key`, SSH keys, `credentials.json`, `token.json`, `client_secret*.json`, folders named `secrets`). The AI can't read or write them, and the viewer doesn't show them.
+- Whatever the AI reads, including document text and pictures, is sent to the AI service you use, like anything else you share with it.
+- The AI can create and change any other text file in those folders. Connect only folders you are comfortable letting it edit.
+- The text of each file before the AI changed it is kept in `~/.pathnote/` so it can be undone. Delete that folder to clear the history.
 - The viewer only listens on 127.0.0.1 and refuses requests from other websites.
 
+## macOS folder permissions
+
+Desktop, Documents, Downloads and iCloud Drive are protected by macOS. The first time Pathnote reads one, macOS asks whether the app that runs Pathnote (Claude, Terminal, ...) may access it. Until you allow it, the viewer shows that folder as empty and says so. You can change this later in System Settings → Privacy & Security → Files and Folders.
+
 ## Development
 
 ```bash

package/bin/pathnote.js

@@ -1,21 +1,23 @@
 #!/usr/bin/env node
-// pathnote <vault folder> [--port 4747] [--viewer]
+// pathnote <folder> [<folder> ...] [--port 4747] [--viewer] [--no-open]
 // pathnote --sample <new folder>   copies the sample notes there, to try Pathnote safely
 //   Started by an MCP client: MCP over stdin/stdout, plus the viewer at http://127.0.0.1:4747
 //   --viewer: only the viewer, for keeping it open while MCP clients come and go
+//   --no-open (or PATHNOTE_NO_OPEN=1): don't open the viewer in the browser when the AI starts working
 // stdout belongs to MCP, so every message for people goes to stderr.
 import fs from 'node:fs';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { Vault } from '../src/vault.js';
+import { Workspace } from '../src/workspace.js';
 import { History } from '../src/history.js';
-import { Hub } from '../src/hub.js';
+import { Hub, openBrowser } from '../src/hub.js';
 import { createServer } from '../src/mcp.js';
 
 const pkg = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url)));
 const args = process.argv.slice(2);
 const flag = name => args.includes(name);
 const opt = name => { const i = args.indexOf(name); return i >= 0 ? args[i + 1] : undefined; };
-const folder = args.find((a, i) => !a.startsWith('--') && args[i - 1] !== '--port');
+const folders = args.filter((a, i) => !a.startsWith('--') && args[i - 1] !== '--port');
+const folder = folders[0];
 
 if (flag('--sample')) {
   if (!folder) { console.error('Usage: pathnote --sample <new folder>'); process.exit(1); }
@@ -25,22 +27,26 @@ if (flag('--sample')) {
   process.exit(0);
 }
 if (!folder || flag('--help')) {
-  console.error(`Pathnote ${pkg.version}\n\nUsage: pathnote <vault folder> [--port 4747] [--viewer]\n       pathnote --sample <new folder>`);
+  console.error(`Pathnote ${pkg.version}\n\nUsage: pathnote <folder> [<folder> ...] [--port 4747] [--viewer] [--no-open]\n       pathnote --sample <new folder>`);
   process.exit(folder ? 0 : 1);
 }
-if (!fs.existsSync(folder) || !fs.statSync(folder).isDirectory()) {
-  console.error(`Pathnote: "${folder}" is not a folder.`);
-  process.exit(1);
+for (const f of folders) {
+  if (!fs.existsSync(f) || !fs.statSync(f).isDirectory()) {
+    console.error(`Pathnote: "${f}" is not a folder.`);
+    process.exit(1);
+  }
 }
 
-const vault = new Vault(folder);
-const history = new History(vault);
-const hub = new Hub(vault, history, Number(opt('--port')) || 4747);
+const ws = new Workspace(folders);
+const history = new History(ws);
+const noOpen = flag('--no-open') || process.env.PATHNOTE_NO_OPEN === '1';
+const hub = new Hub(ws, history, Number(opt('--port')) || 4747, { open: noOpen ? null : openBrowser });
 const url = await hub.start();
-console.error(`Pathnote ${pkg.version}: vault ${vault.root}\nViewer: ${url}`);
+console.error(`Pathnote ${pkg.version}: ${ws.roots.join(', ')}\nViewer: ${url}`);
+ws.warm().catch(() => {});
 
 if (!flag('--viewer')) {
-  await createServer({ vault, history, hub, version: pkg.version }).connect(new StdioServerTransport());
+  await createServer({ ws, history, hub, version: pkg.version }).connect(new StdioServerTransport());
   // The viewer server would keep the process alive after the MCP client quits
   process.stdin.on('close', () => process.exit(0));
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pathnote",
-  "version": "0.1.0",
-  "description": "See which notes your AI searched, read and wrote, live on your note graph. MCP server + local viewer for a markdown folder.",
+  "version": "0.2.1",
+  "description": "See which files your AI searched, read and wrote, live on a map of your folders. MCP server + local viewer.",
   "keywords": [
     "mcp",
     "model-context-protocol",
@@ -34,6 +34,8 @@
   "license": "MIT",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.32.2",
+    "fflate": "0.8.3",
+    "unpdf": "1.9.1",
     "zod": "^4.6.7"
   }
 }

package/src/documents.js

@@ -0,0 +1,98 @@
+// Reads files that aren't plain text: text out of PDF, Word, PowerPoint, Excel and Hangul (.hwpx)
+// files, and pictures as images the AI can look at. Read-only: Pathnote never writes these.
+import { execFile } from 'node:child_process';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { unzipSync, strFromU8 } from 'fflate';
+import { getDocumentProxy, extractText } from 'unpdf';
+
+const run = promisify(execFile);
+const DOCS = new Set(['.pdf', '.docx', '.pptx', '.xlsx', '.hwpx']);
+const IMAGES = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.webp': 'image/webp', '.heic': 'image/heic' };
+export const MAX_DOC = 50 * 1024 * 1024;
+const MAX_TEXT = 200_000;
+// Claude accepts images up to about 5 MB once base64-encoded
+const MAX_IMAGE = 3.5 * 1024 * 1024;
+
+export const isDocument = p => DOCS.has(path.extname(p).toLowerCase());
+export const isImage = p => path.extname(p).toLowerCase() in IMAGES;
+
+const decode = s => s
+  .replace(/&#x([0-9a-f]+);/gi, (_, h) => String.fromCodePoint(parseInt(h, 16)))
+  .replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(+d))
+  .replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, '&');
+
+// XML -> text, with a line break wherever the format ends a paragraph
+const xmlText = (xml, paragraph) => decode(xml
+  .replace(new RegExp(`</${paragraph}>`, 'g'), '\n')
+  .replace(/<(w:tab|a:tab|hp:tab)\b[^>]*\/>/g, '\t')
+  .replace(/<[^>]+>/g, ''))
+  .replace(/\n{3,}/g, '\n\n').trim();
+
+// "ppt/slides/slide10.xml" sorts after "slide9.xml"
+const byNumber = (a, b) => (+a.match(/(\d+)\.xml$/)?.[1] || 0) - (+b.match(/(\d+)\.xml$/)?.[1] || 0);
+
+function unzip(buf, keep) {
+  const files = unzipSync(new Uint8Array(buf), { filter: f => keep(f.name) });
+  return Object.fromEntries(Object.entries(files).map(([k, v]) => [k, strFromU8(v)]));
+}
+
+function xlsx(buf) {
+  const z = unzip(buf, n => n === 'xl/sharedStrings.xml' || n === 'xl/workbook.xml' || /^xl\/worksheets\/sheet\d+\.xml$/.test(n));
+  const shared = [...(z['xl/sharedStrings.xml'] || '').matchAll(/<si>([\s\S]*?)<\/si>/g)].map(m => decode(m[1].replace(/<[^>]+>/g, '')));
+  const names = [...(z['xl/workbook.xml'] || '').matchAll(/<sheet [^>]*name="([^"]*)"/g)].map(m => decode(m[1]));
+  return Object.keys(z).filter(k => k.startsWith('xl/worksheets/')).sort(byNumber).map((k, i) => {
+    const rows = [...z[k].matchAll(/<row\b[^>]*>([\s\S]*?)<\/row>/g)].map(r =>
+      [...r[1].matchAll(/<c\b([^>]*?)(?:\/>|>([\s\S]*?)<\/c>)/g)].map(([, attrs, body = '']) => {
+        const v = body.match(/<v>([\s\S]*?)<\/v>/)?.[1];
+        if (/t="s"/.test(attrs)) return shared[+v] ?? '';
+        if (/t="inlineStr"/.test(attrs)) return decode(body.replace(/<[^>]+>/g, ''));
+        return v === undefined ? '' : decode(v);
+      }).join('\t'));
+    return `--- sheet: ${names[i] ?? i + 1} ---\n${rows.join('\n')}`;
+  }).join('\n\n');
+}
+
+// Text of a document. `buf` is the file's bytes.
+export async function documentText(file, buf) {
+  const ext = path.extname(file).toLowerCase();
+  let text;
+  if (ext === '.pdf') {
+    const pdf = await getDocumentProxy(new Uint8Array(buf));
+    const { text: pages } = await extractText(pdf, { mergePages: false });
+    text = pages.map((t, i) => `--- page ${i + 1} ---\n${t.trim()}`).join('\n\n');
+  } else if (ext === '.docx') {
+    text = xmlText(unzip(buf, n => n === 'word/document.xml')['word/document.xml'] || '', 'w:p');
+  } else if (ext === '.pptx') {
+    const z = unzip(buf, n => /^ppt\/slides\/slide\d+\.xml$/.test(n));
+    text = Object.keys(z).sort(byNumber).map((k, i) => `--- slide ${i + 1} ---\n${xmlText(z[k], 'a:p')}`).join('\n\n');
+  } else if (ext === '.xlsx') {
+    text = xlsx(buf);
+  } else if (ext === '.hwpx') {
+    const z = unzip(buf, n => /^Contents\/section\d+\.xml$/.test(n));
+    text = Object.keys(z).sort(byNumber).map(k => xmlText(z[k], 'hp:p')).join('\n\n');
+  } else {
+    throw new Error(`Pathnote can't read ${ext} files.`);
+  }
+  if (!text.trim()) return '(No text found. It may be a scanned document made of images.)';
+  return text.length > MAX_TEXT ? text.slice(0, MAX_TEXT) + `\n\n(cut off at ${MAX_TEXT} characters)` : text;
+}
+
+// An image the AI can look at. HEIC (iPhone photos) and large pictures go through macOS `sips`
+// to become a JPEG small enough to send.
+export async function imageContent(file, buf) {
+  const ext = path.extname(file).toLowerCase();
+  if (ext !== '.heic' && buf.length <= MAX_IMAGE) return { data: buf.toString('base64'), mimeType: IMAGES[ext] };
+  if (process.platform !== 'darwin') throw new Error(`"${file}" is too large to send as an image (over 3.5 MB).`);
+  const out = path.join(await fs.mkdtemp(path.join(os.tmpdir(), 'pathnote-')), 'image.jpg');
+  try {
+    await run('sips', ['-s', 'format', 'jpeg', '-s', 'formatOptions', '80', '-Z', '1600', file, '--out', out]);
+    const small = await fs.readFile(out);
+    if (small.length > MAX_IMAGE) throw new Error(`"${file}" is still too large after shrinking.`);
+    return { data: small.toString('base64'), mimeType: 'image/jpeg' };
+  } finally {
+    await fs.rm(path.dirname(out), { recursive: true, force: true });
+  }
+}

package/src/history.js

@@ -1,14 +1,14 @@
 // Keeps the text a note had before the AI changed it, so each change can be undone.
-// Stored outside the vault (~/.pathnote/<vault id>/history.jsonl) to keep the vault clean.
+// Stored outside the connected folders (~/.pathnote/<id>/history.jsonl) to keep them clean.
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
 import crypto from 'node:crypto';
 
 export class History {
-  constructor(vault) {
-    this.vault = vault;
-    const id = crypto.createHash('sha1').update(vault.root).digest('hex').slice(0, 12);
+  constructor(ws) {
+    this.ws = ws;
+    const id = crypto.createHash('sha1').update(ws.id).digest('hex').slice(0, 12);
     this.file = path.join(os.homedir(), '.pathnote', id, 'history.jsonl');
   }
 
@@ -26,13 +26,19 @@ export class History {
     await fs.appendFile(this.file, JSON.stringify(entry) + '\n');
   }
 
-  // Call before changing a note. `before` is null for a note that didn't exist.
+  // Call before changing a file. `before` is null for a file that didn't exist.
   async record(rel, before, after, kind) {
     const entry = { id: crypto.randomUUID(), t: Date.now(), path: rel, kind, before, after };
     await this.append(entry);
     return entry;
   }
 
+  async recordMove(from, to) {
+    const entry = { id: crypto.randomUUID(), t: Date.now(), path: to, kind: 'move', from, to };
+    await this.append(entry);
+    return entry;
+  }
+
   // Put the note back the way it was before change `id`. Refuses if someone edited it since,
   // so a user's own later edits are never thrown away.
   async undo(id) {
@@ -40,10 +46,16 @@ export class History {
     const entry = all.find(e => e.id === id);
     if (!entry) throw new Error('No such change.');
     if (all.some(e => e.undoes === id)) throw new Error('Already undone.');
-    const now = await this.vault.readOrNull(entry.path);
+    if (entry.kind === 'move') {
+      // put it back where it was, as long as nothing has taken either place since
+      await this.ws.move(entry.to, entry.from);
+      await this.append({ id: crypto.randomUUID(), t: Date.now(), path: entry.from, kind: 'undo', undoes: id });
+      return entry;
+    }
+    const now = await this.ws.readOrNull(entry.path);
     if (now !== entry.after) throw new Error(`"${entry.path}" changed after the AI wrote it, so it was left as is.`);
-    if (entry.before === null) await this.vault.remove(entry.path);
-    else await this.vault.write(entry.path, entry.before);
+    if (entry.before === null) await this.ws.remove(entry.path);
+    else await this.ws.write(entry.path, entry.before);
     await this.append({ id: crypto.randomUUID(), t: Date.now(), path: entry.path, kind: 'undo', undoes: id });
     return entry;
   }

package/src/hub.js

@@ -1,7 +1,8 @@
 // Local viewer server: serves the graph page and streams what the AI does to it.
-// Claude Desktop may start several Pathnote processes; the first one for a vault owns the
+// Claude Desktop may start several Pathnote processes; the first one for a set of folders owns the
 // viewer port and the others forward their events to it.
 import http from 'node:http';
+import { spawn } from 'node:child_process';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -10,8 +11,11 @@ const PAGE = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'view
 const KEEP = 500;
 
 export class Hub {
-  constructor(vault, history, port) {
-    this.vault = vault;
+  // open: called with the viewer URL the first time the AI does something while no viewer page is
+  // connected, so the map shows up without the user looking for it. null turns this off.
+  constructor(ws, history, port, { open = null } = {}) {
+    this.ws = ws;
+    this.open = open;
     this.history = history;
     this.port = port;
     this.events = [];
@@ -21,11 +25,11 @@ export class Hub {
     this.seq = 0;
   }
 
-  // Own a port for this vault, or find the process that already does. Returns the viewer URL.
+  // Own a port for these folders, or find the process that already does. Returns the viewer URL.
   async start() {
     for (let port = this.port; port < this.port + 10; port++) {
       const other = await this.info(port);
-      if (other?.vault === this.vault.root) { this.forwardTo = port; return `http://127.0.0.1:${port}`; }
+      if (other?.id === this.ws.id) { this.forwardTo = port; return `http://127.0.0.1:${port}`; }
       if (other) continue;
       try {
         await this.listen(port);
@@ -81,6 +85,12 @@ export class Hub {
     this.events.push(e);
     if (this.events.length > KEEP) this.events.shift();
     for (const res of this.clients) res.write(`data: ${JSON.stringify(e)}\n\n`);
+    // Once per process: a page left open from an earlier run reconnects by itself, so it counts
+    if (this.open && this.clients.size === 0) {
+      const open = this.open;
+      this.open = null;
+      open(`http://127.0.0.1:${this.port}`);
+    }
   }
 
   // Only pages served from this port may call the API, so other websites can't trigger undo.
@@ -98,10 +108,11 @@ export class Hub {
       res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-store' });
       return res.end(await fs.readFile(PAGE));
     }
-    if (req.method === 'GET' && url.pathname === '/api/info') return send(res, 200, { app: 'pathnote', vault: this.vault.root });
-    if (req.method === 'GET' && url.pathname === '/api/graph') return send(res, 200, await this.vault.graph());
+    if (req.method === 'GET' && url.pathname === '/api/info') return send(res, 200, { app: 'pathnote', id: this.ws.id, roots: this.ws.roots });
+    if (req.method === 'GET' && url.pathname === '/api/graph') return send(res, 200, await this.ws.graph());
     if (req.method === 'GET' && url.pathname === '/api/events') {
       res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-store', Connection: 'keep-alive' });
+      res.flushHeaders(); // the page counts as connected before the first event
       for (const e of this.events) res.write(`data: ${JSON.stringify(e)}\n\n`);
       this.clients.add(res);
       req.on('close', () => this.clients.delete(res));
@@ -115,7 +126,7 @@ export class Hub {
       const { id } = await body(req);
       try {
         const entry = await this.history.undo(id);
-        this.broadcast({ t: Date.now(), type: 'undo', path: entry.path, changeId: id, created: entry.before === null });
+        this.broadcast({ t: Date.now(), type: 'undo', path: entry.kind === 'move' ? entry.to : entry.path, changeId: id, created: entry.before === null || entry.kind === 'move', back: entry.kind === 'move' ? entry.from : undefined });
         return send(res, 200, { ok: true });
       } catch (e) {
         return send(res, 409, { error: e.message });
@@ -125,6 +136,18 @@ export class Hub {
   }
 }
 
+// Opens a URL in the default browser. Errors are ignored: the URL is also in the client's MCP log.
+export function openBrowser(url) {
+  const [cmd, args] = process.platform === 'darwin' ? ['open', [url]]
+    : process.platform === 'win32' ? ['cmd', ['/c', 'start', '', url]]
+    : ['xdg-open', [url]];
+  try {
+    const child = spawn(cmd, args, { stdio: 'ignore', detached: true });
+    child.on('error', () => {});
+    child.unref();
+  } catch {}
+}
+
 function send(res, status, data) {
   res.writeHead(status, { 'Content-Type': 'application/json' });
   res.end(JSON.stringify(data));

package/src/mcp.js

@@ -6,71 +6,93 @@ const reason = z.string().optional().describe('One short sentence on why you are
 const text = s => ({ content: [{ type: 'text', text: s }] });
 const fail = e => ({ content: [{ type: 'text', text: `Error: ${e.message}` }], isError: true });
 
-export function createServer({ vault, history, hub, version }) {
+export function createServer({ ws, history, hub, version }) {
   const server = new McpServer({ name: 'pathnote', version });
+  const where = `Connected folders: ${ws.roots.join(', ')}. Use full paths.`;
 
-  server.registerTool('list_notes', {
-    title: 'List notes',
-    description: 'List every markdown note in the vault, as paths relative to the vault root.',
-    inputSchema: {}
-  }, async () => {
-    try { return text((await vault.list()).join('\n') || '(no notes)'); } catch (e) { return fail(e); }
+  server.registerTool('list_files', {
+    title: 'List a folder',
+    description: `List what is inside a folder (folders end with "/"). Without a folder, lists the connected folders. ${where}`,
+    inputSchema: { folder: z.string().optional(), reason }
+  }, async ({ folder, reason }) => {
+    try {
+      if (!folder) return text(ws.roots.join('\n'));
+      const abs = ws.resolve(folder);
+      const items = await ws.list(abs);
+      await hub.emit({ type: 'list', path: abs, reason });
+      return text(items.join('\n') || '(empty folder)');
+    } catch (e) { return fail(e); }
   });
 
-  server.registerTool('search_vault', {
-    title: 'Search notes',
-    description: 'Search the notes for words. Returns the best matching note paths with a snippet each.',
+  server.registerTool('search_files', {
+    title: 'Search files',
+    description: `Search text files and documents (PDF, Word, PowerPoint, Excel, Hangul) in the connected folders for words. Returns the best matching paths with a snippet each. ${where}`,
     inputSchema: { query: z.string().describe('Words to look for'), reason }
   }, async ({ query, reason }) => {
     try {
-      const hits = await vault.search(query);
+      const hits = await ws.search(query);
       await hub.emit({ type: 'search', query, hits: hits.map(h => h.path), reason });
       return text(hits.length ? hits.map(h => `${h.path}\n  ${h.snippet}`).join('\n') : 'No matches.');
     } catch (e) { return fail(e); }
   });
 
-  server.registerTool('read_note', {
-    title: 'Read a note',
-    description: 'Read the full text of a note. Path is relative to the vault root; ".md" is optional.',
+  server.registerTool('read_file', {
+    title: 'Read a file',
+    description: `Read a file: text files (up to 2 MB) as they are, PDF, Word (.docx), PowerPoint (.pptx), Excel (.xlsx) and Hangul (.hwpx) as their text, and pictures (.png, .jpg, .gif, .webp, .heic) as images you can see. ${where}`,
     inputSchema: { path: z.string(), reason }
   }, async ({ path, reason }) => {
     try {
-      const body = await vault.read(path);
-      await hub.emit({ type: 'read', path: vault.rel(vault.resolve(path)), reason });
-      return text(body);
+      const abs = ws.resolve(path);
+      const file = await ws.open(abs);
+      await hub.emit({ type: 'read', path: abs, reason });
+      if (file.kind === 'image') return { content: [{ type: 'image', data: file.data, mimeType: file.mimeType }] };
+      return text(file.text);
     } catch (e) { return fail(e); }
   });
 
-  server.registerTool('write_note', {
-    title: 'Write a note',
-    description: 'Create a note, or replace a note\'s whole text. The user can undo this from the Pathnote viewer. Link the notes you used with [[Note name]].',
+  server.registerTool('write_file', {
+    title: 'Write a file',
+    description: `Create a text file, or replace a text file's whole text (not documents or pictures). The user can undo this from the Pathnote viewer. In markdown notes, link the notes you used with [[Note name]]. ${where}`,
     inputSchema: { path: z.string(), content: z.string(), reason }
   }, async ({ path, content, reason }) => {
     try {
-      const rel = vault.rel(vault.resolve(path));
-      const before = await vault.readOrNull(rel);
-      const change = await history.record(rel, before, content, before === null ? 'create' : 'write');
-      await vault.write(rel, content);
-      await hub.emit({ type: 'write', path: rel, created: before === null, changeId: change.id, reason });
-      return text(`${before === null ? 'Created' : 'Replaced'} ${rel}.`);
+      const abs = ws.resolve(path);
+      const before = await ws.readOrNull(abs);
+      const change = await history.record(abs, before, content, before === null ? 'create' : 'write');
+      await ws.write(abs, content);
+      await hub.emit({ type: 'write', path: abs, created: before === null, changeId: change.id, reason });
+      return text(`${before === null ? 'Created' : 'Replaced'} ${abs}.`);
     } catch (e) { return fail(e); }
   });
 
-  server.registerTool('edit_note', {
-    title: 'Edit a note',
-    description: 'Replace one exact piece of text in a note. `find` must appear exactly once. The user can undo this from the Pathnote viewer.',
+  server.registerTool('edit_file', {
+    title: 'Edit a file',
+    description: `Replace one exact piece of text in a file. \`find\` must appear exactly once. The user can undo this from the Pathnote viewer. ${where}`,
     inputSchema: { path: z.string(), find: z.string().min(1), replace: z.string(), reason }
   }, async ({ path, find, replace, reason }) => {
     try {
-      const rel = vault.rel(vault.resolve(path));
-      const before = await vault.read(rel);
+      const abs = ws.resolve(path);
+      const before = await ws.read(abs);
       const count = before.split(find).length - 1;
       if (count !== 1) throw new Error(count ? `The text appears ${count} times; include more of it so it is unique.` : 'The text was not found.');
       const after = before.replace(find, () => replace);
-      const change = await history.record(rel, before, after, 'edit');
-      await vault.write(rel, after);
-      await hub.emit({ type: 'edit', path: rel, changeId: change.id, reason });
-      return text(`Edited ${rel}.`);
+      const change = await history.record(abs, before, after, 'edit');
+      await ws.write(abs, after);
+      await hub.emit({ type: 'edit', path: abs, changeId: change.id, reason });
+      return text(`Edited ${abs}.`);
+    } catch (e) { return fail(e); }
+  });
+
+  server.registerTool('move_file', {
+    title: 'Move a file or folder',
+    description: `Move or rename a file or folder (any type, including pictures and videos) to a new full path. Missing parent folders are created. Never overwrites an existing path. The user can undo this from the Pathnote viewer. ${where}`,
+    inputSchema: { from: z.string(), to: z.string(), reason }
+  }, async ({ from, to, reason }) => {
+    try {
+      const moved = await ws.move(from, to);
+      const change = await history.recordMove(moved.from, moved.to);
+      await hub.emit({ type: 'move', path: moved.to, from: moved.from, dir: moved.dir, changeId: change.id, reason });
+      return text(`Moved ${moved.from} to ${moved.to}.`);
     } catch (e) { return fail(e); }
   });