@gulu9527/code-trust 0.2.0 → 0.2.1

package/README.md

@@ -57,6 +57,15 @@ codetrust rules list
 
 # Install pre-commit hook
 codetrust hook install
+
+# Auto-fix issues (dry-run by default)
+codetrust fix src/
+
+# Apply fixes
+codetrust fix src/ --apply
+
+# Fix only a specific rule
+codetrust fix src/ --apply --rule logic/type-coercion
 ```
 
 ## Trust Score

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { Command as Command6 } from "commander";
+import { Command as Command7 } from "commander";
 
 // src/cli/commands/scan.ts
 import { Command } from "commander";
@@ -645,6 +645,24 @@ function detectImmediateReassign(context, lines, issues) {
   }
 }
 
+// src/rules/fix-utils.ts
+function lineStartOffset(content, lineNumber) {
+  let offset = 0;
+  const lines = content.split("\n");
+  for (let i = 0; i < lineNumber - 1 && i < lines.length; i++) {
+    offset += lines[i].length + 1;
+  }
+  return offset;
+}
+function lineRange(content, lineNumber) {
+  const lines = content.split("\n");
+  const lineIndex = lineNumber - 1;
+  if (lineIndex < 0 || lineIndex >= lines.length) return [0, 0];
+  const start = lineStartOffset(content, lineNumber);
+  const end = start + lines[lineIndex].length + (lineIndex < lines.length - 1 ? 1 : 0);
+  return [start, end];
+}
+
 // src/parsers/ast.ts
 import { parse, AST_NODE_TYPES } from "@typescript-eslint/typescript-estree";
 
@@ -827,6 +845,19 @@ var unusedVariablesRule = {
   severity: "low",
   title: "Unused variable detected",
   description: "AI-generated code sometimes declares variables that are never used, indicating incomplete or hallucinated logic.",
+  fixable: true,
+  fix(context, issue) {
+    const lines = context.fileContent.split("\n");
+    const lineIndex = issue.startLine - 1;
+    if (lineIndex < 0 || lineIndex >= lines.length) return null;
+    const line = lines[lineIndex].trim();
+    if (/^(const|let|var)\s+\w+\s*[=:;]/.test(line) && !line.includes(",")) {
+      const [start, end] = lineRange(context.fileContent, issue.startLine);
+      if (start === end) return null;
+      return { range: [start, end], text: "" };
+    }
+    return null;
+  },
   check(context) {
     const issues = [];
     let ast;
@@ -1550,6 +1581,23 @@ var unusedImportRule = {
   severity: "low",
   title: "Unused import",
   description: "AI-generated code often imports modules or identifiers that are never used in the file.",
+  fixable: true,
+  fix(context, issue) {
+    const lines = context.fileContent.split("\n");
+    const lineIndex = issue.startLine - 1;
+    if (lineIndex < 0 || lineIndex >= lines.length) return null;
+    const line = lines[lineIndex].trim();
+    const isSingleDefault = /^import\s+\w+\s+from\s+/.test(line);
+    const isSingleNamed = /^import\s*\{\s*\w+\s*\}\s*from\s+/.test(line);
+    const isSingleTypeNamed = /^import\s+type\s*\{\s*\w+\s*\}\s*from\s+/.test(line);
+    const isSingleTypeDefault = /^import\s+type\s+\w+\s+from\s+/.test(line);
+    if (!isSingleDefault && !isSingleNamed && !isSingleTypeNamed && !isSingleTypeDefault) {
+      return null;
+    }
+    const [start, end] = lineRange(context.fileContent, issue.startLine);
+    if (start === end) return null;
+    return { range: [start, end], text: "" };
+  },
   check(context) {
     const issues = [];
     let ast;
@@ -1787,6 +1835,33 @@ var typeCoercionRule = {
   severity: "medium",
   title: "Loose equality with type coercion",
   description: "AI-generated code often uses == instead of ===, leading to implicit type coercion bugs.",
+  fixable: true,
+  fix(context, issue) {
+    const lines = context.fileContent.split("\n");
+    const lineIndex = issue.startLine - 1;
+    if (lineIndex < 0 || lineIndex >= lines.length) return null;
+    const line = lines[lineIndex];
+    const base = lineStartOffset(context.fileContent, issue.startLine);
+    const isNotEqual = issue.message.includes("!=");
+    const searchOp = isNotEqual ? "!=" : "==";
+    const replaceOp = isNotEqual ? "!==" : "===";
+    let pos = -1;
+    for (let j = 0; j < line.length - 1; j++) {
+      if (line[j] === searchOp[0] && line[j + 1] === "=") {
+        if (line[j + 2] === "=") {
+          j += 2;
+          continue;
+        }
+        if (!isNotEqual && j > 0 && (line[j - 1] === "!" || line[j - 1] === "<" || line[j - 1] === ">")) {
+          continue;
+        }
+        pos = j;
+        break;
+      }
+    }
+    if (pos === -1) return null;
+    return { range: [base + pos, base + pos + searchOp.length], text: replaceOp };
+  },
   check(context) {
     const issues = [];
     const lines = context.fileContent.split("\n");
@@ -2041,6 +2116,12 @@ var noDebuggerRule = {
   severity: "high",
   title: "Debugger statement",
   description: "Debugger statements should never be committed to production code.",
+  fixable: true,
+  fix(context, issue) {
+    const [start, end] = lineRange(context.fileContent, issue.startLine);
+    if (start === end) return null;
+    return { range: [start, end], text: "" };
+  },
   check(context) {
     const issues = [];
     const lines = context.fileContent.split("\n");
@@ -3460,19 +3541,238 @@ function createHookCommand() {
   return cmd;
 }
 
+// src/cli/commands/fix.ts
+import { Command as Command6 } from "commander";
+
+// src/core/fix-engine.ts
+import { readFileSync as readFileSync2, writeFileSync } from "fs";
+import pc5 from "picocolors";
+var FixEngine = class {
+  ruleEngine;
+  constructor(config) {
+    this.ruleEngine = new RuleEngine(config);
+  }
+  /**
+   * Fix issues in files. Returns results per file.
+   * Uses text range replacement to preserve formatting.
+   * Applies fixes iteratively (up to maxIterations) to handle cascading issues.
+   */
+  async fix(options) {
+    const results = [];
+    const maxIter = options.maxIterations ?? 10;
+    for (const filePath of options.files) {
+      const result = this.fixFile(filePath, options.dryRun ?? true, options.ruleId, maxIter);
+      if (result.applied > 0 || result.skipped > 0) {
+        results.push(result);
+      }
+    }
+    return results;
+  }
+  fixFile(filePath, dryRun, ruleId, maxIter) {
+    const result = {
+      file: filePath,
+      applied: 0,
+      skipped: 0,
+      details: []
+    };
+    let content;
+    try {
+      content = readFileSync2(filePath, "utf-8");
+    } catch {
+      return result;
+    }
+    for (let iter = 0; iter < maxIter; iter++) {
+      const context = {
+        filePath,
+        fileContent: content,
+        addedLines: []
+      };
+      let issues = this.ruleEngine.run(context);
+      if (ruleId) {
+        issues = issues.filter((i) => i.ruleId === ruleId);
+      }
+      const fixableRules = this.ruleEngine.getRules().filter((r) => r.fixable && r.fix);
+      const fixableRuleMap = new Map(fixableRules.map((r) => [r.id, r]));
+      const fixesWithIssues = [];
+      for (const issue of issues) {
+        const rule = fixableRuleMap.get(issue.ruleId);
+        if (!rule || !rule.fix) continue;
+        const fix = rule.fix(context, issue);
+        if (fix) {
+          fixesWithIssues.push({ fix, issue });
+        }
+      }
+      if (fixesWithIssues.length === 0) break;
+      fixesWithIssues.sort((a, b) => b.fix.range[0] - a.fix.range[0]);
+      const nonConflicting = [];
+      for (const item of fixesWithIssues) {
+        const hasConflict = nonConflicting.some(
+          (existing) => item.fix.range[0] < existing.fix.range[1] && item.fix.range[1] > existing.fix.range[0]
+        );
+        if (hasConflict) {
+          result.skipped++;
+          result.details.push({
+            ruleId: item.issue.ruleId,
+            line: item.issue.startLine,
+            message: item.issue.message,
+            status: "conflict"
+          });
+        } else {
+          nonConflicting.push(item);
+        }
+      }
+      if (nonConflicting.length === 0) break;
+      let newContent = content;
+      for (const { fix, issue } of nonConflicting) {
+        const before = newContent.slice(0, fix.range[0]);
+        const after = newContent.slice(fix.range[1]);
+        newContent = before + fix.text + after;
+        result.applied++;
+        result.details.push({
+          ruleId: issue.ruleId,
+          line: issue.startLine,
+          message: issue.message,
+          status: "applied"
+        });
+      }
+      content = newContent;
+      if (nonConflicting.length === 0) break;
+    }
+    if (!dryRun && result.applied > 0) {
+      writeFileSync(filePath, content, "utf-8");
+    }
+    return result;
+  }
+  /**
+   * Format fix results for terminal output.
+   */
+  static formatResults(results, dryRun) {
+    if (results.length === 0) {
+      return pc5.green(t("No fixable issues found.", "\u672A\u53D1\u73B0\u53EF\u4FEE\u590D\u7684\u95EE\u9898\u3002"));
+    }
+    const lines = [];
+    const modeLabel = dryRun ? pc5.yellow(t("[DRY RUN]", "[\u9884\u6F14\u6A21\u5F0F]")) : pc5.green(t("[APPLIED]", "[\u5DF2\u5E94\u7528]"));
+    lines.push(`
+${modeLabel} ${t("Fix Results:", "\u4FEE\u590D\u7ED3\u679C\uFF1A")}
+`);
+    let totalApplied = 0;
+    let totalSkipped = 0;
+    for (const result of results) {
+      lines.push(pc5.bold(pc5.underline(result.file)));
+      for (const detail of result.details) {
+        const icon = detail.status === "applied" ? pc5.green("\u2713") : detail.status === "conflict" ? pc5.yellow("\u26A0") : pc5.dim("\u2013");
+        const lineRef = pc5.dim(`L${detail.line}`);
+        const ruleRef = pc5.cyan(detail.ruleId);
+        lines.push(`  ${icon} ${lineRef} ${ruleRef} ${detail.message}`);
+      }
+      totalApplied += result.applied;
+      totalSkipped += result.skipped;
+      lines.push("");
+    }
+    lines.push(
+      pc5.bold(
+        t(
+          `${totalApplied} fix(es) ${dryRun ? "would be" : ""} applied, ${totalSkipped} skipped`,
+          `${totalApplied} \u4E2A\u4FEE\u590D${dryRun ? "\u5C06\u88AB" : "\u5DF2"}\u5E94\u7528\uFF0C${totalSkipped} \u4E2A\u8DF3\u8FC7`
+        )
+      )
+    );
+    if (dryRun) {
+      lines.push(
+        pc5.dim(
+          t(
+            "Run without --dry-run to apply fixes.",
+            "\u79FB\u9664 --dry-run \u4EE5\u5E94\u7528\u4FEE\u590D\u3002"
+          )
+        )
+      );
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/cli/commands/fix.ts
+import { resolve as resolve5 } from "path";
+import { readdirSync, statSync } from "fs";
+function collectFiles(dir) {
+  const ignorePatterns = ["node_modules", "dist", ".git", "coverage", ".next", "build"];
+  const results = [];
+  function walk(d) {
+    const entries = readdirSync(d, { withFileTypes: true });
+    for (const entry of entries) {
+      if (ignorePatterns.includes(entry.name)) continue;
+      const fullPath = resolve5(d, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (/\.(ts|tsx|js|jsx)$/.test(entry.name)) {
+        results.push(fullPath);
+      }
+    }
+  }
+  walk(dir);
+  return results;
+}
+function createFixCommand() {
+  const cmd = new Command6("fix").description("Auto-fix issues in source files").argument("[files...]", "Specific files or directories to fix (default: src/)").option("--dry-run", "Preview fixes without applying them (default)", true).option("--apply", "Actually apply the fixes").option("--rule <ruleId>", "Only fix issues from a specific rule").action(async (files, opts) => {
+    try {
+      const config = await loadConfig();
+      const engine = new FixEngine(config);
+      let targetFiles;
+      if (files.length > 0) {
+        targetFiles = [];
+        for (const f of files) {
+          const resolved = resolve5(f);
+          try {
+            const stat = statSync(resolved);
+            if (stat.isDirectory()) {
+              targetFiles.push(...collectFiles(resolved));
+            } else {
+              targetFiles.push(resolved);
+            }
+          } catch {
+            console.error(`File not found: ${f}`);
+          }
+        }
+      } else {
+        targetFiles = collectFiles(resolve5("src"));
+      }
+      if (targetFiles.length === 0) {
+        console.log("No files to fix.");
+        return;
+      }
+      const dryRun = !opts.apply;
+      const results = await engine.fix({
+        files: targetFiles,
+        dryRun,
+        ruleId: opts.rule
+      });
+      console.log(FixEngine.formatResults(results, dryRun));
+    } catch (err) {
+      if (err instanceof Error) {
+        console.error(`Error: ${err.message}`);
+      } else {
+        console.error("An unexpected error occurred");
+      }
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
 // src/cli/index.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname4, resolve as resolve5 } from "path";
+import { dirname as dirname4, resolve as resolve6 } from "path";
 var __filename2 = fileURLToPath2(import.meta.url);
 var __dirname2 = dirname4(__filename2);
-var pkg = JSON.parse(readFileSync2(resolve5(__dirname2, "../../package.json"), "utf-8"));
-var program = new Command6();
+var pkg = JSON.parse(readFileSync3(resolve6(__dirname2, "../../package.json"), "utf-8"));
+var program = new Command7();
 program.name("codetrust").description("AI code trust verification tool \u2014 verify AI-generated code with deterministic algorithms").version(pkg.version);
 program.addCommand(createScanCommand());
 program.addCommand(createReportCommand());
 program.addCommand(createInitCommand());
 program.addCommand(createRulesCommand());
 program.addCommand(createHookCommand());
+program.addCommand(createFixCommand());
 program.parse();
 //# sourceMappingURL=index.js.map