@soleri/core 9.0.4 → 9.3.0

package/src/planning/impact-analyzer.test.ts

@@ -0,0 +1,167 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { ImpactAnalyzer } from './impact-analyzer.js';
+
+const TMP = join(import.meta.dirname ?? __dirname, '__impact_test_tmp__');
+
+function setup() {
+  mkdirSync(join(TMP, 'src', 'utils'), { recursive: true });
+  mkdirSync(join(TMP, 'src', 'components'), { recursive: true });
+  mkdirSync(join(TMP, 'src', '__tests__'), { recursive: true });
+}
+
+function teardown() {
+  try {
+    rmSync(TMP, { recursive: true, force: true });
+  } catch {
+    /* ignore */
+  }
+}
+
+describe('ImpactAnalyzer', () => {
+  let analyzer: ImpactAnalyzer;
+
+  beforeEach(() => {
+    analyzer = new ImpactAnalyzer();
+    setup();
+  });
+
+  afterEach(() => {
+    teardown();
+  });
+
+  // ─── No modified files → low risk, empty consumers ─────────
+
+  it('returns low risk with empty consumers when no files modified', () => {
+    const report = analyzer.analyzeImpact([], TMP);
+
+    expect(report.riskLevel).toBe('low');
+    expect(report.affectedConsumers).toHaveLength(0);
+    expect(report.untestedConsumers).toHaveLength(0);
+    expect(report.scopeViolations).toHaveLength(0);
+    expect(report.recommendations).toHaveLength(0);
+  });
+
+  // ─── 1 modified file with 0 consumers → low risk ───────────
+
+  it('returns low risk when modified file has no consumers', () => {
+    writeFileSync(join(TMP, 'src', 'utils', 'helper.ts'), 'export function help() {}');
+    writeFileSync(join(TMP, 'src', 'components', 'button.ts'), 'export const Button = 1;');
+
+    const report = analyzer.analyzeImpact(['src/utils/helper.ts'], TMP);
+
+    expect(report.riskLevel).toBe('low');
+    expect(report.affectedConsumers).toHaveLength(0);
+  });
+
+  // ─── 1 modified file with 3 consumers → medium risk ────────
+
+  it('returns medium risk when modified file has 3 consumers', () => {
+    writeFileSync(join(TMP, 'src', 'utils', 'format.ts'), 'export function format() {}');
+    writeFileSync(
+      join(TMP, 'src', 'components', 'a.ts'),
+      "import { format } from '../utils/format';",
+    );
+    writeFileSync(
+      join(TMP, 'src', 'components', 'b.ts'),
+      "import { format } from '../utils/format';",
+    );
+    writeFileSync(join(TMP, 'src', 'components', 'c.ts'), "const f = require('../utils/format');");
+
+    const report = analyzer.analyzeImpact(['src/utils/format.ts'], TMP);
+
+    expect(report.riskLevel).toBe('medium');
+    expect(report.affectedConsumers).toHaveLength(3);
+    expect(report.recommendations.length).toBeGreaterThan(0);
+  });
+
+  // ─── 1 modified file with 7 consumers → high risk ──────────
+
+  it('returns high risk when modified file has 7 consumers', () => {
+    writeFileSync(join(TMP, 'src', 'utils', 'core.ts'), 'export const core = 1;');
+
+    for (let i = 0; i < 7; i++) {
+      writeFileSync(
+        join(TMP, 'src', 'components', `comp${i}.ts`),
+        `import { core } from '../utils/core';`,
+      );
+    }
+
+    const report = analyzer.analyzeImpact(['src/utils/core.ts'], TMP);
+
+    expect(report.riskLevel).toBe('high');
+    expect(report.affectedConsumers.length).toBeGreaterThanOrEqual(6);
+  });
+
+  // ─── Scope violation detection ──────────────────────────────
+
+  it('detects scope violations when files are outside plan scope', () => {
+    writeFileSync(join(TMP, 'src', 'utils', 'misc.ts'), 'export const x = 1;');
+
+    const report = analyzer.analyzeImpact(['src/utils/misc.ts', 'src/components/button.ts'], TMP, [
+      'components',
+    ]);
+
+    expect(report.scopeViolations).toContain('src/utils/misc.ts');
+    expect(report.scopeViolations).not.toContain('src/components/button.ts');
+  });
+
+  it('returns no scope violations when no planScope provided', () => {
+    const report = analyzer.analyzeImpact(['src/utils/misc.ts'], TMP);
+    expect(report.scopeViolations).toHaveLength(0);
+  });
+
+  // ─── Recommendation generation ─────────────────────────────
+
+  it('generates recommendations for consumers without tests', () => {
+    writeFileSync(join(TMP, 'src', 'utils', 'shared.ts'), 'export const shared = 1;');
+    writeFileSync(
+      join(TMP, 'src', 'components', 'widget.ts'),
+      "import { shared } from '../utils/shared';",
+    );
+
+    const report = analyzer.analyzeImpact(['src/utils/shared.ts'], TMP);
+
+    expect(report.recommendations.length).toBeGreaterThan(0);
+    const recText = report.recommendations.join(' ');
+    expect(recText).toContain('widget');
+  });
+
+  it('includes scope violation in recommendations', () => {
+    writeFileSync(join(TMP, 'src', 'utils', 'oops.ts'), 'export const x = 1;');
+
+    const report = analyzer.analyzeImpact(['src/utils/oops.ts'], TMP, ['components']);
+
+    const recText = report.recommendations.join(' ');
+    expect(recText).toContain('Scope violation');
+  });
+
+  // ─── Untested consumers detection ──────────────────────────
+
+  it('separates test files from untested consumers', () => {
+    writeFileSync(join(TMP, 'src', 'utils', 'api.ts'), 'export const api = 1;');
+    writeFileSync(join(TMP, 'src', 'components', 'page.ts'), "import { api } from '../utils/api';");
+    writeFileSync(
+      join(TMP, 'src', '__tests__', 'api.test.ts'),
+      "import { api } from '../utils/api';",
+    );
+
+    const report = analyzer.analyzeImpact(['src/utils/api.ts'], TMP);
+
+    // Test file should not be in untestedConsumers
+    expect(report.untestedConsumers.every((f) => !f.includes('.test.'))).toBe(true);
+    // page.ts (non-test) should be in untestedConsumers
+    expect(report.untestedConsumers.some((f) => f.includes('page'))).toBe(true);
+  });
+
+  // ─── Graceful when project path doesn't exist ──────────────
+
+  it('returns low risk when project path does not exist', () => {
+    const report = analyzer.analyzeImpact(['src/foo.ts'], '/nonexistent/path/12345');
+
+    expect(report.riskLevel).toBe('low');
+    expect(report.affectedConsumers).toHaveLength(0);
+    expect(report.modifiedFiles).toEqual(['src/foo.ts']);
+  });
+});

