pathnote 0.1.0 → 0.2.0

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,69 @@ 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, open http://127.0.0.1:4747 in your browser, and ask Claude something like:
 
 > 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.
+- 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,12 +1,12 @@
 #!/usr/bin/env node
-// pathnote <vault folder> [--port 4747] [--viewer]
+// pathnote <folder> [<folder> ...] [--port 4747] [--viewer]
 // 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
 // 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 { createServer } from '../src/mcp.js';
@@ -15,7 +15,8 @@ const pkg = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.ur
 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 +26,25 @@ 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]\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 hub = new Hub(ws, history, Number(opt('--port')) || 4747);
 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.0",
+  "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,5 +1,5 @@
 // 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 fs from 'node:fs/promises';
@@ -10,8 +10,8 @@ const PAGE = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'view
 const KEEP = 500;
 
 export class Hub {
-  constructor(vault, history, port) {
-    this.vault = vault;
+  constructor(ws, history, port) {
+    this.ws = ws;
     this.history = history;
     this.port = port;
     this.events = [];
@@ -21,11 +21,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);
@@ -98,8 +98,8 @@ 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' });
       for (const e of this.events) res.write(`data: ${JSON.stringify(e)}\n\n`);
@@ -115,7 +115,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 });

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

package/src/workspace.js

