#!/usr/bin/env node
// brain-mcp: custom MCP server for the personal-brain vault.
//
// Design goal: progressive disclosure. Tools return the minimum tokens needed
// at each tier:
//   tier 1  list_projects / list_actions / list_areas  -> frontmatter summary only
//   tier 2  read_text      -> one full file, on demand
//   tier 3  grep           -> matching lines only, from glossary/reference/etc
//
// All paths are vault-relative and sandboxed to BRAIN_ROOT.

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import { promises as fs } from "node:fs";
import path from "node:path";
import { execFile } from "node:child_process";
import { promisify } from "node:util";

const execFileAsync = promisify(execFile);
const ROOT = path.resolve(process.env.BRAIN_ROOT || process.argv[2] || process.cwd());

// Files grep/list walks skip. Binary + noise.
const SKIP_DIRS = new Set([".git", "node_modules", ".obsidian"]);
const BINARY_EXT = new Set([".pdf", ".epub", ".png", ".jpg", ".jpeg", ".gif", ".zip", ".db"]);
const GREP_LIMIT = 200; // max match lines returned, guards against accidental whole-vault dumps

// PARA buckets: live dir -> archive dir. One file per item, frontmatter = index.
const ARCHIVE_MAP = {
  projects: "archive/projects",
  actions: "archive/actions",
  areas: "archive/area",
};

// Resolve a vault-relative path and refuse anything that escapes ROOT.
function resolveInRoot(rel) {
  const abs = path.resolve(ROOT, rel || ".");
  if (abs !== ROOT && !abs.startsWith(ROOT + path.sep)) {
    throw new Error(`path escapes vault root: ${rel}`);
  }
  return abs;
}

