@linghun/pre-engine-win32-x64 0.1.0

package/bundled/pre-engine/win32-x64/java-deep-layer.cjs

@@ -0,0 +1,350 @@
+"use strict";
+const readline = require("readline");
+const path = require("path");
+const fs = require("fs");
+const { spawn, spawnSync } = require("child_process");
+
+// --- LSP JSON-RPC framing ---
+let msgId = 0;
+function lspEncode(obj) {
+  const body = JSON.stringify(obj);
+  return `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`;
+}
+function lspRequest(method, params) {
+  return lspEncode({ jsonrpc: "2.0", id: ++msgId, method, params });
+}
+function lspNotify(method, params) {
+  return lspEncode({ jsonrpc: "2.0", method, params });
+}
+
+function fileUri(p) {
+  const abs = path.resolve(p).replace(/\\/g, "/");
+  return abs.startsWith("/") ? `file://${abs}` : `file:///${abs}`;
+}
+
+function normUri(uri) { return uri.toLowerCase(); }
+
+// --- jdtls session state ---
+let jdtlsProc = null;
+let jdtlsRoot = null;
+let jdtlsReady = false;
+let jdtlsBuffer = "";
+let jdtlsExpectedLen = -1;
+let jdtlsInitResolve = null;
+let jdtlsInitReject = null;
+let jdtlsDiagnostics = new Map();
+let jdtlsDiagTimers = new Map();
+let jdtlsDiagWaiters = [];
+let openDocs = new Map();
+let jdtlsDocOpenTime = new Map();
+let jdtlsEmptyCount = new Map();
+let jdtlsWarmedUp = false;
+let jdtlsStartingPromise = null;
+
+const BOOTSTRAP_BUDGET_MS = 5000;
+const WARM_SETTLE_MS = 2000;
+
+function findJdtls() {
+  const whichCmd = process.platform === "win32" ? "where.exe" : "which";
+  const r = spawnSync(whichCmd, ["jdtls"], {
+    encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], windowsHide: true,
+  });
+  if (r.status === 0) {
+    const line = r.stdout.split(/\r?\n/).map(l => l.trim()).filter(Boolean)[0];
+    return line || null;
+  }
+  return null;
+}
+
+function killJdtls() {
+  if (jdtlsProc) { try { jdtlsProc.kill(); } catch {} jdtlsProc = null; }
+  jdtlsReady = false;
+  jdtlsWarmedUp = false;
+  jdtlsStartingPromise = null;
+  jdtlsInitResolve = null;
+  jdtlsInitReject = null;
+  jdtlsDiagWaiters.forEach(w => w.resolve([]));
+  jdtlsDiagWaiters = [];
+  jdtlsDiagTimers.forEach(t => clearTimeout(t));
+  jdtlsDiagTimers.clear();
+  openDocs.clear();
+  jdtlsDocOpenTime.clear();
+  jdtlsEmptyCount.clear();
+}
+
+function onJdtlsData(chunk) {
+  jdtlsBuffer += chunk.toString();
+  while (true) {
+    if (jdtlsExpectedLen === -1) {
+      const headerEnd = jdtlsBuffer.indexOf("\r\n\r\n");
+      if (headerEnd === -1) break;
+      const header = jdtlsBuffer.slice(0, headerEnd);
+      const m = header.match(/Content-Length:\s*(\d+)/i);
+      if (!m) { jdtlsBuffer = jdtlsBuffer.slice(headerEnd + 4); continue; }
+      jdtlsExpectedLen = parseInt(m[1], 10);
+      jdtlsBuffer = jdtlsBuffer.slice(headerEnd + 4);
+    }
+    if (jdtlsBuffer.length < jdtlsExpectedLen) break;
+    const body = jdtlsBuffer.slice(0, jdtlsExpectedLen);
+    jdtlsBuffer = jdtlsBuffer.slice(jdtlsExpectedLen);
+    jdtlsExpectedLen = -1;
+    handleJdtlsMessage(body);
+  }
+}
+
+function handleJdtlsMessage(raw) {
+  let msg;
+  try { msg = JSON.parse(raw); } catch { return; }
+
+  if (msg.id && jdtlsInitResolve && !jdtlsReady) {
+    jdtlsReady = true;
+    jdtlsProc.stdin.write(lspNotify("initialized", {}));
+    jdtlsInitResolve();
+    jdtlsInitResolve = null;
+    jdtlsInitReject = null;
+    return;
+  }
+
+  if (msg.method === "textDocument/publishDiagnostics") {
+    const uri = normUri(msg.params.uri);
+    const diags = msg.params.diagnostics || [];
+    jdtlsDiagnostics.set(uri, diags);
+
+    if (diags.length > 0) {
+      jdtlsEmptyCount.set(uri, 0);
+      for (const w of jdtlsDiagWaiters.filter(x => x.uri === uri)) {
+        clearTimeout(w.timer);
+        w.resolve(diags);
+      }
+      jdtlsDiagWaiters = jdtlsDiagWaiters.filter(x => x.uri !== uri);
+    } else {
+      const count = (jdtlsEmptyCount.get(uri) || 0) + 1;
+      jdtlsEmptyCount.set(uri, count);
+      if (jdtlsWarmedUp && count >= 2) {
+        for (const w of jdtlsDiagWaiters.filter(x => x.uri === uri)) {
+          clearTimeout(w.timer);
+          w.resolve([]);
+        }
+        jdtlsDiagWaiters = jdtlsDiagWaiters.filter(x => x.uri !== uri);
+      }
+    }
+  }
+}
+
+function uriToRel(uri, root) {
+  let p = uri.replace(/^file:\/\/\/?/, "");
+  p = decodeURIComponent(p).replace(/\//g, path.sep);
+  if (process.platform === "win32" && /^[a-zA-Z]:/.test(p)) {
+    // already absolute
+  } else if (!path.isAbsolute(p)) {
+    p = path.join(root, p);
+  }
+  return path.relative(root, p).replace(/\\/g, "/");
+}
+
+function waitForDiag(uri, timeoutMs) {
+  return new Promise((resolve) => {
+    const existing = jdtlsDiagnostics.get(uri);
+    if (existing && existing.length > 0) { resolve(existing); return; }
+    if (jdtlsWarmedUp && (jdtlsEmptyCount.get(uri) || 0) >= 2) { resolve([]); return; }
+
+    const timer = setTimeout(() => {
+      jdtlsDiagWaiters = jdtlsDiagWaiters.filter(x => x !== entry);
+      resolve(jdtlsDiagnostics.get(uri) || []);
+    }, timeoutMs);
+    const entry = { uri, resolve, timer };
+    jdtlsDiagWaiters.push(entry);
+  });
+}
+
+function startJdtls(root) {
+  if (jdtlsStartingPromise) return jdtlsStartingPromise;
+  jdtlsStartingPromise = new Promise((resolve, reject) => {
+    const bin = findJdtls();
+    if (!bin) { resolve(false); return; }
+    jdtlsRoot = root;
+    jdtlsInitResolve = () => resolve(true);
+    jdtlsInitReject = reject;
+    const dataDir = path.join(root, ".jdtls-data-" + process.pid);
+    jdtlsProc = spawn(bin, ["-data", dataDir], {
+      cwd: root,
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true,
+    });
+    jdtlsProc.stdout.on("data", onJdtlsData);
+    jdtlsProc.on("error", (e) => { if (jdtlsInitReject) { jdtlsInitReject(e); jdtlsInitReject = null; } });
+    jdtlsProc.on("close", () => { jdtlsReady = false; });
+
+    const initParams = {
+      processId: process.pid,
+      rootUri: fileUri(root),
+      capabilities: { textDocument: { publishDiagnostics: { relatedInformation: true } } },
+      workspaceFolders: [{ uri: fileUri(root), name: path.basename(root) }],
+    };
+    jdtlsProc.stdin.write(lspRequest("initialize", initParams));
+
+    setTimeout(() => {
+      if (!jdtlsReady && jdtlsInitResolve) {
+        jdtlsInitResolve = null;
+        jdtlsInitReject = null;
+        resolve(false);
+      }
+    }, BOOTSTRAP_BUDGET_MS);
+  });
+  return jdtlsStartingPromise;
+}
+
+function eagerWarmUp(root, files) {
+  let candidates = [];
+  if (files && files.length > 0) {
+    candidates = files.map(f => path.isAbsolute(f) ? f : path.join(root, f));
+  } else {
+    try {
+      const entries = fs.readdirSync(root);
+      candidates = entries
+        .filter(e => e.endsWith(".java"))
+        .slice(0, 5)
+        .map(e => path.join(root, e));
+    } catch {}
+    if (candidates.length === 0) {
+      const srcDir = path.join(root, "src");
+      try {
+        const entries = fs.readdirSync(srcDir);
+        candidates = entries
+          .filter(e => e.endsWith(".java"))
+          .slice(0, 5)
+          .map(e => path.join(srcDir, e));
+      } catch {}
+    }
+  }
+  for (const fp of candidates) {
+    if (fs.existsSync(fp)) sendDocOpen(fp);
+  }
+  setTimeout(() => { jdtlsWarmedUp = true; }, WARM_SETTLE_MS);
+}
+
+function sendDocOpen(filePath) {
+  const uri = fileUri(filePath);
+  const nuri = normUri(uri);
+  let text;
+  try { text = fs.readFileSync(filePath, "utf8"); } catch { return; }
+  if (openDocs.has(nuri)) {
+    const version = (openDocs.get(nuri) || 0) + 1;
+    openDocs.set(nuri, version);
+    jdtlsEmptyCount.set(nuri, 0);
+    jdtlsDiagnostics.delete(nuri);
+    jdtlsProc.stdin.write(lspNotify("textDocument/didChange", {
+      textDocument: { uri, version },
+      contentChanges: [{ text }],
+    }));
+  } else {
+    openDocs.set(nuri, 1);
+    jdtlsEmptyCount.set(nuri, 0);
+    jdtlsDocOpenTime.set(nuri, Date.now());
+    jdtlsProc.stdin.write(lspNotify("textDocument/didOpen", {
+      textDocument: { uri, languageId: "java", version: 1, text },
+    }));
+  }
+}
+
+function queryLsp(root, files) {
+  const results = [];
+  const promises = files.map(f => {
+    const fp = path.isAbsolute(f) ? f : path.join(root, f);
+    sendDocOpen(fp);
+    const uri = normUri(fileUri(fp));
+    return waitForDiag(uri, WARM_SETTLE_MS + 3000).then(diags => {
+      for (const d of diags) {
+        if (d.severity && d.severity > 1) continue;
+        results.push({
+          file: path.relative(root, fp).replace(/\\/g, "/"),
+          line: (d.range?.start?.line || 0) + 1,
+          col: (d.range?.start?.character || 0) + 1,
+          message: d.message || "error",
+          source: "java-deep-layer",
+          kind: "type_error",
+        });
+      }
+    });
+  });
+  return Promise.all(promises).then(() => results);
+}
+
+function findJavac() {
+  const whichCmd = process.platform === "win32" ? "where.exe" : "which";
+  const r = spawnSync(whichCmd, ["javac"], {
+    encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], windowsHide: true,
+  });
+  if (r.status === 0) {
+    const line = r.stdout.split(/\r?\n/).map(l => l.trim()).filter(Boolean)[0];
+    return line || null;
+  }
+  return null;
+}
+
+function runJavac(root, files) {
+  const javac = findJavac();
+  if (!javac) return null;
+  const absPaths = files.map(f => path.isAbsolute(f) ? f : path.join(root, f));
+  const outDir = path.join(root, "__javac_out__");
+  try { fs.mkdirSync(outDir, { recursive: true }); } catch {}
+  const args = ["-J-Duser.language=en", "-J-Duser.country=US", "-d", outDir, "-Xlint:all", ...absPaths];
+  const r = spawnSync(javac, args, {
+    cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], windowsHide: true, timeout: 15000,
+  });
+  try { fs.rmSync(outDir, { recursive: true, force: true }); } catch {}
+  if (r.status === 0) return [];
+  const issues = [];
+  const re = /^(.+?):(\d+):\s*(?:error|错误):\s*(.+)$/gm;
+  const output = (r.stderr || "") + (r.stdout || "");
+  let m;
+  while ((m = re.exec(output)) !== null) {
+    const rel = path.relative(root, m[1]).replace(/\\/g, "/");
+    issues.push({ file: rel, line: parseInt(m[2], 10), col: 1, message: m[3], source: "java-deep-layer", kind: "type_error" });
+  }
+  return issues;
+}
+
+async function handleRequest(req) {
+  const t0 = Date.now();
+  const root = req.root || process.cwd();
+  const files = req.files || [];
+  if (files.length === 0) {
+    return { issues: [], status: "clean", reason: "no_files", elapsed_ms: 0 };
+  }
+
+  const javacResult = runJavac(root, files);
+  if (javacResult !== null && javacResult.length > 0) {
+    return { issues: javacResult, status: "type_error", reason: "javac", elapsed_ms: Date.now() - t0, bootstrap: true };
+  }
+  if (javacResult !== null && javacResult.length === 0) {
+    return { issues: [], status: "clean", reason: "javac_clean", elapsed_ms: Date.now() - t0, bootstrap: true };
+  }
+
+  const lspOk = await startJdtls(root);
+  if (lspOk) {
+    eagerWarmUp(root, files);
+    const lspIssues = await queryLsp(root, files);
+    const elapsed = Date.now() - t0;
+    if (lspIssues.length > 0) {
+      return { issues: lspIssues, status: "type_error", reason: "jdtls", elapsed_ms: elapsed };
+    }
+    return { issues: [], status: "clean", reason: "jdtls_clean", elapsed_ms: elapsed };
+  }
+
+  return { issues: [], status: "unavailable", reason: "no_javac_no_jdtls", error: "neither javac nor jdtls found", elapsed_ms: Date.now() - t0 };
+}
+
+const rl = readline.createInterface({ input: process.stdin, terminal: false });
+rl.on("line", (line) => {
+  const trimmed = line.trim();
+  if (!trimmed) return;
+  let req;
+  try { req = JSON.parse(trimmed); } catch { return; }
+  handleRequest(req).then((result) => {
+    process.stdout.write(JSON.stringify(result) + "\n");
+  }).catch((err) => {
+    process.stdout.write(JSON.stringify({ issues: [], status: "error", error: String(err), elapsed_ms: 0 }) + "\n");
+  });
+});
+rl.on("close", () => { killJdtls(); process.exit(0); });

