@gulu9527/code-trust 0.2.1 → 0.3.1

package/dist/index.js

@@ -1,38 +1,70 @@
 // src/core/engine.ts
+import { createHash } from "crypto";
 import { readFile } from "fs/promises";
-import { readFileSync, existsSync as existsSync3 } from "fs";
-import { resolve as resolve2, dirname as dirname3 } from "path";
+import { readFileSync } from "fs";
+import { resolve as resolve2, dirname as dirname3, relative, sep } from "path";
 import { fileURLToPath } from "url";
 
 // src/parsers/diff.ts
 import simpleGit from "simple-git";
+var GIT_DIFF_UNIFIED = "--unified=3";
+var SHORT_HASH_LENGTH = 7;
 var DiffParser = class {
   git;
   constructor(workDir) {
     this.git = simpleGit(workDir);
   }
   async getStagedFiles() {
-    const diffDetail = await this.git.diff(["--cached", "--unified=3"]);
+    const diffDetail = await this.git.diff(["--cached", GIT_DIFF_UNIFIED]);
     return this.parseDiffOutput(diffDetail);
   }
   async getDiffFromRef(ref) {
-    const diffDetail = await this.git.diff([ref, "--unified=3"]);
+    const diffDetail = await this.git.diff([ref, GIT_DIFF_UNIFIED]);
     return this.parseDiffOutput(diffDetail);
   }
   async getChangedFiles() {
-    const diffDetail = await this.git.diff(["--unified=3"]);
-    const stagedDetail = await this.git.diff(["--cached", "--unified=3"]);
-    const allDiff = diffDetail + "\n" + stagedDetail;
-    return this.parseDiffOutput(allDiff);
+    const diffDetail = await this.git.diff([GIT_DIFF_UNIFIED]);
+    const stagedDetail = await this.git.diff(["--cached", GIT_DIFF_UNIFIED]);
+    const unstagedFiles = this.parseDiffOutput(diffDetail);
+    const stagedFiles = this.parseDiffOutput(stagedDetail);
+    return this.mergeDiffFiles(unstagedFiles, stagedFiles);
+  }
+  /**
+   * Merge two sets of diff files, deduplicating by file path.
+   * When a file appears in both, merge their hunks and combine stats.
+   */
+  mergeDiffFiles(unstaged, staged) {
+    const fileMap = /* @__PURE__ */ new Map();
+    for (const file of unstaged) {
+      fileMap.set(file.filePath, file);
+    }
+    for (const file of staged) {
+      const existing = fileMap.get(file.filePath);
+      if (existing) {
+        fileMap.set(file.filePath, {
+          ...existing,
+          // Combine additions/deletions
+          additions: existing.additions + file.additions,
+          deletions: existing.deletions + file.deletions,
+          // Merge hunks (preserve order: staged first, then unstaged)
+          hunks: [...file.hunks, ...existing.hunks],
+          // Status: if either is 'added', treat as added; otherwise keep modified
+          status: existing.status === "added" || file.status === "added" ? "added" : "modified"
+        });
+      } else {
+        fileMap.set(file.filePath, file);
+      }
+    }
+    return Array.from(fileMap.values());
   }
   async getLastCommitDiff() {
-    const diffDetail = await this.git.diff(["HEAD~1", "HEAD", "--unified=3"]);
+    const diffDetail = await this.git.diff(["HEAD~1", "HEAD", GIT_DIFF_UNIFIED]);
     return this.parseDiffOutput(diffDetail);
   }
   async getCurrentCommitHash() {
     try {
       const hash = await this.git.revparse(["HEAD"]);
-      return hash.trim().slice(0, 7);
+      return hash.trim().slice(0, SHORT_HASH_LENGTH);
     } catch {
       return void 0;
     }
@@ -468,7 +500,7 @@ function detectCodeAfterReturn(context, lines, issues) {
       }
     }
     if (/^(return|throw)\b/.test(trimmed) && !trimmed.includes("=>")) {
-      const endsOpen = /[{(\[,]$/.test(trimmed) || /^(return|throw)\s*$/.test(trimmed);
+      const endsOpen = /[[{(,]$/.test(trimmed) || /^(return|throw)\s*$/.test(trimmed);
       if (endsOpen) continue;
       lastReturnDepth = braceDepth;
       lastReturnLine = i;
@@ -659,6 +691,9 @@ function analyzeFunctionNode(node) {
 function calculateCyclomaticComplexity(root) {
   let complexity = 1;
   walkAST(root, (n) => {
+    if (n.type === AST_NODE_TYPES.FunctionDeclaration || n.type === AST_NODE_TYPES.FunctionExpression || n.type === AST_NODE_TYPES.ArrowFunctionExpression || n.type === AST_NODE_TYPES.MethodDefinition) {
+      return false;
+    }
     switch (n.type) {
       case AST_NODE_TYPES.IfStatement:
       case AST_NODE_TYPES.ConditionalExpression:
@@ -687,6 +722,9 @@ function calculateCognitiveComplexity(root) {
   const depthMap = /* @__PURE__ */ new WeakMap();
   depthMap.set(root, 0);
   walkAST(root, (n, parent) => {
+    if (n.type === AST_NODE_TYPES.FunctionDeclaration || n.type === AST_NODE_TYPES.FunctionExpression || n.type === AST_NODE_TYPES.ArrowFunctionExpression || n.type === AST_NODE_TYPES.MethodDefinition) {
+      return false;
+    }
     const parentDepth = parent ? depthMap.get(parent) ?? 0 : 0;
     const isNesting = isNestingNode(n);
     const depth = isNesting ? parentDepth + 1 : parentDepth;
@@ -705,6 +743,9 @@ function calculateMaxNestingDepth(root) {
   const depthMap = /* @__PURE__ */ new WeakMap();
   depthMap.set(root, 0);
   walkAST(root, (n, parent) => {
+    if (n.type === AST_NODE_TYPES.FunctionDeclaration || n.type === AST_NODE_TYPES.FunctionExpression || n.type === AST_NODE_TYPES.ArrowFunctionExpression || n.type === AST_NODE_TYPES.MethodDefinition) {
+      return false;
+    }
     const parentDepth = parent ? depthMap.get(parent) ?? 0 : 0;
     const isNesting = n.type === AST_NODE_TYPES.IfStatement || n.type === AST_NODE_TYPES.ForStatement || n.type === AST_NODE_TYPES.ForInStatement || n.type === AST_NODE_TYPES.ForOfStatement || n.type === AST_NODE_TYPES.WhileStatement || n.type === AST_NODE_TYPES.DoWhileStatement || n.type === AST_NODE_TYPES.SwitchStatement || n.type === AST_NODE_TYPES.TryStatement;
     const currentDepth = isNesting ? parentDepth + 1 : parentDepth;
@@ -886,14 +927,19 @@ function stringifyCondition(node) {
     case AST_NODE_TYPES.Literal:
       return String(node.value);
     case AST_NODE_TYPES.BinaryExpression:
+      return `${stringifyCondition(node.left)} ${node.operator} ${stringifyCondition(node.right)}`;
     case AST_NODE_TYPES.LogicalExpression:
       return `${stringifyCondition(node.left)} ${node.operator} ${stringifyCondition(node.right)}`;
     case AST_NODE_TYPES.UnaryExpression:
       return `${node.operator}${stringifyCondition(node.argument)}`;
     case AST_NODE_TYPES.MemberExpression:
       return `${stringifyCondition(node.object)}.${stringifyCondition(node.property)}`;
-    case AST_NODE_TYPES.CallExpression:
-      return `${stringifyCondition(node.callee)}(...)`;
+    case AST_NODE_TYPES.CallExpression: {
+      const args = node.arguments.map((arg) => stringifyCondition(arg)).join(", ");
+      return `${stringifyCondition(node.callee)}(${args})`;
+    }
+    case AST_NODE_TYPES.ConditionalExpression:
+      return `${stringifyCondition(node.test)} ? ${stringifyCondition(node.consequent)} : ${stringifyCondition(node.alternate)}`;
     default:
       return `[${node.type}]`;
   }
@@ -903,6 +949,10 @@ function truncate(s, maxLen) {
 }
 
 // src/rules/builtin/security.ts
+var isCommentLine = (trimmed) => trimmed.startsWith("//") || trimmed.startsWith("*");
+var stripQuotedStrings = (line) => line.replace(/'[^'\\]*(?:\\.[^'\\]*)*'/g, "''").replace(/"[^"\\]*(?:\\.[^"\\]*)*"/g, '""').replace(/`[^`\\]*(?:\\.[^`\\]*)*`/g, "``");
+var isPatternDefinitionLine = (line) => /\bpattern\s*:\s*\/.*\/[dgimsuvy]*/.test(line);
+var hasQueryContext = (line) => /\b(query|sql|statement|stmt)\b/i.test(line) || /\.(query|execute|run|prepare)\s*\(/i.test(line);
 var securityRules = [
   {
     id: "security/hardcoded-secret",
@@ -915,7 +965,7 @@ var securityRules = [
       const lines = context.fileContent.split("\n");
       const secretPatterns = [
         // API keys / tokens
-        { pattern: /(?:api[_-]?key|apikey)\s*[:=]\s*['"`][A-Za-z0-9_\-]{16,}['"`]/i, label: "API key" },
+        { pattern: /(?:api[_-]?key|apikey)\s*[:=]\s*['"`][A-Za-z0-9_-]{16,}['"`]/i, label: "API key" },
         { pattern: /(?:secret|token|password|passwd|pwd)\s*[:=]\s*['"`][^'"`]{8,}['"`]/i, label: "secret/password" },
         // AWS
         { pattern: /AKIA[0-9A-Z]{16}/, label: "AWS Access Key" },
@@ -968,15 +1018,17 @@ var securityRules = [
       const issues = [];
       const lines = context.fileContent.split("\n");
       for (let i = 0; i < lines.length; i++) {
-        const trimmed = lines[i].trim();
-        if (trimmed.startsWith("//") || trimmed.startsWith("*")) continue;
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (isCommentLine(trimmed) || isPatternDefinitionLine(line)) continue;
+        const sanitizedLine = stripQuotedStrings(line);
         const evalPatterns = [
-          { pattern: /\beval\s*\(/, label: "eval()" },
-          { pattern: /new\s+Function\s*\(/, label: "new Function()" },
-          { pattern: /\b(setTimeout|setInterval)\s*\(\s*['"`]/, label: "setTimeout/setInterval with string" }
+          { pattern: /\beval\s*\(/, label: "eval()", source: sanitizedLine },
+          { pattern: /new\s+Function\s*\(/, label: "new Function()", source: sanitizedLine },
+          { pattern: /\b(setTimeout|setInterval)\s*\(\s*['"`]/, label: "setTimeout/setInterval with string", source: line }
         ];
-        for (const { pattern, label } of evalPatterns) {
-          if (pattern.test(lines[i])) {
+        for (const { pattern, label, source } of evalPatterns) {
+          if (pattern.test(source)) {
             issues.push({
               ruleId: "security/eval-usage",
               severity: "high",
@@ -1009,29 +1061,30 @@ var securityRules = [
     check(context) {
       const issues = [];
       const lines = context.fileContent.split("\n");
+      const sqlKeywords = /\b(SELECT|INSERT|UPDATE|DELETE|DROP|CREATE|ALTER)\b/i;
       for (let i = 0; i < lines.length; i++) {
-        const trimmed = lines[i].trim();
-        if (trimmed.startsWith("//") || trimmed.startsWith("*")) continue;
-        const sqlKeywords = /\b(SELECT|INSERT|UPDATE|DELETE|DROP|CREATE|ALTER)\b/i;
-        if (sqlKeywords.test(lines[i])) {
-          if (/\$\{[^}]+\}/.test(lines[i]) || /['"]\s*\+\s*\w+/.test(lines[i])) {
-            issues.push({
-              ruleId: "security/sql-injection",
-              severity: "high",
-              category: "security",
-              file: context.filePath,
-              startLine: i + 1,
-              endLine: i + 1,
-              message: t(
-                "Potential SQL injection \u2014 string interpolation in SQL query.",
-                "\u6F5C\u5728\u7684 SQL \u6CE8\u5165 \u2014 SQL \u67E5\u8BE2\u4E2D\u4F7F\u7528\u4E86\u5B57\u7B26\u4E32\u63D2\u503C\u3002"
-              ),
-              suggestion: t(
-                "Use parameterized queries or prepared statements instead.",
-                "\u8BF7\u6539\u7528\u53C2\u6570\u5316\u67E5\u8BE2\u6216\u9884\u7F16\u8BD1\u8BED\u53E5\u3002"
-              )
-            });
-          }
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (isCommentLine(trimmed)) continue;
+        const hasSqlKeyword = sqlKeywords.test(line);
+        const hasInterpolation = /\$\{[^}]+\}/.test(line) || /['"]\s*\+\s*\w+/.test(line);
+        if (hasSqlKeyword && hasInterpolation && hasQueryContext(line)) {
+          issues.push({
+            ruleId: "security/sql-injection",
+            severity: "high",
+            category: "security",
+            file: context.filePath,
+            startLine: i + 1,
+            endLine: i + 1,
+            message: t(
+              "Potential SQL injection \u2014 string interpolation in SQL query.",
+              "\u6F5C\u5728\u7684 SQL \u6CE8\u5165 \u2014 SQL \u67E5\u8BE2\u4E2D\u4F7F\u7528\u4E86\u5B57\u7B26\u4E32\u63D2\u503C\u3002"
+            ),
+            suggestion: t(
+              "Use parameterized queries or prepared statements instead.",
+              "\u8BF7\u6539\u7528\u53C2\u6570\u5316\u67E5\u8BE2\u6216\u9884\u7F16\u8BD1\u8BED\u53E5\u3002"
+            )
+          });
         }
       }
       return issues;
@@ -1047,9 +1100,11 @@ var securityRules = [
       const issues = [];
       const lines = context.fileContent.split("\n");
       for (let i = 0; i < lines.length; i++) {
-        const trimmed = lines[i].trim();
+        const line = lines[i];
+        const trimmed = line.trim();
         if (trimmed.startsWith("//") || trimmed.startsWith("*")) continue;
-        if (/\.(innerHTML|outerHTML)\s*=/.test(lines[i]) || /dangerouslySetInnerHTML/.test(lines[i])) {
+        const cleaned = line.replace(/(['"`])(?:(?!\1|\\).|\\.)*\1/g, '""').replace(/\/\/.*$/, "").replace(/\/[^/]+\/[dgimsuvy]*/g, '""');
+        if (/\.(innerHTML|outerHTML)\s*=/.test(cleaned) || /dangerouslySetInnerHTML/.test(cleaned)) {
           issues.push({
             ruleId: "security/dangerous-html",
             severity: "medium",
@@ -1577,6 +1632,9 @@ var missingAwaitRule = {
       const body = getFunctionBody(node);
       if (!body) return;
       walkAST(body, (inner, parent) => {
+        if (inner.type === AST_NODE_TYPES.ArrowFunctionExpression) {
+          return;
+        }
         if (inner !== body && isAsyncFunction(inner)) return false;
         if (inner.type !== AST_NODE_TYPES.CallExpression) return;
         if (parent?.type === AST_NODE_TYPES.AwaitExpression) return;
@@ -1586,6 +1644,9 @@ var missingAwaitRule = {
         if (parent?.type === AST_NODE_TYPES.AssignmentExpression) return;
         if (parent?.type === AST_NODE_TYPES.ArrayExpression) return;
         if (parent?.type === AST_NODE_TYPES.CallExpression && parent !== inner) return;
+        if (parent?.type === AST_NODE_TYPES.ArrowFunctionExpression) {
+          return;
+        }
         const callName = getCallName(inner);
         if (!callName) return;
         if (!asyncFuncNames.has(callName)) return;
@@ -1797,9 +1858,28 @@ var typeCoercionRule = {
 var ALLOWED_NUMBERS = /* @__PURE__ */ new Set([
   -1,
   0,
+  0.1,
+  0.1,
+  0.15,
+  0.2,
+  0.2,
+  0.25,
+  0.3,
+  0.3,
+  0.5,
   1,
   2,
+  3,
+  4,
+  5,
   10,
+  15,
+  20,
+  30,
+  40,
+  50,
+  70,
+  90,
   100
 ]);
 var magicNumberRule = {
@@ -1828,6 +1908,7 @@ var magicNumberRule = {
       if (/^\s*(export\s+)?enum\s/.test(line)) continue;
       if (trimmed.startsWith("import ")) continue;
       if (/^\s*return\s+[0-9]+\s*;?\s*$/.test(line)) continue;
+      if (/^\s*['"]?[-\w]+['"]?\s*:\s*-?\d+\.?\d*(?:e[+-]?\d+)?\s*,?\s*$/.test(trimmed)) continue;
       const cleaned = line.replace(/(['"`])(?:(?!\1|\\).|\\.)*\1/g, '""').replace(/\/\/.*$/, "");
       const numRegex = /(?<![.\w])(-?\d+\.?\d*(?:e[+-]?\d+)?)\b/gi;
       let match;
@@ -1924,6 +2005,17 @@ var nestedTernaryRule = {
 // src/rules/builtin/duplicate-string.ts
 var MIN_STRING_LENGTH = 6;
 var MIN_OCCURRENCES = 3;
+var IGNORED_LITERALS = /* @__PURE__ */ new Set([
+  "high",
+  "medium",
+  "low",
+  "info",
+  "logic",
+  "security",
+  "structure",
+  "style",
+  "coverage"
+]);
 var duplicateStringRule = {
   id: "logic/duplicate-string",
   category: "logic",
@@ -1954,6 +2046,7 @@ var duplicateStringRule = {
       while ((match = stringRegex.exec(cleaned)) !== null) {
         const value = match[2];
         if (value.length < MIN_STRING_LENGTH) continue;
+        if (IGNORED_LITERALS.has(value)) continue;
         if (value.includes("${")) continue;
         if (value.startsWith("http") || value.startsWith("/")) continue;
         if (value.startsWith("test") || value.startsWith("mock")) continue;
@@ -2223,13 +2316,28 @@ var promiseVoidRule = {
       /^save/,
       /^load/,
       /^send/,
-      /^delete/,
       /^update/,
       /^create/,
       /^connect/,
       /^disconnect/,
       /^init/
     ];
+    const syncMethods = [
+      "delete",
+      // Map.delete(), Set.delete(), Object.delete() are synchronous
+      "has",
+      // Map.has(), Set.has() are synchronous
+      "get",
+      // Map.get() is synchronous
+      "set",
+      // Map.set() is synchronous (though some consider it potentially async)
+      "keys",
+      // Object.keys() is synchronous
+      "values",
+      // Object.values() is synchronous
+      "entries"
+      // Object.entries() is synchronous
+    ];
     walkAST(ast, (node) => {
       if (node.type !== AST_NODE_TYPES.ExpressionStatement) return;
       const expr = node.expression;
@@ -2240,6 +2348,7 @@ var promiseVoidRule = {
       const isKnownAsync = asyncFnNames.has(fnName);
       const matchesPattern = commonAsyncPatterns.some((p) => p.test(fnName));
       const endsWithAsync = fnName.endsWith("Async") || fnName.endsWith("async");
+      if (syncMethods.includes(fnName)) return;
       if (!isKnownAsync && !matchesPattern && !endsWithAsync) return;
       const line = node.loc?.start.line ?? 0;
       if (line === 0) return;
@@ -2315,12 +2424,7 @@ var noReassignParamRule = {
         }
       }
       if (paramNames.size === 0) return;
-      let body = null;
-      if (node.type === AST_NODE_TYPES.MethodDefinition) {
-        body = node.value;
-      } else {
-        body = node;
-      }
+      const body = node.type === AST_NODE_TYPES.MethodDefinition ? node.value : node;
       if (!body || !("body" in body)) return;
       const fnBody = body.body;
       if (!fnBody) return;
@@ -2557,15 +2661,33 @@ var RuleEngine = class {
     );
   }
   run(context) {
+    return this.runWithDiagnostics(context).issues;
+  }
+  runWithDiagnostics(context) {
     const allIssues = [];
+    const ruleFailures = [];
+    let rulesExecuted = 0;
+    let rulesFailed = 0;
     for (const rule of this.rules) {
+      rulesExecuted++;
       try {
         const issues = rule.check(context);
         allIssues.push(...issues);
-      } catch (_err) {
+      } catch (err) {
+        rulesFailed++;
+        ruleFailures.push({
+          ruleId: rule.id,
+          file: context.filePath,
+          message: err instanceof Error ? err.message : "Unknown rule execution failure"
+        });
       }
     }
-    return allIssues;
+    return {
+      issues: allIssues,
+      rulesExecuted,
+      rulesFailed,
+      ruleFailures
+    };
   }
   getRules() {
     return [...this.rules];
@@ -2945,6 +3067,8 @@ var PKG_VERSION = (() => {
     return "0.1.0";
   }
 })();
+var REPORT_SCHEMA_VERSION = "1.0.0";
+var FINGERPRINT_VERSION = "1";
 var ScanEngine = class {
   config;
   diffParser;
@@ -2955,81 +3079,191 @@ var ScanEngine = class {
     this.ruleEngine = new RuleEngine(config);
   }
   async scan(options) {
-    const diffFiles = await this.getDiffFiles(options);
+    const selection = await this.getScanCandidates(options);
     const allIssues = [];
-    for (const diffFile of diffFiles) {
-      if (diffFile.status === "deleted") continue;
-      const filePath = resolve2(diffFile.filePath);
-      let fileContent;
-      try {
-        if (existsSync3(filePath)) {
-          fileContent = await readFile(filePath, "utf-8");
-        } else {
-          const content = await this.diffParser.getFileContent(diffFile.filePath);
-          if (!content) continue;
-          fileContent = content;
-        }
-      } catch {
-        continue;
-      }
-      const addedLines = diffFile.hunks.flatMap((hunk) => {
-        const lines = hunk.content.split("\n");
-        const result = [];
-        let currentLine = hunk.newStart;
-        for (const line of lines) {
-          if (line.startsWith("+")) {
-            result.push({ lineNumber: currentLine, content: line.slice(1) });
-            currentLine++;
-          } else if (line.startsWith("-")) {
-          } else {
-            currentLine++;
-          }
-        }
-        return result;
-      });
-      const issues = this.ruleEngine.run({
-        filePath: diffFile.filePath,
-        fileContent,
-        addedLines
-      });
-      allIssues.push(...issues);
-      if (this.isTsJsFile(diffFile.filePath)) {
-        const structureResult = analyzeStructure(fileContent, diffFile.filePath, {
-          maxCyclomaticComplexity: this.config.thresholds["max-cyclomatic-complexity"],
-          maxCognitiveComplexity: this.config.thresholds["max-cognitive-complexity"],
-          maxFunctionLength: this.config.thresholds["max-function-length"],
-          maxNestingDepth: this.config.thresholds["max-nesting-depth"],
-          maxParamCount: this.config.thresholds["max-params"]
-        });
-        allIssues.push(...structureResult.issues);
-        const styleResult = analyzeStyle(fileContent, diffFile.filePath);
-        allIssues.push(...styleResult.issues);
-        const coverageResult = analyzeCoverage(fileContent, diffFile.filePath);
-        allIssues.push(...coverageResult.issues);
-      }
-    }
-    const dimensions = this.groupByDimension(allIssues);
+    const scanErrors = [];
+    const ruleFailures = [];
+    let rulesExecuted = 0;
+    let rulesFailed = 0;
+    let filesScanned = 0;
+    const results = await Promise.all(
+      selection.candidates.map((diffFile) => this.scanFile(diffFile))
+    );
+    for (const result of results) {
+      allIssues.push(...result.issues);
+      ruleFailures.push(...result.ruleFailures);
+      scanErrors.push(...result.scanErrors);
+      rulesExecuted += result.rulesExecuted;
+      rulesFailed += result.rulesFailed;
+      if (result.scanned) {
+        filesScanned++;
+      }
+    }
+    const issuesWithFingerprints = this.attachFingerprints(allIssues);
+    const baseline = await this.loadBaseline(options.baseline);
+    const issuesWithLifecycle = this.attachLifecycle(issuesWithFingerprints, baseline);
+    const fixedIssues = this.getFixedIssues(issuesWithLifecycle, baseline);
+    const lifecycle = this.buildLifecycleSummary(issuesWithLifecycle, fixedIssues, baseline);
+    const dimensions = this.groupByDimension(issuesWithLifecycle);
     const overallScore = calculateOverallScore(dimensions, this.config.weights);
     const grade = getGrade(overallScore);
     const commitHash = await this.diffParser.getCurrentCommitHash();
     return {
+      schemaVersion: REPORT_SCHEMA_VERSION,
       version: PKG_VERSION,
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       commit: commitHash,
+      scanMode: selection.scanMode,
       overall: {
         score: overallScore,
         grade,
-        filesScanned: diffFiles.filter((f) => f.status !== "deleted").length,
-        issuesFound: allIssues.length
+        filesScanned,
+        issuesFound: issuesWithLifecycle.length
+      },
+      toolHealth: {
+        rulesExecuted,
+        rulesFailed,
+        filesConsidered: selection.filesConsidered,
+        filesScanned,
+        filesExcluded: selection.filesExcluded,
+        filesSkipped: scanErrors.length,
+        scanErrors,
+        ruleFailures
       },
       dimensions,
-      issues: allIssues.sort((a, b) => {
+      issues: issuesWithLifecycle.sort((a, b) => {
         const severityOrder = { high: 0, medium: 1, low: 2, info: 3 };
         return severityOrder[a.severity] - severityOrder[b.severity];
-      })
+      }),
+      lifecycle,
+      fixedIssues
     };
   }
-  async getDiffFiles(options) {
+  async scanFile(diffFile) {
+    if (diffFile.status === "deleted") {
+      return this.createSkippedResult(diffFile, "deleted-file", `Skipped deleted file: ${diffFile.filePath}`);
+    }
+    if (!this.isTsJsFile(diffFile.filePath)) {
+      return this.createSkippedResult(diffFile, "unsupported-file-type", `Skipped unsupported file type: ${diffFile.filePath}`);
+    }
+    const fileContent = await this.readFileContent(diffFile);
+    if (!fileContent) {
+      return this.createErrorResult(diffFile, "missing-file-content", `Unable to read file content for ${diffFile.filePath}`);
+    }
+    const addedLines = this.extractAddedLines(diffFile);
+    const ruleResult = this.ruleEngine.runWithDiagnostics({
+      filePath: diffFile.filePath,
+      fileContent,
+      addedLines
+    });
+    const issues = [...ruleResult.issues];
+    issues.push(...this.runStructureAnalysis(fileContent, diffFile.filePath));
+    issues.push(...analyzeStyle(fileContent, diffFile.filePath).issues);
+    issues.push(...analyzeCoverage(fileContent, diffFile.filePath).issues);
+    return {
+      issues,
+      ruleFailures: ruleResult.ruleFailures,
+      rulesExecuted: ruleResult.rulesExecuted,
+      rulesFailed: ruleResult.rulesFailed,
+      scanErrors: [],
+      scanned: true
+    };
+  }
+  createSkippedResult(diffFile, type, message) {
+    return {
+      issues: [],
+      ruleFailures: [],
+      rulesExecuted: 0,
+      rulesFailed: 0,
+      scanErrors: [{ type, file: diffFile.filePath, message }],
+      scanned: false
+    };
+  }
+  createErrorResult(diffFile, type, message) {
+    return {
+      issues: [],
+      ruleFailures: [],
+      rulesExecuted: 0,
+      rulesFailed: 0,
+      scanErrors: [{ type, file: diffFile.filePath, message }],
+      scanned: false
+    };
+  }
+  async readFileContent(diffFile) {
+    const filePath = resolve2(diffFile.filePath);
+    try {
+      return await readFile(filePath, "utf-8");
+    } catch {
+      const content = await this.diffParser.getFileContent(diffFile.filePath);
+      return content ?? null;
+    }
+  }
+  extractAddedLines(diffFile) {
+    return diffFile.hunks.flatMap((hunk) => {
+      const lines = hunk.content.split("\n");
+      const result = [];
+      let currentLine = hunk.newStart;
+      for (const line of lines) {
+        if (line.startsWith("+")) {
+          result.push({ lineNumber: currentLine, content: line.slice(1) });
+          currentLine++;
+        } else if (line.startsWith("-")) {
+        } else {
+          currentLine++;
+        }
+      }
+      return result;
+    });
+  }
+  runStructureAnalysis(fileContent, filePath) {
+    return analyzeStructure(fileContent, filePath, {
+      maxCyclomaticComplexity: this.config.thresholds["max-cyclomatic-complexity"],
+      maxCognitiveComplexity: this.config.thresholds["max-cognitive-complexity"],
+      maxFunctionLength: this.config.thresholds["max-function-length"],
+      maxNestingDepth: this.config.thresholds["max-nesting-depth"],
+      maxParamCount: this.config.thresholds["max-params"]
+    }).issues;
+  }
+  async getScanCandidates(options) {
+    const scanMode = this.getScanMode(options);
+    const candidates = await this.getDiffFiles(options);
+    if (scanMode === "files") {
+      return {
+        scanMode,
+        candidates,
+        filesConsidered: options.files?.length ?? candidates.length,
+        filesExcluded: (options.files?.length ?? candidates.length) - candidates.length
+      };
+    }
+    const filteredCandidates = [];
+    let filesExcluded = 0;
+    for (const candidate of candidates) {
+      if (this.shouldIncludeFile(candidate.filePath)) {
+        filteredCandidates.push(candidate);
+      } else {
+        filesExcluded++;
+      }
+    }
+    return {
+      scanMode,
+      candidates: filteredCandidates,
+      filesConsidered: candidates.length,
+      filesExcluded
+    };
+  }
+  getScanMode(options) {
+    if (options.staged) {
+      return "staged";
+    }
+    if (options.diff) {
+      return "diff";
+    }
+    if (options.files && options.files.length > 0) {
+      return "files";
+    }
+    return "changed";
+  }
+  getDiffFiles(options) {
     if (options.staged) {
       return this.diffParser.getStagedFiles();
     }
@@ -3037,14 +3271,10 @@ var ScanEngine = class {
       return this.diffParser.getDiffFromRef(options.diff);
     }
     if (options.files && options.files.length > 0) {
+      const includedFiles = options.files.filter((filePath) => this.shouldIncludeFile(filePath));
       return Promise.all(
-        options.files.map(async (filePath) => {
-          let content = "";
-          try {
-            content = await readFile(resolve2(filePath), "utf-8");
-          } catch {
-          }
-          return {
+        includedFiles.map(
+          (filePath) => readFile(resolve2(filePath), "utf-8").catch(() => "").then((content) => ({
             filePath,
             status: "modified",
             additions: content.split("\n").length,
@@ -3056,18 +3286,154 @@ var ScanEngine = class {
                 oldLines: 0,
                 newStart: 1,
                 newLines: content.split("\n").length,
-                content: content.split("\n").map((l) => "+" + l).join("\n")
+                content: content.split("\n").map((line) => "+" + line).join("\n")
               }
             ]
-          };
-        })
+          }))
+        )
       );
     }
     return this.diffParser.getChangedFiles();
   }
+  shouldIncludeFile(filePath) {
+    const normalizedPath = filePath.split(sep).join("/");
+    const includePatterns = this.config.include.length > 0 ? this.config.include : ["**/*"];
+    const included = includePatterns.some((pattern) => this.matchesPattern(normalizedPath, pattern));
+    if (!included) {
+      return false;
+    }
+    return !this.config.exclude.some((pattern) => this.matchesPattern(normalizedPath, pattern));
+  }
+  matchesPattern(filePath, pattern) {
+    let regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    regexPattern = regexPattern.replace(/\*\*\//g, "::DOUBLE_DIR::");
+    regexPattern = regexPattern.replace(/\*\*/g, "::DOUBLE_STAR::");
+    regexPattern = regexPattern.replace(/\*/g, "[^/]*");
+    regexPattern = regexPattern.replace(/::DOUBLE_DIR::/g, "(?:.*/)?");
+    regexPattern = regexPattern.replace(/::DOUBLE_STAR::/g, ".*");
+    return new RegExp(`^${regexPattern}$`).test(filePath);
+  }
   isTsJsFile(filePath) {
     return /\.(ts|tsx|js|jsx|mts|mjs|cts|cjs)$/.test(filePath);
   }
+  attachFingerprints(issues) {
+    const occurrenceCounts = /* @__PURE__ */ new Map();
+    return issues.map((issue) => {
+      const normalizedFile = this.normalizeRelativePath(issue.file);
+      const locationComponent = `${issue.startLine}:${issue.endLine}`;
+      const baseKey = [
+        issue.ruleId,
+        normalizedFile,
+        issue.category,
+        issue.severity,
+        locationComponent
+      ].join("|");
+      const occurrenceIndex = occurrenceCounts.get(baseKey) ?? 0;
+      occurrenceCounts.set(baseKey, occurrenceIndex + 1);
+      const fingerprint = createHash("sha256").update(`${FINGERPRINT_VERSION}|${baseKey}|${occurrenceIndex}`).digest("hex");
+      return {
+        ...issue,
+        file: normalizedFile,
+        fingerprint,
+        fingerprintVersion: FINGERPRINT_VERSION
+      };
+    });
+  }
+  normalizeRelativePath(filePath) {
+    const absolutePath = resolve2(filePath);
+    const relativePath = relative(process.cwd(), absolutePath) || filePath;
+    return relativePath.split(sep).join("/");
+  }
+  async loadBaseline(baselinePath) {
+    if (!baselinePath) {
+      return void 0;
+    }
+    const baselineContent = await readFile(resolve2(baselinePath), "utf-8");
+    const parsed = JSON.parse(baselineContent);
+    const issues = this.parseBaselineIssues(parsed.issues);
+    return {
+      issues,
+      fingerprintSet: new Set(issues.map((issue) => issue.fingerprint)),
+      commit: typeof parsed.commit === "string" ? parsed.commit : void 0,
+      timestamp: typeof parsed.timestamp === "string" ? parsed.timestamp : void 0
+    };
+  }
+  parseBaselineIssues(input) {
+    if (!Array.isArray(input)) {
+      return [];
+    }
+    return input.flatMap((item) => {
+      const issue = this.parseBaselineIssue(item);
+      return issue ? [issue] : [];
+    });
+  }
+  parseBaselineIssue(input) {
+    if (!input || typeof input !== "object") {
+      return void 0;
+    }
+    const issue = input;
+    if (!this.isValidBaselineIssue(issue)) {
+      return void 0;
+    }
+    return {
+      ruleId: issue.ruleId,
+      severity: issue.severity,
+      category: issue.category,
+      file: issue.file,
+      startLine: issue.startLine,
+      endLine: issue.endLine,
+      message: issue.message,
+      fingerprint: issue.fingerprint,
+      fingerprintVersion: typeof issue.fingerprintVersion === "string" ? issue.fingerprintVersion : void 0
+    };
+  }
+  isValidBaselineIssue(issue) {
+    return typeof issue.ruleId === "string" && this.isSeverity(issue.severity) && this.isRuleCategory(issue.category) && typeof issue.file === "string" && typeof issue.startLine === "number" && typeof issue.endLine === "number" && typeof issue.message === "string" && typeof issue.fingerprint === "string";
+  }
+  attachLifecycle(issues, baseline) {
+    if (!baseline) {
+      return issues;
+    }
+    return issues.map((issue) => ({
+      ...issue,
+      lifecycle: baseline.fingerprintSet.has(issue.fingerprint) ? "existing" : "new"
+    }));
+  }
+  getFixedIssues(issues, baseline) {
+    if (!baseline) {
+      return [];
+    }
+    const currentFingerprints = new Set(issues.map((issue) => issue.fingerprint));
+    return baseline.issues.filter((issue) => !currentFingerprints.has(issue.fingerprint));
+  }
+  buildLifecycleSummary(issues, fixedIssues, baseline) {
+    if (!baseline) {
+      return void 0;
+    }
+    let newIssues = 0;
+    let existingIssues = 0;
+    for (const issue of issues) {
+      if (issue.lifecycle === "existing") {
+        existingIssues++;
+      } else {
+        newIssues++;
+      }
+    }
+    return {
+      newIssues,
+      existingIssues,
+      fixedIssues: fixedIssues.length,
+      baselineUsed: true,
+      baselineCommit: baseline.commit,
+      baselineTimestamp: baseline.timestamp
+    };
+  }
+  isSeverity(value) {
+    return value === "high" || value === "medium" || value === "low" || value === "info";
+  }
+  isRuleCategory(value) {
+    return ["security", "logic", "structure", "style", "coverage"].includes(value);
+  }
   groupByDimension(issues) {
     const categories = [
       "security",
@@ -3078,7 +3444,7 @@ var ScanEngine = class {
     ];
     const grouped = {};
     for (const cat of categories) {
-      const catIssues = issues.filter((i) => i.category === cat);
+      const catIssues = issues.filter((issue) => issue.category === cat);
       grouped[cat] = calculateDimensionScore(catIssues);
     }
     return grouped;