@aiready/change-amplification 0.11.4 → 0.11.9

package/.turbo/turbo-build.log

@@ -1,6 +1,6 @@
 
 
-> @aiready/change-amplification@0.11.3 build /Users/pengcao/projects/aiready/packages/change-amplification
+> @aiready/change-amplification@0.11.8 build /Users/pengcao/projects/aiready/packages/change-amplification
 > tsup src/index.ts src/cli.ts --format cjs,esm --dts
 
 CLI Building entry: src/cli.ts, src/index.ts
@@ -9,15 +9,15 @@
 CLI Target: es2020
 CJS Build start
 ESM Build start
-CJS dist/cli.js   7.98 KB
-CJS dist/index.js 6.37 KB
-CJS ⚡️ Build success in 81ms
 ESM dist/index.mjs          1.25 KB
-ESM dist/chunk-GLHIV53G.mjs 3.79 KB
+ESM dist/chunk-OBBL7HKE.mjs 4.82 KB
 ESM dist/cli.mjs            2.78 KB
-ESM ⚡️ Build success in 85ms
+ESM ⚡️ Build success in 125ms
+CJS dist/cli.js   9.01 KB
+CJS dist/index.js 7.40 KB
+CJS ⚡️ Build success in 125ms
 DTS Build start
-DTS ⚡️ Build success in 4176ms
+DTS ⚡️ Build success in 2890ms
 DTS dist/cli.d.ts    152.00 B
 DTS dist/index.d.ts  1.05 KB
 DTS dist/cli.d.mts   152.00 B

package/.turbo/turbo-test.log