@@ -0,0 +1,244 @@
+// The folders Pathnote may touch. Every path from the AI is checked against them: it must be
+// inside one of the folders (after following symlinks), not in a skipped folder, and not a
+// file that usually holds secrets.
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { isDocument, isImage, documentText, imageContent, MAX_DOC } from './documents.js';
+
+const SKIP = new Set(['.git', '.obsidian', '.trash', '.Trash', 'node_modules', '.build', 'build', 'DerivedData', 'dist', '.wrangler', '.venv', '__pycache__']);
+// Word and LibreOffice leave these lock files next to open documents
+const LOCK = /^(~\$|\.~lock\.)/;
+const SECRET_DIRS = new Set(['secrets', '.ssh', '.gnupg', '.aws']);
+const SECRET_FILE = /^(\.env(\..*)?|.*\.(pem|p8|p12|key|keystore|jks)|id_(rsa|ed25519|ecdsa)(\.pub)?|credentials\.json|token\.json|client_secret.*\.json|\.npmrc|\.netrc)$/i;
+const TEXT = /\.(md|mdx|txt|markdown|csv|tsv|json|jsonc|ya?ml|toml|ini|cfg|conf|xml|html?|css|scss|js|mjs|cjs|jsx|ts|tsx|py|rb|go|rs|java|kt|swift|m|h|c|cc|cpp|hpp|cs|php|sh|zsh|bash|sql|r|lua|tex|bib|srt|vtt|log)$/i;
+const LINK = /\[\[([^\]|#]+)(?:#[^\]|]*)?(?:\|[^\]]*)?\]\]/g;
+const MAX_READ = 2 * 1024 * 1024;
+const MAX_SEARCH = 512 * 1024;
+export const MAX_NODES = 6000;
+
+const BLOCKED = 'macOS is blocking access to this folder. Allow it in System Settings → Privacy & Security → Files and Folders (for the app that runs Pathnote), then try again.';
+
+// macOS holds file calls on protected folders (Desktop, Downloads, iCloud Drive) until the user
+// answers a permission prompt, possibly forever. Give up after `ms` instead of hanging.
+const timeout = (promise, ms) => Promise.race([promise, new Promise((_, no) => setTimeout(() => no(Object.assign(new Error(BLOCKED), { code: 'EBLOCKED' })), ms))]);
+
+const exists = p => fs.access(p).then(() => true, () => false);
+
+// First file under `dir` that looks like it holds secrets, or null
+async function findSecret(dir) {
+  for (const e of await fs.readdir(dir, { withFileTypes: true })) {
+    const abs = path.join(dir, e.name);
+    if (SECRET_FILE.test(e.name) || (e.isDirectory() && SECRET_DIRS.has(e.name))) return abs;
+    if (e.isDirectory()) { const found = await findSecret(abs); if (found) return found; }
+  }
+  return null;
+}
+
+const expand = p => String(p || '').trim().replace(/^~(?=$|\/)/, os.homedir());
+
+export class Workspace {
+  constructor(folders) {
+    this.roots = [...new Set(folders.map(f => path.resolve(expand(f))))];
+    this.id = this.roots.join('\n');
+  }
+
+  // Full path for something the AI named. Relative paths are allowed when there is one folder.
+  resolve(p) {
+    let s = expand(p);
+    if (!s) throw new Error('Path is empty.');
+    if (!path.isAbsolute(s)) {
+      if (this.roots.length > 1) throw new Error(`Use a full path, e.g. ${path.join(this.roots[0], s)}`);
+      s = path.join(this.roots[0], s);
+    }
+    const abs = path.resolve(s);
+    const root = this.rootOf(abs);
+    if (!root) throw new Error(`"${p}" is outside the connected folders: ${this.roots.join(', ')}`);
+    const parts = path.relative(root, abs).split(path.sep);
+    if (parts.some(x => SKIP.has(x))) throw new Error(`"${p}" is in a folder Pathnote skips.`);
+    if (parts.some(x => SECRET_DIRS.has(x)) || SECRET_FILE.test(path.basename(abs))) throw new Error(`"${p}" looks like it holds secrets, so Pathnote won't open it.`);
+    return abs;
+  }
+
+  rootOf(abs) {
+    return this.roots.find(r => abs === r || abs.startsWith(r + path.sep));
+  }
+
+  // resolve(), then the same check after following symlinks
+  async real(p) {
+    const abs = this.resolve(p);
+    let at = abs;
+    for (;;) {
+      try { at = await timeout(fs.realpath(at), 5000); break; } catch (e) { if (e.code !== 'ENOENT') throw e; at = path.dirname(at); }
+    }
+    const roots = await Promise.all(this.roots.map(r => fs.realpath(r).catch(() => r)));
+    if (!roots.some(r => at === r || at.startsWith(r + path.sep))) throw new Error(`"${p}" leads outside the connected folders.`);
+    return abs;
+  }
+
+  // Immediate contents of a folder; folders end with "/"
+  async list(dir) {
+    const abs = await this.real(dir);
+    const out = [];
+    for (const e of await timeout(fs.readdir(abs, { withFileTypes: true }), 5000)) {
+      if (e.name.startsWith('.') || LOCK.test(e.name) || SKIP.has(e.name) || SECRET_DIRS.has(e.name) || SECRET_FILE.test(e.name)) continue;
+      out.push(e.isDirectory() ? e.name + '/' : e.name);
+    }
+    return out.sort();
+  }
+
+  async read(p) {
+    const abs = await this.real(p);
+    const st = await timeout(fs.stat(abs), 5000);
+    if (st.isDirectory()) throw new Error(`"${p}" is a folder. Use list_files.`);
+    if (st.size > MAX_READ) throw new Error(`"${p}" is ${(st.size / 1048576).toFixed(1)} MB; Pathnote reads files up to 2 MB.`);
+    const buf = await timeout(fs.readFile(abs), 10000);
+    if (buf.subarray(0, 8000).includes(0)) throw new Error(`"${p}" is not a text file.`);
+    return buf.toString('utf8');
+  }
+
+  // Anything the AI can take in: text as is, documents as their text, pictures as images
+  async open(p) {
+    const abs = await this.real(p);
+    if (!isDocument(abs) && !isImage(abs)) return { kind: 'text', text: await this.read(abs) };
+    const st = await timeout(fs.stat(abs), 5000);
+    if (st.size > MAX_DOC) throw new Error(`"${p}" is ${(st.size / 1048576).toFixed(1)} MB; Pathnote opens documents and images up to 50 MB.`);
+    const buf = await timeout(fs.readFile(abs), 15000);
+    if (isImage(abs)) return { kind: 'image', ...(await timeout(imageContent(abs, buf), 20000)) };
+    return { kind: 'document', text: await timeout(documentText(abs, buf), 30000) };
+  }
+
+  // Document text for search, kept until the file changes
+  async docText(abs) {
+    const st = await fs.stat(abs);
+    if (st.size > MAX_DOC) return null;
+    const hit = this.docs?.get(abs);
+    if (hit?.mtime === st.mtimeMs) return hit.text;
+    const text = await timeout(documentText(abs, await fs.readFile(abs)), 15000);
+    (this.docs ??= new Map()).set(abs, { mtime: st.mtimeMs, text });
+    return text;
+  }
+
+  // Read every document's text once in the background, so the first search doesn't wait for it
+  async warm() {
+    for (const it of await this.walk()) {
+      if (it.kind === 'file' && isDocument(it.id)) await this.docText(it.id).catch(() => {});
+    }
+  }
+
+  async readOrNull(p) {
+    try { return await this.read(p); } catch (e) { if (e.code === 'ENOENT') return null; throw e; }
+  }
+
+  async write(p, text) {
+    const abs = await this.real(p);
+    if (isDocument(abs) || isImage(abs)) throw new Error(`Pathnote can read ${path.extname(abs)} files but not write them.`);
+    await timeout(fs.mkdir(path.dirname(abs), { recursive: true }), 5000);
+    await timeout(fs.writeFile(abs, text, 'utf8'), 10000);
+  }
+
+  // Move a file or folder (any type) to a new path in the connected folders. Never overwrites,
+  // and refuses folders that hold secret files, since those would leave the protected place.
+  async move(from, to) {
+    const src = await this.real(from), dst = await this.real(to);
+    if (this.roots.includes(src)) throw new Error(`"${from}" is a connected folder itself; move what is inside it instead.`);
+    const st = await timeout(fs.stat(src), 5000);
+    if (await exists(dst)) throw new Error(`"${to}" already exists; Pathnote never overwrites.`);
+    if (dst.startsWith(src + path.sep)) throw new Error(`Can't move "${from}" into itself.`);
+    if (st.isDirectory()) {
+      const secret = await findSecret(src);
+      if (secret) throw new Error(`"${from}" holds a file that looks like a secret (${path.relative(src, secret)}), so Pathnote won't move it.`);
+    }
+    await timeout(fs.mkdir(path.dirname(dst), { recursive: true }), 5000);
+    try {
+      await fs.rename(src, dst);
+    } catch (e) {
+      if (e.code !== 'EXDEV') throw e;
+      // different disk (e.g. iCloud Drive): copy, then remove the original
+      await fs.cp(src, dst, { recursive: true, errorOnExist: true, force: false, preserveTimestamps: true });
+      await fs.rm(src, { recursive: true });
+    }
+    return { from: src, to: dst, dir: st.isDirectory() };
+  }
+
+  async remove(p) {
+    await fs.rm(await this.real(p), { force: true });
+  }
+
+  // Every folder and file under the roots, minus skipped, hidden and secret ones. Stops at MAX_NODES.
+  async walk() {
+    // All folders at once, so several blocked ones cost one timeout, not one each
+    const per = await Promise.all(this.roots.map(async r => {
+      const mine = [{ id: r, kind: 'root', parent: null }];
+      try {
+        await timeout(this.visit(r, mine, MAX_NODES), 4000);
+        return { items: mine };
+      } catch (e) {
+        if (e.code !== 'EBLOCKED') throw e;
+        return { items: mine.slice(0, 1), blocked: r };
+      }
+    }));
+    this.blocked = per.filter(x => x.blocked).map(x => x.blocked);
+    return per.flatMap(x => x.items).slice(0, MAX_NODES);
+  }
+
+  async visit(root, items, max) {
+    const visit = async (dir, depth) => {
+      let entries;
+      try { entries = await fs.readdir(dir, { withFileTypes: true }); } catch { return; }
+      entries.sort((a, b) => a.name.localeCompare(b.name));
+      for (const e of entries) {
+        if (items.length >= max) return;
+        if (e.name.startsWith('.') || LOCK.test(e.name) || SKIP.has(e.name) || SECRET_DIRS.has(e.name) || SECRET_FILE.test(e.name)) continue;
+        const abs = path.join(dir, e.name);
+        if (e.isDirectory()) { items.push({ id: abs, kind: 'dir', parent: dir }); await visit(abs, depth + 1); }
+        else if (e.isFile()) items.push({ id: abs, kind: 'file', parent: dir });
+      }
+    };
+    await visit(root, 1);
+  }
+
+  // Text files and documents ranked by how often the query's words appear, file-name matches counted extra
+  async search(query, limit = 10) {
+    const words = String(query).toLowerCase().split(/\s+/).filter(Boolean);
+    if (!words.length) return [];
+    const hits = [];
+    for (const it of await this.walk()) {
+      if (it.kind !== 'file' || !(TEXT.test(it.id) || isDocument(it.id))) continue;
+      let text;
+      try {
+        if (isDocument(it.id)) text = await this.docText(it.id);
+        else {
+          const st = await fs.stat(it.id);
+          if (st.size > MAX_SEARCH) continue;
+          text = await timeout(fs.readFile(it.id, 'utf8'), 3000);
+        }
+      } catch { continue; }
+      if (!text) continue;
+      const lower = text.toLowerCase(), name = path.basename(it.id).toLowerCase();
+      let score = 0;
+      for (const w of words) { score += lower.split(w).length - 1; if (name.includes(w)) score += 5; }
+      if (!score) continue;
+      const at = Math.max(0, lower.indexOf(words.find(w => lower.includes(w)) ?? words[0]));
+      hits.push({ path: it.id, score, snippet: text.slice(Math.max(0, at - 60), at + 140).replace(/\s+/g, ' ').trim() });
+    }
+    return hits.sort((a, b) => b.score - a.score).slice(0, limit);
+  }
+
+  // Folder tree for the viewer, plus [[wikilinks]] between markdown notes (resolved by name, like Obsidian)
+  async graph() {
+    const items = await this.walk();
+    const notes = items.filter(i => i.kind === 'file' && /\.md$/i.test(i.id));
+    const byName = new Map(notes.map(n => [path.basename(n.id, path.extname(n.id)).toLowerCase(), n.id]));
+    const links = [];
+    for (const n of notes) {
+      let text;
+      try { text = await fs.readFile(n.id, 'utf8'); } catch { continue; }
+      for (const m of text.matchAll(LINK)) {
+        const target = byName.get(path.basename(m[1].trim()).toLowerCase());
+        if (target && target !== n.id) links.push([n.id, target]);
+      }
+    }
+    return { roots: this.roots, items, links, blocked: this.blocked, capped: items.length >= MAX_NODES };
+  }
+}

package/viewer/index.html

@@ -31,6 +31,8 @@ body { background: var(--bg); color: var(--ink); font: 400 14px/1.43 var(--font)
 .graph { position: relative; min-width: 0; min-height: 0; border-right: 1px solid var(--line); }
 svg { display: block; width: 100%; height: 100%; cursor: grab; touch-action: none; }
 svg.drag { cursor: grabbing; }
+.note { position: absolute; left: 12px; right: 12px; bottom: 12px; padding: 10px 14px; border-radius: 11px; background: var(--surface); color: var(--muted); font-size: 12px; }
+.note b { color: var(--ink); font-weight: 600; }
 .empty { position: absolute; inset: 0; display: grid; place-items: center; color: var(--muted); padding: 24px; text-align: center; pointer-events: none; }
 .log { display: flex; flex-direction: column; min-height: 0; }
 .log h2 { font-size: 14px; font-weight: 600; margin: 0; padding: 10px 16px; border-bottom: 1px solid var(--line); display: flex; justify-content: space-between; align-items: center; }
@@ -50,12 +52,21 @@ li .btn { grid-column: 1 / -1; justify-self: start; margin-top: 4px; }
 .btn:disabled { opacity: .4; cursor: default; }
 .hint { padding: 16px; color: var(--muted); }
 
-.link { stroke: var(--line); stroke-width: 1; }
+/* --k = user units per screen pixel, so dots, labels and lines keep their on-screen size while zooming */
+svg { --k: 1; }
+line { vector-effect: non-scaling-stroke; }
+.tree { stroke: var(--line); stroke-width: 1; }
+.link { stroke: var(--accent); stroke-width: 1; stroke-dasharray: 3 4; opacity: .35; }
 .trail { stroke: var(--accent); stroke-width: 2.5; stroke-linecap: round; transition: stroke-dashoffset .6s ease-in-out, opacity .4s; }
 .src { stroke: var(--accent); stroke-width: 1.5; opacity: .6; }
-.node .dot { fill: var(--node); transition: fill .3s; }
-.node text { font: 400 11px var(--font); fill: var(--muted); paint-order: stroke; stroke: var(--bg); stroke-width: 4px; stroke-linejoin: round; pointer-events: none; }
-.node .ring { fill: none; stroke: var(--accent); stroke-width: 1.5; stroke-dasharray: 3 3; opacity: 0; }
+.node .dot { fill: var(--node); transition: fill .3s; r: calc(var(--k) * 3.5px); }
+.node.dir .dot { r: calc(var(--k) * 5px); }
+.node.root .dot { r: calc(var(--k) * 8px); fill: var(--ink); }
+.node text { font-family: var(--font); font-size: calc(var(--k) * 11px); fill: var(--muted); paint-order: stroke; stroke: var(--bg); stroke-width: calc(var(--k) * 4px); stroke-linejoin: round; pointer-events: none; display: none; }
+.node.root text { font-size: calc(var(--k) * 13px); font-weight: 600; fill: var(--ink); }
+.node.root text, .node.top text, .node.hit text, .node.visited text, .node.written text, svg.near .node.dir text, svg.close .node text { display: inline; }
+.node .ring { fill: none; stroke: var(--accent); stroke-width: 1.5; stroke-dasharray: 3 3; opacity: 0; r: calc(var(--k) * 11px); vector-effect: non-scaling-stroke; }
+.node .pulse { r: calc(var(--k) * 6px); }
 .node.hit .ring { opacity: 1; }
 .node.visited .dot, .node.written .dot { fill: var(--accent); }
 .node.visited text, .node.written text { fill: var(--ink); font-weight: 600; }
@@ -74,13 +85,14 @@ li .btn { grid-column: 1 / -1; justify-self: start; margin-top: 4px; }
 <body>
 <div class="bar">
   <strong>Pathnote</strong>
-  <span class="vault" id="vault"></span>
+  <span class="vault" id="roots"></span>
   <span class="chip" id="status"><i></i><span id="statusText"></span></span>
 </div>
 <div class="main">
   <div class="graph">
     <svg id="g" role="img"></svg>
     <div class="empty" id="empty" hidden></div>
+    <p class="note" id="note" hidden></p>
   </div>
   <div class="log">
     <h2><span id="logTitle"></span><button class="btn" id="clear" type="button"></button></h2>
@@ -92,12 +104,16 @@ li .btn { grid-column: 1 / -1; justify-self: start; margin-top: 4px; }
 const ko = (navigator.language || '').toLowerCase().startsWith('ko');
 const L = ko ? {
   live: '연결됨', off: '연결 끊김', activity: '작업 기록', clear: '경로 지우기', undo: '되돌리기', undone: '되돌림',
-  wait: 'AI가 노트를 검색하거나 읽으면 여기에 기록이 쌓입니다.', empty: '이 폴더에 .md 노트가 없습니다.',
-  hits: n => `${n}개 찾음`, created: '새 노트', graph: '노트 그래프와 AI가 지나간 경로'
+  wait: 'AI가 파일을 찾거나 읽으면 여기에 기록이 쌓입니다.', empty: '연결된 폴더가 비어 있습니다.',
+  hits: n => `${n}개 찾음`, created: '새 파일', graph: '연결된 폴더 구조와 AI가 지나간 경로',
+  capped: n => `파일이 많아 ${n}개까지만 그렸습니다.`, folders: n => `폴더 ${n}개`,
+  blocked: 'macOS가 막고 있어 비어 보이는 폴더: ', allow: ' 시스템 설정 → 개인정보 보호 및 보안 → 파일 및 폴더에서 Pathnote를 실행하는 앱(Claude 등)에 허용한 뒤 새로고침하세요.'
 } : {
   live: 'Live', off: 'Disconnected', activity: 'Activity', clear: 'Clear path', undo: 'Undo', undone: 'undone',
-  wait: 'When the AI searches or reads your notes, it shows up here.', empty: 'No .md notes in this folder.',
-  hits: n => `${n} found`, created: 'new note', graph: 'Note graph with the path the AI took'
+  wait: 'When the AI looks through or reads your files, it shows up here.', empty: 'The connected folders are empty.',
+  hits: n => `${n} found`, created: 'new file', graph: 'Connected folders and the path the AI took',
+  capped: n => `Too many files; drew the first ${n}.`, folders: n => `${n} folders`,
+  blocked: 'macOS is blocking these folders, so they look empty: ', allow: ' Allow them in System Settings → Privacy & Security → Files and Folders for the app that runs Pathnote (e.g. Claude), then reload.'
 };
 document.documentElement.lang = ko ? 'ko' : 'en';
 document.getElementById('logTitle').textContent = L.activity;
@@ -107,81 +123,124 @@ document.getElementById('hint').textContent = L.wait;
 const NS = 'http://www.w3.org/2000/svg';
 const svg = document.getElementById('g');
 svg.setAttribute('aria-label', L.graph);
-const view = el('g'), gLinks = el('g'), gTrail = el('g'), gNodes = el('g');
-view.append(gLinks, gTrail, gNodes);
+const view = el('g'), gTree = el('g'), gLinks = el('g'), gTrail = el('g'), gNodes = el('g');
+view.append(gTree, gLinks, gTrail, gNodes);
 svg.append(view);
-const pos = new Map(), nodeEl = new Map();
-let current = null, sources = new Set(), vb = { x: 0, y: 0, w: 1000, h: 700 };
+const pos = new Map(), nodeEl = new Map(), angleOf = new Map(), depthOf = new Map();
+const RING = 160;
+// connected folders sit on a wide first ring so their names don't crowd the middle
+const radius = depth => (depth + 1.5) * RING;
+let current = null, sources = new Set(), vb = { x: -500, y: -500, w: 1000, h: 1000 };
 
 function el(tag, attrs = {}) {
   const e = document.createElementNS(NS, tag);
   for (const k in attrs) e.setAttribute(k, attrs[k]);
   return e;
 }
-const name = p => p.split('/').pop().replace(/\.md$/i, '');
+const base = p => p.split('/').filter(Boolean).pop() || p;
+const parentOf = p => p.slice(0, p.lastIndexOf('/')) || '/';
 
-// Small force layout: nodes push apart, links pull together, everything drifts to the middle
-function layout(nodes, edges) {
-  const n = nodes.length, P = nodes.map((_, i) => {
-    const a = i * 2.39996, r = 30 * Math.sqrt(i + 1);
-    return { x: r * Math.cos(a), y: r * Math.sin(a), vx: 0, vy: 0 };
-  });
-  const idx = new Map(nodes.map((id, i) => [id, i]));
-  const E = edges.map(([a, b]) => [idx.get(a), idx.get(b)]);
-  const steps = n > 600 ? 80 : 250;
-  for (let s = 0; s < steps; s++) {
-    const cool = 1 - s / steps;
-    for (let i = 0; i < n; i++) for (let j = i + 1; j < n; j++) {
-      const dx = P[i].x - P[j].x, dy = P[i].y - P[j].y, d2 = dx * dx + dy * dy + 0.01;
-      if (d2 > 90000) continue;
-      const f = 1800 / d2;
-      P[i].vx += dx * f; P[i].vy += dy * f; P[j].vx -= dx * f; P[j].vy -= dy * f;
-    }
-    for (const [a, b] of E) {
-      const dx = P[b].x - P[a].x, dy = P[b].y - P[a].y, d = Math.hypot(dx, dy) + 0.01, f = (d - 90) * 0.02 / d;
-      P[a].vx += dx * f; P[a].vy += dy * f; P[b].vx -= dx * f; P[b].vy -= dy * f;
+// Radial tree: each folder gets a slice of the circle sized by how many files it holds,
+// and sits one ring further out than its parent
+function layout(items) {
+  const kids = new Map([['', []]]);
+  for (const it of items) {
+    const p = it.kind === 'root' ? '' : it.parent;
+    if (!kids.has(p)) kids.set(p, []);
+    kids.get(p).push(it.id);
+  }
+  const leaves = new Map();
+  const count = id => {
+    const c = kids.get(id) || [];
+    const n = c.length ? c.reduce((s, k) => s + count(k), 0) : 1;
+    leaves.set(id, n);
+    return n;
+  };
+  count('');
+  // a connected folder with few files still gets a readable share of the circle
+  const total = leaves.get('');
+  for (const r of kids.get('')) leaves.set(r, Math.max(leaves.get(r), total * 0.1));
+  leaves.set('', kids.get('').reduce((s, r) => s + leaves.get(r), 0));
+  const place = (id, a0, a1, depth) => {
+    const a = (a0 + a1) / 2;
+    if (id) {
+      pos.set(id, [Math.cos(a) * radius(depth), Math.sin(a) * radius(depth)]);
+      angleOf.set(id, a); depthOf.set(id, depth);
     }
-    for (const p of P) {
-      p.vx -= p.x * 0.004; p.vy -= p.y * 0.004;
-      p.x += Math.max(-20, Math.min(20, p.vx)) * cool; p.y += Math.max(-20, Math.min(20, p.vy)) * cool;
-      p.vx *= 0.5; p.vy *= 0.5;
+    let at = a0;
+    const sum = (kids.get(id) || []).reduce((s, k) => s + leaves.get(k), 0);
+    for (const k of kids.get(id) || []) {
+      const span = (a1 - a0) * leaves.get(k) / sum;
+      place(k, at, at + span, depth + 1);
+      at += span;
     }
-  }
-  nodes.forEach((id, i) => pos.set(id, [P[i].x, P[i].y]));
+  };
+  place('', -Math.PI / 2, Math.PI * 1.5, 0);
+}
+
+function setView() {
+  svg.setAttribute('viewBox', `${vb.x} ${vb.y} ${vb.w} ${vb.h}`);
+  const k = vb.w / Math.max(1, svg.clientWidth);
+  svg.style.setProperty('--k', k);
+  svg.classList.toggle('near', k < 1.2);
+  svg.classList.toggle('close', k < 0.5);
 }
 
 function fit() {
   const pts = [...pos.values()];
-  if (!pts.length) return;
+  if (!pts.length) return setView();
   const xs = pts.map(p => p[0]), ys = pts.map(p => p[1]);
-  const pad = 60, x0 = Math.min(...xs) - pad, y0 = Math.min(...ys) - pad;
-  vb = { x: x0, y: y0, w: Math.max(...xs) + pad - x0, h: Math.max(...ys) + pad - y0 };
-  svg.setAttribute('viewBox', `${vb.x} ${vb.y} ${vb.w} ${vb.h}`);
+  const pad = 80, x0 = Math.min(...xs) - pad, y0 = Math.min(...ys) - pad;
+  const w = Math.max(...xs) + pad - x0, h = Math.max(...ys) + pad - y0;
+  // keep the drawing's aspect so it isn't squashed in a wide panel
+  const r = svg.clientWidth / Math.max(1, svg.clientHeight);
+  // leave room for file names, which run sideways past the outermost dots
+  const label = 220 * Math.max(w, h * r) / Math.max(1, svg.clientWidth);
+  const size = Math.max(w + 2 * label, h * r);
+  vb = { x: x0 + w / 2 - size / 2, y: y0 + h / 2 - size / r / 2, w: size, h: size / r };
+  setView();
 }
 
-function addNode(id) {
+function addNode(id, kind, top) {
   const [x, y] = pos.get(id);
-  const g = el('g', { class: 'node' });
-  g.append(el('circle', { class: 'pulse', cx: x, cy: y, r: 7 }), el('circle', { class: 'ring', cx: x, cy: y, r: 13 }),
-    el('circle', { class: 'dot', cx: x, cy: y, r: 6 }));
-  const t = el('text', { x, y: y + 22, 'text-anchor': 'middle' });
-  t.textContent = name(id);
+  const g = el('g', { class: `node ${kind}${top ? ' top' : ''}` });
+  g.append(el('circle', { class: 'pulse', cx: x, cy: y }), el('circle', { class: 'ring', cx: x, cy: y }), el('circle', { class: 'dot', cx: x, cy: y }));
+  const a = angleOf.get(id) ?? 0, right = Math.cos(a) >= 0;
+  const t = el('text', { x, y, dx: right ? '0.9em' : '-0.9em', dy: '0.35em', 'text-anchor': right ? 'start' : 'end' });
+  t.textContent = base(id);
   const title = el('title'); title.textContent = id;
   g.append(t, title);
   gNodes.append(g);
   nodeEl.set(id, g);
 }
 
+function treeLine(a, b) {
+  const [x1, y1] = pos.get(a), [x2, y2] = pos.get(b);
+  gTree.append(el('line', { class: 'tree', x1, y1, x2, y2 }));
+}
+
 async function loadGraph() {
-  const { nodes, edges } = await (await fetch('/api/graph')).json();
-  document.getElementById('empty').hidden = nodes.length > 0;
-  document.getElementById('empty').textContent = L.empty;
-  layout(nodes, edges);
-  for (const [a, b] of edges) {
+  const g = await (await fetch('/api/graph')).json();
+  document.getElementById('roots').textContent = g.roots.map(base).join(' · ');
+  document.getElementById('roots').title = g.roots.join('\n');
+  const empty = document.getElementById('empty');
+  empty.hidden = g.items.some(i => i.kind !== 'root') && !g.capped;
+  empty.textContent = g.capped ? L.capped(g.items.length) : L.empty;
+  const note = document.getElementById('note');
+  note.hidden = !g.blocked?.length;
+  if (g.blocked?.length) {
+    note.textContent = '';
+    const b = document.createElement('b'); b.textContent = L.blocked + g.blocked.map(base).join(', ') + '.';
+    note.append(b, L.allow);
+  }
+  layout(g.items);
+  const isRoot = new Set(g.roots);
+  for (const it of g.items) if (it.parent && pos.has(it.parent)) treeLine(it.parent, it.id);
+  for (const it of g.items) addNode(it.id, it.kind, it.kind === 'dir' && isRoot.has(it.parent));
+  for (const [a, b] of g.links) {
     const [x1, y1] = pos.get(a), [x2, y2] = pos.get(b);
     gLinks.append(el('line', { class: 'link', x1, y1, x2, y2 }));
   }
-  nodes.forEach(addNode);
   fit();
 }
 
@@ -202,17 +261,30 @@ function setCurrent(id) {
   nodeEl.get(id)?.classList.add('current');
 }
 
-// A note the AI created: place it next to the notes it read
-function ensureNode(id) {
+// A file the AI created: put it one ring outside its folder
+function ensureNode(id, kind = 'file') {
   if (pos.has(id)) return;
-  const src = [...sources].map(s => pos.get(s)).filter(Boolean);
-  const cx = src.length ? src.reduce((a, p) => a + p[0], 0) / src.length : vb.x + vb.w / 2;
-  const cy = src.length ? src.reduce((a, p) => a + p[1], 0) / src.length : vb.y + vb.h / 2;
-  pos.set(id, [cx + 50, cy - 40]);
-  addNode(id);
+  const parent = parentOf(id);
+  if (pos.has(parent)) {
+    const a = (angleOf.get(parent) ?? 0) + (Math.random() - 0.5) * 0.08, d = (depthOf.get(parent) ?? 1) + 1;
+    pos.set(id, [Math.cos(a) * radius(d), Math.sin(a) * radius(d)]); angleOf.set(id, a); depthOf.set(id, d);
+    treeLine(parent, id);
+  } else {
+    pos.set(id, [vb.x + vb.w / 2, vb.y + vb.h / 2]);
+  }
+  addNode(id, kind);
   document.getElementById('empty').hidden = true;
 }
 
+// Move along the path to a node: line from the last place the AI was
+function visit(id, live) {
+  if (!nodeEl.has(id)) return;
+  if (current && current !== id) line('trail', current, id, live);
+  const g = nodeEl.get(id);
+  g.classList.remove('hit'); g.classList.add('visited');
+  setCurrent(id);
+}
+
 const logEl = document.getElementById('log');
 function addLog(e, tool, text, live) {
   document.getElementById('hint').hidden = true;
@@ -222,7 +294,7 @@ function addLog(e, tool, text, live) {
   if (e.type === 'undo') li.classList.add('undo');
   const a = document.createElement('span'); a.className = 'tool'; a.textContent = tool;
   const tm = document.createElement('time'); tm.textContent = new Date(e.t).toLocaleTimeString();
-  const b = document.createElement('span'); b.className = 'text'; b.textContent = text;
+  const b = document.createElement('span'); b.className = 'text'; b.textContent = text; b.title = e.path || '';
   li.append(a, tm, b);
   if (e.reason) { const w = document.createElement('span'); w.className = 'why'; w.textContent = e.reason; li.append(w); }
   if (e.changeId && e.type !== 'undo') {
@@ -242,32 +314,48 @@ function addLog(e, tool, text, live) {
   logEl.scrollTop = logEl.scrollHeight;
 }
 
+// Show paths shortly: the connected folder's name, then the rest
+function short(p) {
+  const root = rootsList.find(r => p === r || p.startsWith(r + '/'));
+  return root ? base(root) + p.slice(root.length) : p;
+}
+let rootsList = [];
+
 function onEvent(e, live) {
   if (e.type === 'search') {
     for (const h of e.hits) nodeEl.get(h)?.classList.add('hit');
-    addLog(e, 'search_vault', `"${e.query}" · ${L.hits(e.hits.length)}`, live);
+    addLog(e, 'search_files', `"${e.query}" · ${L.hits(e.hits.length)}`, live);
+  } else if (e.type === 'list') {
+    visit(e.path, live);
+    addLog(e, 'list_files', short(e.path) + '/', live);
   } else if (e.type === 'read') {
-    const g = nodeEl.get(e.path);
-    if (g) {
-      if (current && current !== e.path) line('trail', current, e.path, live);
-      g.classList.remove('hit'); g.classList.add('visited');
-      sources.add(e.path); setCurrent(e.path);
-    }
-    addLog(e, 'read_note', e.path, live);
+    visit(e.path, live);
+    if (nodeEl.has(e.path)) sources.add(e.path);
+    addLog(e, 'read_file', short(e.path), live);
   } else if (e.type === 'write' || e.type === 'edit') {
     ensureNode(e.path);
-    for (const s of sources) if (s !== e.path) line('src', s, e.path, live);
+    for (const s of sources) if (s !== e.path && pos.has(s)) line('src', s, e.path, live);
     const g = nodeEl.get(e.path);
     g.classList.remove('gone'); g.classList.add('written');
     setCurrent(e.path);
-    addLog(e, e.type === 'write' ? 'write_note' : 'edit_note', e.created ? `${e.path} (${L.created})` : e.path, live);
+    addLog(e, e.type === 'write' ? 'write_file' : 'edit_file', e.created ? `${short(e.path)} (${L.created})` : short(e.path), live);
+  } else if (e.type === 'move') {
+    visit(e.from, live);
+    ensureNode(e.path, e.dir ? 'dir' : 'file');
+    if (pos.has(e.from)) line('src', e.from, e.path, live);
+    nodeEl.get(e.from)?.classList.add('gone');
+    const g = nodeEl.get(e.path);
+    g.classList.remove('gone'); g.classList.add('written');
+    setCurrent(e.path);
+    addLog(e, 'move_file', `${short(e.from)} → ${short(e.path)}`, live);
   } else if (e.type === 'undo') {
+    if (e.back) nodeEl.get(e.back)?.classList.remove('gone');
     if (e.created) {
       nodeEl.get(e.path)?.classList.add('gone');
       gTrail.querySelectorAll(`[data-to="${CSS.escape(e.path)}"]`).forEach(l => l.style.opacity = 0);
     }
     logEl.querySelectorAll(`[data-change="${e.changeId}"]`).forEach(b => { b.disabled = true; b.textContent = L.undone; });
-    addLog(e, 'undo', e.path, live);
+    addLog(e, 'undo', short(e.path), live);
   }
 }
 
@@ -277,14 +365,14 @@ document.getElementById('clear').onclick = () => {
   current = null; sources = new Set();
 };
 
-// Drag to pan, wheel to zoom
+// Drag to pan, wheel or pinch to zoom
 let drag = null;
 svg.addEventListener('pointerdown', e => { drag = { x: e.clientX, y: e.clientY, vb: { ...vb } }; svg.classList.add('drag'); svg.setPointerCapture(e.pointerId); });
 svg.addEventListener('pointermove', e => {
   if (!drag) return;
   const k = vb.w / svg.clientWidth;
   vb.x = drag.vb.x - (e.clientX - drag.x) * k; vb.y = drag.vb.y - (e.clientY - drag.y) * k;
-  svg.setAttribute('viewBox', `${vb.x} ${vb.y} ${vb.w} ${vb.h}`);
+  setView();
 });
 svg.addEventListener('pointerup', () => { drag = null; svg.classList.remove('drag'); });
 svg.addEventListener('wheel', e => {
@@ -292,14 +380,16 @@ svg.addEventListener('wheel', e => {
   const k = Math.exp(e.deltaY * 0.0015), r = svg.getBoundingClientRect();
   const mx = vb.x + (e.clientX - r.left) / r.width * vb.w, my = vb.y + (e.clientY - r.top) / r.height * vb.h;
   vb = { x: mx - (mx - vb.x) * k, y: my - (my - vb.y) * k, w: vb.w * k, h: vb.h * k };
-  svg.setAttribute('viewBox', `${vb.x} ${vb.y} ${vb.w} ${vb.h}`);
+  setView();
 }, { passive: false });
+addEventListener('resize', fit);
 
 (async () => {
   const info = await (await fetch('/api/info')).json();
-  document.getElementById('vault').textContent = info.vault;
+  rootsList = info.roots;
   await loadGraph();
   const status = document.getElementById('status'), statusText = document.getElementById('statusText');
+  statusText.textContent = L.off;
   let replay = true;
   const es = new EventSource('/api/events');
   es.onopen = () => { status.classList.add('on'); statusText.textContent = L.live; setTimeout(() => { replay = false; }, 300); };
@@ -311,7 +401,6 @@ svg.addEventListener('wheel', e => {
     seen.add(e.key);
     onEvent(e, !replay);
   };
-  statusText.textContent = L.off;
 })();
 </script>
 </body>

package/src/vault.js

@@ -1,109 +0,0 @@
-// Read and write markdown notes inside one folder. Every path that comes from the AI is
-// resolved against the vault root and refused if it points outside it or isn't a .md file.
-import fs from 'node:fs/promises';
-import path from 'node:path';
-
-const SKIP = new Set(['.git', '.obsidian', '.trash', 'node_modules']);
-const LINK = /\[\[([^\]|#]+)(?:#[^\]|]*)?(?:\|[^\]]*)?\]\]/g;
-
-export class Vault {
-  constructor(root) {
-    this.root = path.resolve(root);
-  }
-
-  // "Notes/Plan" or "Notes/Plan.md" -> absolute path, or throw if it escapes the vault
-  resolve(rel) {
-    let p = String(rel || '').trim().replace(/\\/g, '/');
-    if (!p) throw new Error('Note path is empty.');
-    if (!p.toLowerCase().endsWith('.md')) p += '.md';
-    const abs = path.resolve(this.root, p);
-    if (abs !== this.root && !abs.startsWith(this.root + path.sep)) throw new Error(`"${rel}" is outside the vault.`);
-    if (abs.split(path.sep).some(part => SKIP.has(part))) throw new Error(`"${rel}" is in a folder Pathnote does not touch.`);
-    return abs;
-  }
-
-  // Same check after following symlinks, so a link inside the vault can't lead outside it
-  async real(rel) {
-    const abs = this.resolve(rel);
-    const root = await fs.realpath(this.root);
-    let dir = abs;
-    for (;;) {
-      try { dir = await fs.realpath(dir); break; } catch (e) { if (e.code !== 'ENOENT') throw e; dir = path.dirname(dir); }
-    }
-    if (dir !== root && !dir.startsWith(root + path.sep)) throw new Error(`"${rel}" is outside the vault.`);
-    return abs;
-  }
-
-  rel(abs) {
-    return path.relative(this.root, abs).split(path.sep).join('/');
-  }
-
-  async list() {
-    const out = [];
-    const walk = async dir => {
-      for (const e of await fs.readdir(dir, { withFileTypes: true })) {
-        if (e.name.startsWith('.') || SKIP.has(e.name)) continue;
-        const abs = path.join(dir, e.name);
-        if (e.isDirectory()) await walk(abs);
-        else if (e.name.toLowerCase().endsWith('.md')) out.push(this.rel(abs));
-      }
-    };
-    await walk(this.root);
-    return out.sort();
-  }
-
-  async read(rel) {
-    return fs.readFile(await this.real(rel), 'utf8');
-  }
-
-  // Current text, or null when the note doesn't exist yet
-  async readOrNull(rel) {
-    try { return await this.read(rel); } catch (e) { if (e.code === 'ENOENT') return null; throw e; }
-  }
-
-  async write(rel, text) {
-    const abs = await this.real(rel);
-    await fs.mkdir(path.dirname(abs), { recursive: true });
-    await fs.writeFile(abs, text, 'utf8');
-  }
-
-  async remove(rel) {
-    await fs.rm(await this.real(rel), { force: true });
-  }
-
-  // Notes ranked by how often the query's words appear, title matches counted extra
-  async search(query, limit = 10) {
-    const words = String(query).toLowerCase().split(/\s+/).filter(Boolean);
-    if (!words.length) return [];
-    const hits = [];
-    for (const rel of await this.list()) {
-      const text = await this.read(rel);
-      const lower = text.toLowerCase(), name = rel.toLowerCase();
-      let score = 0;
-      for (const w of words) {
-        score += lower.split(w).length - 1;
-        if (name.includes(w)) score += 5;
-      }
-      if (!score) continue;
-      const at = Math.max(0, lower.indexOf(words.find(w => lower.includes(w)) ?? words[0]));
-      const snippet = text.slice(Math.max(0, at - 60), at + 140).replace(/\s+/g, ' ').trim();
-      hits.push({ path: rel, score, snippet });
-    }
-    return hits.sort((a, b) => b.score - a.score).slice(0, limit);
-  }
-
-  // Nodes and [[wikilink]] edges for the viewer. Links resolve by file name, like Obsidian.
-  async graph() {
-    const notes = await this.list();
-    const byName = new Map(notes.map(n => [path.posix.basename(n, '.md').toLowerCase(), n]));
-    const edges = [];
-    for (const n of notes) {
-      const text = await this.read(n);
-      for (const m of text.matchAll(LINK)) {
-        const target = byName.get(path.posix.basename(m[1].trim()).toLowerCase());
-        if (target && target !== n) edges.push([n, target]);
-      }
-    }
-    return { nodes: notes, edges };
-  }
-}