@inspecto-dev/plugin 0.2.0-alpha.0

package/dist/vite.js

@@ -0,0 +1,1058 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import { createUnplugin } from "unplugin";
+
+// src/transform/utils.ts
+var DEFAULT_ESCAPE_TAGS = /* @__PURE__ */ new Set([
+  "template",
+  "script",
+  "style",
+  // React special elements
+  "Fragment",
+  "React.Fragment",
+  "StrictMode",
+  "React.StrictMode",
+  "Suspense",
+  "React.Suspense",
+  "Profiler",
+  "React.Profiler",
+  // React transitions
+  "Transition",
+  "TransitionGroup",
+  // Vue built-in components
+  "KeepAlive",
+  "Teleport",
+  "Suspense",
+  // Vue router built-ins
+  "RouterView",
+  "RouterLink",
+  "NuxtPage",
+  "NuxtLink"
+]);
+var JSX_EXTENSIONS = /* @__PURE__ */ new Set([".jsx", ".tsx", ".js", ".ts", ".mjs", ".mts"]);
+function shouldTransform(filePath, options) {
+  if (process.env["NODE_ENV"] === "production") return false;
+  if (filePath.includes("node_modules")) return false;
+  if (filePath.startsWith("\0")) return false;
+  if (/[/\\](dist|build|\.next|\.nuxt)[/\\]/.test(filePath)) return false;
+  return true;
+}
+function buildEscapeTagsSet(escapeTags) {
+  const merged = new Set(DEFAULT_ESCAPE_TAGS);
+  if (escapeTags) {
+    for (const tag of escapeTags) {
+      merged.add(tag);
+    }
+  }
+  return merged;
+}
+function formatAttrValue(file, line, column) {
+  return `${file}:${line}:${column}`;
+}
+
+// src/transform/index.ts
+import path3 from "path";
+
+// src/transform/transform-jsx.ts
+import * as parser from "@babel/parser";
+import traverse_ from "@babel/traverse";
+import MagicString from "magic-string";
+import path from "path";
+var traverse = typeof traverse_ === "function" ? traverse_ : traverse_.default || traverse_;
+function transformJsx(options) {
+  const {
+    filePath,
+    source,
+    projectRoot,
+    escapeTags,
+    pathType = "absolute",
+    attributeName = "data-inspecto"
+  } = options;
+  const escapeTagsSet = buildEscapeTagsSet(escapeTags);
+  const resolvedPath = pathType === "absolute" ? path.resolve(filePath) : path.relative(projectRoot, path.resolve(filePath));
+  const normalizedPath = resolvedPath.replace(/\\/g, "/");
+  let ast;
+  try {
+    ast = parser.parse(source, {
+      sourceType: "module",
+      plugins: [
+        "jsx",
+        "typescript",
+        "decorators-legacy",
+        "classProperties",
+        "optionalChaining",
+        "nullishCoalescingOperator",
+        "importMeta"
+      ],
+      errorRecovery: true
+    });
+  } catch {
+    return { code: source, map: null, changed: false };
+  }
+  const ms = new MagicString(source);
+  let changed = false;
+  traverse(ast, {
+    JSXOpeningElement(nodePath) {
+      const node = nodePath.node;
+      const alreadyHasAttr = node.attributes.some(
+        (attr) => attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && attr.name.name === attributeName
+      );
+      if (alreadyHasAttr) return;
+      const nameNode = node.name;
+      let tagName;
+      if (nameNode.type === "JSXIdentifier") {
+        tagName = nameNode.name;
+      } else if (nameNode.type === "JSXMemberExpression") {
+        const objName = nameNode.object.type === "JSXIdentifier" ? nameNode.object.name : "";
+        const propName = nameNode.property.type === "JSXIdentifier" ? nameNode.property.name : "";
+        tagName = objName && propName ? `${objName}.${propName}` : objName;
+      } else {
+        tagName = "";
+      }
+      if (escapeTagsSet.has(tagName)) return;
+      const loc = node.loc;
+      if (!loc) return;
+      const { line, column } = loc.start;
+      const attrValue = formatAttrValue(normalizedPath, line, column + 1);
+      let insertPos = null;
+      if (node.attributes && node.attributes.length > 0) {
+        const firstAttr = node.attributes[0];
+        if (firstAttr && firstAttr.start != null) {
+          insertPos = firstAttr.start;
+        }
+      }
+      if (insertPos == null) {
+        if (node.typeParameters && node.typeParameters.end != null) {
+          insertPos = node.typeParameters.end;
+        } else if (node.name.end != null) {
+          insertPos = node.name.end;
+        }
+      }
+      if (insertPos == null) return;
+      ms.appendLeft(
+        insertPos,
+        ` ${attributeName}="${attrValue}"${node.attributes && node.attributes.length > 0 ? "" : " "}`
+      );
+      changed = true;
+    }
+  });
+  if (!changed) {
+    return { code: source, map: null, changed: false };
+  }
+  return {
+    code: ms.toString(),
+    map: ms.generateMap({ hires: true, source: filePath }),
+    changed: true
+  };
+}
+
+// src/transform/transform-vue.ts
+import * as vueCompiler from "@vue/compiler-dom";
+import { parse as parseSFC } from "@vue/compiler-sfc";
+import { NodeTypes } from "@vue/compiler-core";
+import MagicString2 from "magic-string";
+import path2 from "path";
+function transformVue(options) {
+  const {
+    filePath,
+    source,
+    projectRoot,
+    escapeTags,
+    pathType = "absolute",
+    attributeName = "data-inspecto"
+  } = options;
+  const escapeTagsSet = buildEscapeTagsSet(escapeTags);
+  const resolvedPath = pathType === "absolute" ? path2.resolve(filePath) : path2.relative(projectRoot, path2.resolve(filePath));
+  const normalizedPath = resolvedPath.replace(/\\/g, "/");
+  const { descriptor, errors } = parseSFC(source, {
+    filename: filePath,
+    sourceMap: false,
+    ignoreEmpty: true
+  });
+  if (errors.length > 0 || !descriptor.template) {
+    return { code: source, map: null, changed: false };
+  }
+  const templateContent = descriptor.template.content;
+  const templateBlockStart = descriptor.template.loc.start.offset;
+  let ast;
+  try {
+    ast = vueCompiler.parse(templateContent, {
+      parseMode: "html",
+      // Preserve source locations relative to templateContent
+      onError: () => {
+      }
+    });
+  } catch {
+    return { code: source, map: null, changed: false };
+  }
+  const ms = new MagicString2(source);
+  let changed = false;
+  walkElement(ast, (node) => {
+    if (node.type !== NodeTypes.ELEMENT) return;
+    const tagName = node.tag;
+    if (escapeTagsSet.has(tagName)) return;
+    if (tagName === "template" && node === ast.children[0]) return;
+    const alreadyHasAttr = node.props.some(
+      (p) => p.type === NodeTypes.ATTRIBUTE && p.name === attributeName
+    );
+    if (alreadyHasAttr) return;
+    const loc = node.loc;
+    if (!loc) return;
+    const { line, column } = loc.start;
+    const attrValue = formatAttrValue(normalizedPath, line, column + 1);
+    const tagNameEnd = loc.start.offset + tagName.length + 1;
+    const absoluteOffset = templateBlockStart + tagNameEnd;
+    ms.appendLeft(absoluteOffset, ` ${attributeName}="${attrValue}"`);
+    changed = true;
+  });
+  if (!changed) {
+    return { code: source, map: null, changed: false };
+  }
+  return {
+    code: ms.toString(),
+    map: ms.generateMap({ hires: true, source: filePath }),
+    changed: true
+  };
+}
+function walkElement(node, visitor) {
+  if (node.type === NodeTypes.ELEMENT) {
+    visitor(node);
+    for (const child of node.children) {
+      walkElement(child, visitor);
+    }
+  } else if ("children" in node && Array.isArray(node.children)) {
+    for (const child of node.children) {
+      walkElement(child, visitor);
+    }
+  }
+}
+
+// src/transform/index.ts
+function transformRouter(options) {
+  const { filePath, source, projectRoot, pluginOptions } = options;
+  const ext = path3.extname(filePath).toLowerCase();
+  if (JSX_EXTENSIONS.has(ext)) {
+    return transformJsx({
+      filePath,
+      source,
+      projectRoot,
+      escapeTags: pluginOptions.escapeTags,
+      pathType: pluginOptions.pathType,
+      attributeName: pluginOptions.attributeName
+    });
+  }
+  if (ext === ".vue") {
+    return transformVue({
+      filePath,
+      source,
+      projectRoot,
+      escapeTags: pluginOptions.escapeTags,
+      pathType: pluginOptions.pathType,
+      attributeName: pluginOptions.attributeName
+    });
+  }
+  return null;
+}
+
+// src/server/index.ts
+import http from "http";
+import fs3 from "fs";
+import path6 from "path";
+import os2 from "os";
+import { execSync, execFileSync } from "child_process";
+import portfinder from "portfinder";
+import { launchIDE } from "launch-ide";
+
+// src/server/snippet.ts
+import * as fs from "fs";
+import * as path4 from "path";
+import * as parser2 from "@babel/parser";
+import traverse_2 from "@babel/traverse";
+var traverse2 = typeof traverse_2 === "function" ? traverse_2 : traverse_2.default || traverse_2;
+var snippetCache = /* @__PURE__ */ new Map();
+var DEFAULT_MAX_LINES = 100;
+var DEFAULT_CONTEXT_LINES_BEFORE = 5;
+async function extractSnippet(req) {
+  const { file, line, column, maxLines = DEFAULT_MAX_LINES } = req;
+  const absolutePath = path4.resolve(file);
+  let stat;
+  try {
+    stat = await fs.promises.stat(absolutePath);
+  } catch {
+    throw new Error(`FILE_NOT_FOUND: ${absolutePath}`);
+  }
+  const mtime = stat.mtimeMs;
+  let lines;
+  const cached = snippetCache.get(absolutePath);
+  if (cached && cached.mtime === mtime) {
+    lines = cached.lines;
+  } else {
+    const source = await fs.promises.readFile(absolutePath, "utf-8");
+    lines = source.split("\n");
+    snippetCache.set(absolutePath, { mtime, lines });
+  }
+  let snippetLines;
+  let startLine;
+  let componentName;
+  try {
+    const result = extractComponentBoundary(lines.join("\n"), line, column, maxLines);
+    snippetLines = result.lines;
+    startLine = result.startLine;
+    componentName = result.name;
+  } catch {
+    const before = Math.max(0, line - 1 - DEFAULT_CONTEXT_LINES_BEFORE);
+    const after = Math.min(lines.length, before + maxLines);
+    snippetLines = lines.slice(before, after);
+    startLine = before + 1;
+  }
+  if (snippetLines.length > maxLines) {
+    snippetLines = snippetLines.slice(0, maxLines);
+  }
+  return {
+    snippet: snippetLines.join("\n"),
+    startLine,
+    file: absolutePath,
+    ...componentName ? { name: componentName } : {}
+  };
+}
+function extractComponentBoundary(source, targetLine, _targetColumn, maxLines) {
+  const ast = parser2.parse(source, {
+    sourceType: "module",
+    plugins: ["jsx", "typescript", "decorators-legacy", "classProperties"],
+    errorRecovery: true
+  });
+  const allLines = source.split("\n");
+  let bestStart = 0;
+  let bestEnd = allLines.length - 1;
+  let bestName;
+  traverse2(ast, {
+    "FunctionDeclaration|FunctionExpression|ArrowFunctionExpression|ClassMethod"(nodePath) {
+      const node = nodePath.node;
+      if (!node.loc) return;
+      const nodeStart = node.loc.start.line;
+      const nodeEnd = node.loc.end.line;
+      if (targetLine < nodeStart || targetLine > nodeEnd) return;
+      if (nodeEnd - nodeStart < bestEnd - bestStart) {
+        bestStart = nodeStart - 1;
+        bestEnd = nodeEnd - 1;
+        bestName = extractFunctionName(nodePath);
+      }
+    }
+  });
+  let sliceStart = bestStart;
+  let sliceEnd = bestEnd + 1;
+  if (sliceEnd - sliceStart > maxLines) {
+    const targetIdx = targetLine - 1;
+    sliceStart = Math.max(bestStart, targetIdx - Math.floor(maxLines / 3));
+    sliceEnd = sliceStart + maxLines;
+    if (sliceEnd > bestEnd + 1) {
+      sliceEnd = bestEnd + 1;
+      sliceStart = Math.max(0, sliceEnd - maxLines);
+    }
+  }
+  return {
+    lines: allLines.slice(sliceStart, sliceEnd),
+    startLine: sliceStart + 1,
+    ...bestName ? { name: bestName } : {}
+  };
+}
+function extractFunctionName(nodePath) {
+  const node = nodePath.node;
+  if (node.type === "FunctionDeclaration" && node.id) {
+    return node.id.name;
+  }
+  const parent = nodePath.parent;
+  if ((node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") && parent.type === "VariableDeclarator" && parent.id.type === "Identifier") {
+    return parent.id.name;
+  }
+  if (node.type === "ClassMethod" && node.key.type === "Identifier") {
+    return node.key.name;
+  }
+  return void 0;
+}
+
+// src/config.ts
+import fs2 from "fs";
+import path5 from "path";
+import os from "os";
+import { createDefu } from "defu";
+import { DEFAULT_TOOL_MODE, VALID_MODES } from "@inspecto-dev/types";
+var loadedConfig = null;
+var loadedPrompts = null;
+var isWatching = false;
+var arrayReplaceMerge = createDefu((obj, key, val) => {
+  if (Array.isArray(val)) {
+    obj[key] = val;
+    return true;
+  }
+});
+function resolveConfigRoots(cwd, gitRoot) {
+  const roots = [];
+  let current = cwd;
+  const isUnderOrEqual = current === gitRoot || current.startsWith(gitRoot + path5.sep);
+  if (!isUnderOrEqual) {
+    if (fs2.existsSync(path5.join(cwd, ".inspecto"))) roots.push(cwd);
+    return roots;
+  }
+  while (true) {
+    if (fs2.existsSync(path5.join(current, ".inspecto"))) {
+      roots.push(current);
+    }
+    if (current === gitRoot) break;
+    const parent = path5.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return roots;
+}
+function loadUserConfigSync(force = false, cwd = process.cwd(), gitRoot) {
+  if (loadedConfig && !force) return loadedConfig;
+  loadedConfig = null;
+  const layers = [];
+  const roots = resolveConfigRoots(cwd, gitRoot ?? cwd);
+  for (const root of roots) {
+    layers.push(readJsonSafely(path5.join(root, ".inspecto", "settings.local.json")));
+    layers.push(readJsonSafely(path5.join(root, ".inspecto", "settings.json")));
+  }
+  layers.push(readJsonSafely(path5.join(os.homedir(), ".inspecto", "settings.json")));
+  layers.push({ providers: {} });
+  const validLayers = layers.filter((l) => l !== null);
+  loadedConfig = arrayReplaceMerge(...validLayers);
+  return loadedConfig;
+}
+async function loadPromptsConfig(force = false, cwd = process.cwd(), gitRoot) {
+  if (loadedPrompts && !force) return loadedPrompts;
+  const layers = [];
+  const roots = resolveConfigRoots(cwd, gitRoot ?? cwd);
+  for (const root of roots) {
+    const localPath = path5.join(root, ".inspecto", "prompts.local.json");
+    const jsonPath = path5.join(root, ".inspecto", "prompts.json");
+    layers.push(readJsonSafely(localPath));
+    layers.push(readJsonSafely(jsonPath));
+  }
+  layers.push(readJsonSafely(path5.join(os.homedir(), ".inspecto", "prompts.json")));
+  let finalPrompts = [];
+  for (const layer of layers) {
+    if (Array.isArray(layer) && layer.length > 0) {
+      finalPrompts = layer;
+      break;
+    }
+    if (layer && typeof layer === "object" && layer.$replace === true && Array.isArray(layer.items)) {
+      finalPrompts = layer;
+      break;
+    }
+  }
+  loadedPrompts = finalPrompts;
+  return loadedPrompts;
+}
+function readJsonSafely(filePath) {
+  try {
+    if (fs2.existsSync(filePath)) {
+      const content = fs2.readFileSync(filePath, "utf-8").trim();
+      if (!content) return null;
+      const parsed = JSON.parse(content);
+      if (!Array.isArray(parsed) && parsed.prompts && Array.isArray(parsed.prompts)) {
+        return parsed.prompts;
+      }
+      return parsed;
+    }
+  } catch (e) {
+    if (e instanceof SyntaxError) {
+      console.warn(`[inspecto] Failed to parse config at ${filePath}: Invalid JSON`);
+    } else {
+      console.warn(`[inspecto] Failed to read config at ${filePath}:`, e);
+    }
+  }
+  return null;
+}
+function resolveTargetTool(config) {
+  if (config.prefer) {
+    return config.prefer;
+  }
+  if (config.providers && Object.keys(config.providers).length > 0) {
+    return Object.keys(config.providers)[0];
+  }
+  return "github-copilot";
+}
+function resolveToolMode(tool, ide, config) {
+  let requestedType = void 0;
+  if (config.providers && config.providers[tool] && config.providers[tool].type) {
+    const type = config.providers[tool].type;
+    if (type === "plugin" || type === "cli") {
+      requestedType = type;
+    }
+  }
+  requestedType = requestedType ?? DEFAULT_TOOL_MODE[tool];
+  const valid = VALID_MODES[tool] || [DEFAULT_TOOL_MODE[tool]];
+  return requestedType && valid.includes(requestedType) ? requestedType : valid[0];
+}
+function extractToolOverrides(ide, config) {
+  const result = {};
+  if (!config.providers) return result;
+  for (const [tool, cfg] of Object.entries(config.providers)) {
+    if (!cfg) continue;
+    const overrides = {
+      type: cfg.type || DEFAULT_TOOL_MODE[tool] || "plugin"
+    };
+    if (cfg.bin) overrides.binaryPath = cfg.bin;
+    if (cfg.args) overrides.args = cfg.args;
+    if (cfg.cwd) overrides.cwd = cfg.cwd;
+    if (cfg.autoSend !== void 0) overrides.autoSend = cfg.autoSend;
+    result[tool] = overrides;
+  }
+  return result;
+}
+var watchers = [];
+function watchConfig(onReload, cwd = process.cwd(), gitRoot) {
+  if (isWatching) return;
+  isWatching = true;
+  const watchDirs = [path5.join(os.homedir(), ".inspecto")];
+  const roots = resolveConfigRoots(cwd, gitRoot ?? cwd);
+  for (const root of roots) {
+    watchDirs.push(path5.join(root, ".inspecto"));
+  }
+  const CONFIG_FILES = /* @__PURE__ */ new Set([
+    "settings.json",
+    "settings.local.json",
+    "prompts.json",
+    "prompts.local.json"
+  ]);
+  for (const dir of watchDirs) {
+    if (!fs2.existsSync(dir)) continue;
+    try {
+      const watcher = fs2.watch(dir, async (eventType, filename) => {
+        if (!filename || !CONFIG_FILES.has(filename)) return;
+        loadedConfig = null;
+        loadedPrompts = null;
+        loadUserConfigSync(true, cwd, gitRoot);
+        await loadPromptsConfig(true, cwd, gitRoot);
+        onReload();
+      });
+      watcher.unref();
+      watchers.push(watcher);
+    } catch (e) {
+    }
+  }
+}
+
+// src/server/index.ts
+var serverState = {
+  port: null,
+  running: false,
+  projectRoot: "",
+  configRoot: "",
+  cwd: process.cwd()
+};
+var serverInstance = null;
+function resolveProjectRoot() {
+  let gitRoot;
+  try {
+    gitRoot = execSync("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
+  } catch {
+    gitRoot = process.cwd();
+  }
+  let current = gitRoot;
+  while (true) {
+    if (fs3.existsSync(path6.join(current, ".inspecto"))) return current;
+    const parent = path6.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return gitRoot;
+}
+function launchURI(uri) {
+  try {
+    if (process.platform === "darwin") {
+      execFileSync("open", [uri]);
+    } else if (process.platform === "win32") {
+      execFileSync("cmd", ["/c", "start", '""', uri]);
+    } else {
+      execFileSync("xdg-open", [uri]);
+    }
+  } catch (e) {
+    console.error("[inspecto] Failed to launch URI via execFileSync, falling back to launchIDE:", e);
+    launchIDE({ file: uri });
+  }
+}
+async function startServer() {
+  if (serverState.running && serverState.port !== null) {
+    return serverState.port;
+  }
+  serverState.projectRoot = resolveProjectRoot();
+  serverState.configRoot = serverState.projectRoot;
+  serverState.cwd = process.cwd();
+  portfinder.basePort = 5678;
+  const port = await portfinder.getPortPromise();
+  watchConfig(
+    () => {
+      console.log("[inspecto] user config reloaded.");
+    },
+    serverState.cwd,
+    serverState.configRoot
+  );
+  serverInstance = http.createServer((req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+    handleRequest(url, req, res).catch((err) => {
+      console.error("[inspecto] server error:", err);
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: String(err) }));
+    });
+  });
+  await new Promise((resolve2, reject) => {
+    serverInstance.listen(port, "127.0.0.1", () => {
+      serverInstance.unref();
+      resolve2();
+    });
+    serverInstance.once("error", reject);
+  });
+  serverInstance.on("error", (err) => {
+    console.error("[inspecto] persistent server error:", err);
+  });
+  serverState.port = port;
+  serverState.running = true;
+  const portFile = path6.join(os2.tmpdir(), "inspecto.port");
+  try {
+    fs3.writeFileSync(portFile, String(port), "utf-8");
+  } catch {
+  }
+  process.once("exit", () => {
+    try {
+      fs3.unlinkSync(portFile);
+    } catch {
+    }
+  });
+  console.log(`[inspecto] server running at http://127.0.0.1:${port}`);
+  return port;
+}
+async function readBody(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve2(Buffer.concat(chunks).toString("utf-8")));
+    req.on("error", reject);
+  });
+}
+async function handleRequest(url, req, res) {
+  const pathname = url.pathname;
+  if (pathname === "/health" && req.method === "GET") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: true, port: serverState.port }));
+    return;
+  }
+  if (pathname === "/config" && req.method === "GET") {
+    const userConfig = loadUserConfigSync(false, serverState.cwd, serverState.configRoot);
+    const promptsConfig = await loadPromptsConfig(false, serverState.cwd, serverState.configRoot);
+    const effectiveIde = userConfig.ide ?? "vscode";
+    let info;
+    if (!serverState.ideInfo) {
+      const fallbackTargets = userConfig.providers ? Object.keys(userConfig.providers) : ["claude-code", "gemini", "coco", "codex"];
+      info = {
+        ide: effectiveIde,
+        providers: fallbackTargets.reduce(
+          (acc, target) => {
+            acc[target] = {
+              mode: resolveToolMode(target, effectiveIde, userConfig),
+              installed: false
+            };
+            return acc;
+          },
+          {}
+        )
+      };
+    } else {
+      const { scheme: _scheme, ...rest } = serverState.ideInfo;
+      info = rest;
+    }
+    const resolvedProviders = { ...info.providers };
+    for (const tool in resolvedProviders) {
+      resolvedProviders[tool].mode = resolveToolMode(tool, info.ide, userConfig);
+    }
+    const config = {
+      ...info,
+      providers: resolvedProviders,
+      providerOverrides: extractToolOverrides(info.ide, userConfig),
+      prompts: promptsConfig,
+      hotKeys: userConfig.hotKeys,
+      includeSnippet: userConfig.includeSnippet
+    };
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(config));
+    return;
+  }
+  if (pathname === "/config" && req.method === "POST") {
+    try {
+      const body = JSON.parse(await readBody(req));
+      serverState.ideInfo = body;
+      console.log(`[inspecto] Received IDE info from extension:`, body);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: true }));
+    } catch (e) {
+      console.error("[inspecto] Error parsing /config POST request:", e);
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Invalid JSON body" }));
+    }
+    return;
+  }
+  if (pathname === "/open" && req.method === "POST") {
+    let body;
+    try {
+      body = JSON.parse(await readBody(req));
+    } catch (e) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Invalid JSON body" }));
+      return;
+    }
+    const absolutePath = path6.isAbsolute(body.file) ? body.file : path6.resolve(serverState.cwd, body.file);
+    const userConfig = loadUserConfigSync(false, serverState.cwd, serverState.configRoot);
+    const ide = userConfig.ide ?? "vscode";
+    const editorHint = "code";
+    launchIDE({
+      file: absolutePath,
+      line: body.line,
+      column: body.column,
+      editor: editorHint,
+      type: process.platform === "darwin" ? "open" : "exec"
+    });
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ success: true }));
+    return;
+  }
+  if (pathname === "/snippet" && req.method === "GET") {
+    const file = url.searchParams.get("file") ?? "";
+    const line = parseInt(url.searchParams.get("line") ?? "1", 10);
+    const column = parseInt(url.searchParams.get("column") ?? "1", 10);
+    const maxLines = parseInt(url.searchParams.get("maxLines") ?? "100", 10);
+    try {
+      const absolutePath = path6.isAbsolute(file) ? file : path6.resolve(serverState.cwd, file);
+      const result = await extractSnippet({ file: absolutePath, line, column, maxLines });
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(result));
+    } catch (err) {
+      const message = String(err.message || err);
+      const errorCode = message.startsWith("FILE_NOT_FOUND") ? "FILE_NOT_FOUND" : "UNKNOWN";
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: message, errorCode }));
+    }
+    return;
+  }
+  if (pathname === "/send-to-ai" && req.method === "POST") {
+    try {
+      const rawBody = await readBody(req);
+      const body = JSON.parse(rawBody);
+      const result = await dispatchToAi(body);
+      res.writeHead(result.success ? 200 : 500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(result));
+    } catch (e) {
+      console.error("[inspecto] Error parsing /send-to-ai request:", e);
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: String(e), errorCode: "INTERNAL_ERROR" }));
+    }
+    return;
+  }
+  res.writeHead(404, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ error: "not found" }));
+}
+async function dispatchToAi(req) {
+  const { location, snippet, prompt } = req;
+  const userConfig = loadUserConfigSync(false, serverState.cwd, serverState.configRoot);
+  const ide = userConfig.ide ?? "vscode";
+  const resolvedTarget = resolveTargetTool(userConfig);
+  const formattedPrompt = prompt ?? `Please help me with this code from \`${location.file}\` (line ${location.line}):
+
+\`\`\`
+${snippet}
+\`\`\`
+`;
+  const params = new URLSearchParams();
+  params.set("target", resolvedTarget);
+  const overrides = extractToolOverrides(ide, userConfig)[resolvedTarget];
+  if (overrides) {
+    params.set("overrides", JSON.stringify(overrides));
+  }
+  params.set("prompt", formattedPrompt);
+  params.set("file", location.file);
+  params.set("line", String(location.line));
+  params.set("col", String(location.column));
+  params.set("snippet", snippet);
+  const scheme = serverState.ideInfo?.scheme || "vscode";
+  const uri = `${scheme}://inspecto.inspecto/send?${params.toString()}`;
+  console.log(`[inspecto] dispatchToAi: Generated URI: ${uri}`);
+  launchURI(uri);
+  return { success: true };
+}
+
+// src/injectors/utils.ts
+import { createRequire } from "module";
+var resolveClientModule = () => {
+  try {
+    return createRequire(import.meta.url).resolve("@inspecto-dev/core");
+  } catch {
+    try {
+      return __require.resolve("@inspecto-dev/core");
+    } catch {
+      console.warn("[inspecto] Could not resolve @inspecto-dev/core \u2014 falling back to bare specifier");
+      return "@inspecto-dev/core";
+    }
+  }
+};
+
+// src/injectors/webpack.ts
+function getWebpackHtmlScript(serverPort) {
+  return `
+window.__AI_INSPECTOR_PORT__ = ${serverPort};
+window.addEventListener('load', () => {
+  if (window.InspectoClient) {
+    window.InspectoClient.mountInspector({
+      serverUrl: 'http://127.0.0.1:' + window.__AI_INSPECTOR_PORT__,
+    });
+  }
+});
+`;
+}
+function getWebpackAssetScript(serverPort) {
+  return `
+if (typeof window !== 'undefined') {
+  window.__AI_INSPECTOR_PORT__ = ${serverPort};
+  const _initInspecto = () => {
+    if (window.InspectoClient) {
+      window.InspectoClient.mountInspector({
+        serverUrl: 'http://127.0.0.1:' + window.__AI_INSPECTOR_PORT__,
+      });
+    } else {
+      setTimeout(_initInspecto, 100);
+    }
+  };
+  if (document.readyState === 'complete') {
+    _initInspecto();
+  } else {
+    window.addEventListener('load', _initInspecto);
+  }
+}
+`;
+}
+function injectWebpack(compiler, serverPortFn, resolveClientModule2) {
+  const inspectoClientPath = resolveClientModule2();
+  new compiler.webpack.EntryPlugin(compiler.context, inspectoClientPath, { name: void 0 }).apply(
+    compiler
+  );
+  compiler.hooks.compilation.tap("inspecto-overlay", (compilation) => {
+    const HtmlWebpackPlugin = compiler.options.plugins.find(
+      (p) => p && p.constructor && p.constructor.name === "HtmlWebpackPlugin"
+    );
+    if (HtmlWebpackPlugin) {
+      const hooks = HtmlWebpackPlugin.constructor.getHooks(compilation);
+      hooks.alterAssetTagGroups.tapPromise("inspecto-overlay", async (data) => {
+        const port = await serverPortFn();
+        data.headTags.unshift({
+          tagName: "script",
+          voidTag: false,
+          meta: { plugin: "inspecto-overlay" },
+          innerHTML: getWebpackHtmlScript(port)
+        });
+        return data;
+      });
+    } else {
+      compilation.hooks.processAssets.tapPromise(
+        {
+          name: "inspecto-overlay",
+          stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+        },
+        async (assets) => {
+          const port = await serverPortFn();
+          const mainAssetKey = Object.keys(assets).find(
+            (key) => key.endsWith(".js") && (key.includes("main") || key.includes("app"))
+          );
+          if (!mainAssetKey) return;
+          const originalSource = assets[mainAssetKey].source();
+          assets[mainAssetKey] = new compiler.webpack.sources.RawSource(
+            getWebpackAssetScript(port) + "\n" + originalSource
+          );
+        }
+      );
+    }
+  });
+}
+
+// src/injectors/rspack.ts
+function injectRspack(compiler, serverPortFn, resolveClientModule2) {
+  const inspectoClientPath = resolveClientModule2();
+  new compiler.webpack.EntryPlugin(compiler.context, inspectoClientPath, {}).apply(compiler);
+  compiler.hooks.compilation.tap("inspecto-overlay", (compilation) => {
+    const HtmlRspackPlugin = compiler.options.plugins.find(
+      (p) => p && p.constructor && p.constructor.name === "HtmlRspackPlugin"
+    );
+    if (HtmlRspackPlugin) {
+      const hooks = HtmlRspackPlugin.constructor.getHooks(compilation);
+      hooks.alterAssetTagGroups.tapPromise("inspecto-overlay", async (data) => {
+        const port = await serverPortFn();
+        data.headTags.unshift({
+          tagName: "script",
+          voidTag: false,
+          meta: { plugin: "inspecto-overlay" },
+          innerHTML: getWebpackHtmlScript(port)
+        });
+        return data;
+      });
+    }
+  });
+}
+
+// src/injectors/vite.ts
+function getViteVirtualModuleScript(serverPort) {
+  return `
+import { mountInspector } from '@inspecto-dev/core';
+window.__AI_INSPECTOR_PORT__ = ${serverPort};
+mountInspector({
+  serverUrl: 'http://127.0.0.1:' + window.__AI_INSPECTOR_PORT__,
+});
+`;
+}
+var VITE_VIRTUAL_MODULE_ID = "\0virtual:inspecto-client";
+var VITE_VIRTUAL_IMPORT_ID = "/@id/__x00__virtual:inspecto-client";
+
+// src/index.ts
+var DEFAULT_OPTIONS = {
+  include: [],
+  exclude: [],
+  escapeTags: [],
+  pathType: "absolute",
+  attributeName: "data-inspecto"
+};
+var DEFAULT_PORT = 5678;
+var getCleanId = (id) => id.split("?")[0];
+var InspectoPlugin = createUnplugin((userOptions = {}) => {
+  const options = {
+    ...DEFAULT_OPTIONS,
+    ...userOptions
+  };
+  const isProduction = process.env["NODE_ENV"] === "production";
+  let projectRoot = process.cwd();
+  let serverPort = null;
+  const ensureServer = async () => {
+    if (serverPort === null) {
+      serverPort = await startServer();
+    }
+    return serverPort;
+  };
+  return {
+    name: "inspecto-overlay",
+    enforce: "pre",
+    buildStart() {
+      if (isProduction) return;
+      projectRoot = serverState.cwd || process.cwd();
+      ensureServer().catch(console.error);
+    },
+    buildEnd() {
+    },
+    webpack: (compiler) => {
+      if (isProduction) return;
+      injectWebpack(compiler, ensureServer, resolveClientModule);
+    },
+    rspack: (compiler) => {
+      if (isProduction) return;
+      injectRspack(compiler, ensureServer, resolveClientModule);
+    },
+    vite: {
+      config(config) {
+        if (isProduction) return config;
+        return {
+          ...config,
+          define: {
+            ...config.define,
+            __AI_INSPECTOR_PORT__: JSON.stringify(DEFAULT_PORT)
+            // Placeholder, rewritten in configureServer
+          }
+        };
+      },
+      resolveId(id) {
+        if (id === "virtual:inspecto-client") {
+          return VITE_VIRTUAL_MODULE_ID;
+        }
+        return null;
+      },
+      load(id) {
+        if (id === VITE_VIRTUAL_MODULE_ID) {
+          return getViteVirtualModuleScript(serverPort ?? DEFAULT_PORT);
+        }
+        return null;
+      },
+      async configureServer(server) {
+        if (isProduction) return;
+        const port = await ensureServer();
+        if (!server.config.define) {
+          ;
+          server.config.define = {};
+        }
+        ;
+        server.config.define["__AI_INSPECTOR_PORT__"] = JSON.stringify(port);
+        const mod = server.moduleGraph.getModuleById(VITE_VIRTUAL_MODULE_ID);
+        if (mod) server.moduleGraph.invalidateModule(mod);
+      },
+      transformIndexHtml(html) {
+        if (isProduction || !serverPort) return html;
+        return {
+          html,
+          tags: [
+            {
+              tag: "script",
+              attrs: { type: "module" },
+              children: `import '${VITE_VIRTUAL_IMPORT_ID}';`
+            }
+          ]
+        };
+      }
+    },
+    transformInclude(id) {
+      if (isProduction || !id) return false;
+      const cleanId = getCleanId(id);
+      return shouldTransform(cleanId, options);
+    },
+    transform(code, id) {
+      if (isProduction || !id) return null;
+      const cleanId = getCleanId(id);
+      const result = transformRouter({
+        filePath: cleanId,
+        source: code,
+        projectRoot,
+        pluginOptions: options
+      });
+      if (!result || !result.changed) return null;
+      return {
+        code: result.code,
+        map: result.map
+      };
+    }
+  };
+});
+var unplugin = InspectoPlugin;
+var vitePlugin = InspectoPlugin.vite;
+var webpackPlugin = InspectoPlugin.webpack;
+var rspackPlugin = InspectoPlugin.rspack;
+var rollupPlugin = InspectoPlugin.rollup;
+var esbuildPlugin = InspectoPlugin.esbuild;
+var src_default = InspectoPlugin;
+export {
+  src_default as default,
+  esbuildPlugin,
+  rollupPlugin,
+  rspackPlugin,
+  transformJsx,
+  unplugin,
+  vitePlugin,
+  webpackPlugin
+};
+//# sourceMappingURL=vite.js.map