@linghun/pre-engine-darwin-x64 0.1.0

package/bundled/pre-engine/darwin-x64/sql-deep-layer.cjs

@@ -0,0 +1,172 @@
+"use strict";
+const readline = require("readline");
+const path = require("path");
+const fs = require("fs");
+const { spawnSync } = require("child_process");
+
+function findSqlfluff() {
+  const whichCmd = process.platform === "win32" ? "where.exe" : "which";
+  const r = spawnSync(whichCmd, ["sqlfluff"], {
+    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 runSqlfluff(root, files) {
+  const sqlfluff = findSqlfluff();
+  if (!sqlfluff) return null;
+
+  const absPaths = files.map(f => path.isAbsolute(f) ? f : path.join(root, f));
+  const args = ["lint", "--format", "json", "--nocolor", ...absPaths];
+  let r;
+  try {
+    r = spawnSync(sqlfluff, args, {
+      cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true, timeout: 30000,
+    });
+  } catch (e) { return { error: `sqlfluff exec: ${e.message}` }; }
+
+  if (r.error) {
+    return { error: r.error.code === "ETIMEDOUT" ? "sqlfluff timeout" : r.error.message };
+  }
+
+  const issues = [];
+  const output = r.stdout || "";
+  try {
+    const parsed = JSON.parse(output);
+    for (const fileEntry of parsed) {
+      const filePath = fileEntry.filepath || "";
+      const rel = path.relative(root, filePath).replace(/\\/g, "/");
+      for (const violation of (fileEntry.violations || [])) {
+        issues.push({
+          file: rel,
+          line: violation.start_line_no || violation.line_no || 1,
+          col: violation.start_line_pos || violation.line_pos || 1,
+          kind: "sql_error",
+          message: violation.description || violation.message || "SQL lint error",
+          code: violation.code || null,
+          source: "sql-deep-layer",
+        });
+      }
+    }
+  } catch {
+    const lines = output.split(/\r?\n/);
+    for (const l of lines) {
+      const m = l.match(/^(.+?):(\d+):(\d+):\s*(.+)/);
+      if (m) {
+        issues.push({
+          file: path.relative(root, m[1]).replace(/\\/g, "/"),
+          line: parseInt(m[2], 10), col: parseInt(m[3], 10),
+          kind: "sql_error", message: m[4], source: "sql-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 parenDepth = 0;
+    let inSingleQuote = false;
+    let unclosedQuoteLine = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      for (let j = 0; j < line.length; j++) {
+        const ch = line[j];
+        if (ch === "'" && (j === 0 || line[j - 1] !== "'")) {
+          if (!inSingleQuote) { inSingleQuote = true; unclosedQuoteLine = i + 1; }
+          else { inSingleQuote = false; }
+        }
+        if (!inSingleQuote) {
+          if (ch === "(") parenDepth++;
+          else if (ch === ")") parenDepth--;
+        }
+      }
+      if (inSingleQuote && i < lines.length - 1) {
+        if (!lines[i + 1].includes("'")) {
+          issues.push({ file: rel, line: unclosedQuoteLine, col: 1,
+            kind: "syntax_error", message: "Unclosed string literal",
+            source: "sql-deep-layer" });
+          inSingleQuote = false;
+        }
+      }
+    }
+    if (inSingleQuote) {
+      issues.push({ file: rel, line: unclosedQuoteLine, col: 1,
+        kind: "syntax_error", message: "Unclosed string literal at end of file",
+        source: "sql-deep-layer" });
+    }
+    if (parenDepth > 0) {
+      issues.push({ file: rel, line: 1, col: 1,
+        kind: "syntax_error", message: `Unmatched opening parenthesis (${parenDepth} unclosed)`,
+        source: "sql-deep-layer" });
+    } else if (parenDepth < 0) {
+      issues.push({ file: rel, line: 1, col: 1,
+        kind: "syntax_error", message: `Unmatched closing parenthesis (${-parenDepth} extra)`,
+        source: "sql-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 sqlfluffResult = runSqlfluff(root, files);
+  if (sqlfluffResult && !sqlfluffResult.error) {
+    return {
+      issues: sqlfluffResult.issues,
+      status: sqlfluffResult.issues.length > 0 ? "sql_error" : "clean",
+      reason: "sqlfluff",
+      elapsed_ms: Date.now() - t0,
+    };
+  }
+
+  const fallbackIssues = fallbackSyntaxCheck(root, files);
+  if (sqlfluffResult && sqlfluffResult.error) {
+    return {
+      issues: fallbackIssues,
+      status: fallbackIssues.length > 0 ? "syntax_error" : "clean",
+      reason: "fallback",
+      fallback: sqlfluffResult.error,
+      elapsed_ms: Date.now() - t0,
+    };
+  }
+
+  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); });

package/bundled/pre-engine/darwin-x64/swift-deep-layer.cjs

@@ -0,0 +1,113 @@
+"use strict";
+const readline = require("readline");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+function findSwiftc() {
+  const whichCmd = process.platform === "win32" ? "where.exe" : "which";
+  for (const cmd of ["swiftc", "xcrun"]) {
+    const r = spawnSync(whichCmd, [cmd], {
+      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];
+      if (line) return cmd === "xcrun" ? { mode: "xcrun", bin: line } : { mode: "swiftc", bin: line };
+    }
+  }
+  return null;
+}
+
+function runSwiftcCheck(root, files) {
+  const tool = findSwiftc();
+  if (!tool) return null;
+
+  const issues = [];
+  for (const f of files) {
+    const abs = path.isAbsolute(f) ? f : path.join(root, f);
+    let args;
+    if (tool.mode === "xcrun") {
+      args = [tool.bin, ["swiftc", "-parse", abs]];
+    } else {
+      args = [tool.bin, ["-parse", abs]];
+    }
+    let r;
+    try {
+      r = spawnSync(args[0], args[1], {
+        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|note):\s*(.+)$/);
+        if (m && m[3] !== "note") {
+          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: "swift-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: "swift-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 = runSwiftcCheck(root, files);
+  if (lintResult) {
+    return {
+      issues: lintResult.issues,
+      status: lintResult.issues.length > 0 ? "swift_error" : "clean",
+      reason: "swiftc",
+      elapsed_ms: Date.now() - t0,
+    };
+  }
+
+  return {
+    issues: [],
+    status: "unavailable",
+    reason: "swift_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/darwin-x64/ts-deep-layer.cjs

@@ -0,0 +1,142 @@
+"use strict";
+const readline = require("readline");
+const path = require("path");
+const fs = require("fs");
+
+let ts = null;
+let cachedHost = null;
+let cachedOpts = null;
+let cachedFileNames = null;
+let cachedRoot = null;
+let cachedTsconfigPath = null;
+let currentProgram = null;
+let fileStatCache = new Map();
+let knownProjectFiles = new Set();
+
+function updateStatCache(absPath) {
+  try {
+    const st = fs.statSync(absPath);
+    const cached = fileStatCache.get(absPath);
+    const changed = !cached || cached.mtimeMs !== st.mtimeMs || cached.size !== st.size;
+    fileStatCache.set(absPath, { mtimeMs: st.mtimeMs, size: st.size });
+    return changed;
+  } catch {
+    fileStatCache.delete(absPath);
+    return true;
+  }
+}
+
+function tryResolveTs(root) {
+  for (const c of [path.join(root, "node_modules", "typescript"), "typescript"]) {
+    try { return require(c); } catch {}
+  }
+  return null;
+}
+
+function ensureSetup(root, tsconfigPath) {
+  if (!ts) {
+    ts = tryResolveTs(root);
+    if (!ts) return "typescript not available";
+  }
+  if (cachedRoot === root && cachedTsconfigPath === tsconfigPath) return null;
+
+  let opts = { noEmit: true, strict: false, skipLibCheck: true };
+  let fileNames = [];
+
+  if (tsconfigPath) {
+    const cfgFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+    if (!cfgFile.error) {
+      const parsed = ts.parseJsonConfigFileContent(cfgFile.config, ts.sys, path.dirname(tsconfigPath));
+      opts = { ...parsed.options, noEmit: true };
+      fileNames = parsed.fileNames;
+    }
+  }
+
+  cachedOpts = opts;
+  cachedFileNames = fileNames;
+  cachedHost = ts.createCompilerHost(opts);
+  cachedRoot = root;
+  cachedTsconfigPath = tsconfigPath;
+  currentProgram = null;
+  fileStatCache.clear();
+  knownProjectFiles.clear();
+  return null;
+}
+
+function runCheck(root, files, tsconfigPath) {
+  const err = ensureSetup(root, tsconfigPath);
+  if (err) return { error: err };
+
+  const absFiles = files.map(f => path.isAbsolute(f) ? f : path.join(root, f));
+  for (const f of absFiles) knownProjectFiles.add(f);
+  const allFiles = [...new Set([...cachedFileNames, ...knownProjectFiles])];
+
+  let anyStatChanged = false;
+  for (const f of absFiles) {
+    if (updateStatCache(f)) anyStatChanged = true;
+  }
+  let needRebuild = !currentProgram || anyStatChanged;
+  if (!needRebuild) {
+    for (const f of absFiles) {
+      if (!currentProgram.getSourceFile(path.normalize(f))) {
+        needRebuild = true;
+        break;
+      }
+    }
+  }
+
+  if (needRebuild) {
+    currentProgram = ts.createProgram(allFiles, cachedOpts, cachedHost, currentProgram);
+    const normalRoot = path.normalize(root) + path.sep;
+    for (const sf of currentProgram.getSourceFiles()) {
+      const sfPath = path.normalize(sf.fileName);
+      if (sfPath.startsWith(normalRoot) && !fileStatCache.has(sfPath)) {
+        updateStatCache(sfPath);
+      }
+    }
+  }
+
+  const issues = [];
+  for (const f of absFiles) {
+    const sf = currentProgram.getSourceFile(path.normalize(f));
+    if (!sf) continue;
+    const diags = [
+      ...currentProgram.getSemanticDiagnostics(sf),
+      ...currentProgram.getSyntacticDiagnostics(sf),
+    ];
+    for (const d of diags) {
+      if (d.category !== 1) continue;
+      const rel = path.relative(root, sf.fileName).replace(/\\/g, "/");
+      let line = 1;
+      if (d.file && d.start != null) {
+        const lc = d.file.getLineAndCharacterOfPosition(d.start);
+        line = lc.line + 1;
+      }
+      issues.push({
+        file: rel,
+        line,
+        kind: "type_error",
+        detail: ts.flattenDiagnosticMessageText(d.messageText, " "),
+        source: "typescript-deep-layer",
+      });
+    }
+  }
+  return { issues };
+}
+
+const rl = readline.createInterface({ input: process.stdin, terminal: false });
+rl.on("line", line => {
+  line = line.trim();
+  if (!line) return;
+  let req;
+  try { req = JSON.parse(line); } catch { return; }
+  const t0 = Date.now();
+  let resp;
+  try {
+    const result = runCheck(req.root, req.files || [], req.tsconfig || null);
+    resp = { ...result, elapsed_ms: Date.now() - t0 };
+  } catch (e) {
+    resp = { error: String(e), elapsed_ms: Date.now() - t0 };
+  }
+  process.stdout.write(JSON.stringify(resp) + "\n");
+});

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@linghun/pre-engine-darwin-x64",
+  "version": "0.1.0",
+  "license": "Apache-2.0",
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "files": [
+    "bundled"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}