diffprism 0.34.1 → 0.36.0

package/dist/chunk-DHCVZGHE.js

@@ -0,0 +1,501 @@
+// packages/analysis/src/deterministic.ts
+var MECHANICAL_CONFIG_PATTERNS = [
+  /\.config\./,
+  /\.eslintrc/,
+  /\.prettierrc/,
+  /tsconfig.*\.json$/,
+  /\.gitignore$/,
+  /\.lock$/
+];
+var API_SURFACE_PATTERNS = [
+  /\/api\//,
+  /\/routes\//
+];
+function isFormattingOnly(file) {
+  if (file.hunks.length === 0) return false;
+  for (const hunk of file.hunks) {
+    const adds = hunk.changes.filter((c) => c.type === "add").map((c) => c.content.replace(/\s/g, ""));
+    const deletes = hunk.changes.filter((c) => c.type === "delete").map((c) => c.content.replace(/\s/g, ""));
+    if (adds.length === 0 || deletes.length === 0) return false;
+    const deleteBag = [...deletes];
+    for (const add of adds) {
+      const idx = deleteBag.indexOf(add);
+      if (idx === -1) return false;
+      deleteBag.splice(idx, 1);
+    }
+    if (deleteBag.length > 0) return false;
+  }
+  return true;
+}
+function isImportOnly(file) {
+  if (file.hunks.length === 0) return false;
+  const importPattern = /^\s*(import\s|export\s.*from\s|const\s+\w+\s*=\s*require\(|require\()/;
+  for (const hunk of file.hunks) {
+    for (const change of hunk.changes) {
+      if (change.type === "context") continue;
+      const trimmed = change.content.trim();
+      if (trimmed === "") continue;
+      if (!importPattern.test(trimmed)) return false;
+    }
+  }
+  return true;
+}
+function isMechanicalConfigFile(path) {
+  return MECHANICAL_CONFIG_PATTERNS.some((re) => re.test(path));
+}
+function isApiSurface(file) {
+  if (API_SURFACE_PATTERNS.some((re) => re.test(file.path))) return true;
+  const basename = file.path.slice(file.path.lastIndexOf("/") + 1);
+  if ((basename === "index.ts" || basename === "index.js") && file.additions >= 10) {
+    return true;
+  }
+  return false;
+}
+function categorizeFiles(files) {
+  const critical = [];
+  const notable = [];
+  const mechanical = [];
+  const securityFlags = detectSecurityPatterns(files);
+  const complexityScores = computeComplexityScores(files);
+  const securityByFile = /* @__PURE__ */ new Map();
+  for (const flag of securityFlags) {
+    const existing = securityByFile.get(flag.file) || [];
+    existing.push(flag);
+    securityByFile.set(flag.file, existing);
+  }
+  const complexityByFile = /* @__PURE__ */ new Map();
+  for (const score of complexityScores) {
+    complexityByFile.set(score.path, score);
+  }
+  for (const file of files) {
+    const description = `${file.status} (${file.language || "unknown"}) +${file.additions} -${file.deletions}`;
+    const fileSecurityFlags = securityByFile.get(file.path);
+    const fileComplexity = complexityByFile.get(file.path);
+    const criticalReasons = [];
+    if (fileSecurityFlags && fileSecurityFlags.length > 0) {
+      const patterns = fileSecurityFlags.map((f) => f.pattern);
+      const unique = [...new Set(patterns)];
+      criticalReasons.push(`security patterns detected: ${unique.join(", ")}`);
+    }
+    if (fileComplexity && fileComplexity.score >= 8) {
+      criticalReasons.push(`high complexity score (${fileComplexity.score}/10)`);
+    }
+    if (isApiSurface(file)) {
+      criticalReasons.push("modifies public API surface");
+    }
+    if (criticalReasons.length > 0) {
+      critical.push({
+        file: file.path,
+        description,
+        reason: `Critical: ${criticalReasons.join("; ")}`
+      });
+      continue;
+    }
+    const isPureRename = file.status === "renamed" && file.additions === 0 && file.deletions === 0;
+    if (isPureRename) {
+      mechanical.push({
+        file: file.path,
+        description,
+        reason: "Mechanical: pure rename with no content changes"
+      });
+      continue;
+    }
+    if (isFormattingOnly(file)) {
+      mechanical.push({
+        file: file.path,
+        description,
+        reason: "Mechanical: formatting/whitespace-only changes"
+      });
+      continue;
+    }
+    if (isMechanicalConfigFile(file.path)) {
+      mechanical.push({
+        file: file.path,
+        description,
+        reason: "Mechanical: config file change"
+      });
+      continue;
+    }
+    if (file.hunks.length > 0 && isImportOnly(file)) {
+      mechanical.push({
+        file: file.path,
+        description,
+        reason: "Mechanical: import/require-only changes"
+      });
+      continue;
+    }
+    notable.push({
+      file: file.path,
+      description,
+      reason: "Notable: requires review"
+    });
+  }
+  return { critical, notable, mechanical };
+}
+function computeFileStats(files) {
+  return files.map((f) => ({
+    path: f.path,
+    language: f.language,
+    status: f.status,
+    additions: f.additions,
+    deletions: f.deletions
+  }));
+}
+function detectAffectedModules(files) {
+  const dirs = /* @__PURE__ */ new Set();
+  for (const f of files) {
+    const lastSlash = f.path.lastIndexOf("/");
+    if (lastSlash > 0) {
+      dirs.add(f.path.slice(0, lastSlash));
+    }
+  }
+  return [...dirs].sort();
+}
+var TEST_PATTERNS = [
+  /\.test\./,
+  /\.spec\./,
+  /\/__tests__\//,
+  /\/test\//
+];
+function detectAffectedTests(files) {
+  return files.filter((f) => TEST_PATTERNS.some((re) => re.test(f.path))).map((f) => f.path);
+}
+var DEPENDENCY_FIELDS = [
+  '"dependencies"',
+  '"devDependencies"',
+  '"peerDependencies"',
+  '"optionalDependencies"'
+];
+function detectNewDependencies(files) {
+  const deps = /* @__PURE__ */ new Set();
+  const packageFiles = files.filter(
+    (f) => f.path.endsWith("package.json") && f.hunks.length > 0
+  );
+  for (const file of packageFiles) {
+    for (const hunk of file.hunks) {
+      let inDependencyBlock = false;
+      for (const change of hunk.changes) {
+        const line = change.content;
+        if (DEPENDENCY_FIELDS.some((field) => line.includes(field))) {
+          inDependencyBlock = true;
+          continue;
+        }
+        if (inDependencyBlock && line.trim().startsWith("}")) {
+          inDependencyBlock = false;
+          continue;
+        }
+        if (change.type === "add" && inDependencyBlock) {
+          const match = line.match(/"([^"]+)"\s*:/);
+          if (match) {
+            deps.add(match[1]);
+          }
+        }
+      }
+    }
+  }
+  return [...deps].sort();
+}
+function generateSummary(files) {
+  const totalFiles = files.length;
+  const counts = {
+    added: 0,
+    modified: 0,
+    deleted: 0,
+    renamed: 0
+  };
+  let totalAdditions = 0;
+  let totalDeletions = 0;
+  for (const f of files) {
+    counts[f.status]++;
+    totalAdditions += f.additions;
+    totalDeletions += f.deletions;
+  }
+  const parts = [];
+  if (counts.modified > 0) parts.push(`${counts.modified} modified`);
+  if (counts.added > 0) parts.push(`${counts.added} added`);
+  if (counts.deleted > 0) parts.push(`${counts.deleted} deleted`);
+  if (counts.renamed > 0) parts.push(`${counts.renamed} renamed`);
+  const breakdown = parts.length > 0 ? `: ${parts.join(", ")}` : "";
+  return `${totalFiles} files changed${breakdown} (+${totalAdditions} -${totalDeletions})`;
+}
+var BRANCH_PATTERN = /\b(if|else|switch|case|catch)\b|\?\s|&&|\|\|/;
+function computeComplexityScores(files) {
+  const results = [];
+  for (const file of files) {
+    let score = 0;
+    const factors = [];
+    const totalChanges = file.additions + file.deletions;
+    if (totalChanges > 100) {
+      score += 3;
+      factors.push(`large diff (+${file.additions} -${file.deletions})`);
+    } else if (totalChanges > 50) {
+      score += 2;
+      factors.push(`medium diff (+${file.additions} -${file.deletions})`);
+    } else if (totalChanges > 20) {
+      score += 1;
+      factors.push(`moderate diff (+${file.additions} -${file.deletions})`);
+    }
+    const hunkCount = file.hunks.length;
+    if (hunkCount > 4) {
+      score += 2;
+      factors.push(`many hunks (${hunkCount})`);
+    } else if (hunkCount > 2) {
+      score += 1;
+      factors.push(`multiple hunks (${hunkCount})`);
+    }
+    let branchCount = 0;
+    let deepNestCount = 0;
+    for (const hunk of file.hunks) {
+      for (const change of hunk.changes) {
+        if (change.type !== "add") continue;
+        const line = change.content;
+        if (BRANCH_PATTERN.test(line)) {
+          branchCount++;
+        }
+        const leadingSpaces = line.match(/^(\s*)/);
+        if (leadingSpaces) {
+          const ws = leadingSpaces[1];
+          const tabCount = (ws.match(/\t/g) || []).length;
+          const spaceCount = ws.replace(/\t/g, "").length;
+          if (tabCount >= 4 || spaceCount >= 16) {
+            deepNestCount++;
+          }
+        }
+      }
+    }
+    const branchScore = Math.floor(branchCount / 5);
+    if (branchScore > 0) {
+      score += branchScore;
+      factors.push(`${branchCount} logic branches`);
+    }
+    const nestScore = Math.floor(deepNestCount / 5);
+    if (nestScore > 0) {
+      score += nestScore;
+      factors.push(`${deepNestCount} deeply nested lines`);
+    }
+    score = Math.max(1, Math.min(10, score));
+    results.push({ path: file.path, score, factors });
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results;
+}
+var NON_CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".json",
+  ".md",
+  ".css",
+  ".scss",
+  ".less",
+  ".svg",
+  ".png",
+  ".jpg",
+  ".gif",
+  ".ico",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".lock",
+  ".html"
+]);
+var CONFIG_PATTERNS = [
+  /\.config\./,
+  /\.rc\./,
+  /eslint/,
+  /prettier/,
+  /tsconfig/,
+  /tailwind/,
+  /vite\.config/,
+  /vitest\.config/
+];
+function isTestFile(path) {
+  return TEST_PATTERNS.some((re) => re.test(path));
+}
+function isNonCodeFile(path) {
+  const ext = path.slice(path.lastIndexOf("."));
+  return NON_CODE_EXTENSIONS.has(ext);
+}
+function isConfigFile(path) {
+  return CONFIG_PATTERNS.some((re) => re.test(path));
+}
+function detectTestCoverageGaps(files) {
+  const filePaths = new Set(files.map((f) => f.path));
+  const results = [];
+  for (const file of files) {
+    if (file.status !== "added" && file.status !== "modified") continue;
+    if (isTestFile(file.path)) continue;
+    if (isNonCodeFile(file.path)) continue;
+    if (isConfigFile(file.path)) continue;
+    const dir = file.path.slice(0, file.path.lastIndexOf("/") + 1);
+    const basename = file.path.slice(file.path.lastIndexOf("/") + 1);
+    const extDot = basename.lastIndexOf(".");
+    const name = extDot > 0 ? basename.slice(0, extDot) : basename;
+    const ext = extDot > 0 ? basename.slice(extDot) : "";
+    const candidates = [
+      `${dir}${name}.test${ext}`,
+      `${dir}${name}.spec${ext}`,
+      `${dir}__tests__/${name}${ext}`,
+      `${dir}__tests__/${name}.test${ext}`,
+      `${dir}__tests__/${name}.spec${ext}`
+    ];
+    const matchedTest = candidates.find((c) => filePaths.has(c));
+    results.push({
+      sourceFile: file.path,
+      testFile: matchedTest ?? null
+    });
+  }
+  return results;
+}
+var PATTERN_MATCHERS = [
+  { pattern: "todo", test: (l) => /\btodo\b/i.test(l) },
+  { pattern: "fixme", test: (l) => /\bfixme\b/i.test(l) },
+  { pattern: "hack", test: (l) => /\bhack\b/i.test(l) },
+  {
+    pattern: "console",
+    test: (l) => /\bconsole\.(log|debug|warn|error)\b/.test(l)
+  },
+  { pattern: "debug", test: (l) => /\bdebugger\b/.test(l) },
+  {
+    pattern: "disabled_test",
+    test: (l) => /\.(skip)\(|(\bxit|xdescribe|xtest)\(/.test(l)
+  }
+];
+function detectPatterns(files) {
+  const results = [];
+  for (const file of files) {
+    if (file.status === "added" && file.additions > 500) {
+      results.push({
+        file: file.path,
+        line: 0,
+        pattern: "large_file",
+        content: `Large added file: ${file.additions} lines`
+      });
+    }
+    for (const hunk of file.hunks) {
+      for (const change of hunk.changes) {
+        if (change.type !== "add") continue;
+        for (const matcher of PATTERN_MATCHERS) {
+          if (matcher.test(change.content)) {
+            results.push({
+              file: file.path,
+              line: change.lineNumber,
+              pattern: matcher.pattern,
+              content: change.content.trim()
+            });
+          }
+        }
+      }
+    }
+  }
+  results.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+  return results;
+}
+var SECURITY_MATCHERS = [
+  {
+    pattern: "eval",
+    severity: "critical",
+    test: (l) => /\beval\s*\(/.test(l)
+  },
+  {
+    pattern: "inner_html",
+    severity: "warning",
+    test: (l) => /\.innerHTML\b|dangerouslySetInnerHTML/.test(l)
+  },
+  {
+    pattern: "sql_injection",
+    severity: "critical",
+    test: (l) => /`[^`]*\b(SELECT|INSERT|UPDATE|DELETE)\b/i.test(l) || /\b(SELECT|INSERT|UPDATE|DELETE)\b[^`]*\$\{/i.test(l)
+  },
+  {
+    pattern: "exec",
+    severity: "critical",
+    test: (l) => /child_process/.test(l) || /\bexec\s*\(/.test(l) || /\bexecSync\s*\(/.test(l)
+  },
+  {
+    pattern: "hardcoded_secret",
+    severity: "critical",
+    test: (l) => /\b(token|secret|api_key|apikey|password|passwd|credential)\s*=\s*["']/i.test(l)
+  },
+  {
+    pattern: "insecure_url",
+    severity: "warning",
+    test: (l) => /http:\/\/(?!localhost|127\.0\.0\.1|0\.0\.0\.0)/.test(l)
+  }
+];
+function detectSecurityPatterns(files) {
+  const results = [];
+  for (const file of files) {
+    for (const hunk of file.hunks) {
+      for (const change of hunk.changes) {
+        if (change.type !== "add") continue;
+        for (const matcher of SECURITY_MATCHERS) {
+          if (matcher.test(change.content)) {
+            results.push({
+              file: file.path,
+              line: change.lineNumber,
+              pattern: matcher.pattern,
+              content: change.content.trim(),
+              severity: matcher.severity
+            });
+          }
+        }
+      }
+    }
+  }
+  results.sort((a, b) => {
+    const severityOrder = { critical: 0, warning: 1 };
+    const aSev = severityOrder[a.severity];
+    const bSev = severityOrder[b.severity];
+    if (aSev !== bSev) return aSev - bSev;
+    return a.file.localeCompare(b.file) || a.line - b.line;
+  });
+  return results;
+}
+
+// packages/analysis/src/index.ts
+function analyze(diffSet) {
+  const { files } = diffSet;
+  const triage = categorizeFiles(files);
+  const fileStats = computeFileStats(files);
+  const affectedModules = detectAffectedModules(files);
+  const affectedTests = detectAffectedTests(files);
+  const newDependencies = detectNewDependencies(files);
+  const summary = generateSummary(files);
+  const complexity = computeComplexityScores(files);
+  const testCoverage = detectTestCoverageGaps(files);
+  const codePatterns = detectPatterns(files);
+  const securityPatterns = detectSecurityPatterns(files);
+  const patterns = [...securityPatterns, ...codePatterns];
+  return {
+    summary,
+    triage,
+    impact: {
+      affectedModules,
+      affectedTests,
+      publicApiChanges: false,
+      breakingChanges: [],
+      newDependencies
+    },
+    verification: {
+      testsPass: null,
+      typeCheck: null,
+      lintClean: null
+    },
+    fileStats,
+    complexity,
+    testCoverage,
+    patterns
+  };
+}
+
+export {
+  categorizeFiles,
+  computeFileStats,
+  detectAffectedModules,
+  detectAffectedTests,
+  detectNewDependencies,
+  generateSummary,
+  computeComplexityScores,
+  detectTestCoverageGaps,
+  detectPatterns,
+  detectSecurityPatterns,
+  analyze
+};