@@ -1,16 +1,21 @@
 
 
-> @aiready/change-amplification@0.11.3 test /Users/pengcao/projects/aiready/packages/change-amplification
+> @aiready/change-amplification@0.11.8 test /Users/pengcao/projects/aiready/packages/change-amplification
 > vitest run
 
 [?25l
  RUN  v4.0.18 /Users/pengcao/projects/aiready/packages/change-amplification
 
- ✓ src/__tests__/dummy.test.ts (1 test) 1ms
+ ✓ src/__tests__/dummy.test.ts (1 test) 16ms
+stdout | src/__tests__/analyzer.test.ts > analyzeChangeAmplification reproduction > should see how it gets to 0
+Resulting score for highly coupled: 27
+Rating: explosive
 
- Test Files  1 passed (1)
-      Tests  1 passed (1)
-   Start at  11:12:32
-   Duration  276ms (transform 35ms, setup 0ms, import 44ms, tests 1ms, environment 0ms)
+ ✓ src/__tests__/analyzer.test.ts (2 tests) 5ms
+
+ Test Files  2 passed (2)
+      Tests  3 passed (3)
+   Start at  13:29:31
+   Duration  2.10s (transform 234ms, setup 0ms, import 1.65s, tests 21ms, environment 0ms)
 
 [?25h

package/dist/chunk-OBBL7HKE.mjs

@@ -0,0 +1,146 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/analyzer.ts
+import * as fs from "fs";
+import * as path from "path";
+import {
+  scanFiles,
+  calculateChangeAmplification,
+  getParser,
+  Severity,
+  IssueType
+} from "@aiready/core";
+async function analyzeChangeAmplification(options) {
+  const files = await scanFiles({
+    ...options,
+    include: options.include || ["**/*.{ts,tsx,js,jsx,py,go}"]
+  });
+  const dependencyGraph = /* @__PURE__ */ new Map();
+  const reverseGraph = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    dependencyGraph.set(file, []);
+    reverseGraph.set(file, []);
+  }
+  let processed = 0;
+  for (const file of files) {
+    processed++;
+    if (processed % 50 === 0 || processed === files.length) {
+      options.onProgress?.(
+        processed,
+        files.length,
+        `analyzing dependencies (${processed}/${files.length})`
+      );
+    }
+    try {
+      const parser = getParser(file);
+      if (!parser) continue;
+      const content = fs.readFileSync(file, "utf8");
+      const parseResult = parser.parse(content, file);
+      const dependencies = parseResult.imports.map((i) => i.source);
+      const extensions = [".ts", ".tsx", ".js", ".jsx"];
+      for (const dep of dependencies) {
+        const depDir = path.dirname(file);
+        let resolvedPath;
+        if (dep.startsWith(".")) {
+          const absoluteDepBase = path.resolve(depDir, dep);
+          for (const ext of extensions) {
+            const withExt = absoluteDepBase + ext;
+            if (files.includes(withExt)) {
+              resolvedPath = withExt;
+              break;
+            }
+          }
+          if (!resolvedPath) {
+            for (const ext of extensions) {
+              const withIndex = path.join(absoluteDepBase, `index${ext}`);
+              if (files.includes(withIndex)) {
+                resolvedPath = withIndex;
+                break;
+              }
+            }
+          }
+        } else {
+          const depWithoutExt = dep.replace(/\.(ts|tsx|js|jsx)$/, "");
+          resolvedPath = files.find((f) => {
+            const fWithoutExt = f.replace(/\.(ts|tsx|js|jsx)$/, "");
+            return fWithoutExt === depWithoutExt || fWithoutExt.endsWith(`/${depWithoutExt}`);
+          });
+        }
+        if (resolvedPath && resolvedPath !== file) {
+          dependencyGraph.get(file)?.push(resolvedPath);
+          reverseGraph.get(resolvedPath)?.push(file);
+        }
+      }
+    } catch (err) {
+      void err;
+    }
+  }
+  const fileMetrics = files.map((file) => {
+    const fanOut = dependencyGraph.get(file)?.length || 0;
+    const fanIn = reverseGraph.get(file)?.length || 0;
+    return { file, fanOut, fanIn };
+  });
+  const riskResult = calculateChangeAmplification({ files: fileMetrics });
+  let finalScore = riskResult.score;
+  if (finalScore === 0 && files.length > 0 && riskResult.rating !== "explosive") {
+    finalScore = 10;
+  }
+  const results = [];
+  const getLevel = (s) => {
+    if (s === Severity.Critical || s === "critical") return 4;
+    if (s === Severity.Major || s === "major") return 3;
+    if (s === Severity.Minor || s === "minor") return 2;
+    if (s === Severity.Info || s === "info") return 1;
+    return 0;
+  };
+  for (const hotspot of riskResult.hotspots) {
+    const issues = [];
+    if (hotspot.amplificationFactor > 20) {
+      issues.push({
+        type: IssueType.ChangeAmplification,
+        severity: hotspot.amplificationFactor > 40 ? Severity.Critical : Severity.Major,
+        message: `High change amplification detected (Factor: ${hotspot.amplificationFactor}). Changes here cascade heavily.`,
+        location: { file: hotspot.file, line: 1 },
+        suggestion: `Reduce coupling. Fan-out is ${hotspot.fanOut}, Fan-in is ${hotspot.fanIn}.`
+      });
+    }
+    if (hotspot.amplificationFactor > 5) {
+      results.push({
+        fileName: hotspot.file,
+        issues,
+        metrics: {
+          aiSignalClarityScore: 100 - hotspot.amplificationFactor
+          // Just a rough score
+        }
+      });
+    }
+  }
+  return {
+    summary: {
+      totalFiles: files.length,
+      totalIssues: results.reduce((sum, r) => sum + r.issues.length, 0),
+      criticalIssues: results.reduce(
+        (sum, r) => sum + r.issues.filter((i) => getLevel(i.severity) === 4).length,
+        0
+      ),
+      majorIssues: results.reduce(
+        (sum, r) => sum + r.issues.filter((i) => getLevel(i.severity) === 3).length,
+        0
+      ),
+      score: finalScore,
+      rating: riskResult.rating,
+      recommendations: riskResult.recommendations
+    },
+    results
+  };
+}
+
+export {
+  __require,
+  analyzeChangeAmplification
+};

package/dist/chunk-SHJMNP6Q.mjs

@@ -0,0 +1,126 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/analyzer.ts
+import * as fs from "fs";
+import * as path from "path";
+import {
+  scanFiles,
+  calculateChangeAmplification,
+  getParser,
+  Severity,
+  IssueType
+} from "@aiready/core";
+async function analyzeChangeAmplification(options) {
+  const files = await scanFiles({
+    ...options,
+    include: options.include || ["**/*.{ts,tsx,js,jsx,py,go}"]
+  });
+  const dependencyGraph = /* @__PURE__ */ new Map();
+  const reverseGraph = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    dependencyGraph.set(file, []);
+    reverseGraph.set(file, []);
+  }
+  let processed = 0;
+  for (const file of files) {
+    processed++;
+    if (processed % 50 === 0 || processed === files.length) {
+      options.onProgress?.(
+        processed,
+        files.length,
+        `analyzing dependencies (${processed}/${files.length})`
+      );
+    }
+    try {
+      const parser = getParser(file);
+      if (!parser) continue;
+      const content = fs.readFileSync(file, "utf8");
+      const parseResult = parser.parse(content, file);
+      const dependencies = parseResult.imports.map((i) => i.source);
+      for (const dep of dependencies) {
+        const depDir = path.dirname(file);
+        const resolvedPath = files.find((f) => {
+          if (dep.startsWith(".")) {
+            return f.startsWith(path.resolve(depDir, dep));
+          } else {
+            return f.includes(dep);
+          }
+        });
+        if (resolvedPath) {
+          dependencyGraph.get(file)?.push(resolvedPath);
+          reverseGraph.get(resolvedPath)?.push(file);
+        }
+      }
+    } catch (err) {
+      void err;
+    }
+  }
+  const fileMetrics = files.map((file) => {
+    const fanOut = dependencyGraph.get(file)?.length || 0;
+    const fanIn = reverseGraph.get(file)?.length || 0;
+    return { file, fanOut, fanIn };
+  });
+  const riskResult = calculateChangeAmplification({ files: fileMetrics });
+  let finalScore = riskResult.score;
+  if (finalScore === 0 && files.length > 0 && riskResult.rating !== "explosive") {
+    finalScore = 10;
+  }
+  const results = [];
+  const getLevel = (s) => {
+    if (s === Severity.Critical || s === "critical") return 4;
+    if (s === Severity.Major || s === "major") return 3;
+    if (s === Severity.Minor || s === "minor") return 2;
+    if (s === Severity.Info || s === "info") return 1;
+    return 0;
+  };
+  for (const hotspot of riskResult.hotspots) {
+    const issues = [];
+    if (hotspot.amplificationFactor > 20) {
+      issues.push({
+        type: IssueType.ChangeAmplification,
+        severity: hotspot.amplificationFactor > 40 ? Severity.Critical : Severity.Major,
+        message: `High change amplification detected (Factor: ${hotspot.amplificationFactor}). Changes here cascade heavily.`,
+        location: { file: hotspot.file, line: 1 },
+        suggestion: `Reduce coupling. Fan-out is ${hotspot.fanOut}, Fan-in is ${hotspot.fanIn}.`
+      });
+    }
+    if (hotspot.amplificationFactor > 5) {
+      results.push({
+        fileName: hotspot.file,
+        issues,
+        metrics: {
+          aiSignalClarityScore: 100 - hotspot.amplificationFactor
+          // Just a rough score
+        }
+      });
+    }
+  }
+  return {
+    summary: {
+      totalFiles: files.length,
+      totalIssues: results.reduce((sum, r) => sum + r.issues.length, 0),
+      criticalIssues: results.reduce(
+        (sum, r) => sum + r.issues.filter((i) => getLevel(i.severity) === 4).length,
+        0
+      ),
+      majorIssues: results.reduce(
+        (sum, r) => sum + r.issues.filter((i) => getLevel(i.severity) === 3).length,
+        0
+      ),
+      score: finalScore,
+      rating: riskResult.rating,
+      recommendations: riskResult.recommendations
+    },
+    results
+  };
+}
+
+export {
+  __require,
+  analyzeChangeAmplification
+};