package/src/planning/impact-analyzer.ts

@@ -0,0 +1,251 @@
+/**
+ * Impact Analyzer — post-implementation impact analysis.
+ *
+ * Scans modified files for downstream consumers (imports/requires),
+ * detects scope violations, and assigns a risk level.
+ * Uses only `fs` and `path` — zero external dependencies.
+ */
+
+import { readFileSync, readdirSync, statSync, existsSync } from 'node:fs';
+import { join, relative, basename, extname } from 'node:path';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface AffectedConsumer {
+  file: string;
+  imports: string[];
+}
+
+export interface ImpactReport {
+  modifiedFiles: string[];
+  affectedConsumers: AffectedConsumer[];
+  untestedConsumers: string[];
+  scopeViolations: string[];
+  riskLevel: 'low' | 'medium' | 'high';
+  recommendations: string[];
+}
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const CODE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.vue', '.svelte']);
+
+const TEST_PATTERNS = [/\.test\./, /\.spec\./, /__tests__/, /\.stories\./];
+
+const SKIP_DIRS = new Set([
+  'node_modules',
+  '.git',
+  'dist',
+  'build',
+  'coverage',
+  '.next',
+  '.nuxt',
+  '.svelte-kit',
+  '.turbo',
+]);
+
+const MAX_FILES = 5000;
+
+// ---------------------------------------------------------------------------
+// ImpactAnalyzer
+// ---------------------------------------------------------------------------
+
+export class ImpactAnalyzer {
+  /**
+   * Analyze the downstream impact of modified files.
+   */
+  analyzeImpact(modifiedFiles: string[], projectPath: string, planScope?: string[]): ImpactReport {
+    if (modifiedFiles.length === 0 || !existsSync(projectPath)) {
+      return emptyReport(modifiedFiles);
+    }
+
+    const sourceFiles = collectSourceFiles(projectPath);
+    const consumers = findConsumers(modifiedFiles, sourceFiles, projectPath);
+    const untestedConsumers = filterUntested(consumers);
+    const scopeViolations = detectScopeViolations(modifiedFiles, planScope);
+    const riskLevel = assessRisk(consumers.length);
+    const recommendations = buildRecommendations(consumers, untestedConsumers, scopeViolations);
+
+    return {
+      modifiedFiles,
+      affectedConsumers: consumers,
+      untestedConsumers,
+      scopeViolations,
+      riskLevel,
+      recommendations,
+    };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers (all synchronous, all < 30 LOC)
+// ---------------------------------------------------------------------------
+
+function emptyReport(modifiedFiles: string[]): ImpactReport {
+  return {
+    modifiedFiles,
+    affectedConsumers: [],
+    untestedConsumers: [],
+    scopeViolations: [],
+    riskLevel: 'low',
+    recommendations: [],
+  };
+}
+
+/**
+ * Recursively collect source files under projectPath (up to MAX_FILES).
+ */
+function collectSourceFiles(dir: string, result: string[] = []): string[] {
+  if (result.length >= MAX_FILES) return result;
+
+  let entries: string[];
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return result;
+  }
+
+  for (const entry of entries) {
+    if (result.length >= MAX_FILES) break;
+    if (SKIP_DIRS.has(entry)) continue;
+
+    const full = join(dir, entry);
+    let stat;
+    try {
+      stat = statSync(full);
+    } catch {
+      continue;
+    }
+
+    if (stat.isDirectory()) {
+      collectSourceFiles(full, result);
+    } else if (CODE_EXTENSIONS.has(extname(entry))) {
+      result.push(full);
+    }
+  }
+  return result;
+}
+
+/**
+ * Find source files that import any of the modified files.
+ */
+function findConsumers(
+  modifiedFiles: string[],
+  sourceFiles: string[],
+  projectPath: string,
+): AffectedConsumer[] {
+  const patterns = buildImportPatterns(modifiedFiles, projectPath);
+  if (patterns.length === 0) return [];
+
+  const consumers: AffectedConsumer[] = [];
+
+  for (const file of sourceFiles) {
+    // Skip the modified files themselves
+    if (modifiedFiles.some((m) => file.endsWith(m) || file === m)) continue;
+
+    const matched = matchImports(file, patterns);
+    if (matched.length > 0) {
+      consumers.push({ file: relative(projectPath, file), imports: matched });
+    }
+  }
+  return consumers;
+}
+
+/**
+ * Build regex-friendly stems from modified file paths.
+ */
+function buildImportPatterns(modifiedFiles: string[], projectPath: string): string[] {
+  return modifiedFiles
+    .map((f) => {
+      const rel = f.startsWith('/') ? relative(projectPath, f) : f;
+      // Strip extension for import matching
+      const stem = rel.replace(/\.[^.]+$/, '');
+      // Also match the bare filename without extension
+      const bare = basename(rel).replace(/\.[^.]+$/, '');
+      return bare.length >= 3 ? bare : stem;
+    })
+    .filter((p) => p.length >= 3);
+}
+
+/**
+ * Read a file and return which patterns appear in its import/require lines.
+ */
+function matchImports(filePath: string, patterns: string[]): string[] {
+  let content: string;
+  try {
+    content = readFileSync(filePath, 'utf-8');
+  } catch {
+    return [];
+  }
+
+  const importRegex =
+    /(?:import\s+.*?from\s+['"]([^'"]+)['"]|require\s*\(\s*['"]([^'"]+)['"]\s*\))/g;
+  const importPaths: string[] = [];
+  let match: RegExpExecArray | null;
+  while ((match = importRegex.exec(content)) !== null) {
+    importPaths.push(match[1] ?? match[2]);
+  }
+
+  return patterns.filter((p) => importPaths.some((imp) => imp.includes(p)));
+}
+
+/**
+ * Filter consumers that are NOT test files.
+ */
+function filterUntested(consumers: AffectedConsumer[]): string[] {
+  return consumers.map((c) => c.file).filter((f) => !TEST_PATTERNS.some((p) => p.test(f)));
+}
+
+/**
+ * Flag modified files not in the declared plan scope.
+ */
+function detectScopeViolations(modifiedFiles: string[], planScope?: string[]): string[] {
+  if (!planScope || planScope.length === 0) return [];
+
+  return modifiedFiles.filter((f) => {
+    const lower = f.toLowerCase();
+    return !planScope.some((s) => lower.includes(s.toLowerCase()));
+  });
+}
+
+/**
+ * Assign risk based on consumer count.
+ */
+function assessRisk(consumerCount: number): ImpactReport['riskLevel'] {
+  if (consumerCount <= 1) return 'low';
+  if (consumerCount <= 5) return 'medium';
+  return 'high';
+}
+
+/**
+ * Generate actionable recommendation strings.
+ */
+function buildRecommendations(
+  consumers: AffectedConsumer[],
+  untestedConsumers: string[],
+  scopeViolations: string[],
+): string[] {
+  const recs: string[] = [];
+
+  if (consumers.length > 0) {
+    recs.push(
+      `Run tests for ${consumers.length} affected consumer(s): ${consumers
+        .map((c) => c.file)
+        .slice(0, 5)
+        .join(', ')}`,
+    );
+  }
+
+  for (const file of untestedConsumers.slice(0, 3)) {
+    recs.push(`Review import changes in ${file} (no test coverage detected)`);
+  }
+
+  for (const file of scopeViolations.slice(0, 3)) {
+    recs.push(`Scope violation: ${file} was modified but not in the declared plan scope`);
+  }
+
+  return recs;
+}