@raymondchins/agentmap 0.1.0 → 0.2.1

package/hooks/INSTALL.md

@@ -0,0 +1,211 @@
+# agentmap — agent-loop install
+
+The differentiator over "pack the repo into a prompt" tools is **agent-loop
+integration**: the map stays fresh on its own (git `post-commit`) and the agent
+is *nudged* to use it instead of serial grep (Claude Code `PreToolUse` hook).
+Two small, dependency-free files wire both up.
+
+```
+hooks/
+  agentmap-nudge.mjs  PreToolUse(Grep) nudge → "use agentmap --any first"
+  post-commit         git hook → rebuilds .claude/agentmap.json after each commit
+  INSTALL.md          ← you are here
+```
+
+Both are pure Node/POSIX sh stdlib. The only runtime dependency is `agentmap`
+itself (`ts-morph`), used when the map (re)builds.
+
+---
+
+## 0. Prerequisites
+
+- **Node 18+** on PATH.
+- **agentmap available in the repo.** Either:
+  - drop `agentmap.mjs` at the repo root (or `scripts/agentmap.mjs`), or
+  - install it: `npm i -D @raymondchins/agentmap` (then `npx @raymondchins/agentmap` works), or
+  - install it globally: `npm i -g @raymondchins/agentmap` (then `agentmap` works).
+- The repo must have a `tsconfig.json` (agentmap reads it to find source files).
+
+**Caveats:**
+
+- **git hooks run under a non-login shell.** If you manage Node via `nvm`,
+  `nvm` won't be sourced and `node` may not be on PATH inside the hook. Use
+  a system-level Node install (or Volta / Corepack) so the hook can find
+  `node` without shell profile sourcing. Add an explicit `export PATH=...`
+  line at the top of the hook if needed.
+- **Windows:** Git for Windows runs hooks under its bundled `sh`, not bash.
+  The hook script is POSIX sh — do **not** use bash-specific syntax if you
+  customise it.
+
+Smoke-test it builds:
+
+```bash
+node agentmap.mjs        # or: npx @raymondchins/agentmap
+# → agentmap: N files | M features | top hub: ...
+```
+
+This writes `.claude/agentmap.json`. Add it to `.gitignore` (it's a derived
+artifact, rebuilt on every commit):
+
+```bash
+echo ".claude/agentmap.json" >> .gitignore
+```
+
+---
+
+## 1. PreToolUse nudge (Claude Code)
+
+Steers `who-imports` / dependency / reuse / `<Component>` greps toward
+`agentmap --any` before the agent fans out into serial grep. **Non-blocking** —
+it only injects a reminder, never denies the Grep.
+
+### a. Place the hook script
+
+Keep it in the repo so it's version-controlled and path-stable:
+
+```bash
+mkdir -p .claude/hooks
+cp hooks/agentmap-nudge.mjs .claude/hooks/agentmap-nudge.mjs
+```
+
+### b. Register it in `.claude/settings.json`
+
+Add (or merge) this `hooks` block. The matcher `Grep` runs the hook before
+every Grep tool call; the script decides whether to nudge.
+
+```json
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Grep",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/agentmap-nudge.mjs\""
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+`$CLAUDE_PROJECT_DIR` is set by Claude Code to the project root, so the path
+resolves no matter the agent's cwd. Restart the session (or `/hooks` →
+reload) to pick it up.
+
+### c. Verify
+
+```bash
+echo '{"tool_input":{"pattern":"<Heading"}}' | node .claude/hooks/agentmap-nudge.mjs
+# → {"hookSpecificOutput":{...,"additionalContext":"This Grep looks like ..."}}
+
+echo '{"tool_input":{"pattern":"bg-white"}}'  | node .claude/hooks/agentmap-nudge.mjs
+# → (no output — raw-string sweeps are left alone)
+```
+
+---
+
+## 2. post-commit auto-refresh (git)
+
+Rebuilds the map after each commit so the agent never reads a stale map.
+Runs detached + silenced (commit returns instantly) and **skips during
+rebase / merge / cherry-pick / bisect / revert** so it doesn't fire on every
+replayed commit.
+
+**Easiest way — use the built-in installer flag:**
+
+```bash
+agentmap --install-hooks
+```
+
+This copies `hooks/post-commit` to `.git/hooks/post-commit`, chmods it, ensures
+`.claude/agentmap.json` is in `.gitignore`, and prints the Claude Code
+`settings.json` PreToolUse snippet — all in one step.
+
+**Manual alternative:**
+
+```bash
+cp hooks/post-commit .git/hooks/post-commit
+chmod +x .git/hooks/post-commit
+```
+
+It auto-locates the builder: `./agentmap.mjs` → `./scripts/agentmap.mjs` →
+global `agentmap` → `npx --no-install @raymondchins/agentmap`. If none is found it no-ops.
+
+### Verify
+
+```bash
+git commit --allow-empty -m "test: agentmap post-commit"
+# wait a moment for the background rebuild, then:
+git rev-parse --short HEAD
+node -e "console.log(require('./.claude/agentmap.json').generatedSha)"
+# the two SHAs should match
+```
+
+> **Husky / shared hooks:** if the repo uses Husky or `core.hooksPath`, append
+> the body of `hooks/post-commit` to your existing `post-commit` (e.g.
+> `.husky/post-commit`) instead of overwriting `.git/hooks/post-commit`.
+
+---
+
+## 3. One-liner installer (idea)
+
+Drop this as `hooks/install.sh` in your repo (or run inline) to wire both at
+once from the repo root:
+
+```sh
+#!/usr/bin/env sh
+set -eu
+ROOT="$(git rev-parse --show-toplevel)"
+HOOKS="$ROOT/hooks"   # where these files live in your repo
+
+# PreToolUse nudge
+mkdir -p "$ROOT/.claude/hooks"
+cp "$HOOKS/agentmap-nudge.mjs" "$ROOT/.claude/hooks/agentmap-nudge.mjs"
+
+# Merge the PreToolUse(Grep) hook into .claude/settings.json (needs jq).
+SETTINGS="$ROOT/.claude/settings.json"
+[ -f "$SETTINGS" ] || echo '{}' > "$SETTINGS"
+CMD='node "$CLAUDE_PROJECT_DIR/.claude/hooks/agentmap-nudge.mjs"'
+jq --arg cmd "$CMD" '
+  .hooks.PreToolUse = ((.hooks.PreToolUse // []) + [{
+    matcher: "Grep",
+    hooks: [{ type: "command", command: $cmd }]
+  }])
+' "$SETTINGS" > "$SETTINGS.tmp" && mv "$SETTINGS.tmp" "$SETTINGS"
+
+# git post-commit auto-refresh (skip if Husky/core.hooksPath is in use)
+cp "$HOOKS/post-commit" "$ROOT/.git/hooks/post-commit"
+chmod +x "$ROOT/.git/hooks/post-commit"
+
+# Ignore the derived map + first build
+grep -qxF ".claude/agentmap.json" "$ROOT/.gitignore" 2>/dev/null \
+  || echo ".claude/agentmap.json" >> "$ROOT/.gitignore"
+( cd "$ROOT" && { node agentmap.mjs || npx @raymondchins/agentmap; } ) || true
+
+echo "agentmap wired: PreToolUse nudge + post-commit refresh installed."
+```
+
+Run it:
+
+```bash
+sh hooks/install.sh
+```
+
+(The `jq` merge is idempotent-ish but appends — run once. Without `jq`, paste
+the snippet from step 1b by hand.)
+
+---
+
+## How they reinforce each other
+
+1. You commit → **post-commit** rebuilds `.claude/agentmap.json` in the
+   background → the map is always current.
+2. The agent reaches for a who-imports / reuse / `<Component>` grep →
+   **PreToolUse nudge** fires → the agent runs `agentmap --any <query>` and
+   reads the fresh map instead of a slow serial grep.
+
+That loop — fresh map + enforced usage — is the part a static "repo digest"
+tool can't reproduce.

package/hooks/agentmap-nudge.mjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: MIT
+// ============================================================================
+//  agentmap — PreToolUse(Grep) nudge hook
+//
+//  Steers dependency / who-imports / reuse / component-usage greps toward the
+//  agentmap repo-map instead of serial grep. NON-BLOCKING: only ever injects a
+//  reminder via `additionalContext`; never denies the Grep. Exits 0 on every
+//  path. Dependency-free (Node stdlib only) — Claude Code pipes the tool-call
+//  JSON on stdin.
+//
+//  Heuristic: fires when the grep PATTERN looks like (a) a dependency hunt
+//  (import/require/export / "from '..." / who-imports), (b) a component /
+//  "where-is" / reuse lookup (a JSX component tag like <Heading, or where-is /
+//  who-uses / reuse / existing-component intent words). A raw string or
+//  Tailwind-class search (e.g. "bg-white", "text-3xl") and lowercase HTML-tag
+//  sweeps (<div, <h1) produce NO output — no nagging.
+//
+//  agentmap's `--any` router falls back to a live git-grep on its own, so it
+//  still covers the raw-string / copy case — but only when the agent reaches
+//  for it deliberately, not on every content sweep.
+// ============================================================================
+
+let raw = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (c) => (raw += c));
+process.stdin.on("end", () => {
+  try {
+    const payload = JSON.parse(raw || "{}");
+    const ti = payload.tool_input || {};
+    const pattern = String(ti.pattern || "");
+
+    // Defensive guard: pathological-input belt-and-suspenders.
+    // If the pattern is unreasonably long, skip nudging entirely.
+    if (pattern.length > 2000) {
+      process.exit(0);
+    }
+
+    // (a) Dependency / who-imports / reuse intent signals in the pattern itself.
+    const DEP_RE =
+      /\b(import|require\s*\(|imported\s+by|depends|dependents?|dependency)\b|from\s+["']|(^|\|)\s*export\b/i;
+
+    // (b) JSX component open tag in the pattern (PascalCase, e.g. <Heading, <Hero,
+    // <Motion.div). CASE-SENSITIVE on purpose (NO /i flag) — PascalCase-only keeps
+    // raw HTML/content sweeps of <div>/<h1> silent, so it stays high-signal for
+    // "where is this component used/defined".
+    //
+    // Denylist: common TS generic/utility type containers that start with an
+    // uppercase letter but are NOT React components. Without this, a grep for
+    // `<Promise<` or `<Record<string` fires the nudge spuriously.
+    const GENERIC_DENYLIST =
+      /^<(Promise|Array|Map|Set|Record|Partial|Readonly|Pick|Omit|Required|Exclude|Extract|NonNullable|ReturnType|Awaited|Parameters|InstanceType)\b/;
+    const COMPONENT_TAG_RE = /<[A-Z][\w.]*/;
+
+    // (c) Explicit reuse / "where-is" intent words (case-insensitive): "where is",
+    // "who imports/uses/renders", "reuse", "existing/shared util|component|hook|helper",
+    // "is there an existing/shared".
+    const INTENT_RE =
+      /\bwhere\s+is\b|\bwho\s+(imports|uses|renders)\b|\breuse\b|\b(existing|shared)\s+(util|component|hook|helper)\b|\bis\s+there\s+(an?\s+)?(existing|shared)\b/i;
+
+    if (
+      pattern &&
+      (DEP_RE.test(pattern) ||
+        (COMPONENT_TAG_RE.test(pattern) && !GENERIC_DENYLIST.test(pattern)) ||
+        INTENT_RE.test(pattern))
+    ) {
+      const msg =
+        "This Grep looks like a dependency / component / who-imports / reuse search. " +
+        "Use agentmap FIRST — it's faster than serial grep. Easiest: " +
+        "`npx @raymondchins/agentmap --any <query>` (or `node agentmap.mjs --any <query>`) " +
+        "— one command, auto-routes file → symbol → feature → live content. " +
+        "Or be specific: `--relates <path>` (blast radius / who-imports), " +
+        "`--find <symbol>` (reuse-before-rebuild / where a component is defined), " +
+        "`--feature <name>` (files in a feature), `--hubs` (most-imported files). " +
+        "Rebuild the map with `npx @raymondchins/agentmap` (or `node agentmap.mjs`) if it's stale. " +
+        "Only fall back to grep if agentmap doesn't cover it.";
+      process.stdout.write(
+        JSON.stringify({
+          hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            additionalContext: msg,
+          },
+        }),
+      );
+    }
+  } catch {
+    // Never block on parse/other errors — stay silent.
+  }
+  process.exit(0);
+});

package/hooks/post-commit

@@ -0,0 +1,61 @@
+#!/usr/bin/env sh
+# ============================================================================
+#  agentmap — git post-commit hook
+#
+#  Rebuilds .claude/agentmap.json after each commit so the map an agent reads is
+#  never stale. Runs in the background and detached so it never slows the commit.
+#
+#  Guards:
+#   - Skips during rebase / merge / cherry-pick / bisect (avoids rebuilding on
+#     every replayed commit — the map rebuilds once the operation finishes and
+#     you commit normally).
+#   - No-ops cleanly if Node or agentmap.mjs is missing.
+#   - nvm caveat: git hooks run in a non-login shell that does not source nvm
+#     (or ~/.bashrc / ~/.zshrc), so `node` may be absent on PATH. The
+#     `command -v node || exit 0` guard below no-ops cleanly in that case.
+#
+#  Install: copy to .git/hooks/post-commit and `chmod +x` it (see hooks/INSTALL.md).
+# ============================================================================
+
+# Resolve the repo root from the hook's own location (.git/hooks/post-commit).
+ROOT="$(git rev-parse --show-toplevel 2>/dev/null)" || exit 0
+GITDIR="$(git rev-parse --git-dir 2>/dev/null)" || exit 0
+
+# Guard: don't rebuild while a multi-commit operation is replaying commits.
+for state in rebase-merge rebase-apply MERGE_HEAD CHERRY_PICK_HEAD BISECT_LOG REVERT_HEAD; do
+  if [ -e "$GITDIR/$state" ]; then
+    exit 0
+  fi
+done
+
+# Locate the builder: prefer a local agentmap.mjs, else the installed `agentmap`.
+# We cd "$ROOT" before running, so use RELATIVE paths — avoids word-splitting on
+# spaces in the repo path (POSIX sh has no arrays; quoting $RUNNER at invocation
+# would bundle cmd+args into one token and break argument passing).
+RUNNER=""
+if [ -f "$ROOT/agentmap.mjs" ]; then
+  RUNNER="node ./agentmap.mjs"
+elif [ -f "$ROOT/scripts/agentmap.mjs" ]; then
+  RUNNER="node ./scripts/agentmap.mjs"
+elif command -v agentmap >/dev/null 2>&1; then
+  # Bare binary name — the installed binary is named `agentmap` (no scope).
+  RUNNER="agentmap"
+elif command -v npx >/dev/null 2>&1; then
+  # Fetch form MUST use the scoped package name to avoid the unrelated agentmap@0.11.0.
+  RUNNER="npx --no-install @raymondchins/agentmap"
+else
+  exit 0
+fi
+
+# Need Node for the .mjs paths; nvm users may not have it in hook PATH — no-op cleanly.
+case "$RUNNER" in
+  node*) command -v node >/dev/null 2>&1 || exit 0 ;;
+esac
+
+# Rebuild detached + silenced so the commit returns instantly.
+(
+  cd "$ROOT" || exit 0
+  $RUNNER >/dev/null 2>&1
+) &
+
+exit 0

package/mcp.mjs

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: MIT
+// ============================================================================
+//  agentmap — stdio MCP (Model Context Protocol) server.
+//
+//  Exposes the agentmap repo-map as first-class MCP tools so any MCP client
+//  (Cursor, Cline, Claude Desktop, …) can query a TS/JS codebase. Launched by
+//  `agentmap --mcp` (agentmap.mjs dynamically imports this file + calls serve()).
+//
+//  Transport: JSON-RPC 2.0 over newline-delimited JSON on stdin/stdout — the
+//  simplest MCP stdio transport (one JSON object per line each way).
+//
+//  Each tool is implemented by SPAWNING the agentmap CLI in `--json` mode
+//  (`node agentmap.mjs --json <flag> <args…>`), capturing its single-object
+//  stdout, and returning it verbatim. This file depends ONLY on the documented
+//  --json CLI surface — never on agentmap.mjs internals. Node stdlib only.
+// ============================================================================
+import { execFile } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+const PROTOCOL_VERSION = "2024-11-05";
+// agentmap.mjs lives next to this file; run it as a subprocess for every tool.
+const AGENTMAP = fileURLToPath(new URL("./agentmap.mjs", import.meta.url));
+
+// Server version = package.json version (resolve relative to this file, not cwd).
+function pkgVersion() {
+  try {
+    const p = fileURLToPath(new URL("./package.json", import.meta.url));
+    return JSON.parse(readFileSync(p, "utf8")).version || "0.0.0";
+  } catch { return "0.0.0"; }
+}
+
+// ---------------------------------------------------------------------------
+// Tool registry. Each entry: an MCP inputSchema + a fn mapping the call's
+// args → the agentmap CLI argv (always `--json` first so stdout is one object).
+// ---------------------------------------------------------------------------
+const str = (description) => ({ type: "string", description });
+const TOOLS = [
+  {
+    name: "any",
+    description:
+      "Unified router: resolve a query against the repo map (file → symbol → feature) then fall back to a live git-grep for string/copy/data literals. Best default for 'where is X' / reuse-before-rebuild.",
+    inputSchema: { type: "object", properties: { query: str("File path, symbol name, feature name, or any literal string to search for.") }, required: ["query"] },
+    argv: (a) => ["--any", String(a.query ?? "")],
+  },
+  {
+    name: "find",
+    description: "Find every exported symbol whose name matches (substring, case-insensitive). Use to locate a function/class/type before rebuilding it.",
+    inputSchema: { type: "object", properties: { symbol: str("Symbol name or substring to match against exports.") }, required: ["symbol"] },
+    argv: (a) => ["--find", String(a.symbol ?? "")],
+  },
+  {
+    name: "relates",
+    description: "Blast radius for a file: its exports, imports, direct dependents, and the files most related to it by random-walk relevance. Use before editing to see who breaks.",
+    inputSchema: { type: "object", properties: { path: str("File path, basename, or unique substring identifying the target file.") }, required: ["path"] },
+    argv: (a) => ["--relates", String(a.path ?? "")],
+  },
+  {
+    name: "map",
+    description: "Token-budgeted ranked digest of the codebase (PageRank + Aider-style symbol ranking). Optionally focus toward a file and/or set a token budget.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        focus: str("Optional file path/substring to personalize the ranking toward."),
+        tokens: { type: "integer", description: "Optional token budget for the digest (default 8192 global / 1024 focused)." },
+      },
+    },
+    // --map takes optional --focus and --tokens; only pass what's provided.
+    argv: (a) => {
+      const out = ["--map"];
+      if (a.focus != null && String(a.focus) !== "") out.push("--focus", String(a.focus));
+      if (a.tokens != null && Number.isFinite(Number(a.tokens))) out.push("--tokens", String(Math.trunc(Number(a.tokens))));
+      return out;
+    },
+  },
+  {
+    name: "hubs",
+    description: "List the most important files in the repo by PageRank (the hubs everything imports). Read these first to understand a codebase.",
+    inputSchema: { type: "object", properties: {} },
+    argv: () => ["--hubs"],
+  },
+  {
+    name: "features",
+    description: "List every detected feature (top-level app/ route segment) with its file count.",
+    inputSchema: { type: "object", properties: {} },
+    argv: () => ["--features"],
+  },
+  {
+    name: "feature",
+    description: "List all files belonging to a named feature plus its external dependents.",
+    inputSchema: { type: "object", properties: { name: str("Feature name (run the 'features' tool to list them).") }, required: ["name"] },
+    argv: (a) => ["--feature", String(a.name ?? "")],
+  },
+  {
+    name: "symbols",
+    description: "Top N globally ranked symbols (Aider-style importance). Defaults to 30.",
+    inputSchema: { type: "object", properties: { n: { type: "integer", description: "How many symbols to return (default 30)." } } },
+    // --symbols takes an optional positional count.
+    argv: (a) => (a.n != null && Number.isFinite(Number(a.n)) ? ["--symbols", String(Math.trunc(Number(a.n)))] : ["--symbols"]),
+  },
+];
+const TOOL_BY_NAME = new Map(TOOLS.map((t) => [t.name, t]));
+// MCP tools/list wants only the public fields (no internal argv builder).
+const toolList = () => TOOLS.map(({ name, description, inputSchema }) => ({ name, description, inputSchema }));
+
+// Spawn `node agentmap.mjs --json <flag> <args…>` in the client's cwd, resolve
+// with stdout. Rejects (with stderr/message) only on spawn failure; a non-zero
+// exit still resolves so the dispatcher can surface stdout/stderr as isError.
+function runAgentmap(extraArgv) {
+  return new Promise((resolve) => {
+    execFile(
+      process.execPath,
+      [AGENTMAP, "--json", ...extraArgv],
+      { cwd: process.cwd(), maxBuffer: 64 * 1024 * 1024, windowsHide: true },
+      (err, stdout, stderr) => {
+        const code = err && typeof err.code === "number" ? err.code : err ? 1 : 0;
+        resolve({ code, stdout: (stdout || "").trim(), stderr: (stderr || "").trim(), spawnError: err && err.code === undefined ? err.message : "" });
+      },
+    );
+  });
+}
+
+// ---------------------------------------------------------------------------
+// JSON-RPC plumbing. Write one compact JSON object per line to stdout.
+// ---------------------------------------------------------------------------
+function send(obj) { process.stdout.write(JSON.stringify(obj) + "\n"); }
+const result = (id, r) => send({ jsonrpc: "2.0", id, result: r });
+const error = (id, code, message) => send({ jsonrpc: "2.0", id, error: { code, message } });
+
+// Dispatch a tools/call: build argv, run the CLI, wrap stdout as MCP content.
+async function callTool(name, rawArgs) {
+  const tool = TOOL_BY_NAME.get(name);
+  if (!tool) return { content: [{ type: "text", text: `unknown tool: ${name}` }], isError: true };
+  const argv = tool.argv(rawArgs && typeof rawArgs === "object" ? rawArgs : {});
+  const { code, stdout, stderr, spawnError } = await runAgentmap(argv);
+  if (spawnError) return { content: [{ type: "text", text: `failed to launch agentmap: ${spawnError}` }], isError: true };
+  // Exit 1 = query returned zero results (a valid answer, not a tool failure):
+  // surface stdout when present, else a friendly empty note. Exit ≥2 = real
+  // error → mark isError and prefer stderr.
+  if (code >= 2) return { content: [{ type: "text", text: stderr || stdout || `agentmap exited ${code}` }], isError: true };
+  const text = stdout || (code === 1 ? `no results` : stderr) || "";
+  return { content: [{ type: "text", text }] };
+}
+
+// Handle one parsed JSON-RPC request object. Notifications (no `id`) get no
+// reply per the spec; everything else returns a result or an error.
+async function handle(msg) {
+  const { id, method, params } = msg || {};
+  const isNotification = id === undefined || id === null;
+  switch (method) {
+    case "initialize":
+      return result(id, { protocolVersion: PROTOCOL_VERSION, capabilities: { tools: {} }, serverInfo: { name: "agentmap", version: pkgVersion() } });
+    case "notifications/initialized":
+    case "initialized":
+      return; // notification — no response
+    case "ping":
+      return result(id, {});
+    case "tools/list":
+      return result(id, { tools: toolList() });
+    case "tools/call": {
+      const name = params && params.name;
+      const out = await callTool(name, params && params.arguments);
+      return result(id, out);
+    }
+    default:
+      if (isNotification) return; // ignore unknown notifications silently
+      return error(id, -32601, `method not found: ${method}`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// serve() — read newline-delimited JSON from stdin, dispatch each complete
+// line. Never crash on a malformed line: reply with a JSON-RPC parse error
+// (-32700) when we can, otherwise skip it. Lines are processed sequentially so
+// responses stay ordered.
+// ---------------------------------------------------------------------------
+export async function serve() {
+  process.stdin.setEncoding("utf8");
+  let buf = "";
+  let chain = Promise.resolve(); // serialize handling so output order is stable
+
+  process.stdin.on("data", (chunk) => {
+    buf += chunk;
+    let nl;
+    while ((nl = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, nl).replace(/\r$/, "").trim();
+      buf = buf.slice(nl + 1);
+      if (!line) continue;
+      let msg;
+      try { msg = JSON.parse(line); }
+      catch { error(null, -32700, "parse error"); continue; }
+      // batch requests (array) are valid JSON-RPC — handle each element
+      const msgs = Array.isArray(msg) ? msg : [msg];
+      for (const m of msgs) chain = chain.then(() => handle(m)).catch((e) => error(m && m.id != null ? m.id : null, -32603, String(e && e.message || e)));
+    }
+  });
+  // keep the process alive until stdin closes
+  await new Promise((resolve) => process.stdin.on("end", resolve));
+  await chain;
+}
+
+// Run directly (`node mcp.mjs`) as well as when imported + invoked via --mcp.
+if (import.meta.url === `file://${process.argv[1]}` || (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1])) {
+  serve();
+}

