@raymondchins/agentmap 0.4.0 → 0.6.0

package/agentmap.mjs

@@ -17,6 +17,9 @@ import { writeFileSync, readFileSync, existsSync, mkdirSync, renameSync, readdir
 import { execSync, execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { join, dirname } from "node:path";
 
 // Lazy ts-morph: its ~105ms module init only fires on a COLD rebuild. Warm cache
 // queries (the common case) never construct a Project, so they skip the load
@@ -28,7 +31,10 @@ const tsMorph = () => (_tsm ??= _require("ts-morph"));
 
 const MAP = ".claude/agentmap/map.json";
 const MAP_LEGACY = ".claude/agentmap.json"; // pre-namespacing path; read for migration
-const SCHEMA_VERSION = 2;
+// Bumped 2 → 3: Vue SFC support. `.vue` files now appear in the map and the
+// source-discovery / freshness checks treat them as first-class source files.
+// Old caches (schema 2) are ignored so the first run after upgrade rebuilds.
+const SCHEMA_VERSION = 3;
 
 // ---------------------------------------------------------------------------
 // Tuning constants — KEEP THESE VALUES IDENTICAL (output + marketing must not
@@ -85,7 +91,7 @@ const dirtyCount = () =>
     let p = l.slice(3);                                  // strip "XY " status prefix
     if (p.includes(" -> ")) p = p.split(" -> ").pop();   // rename: keep the new path
     p = p.replace(/^"|"$/g, "");                         // unquote space/special paths
-    return /\.(ts|tsx|mjs|cjs|jsx|js)$/.test(p);
+    return /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs|vue)$/.test(p);
   }).length;
 const tokEst = (s) => Math.ceil((s || "").length / 4); // rough chars/4 estimate
 