package/bundled/pre-engine/win32-x64/kotlin-deep-layer.cjs

@@ -0,0 +1,105 @@
+"use strict";
+const readline = require("readline");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+function findKotlinc() {
+  const whichCmd = process.platform === "win32" ? "where.exe" : "which";
+  const r = spawnSync(whichCmd, ["kotlinc"], {
+    encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], windowsHide: true,
+  });
+  if (r.status === 0) {
+    const line = r.stdout.split(/\r?\n/).map(l => l.trim()).filter(Boolean)[0];
+    return line || null;
+  }
+  return null;
+}
+
+function runKotlincCheck(root, files) {
+  const kotlinc = findKotlinc();
+  if (!kotlinc) return null;
+
+  const issues = [];
+  for (const f of files) {
+    const abs = path.isAbsolute(f) ? f : path.join(root, f);
+    let r;
+    try {
+      r = spawnSync(kotlinc, ["-script", abs, "-nowarn"], {
+        cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true, timeout: 60000,
+      });
+    } catch (e) { continue; }
+
+    if (r.error) continue;
+
+    if (r.status !== 0) {
+      const output = (r.stderr || "") + (r.stdout || "");
+      const rel = path.relative(root, abs).replace(/\\/g, "/");
+      const lines = output.split(/\r?\n/);
+      let found = false;
+      for (const line of lines) {
+        const m = line.match(/^.+?:(\d+):(\d+):\s*(error|warning):\s*(.+)$/);
+        if (m) {
+          issues.push({
+            file: rel,
+            line: parseInt(m[1], 10),
+            col: parseInt(m[2], 10),
+            kind: m[3] === "warning" ? "warning" : "error",
+            message: m[4].trim(),
+            source: "kotlin-deep-layer",
+          });
+          found = true;
+        }
+      }
+      if (!found) {
+        const firstLine = lines.find(l => l.trim()) || "compilation error";
+        issues.push({
+          file: rel, line: 1, col: 1,
+          kind: "error", message: firstLine.trim(),
+          source: "kotlin-deep-layer",
+        });
+      }
+    }
+  }
+  return { issues };
+}
+
+async function handleRequest(req) {
+  const t0 = Date.now();
+  const root = req.root || process.cwd();
+  const files = req.files || [];
+  if (files.length === 0) {
+    return { issues: [], status: "clean", reason: "no_files", elapsed_ms: 0 };
+  }
+
+  const lintResult = runKotlincCheck(root, files);
+  if (lintResult) {
+    return {
+      issues: lintResult.issues,
+      status: lintResult.issues.length > 0 ? "kotlin_error" : "clean",
+      reason: "kotlinc",
+      elapsed_ms: Date.now() - t0,
+    };
+  }
+
+  return {
+    issues: [],
+    status: "unavailable",
+    reason: "kotlinc_not_found",
+    elapsed_ms: Date.now() - t0,
+  };
+}
+
+const rl = readline.createInterface({ input: process.stdin, terminal: false });
+rl.on("line", (line) => {
+  const trimmed = line.trim();
+  if (!trimmed) return;
+  let req;
+  try { req = JSON.parse(trimmed); } catch { return; }
+  handleRequest(req).then((result) => {
+    process.stdout.write(JSON.stringify(result) + "\n");
+  }).catch((err) => {
+    process.stdout.write(JSON.stringify({ issues: [], status: "error", error: String(err), elapsed_ms: 0 }) + "\n");
+  });
+});
+rl.on("close", () => { process.exit(0); });

