@aipanel/dsh-plugin 1.2.4 → 1.2.6

package/dist/index.js

@@ -1,8 +1,266 @@
 // dsh-plugin/src/index.ts
-import path from "node:path";
+import fs2 from "node:fs";
+import path2 from "node:path";
 import { randomUUID } from "node:crypto";
-var name = "aipanel";
-var inject = ["tools", "subprocess"];
+
+// ../../core/es/constants.mjs
+var LOG_PREFIX = "[vite-plugin-aipanel]";
+var EXT_BROADCAST = {
+  PAGE_CONTEXT: "PAGE_CONTEXT",
+  THEME_CHANGE: "THEME_CHANGE",
+  SERVICE_APPEARED: "SERVICE_APPEARED",
+  SERVICE_GONE: "SERVICE_GONE"
+};
+var EXT_MSG = {
+  ...EXT_BROADCAST,
+  GET_PORT_INFO: "GET_PORT_INFO",
+  TAB_SWITCHED: "TAB_SWITCHED",
+  REQUEST_PAGE_CONTEXT: "REQUEST_PAGE_CONTEXT",
+  SELECTION_START: "SELECTION_START",
+  SELECTION_STOP: "SELECTION_STOP",
+  CS_QUERY_WINDOW: "__CS_QUERY_WINDOW__"
+};
+var SEVERITY_ERROR = 1;
+var SEVERITY_WARN = 2;
+
+// ../../core/es/logger-core.mjs
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  LogLevel2[LogLevel2["NONE"] = 4] = "NONE";
+  return LogLevel2;
+})(LogLevel || {});
+var globalConfig = {
+  verbose: false,
+  level: 1,
+  showTimestamp: true,
+  showCaller: true,
+  showTrace: false,
+  indent: "  "
+};
+function getConfig() {
+  return globalConfig;
+}
+function formatValue(value, depth = 0) {
+  if (depth > 3) return "...";
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "string") return depth > 0 ? `"${value}"` : value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (value instanceof Error) {
+    return `${value.name}: ${value.message}${value.stack ? `
+${value.stack}` : ""}`;
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    if (value.length > 5) {
+      const items2 = value.slice(0, 3).map((v) => formatValue(v, depth + 1));
+      return `[${items2.join(", ")}, ... ${value.length - 3} more items]`;
+    }
+    const items = value.map((v) => formatValue(v, depth + 1));
+    return `[${items.join(", ")}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0) return "{}";
+    if (entries.length > 5) {
+      const shown = entries.slice(0, 3).map(([k, v]) => `${k}: ${formatValue(v, depth + 1)}`);
+      return `{${shown.join(", ")}, ... ${entries.length - 3} more keys}`;
+    }
+    const formatted = entries.map(([k, v]) => `${k}: ${formatValue(v, depth + 1)}`);
+    return `{${formatted.join(", ")}}`;
+  }
+  return String(value);
+}
+function formatContext(context) {
+  if (!context || Object.keys(context).length === 0) return "";
+  const parts = [];
+  if (context.module) parts.push(`[${context.module}]`);
+  if (context.operation) parts.push(`(${context.operation})`);
+  if (context.traceId) parts.push(`trace:${context.traceId}`);
+  if (context.duration !== void 0) parts.push(`${context.duration}ms`);
+  const extraKeys = Object.keys(context).filter(
+    (k) => !["module", "operation", "traceId", "duration", "error"].includes(k)
+  );
+  if (extraKeys.length > 0) {
+    const extra = {};
+    extraKeys.forEach((k) => extra[k] = context[k]);
+    parts.push(formatValue(extra));
+  }
+  return parts.join(" ");
+}
+
+// ../../core/es/node-logger.mjs
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var COLORS = {
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  bright: "\x1B[1m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m"
+};
+var LEVEL_COLORS = {
+  [LogLevel.DEBUG]: COLORS.cyan,
+  [LogLevel.INFO]: COLORS.green,
+  [LogLevel.WARN]: COLORS.yellow,
+  [LogLevel.ERROR]: COLORS.red,
+  [LogLevel.NONE]: COLORS.reset
+};
+var LEVEL_NAMES = {
+  [LogLevel.DEBUG]: "DEBUG",
+  [LogLevel.INFO]: "INFO",
+  [LogLevel.WARN]: "WARN",
+  [LogLevel.ERROR]: "ERROR",
+  [LogLevel.NONE]: "NONE"
+};
+function getTimestamp() {
+  const now = /* @__PURE__ */ new Date();
+  const hours = String(now.getHours()).padStart(2, "0");
+  const minutes = String(now.getMinutes()).padStart(2, "0");
+  const seconds = String(now.getSeconds()).padStart(2, "0");
+  const ms = String(now.getMilliseconds()).padStart(3, "0");
+  return `${hours}:${minutes}:${seconds}.${ms}`;
+}
+function getCallerInfo(depth = 3) {
+  const stack = new Error().stack;
+  if (!stack) return "";
+  const lines = stack.split("\n");
+  const targetLine = lines[depth];
+  if (!targetLine) return "";
+  const match = targetLine.match(/at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?/);
+  if (!match) return "";
+  const [, funcName, filePath, line] = match;
+  const fileName = filePath.split("/").pop() || filePath;
+  const func = funcName || "<anonymous>";
+  return `${fileName}:${line} ${func}`;
+}
+function log(level, message, context, ...args) {
+  if (level < getConfig().level) return;
+  const parts = [];
+  parts.push(`${COLORS.dim}[${process.pid}]${COLORS.reset}`);
+  if (getConfig().showTimestamp) {
+    parts.push(`${COLORS.dim}${getTimestamp()}${COLORS.reset}`);
+  }
+  const levelColor = LEVEL_COLORS[level];
+  const levelName = LEVEL_NAMES[level].padEnd(5);
+  parts.push(`${levelColor}${levelName}${COLORS.reset}`);
+  parts.push(`${COLORS.bright}${LOG_PREFIX}${COLORS.reset}`);
+  const contextStr = formatContext(context);
+  if (contextStr) {
+    parts.push(`${COLORS.magenta}${contextStr}${COLORS.reset}`);
+  }
+  parts.push(message);
+  if (getConfig().showCaller && level >= LogLevel.WARN) {
+    const caller = getCallerInfo(4);
+    if (caller) {
+      parts.push(`${COLORS.dim}(${caller})${COLORS.reset}`);
+    }
+  }
+  const formattedArgs = args.map((a) => formatValue(a)).join(" ");
+  if (formattedArgs) {
+    parts.push(formattedArgs);
+  }
+  if (context?.error) {
+    const err = context.error;
+    if (err instanceof Error) {
+      parts.push(`${COLORS.red}Error: ${err.message}${COLORS.reset}`);
+      if (level >= LogLevel.ERROR && getConfig().showTrace && err.stack) {
+        console.error(`${COLORS.dim}${err.stack}${COLORS.reset}`);
+      }
+    } else {
+      parts.push(`${COLORS.red}Error: ${formatValue(err)}${COLORS.reset}`);
+    }
+  }
+  const output = parts.join(" ");
+  if (level >= LogLevel.ERROR) {
+    console.error(output);
+  } else if (level === LogLevel.WARN) {
+    console.warn(output);
+  } else {
+    console.log(output);
+  }
+}
+var nodeLogger = {
+  debug(message, context, ...args) {
+    log(LogLevel.DEBUG, message, context, ...args);
+  },
+  info(message, context, ...args) {
+    log(LogLevel.INFO, message, context, ...args);
+  },
+  warn(message, context, ...args) {
+    log(LogLevel.WARN, message, context, ...args);
+  },
+  error(message, context, ...args) {
+    log(LogLevel.ERROR, message, context, ...args);
+  },
+  group(label, context) {
+    if (!getConfig().verbose) return;
+    const contextStr = formatContext(context);
+    console.log(
+      `${COLORS.dim}[${process.pid}]${COLORS.reset} ${COLORS.bright}${LOG_PREFIX}${COLORS.reset} ${COLORS.blue}\u25BC${COLORS.reset} ${label}${contextStr ? ` ${contextStr}` : ""}`
+    );
+  },
+  groupEnd() {
+    if (!getConfig().verbose) return;
+  }
+};
+function createNodeLogger(module) {
+  return {
+    debug(message, context, ...args) {
+      nodeLogger.debug(message, { ...context, module }, ...args);
+    },
+    info(message, context, ...args) {
+      nodeLogger.info(message, { ...context, module }, ...args);
+    },
+    warn(message, context, ...args) {
+      nodeLogger.warn(message, { ...context, module }, ...args);
+    },
+    error(message, context, ...args) {
+      nodeLogger.error(message, { ...context, module }, ...args);
+    },
+    timer(operation, context) {
+      return new PerformanceTimer(operation, { ...context, module });
+    }
+  };
+}
+var PerformanceTimer = class {
+  constructor(operation, context) {
+    __publicField(this, "startTime");
+    __publicField(this, "context");
+    __publicField(this, "operation");
+    this.operation = operation;
+    this.context = context || {};
+    this.startTime = performance.now();
+    nodeLogger.debug(`\u23F1\uFE0F  Starting: ${operation}`, this.context);
+  }
+  end(message) {
+    const duration = Math.round(performance.now() - this.startTime);
+    const msg = message || `\u2713 Completed: ${this.operation}`;
+    nodeLogger.debug(msg, { ...this.context, duration });
+    return duration;
+  }
+  checkpoint(label) {
+    const elapsed = Math.round(performance.now() - this.startTime);
+    nodeLogger.debug(`  \u21B3 ${label}`, { ...this.context, duration: elapsed });
+    return elapsed;
+  }
+};
+
+// ../../core/es/node/diagnostics.mjs
+import fs from "node:fs";
+import path from "node:path";
+import { exec } from "node:child_process";
+import { createRequire } from "node:module";
+var log2 = createNodeLogger("Diagnostics");
 var JS_EXTENSIONS = /* @__PURE__ */ new Set([
   ".js",
   ".jsx",
@@ -14,99 +272,462 @@ var JS_EXTENSIONS = /* @__PURE__ */ new Set([
   ".cts",
   ".vue"
 ]);
-var MUTATING_TOOLS = /* @__PURE__ */ new Set(["write", "edit", "apply_patch"]);
-var STDOUT_MAX_BYTES = 2e5;
-var STDOUT_SPILL_MAX_BYTES = 2e6;
-var STDERR_MAX_BYTES = 1e5;
-var GRACE_MS = 3e4;
-function apply(ctx, config = {}) {
-  const cwd = config.cwd ?? process.cwd();
-  const autoDiagnose = config.autoDiagnose ?? true;
-  const tools = ctx.tools;
-  const subprocess = ctx.subprocess;
-  async function collectOutput(argv, signal) {
+function isJsFile(filePath) {
+  return JS_EXTENSIONS.has(path.extname(filePath));
+}
+var ESLintClass;
+function loadESLint(workspace) {
+  if (ESLintClass) return;
+  log2.debug("Loading eslint", { workspace });
+  try {
+    const req = createRequire(path.join(workspace, "package.json"));
+    const eslintModule = req("eslint");
+    ESLintClass ?? (ESLintClass = eslintModule.ESLint ?? eslintModule.FlatESLint);
+    log2.debug("eslint loaded", { hasClass: !!ESLintClass });
+  } catch (e) {
+    log2.warn("eslint not found", { error: e.message });
+  }
+}
+async function lintFiles(pattern, cwd, warnLimit = 5) {
+  loadESLint(cwd);
+  if (!ESLintClass) return {};
+  try {
+    const eslint = new ESLintClass({ cwd });
+    const results = await eslint.lintFiles(pattern);
+    const messages = results.flatMap(
+      (r) => (r.messages ?? []).map((m) => ({ ...m, filePath: r.filePath }))
+    );
+    log2.debug("ESLint lint", {
+      pattern,
+      fileCount: results.length,
+      messageCount: messages.length
+    });
+    if (messages.length === 0) return {};
+    const ESLINT_ERROR = 2;
+    const ESLINT_WARN = 1;
+    const lines = [];
+    const errors = messages.filter((m) => m.severity === ESLINT_ERROR);
+    const warnings = messages.filter((m) => m.severity === ESLINT_WARN);
+    if (errors.length > 0) {
+      lines.push(
+        ...errors.map(
+          (m) => `ERROR [${m.filePath}:${m.line}:${m.column}] ${m.message} (${m.ruleId})`
+        )
+      );
+    }
+    if (warnings.length > 0) {
+      lines.push(
+        ...warnings.slice(0, warnLimit).map((m) => `WARN [${m.filePath}:${m.line}:${m.column}] ${m.message} (${m.ruleId})`)
+      );
+      if (warnings.length > warnLimit)
+        lines.push(`... and ${warnings.length - warnLimit} more warnings`);
+    }
+    const diagnostics = messages.map((m) => ({
+      severity: m.severity === ESLINT_ERROR ? SEVERITY_ERROR : m.severity === ESLINT_WARN ? SEVERITY_WARN : m.severity,
+      file: m.filePath,
+      range: {
+        start: { line: (m.line || 1) - 1, character: (m.column || 1) - 1 },
+        end: {
+          line: (m.endLine || m.line || 1) - 1,
+          character: (m.endColumn || m.column || 1) - 1
+        }
+      },
+      message: `[ESLint] ${m.message} (${m.ruleId})`,
+      source: "eslint"
+    }));
+    return { text: lines.length > 0 ? lines.join("\n") : void 0, diagnostics };
+  } catch (err) {
+    log2.warn("ESLint failed", { pattern, error: err.message });
+    return {};
+  }
+}
+var _vueTscBin;
+function resolveVueTscBin() {
+  if (_vueTscBin !== void 0) return _vueTscBin;
+  try {
+    const req = createRequire(import.meta.url);
+    _vueTscBin = req.resolve("vue-tsc/bin/vue-tsc.js");
+  } catch {
+    _vueTscBin = null;
+  }
+  return _vueTscBin;
+}
+function findTsconfigDir(filePath) {
+  const resolved = path.resolve(filePath);
+  let dir = path.dirname(resolved);
+  log2.debug("findTsconfigDir start", { filePath: resolved });
+  while (true) {
+    const tsconfigPath = path.join(dir, "tsconfig.json");
+    if (fs.existsSync(tsconfigPath)) {
+      log2.debug("findTsconfigDir found", { dir, tsconfigPath });
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      log2.warn("findTsconfigDir not found", { filePath: resolved });
+      return null;
+    }
+    dir = parent;
+  }
+}
+function findAllTsconfigDirs(workspace) {
+  const dirs = [];
+  function walk(dir) {
+    let entries;
     try {
-      const exe = await subprocess.resolveExecutable("npx", void 0, signal);
-      const proc = subprocess.spawn({
-        argv: [exe, ...argv],
-        cwd,
-        stdio: {
-          stdin: "ignore",
-          stdout: { maxBytes: STDOUT_MAX_BYTES, spill: { maxBytes: STDOUT_SPILL_MAX_BYTES } },
-          stderr: { maxBytes: STDERR_MAX_BYTES }
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+      const full = path.join(dir, entry.name);
+      if (fs.existsSync(path.join(full, "tsconfig.json"))) {
+        dirs.push(full);
+      }
+      walk(full);
+    }
+  }
+  walk(workspace);
+  log2.debug("findAllTsconfigDirs result", {
+    workspace,
+    count: dirs.length,
+    dirs: dirs.map((d) => path.relative(workspace, d))
+  });
+  return dirs;
+}
+function parseTscDiags(rawOutput, filePath, projectDir) {
+  const errorLinePat = /^(.+?)\((\d+),(\d+)\):\s+(error|warning)\s+TS(\d+):\s+(.+)$/;
+  const diags = [];
+  const resolved = filePath ? path.resolve(filePath) : void 0;
+  const lines = rawOutput.split("\n");
+  for (const line of lines) {
+    const match = errorLinePat.exec(line);
+    if (match) {
+      const [, file, lineNum, col, severity, code, message] = match;
+      const resolvedFile = projectDir ? path.resolve(projectDir, file) : path.resolve(file);
+      if (resolved) {
+        if (resolvedFile !== resolved) continue;
+      }
+      diags.push({
+        severity: severity === "error" ? SEVERITY_ERROR : SEVERITY_WARN,
+        file: resolvedFile,
+        range: {
+          start: { line: Number(lineNum) - 1, character: Number(col) - 1 },
+          end: { line: Number(lineNum) - 1, character: Number(col) - 1 }
         },
-        graceMs: GRACE_MS,
-        signal
+        message: `[TS${code}] ${message}`,
+        source: "vue-tsc"
       });
-      await proc.done;
-      return { text: proc.collected.stdout?.readFrom(0)?.text ?? "" };
-    } catch (e) {
-      return { text: "", error: String(e) };
     }
   }
-  async function runDiagnostics(filePath, signal) {
-    const parts = [];
-    const tsc = await collectOutput(["tsc", "--noEmit", "--pretty", "false"], signal);
-    if (tsc.error) parts.push("## tsc\n\n(diagnostics skipped: " + tsc.error + ")");
-    else if (tsc.text.trim()) parts.push("## tsc\n\n" + tsc.text.trim());
-    const eslint = await collectOutput(["eslint", filePath, "--format", "compact"], signal);
-    if (eslint.text.trim()) parts.push("## eslint\n\n" + eslint.text.trim());
-    return parts.join("\n\n");
-  }
-  const diagnosticsTool = {
-    name: "run_diagnostics",
-    description: "Run ESLint and TypeScript type checks on filePath and report problems. Use after editing code to verify no lint/type errors before proceeding.",
-    parameters: {
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        filePath: {
-          type: "string",
-          description: "Absolute or cwd-relative file path to diagnose"
+  return diags;
+}
+async function runVueTsc(filePath, cwd) {
+  const dir = cwd;
+  const projectDir = filePath ? findTsconfigDir(filePath) ?? dir : dir;
+  log2.debug("runVueTsc", {
+    filePath: filePath || "(all)",
+    cwd: dir,
+    projectDir,
+    processCwd: process.cwd()
+  });
+  const bin = resolveVueTscBin();
+  if (!bin) {
+    log2.warn("vue-tsc bin not found", { projectDir });
+    return { rawOutput: "", exitCode: 0 };
+  }
+  const timeout = filePath ? 6e4 : 12e4;
+  const maxBuffer = filePath ? 10 * 1024 * 1024 : 50 * 1024 * 1024;
+  return new Promise((resolve) => {
+    exec(
+      `node "${bin}" --build --noEmit --pretty false`,
+      { cwd: projectDir, timeout, maxBuffer },
+      (error, stdout, stderr) => {
+        let rawOutput = stdout + stderr;
+        const killed = error?.killed;
+        const exitCode = typeof error?.code === "number" ? error.code : killed ? 1 : 0;
+        if (killed && !rawOutput) {
+          rawOutput = "vue-tsc \u68C0\u67E5\u8D85\u65F6\uFF0C\u8BF7\u5C1D\u8BD5\u7F29\u5C0F\u68C0\u67E5\u8303\u56F4\u6216\u4F18\u5316\u9879\u76EE\u914D\u7F6E\u3002";
         }
-      },
-      required: ["filePath"]
-    },
-    output: {
-      schema: { type: "string" },
-      render: (_args, value) => [{ type: "text", text: value }]
-    },
-    async execute(args, exec) {
-      const filePath = args?.filePath;
-      const target = typeof filePath === "string" ? path.resolve(cwd, filePath) : cwd;
-      return runDiagnostics(target, exec.signal).catch((e) => "diagnostics failed: " + String(e));
-    }
+        const diagnostics = parseTscDiags(rawOutput, filePath, projectDir);
+        if (filePath) {
+          const resolved = path.resolve(filePath);
+          const errorLinePat = /^(.+?)\((\d+),(\d+)\):\s+(error|warning)\s+TS\d+:/;
+          const lines = rawOutput.split("\n");
+          const filtered = [];
+          let keep = false;
+          for (const line of lines) {
+            const m = errorLinePat.exec(line);
+            if (m) {
+              keep = path.resolve(projectDir, m[1]) === resolved;
+            } else if (!/^\s/.test(line)) {
+              keep = false;
+            }
+            if (keep) filtered.push(line);
+          }
+          rawOutput = filtered.join("\n");
+        }
+        log2.debug("vue-tsc finished", {
+          filePath: filePath || "(all)",
+          exitCode,
+          outputLength: rawOutput.length
+        });
+        resolve({ rawOutput, exitCode, diagnostics });
+      }
+    );
+  });
+}
+async function runAllChecks(pattern, cwd) {
+  log2.debug("runAllChecks", { pattern, cwd });
+  const [eslintOutput, tscOutput] = await Promise.all([
+    lintFiles(pattern, cwd),
+    runVueTsc(pattern, cwd)
+  ]);
+  return { eslintOutput, tscOutput };
+}
+async function runProjectDiagnostics(workspace) {
+  const tscDirs = fs.existsSync(path.join(workspace, "tsconfig.json")) ? [workspace] : findAllTsconfigDirs(workspace);
+  log2.debug("Tsc dirs to check", { count: tscDirs.length, dirs: tscDirs });
+  const [eslintOutput, ...tscOutputs] = await Promise.all([
+    lintFiles(".", workspace, 10),
+    ...tscDirs.map((dir) => runVueTsc(void 0, dir))
+  ]);
+  const mergedTsc = {
+    rawOutput: tscOutputs.flatMap((o) => o.rawOutput).filter(Boolean).join("\n"),
+    exitCode: tscOutputs.reduce((max, o) => Math.max(max, o.exitCode), 0),
+    diagnostics: tscOutputs.flatMap((o) => o.diagnostics ?? [])
   };
-  tools.register(diagnosticsTool);
-  ctx.on(
-    "tools/post-execute",
-    async (exec, result, next) => {
-      const decision = await next();
-      if (!autoDiagnose) return decision;
-      if (!MUTATING_TOOLS.has(exec.name)) return decision;
-      if (result.isError) return decision;
-      if (decision.kind !== "accept") return decision;
-      const filePath = exec.arguments?.filePath;
-      if (typeof filePath !== "string" || !filePath) return decision;
-      if (!JS_EXTENSIONS.has(path.extname(filePath))) return decision;
-      const diag = await runDiagnostics(path.resolve(cwd, filePath), exec.signal).catch(
-        () => "diagnostics unavailable"
-      );
-      const message = {
-        role: "user",
-        id: randomUUID(),
-        content: [
-          {
-            type: "text",
-            text: `Auto diagnostics after ${exec.name} (${filePath}):
-${diag}`
+  return { eslintOutput, tscOutput: mergedTsc };
+}
+
+// dsh-plugin/src/index.ts
+var name = "aipanel";
+var inject = ["tools"];
+var MUTATING_TOOLS = /* @__PURE__ */ new Set(["write", "edit", "apply_patch"]);
+var DEFAULT_CONTEXT_API_PATH = "/__aipanel_context__";
+function collectNodeIds(text) {
+  const ids = [];
+  const re = new RegExp("@\u8282\u70B9\\[(n[0-9a-z]+)\\]", "g");
+  let m;
+  while ((m = re.exec(text)) !== null) ids.push(m[1]);
+  return ids;
+}
+function buildNodeContext(e) {
+  const lines = [`\u8282\u70B9 ID\uFF1A${e.id ?? ""}`];
+  if (e.filePath) lines.push(`\u6E90\u7801\u6587\u4EF6\u8DEF\u5F84\uFF1A${e.filePath}${e.line ? `:${e.line}` : ""}`);
+  if (e.line) lines.push(`\u4EE3\u7801\u6240\u5728\u884C\u53F7\uFF1A${e.line}`);
+  if (e.column) lines.push(`\u4EE3\u7801\u6240\u5728\u5217\u53F7\uFF1A${e.column}`);
+  if (e.description) lines.push(`DOM \u5143\u7D20\u9009\u62E9\u5668\uFF1A${e.description}`);
+  if (e.innerText) lines.push(`DOM \u5143\u7D20\u5185\u90E8\u6587\u672C\uFF1A${e.innerText.slice(0, 200)}`);
+  if (e.previewPageUrl) lines.push(`\u7528\u6237\u9009\u4E2D\u8282\u70B9\u65F6\u7684\u9875\u9762 URL\uFF1A${e.previewPageUrl}`);
+  if (e.previewPageTitle) lines.push(`\u9875\u9762\u6807\u9898\uFF1A${e.previewPageTitle}`);
+  return lines.join("\n");
+}
+function toDiagnosticEntries(items) {
+  return items.map((d) => ({
+    file: d.file ?? "",
+    line: d.range.start.line + 1,
+    column: d.range.start.character + 1,
+    severity: d.severity === SEVERITY_ERROR ? "error" : "warning",
+    message: d.message
+  }));
+}
+function buildDiagnosticsCanonical(title, eslintOutput, tscOutput) {
+  return {
+    title,
+    sections: [
+      { title: "ESLint", text: eslintOutput.text || "\u6CA1\u6709\u53D1\u73B0\u95EE\u9898" },
+      { title: "vue-tsc", text: tscOutput.rawOutput.trim() || "\u6CA1\u6709\u53D1\u73B0\u7C7B\u578B\u9519\u8BEF" }
+    ],
+    diagnostics: [
+      ...toDiagnosticEntries(eslintOutput.diagnostics ?? []),
+      ...toDiagnosticEntries(tscOutput.diagnostics ?? [])
+    ]
+  };
+}
+function renderDiagnosticsText(value) {
+  const body = value.sections.map((s) => `## ${s.title}
+
+${s.text}`).join("\n\n");
+  return body ? `${value.title}
+
+${body}` : value.title;
+}
+function apply(ctx, config = {}) {
+  const cwd = config.cwd ?? process.cwd();
+  const enableDiagnostics = config.enableDiagnostics ?? false;
+  const autoDiagnose = config.autoDiagnose ?? process.env.OPENCODE_ENABLE_LINT === "1";
+  const vitePort = config.vitePort ?? 0;
+  const contextApiPath = config.contextApiPath ?? DEFAULT_CONTEXT_API_PATH;
+  const tools = ctx.tools;
+  if (enableDiagnostics) {
+    const diagnosticsTool = {
+      name: "run_diagnostics",
+      description: "\u8FD0\u884C ESLint \u548C vue-tsc \u7C7B\u578B\u68C0\u67E5\uFF0C\u8FD4\u56DE\u8BCA\u65AD\u7ED3\u679C\u3002\n\n**\u4F55\u65F6\u4F7F\u7528\u6B64\u5DE5\u5177**\uFF1A\n- \u521A\u5B8C\u6210\u4EE3\u7801\u4FEE\u6539\uFF0C\u60F3\u9A8C\u8BC1\u662F\u5426\u6709 ESLint \u9519\u8BEF\u6216\u7C7B\u578B\u9519\u8BEF\n- \u5728\u63D0\u4EA4\u4EE3\u7801\u524D\u8FDB\u884C\u8D28\u91CF\u68C0\u67E5\n- \u6392\u67E5\u7F16\u8F91\u5668\u672A\u663E\u793A\u4F46\u5B9E\u9645\u5B58\u5728\u7684\u7C7B\u578B\u95EE\u9898\n- \u4E0D\u4F20\u53C2\u6570\u53EF\u5168\u91CF\u8BCA\u65AD\u6574\u4E2A\u9879\u76EE\n\n**\u8BCA\u65AD\u5185\u5BB9**\uFF1A\n- ESLint \u89C4\u5219\u68C0\u67E5\uFF08error \u548C warning\uFF09\n- vue-tsc \u7C7B\u578B\u68C0\u67E5\uFF08TypeScript \u7C7B\u578B\u9519\u8BEF\u548C\u8B66\u544A\uFF09",
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          filePath: {
+            type: "string",
+            description: "\u8981\u8BCA\u65AD\u7684\u6587\u4EF6\u8DEF\u5F84\uFF08\u7EDD\u5BF9\u8DEF\u5F84\u6216\u76F8\u5BF9\u8DEF\u5F84\uFF09\uFF0C\u4E0D\u4F20\u5219\u5168\u91CF\u8BCA\u65AD\u6574\u4E2A\u9879\u76EE"
           }
+        }
+      },
+      output: {
+        // 结构化 canonical 输出：文本分区（模型可见）+ 诊断数组（持久化供 client 渲染）
+        schema: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            title: { type: "string" },
+            sections: {
+              type: "array",
+              items: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                  title: { type: "string" },
+                  text: { type: "string" }
+                },
+                required: ["title", "text"]
+              }
+            },
+            diagnostics: {
+              type: "array",
+              items: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                  file: { type: "string" },
+                  line: { type: "integer" },
+                  column: { type: "integer" },
+                  severity: { type: "string", enum: ["error", "warning"] },
+                  message: { type: "string" }
+                },
+                required: ["file", "line", "column", "severity", "message"]
+              }
+            }
+          },
+          required: ["title", "sections", "diagnostics"]
+        },
+        // canonical → 模型可见文本（## ESLint / ## vue-tsc 分区，与 formatDiagnosticsSections 一致）
+        render: (_args, value) => [
+          { type: "text", text: renderDiagnosticsText(value) }
         ],
-        source: { kind: "plugin", plugin: name }
-      };
-      return { kind: "accept", additionalContexts: [message] };
-    }
-  );
+        // 结构化诊断投影进持久化 meta（tool/result.meta），client 侧 dsh-client 据此渲染诊断卡片
+        presentationMeta: (_args, value) => ({
+          diagnostics: value.diagnostics
+        })
+      },
+      async execute(args) {
+        const filePath = args?.filePath;
+        if (typeof filePath === "string" && filePath) {
+          const resolved = path2.resolve(cwd, filePath);
+          if (!fs2.existsSync(resolved)) throw new Error(`\u6587\u4EF6\u4E0D\u5B58\u5728: ${resolved}`);
+          const { eslintOutput: eslintOutput2, tscOutput: tscOutput2 } = await runAllChecks(resolved, cwd);
+          return buildDiagnosticsCanonical(
+            `\u8BCA\u65AD\u7ED3\u679C: ${path2.relative(cwd, resolved)}`,
+            eslintOutput2,
+            tscOutput2
+          );
+        }
+        const { eslintOutput, tscOutput } = await runProjectDiagnostics(cwd);
+        return buildDiagnosticsCanonical("\u5168\u91CF\u8BCA\u65AD\u7ED3\u679C", eslintOutput, tscOutput);
+      }
+    };
+    tools.register(diagnosticsTool);
+    ctx.on(
+      "tools/post-execute",
+      async (exec2, result, next) => {
+        const decision = await next();
+        if (!autoDiagnose) return decision;
+        if (exec2.parent !== void 0) return decision;
+        if (!MUTATING_TOOLS.has(exec2.name)) return decision;
+        if (result.isError) return decision;
+        if (decision.kind !== "accept") return decision;
+        const rawArgs = exec2.arguments;
+        const filePath = typeof rawArgs?.file_path === "string" ? rawArgs.file_path : rawArgs?.filePath;
+        if (typeof filePath !== "string" || !filePath) return decision;
+        if (!isJsFile(filePath)) return decision;
+        const { eslintOutput, tscOutput } = await runAllChecks(
+          path2.resolve(cwd, filePath),
+          cwd
+        ).catch(() => ({
+          eslintOutput: {},
+          tscOutput: { rawOutput: "", exitCode: 0 }
+        }));
+        const parts = [];
+        if (tscOutput.rawOutput.trim()) parts.push("## vue-tsc\n\n" + tscOutput.rawOutput.trim());
+        if (eslintOutput.text) parts.push("## ESLint\n\n" + eslintOutput.text);
+        const diagText = parts.join("\n\n");
+        if (!diagText) return decision;
+        const existing = decision.kind === "accept" && decision.content || result.content;
+        return {
+          kind: "accept",
+          content: [...existing, { type: "text", text: `
+
+${diagText}` }]
+        };
+      }
+    );
+  }
+  if (vitePort > 0) {
+    const contextBase = `http://127.0.0.1:${vitePort}${contextApiPath}`;
+    ctx.on(
+      "agent/pre-step",
+      async ({ signal }, next) => {
+        const decision = await next();
+        if (decision.kind === "reject") return decision;
+        const ids = /* @__PURE__ */ new Set();
+        for (const message of decision.messages) {
+          if (message.source.kind !== "user") continue;
+          for (const block of message.content) {
+            if (block.type !== "text") continue;
+            for (const id of collectNodeIds(block.text)) ids.add(id);
+          }
+        }
+        if (ids.size === 0) return decision;
+        let elements = [];
+        try {
+          const res = await fetch(contextBase, { signal });
+          if (res.ok) {
+            const pc = await res.json();
+            elements = pc.selectedElements ?? [];
+          }
+        } catch {
+        }
+        const byId = /* @__PURE__ */ new Map();
+        for (const el of elements) {
+          if (el.id) byId.set(el.id, el);
+        }
+        const injected = [...ids].map((id) => byId.get(id)).filter((el) => el !== void 0);
+        if (injected.length === 0) return decision;
+        const contextText = injected.map(buildNodeContext).join("\n\n---\n\n");
+        const contextMessage = {
+          role: "user",
+          id: randomUUID(),
+          content: [
+            {
+              type: "text",
+              text: `\u4EE5\u4E0B\u662F\u7528\u6237\u5F15\u7528\u8282\u70B9\u7684\u5B8C\u6574\u4E0A\u4E0B\u6587\uFF08\u8282\u70B9 ID \u4E0E\u6D88\u606F\u4E2D\u7684 @\u8282\u70B9[id] \u6807\u8BB0\u5BF9\u5E94\uFF09\uFF1A
+
+${contextText}`
+            }
+          ],
+          source: { kind: "plugin", plugin: name }
+        };
+        try {
+          await fetch(contextBase, { method: "DELETE", signal });
+        } catch {
+        }
+        return { ...decision, messages: [...decision.messages, contextMessage] };
+      },
+      { prepend: true }
+    );
+  }
 }
 export {
   apply,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aipanel/dsh-plugin",
-  "version": "1.2.4",
+  "version": "1.2.6",
   "type": "module",
   "description": "AIPanel for DeepSeek Harness (dsh)：注入审查工具 run_diagnostics、编辑后自动诊断。",
   "main": "./dist/index.js",
@@ -11,15 +11,19 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
+  "dependencies": {
+    "vue-tsc": "^3.3.9"
+  },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-agent": "^0.1.1-rc.2",
     "@deepseek-ai/dsh-llm": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-subprocess": "^0.1.1-rc.2",
     "@deepseek-ai/dsh-tools": "^0.1.1-rc.2",
-    "esbuild": "^0.25.0"
+    "esbuild": "^0.25.0",
+    "@aipanel/core": "1.2.6"
   },
   "scripts": {
-    "build": "esbuild src/index.ts --bundle --outfile=dist/index.js --platform=node --format=esm --target=node18 --external:@deepseek-ai/* --external:node:*",
+    "build": "esbuild src/index.ts --bundle --outfile=dist/index.js --platform=node --format=esm --target=node18 --external:@deepseek-ai/* --external:node:* --external:vue-tsc",
     "typecheck": "tsc -p tsconfig.json"
   }
 }