@sun-asterisk/impact-analyzer 1.0.3 → 1.0.5

package/.specify/specs/features/component-impact-detection.md

@@ -0,0 +1,263 @@
+# Feature Spec:  Component Impact Detection
+
+## 1. Overview
+
+Identify UI components affected by code changes.  This feature traces component dependencies to find parent components that may be impacted by changes to child components.
+
+## 2. User Story
+
+> As a developer reviewing a pull request,
+> I want to see which UI components are affected by the code changes,
+> So that I can plan visual testing and assess user-facing impact.
+
+## 3. Functional Requirements
+
+### FR-001: Detect Component Definitions
+- **Description**:  Identify React/Vue/Angular component definitions
+- **Patterns to Support**:
+  - React functional components
+  - React class components
+  - React. FC type annotation
+  - Vue Single File Components (SFC)
+  - Vue Composition API (script setup)
+  - Angular @Component decorator
+- **Acceptance Criteria**:
+  - Detects function components (named and arrow)
+  - Detects class components extending React.Component
+  - Detects Vue SFC script blocks
+  - Detects Angular component classes
+
+### FR-002: Build Component Dependency Tree
+- **Description**:  Map component import/usage relationships
+- **Input**: Changed component names
+- **Output**:  Tree of parent components
+- **Acceptance Criteria**:
+  - Traces JSX/TSX component usage
+  - Resolves import statements
+  - Handles re-exports
+  - Handles dynamic imports
+
+### FR-003: Detect Props/Interface Changes
+- **Description**: Identify changes to component props
+- **Patterns to Support**:
+  - TypeScript interface:  `interface Props { }`
+  - TypeScript type: `type Props = { }`
+  - PropTypes definition
+  - Vue defineProps
+  - Angular @Input() decorator
+- **Acceptance Criteria**:
+  - Detects added props
+  - Detects removed props
+  - Detects prop type changes
+  - Flags breaking prop changes
+
+### FR-004: Find Parent Components
+- **Description**: Locate all components that use the changed component
+- **Input**: Changed component name and file
+- **Output**: List of parent components with usage count
+- **Acceptance Criteria**:
+  - Searches all component files in project
+  - Finds JSX usage:  `<ComponentName />`
+  - Handles aliased imports
+  - Counts usage instances
+
+### FR-005: Classify Component Type
+- **Description**:  Categorize the component framework and style
+- **Types**:
+  - `react-functional`: React function components
+  - `react-class`: React class components
+  - `vue-sfc`: Vue Single File Components
+  - `vue-composition`: Vue Composition API
+  - `angular`: Angular components
+- **Acceptance Criteria**:
+  - Correctly identifies React components
+  - Correctly identifies Vue components
+  - Correctly identifies Angular components
+
+### FR-006: Generate Component Report
+- **Description**: Compile component impacts into structured report
+- **Output**:  `ComponentImpact[]` array
+- **Acceptance Criteria**:
+  - Includes component name and type
+  - Includes parent component list
+  - Indicates props changes
+  - Includes severity based on usage
+
+## 4. Non-Functional Requirements
+
+### NFR-001: Performance
+- Analysis should add <10 seconds to total analysis time
+- Should handle projects with 500+ components
+
+### NFR-002: Accuracy
+- Should detect >90% of component changes
+- Should find >85% of parent component relationships
+
+## 5. Output Schema
+
+```javascript
+/**
+ * @typedef {Object} ComponentImpact
+ * @property {string} componentName - Component name
+ * @property {string} filePath - Path to component file
+ * @property {'react-functional'|'react-class'|'vue-sfc'|'vue-composition'|'angular'} componentType
+ * @property {ParentComponent[]} parentComponents
+ * @property {boolean} propsChanged - Whether props interface was modified
+ * @property {FileChange} changeSource
+ * @property {'low'|'medium'|'high'|'critical'} severity
+ */
+
+/**
+ * @typedef {Object} ParentComponent
+ * @property {string} name - Parent component name
+ * @property {string} filePath - Path to parent component
+ * @property {number} usageCount - How many times child is used
+ */
+```
+
+## 6. Severity Classification
+
+| Severity | Criteria |
+|----------|----------|
+| Critical | Props changed + >10 parent components |
+| High | Props changed OR >10 parent components |
+| Medium | 3-10 parent components |
+| Low | <3 parent components |
+
+## 7. Component Detection Patterns
+
+### React Functional Components
+```javascript
+// Named function
+function Button({ label }) {
+  return <button>{label}</button>;
+}
+
+// Arrow function
+const Button = ({ label }) => <button>{label}</button>;
+
+// React. FC type
+const Button:  React.FC<ButtonProps> = ({ label }) => { };
+
+// forwardRef
+const Button = forwardRef((props, ref) => { });
+
+// memo
+const Button = memo(({ label }) => { });
+```
+
+### React Class Components
+```javascript
+class Button extends React.Component { }
+class Button extends Component { }
+class Button extends React.PureComponent { }
+```
+
+### Vue Components
+```vue
+<!-- Options API -->
+<script>
+export default {
+  name: 'Button',
+  props: { label: String }
+}
+</script>
+
+<!-- Composition API -->
+<script setup>
+defineProps({ label: String })
+</script>
+```
+
+### Angular Components
+```typescript
+@Component({
+  selector: 'app-button',
+  template: '<button>{{label}}</button>'
+})
+export class ButtonComponent {
+  @Input() label: string;
+}
+```
+
+## 8. Test Scenarios
+
+### Scenario 1: Direct Component Change
+- **Given**:  A component's JSX is modified
+- **When**: Analysis runs
+- **Then**:  Component is detected with its parent components
+
+### Scenario 2: Props Interface Change
+- **Given**: A component's Props interface is modified
+- **When**: Analysis runs
+- **Then**:  `propsChanged` is true and severity is elevated
+
+### Scenario 3: Shared Component Change
+- **Given**:  A shared component (used by 15+ parents) is modified
+- **When**: Analysis runs
+- **Then**:  All parent components are listed, severity is high
+
+### Scenario 4: Isolated Component Change
+- **Given**: A component with no parents is modified
+- **When**: Analysis runs
+- **Then**: Component is detected with empty parent list
+
+### Scenario 5: Style-Only Change
+- **Given**: Only CSS/styles in a component file change
+- **When**:  Analysis runs
+- **Then**: Component is detected with low severity
+
+## 9. Edge Cases
+
+| Case | Expected Behavior |
+|------|-------------------|
+| Higher-order components | Detect both wrapper and wrapped |
+| Render props | Detect component, not render function |
+| Context providers | Detect as component |
+| CSS-only files | Skip, not a component |
+| Test files | Skip (excluded by pattern) |
+| Storybook files | Skip (excluded by pattern) |
+
+## 10. Example
+
+### Input
+```javascript
+// Changed file: src/components/Button/Button.jsx
+// Modified lines: 5-8
+
+/**
+ * @typedef {Object} ButtonProps
+ * @property {string} label
+ * @property {string} variant  // Line 5 - ADDED
+ * @property {() => void} onClick
+ */
+
+function Button({ label, variant, onClick }) {  // Line 8 - CHANGED
+  return (
+    <button className={variant} onClick={onClick}>
+      {label}
+    </button>
+  );
+}
+```
+
+### Expected Output
+```javascript
+{
+  component: [
+    {
+      componentName: "Button",
+      filePath:  "src/components/Button/Button.jsx",
+      componentType: "react-functional",
+      parentComponents: [
+        { name: "Header", filePath: "src/components/Header. jsx", usageCount: 2 },
+        { name: "Modal", filePath: "src/components/Modal.jsx", usageCount: 1 },
+        { name: "Form", filePath: "src/components/Form.jsx", usageCount: 3 }
+      ],
+      propsChanged: true,
+      changeSource: { path:  "src/components/Button/Button.jsx", ... },
+      severity: "medium"
+    }
+  ]
+}
+```