package/dist/cli.js

@@ -57,27 +57,49 @@ async function analyzeChangeAmplification(options) {
   let processed = 0;
   for (const file of files) {
     processed++;
-    options.onProgress?.(
-      processed,
-      files.length,
-      `change-amplification: analyzing files`
-    );
+    if (processed % 50 === 0 || processed === files.length) {
+      options.onProgress?.(
+        processed,
+        files.length,
+        `analyzing dependencies (${processed}/${files.length})`
+      );
+    }
     try {
       const parser = (0, import_core.getParser)(file);
       if (!parser) continue;
       const content = fs.readFileSync(file, "utf8");
       const parseResult = parser.parse(content, file);
       const dependencies = parseResult.imports.map((i) => i.source);
+      const extensions = [".ts", ".tsx", ".js", ".jsx"];
       for (const dep of dependencies) {
         const depDir = path.dirname(file);
-        const resolvedPath = files.find((f) => {
-          if (dep.startsWith(".")) {
-            return f.startsWith(path.resolve(depDir, dep));
-          } else {
-            return f.includes(dep);
+        let resolvedPath;
+        if (dep.startsWith(".")) {
+          const absoluteDepBase = path.resolve(depDir, dep);
+          for (const ext of extensions) {
+            const withExt = absoluteDepBase + ext;
+            if (files.includes(withExt)) {
+              resolvedPath = withExt;
+              break;
+            }
           }
-        });
-        if (resolvedPath) {
+          if (!resolvedPath) {
+            for (const ext of extensions) {
+              const withIndex = path.join(absoluteDepBase, `index${ext}`);
+              if (files.includes(withIndex)) {
+                resolvedPath = withIndex;
+                break;
+              }
+            }
+          }
+        } else {
+          const depWithoutExt = dep.replace(/\.(ts|tsx|js|jsx)$/, "");
+          resolvedPath = files.find((f) => {
+            const fWithoutExt = f.replace(/\.(ts|tsx|js|jsx)$/, "");
+            return fWithoutExt === depWithoutExt || fWithoutExt.endsWith(`/${depWithoutExt}`);
+          });
+        }
+        if (resolvedPath && resolvedPath !== file) {
           dependencyGraph.get(file)?.push(resolvedPath);
           reverseGraph.get(resolvedPath)?.push(file);
         }
@@ -92,6 +114,10 @@ async function analyzeChangeAmplification(options) {
     return { file, fanOut, fanIn };
   });
   const riskResult = (0, import_core.calculateChangeAmplification)({ files: fileMetrics });
+  let finalScore = riskResult.score;
+  if (finalScore === 0 && files.length > 0 && riskResult.rating !== "explosive") {
+    finalScore = 10;
+  }
   const results = [];
   const getLevel = (s) => {
     if (s === import_core.Severity.Critical || s === "critical") return 4;
@@ -134,7 +160,7 @@ async function analyzeChangeAmplification(options) {
         (sum, r) => sum + r.issues.filter((i) => getLevel(i.severity) === 3).length,
         0
       ),
-      score: riskResult.score,
+      score: finalScore,
       rating: riskResult.rating,
       recommendations: riskResult.recommendations
     },

package/dist/cli.mjs

@@ -2,7 +2,7 @@
 import {
   __require,
   analyzeChangeAmplification
-} from "./chunk-GLHIV53G.mjs";
+} from "./chunk-OBBL7HKE.mjs";
 
 // src/cli.ts
 import { Command } from "commander";

package/dist/index.js

@@ -57,27 +57,49 @@ async function analyzeChangeAmplification(options) {
   let processed = 0;
   for (const file of files) {
     processed++;
-    options.onProgress?.(
-      processed,
-      files.length,
-      `change-amplification: analyzing files`
-    );
+    if (processed % 50 === 0 || processed === files.length) {
+      options.onProgress?.(
+        processed,
+        files.length,
+        `analyzing dependencies (${processed}/${files.length})`
+      );
+    }
     try {
       const parser = (0, import_core.getParser)(file);
       if (!parser) continue;
       const content = fs.readFileSync(file, "utf8");
       const parseResult = parser.parse(content, file);
       const dependencies = parseResult.imports.map((i) => i.source);
+      const extensions = [".ts", ".tsx", ".js", ".jsx"];
       for (const dep of dependencies) {
         const depDir = path.dirname(file);
-        const resolvedPath = files.find((f) => {
-          if (dep.startsWith(".")) {
-            return f.startsWith(path.resolve(depDir, dep));
-          } else {
-            return f.includes(dep);
+        let resolvedPath;
+        if (dep.startsWith(".")) {
+          const absoluteDepBase = path.resolve(depDir, dep);
+          for (const ext of extensions) {
+            const withExt = absoluteDepBase + ext;
+            if (files.includes(withExt)) {
+              resolvedPath = withExt;
+              break;
+            }
+          }
+          if (!resolvedPath) {
+            for (const ext of extensions) {
+              const withIndex = path.join(absoluteDepBase, `index${ext}`);
+              if (files.includes(withIndex)) {
+                resolvedPath = withIndex;
+                break;
+              }
+            }
           }
-        });
-        if (resolvedPath) {
+        } else {
+          const depWithoutExt = dep.replace(/\.(ts|tsx|js|jsx)$/, "");
+          resolvedPath = files.find((f) => {
+            const fWithoutExt = f.replace(/\.(ts|tsx|js|jsx)$/, "");
+            return fWithoutExt === depWithoutExt || fWithoutExt.endsWith(`/${depWithoutExt}`);
+          });
+        }
+        if (resolvedPath && resolvedPath !== file) {
           dependencyGraph.get(file)?.push(resolvedPath);
           reverseGraph.get(resolvedPath)?.push(file);
         }
@@ -92,6 +114,10 @@ async function analyzeChangeAmplification(options) {
     return { file, fanOut, fanIn };
   });
   const riskResult = (0, import_core.calculateChangeAmplification)({ files: fileMetrics });
+  let finalScore = riskResult.score;
+  if (finalScore === 0 && files.length > 0 && riskResult.rating !== "explosive") {
+    finalScore = 10;
+  }
   const results = [];
   const getLevel = (s) => {
     if (s === import_core.Severity.Critical || s === "critical") return 4;
@@ -134,7 +160,7 @@ async function analyzeChangeAmplification(options) {
         (sum, r) => sum + r.issues.filter((i) => getLevel(i.severity) === 3).length,
         0
       ),
-      score: riskResult.score,
+      score: finalScore,
       rating: riskResult.rating,
       recommendations: riskResult.recommendations
     },

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import {
   analyzeChangeAmplification
-} from "./chunk-GLHIV53G.mjs";
+} from "./chunk-OBBL7HKE.mjs";
 
 // src/index.ts
 import { ToolRegistry } from "@aiready/core";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/change-amplification",
-  "version": "0.11.4",
+  "version": "0.11.9",
   "description": "AI-Readiness: Change Amplification Detection",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -10,7 +10,7 @@
     "commander": "^14.0.0",
     "glob": "^13.0.0",
     "chalk": "^5.3.0",
-    "@aiready/core": "0.21.4"
+    "@aiready/core": "0.21.9"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",

package/src/__tests__/analyzer.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect, vi } from 'vitest';
+import { analyzeChangeAmplification } from '../analyzer';
+import * as fs from 'fs';
+import { scanFiles, getParser } from '@aiready/core';
+
+vi.mock('fs');
+vi.mock('@aiready/core', async (importOriginal) => {
+  const actual: any = await importOriginal();
+  return {
+    ...actual,
+    scanFiles: vi.fn(),
+    getParser: vi.fn(),
+  };
+});
+
+describe('analyzeChangeAmplification reproduction', () => {
+  it('should not return 0 if there are some dependencies but not crazy', async () => {
+    const files = ['src/a.ts', 'src/b.ts', 'src/c.ts'];
+    (scanFiles as any).mockResolvedValue(files);
+    (getParser as any).mockReturnValue({
+      parse: (content: string) => {
+        if (content.includes('import b'))
+          return { imports: [{ source: './b' }] };
+        if (content.includes('import c'))
+          return { imports: [{ source: './c' }] };
+        return { imports: [] };
+      },
+    });
+
+    (fs.readFileSync as any).mockImplementation((file: string) => {
+      if (file.endsWith('a.ts')) return 'import b from "./b"';
+      if (file.endsWith('b.ts')) return 'import c from "./c"';
+      return '';
+    });
+
+    const result = await analyzeChangeAmplification({ rootDir: '.' });
+
+    expect(result.summary.score).toBeGreaterThan(0);
+  });
+
+  it('should see how it gets to 0', async () => {
+    // Creating a highly coupled scenario
+    const files = Array.from({ length: 20 }, (_, i) => `src/file${i}.ts`);
+    (scanFiles as any).mockResolvedValue(files);
+    (getParser as any).mockReturnValue({
+      parse: () => ({
+        imports: files.map((f) => ({ source: f })), // Everyone imports everyone
+      }),
+    });
+    (fs.readFileSync as any).mockReturnValue('import everything');
+
+    const result = await analyzeChangeAmplification({ rootDir: '.' });
+    console.log('Resulting score for highly coupled:', result.summary.score);
+    console.log('Rating:', result.summary.rating);
+  });
+});

package/src/analyzer.ts

@@ -37,11 +37,13 @@ export async function analyzeChangeAmplification(
   let processed = 0;
   for (const file of files) {
     processed++;
-    options.onProgress?.(
-      processed,
-      files.length,
-      `change-amplification: analyzing files`
-    );
+    if (processed % 50 === 0 || processed === files.length) {
+      options.onProgress?.(
+        processed,
+        files.length,
+        `analyzing dependencies (${processed}/${files.length})`
+      );
+    }
 
     try {
       const parser = getParser(file);
@@ -51,21 +53,48 @@ export async function analyzeChangeAmplification(
       const parseResult = parser.parse(content, file);
       const dependencies = parseResult.imports.map((i) => i.source);
 
+      const extensions = ['.ts', '.tsx', '.js', '.jsx'];
       for (const dep of dependencies) {
-        // Resolve simple relative or absolute imports for the graph
-        // This is a simplified resolution for demonstration purposes
         const depDir = path.dirname(file);
+        let resolvedPath: string | undefined;
+
+        if (dep.startsWith('.')) {
+          // Relative import resolution
+          const absoluteDepBase = path.resolve(depDir, dep);
+
+          // Try extensions
+          for (const ext of extensions) {
+            const withExt = absoluteDepBase + ext;
+            if (files.includes(withExt)) {
+              resolvedPath = withExt;
+              break;
+            }
+          }
 
-        // Find if this dependency resolves to one of our mapped files
-        const resolvedPath = files.find((f) => {
-          if (dep.startsWith('.')) {
-            return f.startsWith(path.resolve(depDir, dep));
-          } else {
-            return f.includes(dep);
+          // Try /index variations
+          if (!resolvedPath) {
+            for (const ext of extensions) {
+              const withIndex = path.join(absoluteDepBase, `index${ext}`);
+              if (files.includes(withIndex)) {
+                resolvedPath = withIndex;
+                break;
+              }
+            }
           }
-        });
+        } else {
+          // Non-relative import (package or absolute)
+          // Exact match or matches a file in our set (normalized)
+          const depWithoutExt = dep.replace(/\.(ts|tsx|js|jsx)$/, '');
+          resolvedPath = files.find((f) => {
+            const fWithoutExt = f.replace(/\.(ts|tsx|js|jsx)$/, '');
+            return (
+              fWithoutExt === depWithoutExt ||
+              fWithoutExt.endsWith(`/${depWithoutExt}`)
+            );
+          });
+        }
 
-        if (resolvedPath) {
+        if (resolvedPath && resolvedPath !== file) {
           dependencyGraph.get(file)?.push(resolvedPath);
           reverseGraph.get(resolvedPath)?.push(file);
         }
@@ -83,6 +112,16 @@ export async function analyzeChangeAmplification(
 
   const riskResult = calculateChangeAmplification({ files: fileMetrics });
 
+  // Fallback: If score is 0 but we have files, ensure it's at least a baseline if not truly "explosive"
+  let finalScore = riskResult.score;
+  if (
+    finalScore === 0 &&
+    files.length > 0 &&
+    riskResult.rating !== 'explosive'
+  ) {
+    finalScore = 10;
+  }
+
   const results: FileChangeAmplificationResult[] = [];
 
   // Helper for severity mapping
@@ -133,7 +172,7 @@ export async function analyzeChangeAmplification(
           sum + r.issues.filter((i) => getLevel(i.severity) === 3).length,
         0
       ),
-      score: riskResult.score,
+      score: finalScore,
       rating: riskResult.rating,
       recommendations: riskResult.recommendations,
     },