mcp-server-nuxt 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,2151 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { resolve } from "path";
+
+// src/context.ts
+import path5 from "path";
+import { promises as fs5 } from "fs";
+
+// src/utils/config-reader.ts
+import { promises as fs, existsSync, statSync } from "fs";
+import path from "path";
+var CONFIG_FILENAMES = [
+  "nuxt.config.ts",
+  "nuxt.config.js",
+  "nuxt.config.mts",
+  "nuxt.config.mjs",
+  "nuxt.config.cjs"
+];
+function detectProjectRoot(start = process.cwd()) {
+  let current = path.resolve(start);
+  try {
+    if (statSync(current).isFile()) return path.dirname(current);
+  } catch {
+  }
+  for (; ; ) {
+    if (hasConfigFile(current)) return current;
+    const parent = path.dirname(current);
+    if (parent === current) return path.resolve(start);
+    current = parent;
+  }
+}
+function findConfigFile(root) {
+  for (const name of CONFIG_FILENAMES) {
+    const full = path.join(root, name);
+    if (existsSync(full)) return full;
+  }
+  return null;
+}
+function hasConfigFile(root) {
+  return findConfigFile(root) !== null;
+}
+async function loadNuxtConfig(projectRoot) {
+  const configPath = findConfigFile(projectRoot);
+  if (!configPath) {
+    return {
+      value: {},
+      source: null,
+      configPath: null,
+      sourceKind: "none",
+      error: `No nuxt.config file found in ${projectRoot}`
+    };
+  }
+  let source = null;
+  try {
+    source = await fs.readFile(configPath, "utf8");
+  } catch {
+  }
+  try {
+    const kit = await import("@nuxt/kit");
+    if (typeof kit.loadNuxtConfig === "function") {
+      const value = await kit.loadNuxtConfig({
+        rootDir: projectRoot,
+        overrides: { _mcpServerNuxt: true }
+      });
+      return {
+        value: stripInternalKeys(value),
+        source,
+        configPath,
+        sourceKind: "resolved"
+      };
+    }
+  } catch (err) {
+  }
+  try {
+    const value = parseConfigSource(source ?? "");
+    return {
+      value,
+      source,
+      configPath,
+      sourceKind: value && Object.keys(value).length > 0 ? "parsed" : "raw"
+    };
+  } catch (err) {
+    return {
+      value: {},
+      source,
+      configPath,
+      sourceKind: "raw",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function stripInternalKeys(value) {
+  const out = {};
+  for (const [key, v] of Object.entries(value)) {
+    if (key.startsWith("_") || key === "$schema") continue;
+    out[key] = v;
+  }
+  return out;
+}
+function parseConfigSource(source) {
+  const result = {};
+  const body = extractConfigBody(source);
+  if (!body) return result;
+  const assignments = splitTopLevel(body);
+  for (const assignment of assignments) {
+    const match = assignment.match(/^[\s,;]*["']?([\w$.-]+)["']?\s*[:=]\s*([\s\S]*)$/);
+    if (!match) continue;
+    const key = match[1];
+    const rawValue = match[2].trim().replace(/[,;]\s*$/, "");
+    result[key] = tryParseValue(rawValue);
+  }
+  return result;
+}
+function extractConfigBody(source) {
+  const defMatch = source.match(/defineNuxtConfig\s*\(\s*(\{)/);
+  let startIndex = defMatch ? source.indexOf("{", defMatch.index ?? 0) : -1;
+  if (startIndex === -1) {
+    const expMatch = source.match(/export\s+default\s+(\{)/);
+    startIndex = expMatch ? source.indexOf("{", expMatch.index ?? 0) : -1;
+  }
+  if (startIndex === -1) return null;
+  let depth = 0;
+  let inString = null;
+  let inTemplate = false;
+  let inComment = null;
+  for (let i = startIndex; i < source.length; i++) {
+    const ch = source[i];
+    const prev = i > 0 ? source[i - 1] : "";
+    if (inComment === "line") {
+      if (ch === "\n") inComment = null;
+      continue;
+    }
+    if (inComment === "block") {
+      if (ch === "*" && source[i + 1] === "/") {
+        inComment = null;
+        i++;
+      }
+      continue;
+    }
+    if (inString) {
+      if (ch === "\\") {
+        i++;
+        continue;
+      }
+      if (ch === inString) inString = null;
+      continue;
+    }
+    if (inTemplate) {
+      if (ch === "\\") {
+        i++;
+        continue;
+      }
+      if (ch === "`") inTemplate = false;
+      continue;
+    }
+    if (ch === "/" && source[i + 1] === "/") {
+      inComment = "line";
+      i++;
+      continue;
+    }
+    if (ch === "/" && source[i + 1] === "*") {
+      inComment = "block";
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inString = ch;
+      continue;
+    }
+    if (ch === "`") {
+      inTemplate = true;
+      continue;
+    }
+    if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) return source.slice(startIndex + 1, i);
+    }
+  }
+  return null;
+}
+function splitTopLevel(body) {
+  const parts = [];
+  let depth = 0;
+  let current = "";
+  let inString = null;
+  let inTemplate = false;
+  for (let i = 0; i < body.length; i++) {
+    const ch = body[i];
+    if (inString) {
+      current += ch;
+      if (ch === "\\") {
+        current += body[i + 1] ?? "";
+        i++;
+      } else if (ch === inString) inString = null;
+      continue;
+    }
+    if (inTemplate) {
+      current += ch;
+      if (ch === "\\") {
+        current += body[i + 1] ?? "";
+        i++;
+      } else if (ch === "`") inTemplate = false;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inString = ch;
+      current += ch;
+      continue;
+    }
+    if (ch === "`") {
+      inTemplate = true;
+      current += ch;
+      continue;
+    }
+    if (ch === "{" || ch === "[" || ch === "(") depth++;
+    else if (ch === "}" || ch === "]" || ch === ")") depth--;
+    if (ch === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) parts.push(current);
+  return parts;
+}
+function tryParseValue(raw) {
+  const trimmed = raw.trim();
+  if (trimmed === "") return void 0;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+  }
+  const strMatch = trimmed.match(/^(["'])([\s\S]*)\1$/);
+  if (strMatch) return strMatch[2];
+  const arrMatch = trimmed.match(/^\[([\s\S]*)\]$/);
+  if (arrMatch && !trimmed.includes("=>")) {
+    const items = splitTopLevel(arrMatch[1]).map((i) => i.trim()).filter(Boolean).map((i) => tryParseValue(i.replace(/^,/, "").trim()));
+    return items;
+  }
+  return { __raw: trimmed };
+}
+function getConfigValue(config, key) {
+  if (!key || key === "") return config;
+  const parts = key.split(".");
+  let current = config;
+  for (const part of parts) {
+    if (current === null || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function serializeValue(value, indent = 0) {
+  if (value === void 0) return "undefined";
+  if (value === null) return "null";
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (typeof value === "function") return String(value);
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    const pad = " ".repeat(indent + 2);
+    const inner = value.map((v) => pad + serializeValue(v, indent + 2)).join(",\n");
+    return `[
+${inner},
+${" ".repeat(indent)}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0) return "{}";
+    const pad = " ".repeat(indent + 2);
+    const inner = entries.map(([k, v]) => `${pad}${JSON.stringify(k)}: ${serializeValue(v, indent + 2)}`).join(",\n");
+    return `{
+${inner},
+${" ".repeat(indent)}}`;
+  }
+  return String(value);
+}
+function setConfigValue(source, key, value, rawValue) {
+  const body = extractConfigBody(source);
+  if (!body) throw new Error("Could not locate defineNuxtConfig({...}) in nuxt.config");
+  const expression = rawValue ?? serializeValue(value);
+  const parts = key.split(".");
+  const topKey = parts[0];
+  const existing = findTopLevelAssignment(body, topKey);
+  let newBody;
+  if (!existing) {
+    newBody = insertBeforeClosing(body, `${topKey}: ${expression},`);
+  } else if (parts.length === 1) {
+    newBody = body.replace(existing.fullMatch, `${topKey}: ${expression}`);
+  } else {
+    const nested = setNestedKey(existing.value, parts.slice(1), value, rawValue);
+    newBody = body.replace(existing.fullMatch, `${topKey}: ${nested}`);
+  }
+  const newSource = replaceConfigBody(source, body, newBody);
+  const diff = createDiff(source, newSource);
+  return { newSource, diff };
+}
+function appendModule(source, name, options) {
+  const body = extractConfigBody(source);
+  if (!body) throw new Error("Could not locate defineNuxtConfig({...}) in nuxt.config");
+  const entry = options === void 0 ? JSON.stringify(name) : `[${JSON.stringify(name)}, ${serializeValue(options)}]`;
+  const existing = findTopLevelAssignment(body, "modules");
+  let newBody;
+  if (existing) {
+    const trimmed = existing.value.trim();
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      const inner = trimmed.slice(1, -1).trim();
+      newBody = body.replace(existing.fullMatch, `modules: [${inner ? `${inner}, ${entry}` : entry}]`);
+    } else {
+      newBody = body.replace(existing.fullMatch, `modules: [${entry}]`);
+    }
+  } else {
+    newBody = insertBeforeClosing(body, `modules: [${entry}],`);
+  }
+  const newSource = replaceConfigBody(source, body, newBody);
+  const diff = createDiff(source, newSource);
+  return { newSource, diff };
+}
+function findTopLevelAssignment(body, key) {
+  const assignments = splitTopLevel(body);
+  for (const assignment of assignments) {
+    const match = assignment.match(/^([\s]*)(["']?)([\w$.-]+)\2\s*:\s*([\s\S]*)$/);
+    if (!match) continue;
+    if (match[3] === key) {
+      return { fullMatch: assignment.trim(), value: match[4].trim() };
+    }
+  }
+  return null;
+}
+function insertBeforeClosing(body, line) {
+  const indent = detectIndent(body);
+  const trimmed = body.replace(/\s+$/, "");
+  return `${trimmed}
+${indent}${line}
+`;
+}
+function detectIndent(body) {
+  const lines = body.split("\n");
+  const lastNonEmpty = [...lines].reverse().find((l) => l.trim() !== "") ?? "";
+  return lastNonEmpty.match(/^\s*/)?.[0] ?? "";
+}
+function setNestedKey(valueText, parts, value, rawValue) {
+  const expression = rawValue ?? serializeValue(value);
+  const objMatch = valueText.match(/^\{([\s\S]*)\}$/);
+  if (!objMatch) {
+    return `{ ${parts[0]}: ${expression} }`;
+  }
+  const inner = objMatch[1];
+  const existing = findTopLevelAssignment(inner, parts[0]);
+  if (!existing) {
+    return `{${inner}
+  ${parts[0]}: ${expression},
+}`;
+  }
+  if (parts.length === 1) {
+    return `{${inner.replace(existing.fullMatch, `${parts[0]}: ${expression}`)}}`;
+  }
+  return `{${inner.replace(
+    existing.fullMatch,
+    `${parts[0]}: ${setNestedKey(existing.value, parts.slice(1), value, rawValue)}`
+  )}}`;
+}
+function replaceConfigBody(source, oldBody, newBody) {
+  const idx = source.indexOf(oldBody);
+  if (idx === -1) return source;
+  return source.slice(0, idx) + newBody + source.slice(idx + oldBody.length);
+}
+function createDiff(before, after) {
+  const beforeLines = before.split("\n");
+  const afterLines = after.split("\n");
+  const lines = [];
+  const maxLen = Math.max(beforeLines.length, afterLines.length);
+  let context = [];
+  for (let i = 0; i < maxLen; i++) {
+    const b = beforeLines[i];
+    const a = afterLines[i];
+    if (b === a) {
+      if (context.length) {
+        lines.push(...context.map((c) => `  ${c.text}`));
+        context = [];
+      }
+      lines.push(`  ${b ?? ""}`);
+    } else {
+      if (context.length === 0) lines.push("---");
+      if (b !== void 0) context.push({ b: i, a: -1, text: `- ${b}` });
+      if (a !== void 0) context.push({ b: -1, a: i, text: `+ ${a}` });
+    }
+  }
+  if (context.length) lines.push(...context.map((c) => `  ${c.text}`));
+  return lines.join("\n") || "(no changes)";
+}
+
+// src/utils/nuxt-parser.ts
+import { promises as fs2 } from "fs";
+import path2 from "path";
+import fg from "fast-glob";
+var DEFAULT_IGNORE = ["**/node_modules/**", "**/.nuxt/**", "**/.output/**", "**/dist/**", "**/.git/**"];
+var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".vue",
+  ".ts",
+  ".js",
+  ".mts",
+  ".mjs",
+  ".cts",
+  ".cjs",
+  ".tsx",
+  ".jsx",
+  ".json",
+  ".md",
+  ".mdx",
+  ".css",
+  ".scss",
+  ".html",
+  ".yml",
+  ".yaml"
+]);
+async function findFiles(root, patterns, extraIgnore = []) {
+  const files = await fg(patterns, {
+    cwd: root,
+    absolute: true,
+    onlyFiles: true,
+    dot: false,
+    ignore: [...DEFAULT_IGNORE, ...extraIgnore]
+  });
+  return files.sort();
+}
+function relativePath(root, file) {
+  const rel = path2.relative(root, file);
+  return rel.split(path2.sep).join("/");
+}
+async function readIfExists(file) {
+  try {
+    return await fs2.readFile(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function exists(file) {
+  try {
+    await fs2.access(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pascalCase(segment) {
+  return segment.replace(/\.(vue|ts|js|mts|mjs|tsx|jsx)$/, "").split(/[-_.\s]+/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+function camelCase(segment) {
+  return segment.replace(/\.(ts|js|mts|mjs)$/, "").split(/[-_.\s]+/).filter(Boolean).map((word, i) => i === 0 ? word.charAt(0).toLowerCase() + word.slice(1) : word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+function componentAutoImportName(relPath) {
+  return relPath.split("/").map(pascalCase).join("");
+}
+function convertDynamicSegment(segment) {
+  const optional = segment.match(/^\[\[(.+)\]\]$/);
+  if (optional) {
+    return { path: `:${optional[1]}?`, param: { name: optional[1], optional: true, catchAll: false } };
+  }
+  const catchAll = segment.match(/^\[\.\.\.(.+)\]$/);
+  if (catchAll) {
+    return { path: `:${catchAll[1]}(.*)*`, param: { name: catchAll[1], optional: false, catchAll: true } };
+  }
+  const dynamic = segment.match(/^\[(.+)\]$/);
+  if (dynamic) {
+    return { path: `:${dynamic[1]}`, param: { name: dynamic[1], optional: false, catchAll: false } };
+  }
+  return { path: segment };
+}
+function fileToRoutePath(relPath) {
+  const withoutExt = relPath.replace(/\.vue$/, "");
+  const segments = withoutExt.split("/").filter((s) => s !== "");
+  const outSegments = [];
+  const params = [];
+  for (const segment of segments) {
+    if (segment === "index") continue;
+    const { path: converted, param } = convertDynamicSegment(segment);
+    outSegments.push(converted);
+    if (param) params.push(param);
+  }
+  return { path: "/" + outSegments.join("/"), params };
+}
+function routeSegmentToFile(segment) {
+  const optional = segment.match(/^:(.+)\?$/);
+  if (optional) return `[[${optional[1]}]]`;
+  const catchAll = segment.match(/^:(.+)\(\.\*\)\*$/);
+  if (catchAll) return `[...${catchAll[1]}]`;
+  const dynamic = segment.match(/^:(.+)$/);
+  if (dynamic) return `[${dynamic[1]}]`;
+  return segment;
+}
+function routePathToFile(routePath) {
+  const trimmed = routePath.replace(/^\/+|\/+$/g, "");
+  if (!trimmed) return "pages/index.vue";
+  const segments = trimmed.split("/").map(routeSegmentToFile);
+  return "pages/" + segments.join("/") + ".vue";
+}
+function routePathToNitroFile(apiPath, method) {
+  let trimmed = apiPath.replace(/^\/+|\/+$/g, "");
+  if (trimmed === "api") trimmed = "";
+  else if (trimmed.startsWith("api/")) trimmed = trimmed.slice("api/".length);
+  const segments = trimmed ? trimmed.split("/").map(routeSegmentToFile) : [];
+  const base = segments.length ? segments.join("/") : "index";
+  const suffix = method && method !== "*" ? `.${method.toLowerCase()}` : "";
+  return `server/api/${base}${suffix}.ts`;
+}
+function extractPageMeta(content) {
+  const meta = {};
+  let middleware = [];
+  let layout;
+  const defMatch = content.match(/definePageMeta\s*\(\s*\{([\s\S]*?)\}\s*\)/);
+  if (!defMatch) return { meta, middleware, layout };
+  const body = defMatch[1];
+  for (const line of body.split("\n")) {
+    const layoutMatch = line.match(/layout\s*:\s*["']([^"']+)["']/);
+    if (layoutMatch) layout = layoutMatch[1];
+    const mwMatch = line.match(/middleware\s*:\s*(\[[\s\S]*?\]|["'][^"']+["'])/);
+    if (mwMatch) {
+      const raw = mwMatch[1];
+      if (raw.startsWith("[")) {
+        middleware = [...raw.matchAll(/["']([^"']+)["']/g)].map((m) => m[1]);
+      } else {
+        middleware = [raw.replace(/["']/g, "")];
+      }
+    }
+    const kv = line.match(/^\s*([\w$]+)\s*:\s*([\s\S]*?)\s*(?:,|$)/);
+    if (kv && !["layout", "middleware"].includes(kv[1])) {
+      meta[kv[1]] = kv[2].trim();
+    }
+  }
+  return { meta, middleware, layout };
+}
+async function listRoutesIn(scanRoot, layer) {
+  const files = await findFiles(scanRoot, ["pages/**/*.vue"]);
+  const byPath = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const rel = relativePath(scanRoot, file).replace(/^pages\//, "");
+    byPath.set(fileToRoutePath(rel).path, file);
+  }
+  const routes = [];
+  for (const file of files) {
+    const rel = relativePath(scanRoot, file).replace(/^pages\//, "");
+    const { path: routePath, params } = fileToRoutePath(rel);
+    const content = await readIfExists(file) ?? "";
+    const { meta, middleware, layout } = extractPageMeta(content);
+    const children = [...byPath.keys()].filter(
+      (p) => p.startsWith(routePath === "/" ? "/" : routePath + "/") && p !== routePath
+    );
+    routes.push({
+      path: routePath,
+      file: relativePath(scanRoot, file),
+      absolutePath: file,
+      params,
+      meta,
+      middleware,
+      layout,
+      nested: children.length > 0,
+      children,
+      layer
+    });
+  }
+  return routes;
+}
+async function listPageRoutes(root, layers = []) {
+  const targets = [{ cwd: root, name: void 0 }, ...layers.map((l) => ({ cwd: l.cwd, name: l.name }))];
+  const routes = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const target of targets) {
+    for (const route of await listRoutesIn(target.cwd, target.name)) {
+      if (seen.has(route.absolutePath)) continue;
+      seen.add(route.absolutePath);
+      routes.push(route);
+    }
+  }
+  return routes.sort((a, b) => a.path.localeCompare(b.path));
+}
+function parseProps(content) {
+  const props = [];
+  const typeMatch = content.match(/defineProps\s*<\s*\{([\s\S]*?)\}\s*>/);
+  if (typeMatch) {
+    const body = typeMatch[1];
+    for (const entry of splitTopLevelComma(body)) {
+      const m = entry.trim().match(/^([\w$]+)(\??)\s*:\s*([\s\S]*)$/);
+      if (!m) continue;
+      props.push({
+        name: m[1],
+        type: m[3].trim(),
+        required: m[2] !== "?"
+      });
+    }
+    return props;
+  }
+  const runtimeMatch = content.match(/defineProps\s*\(\s*\{([\s\S]*?)\}\s*\)/);
+  if (runtimeMatch) {
+    const body = runtimeMatch[1];
+    for (const entry of splitTopLevelComma(body)) {
+      const m = entry.trim().match(/^([\w$]+)\s*:\s*([\s\S]*)$/);
+      if (!m) continue;
+      const name = m[1];
+      const value = m[2].trim();
+      if (value.startsWith("{")) {
+        const typeM = value.match(/\btype\s*:\s*([\w$[\].]+)/);
+        const reqM = value.match(/\brequired\s*:\s*(true|false)/);
+        const defM = value.match(/\bdefault\s*:\s*([^,}]+)/);
+        props.push({
+          name,
+          type: typeM?.[1],
+          required: reqM?.[1] === "true",
+          default: defM?.[1]?.trim()
+        });
+      } else {
+        props.push({ name, type: value.replace(/[()]/g, "").trim(), required: false });
+      }
+    }
+  }
+  return props;
+}
+function parseEmits(content) {
+  const emits = [];
+  const runtimeMatch = content.match(/defineEmits\s*\(\s*\[([\s\S]*?)\]\s*\)/);
+  if (runtimeMatch) {
+    for (const m of runtimeMatch[1].matchAll(/["']([^"']+)["']/g)) emits.push(m[1]);
+    return emits;
+  }
+  const typeMatch = content.match(/defineEmits\s*<\s*\{([\s\S]*?)\}\s*>/);
+  if (typeMatch) {
+    for (const m of typeMatch[1].matchAll(/['"]?([\w:$-]+)['"]?\s*\(/g)) {
+      if (!["on", "call"].includes(m[1])) emits.push(m[1]);
+    }
+  }
+  return emits;
+}
+function parseSlots(content) {
+  const slots = /* @__PURE__ */ new Set();
+  for (const m of content.matchAll(/<slot(?:\s+name=["']([^"']+)["'])?[^>]*\/?>/g)) {
+    slots.add(m[1] ?? "default");
+  }
+  if (/\buseSlots\s*\(/.test(content)) slots.add("default");
+  return [...slots];
+}
+function splitTopLevelComma(text) {
+  const parts = [];
+  let depth = 0;
+  let current = "";
+  for (const ch of text) {
+    if (ch === "{" || ch === "[" || ch === "(") depth++;
+    else if (ch === "}" || ch === "]" || ch === ")") depth--;
+    if (ch === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  if (current.trim()) parts.push(current);
+  return parts;
+}
+async function parseVueComponent(file) {
+  const content = await readIfExists(file) ?? "";
+  const scriptSetup = content.match(/<script\s+setup[^>]*>([\s\S]*?)<\/script>/)?.[1] ?? "";
+  const template = content.match(/<template>([\s\S]*?)<\/template>/)?.[1] ?? content;
+  const combined = scriptSetup + "\n" + template;
+  return {
+    props: parseProps(scriptSetup || combined),
+    emits: parseEmits(scriptSetup),
+    slots: parseSlots(template),
+    hasScriptSetup: scriptSetup.length > 0
+  };
+}
+async function listComponents(root, layers = []) {
+  const targets = [{ cwd: root, name: void 0 }, ...layers.map((l) => ({ cwd: l.cwd, name: l.name }))];
+  const components = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const target of targets) {
+    const files = await findFiles(target.cwd, ["components/**/*.vue"]);
+    for (const file of files) {
+      if (seen.has(file)) continue;
+      seen.add(file);
+      const rel = relativePath(target.cwd, file);
+      const relFromComponents = rel.replace(/^components\//, "");
+      const { props, emits, slots } = await parseVueComponent(file);
+      components.push({
+        name: componentAutoImportName(relFromComponents),
+        file: rel,
+        absolutePath: file,
+        directory: "components",
+        props,
+        emits,
+        slots,
+        autoImported: true,
+        isPage: false,
+        layer: target.name
+      });
+    }
+  }
+  return components.sort((a, b) => a.name.localeCompare(b.name));
+}
+async function parseComposable(file) {
+  const content = await readIfExists(file) ?? "";
+  const fnMatch = content.match(/export\s+(?:async\s+)?function\s+([\w$]+)\s*\(([\s\S]*?)\)\s*(?::\s*([^{=]+))?\s*\{/);
+  if (!fnMatch) return {};
+  const params = fnMatch[2].trim();
+  const returnType = fnMatch[3]?.trim() ?? void 0;
+  return { parameters: params || void 0, returnType };
+}
+async function listComposables(root, layers = []) {
+  const targets = [{ cwd: root, name: void 0 }, ...layers.map((l) => ({ cwd: l.cwd, name: l.name }))];
+  const composables = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const target of targets) {
+    const files = await findFiles(target.cwd, ["composables/**/*.{ts,js,mts,mjs}", "utils/**/*.{ts,js,mts,mjs}"]);
+    for (const file of files) {
+      if (seen.has(file)) continue;
+      seen.add(file);
+      const rel = relativePath(target.cwd, file);
+      const dir = rel.startsWith("composables/") ? "composables" : "utils";
+      const basename = rel.split("/").pop() ?? "";
+      const name = camelCase(basename);
+      const { parameters, returnType } = await parseComposable(file);
+      const exported = await readIfExists(file) ?? "";
+      const isAutoImported = /^use[A-Z]/.test(name) || /export\s+(?:default|const)\s+/.test(exported) || /\bautoImport\s*:\s*true/.test(exported);
+      composables.push({
+        name,
+        file: rel,
+        absolutePath: file,
+        parameters,
+        returnType,
+        autoImported: isAutoImported,
+        directory: dir,
+        layer: target.name
+      });
+    }
+  }
+  return composables.sort((a, b) => a.name.localeCompare(b.name));
+}
+var METHOD_SUFFIXES = {
+  get: "GET",
+  post: "POST",
+  put: "PUT",
+  patch: "PATCH",
+  delete: "DELETE",
+  head: "HEAD",
+  options: "OPTIONS"
+};
+function nitroPathFromFile(rel) {
+  const withoutExt = rel.replace(/\.(ts|js|mts|mjs)$/, "");
+  const segments = withoutExt.split("/");
+  const last = segments[segments.length - 1];
+  let method = "*";
+  let lastSegment = last;
+  for (const [suffix, httpMethod] of Object.entries(METHOD_SUFFIXES)) {
+    if (last.endsWith(`.${suffix}`)) {
+      method = httpMethod;
+      lastSegment = last.slice(0, -(suffix.length + 1));
+      break;
+    }
+  }
+  segments[segments.length - 1] = lastSegment;
+  const converted = segments.map((s) => convertDynamicSegment(s).path);
+  if (converted[converted.length - 1] === "index") converted.pop();
+  return { path: "/" + converted.join("/"), method };
+}
+async function listServerRoutes(root) {
+  const files = await findFiles(root, [
+    "server/api/**/*.{ts,js,mts,mjs}",
+    "server/routes/**/*.{ts,js,mts,mjs}",
+    "server/middleware/**/*.{ts,js,mts,mjs}",
+    "server/plugins/**/*.{ts,js,mts,mjs}"
+  ]);
+  const globalMiddleware = files.filter((f) => relativePath(root, f).startsWith("server/middleware/")).map((f) => relativePath(root, f).replace(/^server\/middleware\//, "").replace(/\.(ts|js|mts|mjs)$/, ""));
+  const routes = [];
+  for (const file of files) {
+    const rel = relativePath(root, file);
+    let kind;
+    let pathPrefix = "";
+    if (rel.startsWith("server/api/")) {
+      kind = "api";
+      pathPrefix = "/api";
+    } else if (rel.startsWith("server/routes/")) {
+      kind = "route";
+    } else if (rel.startsWith("server/middleware/")) {
+      kind = "middleware";
+    } else {
+      kind = "plugin";
+    }
+    const inner = rel.replace(/^server\/(api|routes|middleware|plugins)\//, "");
+    const { path: subPath, method } = nitroPathFromFile(inner);
+    routes.push({
+      path: kind === "middleware" || kind === "plugin" ? `(global: ${inner.replace(/\.(ts|js|mts|mjs)$/, "")})` : pathPrefix + subPath,
+      file: rel,
+      absolutePath: file,
+      method: kind === "api" || kind === "route" ? method : "*",
+      kind,
+      middleware: kind === "middleware" || kind === "plugin" ? [] : globalMiddleware
+    });
+  }
+  return routes.sort((a, b) => a.path.localeCompare(b.path));
+}
+function isNuxtModule(name) {
+  return name.startsWith("@nuxt/") || name.startsWith("nuxt-") || name.includes("nuxt") || name.startsWith("@nuxtjs/") || name === "nitro" || name === "@pinia/nuxt";
+}
+async function listModules(root, configValue) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  const configModules = configValue["modules"] ?? [];
+  const configModuleNames = /* @__PURE__ */ new Set();
+  for (const mod of configModules) {
+    if (typeof mod === "string") {
+      configModuleNames.add(mod);
+      seen.add(mod);
+      result.push({ name: mod, status: "active", source: "nuxt.config", local: false, config: void 0 });
+    } else if (Array.isArray(mod) && typeof mod[0] === "string") {
+      configModuleNames.add(mod[0]);
+      seen.add(mod[0]);
+      result.push({ name: mod[0], status: "active", source: "nuxt.config", local: false, config: mod[1] });
+    } else if (typeof mod === "function") {
+      const name = mod.name || "(local module)";
+      configModuleNames.add(name);
+      seen.add(name);
+      result.push({ name, status: "active", source: "nuxt.config", local: true, config: void 0 });
+    }
+  }
+  try {
+    const pkgRaw = await readIfExists(path2.join(root, "package.json"));
+    if (pkgRaw) {
+      const pkg = JSON.parse(pkgRaw);
+      const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+      for (const [name, version] of Object.entries(deps)) {
+        if (!isNuxtModule(name)) continue;
+        const status = configModuleNames.has(name) ? "active" : "inactive";
+        if (seen.has(name)) {
+          const existing = result.find((m) => m.name === name);
+          if (existing) {
+            existing.version = version;
+            existing.source = status === "active" ? "both" : "package.json";
+          }
+        } else {
+          seen.add(name);
+          result.push({ name, version, status, source: "package.json", local: false, config: void 0 });
+        }
+      }
+    }
+  } catch {
+  }
+  for (const mod of result) {
+    if (!mod.version) {
+      const pkgPath = path2.join(root, "node_modules", ...mod.name.split("/"), "package.json");
+      const raw = await readIfExists(pkgPath);
+      if (raw) {
+        try {
+          mod.version = JSON.parse(raw).version;
+        } catch {
+        }
+      }
+    }
+  }
+  return result.sort((a, b) => a.name.localeCompare(b.name));
+}
+async function searchCode(root, query, fileTypes, maxResults = 50) {
+  const patterns = fileTypes && fileTypes.length > 0 ? fileTypes.map((ext) => `**/*${ext.startsWith(".") ? ext : "." + ext}`) : ["**/*"];
+  const files = await findFiles(root, patterns, [
+    "**/package-lock.json",
+    "**/yarn.lock",
+    "**/pnpm-lock.yaml",
+    "**/bun.lockb"
+  ]);
+  const matches = [];
+  const regex = new RegExp(escapeRegExp(query), "i");
+  for (const file of files) {
+    const ext = path2.extname(file).toLowerCase();
+    if (!TEXT_EXTENSIONS.has(ext)) continue;
+    const content = await readIfExists(file);
+    if (!content) continue;
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const m = regex.exec(line);
+      if (!m) continue;
+      const start = Math.max(0, i - 1);
+      const end = Math.min(lines.length - 1, i + 1);
+      matches.push({
+        file: relativePath(root, file),
+        line: i + 1,
+        column: m.index + 1,
+        lineText: line.trim(),
+        context: lines.slice(start, end + 1)
+      });
+      if (matches.length >= maxResults) return matches;
+    }
+  }
+  return matches;
+}
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function getNuxtVersion(root) {
+  const candidates = [
+    path2.join(root, "node_modules", "nuxt", "package.json"),
+    path2.join(root, "package.json")
+  ];
+  for (const file of candidates) {
+    const raw = await readIfExists(file);
+    if (!raw) continue;
+    try {
+      const pkg = JSON.parse(raw);
+      if (file.endsWith("node_modules/nuxt/package.json") && typeof pkg.version === "string") {
+        return pkg.version;
+      }
+      const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+      const version = deps["nuxt"] ?? deps["nuxt-edge"];
+      if (version) return version.replace(/[\^~]/, "");
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function listDirectories(root) {
+  const dirs = ["pages", "components", "composables", "utils", "server", "layouts", "middleware", "plugins", "assets", "public", "content", "modules"];
+  const existing = [];
+  for (const dir of dirs) {
+    if (await exists(path2.join(root, dir))) existing.push(dir);
+  }
+  return existing;
+}
+async function isBuilt(root) {
+  return exists(path2.join(root, ".nuxt"));
+}
+async function analyzeBundleDeps(root) {
+  const packages = [];
+  const warnings = [];
+  const raw = await readIfExists(path2.join(root, "package.json"));
+  if (!raw) return { packages, warnings };
+  let pkg;
+  try {
+    pkg = JSON.parse(raw);
+  } catch {
+    return { packages, warnings };
+  }
+  const dependencies = pkg.dependencies ?? {};
+  const devDependencies = pkg.devDependencies ?? {};
+  const all = /* @__PURE__ */ new Map();
+  for (const [name, version] of Object.entries(dependencies)) all.set(name, { version, kind: "runtime" });
+  for (const [name, version] of Object.entries(devDependencies)) all.set(name, { version, kind: "dev" });
+  for (const [name, { version, kind }] of all) {
+    const isModule = isNuxtModule(name);
+    packages.push({ name, version, kind: isModule ? "nuxt-module" : kind });
+    if (isModule) {
+      if (kind === "runtime") {
+        warnings.push(`Nuxt module "${name}" is in dependencies; it should be in devDependencies.`);
+      }
+      const installed = await exists(path2.join(root, "node_modules", ...name.split("/"), "package.json"));
+      if (!installed) warnings.push(`Nuxt module "${name}" is declared but not installed in node_modules.`);
+    }
+  }
+  packages.sort((a, b) => a.name.localeCompare(b.name));
+  return { packages, warnings };
+}
+async function readTypeInfo(root) {
+  const result = {};
+  const importsDts = await readIfExists(path2.join(root, ".nuxt", "imports.d.ts"));
+  if (importsDts) result.importsDts = importsDts;
+  const typesDir = path2.join(root, ".nuxt", "types");
+  if (await exists(typesDir)) {
+    const files = await findFiles(root, [".nuxt/types/**/*.d.ts"]);
+    result.typesDir = files.map((f) => relativePath(root, f)).sort();
+  }
+  const schema = await readIfExists(path2.join(root, ".nuxt", "schema", "nuxt.schema.json"));
+  if (schema) result.schema = schema;
+  return result;
+}
+
+// src/utils/layers.ts
+import path3 from "path";
+import { promises as fs3 } from "fs";
+async function layerName(dir) {
+  try {
+    const raw = await fs3.readFile(path3.join(dir, "package.json"), "utf8");
+    const pkg = JSON.parse(raw);
+    if (pkg.name) return pkg.name;
+  } catch {
+  }
+  return path3.basename(dir);
+}
+async function readExtends(configFile) {
+  if (!configFile) return [];
+  try {
+    const source = await fs3.readFile(configFile, "utf8");
+    const parsed = parseConfigSource(source);
+    const ext = parsed["extends"];
+    if (Array.isArray(ext)) return ext.filter((e) => typeof e === "string");
+  } catch {
+  }
+  return [];
+}
+async function resolveLayer(dir, counter, seen) {
+  const abs = path3.resolve(dir);
+  if (seen.has(abs)) return null;
+  seen.add(abs);
+  const configFile = findConfigFile(abs);
+  const extendsEntries = await readExtends(configFile);
+  const layer = {
+    cwd: abs,
+    name: await layerName(abs),
+    configFile,
+    extends: extendsEntries,
+    priority: counter.value++,
+    children: []
+  };
+  for (const entry of extendsEntries.slice().reverse()) {
+    const child = await resolveLayer(path3.resolve(abs, entry), counter, seen);
+    if (child) layer.children.push(child);
+  }
+  return layer;
+}
+async function resolveLayers(root, extendsEntries) {
+  const absRoot = path3.resolve(root);
+  const seen = /* @__PURE__ */ new Set([absRoot]);
+  const counter = { value: 1 };
+  const rootLayer = {
+    cwd: absRoot,
+    name: await layerName(absRoot),
+    configFile: findConfigFile(absRoot),
+    extends: extendsEntries,
+    priority: 0,
+    children: []
+  };
+  const result = [rootLayer];
+  const appendTree = (layer) => {
+    result.push(layer);
+    for (const child of layer.children) appendTree(child);
+  };
+  for (const entry of extendsEntries.slice().reverse()) {
+    const child = await resolveLayer(path3.resolve(absRoot, entry), counter, seen);
+    if (child) {
+      rootLayer.children.push(child);
+      appendTree(child);
+    }
+  }
+  return result;
+}
+
+// src/utils/auto-imports.ts
+import { promises as fs4 } from "fs";
+import path4 from "path";
+async function readIfExists2(file) {
+  try {
+    return await fs4.readFile(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+function classify(name, source) {
+  if (source.endsWith(".vue") || source.includes("/components/")) return "component";
+  if (/^use[A-Z]/.test(name)) return "function";
+  if (/^[A-Z]/.test(name)) return "value";
+  return "function";
+}
+function sourceFromType(type) {
+  const m = type.match(/typeof\s+import\(['"]([^'"]+)['"]\)/);
+  return m?.[1];
+}
+function parseImportsDts(content) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (name, source, signature) => {
+    if (!name || name.startsWith("_")) return;
+    if (seen.has(name)) return;
+    seen.add(name);
+    result.push({ name, source, kind: classify(name, source), signature });
+  };
+  for (const line of content.split("\n")) {
+    const exportFrom = line.match(/export\s*\{([^}]*)\}\s*from\s*['"]([^'"]+)['"]/);
+    if (exportFrom) {
+      const source = exportFrom[2];
+      for (const raw of exportFrom[1].split(",")) {
+        const item = raw.trim();
+        if (!item) continue;
+        const as = item.match(/^([\w$]+)\s+as\s+([\w$]+)$/);
+        if (as) push(as[2], source);
+        else if (item === "default") continue;
+        else push(item, source);
+      }
+      continue;
+    }
+    const exportConst = line.match(/export\s+const\s+([\w$]+)\s*:\s*([^\n;]+)/);
+    if (exportConst) {
+      const name = exportConst[1];
+      const type = exportConst[2].trim();
+      push(name, sourceFromType(type) ?? "#imports", type);
+      continue;
+    }
+    const constDecl = line.match(/^\s*const\s+([\w$]+)\s*:\s*([^\n;]+)/);
+    if (constDecl) {
+      const name = constDecl[1];
+      const type = constDecl[2].trim();
+      push(name, sourceFromType(type) ?? "#imports", type);
+      continue;
+    }
+  }
+  return result;
+}
+async function readAutoImports(root) {
+  const candidates = [
+    path4.join(root, ".nuxt", "imports.d.ts"),
+    path4.join(root, ".nuxt", "types", "imports.d.ts")
+  ];
+  for (const file of candidates) {
+    const content = await readIfExists2(file);
+    if (content) return { built: true, imports: parseImportsDts(content) };
+  }
+  return { built: false, imports: [] };
+}
+
+// src/utils/write-guard.ts
+var WriteGuard = class {
+  constructor(allowWrites2) {
+    this.allowWrites = allowWrites2;
+  }
+  allowWrites;
+  /**
+   * Decide whether a write operation may proceed.
+   *
+   * @param dryRun when true, no disk write is attempted — always allowed.
+   */
+  authorize(dryRun) {
+    if (dryRun) return { ok: true };
+    if (this.allowWrites) return { ok: true };
+    return {
+      ok: false,
+      error: "Write operations are disabled. Set MCP_NUXT_ALLOW_WRITES=1 or pass --allow-writes to enable real writes. Dry-run plans are always available."
+    };
+  }
+};
+
+// src/context.ts
+var NuxtProjectContext = class {
+  root;
+  writeGuard;
+  configCache = null;
+  snapshotCache = null;
+  layersCache = null;
+  constructor(root, options = {}) {
+    this.root = path5.resolve(root ?? detectProjectRoot(process.cwd()));
+    this.writeGuard = new WriteGuard(options.allowWrites ?? false);
+  }
+  /** Resolve a path relative to the project root. */
+  p(...segments) {
+    return path5.join(this.root, ...segments);
+  }
+  async config() {
+    if (!this.configCache) this.configCache = await loadNuxtConfig(this.root);
+    return this.configCache;
+  }
+  async snapshot() {
+    if (this.snapshotCache) return this.snapshotCache;
+    const config = await this.config();
+    const layers = await this.layers();
+    const extraLayers = layers.slice(1).map((l) => ({ cwd: l.cwd, name: l.name }));
+    const [routes, components, composables, serverRoutes, nuxtVersion, directories, built] = await Promise.all([
+      listPageRoutes(this.root, extraLayers),
+      listComponents(this.root, extraLayers),
+      listComposables(this.root, extraLayers),
+      listServerRoutes(this.root),
+      getNuxtVersion(this.root),
+      listDirectories(this.root),
+      isBuilt(this.root)
+    ]);
+    const modules = await listModules(this.root, config.value);
+    const name = await this.projectName();
+    const configFile = config.configPath ? path5.basename(config.configPath) : void 0;
+    const overview = {
+      root: this.root,
+      name,
+      framework: "Nuxt",
+      nuxtVersion,
+      hasNuxtConfig: config.configPath !== null,
+      configFile,
+      counts: {
+        routes: routes.length,
+        components: components.length,
+        composables: composables.length,
+        serverRoutes: serverRoutes.filter((r) => r.kind === "api" || r.kind === "route").length,
+        middleware: serverRoutes.filter((r) => r.kind === "middleware").length,
+        plugins: serverRoutes.filter((r) => r.kind === "plugin").length,
+        modules: modules.filter((m) => m.status === "active").length
+      },
+      directories,
+      modules: modules.map((m) => m.name),
+      layers: layers.map((l) => l.name),
+      built
+    };
+    this.snapshotCache = { routes, components, composables, serverRoutes, modules, overview };
+    return this.snapshotCache;
+  }
+  async invalidate() {
+    this.snapshotCache = null;
+    this.configCache = null;
+    this.layersCache = null;
+  }
+  /** Resolve the Nuxt extends hierarchy (highest priority first). */
+  async layers() {
+    if (this.layersCache) return this.layersCache;
+    const config = await this.config();
+    const ext = config.value["extends"];
+    const entries = Array.isArray(ext) ? ext.filter((e) => typeof e === "string") : [];
+    this.layersCache = await resolveLayers(this.root, entries);
+    return this.layersCache;
+  }
+  /** Read type info (.nuxt/imports.d.ts, .nuxt/types, schema). */
+  async typeInfo() {
+    return readTypeInfo(this.root);
+  }
+  /** Read the parsed auto-imports registry (requires .nuxt build output). */
+  async autoImports() {
+    return readAutoImports(this.root);
+  }
+  async projectName() {
+    try {
+      const pkg = JSON.parse(await fs5.readFile(this.p("package.json"), "utf8"));
+      return pkg.name ?? path5.basename(this.root);
+    } catch {
+      return path5.basename(this.root);
+    }
+  }
+};
+
+// src/utils/helpers.ts
+function textResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+function jsonResult(value) {
+  return textResult(JSON.stringify(value, null, 2));
+}
+function errorResult(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return textResult(JSON.stringify({ error: message }, null, 2));
+}
+function safe(fn) {
+  return async (...args) => {
+    try {
+      return await fn(...args);
+    } catch (error) {
+      return errorResult(error);
+    }
+  };
+}
+
+// src/tools/project-overview.ts
+function registerOverviewTools(server, ctx) {
+  server.tool(
+    "get_project_overview",
+    "Get a high-level overview of the Nuxt project: root, name, Nuxt version, config file, directory layout, layer list, and counts of routes, components, composables, server routes, middleware, plugins and modules.",
+    safe(async () => {
+      const { overview } = await ctx.snapshot();
+      return jsonResult(overview);
+    })
+  );
+  server.tool(
+    "get_type_info",
+    "Read generated Nuxt type information (.nuxt/imports.d.ts, .nuxt/types files and nuxt.schema.json) when the project has been built.",
+    safe(async () => {
+      return jsonResult(await ctx.typeInfo());
+    })
+  );
+}
+
+// src/tools/routes.ts
+import { promises as fs6 } from "fs";
+import path6 from "path";
+import { z } from "zod";
+function registerRouteTools(server, ctx) {
+  server.tool(
+    "list_routes",
+    "List all page routes with their resolved URL paths, source files, params, middleware, layouts and children. Use this to understand the page/routing surface of the project.",
+    {
+      pattern: z.string().optional().describe("Optional substring filter matched against the route path or file")
+    },
+    safe(async ({ pattern }) => {
+      const { routes } = await ctx.snapshot();
+      let filtered = routes;
+      if (pattern) {
+        const needle = pattern.toLowerCase();
+        filtered = routes.filter(
+          (r) => r.path.toLowerCase().includes(needle) || r.file.toLowerCase().includes(needle)
+        );
+      }
+      return jsonResult({ count: filtered.length, total: routes.length, routes: filtered });
+    })
+  );
+  server.tool(
+    "get_route",
+    "Get detailed information about a single page route by its resolved URL path (e.g. /users/:id).",
+    {
+      path: z.string().describe("The resolved route path, e.g. /users/:id")
+    },
+    safe(async ({ path: path11 }) => {
+      const { routes } = await ctx.snapshot();
+      const route = routes.find((r) => r.path === path11);
+      if (!route) {
+        return jsonResult({
+          found: false,
+          path: path11,
+          suggestions: routes.filter((r) => r.path.includes(path11) || path11.includes(r.path)).slice(0, 10).map((r) => r.path)
+        });
+      }
+      return jsonResult({ found: true, route });
+    })
+  );
+  server.tool(
+    "add_route",
+    "Scaffold a new page route under pages/ following Nuxt conventions. Supports static, dynamic (:id -> [id]), optional ([[id]]), and catch-all ([...slug]) segments.",
+    {
+      path: z.string().describe("Route path, e.g. /users/:id or /about"),
+      layout: z.string().optional().describe("Optional layout name to set in definePageMeta"),
+      middleware: z.array(z.string()).optional().describe("Optional middleware names to set in definePageMeta"),
+      dryRun: z.boolean().optional().describe("When true (default), return the planned file without writing")
+    },
+    safe(async ({ path: routePath, layout, middleware, dryRun }) => {
+      const auth = ctx.writeGuard.authorize(dryRun ?? true);
+      if (!auth.ok) return jsonResult(auth);
+      const file = ctx.p(routePathToFile(routePath));
+      const meta = [];
+      if (layout) meta.push(`  layout: '${layout}'`);
+      if (middleware && middleware.length > 0) {
+        meta.push(`  middleware: [${middleware.map((m) => `'${m}'`).join(", ")}]`);
+      }
+      const metaBlock = meta.length > 0 ? `
+definePageMeta({
+${meta.join(",\n")}
+})` : "";
+      const content = `<script setup>${metaBlock}
+</script>
+
+<template>
+  <div>${routePath}</div>
+</template>
+`;
+      if (dryRun ?? true) return jsonResult({ written: false, dryRun: true, path: file, content });
+      await fs6.mkdir(path6.dirname(file), { recursive: true });
+      await fs6.writeFile(file, content, "utf8");
+      return jsonResult({ written: true, path: file });
+    })
+  );
+}
+
+// src/tools/components.ts
+import { promises as fs7 } from "fs";
+import path7 from "path";
+import { z as z2 } from "zod";
+function registerComponentTools(server, ctx) {
+  server.tool(
+    "list_components",
+    "List all Vue components with their auto-imported names, file paths, props, emits and slots. Use this to discover existing UI building blocks before writing new code.",
+    {
+      name: z2.string().optional().describe("Optional substring filter on component name"),
+      directory: z2.string().optional().describe("Optional directory filter (e.g. components)")
+    },
+    safe(async ({ name, directory }) => {
+      const { components } = await ctx.snapshot();
+      let filtered = components;
+      if (name) filtered = filtered.filter((c) => c.name.toLowerCase().includes(name.toLowerCase()));
+      if (directory) filtered = filtered.filter((c) => c.directory === directory);
+      return jsonResult({ count: filtered.length, total: components.length, components: filtered });
+    })
+  );
+  server.tool(
+    "inspect_component",
+    "Get detailed information about a single component by its auto-imported name (e.g. BaseButton): props types, slots, emits, and script setup details.",
+    {
+      name: z2.string().describe("Auto-imported component name, e.g. BaseButton")
+    },
+    safe(async ({ name }) => {
+      const { components } = await ctx.snapshot();
+      const component = components.find((c) => c.name === name);
+      if (!component) {
+        return jsonResult({
+          found: false,
+          name,
+          suggestions: components.filter((c) => c.name.toLowerCase().includes(name.toLowerCase())).slice(0, 10).map((c) => c.name)
+        });
+      }
+      return jsonResult({ found: true, component });
+    })
+  );
+  server.tool(
+    "generate_component",
+    "Generate a new Vue SFC under components/ with typed defineProps/defineEmits and slots.",
+    {
+      name: z2.string().describe("Component name, e.g. BaseButton or ui/BaseButton"),
+      props: z2.record(z2.string()).optional().describe('Prop name -> type, e.g. { "label": "string", "count": "number" }'),
+      emits: z2.array(z2.string()).optional().describe("Event names to declare with defineEmits"),
+      slots: z2.array(z2.string()).optional().describe("Slot names (default slot is always included)"),
+      dryRun: z2.boolean().optional().describe("When true (default), return the planned file without writing")
+    },
+    safe(async ({ name, props, emits, slots, dryRun }) => {
+      const auth = ctx.writeGuard.authorize(dryRun ?? true);
+      if (!auth.ok) return jsonResult(auth);
+      const clean = name.replace(/\.vue$/, "");
+      const file = ctx.p("components", clean + ".vue");
+      const propsBlock = props && Object.keys(props).length > 0 ? `
+const props = defineProps<{
+${Object.entries(props).map(([k, v]) => `  ${k}: ${v}`).join("\n")}
+}>()` : "";
+      const emitsBlock = emits && emits.length > 0 ? `
+const emit = defineEmits<{
+${emits.map((e) => `  ${e}: []`).join("\n")}
+}>()` : "";
+      const slotNodes = slots && slots.length > 0 ? slots.map((s) => `    <slot name="${s}" />`).join("\n") : "    <slot />";
+      const content = `<script setup lang="ts">${propsBlock}${emitsBlock}
+</script>
+
+<template>
+${slotNodes}
+</template>
+`;
+      if (dryRun ?? true) return jsonResult({ written: false, dryRun: true, path: file, content });
+      await fs7.mkdir(path7.dirname(file), { recursive: true });
+      await fs7.writeFile(file, content, "utf8");
+      return jsonResult({ written: true, path: file });
+    })
+  );
+}
+
+// src/tools/composables.ts
+import { z as z3 } from "zod";
+function registerComposableTools(server, ctx) {
+  server.tool(
+    "list_composables",
+    "List all composables, both auto-imported and explicit. Returns name, file path, parameters, and return type. Use this to discover reusable logic before writing new code.",
+    { name: z3.string().optional().describe("Optional substring filter on composable name") },
+    safe(async ({ name }) => {
+      const { composables } = await ctx.snapshot();
+      let filtered = composables;
+      if (name) filtered = composables.filter((c) => c.name.toLowerCase().includes(name.toLowerCase()));
+      return jsonResult({
+        count: filtered.length,
+        total: composables.length,
+        autoImportedCount: composables.filter((c) => c.autoImported).length,
+        composables: filtered
+      });
+    })
+  );
+  server.tool(
+    "get_auto_imports",
+    "Read the .nuxt/imports.d.ts auto-imports registry: every auto-imported symbol with its source path and type signature. Requires the project to have been prepared/built. Use this instead of guessing import paths or function signatures.",
+    {
+      filter: z3.string().optional().describe("Optional substring filter on the symbol name or source path")
+    },
+    safe(async ({ filter }) => {
+      const { built, imports } = await ctx.autoImports();
+      let filtered = imports;
+      if (filter) {
+        const needle = filter.toLowerCase();
+        filtered = imports.filter(
+          (i) => i.name.toLowerCase().includes(needle) || i.source.toLowerCase().includes(needle)
+        );
+      }
+      return jsonResult({ built, count: filtered.length, total: imports.length, imports: filtered });
+    })
+  );
+}
+
+// src/tools/server-api.ts
+import { promises as fs8 } from "fs";
+import path8 from "path";
+import { z as z4 } from "zod";
+function registerServerApiTools(server, ctx) {
+  server.tool(
+    "list_server_routes",
+    "List all Nitro server API routes, middleware, and plugins. Returns route path, handler file, HTTP method, and middleware chain. Use this to understand the server/API surface of the project.",
+    {
+      type: z4.enum(["api", "middleware", "plugin"]).optional().describe("Filter by route kind")
+    },
+    safe(async ({ type }) => {
+      const { serverRoutes } = await ctx.snapshot();
+      let routes = serverRoutes;
+      if (type) routes = serverRoutes.filter((r) => r.kind === type);
+      const grouped = {
+        api: serverRoutes.filter((r) => r.kind === "api" || r.kind === "route").length,
+        middleware: serverRoutes.filter((r) => r.kind === "middleware").length,
+        plugin: serverRoutes.filter((r) => r.kind === "plugin").length
+      };
+      return jsonResult({ count: routes.length, totals: grouped, routes });
+    })
+  );
+  server.tool(
+    "scaffold_nitro_api",
+    "Generate a new Nitro server API handler under server/api/ with H3 defineEventHandler and optional Zod body validation.",
+    {
+      path: z4.string().describe("API path, e.g. /api/hello or /api/users/:id"),
+      method: z4.enum(["get", "post", "put", "patch", "delete"]).optional().describe("HTTP method (default: handle all methods)"),
+      zod: z4.boolean().optional().describe("Include readValidatedBody with a Zod schema (default false)"),
+      dryRun: z4.boolean().optional().describe("When true (default), return the planned file without writing")
+    },
+    safe(async ({ path: apiPath, method, zod, dryRun }) => {
+      const auth = ctx.writeGuard.authorize(dryRun ?? true);
+      if (!auth.ok) return jsonResult(auth);
+      const file = ctx.p(routePathToNitroFile(apiPath, method));
+      const content = zod ? "import { z } from 'zod'\n\nexport default defineEventHandler(async (event) => {\n  const body = await readValidatedBody(event, z.object({}).passthrough().safeParse)\n  if (!body.success) throw createError({ statusCode: 400, statusMessage: 'Invalid body' })\n  return body.data\n})\n" : "export default defineEventHandler((event) => {\n  return { ok: true }\n})\n";
+      if (dryRun ?? true) return jsonResult({ written: false, dryRun: true, path: file, content });
+      await fs8.mkdir(path8.dirname(file), { recursive: true });
+      await fs8.writeFile(file, content, "utf8");
+      return jsonResult({ written: true, path: file });
+    })
+  );
+}
+
+// src/tools/modules.ts
+import { promises as fs9 } from "fs";
+import { z as z5 } from "zod";
+function registerModuleTools(server, ctx) {
+  server.tool(
+    "list_modules",
+    "List Nuxt modules discovered from nuxt.config and package.json, with version, status (active/inactive) and source. Use this to understand which Nuxt features are available.",
+    {
+      status: z5.enum(["active", "inactive"]).optional().describe("Filter by module status")
+    },
+    safe(async ({ status }) => {
+      const { modules } = await ctx.snapshot();
+      let filtered = modules;
+      if (status) filtered = modules.filter((m) => m.status === status);
+      return jsonResult({
+        count: filtered.length,
+        active: modules.filter((m) => m.status === "active").length,
+        modules: filtered
+      });
+    })
+  );
+  server.tool(
+    "add_nuxt_module",
+    "Add a Nuxt module to the modules array in nuxt.config, optionally with options. Returns a diff; dry-run by default.",
+    {
+      name: z5.string().describe("Module name, e.g. @nuxtjs/i18n"),
+      options: z5.string().optional().describe('Optional module options as a JSON object string, e.g. {"locales": ["en"]}'),
+      dryRun: z5.boolean().optional().describe("When true (default), return the planned change without writing")
+    },
+    safe(async ({ name, options, dryRun }) => {
+      const auth = ctx.writeGuard.authorize(dryRun ?? true);
+      if (!auth.ok) return jsonResult(auth);
+      const config = await ctx.config();
+      if (!config.configPath || !config.source) {
+        return jsonResult({ ok: false, error: "No writable nuxt.config file found." });
+      }
+      let parsedOptions;
+      if (options !== void 0) {
+        try {
+          parsedOptions = JSON.parse(options);
+        } catch {
+          return jsonResult({ ok: false, error: "options must be a valid JSON object string" });
+        }
+      }
+      const { newSource, diff } = appendModule(config.source, name, parsedOptions);
+      if (dryRun ?? true) {
+        return jsonResult({ ok: true, written: false, dryRun: true, module: name, diff });
+      }
+      await fs9.writeFile(config.configPath, newSource, "utf8");
+      await ctx.invalidate();
+      return jsonResult({ ok: true, written: true, module: name, diff });
+    })
+  );
+}
+
+// src/tools/pages.ts
+import { promises as fs10 } from "fs";
+import { z as z6 } from "zod";
+function registerPageTools(server, ctx) {
+  server.tool(
+    "inspect_route_meta",
+    "Inspect a single route: returns route params, middleware, layout, page meta plus the component props, emits and slots. Accepts a route path (e.g. /users/:id) or a page file path.",
+    {
+      path: z6.string().describe("Route path (e.g. /users/:id) or page file (e.g. pages/users/[id].vue)")
+    },
+    safe(async ({ path: path11 }) => {
+      const { routes } = await ctx.snapshot();
+      const route = routes.find((r) => r.path === path11 || r.file === path11);
+      if (!route) {
+        return jsonResult({
+          found: false,
+          path: path11,
+          suggestions: routes.filter((r) => r.path.includes(path11) || path11.includes(r.path)).slice(0, 10).map((r) => r.path)
+        });
+      }
+      const content = await fs10.readFile(route.absolutePath, "utf8");
+      const { meta, middleware, layout } = extractPageMeta(content);
+      const { props, emits, slots, hasScriptSetup } = await parseVueComponent(route.absolutePath);
+      return jsonResult({
+        found: true,
+        route: { ...route, meta, middleware, layout },
+        component: { props, emits, slots, hasScriptSetup },
+        sourceLength: content.length
+      });
+    })
+  );
+}
+
+// src/tools/config.ts
+import { promises as fs11 } from "fs";
+import { z as z7 } from "zod";
+function registerConfigTools(server, ctx) {
+  server.tool(
+    "read_config",
+    "Read the resolved Nuxt config, or a single key by dot-notation (e.g. runtimeConfig.public.apiBase). Omit the key to return the whole config.",
+    {
+      key: z7.string().optional().describe("Dot-notation config key to read")
+    },
+    safe(async ({ key }) => {
+      const config = await ctx.config();
+      return jsonResult({
+        configFile: config.configPath,
+        sourceKind: config.sourceKind,
+        error: config.error,
+        value: getConfigValue(config.value, key)
+      });
+    })
+  );
+  server.tool(
+    "update_config",
+    "Update a nuxt.config value by dot-notation key. Returns a diff of the change. Dry-run by default; real writes require the server to be started with write authorization.",
+    {
+      key: z7.string().describe("Dot-notation config key, e.g. ssr or runtimeConfig.public.apiBase"),
+      value: z7.string().describe(`New value as JSON or a JS expression, e.g. "false" or "'https://api.example.com'"`),
+      dryRun: z7.boolean().optional().describe("When true (default), return the planned change without writing")
+    },
+    safe(async ({ key, value, dryRun }) => {
+      const auth = ctx.writeGuard.authorize(dryRun ?? true);
+      if (!auth.ok) return jsonResult(auth);
+      const config = await ctx.config();
+      if (!config.configPath || !config.source) {
+        return jsonResult({ ok: false, error: "No writable nuxt.config file found." });
+      }
+      let parsed;
+      let raw;
+      try {
+        parsed = JSON.parse(value);
+      } catch {
+        raw = value;
+      }
+      const { newSource, diff } = setConfigValue(config.source, key, parsed, raw);
+      if (dryRun ?? true) {
+        return jsonResult({ ok: true, written: false, dryRun: true, key, configFile: config.configPath, diff });
+      }
+      await fs11.writeFile(config.configPath, newSource, "utf8");
+      await ctx.invalidate();
+      return jsonResult({ ok: true, written: true, key, configFile: config.configPath, diff });
+    })
+  );
+}
+
+// src/tools/search.ts
+import { z as z8 } from "zod";
+
+// src/data/nuxt-docs.ts
+var DOCS = [
+  {
+    topic: "routing",
+    title: "File-based Routing",
+    body: "Nuxt maps files under pages/ to routes. `pages/index.vue` -> `/`, `pages/about.vue` -> `/about`, `pages/users/[id].vue` -> `/users/:id` (dynamic), `pages/users/[[id]].vue` -> `/users/:id?` (optional), and `pages/docs/[...slug].vue` -> `/docs/:slug(.*)*` (catch-all). Nested routes use a parent file with a same-named directory plus child pages. Use definePageMeta({ layout, middleware, ... }) to attach layout, middleware and route meta.",
+    related: ["components", "layers"]
+  },
+  {
+    topic: "nitro",
+    title: "Nitro Server Engine",
+    body: "Files under server/api/ become Nitro API endpoints. `server/api/hello.get.ts` handles GET `/api/hello`; the method suffix (get/post/put/patch/delete) is stripped from the URL. `server/middleware/` runs before every request, and `server/plugins/` run once at server startup. Handlers use H3: `defineEventHandler(event)`, `readBody(event)`, `readValidatedBody(event, schema.safeParse)`, and `createError({ statusCode, statusMessage })`.",
+    related: ["routing"]
+  },
+  {
+    topic: "modules",
+    title: "Nuxt Modules",
+    body: "Modules are added via the `modules` array in nuxt.config, e.g. `modules: ['@nuxtjs/i18n']` or `['@nuxtjs/i18n', { locales: ['en'] }]`. They run at build time and can register components, composables, plugins, and config. Keep Nuxt modules in devDependencies, not dependencies. Local modules can be functions: `modules: [function () { ... }]`.",
+    related: ["config"]
+  },
+  {
+    topic: "layers",
+    title: "Nuxt Layers (extends)",
+    body: "`extends: ['../layer-a', '../layer-b']` composes multiple Nuxt projects into one app. Later entries override earlier ones, and the local project overrides all layers. Components, pages, composables, and config resolve across layers by priority; auto-imports and assets follow the same override chain. Use layers to share UI kits or split a monolith.",
+    related: ["routing", "components", "config"]
+  },
+  {
+    topic: "composables",
+    title: "Composables & Auto-imports",
+    body: "Files in composables/ (and utils/) are auto-imported when they export a `useXxx` function. `composables/useFoo.ts` exports `useFoo` and is usable anywhere without an import statement. Nuxt also auto-imports Vue APIs (ref, computed, watch) and lifecycle hooks. The registry lives in `.nuxt/imports.d.ts` after `nuxi prepare`.",
+    related: ["components"]
+  },
+  {
+    topic: "config",
+    title: "Nuxt Configuration",
+    body: "nuxt.config.ts exports `defineNuxtConfig({ ... })`. Common keys: `ssr`, `modules`, `extends`, `runtimeConfig.public` (exposed to the client), `nitro`, `app.head`, and `css`. Runtime config is read with `useRuntimeConfig()`. Prefer `runtimeConfig` over hard-coded env access so values are typed and overridable.",
+    related: ["modules", "layers"]
+  },
+  {
+    topic: "components",
+    title: "Vue Components",
+    body: 'Files in components/ are auto-imported by their PascalCase path, e.g. `components/base/BaseButton.vue` -> `<BaseButton>`. Use `<script setup lang="ts">` with `defineProps<{...}>()` for typed props and `defineEmits<{...}>()` for events. Slots are declared with `<slot name="...">`; the unnamed slot is the default slot.',
+    related: ["composables"]
+  }
+];
+function getNuxtDocs(topic) {
+  const t = topic.trim().toLowerCase();
+  return DOCS.find((d) => d.topic === t || d.title.toLowerCase().includes(t)) ?? null;
+}
+function listNuxtDocsTopics() {
+  return DOCS.map((d) => d.topic);
+}
+
+// src/tools/search.ts
+function registerSearchTools(server, ctx) {
+  server.tool(
+    "search_code",
+    "Search project source files for a substring or regex. Returns matching files with line/column numbers and surrounding context lines.",
+    {
+      query: z8.string().describe("Substring or regex to search for"),
+      fileTypes: z8.array(z8.string()).optional().describe('Optional file extensions, e.g. ["vue", "ts"]'),
+      maxResults: z8.number().int().min(1).max(200).optional().describe("Maximum number of results (default 50)")
+    },
+    safe(async ({ query, fileTypes, maxResults }) => {
+      const matches = await searchCode(ctx.root, query, fileTypes, maxResults ?? 50);
+      return jsonResult({ query, count: matches.length, matches });
+    })
+  );
+  server.tool(
+    "get_nuxt_docs",
+    "Get targeted offline Nuxt documentation guidance for a feature area (routing, nitro, modules, layers, composables, config, components).",
+    {
+      topic: z8.string().describe("Feature topic, e.g. routing, nitro, modules, layers")
+    },
+    safe(async ({ topic }) => {
+      const doc = getNuxtDocs(topic);
+      if (!doc) return jsonResult({ found: false, topic, available: listNuxtDocsTopics() });
+      return jsonResult({ found: true, ...doc });
+    })
+  );
+}
+
+// src/tools/layers.ts
+function registerLayerTools(server, ctx) {
+  server.tool(
+    "inspect_layers",
+    "Resolve and return the full Nuxt extends hierarchy (layers). Returns layers ordered by override priority (project first), with each layer's config file, raw extends, and sub-layers.",
+    safe(async () => {
+      const layers = await ctx.layers();
+      return jsonResult({ count: layers.length, layers });
+    })
+  );
+}
+
+// src/utils/tsc-checker.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import path9 from "path";
+function parseTscOutput(output) {
+  const diagnostics = [];
+  for (const line of output.split("\n")) {
+    const m = line.match(/^([^(]+)\((\d+),(\d+)\):\s*(error|warning)\s+TS(\d+):\s+(.+)$/);
+    if (!m) continue;
+    diagnostics.push({
+      file: m[1].trim() || void 0,
+      line: Number(m[2]),
+      column: Number(m[3]),
+      severity: m[4] === "error" ? "error" : "warning",
+      code: Number(m[5]),
+      message: m[6].trim()
+    });
+  }
+  return diagnostics;
+}
+function findTsc(root) {
+  const tsBin = path9.join(root, "node_modules", "typescript", "bin", "tsc");
+  if (existsSync2(tsBin)) return { cmd: process.execPath, args: [tsBin] };
+  const bin = path9.join(root, "node_modules", ".bin", "tsc");
+  if (existsSync2(bin)) return { cmd: bin, args: [] };
+  return null;
+}
+async function runTscCheck(root) {
+  const tsconfigs = [path9.join(root, ".nuxt", "tsconfig.json"), path9.join(root, "tsconfig.json")];
+  const tsconfig = tsconfigs.find((f) => existsSync2(f));
+  if (!tsconfig) return { ran: false, diagnostics: [] };
+  const tsc = findTsc(root);
+  if (!tsc) return { ran: false, diagnostics: [] };
+  const args = [...tsc.args, "--noEmit", "-p", tsconfig];
+  const output = await new Promise((resolve2, reject) => {
+    const child = spawn(tsc.cmd, args, { cwd: root });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => stdout += d.toString());
+    child.stderr.on("data", (d) => stderr += d.toString());
+    child.on("close", () => resolve2(`${stdout}
+${stderr}`));
+    child.on("error", reject);
+  });
+  return {
+    ran: true,
+    diagnostics: parseTscOutput(output),
+    command: [tsc.cmd, ...args].join(" ")
+  };
+}
+
+// src/tools/diagnostics.ts
+function registerDiagnosticTools(server, ctx) {
+  server.tool(
+    "check_type_errors",
+    "Run a TypeScript type check against .nuxt/tsconfig.json (or the project tsconfig.json) and return structured diagnostics with file, line, column, code and severity.",
+    safe(async () => {
+      const result = await runTscCheck(ctx.root);
+      return jsonResult({
+        ran: result.ran,
+        errors: result.diagnostics.filter((d) => d.severity === "error").length,
+        warnings: result.diagnostics.filter((d) => d.severity === "warning").length,
+        command: result.command,
+        diagnostics: result.diagnostics
+      });
+    })
+  );
+  server.tool(
+    "analyze_bundle_deps",
+    "Analyze package.json dependencies: classify Nuxt modules vs runtime/dev dependencies and surface warnings for misplaced or missing modules.",
+    safe(async () => {
+      return jsonResult(await analyzeBundleDeps(ctx.root));
+    })
+  );
+}
+
+// src/tools/index.ts
+function registerAllTools(server, ctx) {
+  registerOverviewTools(server, ctx);
+  registerRouteTools(server, ctx);
+  registerComponentTools(server, ctx);
+  registerComposableTools(server, ctx);
+  registerServerApiTools(server, ctx);
+  registerModuleTools(server, ctx);
+  registerPageTools(server, ctx);
+  registerConfigTools(server, ctx);
+  registerSearchTools(server, ctx);
+  registerLayerTools(server, ctx);
+  registerDiagnosticTools(server, ctx);
+}
+
+// src/resources/layers-graph.ts
+var LAYERS_URI = "nuxt://project/layers";
+function registerLayersResource(server, ctx) {
+  server.registerResource(
+    "project-layers",
+    LAYERS_URI,
+    {
+      title: "Nuxt Layers",
+      description: "Resolved extends hierarchy with override priority order",
+      mimeType: "application/json"
+    },
+    async () => {
+      const layers = await ctx.layers();
+      return {
+        contents: [
+          {
+            uri: LAYERS_URI,
+            mimeType: "application/json",
+            text: JSON.stringify({ count: layers.length, layers }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/resources/auto-imports.ts
+var AUTO_IMPORTS_URI = "nuxt://project/auto-imports";
+var TYPES_URI = "nuxt://project/types";
+function registerAutoImportsResource(server, ctx) {
+  server.registerResource(
+    "project-auto-imports",
+    AUTO_IMPORTS_URI,
+    {
+      title: "Nuxt Auto-imports Registry",
+      description: "Every auto-imported symbol with source path and type signature (from .nuxt/imports.d.ts)",
+      mimeType: "application/json"
+    },
+    async () => {
+      const { built, imports } = await ctx.autoImports();
+      return {
+        contents: [
+          {
+            uri: AUTO_IMPORTS_URI,
+            mimeType: "application/json",
+            text: JSON.stringify({ built, count: imports.length, imports }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.registerResource(
+    "project-types",
+    TYPES_URI,
+    {
+      title: "Nuxt Generated Types",
+      description: "Raw generated type info (.nuxt/imports.d.ts, .nuxt/types file list, nuxt.schema.json)",
+      mimeType: "application/json"
+    },
+    async () => {
+      const info = await ctx.typeInfo();
+      return {
+        contents: [
+          {
+            uri: TYPES_URI,
+            mimeType: "application/json",
+            text: JSON.stringify(info, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/resources/project-structure.ts
+var OVERVIEW_URI = "nuxt://project/overview";
+function registerProjectStructureResource(server, ctx) {
+  server.registerResource(
+    "project-overview",
+    OVERVIEW_URI,
+    {
+      title: "Nuxt Project Overview",
+      description: "High-level overview of the Nuxt project structure and counts",
+      mimeType: "application/json"
+    },
+    async () => {
+      const { overview } = await ctx.snapshot();
+      return {
+        contents: [
+          {
+            uri: OVERVIEW_URI,
+            mimeType: "application/json",
+            text: JSON.stringify(overview, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/resources/route-map.ts
+var ROUTES_URI = "nuxt://project/routes";
+function registerRouteMapResource(server, ctx) {
+  server.registerResource(
+    "project-routes",
+    ROUTES_URI,
+    {
+      title: "Nuxt Route Map",
+      description: "Full resolved route map with files, params, middleware and layouts",
+      mimeType: "application/json"
+    },
+    async () => {
+      const { routes } = await ctx.snapshot();
+      return {
+        contents: [
+          {
+            uri: ROUTES_URI,
+            mimeType: "application/json",
+            text: JSON.stringify({ count: routes.length, routes }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/resources/nuxt-config.ts
+var CONFIG_URI = "nuxt://project/config";
+function registerNuxtConfigResource(server, ctx) {
+  server.registerResource(
+    "project-config",
+    CONFIG_URI,
+    {
+      title: "Nuxt Config",
+      description: "Current resolved Nuxt configuration object",
+      mimeType: "application/json"
+    },
+    async () => {
+      const config = await ctx.config();
+      return {
+        contents: [
+          {
+            uri: CONFIG_URI,
+            mimeType: "application/json",
+            text: JSON.stringify(
+              {
+                configFile: config.configPath,
+                sourceKind: config.sourceKind,
+                error: config.error,
+                value: config.value
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/resources/module-graph.ts
+var MODULES_URI = "nuxt://project/modules";
+function registerModuleGraphResource(server, ctx) {
+  server.registerResource(
+    "project-modules",
+    MODULES_URI,
+    {
+      title: "Nuxt Modules",
+      description: "Installed Nuxt modules with status, source and configuration",
+      mimeType: "application/json"
+    },
+    async () => {
+      const { modules } = await ctx.snapshot();
+      return {
+        contents: [
+          {
+            uri: MODULES_URI,
+            mimeType: "application/json",
+            text: JSON.stringify({ count: modules.length, modules }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/resources/index.ts
+function registerAllResources(server, ctx) {
+  registerProjectStructureResource(server, ctx);
+  registerRouteMapResource(server, ctx);
+  registerNuxtConfigResource(server, ctx);
+  registerModuleGraphResource(server, ctx);
+  registerLayersResource(server, ctx);
+  registerAutoImportsResource(server, ctx);
+}
+
+// src/utils/file-watcher.ts
+import { EventEmitter } from "events";
+import { promises as fs12 } from "fs";
+import path10 from "path";
+var ProjectWatcher = class extends EventEmitter {
+  constructor(root, intervalMs = 2e3) {
+    super();
+    this.root = root;
+    this.intervalMs = intervalMs;
+  }
+  root;
+  intervalMs;
+  timers = /* @__PURE__ */ new Map();
+  snapshots = /* @__PURE__ */ new Map();
+  running = false;
+  async start() {
+    if (this.running) return;
+    this.running = true;
+    await this.scan();
+    this.loop();
+  }
+  stop() {
+    this.running = false;
+    for (const timer of this.timers.values()) clearTimeout(timer);
+    this.timers.clear();
+  }
+  async loop() {
+    while (this.running) {
+      await new Promise((resolve2) => setTimeout(resolve2, this.intervalMs));
+      await this.scan();
+    }
+  }
+  async scan() {
+    const files = await this.walk(this.root);
+    const seen = /* @__PURE__ */ new Set();
+    for (const file of files) {
+      seen.add(file);
+      const before = this.snapshots.get(file);
+      const after = await this.hash(file);
+      if (before === void 0) {
+        this.snapshots.set(file, after);
+        this.emit("change", { type: "add", path: file });
+      } else if (before !== after) {
+        this.snapshots.set(file, after);
+        this.emit("change", { type: "change", path: file });
+      }
+    }
+    for (const [file] of this.snapshots) {
+      if (!seen.has(file)) {
+        this.snapshots.delete(file);
+        this.emit("change", { type: "unlink", path: file });
+      }
+    }
+  }
+  async walk(dir) {
+    const out = [];
+    let entries;
+    try {
+      entries = await fs12.readdir(dir, { withFileTypes: true });
+    } catch {
+      return out;
+    }
+    for (const entry of entries) {
+      if (entry.name === "node_modules" || entry.name === ".nuxt" || entry.name === ".output" || entry.name === ".git" || entry.name === "dist") continue;
+      const full = path10.join(dir, entry.name);
+      if (entry.isDirectory()) out.push(...await this.walk(full));
+      else if (entry.isFile()) out.push(full);
+    }
+    return out;
+  }
+  async hash(file) {
+    try {
+      const stat = await fs12.stat(file);
+      return `${stat.size}:${stat.mtimeMs}`;
+    } catch {
+      return "missing";
+    }
+  }
+};
+
+// src/server.ts
+async function setupServer(server, projectPath2, options = {}) {
+  const ctx = new NuxtProjectContext(projectPath2, options);
+  registerAllTools(server, ctx);
+  registerAllResources(server, ctx);
+  const watcher = new ProjectWatcher(ctx.root);
+  let timer;
+  watcher.on("change", () => {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      void ctx.invalidate();
+    }, 300);
+  });
+  void watcher.start();
+  return { ctx, watcher };
+}
+
+// src/index.ts
+var projectPath = resolve(process.cwd(), process.argv[2] || ".");
+var allowWrites = process.argv.includes("--allow-writes") || process.env.MCP_NUXT_ALLOW_WRITES === "1";
+async function main() {
+  const server = new McpServer({
+    name: "mcp-server-nuxt",
+    version: "0.2.0"
+  });
+  await setupServer(server, projectPath, { allowWrites });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error(`MCP Nuxt Server started for project: ${projectPath}`);
+}
+main().catch((error) => {
+  console.error("MCP Nuxt Server crashed:", error);
+  process.exit(1);
+});