@sun-asterisk/impact-analyzer 1.0.3 → 1.0.5

package/.specify/tasks/task-004-report.md

@@ -0,0 +1,484 @@
+# Task 004: Fix Report Generator - Output Format Issues
+
+**Status:** 📋 TODO  
+**Priority:** 🔴 HIGH  
+**Assignee:** AI Agent  
+**Created:** 2025-12-25
+
+---
+
+## 📝 Overview
+
+Fix report generator to correctly display impact analysis data in both Markdown and JSON formats. Current issues:
+1. **Field name mismatches** - Using old field names (`table` instead of `tableName`)
+2. **Source code in reports** - Showing code snippets instead of just affected entities
+3. **JSON output broken** - Contains internal data structures not suitable for reports
+
+## 🎯 Goals
+
+### 1. Update Report Field Names
+The database detector now returns spec-compliant output, but the report generator uses old field names.
+
+**Current Issue:**
+```javascript
+// Report uses:
+db.table         // ❌ Undefined
+db.name          // ❌ Undefined
+
+// Should use:
+db.tableName     // ✅ Correct
+db.modelName     // ✅ Correct
+db.modelPath     // ✅ Correct
+```
+
+### 2. Remove Source Code from Reports
+Reports should focus on **WHAT** changed, not HOW it changed.
+
+**Show:**
+- ✅ Endpoint paths: `GET /users/:id`
+- ✅ Table names: `users`, `posts`
+- ✅ Field names: `email`, `phone`
+- ✅ Component names: `UserProfile.tsx`
+- ✅ Impact severity: `critical`, `high`
+
+**Do NOT Show:**
+- ❌ Code snippets
+- ❌ Diff output
+- ❌ Method implementations
+- ❌ File contents
+- ❌ Git diff details
+
+### 3. Fix JSON Output
+JSON output should be clean, structured data suitable for CI/CD integration.
+
+**Requirements:**
+- Remove internal data structures (AST, diff, oldContent)
+- Remove file contents
+- Focus on actionable insights
+- Flatten nested structures where appropriate
+
+## 📋 Implementation Tasks
+
+### Phase 1: Audit Current Issues
+
+- [ ] List all places using old field names (`table`, `name`)
+- [ ] Identify where source code is being included
+- [ ] Review JSON output structure
+- [ ] Document expected vs actual output
+
+**Audit Checklist:**
+```bash
+# Find old field references
+grep -n "\.table\b" core/report-generator.js
+grep -n "\.name\b" core/report-generator.js
+
+# Check what's in changes object
+grep -n "changes\." core/report-generator.js
+
+# Check JSON output
+grep -n "JSON.stringify" index.js
+```
+
+### Phase 2: Fix Database Section
+
+**File:** `core/report-generator.js`
+
+#### Issue 1: Wrong Field Names
+
+**Current Code:**
+```javascript
+lines.push(`| \`${db.table}\` | ${db.operations.join(', ')} | ${fieldsDisplay} |`);
+```
+
+**Fixed Code:**
+```javascript
+lines.push(`| \`${db.tableName}\` | ${db.operations.join(', ')} | ${fieldsDisplay} |`);
+```
+
+#### Issue 2: Show Model Information
+
+**Add to report:**
+```javascript
+// Database Impact Section
+lines.push('| Table | Model | Impact Type | Severity | Operations |');
+lines.push('|-------|-------|-------------|----------|-----------|');
+
+dbImpacts.forEach(db => {
+  lines.push(`| \`${db.tableName}\` | ${db.modelName} | ${db.impactType} | ${db.severity} | ${db.operations.join(', ')} |`);
+});
+```
+
+**Detailed Section:**
+```javascript
+dbImpacts.forEach(db => {
+  lines.push(`### \`${db.tableName}\` (${db.modelName})\n`);
+  lines.push(`- **Impact Type:** ${db.impactType}`);
+  lines.push(`- **Severity:** ${db.severity}`);
+  lines.push(`- **Operations:** ${db.operations.join(', ')}`);
+  lines.push(`- **Entity File:** ${db.modelPath}`);
+  
+  if (db.fields && db.fields.length > 0) {
+    lines.push(`- **Affected Fields:** ${db.fields.map(f => `\`${f}\``).join(', ')}`);
+  }
+  lines.push('');
+});
+```
+
+### Phase 3: Fix Console Report
+
+**File:** `core/report-generator.js`
+
+**Current Issue:**
+```javascript
+console.log(`   • ${d.table} (${d.operations.join(', ')})`);  // ❌ undefined
+```
+
+**Fix:**
+```javascript
+console.log(`   • ${d.tableName} (${d.impactType}, ${d.severity})`);
+console.log(`     Operations: ${d.operations.join(', ')}`);
+if (d.fields && d.fields.length > 0) {
+  console.log(`     Fields: ${d.fields.slice(0, 5).join(', ')}${d.fields.length > 5 ? '...' : ''}`);
+}
+```
+
+### Phase 4: Clean JSON Output
+
+**File:** `index.js`
+
+**Current Issue:**
+```javascript
+// This includes everything, including code and diffs
+fs.writeFileSync(jsonOutput, JSON.stringify({ changes, impact }, null, 2));
+```
+
+**Solution:** Create clean report structure
+
+```javascript
+// Create clean JSON report
+const jsonReport = reporter.generateJSONReport(changes, impact);
+fs.writeFileSync(jsonOutput, JSON.stringify(jsonReport, null, 2));
+```
+
+**Implementation in `report-generator.js`:**
+```javascript
+/**
+ * Generate clean JSON report suitable for CI/CD
+ * Excludes source code, diffs, and internal data structures
+ */
+generateJSONReport(changes, impact) {
+  return {
+    metadata: {
+      timestamp: new Date().toISOString(),
+      filesChanged: changes.changedFiles.length,
+      symbolsChanged: changes.changedSymbols?.length || 0,
+    },
+    summary: {
+      impactScore: impact.impactScore,
+      severity: impact.severity,
+      affectedEndpoints: impact.affectedEndpoints?.length || 0,
+      affectedTables: impact.databaseImpact?.length || 0,
+      affectedComponents: this.countComponents(changes.changedFiles),
+    },
+    endpoints: this.formatEndpointsForJSON(impact.affectedEndpoints),
+    database: this.formatDatabaseForJSON(impact.databaseImpact),
+    components: this.formatComponentsForJSON(changes.changedFiles),
+    logic: {
+      riskLevel: impact.logicImpact?.riskLevel || 'low',
+      directCallers: impact.logicImpact?.directCallers?.length || 0,
+      indirectCallers: impact.logicImpact?.indirectCallers?.length || 0,
+    }
+  };
+}
+
+formatEndpointsForJSON(endpoints) {
+  if (!endpoints || endpoints.length === 0) return [];
+  
+  return endpoints.map(e => ({
+    method: e.method,
+    path: e.path,
+    controller: e.controller,
+    impactLevel: e.impactLevel,
+    // DO NOT include: affectedBy, callChain with code
+  }));
+}
+
+formatDatabaseForJSON(dbImpacts) {
+  if (!dbImpacts || dbImpacts.length === 0) return [];
+  
+  return dbImpacts.map(db => ({
+    tableName: db.tableName,
+    modelName: db.modelName,
+    modelPath: db.modelPath,
+    impactType: db.impactType,
+    severity: db.severity,
+    operations: db.operations,
+    fields: db.fields || [],
+    // DO NOT include: changeSource with diff/content
+  }));
+}
+
+formatComponentsForJSON(changedFiles) {
+  const components = changedFiles.filter(f => this.isComponentFile(f));
+  
+  return components.map(c => ({
+    path: c.path,
+    type: this.detectPageType(c.path),
+    status: c.status,
+    linesAdded: c.changes?.added || 0,
+    linesDeleted: c.changes?.deleted || 0,
+    // DO NOT include: content, oldContent, diff
+  }));
+}
+
+isComponentFile(file) {
+  const path = file.path.toLowerCase();
+  return (
+    path.includes('/page') || path.includes('/component') ||
+    path.includes('/view') || path.includes('/screen') ||
+    path.includes('.page.') || path.includes('.component.')
+  );
+}
+
+countComponents(changedFiles) {
+  return changedFiles.filter(f => this.isComponentFile(f)).length;
+}
+```
+
+### Phase 5: Remove Code from Markdown Report
+
+**File:** `core/report-generator.js`
+
+**Current Issues to Fix:**
+
+1. **Changed Files Section** - Showing diff snippets
+```javascript
+// REMOVE OR SIMPLIFY
+generateChangedFilesSection(changedFiles) {
+  // Don't show: oldContent, content, diff
+  // Only show: path, status, lines changed
+}
+```
+
+2. **Logic Impact Section** - Showing method details
+```javascript
+// Keep simple
+lines.push(`**Direct Callers:** ${logicImpact.directCallers.length}`);
+lines.push(`**Indirect Callers:** ${logicImpact.indirectCallers.length}`);
+// Don't list all method names with signatures
+```
+
+**Clean Changed Files Section:**
+```javascript
+generateChangedFilesSection(changedFiles) {
+  const lines = ['## 📝 Changed Files\n'];
+  
+  lines.push(`**Total Files Changed:** ${changedFiles.length}\n`);
+  
+  lines.push('| File | Type | Status | Changes |');
+  lines.push('|------|------|--------|---------|');
+  
+  changedFiles.forEach(f => {
+    const type = f.type || 'source';
+    const changes = `+${f.changes?.added || 0} -${f.changes?.deleted || 0}`;
+    const statusEmoji = this.getStatusEmoji(f.status);
+    lines.push(`| ${statusEmoji} ${f.path} | ${type} | ${f.status} | ${changes} |`);
+  });
+  
+  return lines.join('\n');
+}
+```
+
+## ✅ Acceptance Criteria
+
+### Markdown Report
+- [ ] Database section uses `tableName`, `modelName`, `modelPath`
+- [ ] Database section shows `impactType` and `severity`
+- [ ] No source code snippets
+- [ ] No diff output
+- [ ] Only shows entity names and affected fields
+
+### Console Report
+- [ ] Database section uses correct field names
+- [ ] Shows severity for each table
+- [ ] Compact, readable format
+- [ ] No code output
+
+### JSON Report
+- [ ] Clean structure suitable for CI/CD
+- [ ] No `content`, `oldContent`, `diff` fields
+- [ ] Uses correct field names (`tableName` not `table`)
+- [ ] Flat structure where possible
+- [ ] Includes metadata (timestamp, counts)
+- [ ] Valid JSON format
+
+## 🧪 Testing
+
+### Manual Tests
+
+**Test 1: Markdown Report Format**
+```bash
+node index.js --input=src --base=origin/main --output=test-report.md
+
+# Check report:
+cat test-report.md
+
+# Expected:
+# - Database section has tableName, modelName
+# - No code snippets
+# - Clean table format
+```
+
+**Test 2: JSON Report Format**
+```bash
+node index.js --input=src --base=origin/main --json=test-report.json
+
+# Check JSON:
+cat test-report.json | jq .
+
+# Expected:
+# - Valid JSON
+# - No content/diff fields
+# - Clean database section with tableName
+```
+
+**Test 3: Console Output**
+```bash
+node index.js --input=src --base=origin/main
+
+# Expected:
+# - Database impact shows tableName
+# - No undefined values
+# - Clean, readable output
+```
+
+## 📊 Expected Output Examples
+
+### Markdown Report
+
+#### Database Section
+```markdown
+## 💾 Database Impact
+
+**Total Tables Affected:** 2
+
+| Table | Model | Impact Type | Severity | Operations |
+|-------|-------|-------------|----------|-----------|
+| `users` | UserEntity | schema | critical | SELECT, INSERT, UPDATE |
+| `posts` | PostEntity | query | medium | INSERT |
+
+### Details
+
+#### `users` (UserEntity)
+- **Impact Type:** schema
+- **Severity:** critical
+- **Operations:** SELECT, INSERT, UPDATE
+- **Entity File:** src/entities/user.entity.ts
+- **Affected Fields:** `email`, `phone`, `updatedAt`
+
+#### `posts` (PostEntity)
+- **Impact Type:** query
+- **Severity:** medium
+- **Operations:** INSERT
+- **Entity File:** src/entities/post.entity.ts
+```
+
+### JSON Report
+```json
+{
+  "metadata": {
+    "timestamp": "2025-12-25T03:00:00.000Z",
+    "filesChanged": 5,
+    "symbolsChanged": 8
+  },
+  "summary": {
+    "impactScore": 75,
+    "severity": "high",
+    "affectedEndpoints": 3,
+    "affectedTables": 2,
+    "affectedComponents": 1
+  },
+  "endpoints": [
+    {
+      "method": "GET",
+      "path": "/users/:id",
+      "controller": "UserController.getUser",
+      "impactLevel": "high"
+    }
+  ],
+  "database": [
+    {
+      "tableName": "users",
+      "modelName": "UserEntity",
+      "modelPath": "src/entities/user.entity.ts",
+      "impactType": "schema",
+      "severity": "critical",
+      "operations": ["SELECT", "INSERT", "UPDATE"],
+      "fields": ["email", "phone", "updatedAt"]
+    }
+  ],
+  "components": [
+    {
+      "path": "src/pages/UserProfile.tsx",
+      "type": "page",
+      "status": "modified",
+      "linesAdded": 15,
+      "linesDeleted": 3
+    }
+  ],
+  "logic": {
+    "riskLevel": "medium",
+    "directCallers": 5,
+    "indirectCallers": 12
+  }
+}
+```
+
+### Console Output
+```
+💾 DATABASE IMPACT:
+   • users (schema, critical)
+     Operations: SELECT, INSERT, UPDATE
+     Fields: email, phone, updatedAt
+   • posts (query, medium)
+     Operations: INSERT
+```
+
+## 🎯 Definition of Done
+
+- [ ] All field name mismatches fixed
+- [ ] No source code in reports
+- [ ] JSON output uses clean structure
+- [ ] Markdown report shows proper database info
+- [ ] Console report uses correct fields
+- [ ] All tests pass
+- [ ] Reports are readable and actionable
+- [ ] JSON is valid and CI/CD friendly
+
+## 🔗 References
+
+- **Current Code:** `core/report-generator.js`, `index.js`
+- **Spec:** `.specify/specs/features/database-impact-detection.md` (Section 5 - Output Schema)
+- **Task 002:** `.specify/tasks/task-002-database-detector.md` (Database output format)
+
+## 📝 Notes
+
+### Report Best Practices
+
+1. **Focus on "What" not "How"**
+   - ✅ "Table `users` changed"
+   - ❌ "Line 45: `email: string;` added"
+
+2. **Keep JSON Clean**
+   - ✅ Include: tableName, operations, severity
+   - ❌ Exclude: diff, content, oldContent, AST
+
+3. **Make Reports Actionable**
+   - Show severity so developers know priority
+   - Show affected entities so QA knows what to test
+   - Show file paths for quick navigation
+
+---
+
+**Last Updated:** 2025-12-25  
+**Implementation Status:** TODO

package/README.md

@@ -151,7 +151,7 @@ npx @sun-asterisk/impact-analyzer --input=src --base=abc123 --head=def456
 
 ## CI/CD Integration
 
-### GitHub Actions
+### GitHub Actions (Recommended - Simple)
 
 ```yaml
 name: Impact Analysis
@@ -165,7 +165,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
         with:
-          fetch-depth: 0  # Fetch full history
+          fetch-depth: 2  # Fetch current commit + parent
 
       - uses: actions/setup-node@v3
         with:
@@ -175,22 +175,16 @@ jobs:
         run: |
           npx @sun-asterisk/impact-analyzer \
             --input=src \
-            --base=origin/${{ github.base_ref }} \
-            --output=impact-report.md \
-            --json=impact-report.json
+            --base=origin/${{ github.event.pull_request.base.ref }} \
+            --head=HEAD \
+            --output=impact-report.md
 
-      - name: Comment PR
-        uses: actions/github-script@v6
+      - name: Upload impact reports
+        uses: actions/upload-artifact@v4
         with:
-          script: |
-            const fs = require('fs');
-            const report = fs.readFileSync('impact-report.md', 'utf8');
-            github.rest.issues.createComment({
-              issue_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              body: report
-            });
+          name: impact-reports-${{ github.sha }}
+          path: impact-report.md
+          retention-days: 30
 ```
 
 ### GitLab CI
@@ -200,11 +194,12 @@ impact-analysis:
   stage: test
   image: node:18
   variables:
-    GIT_DEPTH: 0  # Fetch full history
+    GIT_DEPTH: 2  # Fetch current + parent commit
   script:
     - npx @sun-asterisk/impact-analyzer
         --input=src
         --base=origin/$CI_MERGE_REQUEST_TARGET_BRANCH_NAME
+        --head=HEAD
         --output=impact-report.md
         --json=impact-report.json
   artifacts:
@@ -227,6 +222,7 @@ pipeline {
                     npx @sun-asterisk/impact-analyzer \
                         --input=src \
                         --base=origin/main \
+                        --head=HEAD \
                         --output=impact-report.md \
                         --json=impact-report.json
                 '''
@@ -236,8 +232,6 @@ pipeline {
 }
 ```
 
-## Report Output
-
 ### Severity Levels
 
 - 🟢 **LOW** (0-20) - Minor changes