@@ -96,7 +102,8 @@ const getOrSet = (m, k, make) => { let v = m.get(k); if (v === undefined) { v =
 // "path:mtimeMs:size" for source files so the cache can be trusted between runs
 // without a full reparse. Skips node_modules/.git/.next. Any error ⇒ "" (caller
 // falls through to build, i.e. current behavior). Never used on the git path.
-const SRC_EXT = /\.(ts|tsx|mts|cts|jsx|js|mjs|cjs)$/;
+// Includes `.vue` so editing a Vue SFC invalidates the non-git cache too.
+const SRC_EXT = /\.(ts|tsx|mts|cts|jsx|js|mjs|cjs|vue)$/;
 function sourceFingerprint() {
   try {
     const entries = [];
@@ -121,6 +128,70 @@ function sourceFingerprint() {
   } catch { return ""; }
 }
 
+// =============================================================================
+// Vue Single File Component support — best-effort, zero-dependency.
+//
+// agentmap is TS/JS-first. Vue `.vue` SFCs are NOT TypeScript; the Vue compiler
+// (`@vue/compiler-sfc`) is intentionally NOT a dependency (CONTRIBUTING near-
+// zero-deps rule). Instead we extract ONLY the `<script>` / `<script setup>`
+// block text with a conservative regex and feed it to ts-morph as a VIRTUAL
+// source file (e.g. `App.vue.ts`). A virtual→real path map (see build())
+// rewrites every user-facing path back to the real `.vue` path so no
+// `.vue.ts` / `.vue.js` ever leaks into JSON or prose.
+//
+// Non-goals: no template AST, no `<style>` parsing, no Nuxt auto-import
+// resolution, no Svelte/Astro. Only `<script>` blocks that look like JS/TS.
+// =============================================================================
+
+// Find the first top-level `<script ...>` block (optionally `<script setup ...>`)
+// whose opening tag does NOT carry `src="..."` (external script reference —
+// the actual JS lives in another file agentmap already indexes on its own).
+// Handles single + double quoted lang/src attributes and `lang="ts"`/`ts`.
+// Returns { lang, setup, text } for the matched block, or null if none.
+//
+// Greedy-free: stops at the FIRST `</script>` on its own. Vue forbids nested
+// `<script>` tags, so a non-greedy match up to `</script>` is safe. We do NOT
+// support `<script>` + `<script setup>` in the same SFC for indexing — we pick
+// the richer one: prefer `setup` block if present, else the normal block.
+function extractVueScripts(text) {
+  const blocks = [];
+  // Open-tag matcher is QUOTE-AWARE: attribute values may legitimately contain
+  // `>` (e.g. `<script setup lang="ts" generic="T extends Record<string, unknown>">`
+  // — a common Vue 3 idiom for typed generic components). We require all
+  // attributes to be either bare (`setup`) or quoted (`name="value"` or
+  // `name='value'`), which matches valid SFC syntax. Bareword and unquoted forms
+  // are intentionally not matched because they're not valid HTML and would
+  // almost certainly indicate a parsing bug we want to surface, not silently
+  // misparse.
+  const re = /<script(\s+[a-zA-Z][\w-]*(\s*=\s*(?:"[^"]*"|'[^']*'))?)*\s*\/?>/gi;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    const attrs = (m[0].slice(7, -1) || "").trim(); // strip <script…> wrapper
+    // find body: text after the opening tag up to </script>
+    const openEnd = m.index + m[0].length;
+    const closeStart = text.toLowerCase().indexOf("</script>", openEnd);
+    if (closeStart === -1) break; // unterminated — stop scanning
+    const body = text.slice(openEnd, closeStart);
+    // external script reference → skip (the target file is indexed directly).
+    if (/\bsrc\s*=\s*["'][^"']+["']/i.test(attrs)) continue;
+    if (!body.trim()) continue; // empty body (e.g. <script/>) — not useful
+    const setup = /\bsetup\b/i.test(attrs);
+    const lang = (attrs.match(/\blang\s*=\s*["']([^"']+)["']/i) || [])[1] || "js";
+    blocks.push({ lang: lang.toLowerCase(), setup, text: body });
+    re.lastIndex = closeStart + "</script>".length; // resume after </script>
+  }
+  if (!blocks.length) return null;
+  // Prefer a setup block (the modern idiom) when present; else the plain block.
+  return blocks.find((b) => b.setup) || blocks[0];
+}
+
+// Virtual file path mapping for a `.vue` source. The virtual path is what
+// ts-morph sees (so `.ts`/`.js` parsing kicks in); the real path is what every
+// user-facing output shows. `lang="ts"` → `.vue.ts`, otherwise `.vue.js`.
+function vueVirtualPath(realPath, lang) {
+  return lang === "ts" ? `${realPath}.ts` : `${realPath}.js`;
+}
+
 // Feature = first real route segment under app/ (or src/app/), skipping route
 // groups (parens), dynamic segments ([id]) and parallel routes (@slot).
 function featureOf(path) {
@@ -246,13 +317,25 @@ function makeProject() {
   const loaded = new Set(project.getSourceFiles().map((s) => s.getFilePath()));
   const cwdp = process.cwd().replace(/\\/g, "/");
   const listed = sh("git ls-files --cached --others --exclude-standard").split("\n").filter(Boolean);
+  // `.vue` discovery: same channel as TS/JS (git ls-files when available, else
+  // a broad glob fallback). We do NOT hand `.vue` straight to ts-morph (it is
+  // not TS/JS). Instead, for each `.vue` file we read its `<script>` block via
+  // extractVueScripts() and register it as a VIRTUAL source file
+  // (`App.vue.ts` / `App.vue.js`). A virtual→real path map is returned alongside
+  // the project so build() can rewrite every user-facing path back to `.vue`.
+  const vueFiles = [];
   if (listed.length) {
     const missing = [];
     for (const f of listed) {
-      if (!/\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/.test(f)) continue;
-      const segs = f.split("/");
-      if (segs.includes("node_modules") || segs.includes(".next")) continue;
-      if (!loaded.has(`${cwdp}/${f}`)) missing.push(f);
+      if (/\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/.test(f)) {
+        const segs = f.split("/");
+        if (segs.includes("node_modules") || segs.includes(".next")) continue;
+        if (!loaded.has(`${cwdp}/${f}`)) missing.push(f);
+      } else if (f.endsWith(".vue")) {
+        const segs = f.split("/");
+        if (segs.includes("node_modules") || segs.includes(".next")) continue;
+        vueFiles.push(f);
+      }
     }
     if (missing.length) project.addSourceFilesAtPaths(missing);
   } else {
@@ -262,8 +345,38 @@ function makeProject() {
       "components/**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}", "lib/**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}",
       "pages/**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}", "*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}",
     ]);
+    // Non-git `.vue` fallback: walk the tree like sourceFingerprint() does.
+    try {
+      const walk = (dir) => {
+        for (const name of readdirSync(dir)) {
+          if (name === "node_modules" || name === ".git" || name === ".next") continue;
+          const full = dir + "/" + name;
+          // lstatSync (NOT statSync) + skip symlinks, matching sourceFingerprint():
+          // a circular symlink would otherwise recurse until the stack overflows.
+          let st; try { st = lstatSync(full); } catch { continue; }
+          if (st.isSymbolicLink()) continue;
+          if (st.isDirectory()) walk(full);
+          else if (name.endsWith(".vue")) vueFiles.push(full.replace(/^\.\//, ""));
+        }
+      };
+      walk(".");
+    } catch { /* ignore — proceed without Vue */ }
   }
-  return project;
+  // Build the virtual→real map and register each `<script>` block as a virtual
+  // ts-morph source. Files without a usable `<script>` block are silently
+  // skipped (template/style-only SFCs contribute nothing to the import graph).
+  const vueMap = Object.create(null); // virtualPath → realPath
+  const vueReal = Object.create(null); // realPath → true (for resolver)
+  for (const f of vueFiles) {
+    let text; try { text = readFileSync(f, "utf8"); } catch { continue; }
+    const block = extractVueScripts(text);
+    if (!block || !block.text.trim()) continue;
+    const vpath = vueVirtualPath(f, block.lang);
+    project.createSourceFile(`${cwdp}/${vpath}`, block.text, { overwrite: true });
+    vueMap[`${cwdp}/${vpath}`] = `${cwdp}/${f}`;
+    vueReal[`${cwdp}/${f}`] = true;
+  }
+  return { project, vueMap, vueReal };
 }
 
 // ---------------------------------------------------------------------------
@@ -273,11 +386,18 @@ function makeProject() {
 // ---------------------------------------------------------------------------
 function build() {
   const t0 = Date.now();
-  const project = makeProject();
+  const { project, vueMap, vueReal } = makeProject();
   const { SyntaxKind } = tsMorph();
   const CallExpression = SyntaxKind.CallExpression;
   const cwd = process.cwd().replace(/\\/g, "/");
-  const rel = (p) => p.replace(cwd + "/", "");
+  // rel() rewrites ts-morph file paths to repo-relative keys. For Vue virtual
+  // sources (`App.vue.ts`), vueMap rewrites back to the real `.vue` path so
+  // users never see virtual paths in the map, hubs, --relates, or --find.
+  const rel = (p) => {
+    const abs = p.replace(/\\/g, "/");
+    const real = vueMap[abs];
+    return (real || abs).replace(cwd + "/", "");
+  };
   const files = {}, dependents = {}, features = {};
   // PATH-SEGMENT exclusion (not substring) so e.g. components/.next-demo or
   // src/node_modules_helper.ts are NOT wrongly excluded.
@@ -298,10 +418,19 @@ function build() {
     };
     const baseAbs = join(fromAbsDir, spec);
     const tryGet = (abs) => { const sf = project.getSourceFile(abs); return sf ? sf : null; };
+    // Vue SFC: `import X from "./C.vue"` (exact) ALWAYS wins — the user wrote
+    // `.vue` explicitly, so we honor that. This check must stay BEFORE the
+    // TS/JS loop.
+    if (vueReal[baseAbs]) return rel(baseAbs);
     let sf = tryGet(baseAbs);
     if (!sf) for (const e of RES_EXT) { sf = tryGet(`${baseAbs}.${e}`); if (sf) break; }
     if (!sf) for (const e of RES_EXT) { sf = tryGet(`${baseAbs}/index.${e}`); if (sf) break; }
-    return sf ? rel(sf.getFilePath()) : null;
+    // TS/JS SHADOW WINS: when a same-name .ts/.js exists, the extensionless
+    // `import "./C"` resolves to it (TS/JS-first priority is preserved). Only
+    // fall through to `.vue` as a last resort, when no TS/JS shadow exists.
+    if (sf) return rel(sf.getFilePath());
+    if (vueReal[`${baseAbs}.vue`]) return rel(`${baseAbs}.vue`);
+    return null;
   };
 
   const sourceFiles = project.getSourceFiles();
@@ -598,7 +727,7 @@ function parseSettings(text, settingsPath) {
   try { return JSON.parse(text) || {}; }
   catch {
     try { return JSON.parse(stripJsonComments(text)) || {}; }
-    catch { throw new Error(`${settingsPath} is not valid JSON — fix or remove it, then re-run --install-hooks`); }
+    catch { throw new Error(`${settingsPath} is not valid JSON — fix or remove it, then re-run`); }
   }
 }
 
@@ -717,6 +846,65 @@ function installHooks({ dryRun = false } = {}) {
   console.log("\nDone — the map auto-refreshes on commit, and greps are nudged to agentmap first.");
 }
 
+// ---------------------------------------------------------------------------
+// --setup-mcp: register the agentmap MCP server in the global configs of
+// MCP-capable IDEs that aren't Claude Code (which uses --install-hooks instead).
+// Merge-safe + idempotent; with { dryRun:true } it prints the plan and writes
+// nothing. Throws on the first malformed config so the caller can stderr+exit 1.
+// ---------------------------------------------------------------------------
+function setupMcp({ dryRun = false } = {}) {
+  const mcpPath = fileURLToPath(new URL("./mcp.mjs", import.meta.url));
+
+  // npx materializes the package under a `_npx` cache dir that gets garbage-
+  // collected, so a config pointing at that path would rot. When invoked via npx,
+  // pin to the published spec instead; otherwise reference the resolved file.
+  const isNpx = mcpPath.includes("_npx");
+  const command = isNpx ? "npx" : process.execPath;
+  const args = isNpx ? ["-y", "@raymondchins/agentmap", "--mcp"] : [mcpPath];
+
+  // Each target: a global config file + how to graft the agentmap entry into it.
+  // Antigravity is written to BOTH paths on purpose — older builds read only the
+  // IDE-specific ~/.gemini/antigravity path, newer unified builds read the shared
+  // ~/.gemini/config path, so writing both is version-proof.
+  const targets = [
+    {
+      label: "OpenCode",
+      path: join(homedir(), ".config", "opencode", "opencode.json"),
+      graft: (cfg) => { (cfg.mcp ??= {}).agentmap = { type: "stdio", command, args, enabled: true }; },
+    },
+    {
+      label: "Antigravity IDE",
+      path: join(homedir(), ".gemini", "antigravity", "mcp_config.json"),
+      graft: (cfg) => { (cfg.mcpServers ??= {}).agentmap = { command, args }; },
+    },
+    {
+      label: "Antigravity (shared)",
+      path: join(homedir(), ".gemini", "config", "mcp_config.json"),
+      graft: (cfg) => { (cfg.mcpServers ??= {}).agentmap = { command, args }; },
+    },
+  ];
+
+  if (dryRun) console.log("--dry-run: would configure MCP server (no changes written):");
+
+  for (const { label, path, graft } of targets) {
+    // Reuse parseSettings so JSONC (comments) is tolerated and a malformed file
+    // throws a clear error WITHOUT clobbering the original (we never write on the
+    // failure path, so no .bak dance is needed).
+    let cfg = {};
+    if (existsSync(path)) cfg = parseSettings(readFileSync(path, "utf8"), path);
+    graft(cfg);
+
+    if (dryRun) {
+      console.log(`  ${label}: would write to ${path}`);
+    } else {
+      mkdirSync(dirname(path), { recursive: true });
+      writeFileSync(path, JSON.stringify(cfg, null, 2) + "\n");
+      console.log(`configured ${label} MCP server → ${path}`);
+    }
+  }
+}
+
+
 // ---------------------------------------------------------------------------
 // CLI
 // ---------------------------------------------------------------------------
@@ -739,7 +927,7 @@ const out = (obj, prose) => { if (wantJson) console.log(JSON.stringify(obj)); el
 // NOT in this set is an unknown flag → usage error (exit 2), not a silent build.
 const KNOWN = new Set([
   "--json", "--print",
-  "--help", "-h", "--version", "-v", "--install-hooks", "--dry-run", "--mcp",
+  "--help", "-h", "--version", "-v", "--install-hooks", "--dry-run", "--setup-mcp", "--mcp",
   "--any", "--find", "--relates", "--map", "--focus", "--tokens",
   "--symbols", "--feature", "--features", "--hubs",
 ]);
@@ -776,6 +964,9 @@ Maintenance:
   --install-hooks [--dry-run]
                        install git post-commit + copy the PreToolUse nudge +
                        wire .claude/settings.json (--dry-run = preview, no writes)
+  --setup-mcp [--dry-run]
+                       configure MCP server for OpenCode & Antigravity IDE
+                       (--dry-run = preview, no writes)
   --mcp                start a stdio MCP server (for MCP-capable agents)
   --help, -h           show this help
   --version, -v        print the version
@@ -811,6 +1002,11 @@ else if (has("--install-hooks")) {
   try { installHooks({ dryRun: has("--dry-run") }); process.exit(0); }
   catch (e) { console.error(`agentmap --install-hooks failed: ${e?.message || e}`); process.exit(1); }
 }
+// --setup-mcp: configure MCP server for OpenCode & Antigravity IDE.
+else if (has("--setup-mcp")) {
+  try { setupMcp({ dryRun: has("--dry-run") }); process.exit(0); }
+  catch (e) { console.error(`agentmap --setup-mcp failed: ${e?.message || e}`); process.exit(1); }
+}
 // Unknown-flag guard: any "-"-prefixed token not in KNOWN → usage error (exit
 // 2). Runs BEFORE the bare-build fallthrough so a typo never silently rebuilds.
 // Bare invocation with NO flags still builds (handled in the final else).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raymondchins/agentmap",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "publishConfig": {
     "access": "public"
   },
@@ -18,7 +18,7 @@
   ],
   "scripts": {
     "map": "node agentmap.mjs",
-    "test": "node --test test/*.test.mjs",
+    "test": "node --test test/*.test.mjs test/**/*.test.mjs",
     "eval": "node eval/eval.mjs"
   },
   "engines": {