ai-code-reviewer-plus 0.1.0

package/dist/index.js

@@ -0,0 +1,713 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ConfigError: () => ConfigError,
+  GitCommandError: () => GitCommandError,
+  ParseError: () => ParseError,
+  VERSION: () => VERSION,
+  analyzeCode: () => analyzeCode,
+  analyzeDiffs: () => analyzeDiffs,
+  collectCommitDiff: () => collectCommitDiff,
+  collectDiff: () => collectDiff,
+  detectProject: () => detectProject,
+  formatDiffSummary: () => formatDiffSummary,
+  formatDuration: () => formatDuration,
+  formatFinding: () => formatFinding,
+  formatReviewReport: () => formatReviewReport,
+  formatSummary: () => formatSummary,
+  getAvailableRules: () => getAvailableRules,
+  getDefaultConfig: () => getDefaultConfig,
+  loadConfigFile: () => loadConfigFile,
+  mergeConfig: () => mergeConfig
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/analyzers/index.ts
+var RULES = [
+  // Security rules
+  {
+    id: "SEC-001",
+    dimension: "security",
+    severity: "BLOCKER",
+    pattern: /\.innerHTML\s*=\s*/,
+    title: "XSS: Direct innerHTML assignment",
+    description: "Assigning to innerHTML with unsanitized input creates an XSS vulnerability.",
+    suggestion: "Use textContent or sanitize input before rendering.",
+    fixExample: "element.textContent = sanitize(userInput)"
+  },
+  {
+    id: "SEC-002",
+    dimension: "security",
+    severity: "BLOCKER",
+    pattern: /eval\s*\(/,
+    title: "XSS: Use of eval()",
+    description: "eval() executes arbitrary code, creating a severe security risk.",
+    suggestion: "Avoid eval(). Use JSON.parse() for data or Function constructor for controlled logic.",
+    fixExample: "const data = JSON.parse(jsonString)"
+  },
+  {
+    id: "SEC-003",
+    dimension: "security",
+    severity: "HIGH",
+    pattern: /document\.write\s*\(/,
+    title: "XSS: Use of document.write()",
+    description: "document.write() can inject arbitrary HTML, enabling XSS attacks.",
+    suggestion: "Use DOM manipulation methods like createElement and appendChild."
+  },
+  // Correctness rules
+  {
+    id: "COR-001",
+    dimension: "correctness",
+    severity: "HIGH",
+    pattern: /\.\w+\s*\(\s*\)\s*\.\s*\w+\s*\(\s*\)\s*\.\s*\w+\s*\(\s*\)/,
+    title: "Potential null reference: Long method chain",
+    description: "Chained method calls without null checks can throw TypeError at runtime.",
+    suggestion: "Add null checks or use optional chaining (?.).",
+    fixExample: "obj?.method1()?.method2()?.method3()"
+  },
+  {
+    id: "COR-002",
+    dimension: "correctness",
+    severity: "MEDIUM",
+    pattern: /==(?!=)/,
+    title: "Loose equality comparison",
+    description: "Using == instead of === can produce unexpected type coercion results.",
+    suggestion: "Use === for strict equality comparison.",
+    fixExample: "value === expected"
+  },
+  // Performance rules
+  {
+    id: "PER-001",
+    dimension: "performance",
+    severity: "HIGH",
+    pattern: /for\s*\(.*await/,
+    title: "Sequential async in loop",
+    description: "Using await inside a for loop processes operations sequentially, often causing N+1 latency.",
+    suggestion: "Use Promise.all() for parallel execution, or process in batches.",
+    fixExample: "await Promise.all(items.map(i => fetch(i)))"
+  },
+  {
+    id: "PER-002",
+    dimension: "performance",
+    severity: "MEDIUM",
+    pattern: /console\.log\s*\(/,
+    title: "Console.log in production code",
+    description: "Leftover console.log calls add overhead and may leak sensitive data.",
+    suggestion: "Remove console.log or use a proper logging library."
+  },
+  // Maintainability rules
+  {
+    id: "MAIN-001",
+    dimension: "maintainability",
+    severity: "LOW",
+    pattern: /\/\/\s*TODO|\/\/\s*FIXME|\/\/\s*HACK/i,
+    title: "Unresolved TODO/FIXME comment",
+    description: "TODO/FIXME/HACK comments indicate unfinished or problematic code.",
+    suggestion: "Resolve the comment or create a tracked issue."
+  },
+  {
+    id: "MAIN-002",
+    dimension: "maintainability",
+    severity: "LOW",
+    pattern: /:\s*any\b/,
+    title: "Use of `any` type",
+    description: "Using any bypasses TypeScript type checking, reducing type safety.",
+    suggestion: "Replace any with a specific type or unknown.",
+    fixExample: "const data: unknown = value"
+  },
+  // Best practices rules
+  {
+    id: "BP-001",
+    dimension: "best-practices",
+    severity: "MEDIUM",
+    pattern: /var\s+\w/,
+    title: "Use of var instead of let/const",
+    description: "var has function scope and hoisting, which can cause subtle bugs.",
+    suggestion: "Use const for values that don't change, let for those that do.",
+    fixExample: "const value = 42"
+  }
+];
+function analyzeDiffs(diffs, enabledRules, disabledRules, severityOverrides) {
+  const findings = [];
+  const activeRules = filterRules(RULES, enabledRules, disabledRules);
+  for (const diff of diffs) {
+    for (const hunk of diff.hunks) {
+      for (const rule of activeRules) {
+        for (const line of hunk.lines) {
+          if (!line.startsWith("+")) continue;
+          const content = line.slice(1);
+          if (!rule.pattern.test(content)) continue;
+          const severity = severityOverrides?.[rule.id] ?? rule.severity;
+          findings.push({
+            id: rule.id,
+            dimension: rule.dimension,
+            severity,
+            title: rule.title,
+            description: rule.description,
+            file: diff.file,
+            line: hunk.newStart + countAddedLinesBefore(hunk, line),
+            codeSnippet: content.trim(),
+            suggestion: rule.suggestion,
+            fixExample: rule.fixExample,
+            confidence: "high"
+          });
+        }
+      }
+    }
+  }
+  return findings;
+}
+function analyzeCode(code, file, enabledRules, disabledRules, severityOverrides) {
+  const findings = [];
+  const activeRules = filterRules(RULES, enabledRules, disabledRules);
+  const lines = code.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    for (const rule of activeRules) {
+      if (!rule.pattern.test(lines[i])) continue;
+      const severity = severityOverrides?.[rule.id] ?? rule.severity;
+      findings.push({
+        id: rule.id,
+        dimension: rule.dimension,
+        severity,
+        title: rule.title,
+        description: rule.description,
+        file,
+        line: i + 1,
+        codeSnippet: lines[i].trim(),
+        suggestion: rule.suggestion,
+        fixExample: rule.fixExample,
+        confidence: "high"
+      });
+    }
+  }
+  return findings;
+}
+function getAvailableRules() {
+  const grouped = {};
+  for (const rule of RULES) {
+    ;
+    (grouped[rule.dimension] ??= []).push(rule);
+  }
+  return grouped;
+}
+function filterRules(allRules, enabled, disabled) {
+  if (enabled && enabled.length > 0) {
+    const set = new Set(enabled);
+    return allRules.filter((r) => set.has(r.id));
+  }
+  if (disabled && disabled.length > 0) {
+    const set = new Set(disabled);
+    return allRules.filter((r) => !set.has(r.id));
+  }
+  return allRules;
+}
+function countAddedLinesBefore(hunk, targetLine) {
+  let count = 0;
+  for (const line of hunk.lines) {
+    if (line === targetLine) return count;
+    if (line.startsWith("+")) count++;
+  }
+  return count;
+}
+
+// src/collectors/diff-collector.ts
+var import_node_child_process = require("child_process");
+var import_node_util = require("util");
+
+// src/errors.ts
+var GitCommandError = class _GitCommandError extends Error {
+  constructor(options) {
+    const msg = options.message ?? `git ${[options.command, ...options.args ?? []].join(" ")} failed${options.exitCode != null ? ` (exit ${options.exitCode})` : ""}`;
+    super(msg);
+    this.name = "GitCommandError";
+    this.command = options.command ?? "git";
+    this.args = options.args ?? [];
+    this.exitCode = options.exitCode;
+    this.cwd = options.cwd;
+    if (options.cause && Error.captureStackTrace) {
+      Error.captureStackTrace(this, _GitCommandError);
+    }
+  }
+};
+var ParseError = class extends Error {
+  constructor(options) {
+    const msg = options.message ?? `Failed to parse ${options.parser} output`;
+    super(msg);
+    this.name = "ParseError";
+    this.parser = options.parser;
+    this.rawInput = options.rawInput;
+  }
+};
+var ConfigError = class extends Error {
+  constructor(options) {
+    const msg = options.message ?? `Invalid configuration${options.field ? ` in field '${options.field}'` : ""}`;
+    super(msg);
+    this.name = "ConfigError";
+    this.filePath = options.filePath;
+    this.field = options.field;
+  }
+};
+
+// src/collectors/diff-collector.ts
+var exec = (0, import_node_util.promisify)(import_node_child_process.execFile);
+async function collectDiff(options) {
+  const { root, targetBranch = "main", commitHash } = options;
+  const args = ["diff", "--no-color"];
+  if (commitHash) {
+    args.push(commitHash);
+  } else {
+    args.push(targetBranch, "HEAD");
+  }
+  try {
+    const { stdout } = await exec("git", args, { cwd: root, maxBuffer: 50 * 1024 * 1024 });
+    return parseDiffOutput(stdout);
+  } catch (err) {
+    throw new GitCommandError({
+      command: "diff",
+      args,
+      cwd: root,
+      message: "Failed to collect git diff",
+      cause: err instanceof Error ? err : void 0
+    });
+  }
+}
+async function collectCommitDiff(options) {
+  const { root, hash } = options;
+  const args = ["diff", "--no-color", hash];
+  try {
+    const { stdout } = await exec("git", args, { cwd: root });
+    return parseDiffOutput(stdout);
+  } catch (err) {
+    throw new GitCommandError({
+      command: "diff",
+      args,
+      cwd: root,
+      message: `Failed to collect diff for commit ${hash}`,
+      cause: err instanceof Error ? err : void 0
+    });
+  }
+}
+function parseDiffOutput(stdout) {
+  if (!stdout.trim()) return [];
+  const diffs = [];
+  const fileSections = stdout.split(/^diff --git /m).filter((s) => s.trim());
+  for (const section of fileSections) {
+    const diff = parseFileSection(section);
+    if (diff) diffs.push(diff);
+  }
+  return diffs;
+}
+function parseFileSection(section) {
+  const lines = section.split("\n");
+  const headerLine = lines[0];
+  const pathMatch = headerLine?.match(/^a\/(.+) b\/(.+)/);
+  if (!pathMatch) return null;
+  const file = pathMatch[2];
+  const from = pathMatch[1];
+  let status = "modified", currentHunk = null, additions = 0, deletions = 0;
+  if (lines.some((l) => l.startsWith("new file mode"))) {
+    status = "added";
+  } else if (lines.some((l) => l.startsWith("deleted file mode"))) {
+    status = "deleted";
+  } else if (lines.some((l) => l.startsWith("rename from "))) {
+    status = "renamed";
+  }
+  const hunks = [];
+  for (const line of lines) {
+    const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+    if (hunkMatch) {
+      if (currentHunk) hunks.push(currentHunk);
+      currentHunk = {
+        header: line,
+        oldStart: Number(hunkMatch[1]),
+        oldCount: Number(hunkMatch[2] ?? 1),
+        newStart: Number(hunkMatch[3]),
+        newCount: Number(hunkMatch[4] ?? 1),
+        lines: []
+      };
+      continue;
+    }
+    if (line.startsWith("+") && currentHunk) {
+      additions++;
+      currentHunk.lines.push(line);
+    } else if (line.startsWith("-") && currentHunk && !line.startsWith("---")) {
+      deletions++;
+      currentHunk.lines.push(line);
+    } else if (line.startsWith(" ") && currentHunk) {
+      currentHunk.lines.push(line);
+    }
+  }
+  if (currentHunk) hunks.push(currentHunk);
+  return {
+    file,
+    from: status === "renamed" || status === "deleted" ? from : void 0,
+    status,
+    additions,
+    deletions,
+    hunks
+  };
+}
+
+// src/collectors/project-detector.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+async function detectProject(root) {
+  const markers = [
+    { type: "node", file: "package.json" },
+    { type: "go", file: "go.mod" },
+    { type: "python", file: "requirements.txt" },
+    { type: "rust", file: "Cargo.toml" }
+  ];
+  for (const marker of markers) {
+    const filePath = (0, import_node_path.join)(root, marker.file);
+    if ((0, import_node_fs.existsSync)(filePath)) {
+      if (marker.type === "node") {
+        return detectNodeProject(root, filePath);
+      }
+      if (marker.type === "go") {
+        return {
+          type: "go",
+          language: "go",
+          packageManager: "go mod",
+          root
+        };
+      }
+      if (marker.type === "python") {
+        return {
+          type: "python",
+          language: "python",
+          packageManager: "pip",
+          root
+        };
+      }
+    }
+  }
+  return {
+    type: "unknown",
+    language: "unknown",
+    root
+  };
+}
+function detectNodeProject(root, packageJsonPath) {
+  try {
+    const content = (0, import_node_fs.readFileSync)(packageJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (deps.vue || deps.Vue) {
+      const version = deps.vue || deps.Vue || "";
+      const isVue3 = version.startsWith("^3") || version.startsWith("3");
+      return {
+        type: "vue",
+        framework: isVue3 ? "vue3" : "vue2",
+        language: "typescript",
+        packageManager: detectPackageManager(root),
+        root
+      };
+    }
+    if (deps.react || deps.React) {
+      const version = deps.react || deps.React || "";
+      const isReact18 = version.startsWith("^18") || version.startsWith("18");
+      return {
+        type: "react",
+        framework: isReact18 ? "react18" : "react",
+        language: "typescript",
+        packageManager: detectPackageManager(root),
+        root
+      };
+    }
+    return {
+      type: "node",
+      language: "javascript",
+      packageManager: detectPackageManager(root),
+      root
+    };
+  } catch {
+    return {
+      type: "node",
+      language: "javascript",
+      packageManager: "npm",
+      root
+    };
+  }
+}
+function detectPackageManager(root) {
+  if ((0, import_node_fs.existsSync)((0, import_node_path.join)(root, "pnpm-lock.yaml"))) return "pnpm";
+  if ((0, import_node_fs.existsSync)((0, import_node_path.join)(root, "yarn.lock"))) return "yarn";
+  if ((0, import_node_fs.existsSync)((0, import_node_path.join)(root, "package-lock.json"))) return "npm";
+  return "npm";
+}
+
+// src/types.ts
+var VERSION = "0.1.0";
+
+// src/utils/config.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var DEFAULT_CONFIG = {
+  rules: {
+    enabled: ["COR-001", "SEC-001", "SEC-002", "PER-001", "MAIN-001"],
+    disabled: [],
+    severityOverrides: {}
+  },
+  excludePaths: ["node_modules/", "dist/", "coverage/", "vendor/", ".git/"],
+  maxFindingsPerFile: 20,
+  outputFormat: "markdown",
+  targetBranch: "main"
+};
+function mergeConfig(user) {
+  return {
+    ...DEFAULT_CONFIG,
+    ...user,
+    rules: {
+      ...DEFAULT_CONFIG.rules,
+      ...user.rules,
+      enabled: user.rules?.enabled ?? DEFAULT_CONFIG.rules.enabled,
+      disabled: user.rules?.disabled ?? DEFAULT_CONFIG.rules.disabled,
+      severityOverrides: user.rules?.severityOverrides ?? DEFAULT_CONFIG.rules.severityOverrides
+    },
+    excludePaths: user.excludePaths ?? DEFAULT_CONFIG.excludePaths,
+    maxFindingsPerFile: user.maxFindingsPerFile ?? DEFAULT_CONFIG.maxFindingsPerFile,
+    outputFormat: user.outputFormat ?? DEFAULT_CONFIG.outputFormat
+  };
+}
+function getDefaultConfig() {
+  return structuredClone(DEFAULT_CONFIG);
+}
+function loadConfigFile(root, fileName = ".ai-code-reviewer-plus.yml") {
+  const filePath = (0, import_node_path2.join)(root, fileName);
+  if (!(0, import_node_fs2.existsSync)(filePath)) {
+    return {};
+  }
+  try {
+    const content = (0, import_node_fs2.readFileSync)(filePath, "utf-8");
+    return parseSimpleYAML(content);
+  } catch (err) {
+    throw new ConfigError({
+      filePath,
+      message: `Failed to load config file: ${err instanceof Error ? err.message : "Unknown error"}`
+    });
+  }
+}
+function parseSimpleYAML(content) {
+  const config = {
+    rules: {
+      enabled: [],
+      disabled: [],
+      severityOverrides: {}
+    },
+    excludePaths: []
+  };
+  const lines = content.split("\n");
+  let currentSection = "";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#") || !trimmed) continue;
+    if (trimmed.startsWith("rules:")) {
+      currentSection = "rules";
+    } else if (trimmed.startsWith("excludePaths:")) {
+      currentSection = "excludePaths";
+    } else if (trimmed.startsWith("maxFindingsPerFile:")) {
+      const value = trimmed.split(":")[1]?.trim();
+      if (value) config.maxFindingsPerFile = Number(value);
+    } else if (trimmed.startsWith("outputFormat:")) {
+      const value = trimmed.split(":")[1]?.trim();
+      if (value && (value === "markdown" || value === "json")) {
+        config.outputFormat = value;
+      }
+    } else if (trimmed.startsWith("- ") && currentSection) {
+      const value = trimmed.slice(2);
+      if (currentSection === "rules") {
+        const ruleId = value.split(" ")[0];
+        if (ruleId) {
+          config.rules.enabled.push(ruleId);
+        }
+      } else if (currentSection === "excludePaths") {
+        config.excludePaths.push(value);
+      }
+    }
+  }
+  return config;
+}
+
+// src/utils/format.ts
+function formatFinding(finding) {
+  const severityEmoji = {
+    BLOCKER: "\u{1F6AB}",
+    HIGH: "\u{1F534}",
+    MEDIUM: "\u{1F7E1}",
+    LOW: "\u{1F7E2}",
+    SUGGESTION: "\u{1F4A1}"
+  };
+  const emoji = severityEmoji[finding.severity];
+  const location = finding.line ? `:${finding.line}` : "";
+  let output = `- ${emoji} **${finding.id}** [${finding.severity}] \`${finding.file}${location}\`
+`;
+  output += `  **${finding.title}**
+`;
+  output += `  ${finding.description}
+`;
+  if (finding.codeSnippet) {
+    output += `  \`\`\`
+  ${finding.codeSnippet}
+  \`\`\`
+`;
+  }
+  if (finding.suggestion) {
+    output += `  \u{1F4A1} ${finding.suggestion}
+`;
+  }
+  if (finding.fixExample) {
+    output += `  **Fix:**
+  \`\`\`
+  ${finding.fixExample}
+  \`\`\`
+`;
+  }
+  const confidenceEmoji = { high: "\u{1F7E2}", medium: "\u{1F7E1}", low: "\u{1F534}" };
+  output += `  Confidence: ${confidenceEmoji[finding.confidence]}
+`;
+  return output;
+}
+function formatSummary(result) {
+  const { summary, duration } = result;
+  let output = `## \u{1F4CA} Review Summary
+
+`;
+  output += `- **Total findings**: ${summary.total}
+`;
+  output += `- **\u{1F6AB} Blockers**: ${summary.blockers}
+`;
+  output += `- **\u{1F534} High**: ${summary.high}
+`;
+  output += `- **\u{1F7E1} Medium**: ${summary.medium}
+`;
+  output += `- **\u{1F7E2} Low**: ${summary.low}
+`;
+  output += `- **\u{1F4A1} Suggestions**: ${summary.suggestions}
+`;
+  output += `- **Files reviewed**: ${result.filesReviewed.length}
+`;
+  output += `- **Duration**: ${formatDuration(duration)}
+`;
+  return output;
+}
+function formatReviewReport(result) {
+  let output = `# \u{1F50D} Code Review Report
+
+`;
+  output += formatSummary(result);
+  output += `
+---
+
+`;
+  const blockers = result.findings.filter((f) => f.severity === "BLOCKER");
+  const high = result.findings.filter((f) => f.severity === "HIGH");
+  const medium = result.findings.filter((f) => f.severity === "MEDIUM");
+  const low = result.findings.filter((f) => f.severity === "LOW");
+  const suggestions = result.findings.filter((f) => f.severity === "SUGGESTION");
+  if (blockers.length > 0) {
+    output += `## \u{1F6AB} Blockers (Must Fix)
+
+`;
+    for (const f of blockers) {
+      output += `${formatFinding(f)}
+`;
+    }
+  }
+  if (high.length > 0) {
+    output += `## \u{1F534} High Priority
+
+`;
+    for (const f of high) {
+      output += `${formatFinding(f)}
+`;
+    }
+  }
+  if (medium.length > 0) {
+    output += `## \u{1F7E1} Medium Priority
+
+`;
+    for (const f of medium) {
+      output += `${formatFinding(f)}
+`;
+    }
+  }
+  if (low.length > 0) {
+    output += `## \u{1F7E2} Low Priority
+
+`;
+    for (const f of low) {
+      output += `${formatFinding(f)}
+`;
+    }
+  }
+  if (suggestions.length > 0) {
+    output += `## \u{1F4A1} Suggestions
+
+`;
+    for (const f of suggestions) {
+      output += `${formatFinding(f)}
+`;
+    }
+  }
+  return output;
+}
+function formatDiffSummary(diff) {
+  const statusEmoji = {
+    added: "\u2795",
+    deleted: "\u274C",
+    modified: "\u{1F4DD}",
+    renamed: "\u{1F4E6}"
+  };
+  const emoji = statusEmoji[diff.status];
+  const renameInfo = diff.status === "renamed" && diff.from ? ` (${diff.from} \u2192 ${diff.file})` : "";
+  return `- ${emoji} \`${diff.file}\` +${diff.additions}/-${diff.deletions}${renameInfo}`;
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  const seconds = Math.round(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const secs = seconds % 60;
+  return secs > 0 ? `${minutes}m ${secs}s` : `${minutes}m`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigError,
+  GitCommandError,
+  ParseError,
+  VERSION,
+  analyzeCode,
+  analyzeDiffs,
+  collectCommitDiff,
+  collectDiff,
+  detectProject,
+  formatDiffSummary,
+  formatDuration,
+  formatFinding,
+  formatReviewReport,
+  formatSummary,
+  getAvailableRules,
+  getDefaultConfig,
+  loadConfigFile,
+  mergeConfig
+});