// Parse a leading YAML frontmatter block into a flat key->string map.
// Intentionally simple: our frontmatter is flat scalars, no nested YAML.
function parseFrontmatter(text) {
  if (!text.startsWith("---")) return {};
  const end = text.indexOf("\n---", 3);
  if (end === -1) return {};
  const block = text.slice(text.indexOf("\n") + 1, end);
  const out = {};
  for (const line of block.split("\n")) {
    const m = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
    if (m) out[m[1]] = m[2].replace(/^["']|["']$/g, "").trim();
  }
  return out;
}

// Flip status/stage to archived and stamp an archived date into frontmatter.
function stampArchived(text) {
  const today = new Date().toISOString().slice(0, 10);
  text = text.replace(/^status:[ \t].*$/m, "status: archived");
  text = text.replace(/^stage:[ \t].*$/m, "stage: archived");
  if (text.startsWith("---")) {
    const end = text.indexOf("\n---", 3);
    if (end !== -1 && !/^archived:/m.test(text.slice(0, end))) {
      text = text.slice(0, end) + `\narchived: ${today}` + text.slice(end);
    }
  }
  return text;
}

async function* walk(dir) {
  let entries;
  try {
    entries = await fs.readdir(dir, { withFileTypes: true });
  } catch {
    return;
  }
  for (const e of entries) {
    if (e.isDirectory()) {
      if (SKIP_DIRS.has(e.name)) continue;
      yield* walk(path.join(dir, e.name));
    } else if (e.isFile()) {
      if (BINARY_EXT.has(path.extname(e.name).toLowerCase())) continue;
      yield path.join(dir, e.name);
    }
  }
}

// Commit and push a single file after a write operation.
async function gitCommitAndPush(rel, action) {
  try {
    await execFileAsync("git", ["-C", ROOT, "add", rel]);
    await execFileAsync("git", ["-C", ROOT, "commit", "-m", `mcp: ${action} ${rel}`]);
    await execFileAsync("git", ["-C", ROOT, "pull", "--rebase", "--autostash", "origin", "main"]);
    await execFileAsync("git", ["-C", ROOT, "push", "origin", "main"]);
    return " — pushed";
  } catch (err) {
    const msg = err.stderr || err.message || String(err);
    if (msg.includes("nothing to commit")) return "";
    return ` — push failed: ${msg.trim().split("\n")[0]}`;
  }
}

// Commit a move (new file added, old path deleted) in one commit.
async function gitCommitMove(oldRel, newRel, action) {
  try {
    await execFileAsync("git", ["-C", ROOT, "add", newRel]);
    await execFileAsync("git", ["-C", ROOT, "add", "-A", "--", oldRel]);
    await execFileAsync("git", ["-C", ROOT, "commit", "-m", `mcp: ${action} ${oldRel} -> ${newRel}`]);
    await execFileAsync("git", ["-C", ROOT, "pull", "--rebase", "--autostash", "origin", "main"]);
    await execFileAsync("git", ["-C", ROOT, "push", "origin", "main"]);
    return " — pushed";
  } catch (err) {
    const msg = err.stderr || err.message || String(err);
    if (msg.includes("nothing to commit")) return "";
    return ` — push failed: ${msg.trim().split("\n")[0]}`;
  }
}

// Shared: move <kind>/<id>.md into its archive dir, flipping status/stage.
async function archiveItem(kind, id) {
  const srcRel = `${kind}/${id}.md`;
  const src = resolveInRoot(srcRel);
  let text;
  try {
    text = await fs.readFile(src, "utf8");
  } catch {
    return { content: [{ type: "text", text: `${srcRel} not found` }], isError: true };
  }
  text = stampArchived(text);
  const destRel = `${ARCHIVE_MAP[kind]}/${id}.md`;
  const dest = resolveInRoot(destRel);
  await fs.mkdir(path.dirname(dest), { recursive: true });
  await fs.writeFile(dest, text);
  await fs.unlink(src);
  const status = await gitCommitMove(srcRel, destRel, "archive");
  return { content: [{ type: "text", text: `archived ${srcRel} -> ${destRel}${status}` }] };
}

const server = new McpServer({ name: "brain-mcp", version: "0.4.0" });

// ---- tier 1: derived indexes -----------------------------------------------
server.registerTool(
  "list_projects",
  {
    title: "List projects",
    description:
      "Derived project index. Scans frontmatter of projects/*.md (skips _template) and returns one summary line per project. Reads frontmatter only, never bodies. Start here every session.",
    inputSchema: {
      status: z.enum(["active", "idle", "done"]).optional().describe("filter by status"),
      domain: z.string().optional().describe("filter by domain, e.g. woodwork, code, 3d, trip, work"),
      include_archive: z.boolean().optional().describe("also scan archive/projects/ (default false)"),
    },
  },
  async ({ status, domain, include_archive }) => {
    const dirs = [resolveInRoot("projects")];
    if (include_archive) dirs.push(resolveInRoot("archive/projects"));
    const lines = [];
    for (const dir of dirs) {
      for await (const file of walk(dir)) {
        const rel = path.relative(ROOT, file);
        if (path.basename(file) === "_template.md") continue;
        if (path.extname(file) !== ".md") continue;
        const fm = parseFrontmatter(await fs.readFile(file, "utf8"));
        if (!fm.id) continue;
        if (status && fm.status !== status) continue;
        if (domain && fm.domain !== domain) continue;
        lines.push(
          `${fm.id} | ${fm.domain || "?"} | ${fm.status || "?"} | touched ${fm.last_touched || "?"} | next: ${fm.next_action || "-"} | ${rel}`
        );
      }
    }
    lines.sort();
    return { content: [{ type: "text", text: lines.length ? lines.join("\n") : "(no projects match)" }] };
  }
);

server.registerTool(
  "list_actions",
  {
    title: "List actions",
    description:
      "Derived action index (GTD). Scans frontmatter of actions/*.md (skips _template), returns one line per action sorted by due date (undated last). Reads frontmatter only.",
    inputSchema: {
      stage: z.enum(["someday", "next", "waiting"]).optional().describe("filter by stage"),
      domain: z.string().optional().describe("filter by tag, e.g. 3d, workshop, code"),
      due_before: z.string().optional().describe("only actions with due <= this YYYY-MM-DD"),
      include_archive: z.boolean().optional().describe("also scan archive/actions/ (default false)"),
    },
  },
  async ({ stage, domain, due_before, include_archive }) => {
    const dirs = [resolveInRoot("actions")];
    if (include_archive) dirs.push(resolveInRoot("archive/actions"));
    const rows = [];
    for (const dir of dirs) {
      for await (const file of walk(dir)) {
        const rel = path.relative(ROOT, file);
        if (path.basename(file) === "_template.md") continue;
        if (path.extname(file) !== ".md") continue;
        const fm = parseFrontmatter(await fs.readFile(file, "utf8"));
        if (!fm.id) continue;
        if (stage && fm.stage !== stage) continue;
        if (domain && !(fm.tags || "").includes(domain)) continue;
        if (due_before && (!fm.due || fm.due > due_before)) continue;
        rows.push({
          due: fm.due || "~",
          line: `${fm.id} | ${fm.stage || "?"} | due ${fm.due || "-"} | tags ${fm.tags || "-"} | ${rel}`,
        });
      }
    }
    rows.sort((a, b) => (a.due < b.due ? -1 : a.due > b.due ? 1 : 0));
    return {
      content: [{ type: "text", text: rows.length ? rows.map((r) => r.line).join("\n") : "(no actions match)" }],
    };
  }
);

server.registerTool(
  "list_areas",
  {
    title: "List areas",
    description:
      "Derived area index. Scans frontmatter of areas/*.md (skips _template), one line per area of responsibility / long-term goal. Reads frontmatter only.",
    inputSchema: {
      domain: z.string().optional().describe("filter by domain"),
      include_archive: z.boolean().optional().describe("also scan archive/area/ (default false)"),
    },
  },
  async ({ domain, include_archive }) => {
    const dirs = [resolveInRoot("areas")];
    if (include_archive) dirs.push(resolveInRoot("archive/area"));
    const lines = [];
    for (const dir of dirs) {
      for await (const file of walk(dir)) {
        const rel = path.relative(ROOT, file);
        if (path.basename(file) === "_template.md") continue;
        if (path.extname(file) !== ".md") continue;
        const fm = parseFrontmatter(await fs.readFile(file, "utf8"));
        const id = fm.id || path.basename(file, ".md");
        lines.push(`${id} | ${fm.domain || "?"} | updated ${fm["last-updated"] || fm.last_touched || "?"} | ${rel}`);
      }
    }
    lines.sort();
    return { content: [{ type: "text", text: lines.length ? lines.join("\n") : "(no areas match)" }] };
  }
);

// ---- tier 2: read one file -------------------------------------------------
server.registerTool(
  "read_text",
  {
    title: "Read file",
    description: "Read a full vault file as text. Use after list_projects/grep narrows to one file.",
    inputSchema: { path: z.string().describe("vault-relative path, e.g. projects/woodwork-table.md") },
  },
  async ({ path: rel }) => {
    const text = await fs.readFile(resolveInRoot(rel), "utf8");
    return { content: [{ type: "text", text }] };
  }
);

// ---- tier 3: content search ------------------------------------------------
server.registerTool(
  "grep",
  {
    title: "Grep content",
    description:
      "Search file contents by regex, return matching lines as 'relpath:lineno: text'. Use for glossary/reference/fact lookups instead of reading whole files. Skips archive/ by default.",
    inputSchema: {
      pattern: z.string().describe("JavaScript regex, case-insensitive"),
      path: z.string().optional().describe("limit to this file or subdir (default whole vault)"),
      include_archive: z.boolean().optional().describe("also search archive/ (default false)"),
    },
  },
  async ({ pattern, path: rel, include_archive }) => {
    let re;
    try {
      re = new RegExp(pattern, "i");
    } catch (e) {
      return { content: [{ type: "text", text: `bad regex: ${e.message}` }], isError: true };
    }
    const start = resolveInRoot(rel);
    const stat = await fs.stat(start);
    let files = [];
    if (stat.isFile()) files.push(start);
    else for await (const f of walk(start)) files.push(f);

    const archiveAbs = resolveInRoot("archive");
    const startInArchive = start === archiveAbs || start.startsWith(archiveAbs + path.sep);
    if (!include_archive && !startInArchive) {
      files = files.filter((f) => !(f === archiveAbs || f.startsWith(archiveAbs + path.sep)));
    }

    const hits = [];
    for (const file of files) {
      if (hits.length >= GREP_LIMIT) break;
      const text = await fs.readFile(file, "utf8");
      const relp = path.relative(ROOT, file);
      text.split("\n").forEach((line, i) => {
        if (hits.length < GREP_LIMIT && re.test(line)) hits.push(`${relp}:${i + 1}: ${line.trim()}`);
      });
    }
    return {
      content: [
        { type: "text", text: hits.length ? hits.join("\n") + (hits.length >= GREP_LIMIT ? "\n(truncated)" : "") : "(no matches)" },
      ],
    };
  }
);

// ---- writes ----------------------------------------------------------------
server.registerTool(
  "append",
  {
    title: "Append to file",
    description: "Append text to a file (created if missing). For append-only data: journal lines, project Log entries.",
    inputSchema: {
      path: z.string().describe("vault-relative path"),
      text: z.string().describe("text to append; a trailing newline is added if absent"),
    },
  },
  async ({ path: rel, text }) => {
    const abs = resolveInRoot(rel);
    await fs.mkdir(path.dirname(abs), { recursive: true });
    await fs.appendFile(abs, text.endsWith("\n") ? text : text + "\n");
    const status = await gitCommitAndPush(rel, "append");
    return { content: [{ type: "text", text: `appended to ${rel}${status}` }] };
  }
);

server.registerTool(
  "edit",
  {
    title: "Edit file",
    description: "Replace the first exact occurrence of old_string with new_string in a file. Targeted edit, no full rewrite.",
    inputSchema: {
      path: z.string(),
      old_string: z.string().describe("exact text to find (must be unique enough to match once)"),
      new_string: z.string(),
    },
  },
  async ({ path: rel, old_string, new_string }) => {
    const abs = resolveInRoot(rel);
    const text = await fs.readFile(abs, "utf8");
    const idx = text.indexOf(old_string);
    if (idx === -1) return { content: [{ type: "text", text: "old_string not found" }], isError: true };
    const next = text.slice(0, idx) + new_string + text.slice(idx + old_string.length);
    await fs.writeFile(abs, next);
    const status = await gitCommitAndPush(rel, "edit");
    return { content: [{ type: "text", text: `edited ${rel}${status}` }] };
  }
);

server.registerTool(
  "write_text",
  {
    title: "Write file",
    description: "Create or overwrite a file. Use for new project/action/area files from a template; prefer append/edit for existing files.",
    inputSchema: { path: z.string(), content: z.string() },
  },
  async ({ path: rel, content }) => {
    const abs = resolveInRoot(rel);
    await fs.mkdir(path.dirname(abs), { recursive: true });
    await fs.writeFile(abs, content);
    const status = await gitCommitAndPush(rel, "write");
    return { content: [{ type: "text", text: `wrote ${rel}${status}` }] };
  }
);

server.registerTool(
  "list",
  {
    title: "List directory",
    description: "List files and directories at a vault path.",
    inputSchema: { path: z.string().optional().describe("vault-relative dir, default root") },
  },
  async ({ path: rel }) => {
    const abs = resolveInRoot(rel || ".");
    const entries = await fs.readdir(abs, { withFileTypes: true });
    const out = entries
      .filter((e) => !SKIP_DIRS.has(e.name))
      .map((e) => (e.isDirectory() ? `${e.name}/` : e.name))
      .sort();
    return { content: [{ type: "text", text: out.join("\n") || "(empty)" }] };
  }
);

// ---- archive ---------------------------------------------------------------
server.registerTool(
  "archive_project",
  {
    title: "Archive project",
    description: "Move projects/<id>.md to archive/projects/<id>.md and set status: archived.",
    inputSchema: { id: z.string().describe("project id (filename without .md)") },
  },
  async ({ id }) => archiveItem("projects", id)
);

server.registerTool(
  "archive_action",
  {
    title: "Archive action",
    description: "Move actions/<id>.md to archive/actions/<id>.md and set stage: archived.",
    inputSchema: { id: z.string().describe("action id (filename without .md)") },
  },
  async ({ id }) => archiveItem("actions", id)
);

server.registerTool(
  "archive_area",
  {
    title: "Archive area",
    description: "Move areas/<id>.md to archive/area/<id>.md and set status: archived.",
    inputSchema: { id: z.string().describe("area id (filename without .md)") },
  },
  async ({ id }) => archiveItem("areas", id)
);

// ---- glossary --------------------------------------------------------------
server.registerTool(
  "glossary_add",
  {
    title: "Add glossary entry",
    description:
      "Insert a new row into glossary.md in the correct alphabetical position by acronym. " +
      "Server-side sort — do not read glossary.md first.",
    inputSchema: {
      acronym:    z.string().describe("The acronym or short form, e.g. 'ACE'"),
      definition: z.string().describe("Full expansion, e.g. 'AMBA Coherency Extensions'"),
      notes:      z.string().optional().describe("Optional context or disambiguation"),
    },
  },
  async ({ acronym, definition, notes = "" }) => {
    const rel = "glossary.md";
    const abs = resolveInRoot(rel);
    const text = await fs.readFile(abs, "utf8");
    const lines = text.split("\n");

    const isDataRow = (l) => /^\|/.test(l) && !/^\|[-: |]+\|/.test(l);
    const acronymOf  = (l) => l.split("|")[1]?.trim() ?? "";
    const newKey = acronym.toLowerCase();
    let insertAt = -1;
    for (let i = 0; i < lines.length; i++) {
      if (isDataRow(lines[i]) && acronymOf(lines[i]).toLowerCase() <= newKey) {
        insertAt = i + 1;
      }
    }
    if (insertAt === -1) {
      insertAt = lines.findIndex((l) => /^\|[-: |]+\|/.test(l)) + 1;
    }

    const newRow = `| ${acronym} | ${definition} | ${notes} |`;
    lines.splice(insertAt, 0, newRow);
    await fs.writeFile(abs, lines.join("\n"));
    const status = await gitCommitAndPush(rel, "glossary_add");
    return { content: [{ type: "text", text: `added '${acronym}' at line ${insertAt + 1}${status}` }] };
  }
);

// ---- blog drafts -----------------------------------------------------------
server.registerTool(
  "blog_draft",
  {
    title: "Create blog draft",
    description:
      "Create a new blog draft in drafts/blog-{slug}.md with correct frontmatter. " +
      "The 'blog' tag is always included; add domain-specific tags alongside it.",
    inputSchema: {
      slug:  z.string().describe("kebab-case identifier, e.g. 'mcp-oauth-setup'"),
      title: z.string().describe("Post title, used as the H1 heading"),
      tags:  z.array(z.string()).optional().describe("Extra tags beyond 'blog'"),
      body:  z.string().optional().describe("Initial markdown body content"),
    },
  },
  async ({ slug, title, tags = [], body = "" }) => {
    const today = new Date().toISOString().slice(0, 10);
    const allTags = ["blog", ...tags.filter((t) => t !== "blog")];
    const rel = `drafts/blog-${slug}.md`;
    const abs = resolveInRoot(rel);

    const content = [
      "---",
      `id: blog-${slug}`,
      `stage: draft`,
      `tags: [${allTags.join(", ")}]`,
      `created: ${today}`,
      "---",
      "",
      `# ${title}`,
      "",
      body,
    ].join("\n").trimEnd() + "\n";

    await fs.mkdir(path.dirname(abs), { recursive: true });
    await fs.writeFile(abs, content);
    const status = await gitCommitAndPush(rel, "blog_draft");
    return { content: [{ type: "text", text: `created ${rel}${status}` }] };
  }
);

// ---- delete ----------------------------------------------------------------
server.registerTool(
  "delete",
  {
    title: "Delete file",
    description:
      "Permanently delete a vault file. A small set of core files (glossary.md, CLAUDE.md, README.md, todo.md) are protected.",
    inputSchema: {
      path: z.string().describe("vault-relative path"),
    },
  },
  async ({ path: rel }) => {
    const PROTECTED = new Set(["glossary.md", "CLAUDE.md", "README.md", "todo.md"]);
    if (PROTECTED.has(path.basename(rel))) {
      return { content: [{ type: "text", text: `'${rel}' is a protected file and cannot be deleted` }], isError: true };
    }
    const abs = resolveInRoot(rel);
    try { await fs.access(abs); } catch {
      return { content: [{ type: "text", text: `'${rel}' not found` }], isError: true };
    }
    await fs.unlink(abs);
    try {
      await execFileAsync("git", ["-C", ROOT, "rm", "--cached", rel]);
      await execFileAsync("git", ["-C", ROOT, "commit", "-m", `mcp: delete ${rel}`]);
      await execFileAsync("git", ["-C", ROOT, "pull", "--rebase", "--autostash", "origin", "main"]);
      await execFileAsync("git", ["-C", ROOT, "push", "origin", "main"]);
      return { content: [{ type: "text", text: `deleted ${rel} — pushed` }] };
    } catch (err) {
      const msg = (err.stderr || err.message || String(err)).trim().split("\n")[0];
      return { content: [{ type: "text", text: `deleted ${rel} (git: ${msg})` }] };
    }
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);