package/.specify/specs/features/database-impact-detection.md

@@ -0,0 +1,247 @@
+# Feature Spec: Database Impact Detection
+
+## 1. Overview
+
+Identify database tables and models affected by code changes.  This helps developers understand data layer impacts and plan database-related testing or migrations.
+
+## 2. User Story
+
+> As a developer reviewing a pull request,
+> I want to see which database tables are affected by the code changes,
+> So that I can assess data integrity risks and plan database testing.
+
+## 3. Functional Requirements
+
+### FR-001: Detect Entity/Model Changes
+- **Description**:  Identify changes to ORM entity or model files
+- **Patterns to Support**:
+  - TypeORM:  `@Entity()` decorator
+  - Sequelize: `@Table()` decorator, `Model.init()`
+  - Mongoose: `mongoose.model()`, `new Schema()`
+  - Prisma:  Changes to `schema.prisma`
+- **Acceptance Criteria**:
+  - Detects new entity definitions
+  - Detects modified entity properties
+  - Detects deleted entities
+  - Detects relation changes
+
+### FR-002: Extract Table Names
+- **Description**:  Determine database table name from entity definition
+- **Sources**:
+  - Explicit table name in decorator:  `@Entity('users')`
+  - Decorator options: `@Entity({ name: 'users' })`
+  - Class name conversion (PascalCase → snake_case)
+  - Sequelize tableName option
+  - Mongoose collection name
+- **Acceptance Criteria**:
+  - Correctly extracts explicit table names
+  - Correctly converts class names when not specified
+  - Handles custom naming strategies
+
+### FR-003: Detect Repository/DAO Changes
+- **Description**: Find changes to data access layer code
+- **Patterns to Support**:
+  - TypeORM Repository pattern
+  - Custom repository classes
+  - Query builder usage
+  - Raw SQL queries
+- **Acceptance Criteria**:
+  - Identifies affected entity from repository
+  - Detects query method changes
+  - Identifies CRUD operations
+
+### FR-004: Classify Impact Type
+- **Description**:  Categorize the type of database impact
+- **Categories**:
+  - `schema`: Column/property changes, new entities
+  - `query`: Repository method changes
+  - `relation`: Foreign key/relation changes
+  - `migration`: Migration file changes
+- **Acceptance Criteria**:
+  - Correctly classifies schema changes
+  - Correctly classifies query-only changes
+  - Correctly classifies relation changes
+
+### FR-005: Identify CRUD Operations
+- **Description**: Determine which database operations are affected
+- **Operations**:  SELECT, INSERT, UPDATE, DELETE
+- **Detection Methods**:
+  - Method name analysis (find*, create*, update*, delete*)
+  - Query builder analysis
+  - Decorator analysis (@Query, etc.)
+- **Acceptance Criteria**:
+  - Correctly identifies read operations
+  - Correctly identifies write operations
+  - Handles mixed operations
+
+### FR-006: Generate Database Report
+- **Description**:  Compile database impacts into structured report
+- **Output**: `DatabaseImpact[]` array
+- **Acceptance Criteria**:
+  - Includes table name and model name
+  - Includes impact classification
+  - Includes affected operations
+  - Deduplicates by table/impact type
+
+## 4. Non-Functional Requirements
+
+### NFR-001: Performance
+- Analysis should add <5 seconds to total analysis time
+
+### NFR-002: Accuracy
+- Should detect >95% of schema changes
+- Should detect >85% of query changes
+
+## 5. Output Schema
+
+```javascript
+/**
+ * @typedef {Object} DatabaseImpact
+ * @property {string} tableName - Database table name (snake_case)
+ * @property {string} modelName - Entity/Model class name
+ * @property {string} modelPath - File path to model definition
+ * @property {'schema'|'query'|'relation'|'migration'} impactType
+ * @property {('SELECT'|'INSERT'|'UPDATE'|'DELETE')[]} operations
+ * @property {FileChange} changeSource
+ * @property {'low'|'medium'|'high'|'critical'} severity
+ */
+```
+
+## 6. Severity Classification
+
+| Severity | Criteria |
+|----------|----------|
+| Critical | Schema changes (columns, constraints) |
+| High | Relation changes, DELETE operations |
+| Medium | INSERT, UPDATE operations |
+| Low | SELECT-only query changes |
+
+## 7. ORM Detection Patterns
+
+### TypeORM
+```javascript
+// Entity detection
+@Entity('users')
+@Entity({ name: 'users' })
+class User { }
+
+// Column detection
+@Column()
+@PrimaryColumn()
+@PrimaryGeneratedColumn()
+
+// Relation detection
+@OneToMany()
+@ManyToOne()
+@OneToOne()
+@ManyToMany()
+
+// Repository detection
+class UserRepository extends Repository<User> { }
+@EntityRepository(User)
+```
+
+### Sequelize
+```javascript
+// Model detection
+@Table({ tableName: 'users' })
+class User extends Model { }
+
+User.init({ }, { tableName: 'users' })
+
+// Column detection
+@Column
+@PrimaryKey
+@AutoIncrement
+
+// Relation detection
+@HasMany()
+@BelongsTo()
+@BelongsToMany()
+```
+
+### Mongoose
+```javascript
+// Schema detection
+const userSchema = new Schema({ })
+mongoose.model('User', userSchema)
+
+// Collection override
+mongoose.model('User', userSchema, 'custom_users')
+```
+
+### Prisma
+```prisma
+// Model detection in schema. prisma
+model User {
+  id    Int     @id @default(autoincrement())
+  email String  @unique
+  posts Post[]
+}
+```
+
+## 8. Test Scenarios
+
+### Scenario 1: Entity Column Change
+- **Given**: A property in an entity class is modified
+- **When**: Analysis runs
+- **Then**: Impact type is "schema" with high severity
+
+### Scenario 2: New Relation Added
+- **Given**:  A new relation decorator is added
+- **When**: Analysis runs
+- **Then**: Impact type is "relation"
+
+### Scenario 3: Repository Query Change
+- **Given**: A repository method is modified
+- **When**: Analysis runs
+- **Then**: Impact type is "query" with affected operations
+
+### Scenario 4: Prisma Schema Change
+- **Given**: schema.prisma is modified
+- **When**:  Analysis runs
+- **Then**:  Affected models are detected
+
+## 9. Edge Cases
+
+| Case | Expected Behavior |
+|------|-------------------|
+| No ORM detected | Return empty array |
+| Dynamic table names | Log warning, use class name |
+| Abstract entities | Skip, not mapped to table |
+| Embedded entities | Include in parent entity impact |
+| View entities | Mark as "view" in output |
+
+## 10. Example
+
+### Input
+```javascript
+// Changed file: src/entities/user.entity. js
+// Modified lines: 8-10
+
+@Entity('users')
+class User {
+  @Column()
+  email;  // Line 8 - CHANGED
+
+  @Column({ nullable: true })  // Line 9 - ADDED
+  phone;  // Line 10 - ADDED
+}
+```
+
+### Expected Output
+```javascript
+{
+  database: [
+    {
+      tableName: "users",
+      modelName: "User",
+      modelPath: "src/entities/user.entity.js",
+      impactType: "schema",
+      operations: ["SELECT", "INSERT", "UPDATE"],
+      changeSource:  { path: "src/entities/user. entity.js", ...  },
+      severity:  "critical"
+    }
+  ]
+}
+```