ultracode 5.4.0 → 5.6.0

package/dist/chunks/validation-tool-handlers-RREUYKIR.js

@@ -0,0 +1,555 @@
+import { OxlintLinter } from './chunk-JWCPPJ4E.js';
+import { exec } from './chunk-R7CSWEXZ.js';
+import { ValidateFileSchema, ValidateDirectorySchema } from './chunk-XGXCOGVI.js';
+import { BaseToolHandler } from './chunk-SAMX3HJQ.js';
+import './chunk-WIE3G5ES.js';
+import './chunk-XK2NY7RB.js';
+import './chunk-HEMJHRHZ.js';
+import { toError } from './chunk-5WKPA33T.js';
+import './chunk-BMHPPH2B.js';
+import { init_logging, log } from './chunk-VCCBEJQ5.js';
+import './chunk-NAQKA54E.js';
+import { copyFile, readFile, unlink, access } from 'fs/promises';
+import { join } from 'path';
+import { LRUCache } from 'lru-cache';
+import { tmpdir } from 'os';
+
+// src/tools/handlers/validation-tool-handlers.ts
+init_logging();
+var CONFIG_FILES = {
+  biome: ["biome.json", "biome.jsonc"],
+  eslint: [
+    ".eslintrc",
+    ".eslintrc.js",
+    ".eslintrc.json",
+    ".eslintrc.yml",
+    ".eslintrc.yaml",
+    "eslint.config.js",
+    "eslint.config.mjs",
+    "eslint.config.cjs"
+  ],
+  oxlint: ["oxlint.config.ts", "oxlint.config.js"]
+};
+var configCache = new LRUCache({
+  max: 100,
+  ttl: 1e3 * 60 * 5
+  // 5 minutes
+});
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectLinterConfigsUncached(projectPath) {
+  const hasBiomeConfig = (await Promise.all(CONFIG_FILES.biome.map((f) => fileExists(join(projectPath, f))))).some(
+    (exists) => exists
+  );
+  const hasESLintConfig = (await Promise.all(CONFIG_FILES.eslint.map((f) => fileExists(join(projectPath, f))))).some(
+    (exists) => exists
+  );
+  const hasOxlintConfig = (await Promise.all(CONFIG_FILES.oxlint.map((f) => fileExists(join(projectPath, f))))).some(
+    (exists) => exists
+  );
+  let preferredFixerForTS = "oxlint";
+  if (hasBiomeConfig) {
+    preferredFixerForTS = "biome";
+  } else if (hasESLintConfig) {
+    preferredFixerForTS = "eslint";
+  } else if (hasOxlintConfig) {
+    preferredFixerForTS = "oxlint";
+  }
+  return {
+    hasBiomeConfig,
+    hasESLintConfig,
+    hasOxlintConfig,
+    preferredFixerForTS
+  };
+}
+async function detectLinterConfigs(projectPath) {
+  const cached = configCache.get(projectPath);
+  if (cached) {
+    return cached;
+  }
+  const result = await detectLinterConfigsUncached(projectPath);
+  configCache.set(projectPath, result);
+  return result;
+}
+
+// src/validation/linters/biome-linter.ts
+init_logging();
+var BiomeLinter = class {
+  name = "biome";
+  binPath = null;
+  /**
+   * Lint file with Biome
+   * @param filePath - Path to file to lint
+   * @param _content - File content (not used, Biome reads from disk)
+   * @param autofix - Apply automatic fixes (biome check --write)
+   * @param dryRun - Show what would be fixed without applying changes
+   */
+  async lint(filePath, _content, autofix = false, dryRun = false) {
+    try {
+      const bin = await this.getBinPath();
+      if (autofix && dryRun) {
+        const tempFile = join(tmpdir(), `biome-dryrun-${Date.now()}.tmp`);
+        try {
+          await copyFile(filePath, tempFile);
+          const command2 = `"${bin}" check --write --reporter=json "${tempFile}"`;
+          await exec(command2, { timeout: 3e4 });
+          const original = await readFile(filePath, "utf-8");
+          const fixed = await readFile(tempFile, "utf-8");
+          const problems = await this.lint(filePath, _content, false);
+          if (original !== fixed) {
+            problems.push({
+              severity: "info",
+              message: `[DRY-RUN] Would apply autofixes (${fixed.length - original.length} chars diff)`,
+              line: 0,
+              column: 0,
+              source: "biome"
+            });
+          }
+          return problems;
+        } finally {
+          await unlink(tempFile).catch(() => {
+          });
+        }
+      }
+      const writeFlag = autofix ? "--write" : "";
+      const command = `"${bin}" check ${writeFlag} --reporter=json "${filePath}"`;
+      const { stdout, stderr } = await exec(command, { timeout: 3e4 });
+      return this.parseOutput(stdout || stderr);
+    } catch (error) {
+      const err = error;
+      const output = err.stdout || err.stderr || "";
+      if (output) {
+        return this.parseOutput(output);
+      }
+      log.w("BIOME", "lint_fail", { err: String(error) });
+      return [];
+    }
+  }
+  parseOutput(output) {
+    try {
+      const parsed = JSON.parse(output);
+      if (!parsed.diagnostics) return [];
+      return parsed.diagnostics.map((d) => ({
+        severity: d.severity === "error" ? "error" : "warning",
+        message: d.message.content,
+        line: d.location?.span?.start?.line ?? 0,
+        column: d.location?.span?.start?.column ?? 0,
+        ruleId: d.category,
+        source: "biome"
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async getBinPath() {
+    if (this.binPath) return this.binPath;
+    const { createRequire } = await import('module');
+    const { dirname, join: join3 } = await import('path');
+    const { access: access2 } = await import('fs/promises');
+    try {
+      const require2 = createRequire(import.meta.url);
+      const biomePkg = require2.resolve("@biomejs/biome/package.json");
+      const biomeDir = dirname(biomePkg);
+      const binPath = join3(biomeDir, "bin", "biome");
+      await access2(binPath);
+      this.binPath = binPath;
+      return binPath;
+    } catch (error) {
+      log.e("BIOME", "not_found", {
+        err: String(error),
+        hint: "Biome should be in dependencies"
+      });
+      throw new Error("Biome binary not found (check installation)");
+    }
+  }
+};
+
+// src/tools/handlers/validation-tool-handlers.ts
+var ValidateFileToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return ValidateFileSchema.parse(args);
+  }
+  async execute(args) {
+    const { extname } = await import('path');
+    const filePath = this.context.normalizeInputPath(args.filePath) || args.filePath;
+    const ext = extname(filePath).toLowerCase();
+    const results = [];
+    try {
+      const validators = args.validators || this.getDefaultValidators(ext);
+      for (const validator of validators) {
+        const result = await this.runValidator(
+          validator,
+          filePath,
+          args.fixable,
+          args.dryRun ?? false,
+          args.projectPath
+        );
+        results.push(result);
+      }
+      const totalErrors = results.reduce((sum, r) => sum + (r.errors || 0), 0);
+      const totalWarnings = results.reduce((sum, r) => sum + (r.warnings || 0), 0);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                file: filePath,
+                validators,
+                totalErrors,
+                totalWarnings,
+                isValid: totalErrors === 0,
+                results
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    } catch (error) {
+      const err = toError(error);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: err.message }) }]
+      };
+    }
+  }
+  getDefaultValidators(ext) {
+    const map = {
+      ".ts": ["oxlint", "tsc"],
+      ".tsx": ["oxlint", "tsc"],
+      ".js": ["oxlint"],
+      ".jsx": ["oxlint"],
+      ".py": ["pylint", "mypy"],
+      ".rs": ["cargo-check"],
+      ".go": ["go-vet"],
+      ".java": ["javac"],
+      ".cs": ["roslyn"],
+      ".csx": ["roslyn"]
+    };
+    return map[ext] || [];
+  }
+  async runValidator(validator, filePath, fixable, dryRun, projectPath) {
+    const { exec: exec2 } = await import('./shell-7G3FZNWY.js');
+    const { dirname, extname } = await import('path');
+    const cwd = dirname(filePath);
+    const ext = extname(filePath);
+    if (fixable && (validator === "oxlint" || ext === ".ts" || ext === ".tsx" || ext === ".js" || ext === ".jsx")) {
+      const configInfo = await detectLinterConfigs(projectPath || cwd);
+      if (configInfo.preferredFixerForTS === "biome") {
+        log.d("VALIDATION", "using_biome", { filePath, config: "biome.json" });
+        try {
+          const biomeLinter = new BiomeLinter();
+          const problems = await biomeLinter.lint(filePath, "", true, dryRun);
+          return {
+            validator: "biome",
+            errors: problems.filter((p) => p.severity === "error").length,
+            warnings: problems.filter((p) => p.severity === "warning").length,
+            issues: problems.map((p) => ({
+              line: p.line,
+              column: p.column,
+              message: p.message,
+              rule: p.ruleId,
+              severity: p.severity
+            }))
+          };
+        } catch (error) {
+          log.w("VALIDATION", "biome_failed_fallback", {
+            filePath,
+            err: String(error),
+            fallback: "oxlint"
+          });
+        }
+      } else if (configInfo.preferredFixerForTS === "eslint") {
+        log.d("VALIDATION", "eslint_config_detected", {
+          filePath,
+          config: ".eslintrc",
+          note: "ESLint not implemented, falling back to oxlint"
+        });
+      }
+    }
+    try {
+      let command;
+      switch (validator) {
+        case "oxlint": {
+          if (fixable || dryRun) {
+            const oxlintLinter = new OxlintLinter();
+            const problems = await oxlintLinter.lint(filePath, "", fixable, dryRun);
+            return {
+              validator: "oxlint",
+              errors: problems.filter((p) => p.severity === "error").length,
+              warnings: problems.filter((p) => p.severity === "warning").length,
+              issues: problems.map((p) => ({
+                line: p.line,
+                column: p.column,
+                message: p.message,
+                rule: p.ruleId,
+                severity: p.severity
+              }))
+            };
+          }
+          const oxlintBin = await this.findOxlintBin();
+          command = `"${oxlintBin}" --format json "${filePath}"`;
+          break;
+        }
+        case "tsc":
+          command = `npx tsc --noEmit "${filePath}" 2>&1`;
+          break;
+        case "pylint":
+          command = `pylint --output-format=json "${filePath}"`;
+          break;
+        case "mypy":
+          command = `mypy --no-error-summary "${filePath}"`;
+          break;
+        case "cargo-check":
+          command = `cargo check --message-format=json 2>&1`;
+          break;
+        case "go-vet":
+          command = `go vet "${filePath}" 2>&1`;
+          break;
+        case "roslyn": {
+          try {
+            const { getCSharpParser, ensureRoslynStarted, findSolutionFile } = await import('./addons-72SDV3F3.js');
+            let parser = getCSharpParser();
+            if (!parser) {
+              let dir = cwd;
+              let slnPath = null;
+              for (let i = 0; i < 10; i++) {
+                slnPath = findSolutionFile(dir);
+                if (slnPath) break;
+                const { dirname: dn } = await import('path');
+                const parent = dn(dir);
+                if (parent === dir) break;
+                dir = parent;
+              }
+              if (slnPath) {
+                parser = await ensureRoslynStarted(slnPath);
+              }
+            }
+            if (!parser) {
+              return {
+                validator: "roslyn",
+                errors: 0,
+                warnings: 0,
+                issues: [{ message: "Roslyn addon not available (no .sln found or DLL missing)", severity: "warning" }]
+              };
+            }
+            const parseResult = await parser.parseFile(filePath);
+            if (!parseResult || !parseResult.entities || parseResult.entities.length === 0) {
+              return { validator: "roslyn", errors: 0, warnings: 0, issues: [] };
+            }
+            const issues2 = [];
+            for (const entity of parseResult.entities) {
+              if (entity.metadata?.diagnostics) {
+                for (const diag of entity.metadata.diagnostics) {
+                  issues2.push({
+                    line: diag.line,
+                    column: diag.column,
+                    message: `${diag.id}: ${diag.message}`,
+                    rule: diag.id,
+                    severity: diag.severity === "error" ? "error" : diag.severity === "warning" ? "warning" : "info"
+                  });
+                }
+              }
+            }
+            return {
+              validator: "roslyn",
+              errors: issues2.filter((i) => i.severity === "error").length,
+              warnings: issues2.filter((i) => i.severity === "warning").length,
+              issues: issues2
+            };
+          } catch (error) {
+            return {
+              validator: "roslyn",
+              errors: 1,
+              warnings: 0,
+              issues: [{ message: `Roslyn validation failed: ${String(error)}`, severity: "error" }]
+            };
+          }
+        }
+        default:
+          return { validator, errors: 0, warnings: 0, issues: [{ message: "Unknown validator", severity: "error" }] };
+      }
+      const result = await exec2(command, { cwd, timeout: 6e4 });
+      const issues = this.parseValidatorOutput(validator, result.stdout + result.stderr);
+      return {
+        validator,
+        errors: issues.filter((i) => i.severity === "error").length,
+        warnings: issues.filter((i) => i.severity === "warning").length,
+        issues
+      };
+    } catch (error) {
+      const execError = error;
+      const output = execError.stdout || execError.stderr || execError.message;
+      const issues = this.parseValidatorOutput(validator, output);
+      return {
+        validator,
+        errors: issues.filter((i) => i.severity === "error").length || 1,
+        warnings: issues.filter((i) => i.severity === "warning").length,
+        issues: issues.length > 0 ? issues : [{ message: output, severity: "error" }]
+      };
+    }
+  }
+  oxlintBinPath = null;
+  /**
+   * Find oxlint binary path from installed package
+   */
+  async findOxlintBin() {
+    if (this.oxlintBinPath) return this.oxlintBinPath;
+    const { createRequire } = await import('module');
+    const { dirname, join: join3 } = await import('path');
+    const { access: access2 } = await import('fs/promises');
+    try {
+      const require2 = createRequire(import.meta.url);
+      const oxlintPkg = require2.resolve("oxlint/package.json");
+      const oxlintDir = dirname(oxlintPkg);
+      const pkg = require2(oxlintPkg);
+      const binPath = typeof pkg.bin === "string" ? pkg.bin : typeof pkg.bin === "object" ? pkg.bin["oxlint"] : null;
+      if (binPath) {
+        const fullPath = join3(oxlintDir, binPath);
+        await access2(fullPath);
+        this.oxlintBinPath = fullPath;
+        return fullPath;
+      }
+    } catch {
+    }
+    this.oxlintBinPath = "npx oxlint";
+    return "npx oxlint";
+  }
+  parseValidatorOutput(validator, output) {
+    try {
+      if (validator === "oxlint") {
+        const parsed = JSON.parse(output);
+        if (parsed.diagnostics) {
+          return parsed.diagnostics.map((d) => ({
+            line: d.labels?.[0]?.span?.line,
+            column: d.labels?.[0]?.span?.column,
+            message: d.message,
+            rule: d.code,
+            severity: d.severity === "error" ? "error" : "warning"
+          }));
+        }
+      } else if (validator === "pylint") {
+        const parsed = JSON.parse(output);
+        if (Array.isArray(parsed)) {
+          return parsed.flatMap(
+            (file) => (file.messages || []).map(
+              (m) => ({
+                line: m.line,
+                column: m.column,
+                message: m.message || "Unknown error",
+                rule: m.ruleId || m.symbol,
+                severity: m.severity === 2 ? "error" : "warning"
+              })
+            )
+          );
+        }
+      }
+    } catch {
+    }
+    const issues = [];
+    const lines = output.split("\n");
+    for (const line of lines) {
+      if (line.includes("error") || line.includes("Error")) {
+        issues.push({ message: line.trim(), severity: "error" });
+      } else if (line.includes("warning") || line.includes("Warning")) {
+        issues.push({ message: line.trim(), severity: "warning" });
+      }
+    }
+    return issues;
+  }
+};
+var ValidateDirectoryToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return ValidateDirectorySchema.parse(args);
+  }
+  async execute(args) {
+    const { glob } = await import('./glob-CGKPA3YD.js');
+    const directory = this.resolveProjectPath(args);
+    const extensions = args.extensions || [".ts", ".tsx", ".js", ".jsx", ".py"];
+    try {
+      const patterns = extensions.map((ext) => `**/*${ext}`);
+      let files = [];
+      for (const pattern of patterns) {
+        const found = await glob(pattern, { cwd: directory, absolute: true });
+        files.push(...found);
+      }
+      files = files.slice(0, args.maxFiles);
+      const validateHandler = new ValidateFileToolHandler(this.context);
+      const results = [];
+      if (args.parallel) {
+        const promises = files.map(async (file) => {
+          const result = await validateHandler.handle({
+            filePath: file,
+            projectPath: args.projectPath,
+            validators: args.validators,
+            fixable: args.fixable,
+            dryRun: args.dryRun
+          });
+          const text = result.content[0]?.text || "{}";
+          const parsed = JSON.parse(text);
+          return { file, ...parsed };
+        });
+        results.push(...await Promise.all(promises));
+      } else {
+        for (const file of files) {
+          const result = await validateHandler.handle({
+            filePath: file,
+            projectPath: args.projectPath,
+            validators: args.validators,
+            fixable: args.fixable,
+            dryRun: args.dryRun
+          });
+          const text = result.content[0]?.text || "{}";
+          const parsed = JSON.parse(text);
+          results.push({ file, ...parsed });
+        }
+      }
+      const totalErrors = results.reduce((sum, r) => sum + (r.totalErrors || 0), 0);
+      const totalWarnings = results.reduce((sum, r) => sum + (r.totalWarnings || 0), 0);
+      const invalidFiles = results.filter((r) => !r.isValid);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                directory,
+                filesValidated: files.length,
+                totalErrors,
+                totalWarnings,
+                invalidFilesCount: invalidFiles.length,
+                summary: {
+                  passed: files.length - invalidFiles.length,
+                  failed: invalidFiles.length
+                },
+                invalidFiles: invalidFiles.slice(0, 20).map((f) => ({
+                  file: f.file,
+                  errors: f.totalErrors,
+                  warnings: f.totalWarnings
+                }))
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    } catch (error) {
+      const err = toError(error);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: err.message }) }]
+      };
+    }
+  }
+};
+
+export { ValidateDirectoryToolHandler, ValidateFileToolHandler };
+//# sourceMappingURL=validation-tool-handlers-RREUYKIR.js.map
+//# sourceMappingURL=validation-tool-handlers-RREUYKIR.js.map