package/package.json

@@ -1,20 +1,24 @@
 {
   "name": "@raymondchins/agentmap",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "publishConfig": {
     "access": "public"
   },
-  "description": "The repo map your coding agent is forced to use. A queryable, ranked ts-morph code-relationship map for TypeScript/JavaScript repos — PageRank hubs, Aider-style symbol ranking, a token-budgeted digest, and a single --any router (file → symbol → feature → live git-grep), wired into the agent loop via post-commit auto-refresh and a PreToolUse hook.",
+  "description": "The repo map your coding agent is forced to use — ~98% fewer tokens (up to 99.9% per task) to understand a TS/JS codebase. A queryable, ranked ts-morph code-relationship map: PageRank hubs, Aider-style symbol ranking, a token-budgeted digest, and a single --any router (file → symbol → feature → live git-grep), wired into the agent loop via post-commit auto-refresh and a PreToolUse hook.",
   "type": "module",
   "bin": {
-    "agentmap": "./repomap.mjs"
+    "agentmap": "agentmap.mjs"
   },
-  "main": "repomap.mjs",
+  "main": "agentmap.mjs",
   "files": [
-    "repomap.mjs"
+    "agentmap.mjs",
+    "mcp.mjs",
+    "hooks",
+    "NOTICE"
   ],
   "scripts": {
-    "map": "node repomap.mjs"
+    "map": "node agentmap.mjs",
+    "test": "node --test test/*.test.mjs"
   },
   "engines": {
     "node": ">=18"
@@ -23,6 +27,7 @@
     "ts-morph": "28.0.0"
   },
   "keywords": [
+    "agentmap",
     "repo-map",
     "repomap",
     "code-map",