package/bundled/pre-engine/win32-x64/php-deep-layer.cjs

@@ -0,0 +1,179 @@
+"use strict";
+const readline = require("readline");
+const path = require("path");
+const fs = require("fs");
+const { spawnSync } = require("child_process");
+
+function findPhp() {
+  const whichCmd = process.platform === "win32" ? "where.exe" : "which";
+  const r = spawnSync(whichCmd, ["php"], {
+    encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], windowsHide: true,
+  });
+  if (r.status === 0) {
+    const line = r.stdout.split(/\r?\n/).map(l => l.trim()).filter(Boolean)[0];
+    return line || null;
+  }
+  return null;
+}
+
+function runPhpLint(root, files) {
+  const php = findPhp();
+  if (!php) return null;
+
+  const issues = [];
+  for (const f of files) {
+    const abs = path.isAbsolute(f) ? f : path.join(root, f);
+    let r;
+    try {
+      r = spawnSync(php, ["-l", abs], {
+        cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true, timeout: 30000,
+      });
+    } catch (e) { continue; }
+
+    if (r.error) continue;
+
+    const output = (r.stdout || "") + (r.stderr || "");
+    if (r.status !== 0) {
+      const rel = path.relative(root, abs).replace(/\\/g, "/");
+      const m = output.match(/Parse error:\s*(.+?)\s+in\s+.+?\s+on line\s+(\d+)/i);
+      if (m) {
+        issues.push({
+          file: rel,
+          line: parseInt(m[2], 10),
+          col: 1,
+          kind: "error",
+          message: m[1],
+          source: "php-deep-layer",
+        });
+      } else {
+        const trimmed = output.trim().split(/\r?\n/)[0] || "syntax error";
+        issues.push({
+          file: rel, line: 1, col: 1,
+          kind: "error", message: trimmed,
+          source: "php-deep-layer",
+        });
+      }
+    }
+  }
+  return { issues };
+}
+
+function fallbackSyntaxCheck(root, files) {
+  const issues = [];
+  for (const f of files) {
+    const abs = path.isAbsolute(f) ? f : path.join(root, f);
+    let content;
+    try { content = fs.readFileSync(abs, "utf8"); } catch { continue; }
+    const rel = path.relative(root, abs).replace(/\\/g, "/");
+    const lines = content.split(/\r?\n/);
+
+    let braceDepth = 0;
+    let inSingleQuote = false, inDoubleQuote = false;
+    let inLineComment = false, inBlockComment = false;
+    let inHeredoc = null;
+    let unclosedLine = 0;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      if (inHeredoc) {
+        if (line.trim() === inHeredoc || line.trim() === inHeredoc + ";") {
+          inHeredoc = null;
+        }
+        continue;
+      }
+
+      inLineComment = false;
+      for (let j = 0; j < line.length; j++) {
+        const ch = line[j];
+        const next = j + 1 < line.length ? line[j + 1] : "";
+
+        if (inBlockComment) {
+          if (ch === "*" && next === "/") { inBlockComment = false; j++; }
+          continue;
+        }
+        if (inSingleQuote) {
+          if (ch === "\\") { j++; continue; }
+          if (ch === "'") inSingleQuote = false;
+          continue;
+        }
+        if (inDoubleQuote) {
+          if (ch === "\\") { j++; continue; }
+          if (ch === '"') inDoubleQuote = false;
+          continue;
+        }
+        if (inLineComment) continue;
+
+        if (ch === "/" && next === "/") { inLineComment = true; continue; }
+        if (ch === "#") { inLineComment = true; continue; }
+        if (ch === "/" && next === "*") { inBlockComment = true; j++; continue; }
+        if (ch === "'") { inSingleQuote = true; unclosedLine = i + 1; continue; }
+        if (ch === '"') { inDoubleQuote = true; unclosedLine = i + 1; continue; }
+        if (ch === "<" && next === "<" && j + 2 < line.length && line[j + 2] === "<") {
+          const rest = line.slice(j + 3).trim().replace(/^'|'$/g, "").replace(/^"|"$/g, "");
+          if (rest) { inHeredoc = rest; }
+          break;
+        }
+        if (ch === "{") braceDepth++;
+        else if (ch === "}") braceDepth--;
+      }
+    }
+    if (braceDepth > 0) {
+      issues.push({ file: rel, line: lines.length, col: 1,
+        kind: "syntax_error", message: `Unmatched opening brace (${braceDepth} unclosed)`,
+        source: "php-deep-layer" });
+    } else if (braceDepth < 0) {
+      issues.push({ file: rel, line: 1, col: 1,
+        kind: "syntax_error", message: `Unmatched closing brace (${-braceDepth} extra)`,
+        source: "php-deep-layer" });
+    }
+    if (inDoubleQuote || inSingleQuote) {
+      issues.push({ file: rel, line: unclosedLine, col: 1,
+        kind: "syntax_error", message: "Unclosed string literal",
+        source: "php-deep-layer" });
+    }
+  }
+  return issues;
+}
+
+async function handleRequest(req) {
+  const t0 = Date.now();
+  const root = req.root || process.cwd();
+  const files = req.files || [];
+  if (files.length === 0) {
+    return { issues: [], status: "clean", reason: "no_files", elapsed_ms: 0 };
+  }
+
+  const lintResult = runPhpLint(root, files);
+  if (lintResult) {
+    return {
+      issues: lintResult.issues,
+      status: lintResult.issues.length > 0 ? "php_error" : "clean",
+      reason: "php",
+      elapsed_ms: Date.now() - t0,
+    };
+  }
+
+  const fallbackIssues = fallbackSyntaxCheck(root, files);
+  return {
+    issues: fallbackIssues,
+    status: fallbackIssues.length > 0 ? "syntax_error" : "clean",
+    reason: fallbackIssues.length > 0 ? "fallback" : "fallback_clean",
+    elapsed_ms: Date.now() - t0,
+  };
+}
+
+const rl = readline.createInterface({ input: process.stdin, terminal: false });
+rl.on("line", (line) => {
+  const trimmed = line.trim();
+  if (!trimmed) return;
+  let req;
+  try { req = JSON.parse(trimmed); } catch { return; }
+  handleRequest(req).then((result) => {
+    process.stdout.write(JSON.stringify(result) + "\n");
+  }).catch((err) => {
+    process.stdout.write(JSON.stringify({ issues: [], status: "error", error: String(err), elapsed_ms: 0 }) + "\n");
+  });
+});
+rl.on("close", () => { process.exit(0); });