@girardmedia/bootspring 1.2.0 → 2.0.3

package/intelligence/learning/insights.json

@@ -1,12 +1,522 @@
 {
   "version": "1.0.0",
-  "last_analysis": null,
-  "insights": [],
+  "last_analysis": "2026-02-21T18:13:21.290Z",
+  "insights": [
+    {
+      "type": "cold_start",
+      "subject": "general",
+      "message": "Using industry best practices until learning data accumulates",
+      "level": "info",
+      "confidence": 0.5,
+      "weight": 1,
+      "is_default": true
+    },
+    {
+      "type": "cold_start",
+      "subject": "data_collection",
+      "message": "Recommendations will improve significantly after 5 recorded decisions",
+      "level": "info",
+      "confidence": 0.5,
+      "weight": 1,
+      "is_default": true
+    }
+  ],
   "correlations": [],
-  "anti_patterns": [],
+  "anti_patterns": [
+    {
+      "type": "security",
+      "decision": "hardcoded_secrets",
+      "failure_rate": 1,
+      "occurrences": 0,
+      "recommendation": "AVOID",
+      "message": "Never hardcode API keys, passwords, or secrets in source code",
+      "is_default": true,
+      "weight": 1
+    },
+    {
+      "type": "database",
+      "decision": "no_migrations",
+      "failure_rate": 0.8,
+      "occurrences": 0,
+      "recommendation": "AVOID",
+      "message": "Always use migrations for schema changes, avoid direct DB modifications",
+      "is_default": true,
+      "weight": 1
+    },
+    {
+      "type": "deployment",
+      "decision": "direct_to_production",
+      "failure_rate": 0.7,
+      "occurrences": 0,
+      "recommendation": "AVOID",
+      "message": "Deploy to staging first, test thoroughly before production",
+      "is_default": true,
+      "weight": 1
+    },
+    {
+      "type": "testing",
+      "decision": "skip_tests_for_deadline",
+      "failure_rate": 0.75,
+      "occurrences": 0,
+      "recommendation": "AVOID",
+      "message": "Skipping tests to meet deadlines often leads to bugs and longer timelines",
+      "is_default": true,
+      "weight": 1
+    },
+    {
+      "type": "refactoring",
+      "decision": "big_bang_refactor",
+      "failure_rate": 0.65,
+      "occurrences": 0,
+      "recommendation": "AVOID",
+      "message": "Large refactors without tests are risky - prefer incremental changes",
+      "is_default": true,
+      "weight": 1
+    },
+    {
+      "type": "feature",
+      "decision": "no_requirements",
+      "failure_rate": 0.6,
+      "occurrences": 0,
+      "recommendation": "AVOID",
+      "message": "Starting development without clear requirements leads to rework",
+      "is_default": true,
+      "weight": 1
+    },
+    {
+      "type": "architecture",
+      "decision": "premature_optimization",
+      "failure_rate": 0.5,
+      "occurrences": 0,
+      "recommendation": "CAUTION",
+      "message": "Optimizing before measuring often wastes effort on non-bottlenecks",
+      "is_default": true,
+      "weight": 1
+    },
+    {
+      "type": "api",
+      "decision": "breaking_change_no_version",
+      "failure_rate": 0.8,
+      "occurrences": 0,
+      "recommendation": "AVOID",
+      "message": "Breaking API changes without versioning breaks existing clients",
+      "is_default": true,
+      "weight": 1
+    }
+  ],
   "recommendations": {
-    "by_type": {},
-    "by_phase": {},
-    "general": []
+    "by_type": {
+      "database": {
+        "success_rate": 0.8,
+        "recommendation": "Use migrations for schema changes, write tests for queries",
+        "sample_size": 0,
+        "is_default": true,
+        "tips": [
+          "Always create rollback migrations",
+          "Test with production-like data volumes",
+          "Index columns used in WHERE clauses"
+        ]
+      },
+      "api": {
+        "success_rate": 0.75,
+        "recommendation": "Document endpoints, validate inputs, handle errors consistently",
+        "sample_size": 0,
+        "is_default": true,
+        "tips": [
+          "Use OpenAPI/Swagger for documentation",
+          "Return appropriate HTTP status codes",
+          "Include request IDs for debugging"
+        ]
+      },
+      "ui": {
+        "success_rate": 0.7,
+        "recommendation": "Start with mobile-first design, use design system components",
+        "sample_size": 0,
+        "is_default": true,
+        "tips": [
+          "Test on real devices, not just emulators",
+          "Consider accessibility from the start",
+          "Use semantic HTML elements"
+        ]
+      },
+      "testing": {
+        "success_rate": 0.85,
+        "recommendation": "Write tests for critical paths first, mock external services",
+        "sample_size": 0,
+        "is_default": true,
+        "tips": [
+          "Use factories for test data",
+          "Keep tests independent and isolated",
+          "Test behavior, not implementation"
+        ]
+      },
+      "security": {
+        "success_rate": 0.9,
+        "recommendation": "Never store secrets in code, validate all inputs, use prepared statements",
+        "sample_size": 0,
+        "is_default": true,
+        "tips": [
+          "Use environment variables for configuration",
+          "Implement rate limiting on public endpoints",
+          "Keep dependencies updated"
+        ]
+      },
+      "architecture": {
+        "success_rate": 0.65,
+        "recommendation": "Start simple, refactor when patterns emerge, document decisions",
+        "sample_size": 0,
+        "is_default": true,
+        "tips": [
+          "Use ADRs (Architecture Decision Records)",
+          "Prefer composition over inheritance",
+          "Keep components loosely coupled"
+        ]
+      },
+      "feature": {
+        "success_rate": 0.75,
+        "recommendation": "Break into small increments, define acceptance criteria, get early feedback",
+        "sample_size": 0,
+        "is_default": true,
+        "tips": [
+          "Ship MVPs and iterate",
+          "Use feature flags for gradual rollout",
+          "Track metrics to measure success"
+        ]
+      },
+      "bugfix": {
+        "success_rate": 0.8,
+        "recommendation": "Write failing test first, fix root cause, verify no regressions",
+        "sample_size": 0,
+        "is_default": true,
+        "tips": [
+          "Understand the bug before fixing",
+          "Check for similar issues elsewhere",
+          "Update documentation if behavior was unclear"
+        ]
+      },
+      "refactoring": {
+        "success_rate": 0.7,
+        "recommendation": "Ensure test coverage, make small changes, keep separate from features",
+        "sample_size": 0,
+        "is_default": true,
+        "tips": [
+          "Use IDE refactoring tools when available",
+          "Commit frequently during refactoring",
+          "Review changes in small batches"
+        ]
+      },
+      "performance": {
+        "success_rate": 0.65,
+        "recommendation": "Measure first, optimize bottlenecks, measure again",
+        "sample_size": 0,
+        "is_default": true,
+        "tips": [
+          "Set performance budgets upfront",
+          "Profile in production-like environments",
+          "Consider caching strategies"
+        ]
+      },
+      "deployment": {
+        "success_rate": 0.75,
+        "recommendation": "Use staging environment, implement health checks, have rollback plan",
+        "sample_size": 0,
+        "is_default": true,
+        "tips": [
+          "Automate deployments",
+          "Use blue-green or canary deployments",
+          "Monitor error rates after deploy"
+        ]
+      },
+      "documentation": {
+        "success_rate": 0.8,
+        "recommendation": "Keep docs close to code, include examples, update during changes",
+        "sample_size": 0,
+        "is_default": true,
+        "tips": [
+          "Use inline comments for \"why\", not \"what\"",
+          "Include runnable code examples",
+          "Document breaking changes prominently"
+        ]
+      }
+    },
+    "by_phase": {
+      "planning": {
+        "success_rate": 0.8,
+        "recommendation": "Break large features into small stories, define acceptance criteria",
+        "sample_size": 0,
+        "is_default": true,
+        "tips": [
+          "Include technical spike time for unknowns",
+          "Define \"done\" criteria upfront",
+          "Identify dependencies early"
+        ]
+      },
+      "development": {
+        "success_rate": 0.75,
+        "recommendation": "Commit early and often, write tests alongside code",
+        "sample_size": 0,
+        "is_default": true,
+        "tips": [
+          "Use meaningful commit messages",
+          "Keep pull requests small and focused",
+          "Request reviews early for big changes"
+        ]
+      },
+      "testing": {
+        "success_rate": 0.85,
+        "recommendation": "Automate tests, test edge cases, verify in staging",
+        "sample_size": 0,
+        "is_default": true,
+        "tips": [
+          "Include both happy path and error cases",
+          "Test with realistic data",
+          "Run security scans in CI"
+        ]
+      },
+      "deployment": {
+        "success_rate": 0.7,
+        "recommendation": "Use feature flags, deploy to staging first, monitor closely",
+        "sample_size": 0,
+        "is_default": true,
+        "tips": [
+          "Have runbooks for common issues",
+          "Set up alerting before deploying",
+          "Deploy during low-traffic periods for risky changes"
+        ]
+      },
+      "maintenance": {
+        "success_rate": 0.8,
+        "recommendation": "Keep dependencies updated, monitor for issues, document learnings",
+        "sample_size": 0,
+        "is_default": true,
+        "tips": [
+          "Schedule regular dependency updates",
+          "Review and clean up technical debt",
+          "Archive unused code rather than commenting out"
+        ]
+      }
+    },
+    "general": [
+      {
+        "priority": "info",
+        "message": "Learning in progress: 0/21 decisions recorded",
+        "action": "Continue recording outcomes to improve recommendations",
+        "progress": 0
+      },
+      {
+        "priority": "medium",
+        "message": "Building your decision history - recommendations will improve with more data",
+        "action": "Continue making decisions and recording outcomes"
+      },
+      {
+        "priority": "low",
+        "message": "Record outcomes for decisions to help the system learn",
+        "action": "Use decision tracker to mark decisions as success, failure, or reverted"
+      },
+      {
+        "priority": "high",
+        "message": "Overall success rate is below 50% - consider pausing to review decision processes",
+        "action": "Review recent failures and identify common issues"
+      }
+    ]
+  },
+  "scenarios": {
+    "new_feature": {
+      "name": "New Feature Development",
+      "steps": [
+        "Define acceptance criteria before coding",
+        "Break feature into small, testable increments",
+        "Write tests for core functionality first",
+        "Implement happy path, then edge cases",
+        "Document API changes and user-facing behavior"
+      ],
+      "common_pitfalls": [
+        "Starting without clear requirements",
+        "Building too much before getting feedback",
+        "Skipping tests for \"simple\" features"
+      ],
+      "success_indicators": [
+        "All acceptance criteria met",
+        "Tests passing and covering edge cases",
+        "Code reviewed and approved"
+      ],
+      "confidence": 0.75,
+      "is_default": true
+    },
+    "bug_fix": {
+      "name": "Bug Fix",
+      "steps": [
+        "Reproduce the bug reliably first",
+        "Write a failing test that demonstrates the bug",
+        "Identify root cause before implementing fix",
+        "Fix the root cause, not just symptoms",
+        "Verify fix resolves original issue without regressions"
+      ],
+      "common_pitfalls": [
+        "Fixing symptoms instead of root cause",
+        "Not writing a regression test",
+        "Rushing fix without understanding impact"
+      ],
+      "success_indicators": [
+        "Bug no longer reproducible",
+        "Regression test added and passing",
+        "No new issues introduced"
+      ],
+      "confidence": 0.75,
+      "is_default": true
+    },
+    "refactoring": {
+      "name": "Code Refactoring",
+      "steps": [
+        "Ensure comprehensive test coverage exists first",
+        "Make small, incremental changes",
+        "Run tests after each change",
+        "Keep refactoring separate from feature changes",
+        "Document architectural decisions"
+      ],
+      "common_pitfalls": [
+        "Refactoring without test coverage",
+        "Combining refactoring with feature work",
+        "Making too many changes at once"
+      ],
+      "success_indicators": [
+        "All existing tests still pass",
+        "Code metrics improved (complexity, duplication)",
+        "No behavior changes introduced"
+      ],
+      "confidence": 0.75,
+      "is_default": true
+    },
+    "testing": {
+      "name": "Writing Tests",
+      "steps": [
+        "Identify critical paths and edge cases",
+        "Write unit tests for isolated logic",
+        "Write integration tests for component interactions",
+        "Mock external dependencies consistently",
+        "Aim for meaningful coverage, not 100% coverage"
+      ],
+      "common_pitfalls": [
+        "Testing implementation details instead of behavior",
+        "Brittle tests that break on refactoring",
+        "Ignoring edge cases and error paths"
+      ],
+      "success_indicators": [
+        "Tests are reliable and not flaky",
+        "Tests run quickly (unit tests < 10s)",
+        "Tests catch real bugs during development"
+      ],
+      "confidence": 0.75,
+      "is_default": true
+    },
+    "database_migration": {
+      "name": "Database Migration",
+      "steps": [
+        "Plan migration with rollback strategy",
+        "Test migration on copy of production data",
+        "Make migrations backward compatible when possible",
+        "Deploy migration before code that depends on it",
+        "Monitor for performance issues after deployment"
+      ],
+      "common_pitfalls": [
+        "No rollback plan",
+        "Locking tables during high-traffic periods",
+        "Deploying dependent code before migration completes"
+      ],
+      "success_indicators": [
+        "Migration completes without errors",
+        "Application continues working during migration",
+        "Rollback tested and working"
+      ],
+      "confidence": 0.75,
+      "is_default": true
+    },
+    "api_development": {
+      "name": "API Development",
+      "steps": [
+        "Design API contract before implementation",
+        "Validate all inputs at the boundary",
+        "Return consistent error formats",
+        "Version APIs for breaking changes",
+        "Document endpoints with examples"
+      ],
+      "common_pitfalls": [
+        "Inconsistent error handling",
+        "Missing input validation",
+        "Breaking changes without versioning"
+      ],
+      "success_indicators": [
+        "Clear and consistent API contract",
+        "Comprehensive error handling",
+        "Documentation up to date"
+      ],
+      "confidence": 0.75,
+      "is_default": true
+    },
+    "performance": {
+      "name": "Performance Optimization",
+      "steps": [
+        "Measure before optimizing - establish baseline",
+        "Identify bottleneck using profiling tools",
+        "Focus on the biggest impact first",
+        "Measure after each change",
+        "Document performance requirements and results"
+      ],
+      "common_pitfalls": [
+        "Optimizing without measuring",
+        "Premature optimization",
+        "Optimizing non-bottlenecks"
+      ],
+      "success_indicators": [
+        "Measurable performance improvement",
+        "No functionality regressions",
+        "Performance requirements documented and met"
+      ],
+      "confidence": 0.5,
+      "is_default": true
+    },
+    "security": {
+      "name": "Security Implementation",
+      "steps": [
+        "Validate and sanitize all user inputs",
+        "Use parameterized queries for database access",
+        "Implement proper authentication and authorization",
+        "Store secrets in environment variables or vaults",
+        "Log security events without exposing sensitive data"
+      ],
+      "common_pitfalls": [
+        "Trusting user input",
+        "Hardcoding secrets",
+        "Logging sensitive information"
+      ],
+      "success_indicators": [
+        "Passes security review/scan",
+        "No secrets in codebase",
+        "Proper access controls in place"
+      ],
+      "confidence": 0.9,
+      "is_default": true
+    }
+  },
+  "using_defaults": true,
+  "blend_ratio": {
+    "defaultWeight": 1,
+    "learnedWeight": 0,
+    "phase": "cold_start"
+  },
+  "analysis_summary": {
+    "total_decisions": 0,
+    "completed_decisions": 0,
+    "success_rate": 0,
+    "top_performing_type": null,
+    "patterns_found": 2,
+    "anti_patterns_found": 8,
+    "using_defaults": true,
+    "blend_ratio": {
+      "defaultWeight": 1,
+      "learnedWeight": 0,
+      "phase": "cold_start"
+    },
+    "decisions_until_full_learning": 21
   }
-}
+}