@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/framework-intelligence-3LORTPOX.js

@@ -0,0 +1,860 @@
+import {
+  ASTEngine
+} from "./chunk-3ZTOHHSW.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-KAET47ZL.js";
+import "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/framework-intelligence.ts
+var FrameworkIntelligence;
+((FrameworkIntelligence2) => {
+  FrameworkIntelligence2.PURE_LANGUAGE_PRIMARIES = /* @__PURE__ */ new Set([
+    "JavaScript",
+    "TypeScript",
+    "Python",
+    "Ruby",
+    "Java",
+    "C#",
+    "C++",
+    "C",
+    "Go",
+    "Rust",
+    "SQL",
+    "Dart",
+    "Objective-C",
+    "YAML",
+    "JSON",
+    "Lua",
+    "R",
+    "Haskell",
+    "Scala",
+    "Clojure",
+    "Groovy",
+    "Elixir",
+    "PHP",
+    "Swift",
+    "Kotlin",
+    "Erlang",
+    "Bash",
+    "unknown"
+  ]);
+  FrameworkIntelligence2.TOOLING_DEFAULTS = /* @__PURE__ */ new Set([
+    "stl",
+    "win32",
+    "POSIX",
+    "Standard Library",
+    "Standard C Library",
+    "test-framework",
+    "cmake"
+  ]);
+  class FrameworkDetector {
+    patterns = /* @__PURE__ */ new Map();
+    insights = [];
+    constructor() {
+      this.initializePatterns();
+    }
+    analyzeFrameworkUsage(symbols, relationships, imports, content, language) {
+      const detectedFrameworks = this.detectFrameworks(imports, content, language);
+      const patterns = [];
+      this.insights = [];
+      for (const framework of detectedFrameworks) {
+        const frameworkPatterns = this.analyzeFrameworkPatterns(
+          framework,
+          symbols,
+          relationships,
+          content,
+          language
+        );
+        patterns.push(...frameworkPatterns);
+      }
+      this.generateArchitecturalInsights(symbols, relationships, patterns, content);
+      const architecturalScore = this.calculateArchitecturalScore(patterns, this.insights);
+      return {
+        detectedFrameworks,
+        patterns,
+        insights: this.insights,
+        architecturalScore
+      };
+    }
+    detectFrameworks(imports, content, language) {
+      const frameworks = /* @__PURE__ */ new Set();
+      switch (language) {
+        case "typescript":
+        case "javascript":
+          this.detectJavaScriptFrameworks(imports, content, frameworks);
+          break;
+        case "python":
+          this.detectPythonFrameworks(imports, content, frameworks);
+          break;
+        case "java":
+          this.detectJavaFrameworks(imports, content, frameworks);
+          break;
+        case "csharp":
+        case "fsharp":
+          this.detectDotNetFrameworks(imports, content, frameworks);
+          break;
+        case "ruby":
+          this.detectRubyFrameworks(imports, content, frameworks);
+          break;
+        case "swift":
+          this.detectSwiftFrameworks(imports, content, frameworks);
+          break;
+        case "kotlin":
+          this.detectKotlinFrameworks(imports, content, frameworks);
+          break;
+        case "go":
+          this.detectGoFrameworks(imports, content, frameworks);
+          break;
+        case "rust":
+          this.detectRustFrameworks(imports, content, frameworks);
+          break;
+        case "lua":
+          this.detectLuaFrameworks(imports, content, frameworks);
+          break;
+        case "dart":
+          this.detectDartFrameworks(imports, content, frameworks);
+          break;
+        case "elixir":
+          this.detectElixirFrameworks(imports, content, frameworks);
+          break;
+        case "sql":
+          this.detectSqlFrameworks(imports, content, frameworks);
+          break;
+        case "scala":
+          this.detectScalaFrameworks(imports, content, frameworks);
+          break;
+        case "haskell":
+          this.detectHaskellFrameworks(imports, content, frameworks);
+          break;
+        case "erlang":
+          this.detectErlangFrameworks(imports, content, frameworks);
+          break;
+        case "c":
+        case "cpp":
+          this.detectCCppFrameworks(imports, content, frameworks);
+          break;
+        case "groovy":
+          this.detectGroovyFrameworks(imports, content, frameworks);
+          break;
+        default:
+          break;
+      }
+      return Array.from(frameworks);
+    }
+    detectSqlFrameworks(imports, content, frameworks) {
+      if (content.includes("{{ config(") || content.includes("{{ ref(") || content.includes("{{ source(") || content.includes("{% ") || content.includes("materialized=") || content.includes("{{ dbt_")) {
+        frameworks.add("dbt");
+      }
+      if (/--\s*(postgres|postgresql)/i.test(content) || /postgresql/i.test(content.slice(0, 500))) frameworks.add("postgresql");
+      if (/--\s*mysql/i.test(content) || /\bmysql\b/i.test(content.slice(0, 500))) frameworks.add("mysql");
+    }
+    detectDartFrameworks(imports, content, frameworks) {
+      if (this.hasImport(imports, "package:flutter") || content.includes("Flutter") || content.includes("Widget build") || content.includes("StatelessWidget") || content.includes("StatefulWidget") || content.includes("MaterialApp")) {
+        frameworks.add("flutter");
+        if (this.hasImport(imports, "package:flutter_bloc") || content.includes("BlocProvider") || content.includes("BlocBuilder")) frameworks.add("flutter-bloc");
+        if (this.hasImport(imports, "package:riverpod") || content.includes("riverpod")) frameworks.add("riverpod");
+        if (this.hasImport(imports, "package:provider") || content.includes("ChangeNotifierProvider")) frameworks.add("provider");
+        if (this.hasImport(imports, "package:dio") || content.includes("Dio()")) frameworks.add("dio");
+        if (content.includes("Get.put") || this.hasImport(imports, "package:get")) frameworks.add("getx");
+      }
+      if (this.hasImport(imports, "package:angular") || content.includes("@Component")) frameworks.add("angular-dart");
+      if (this.hasImport(imports, "package:test") || content.includes("test(") || content.includes("expect(")) frameworks.add("dart-test");
+    }
+    detectElixirFrameworks(imports, content, frameworks) {
+      if (content.includes("use Phoenix") || content.includes("Phoenix.") || this.hasImport(imports, "phoenix")) {
+        frameworks.add("phoenix");
+        if (content.includes("Ecto.") || this.hasImport(imports, "ecto")) frameworks.add("ecto");
+      }
+      if (content.includes("Plug.") || this.hasImport(imports, "plug")) frameworks.add("plug");
+      if (content.includes("defmodule") && content.includes("use ExUnit")) frameworks.add("exunit");
+      if (content.includes("Broadway") || this.hasImport(imports, "broadway")) frameworks.add("broadway");
+    }
+    detectScalaFrameworks(imports, content, frameworks) {
+      if (this.hasImport(imports, "play.api") || content.includes("extends Controller")) frameworks.add("play");
+      if (this.hasImport(imports, "akka") || content.includes("ActorSystem") || content.includes("ActorRef")) {
+        frameworks.add("akka");
+        if (content.includes("akka.http") || content.includes("Http()")) frameworks.add("akka-http");
+      }
+      if (this.hasImport(imports, "org.apache.spark") || content.includes("SparkSession")) frameworks.add("spark");
+      if (content.includes("scalatest") || this.hasImport(imports, "org.scalatest")) frameworks.add("scalatest");
+      if (this.hasImport(imports, "slick") || content.includes("TableQuery")) frameworks.add("slick");
+    }
+    detectHaskellFrameworks(imports, content, frameworks) {
+      if (this.hasImport(imports, "Yesod") || content.includes("mkYesod")) frameworks.add("yesod");
+      if (this.hasImport(imports, "Servant") || content.includes(":>")) frameworks.add("servant");
+      if (this.hasImport(imports, "Lens") || content.includes("makeLenses")) frameworks.add("lens");
+      if (content.includes("import Test.") || content.includes("QuickCheck")) frameworks.add("hspec-quickcheck");
+    }
+    detectErlangFrameworks(imports, content, frameworks) {
+      if (content.includes("-behaviour(gen_server)") || content.includes("gen_server:") || content.includes("-behaviour(supervisor)")) frameworks.add("otp");
+      if (content.includes("cowboy") || content.includes("cowboy_router")) frameworks.add("cowboy");
+      if (content.includes("rebar3") || content.includes("rebar.config")) frameworks.add("rebar3");
+      if (content.includes("meck:") || content.includes("eunit:") || content.includes("?assert")) frameworks.add("eunit");
+    }
+    detectCCppFrameworks(imports, content, frameworks) {
+      if (content.includes("#include <Q") || content.includes("QApplication") || content.includes("QWidget")) frameworks.add("qt");
+      if (content.includes("#include <boost/") || content.includes("boost::")) frameworks.add("boost");
+      if (content.includes("glfw") || content.includes("glut") || content.includes("GL/gl") || content.includes("#include <GL/")) frameworks.add("opengl");
+      if (content.includes("unittest") || content.includes("gtest") || content.includes("catch2") || content.includes("doctest")) frameworks.add("test-framework");
+      if (content.includes("cmake_minimum_required") || content.includes("project(")) frameworks.add("cmake");
+    }
+    detectGroovyFrameworks(imports, content, frameworks) {
+      if (content.includes("@Grab") || content.includes("grails") || content.includes("GrailsApp")) frameworks.add("grails");
+      if (content.includes("gradle") || content.includes("buildscript")) frameworks.add("gradle");
+      if (content.includes("spock.lang") || content.includes("expect:")) frameworks.add("spock");
+    }
+    detectJavaScriptFrameworks(imports, content, frameworks) {
+      if (this.hasImport(imports, "react") || content.includes("React.")) {
+        frameworks.add("react");
+        if (this.hasImport(imports, "next") || content.includes("getServerSideProps")) {
+          frameworks.add("nextjs");
+        }
+        if (this.hasImport(imports, "gatsby")) {
+          frameworks.add("gatsby");
+        }
+      }
+      if (this.hasImport(imports, "vue") || content.includes("createApp")) {
+        frameworks.add("vue");
+        if (this.hasImport(imports, "nuxt")) {
+          frameworks.add("nuxtjs");
+        }
+      }
+      if (this.hasImport(imports, "@angular/core") || content.includes("@Component")) {
+        frameworks.add("angular");
+      }
+      if (this.hasImport(imports, "express")) {
+        frameworks.add("express");
+      }
+      if (this.hasImport(imports, "fastify")) {
+        frameworks.add("fastify");
+      }
+      if (this.hasImport(imports, "koa")) {
+        frameworks.add("koa");
+      }
+      if (this.hasImport(imports, "jest") || content.includes("describe(")) {
+        frameworks.add("jest");
+      }
+      if (this.hasImport(imports, "mocha")) {
+        frameworks.add("mocha");
+      }
+      if (this.hasImport(imports, "redux") || this.hasImport(imports, "@reduxjs/toolkit")) {
+        frameworks.add("redux");
+      }
+      if (this.hasImport(imports, "zustand")) {
+        frameworks.add("zustand");
+      }
+    }
+    detectPythonFrameworks(imports, content, frameworks) {
+      if (this.hasModule(imports, "django") || content.includes("from django")) {
+        frameworks.add("django");
+      }
+      if (this.hasModule(imports, "flask") || content.includes("from flask")) {
+        frameworks.add("flask");
+      }
+      if (this.hasModule(imports, "fastapi")) {
+        frameworks.add("fastapi");
+      }
+      if (this.hasModule(imports, "tornado")) {
+        frameworks.add("tornado");
+      }
+      if (this.hasModule(imports, "pandas")) {
+        frameworks.add("pandas");
+      }
+      if (this.hasModule(imports, "numpy")) {
+        frameworks.add("numpy");
+      }
+      if (this.hasModule(imports, "tensorflow") || this.hasModule(imports, "tf")) {
+        frameworks.add("tensorflow");
+      }
+      if (this.hasModule(imports, "torch") || this.hasModule(imports, "pytorch")) {
+        frameworks.add("pytorch");
+      }
+      if (this.hasModule(imports, "pytest") || content.includes("def test_")) {
+        frameworks.add("pytest");
+      }
+    }
+    detectJavaFrameworks(imports, content, frameworks) {
+      if (this.hasImport(imports, "org.springframework")) {
+        frameworks.add("spring");
+        if (content.includes("@SpringBootApplication")) {
+          frameworks.add("spring-boot");
+        }
+        if (content.includes("@RestController")) {
+          frameworks.add("spring-mvc");
+        }
+      }
+      if (this.hasImport(imports, "org.junit")) {
+        frameworks.add("junit");
+      }
+      if (this.hasImport(imports, "org.mockito")) {
+        frameworks.add("mockito");
+      }
+      if (this.hasImport(imports, "javax.persistence") || this.hasImport(imports, "jakarta.persistence")) {
+        frameworks.add("jpa");
+      }
+      if (this.hasImport(imports, "org.hibernate")) {
+        frameworks.add("hibernate");
+      }
+    }
+    detectDotNetFrameworks(imports, content, frameworks) {
+      if (this.hasImport(imports, "Microsoft.AspNetCore") || content.includes("using Microsoft.AspNetCore")) {
+        frameworks.add("aspnet-core");
+      }
+      if (this.hasImport(imports, "Microsoft.EntityFrameworkCore")) {
+        frameworks.add("entity-framework");
+      }
+      if (this.hasImport(imports, "Xunit") || content.includes("[Fact]")) {
+        frameworks.add("xunit");
+      }
+      if (this.hasImport(imports, "NUnit")) {
+        frameworks.add("nunit");
+      }
+      if (content.includes("using System.Linq") || content.includes(".Where(") || content.includes(".Select(")) {
+        frameworks.add("linq");
+      }
+    }
+    detectRubyFrameworks(imports, content, frameworks) {
+      if (content.includes("require 'rails'") || content.includes("class ApplicationController")) {
+        frameworks.add("rails");
+      }
+      if (content.includes("require 'sinatra'")) {
+        frameworks.add("sinatra");
+      }
+      if (content.includes("require 'hanami'")) {
+        frameworks.add("hanami");
+      }
+      if (content.includes("require 'rspec'")) {
+        frameworks.add("rspec");
+      }
+    }
+    detectPHPFrameworks(imports, content, frameworks) {
+      if (content.includes("use Illuminate\\") || content.includes("Artisan::")) {
+        frameworks.add("laravel");
+      }
+      if (content.includes("use Symfony\\")) {
+        frameworks.add("symfony");
+      }
+      if (content.includes("class CI_Controller") || content.includes("$this->load->")) {
+        frameworks.add("codeigniter");
+      }
+    }
+    detectSwiftFrameworks(imports, content, frameworks) {
+      if (this.hasImport(imports, "UIKit")) {
+        frameworks.add("uikit");
+      }
+      if (this.hasImport(imports, "SwiftUI")) {
+        frameworks.add("swiftui");
+      }
+      if (this.hasImport(imports, "Combine")) {
+        frameworks.add("combine");
+      }
+      if (this.hasImport(imports, "NIO") || this.hasImport(imports, "NIOCore") || this.hasImport(imports, "NIOHTTP1") || content.includes("import NIO")) {
+        frameworks.add("swift-nio");
+      }
+      if (this.hasImport(imports, "Vapor") || content.includes("Vapor")) {
+        frameworks.add("vapor");
+      }
+      if (this.hasImport(imports, "XCTest") || content.includes("XCTest")) {
+        frameworks.add("xctest");
+      }
+    }
+    detectKotlinFrameworks(imports, content, frameworks) {
+      if (this.hasImport(imports, "android") || this.hasImport(imports, "androidx")) {
+        frameworks.add("android");
+      }
+      if (this.hasImport(imports, "kotlinx.coroutines")) {
+        frameworks.add("kotlin-coroutines");
+      }
+      if (this.hasImport(imports, "org.springframework")) {
+        frameworks.add("spring-kotlin");
+      }
+    }
+    detectGoFrameworks(imports, content, frameworks) {
+      if (this.hasImport(imports, "gin-gonic/gin")) {
+        frameworks.add("gin");
+      }
+      if (this.hasImport(imports, "gorilla/mux")) {
+        frameworks.add("gorilla");
+      }
+      if (this.hasImport(imports, "echo")) {
+        frameworks.add("echo");
+      }
+    }
+    detectRustFrameworks(imports, content, frameworks) {
+      if (this.hasImport(imports, "actix_web") || this.hasImport(imports, "actix-web") || content.includes("#[actix_web::main]")) {
+        frameworks.add("actix-web");
+      }
+      if (this.hasImport(imports, "axum") || content.includes("axum::")) {
+        frameworks.add("axum");
+      }
+      if (this.hasImport(imports, "warp")) {
+        frameworks.add("warp");
+      }
+      if (this.hasImport(imports, "rocket") || content.includes("#[rocket::")) {
+        frameworks.add("rocket");
+      }
+      if (this.hasImport(imports, "poem")) {
+        frameworks.add("poem");
+      }
+      if (this.hasImport(imports, "tokio") || content.includes("#[tokio::main]")) {
+        frameworks.add("tokio");
+      }
+      if (this.hasImport(imports, "async_std")) {
+        frameworks.add("async-std");
+      }
+      if (this.hasImport(imports, "rayon") || content.includes("rayon::")) {
+        frameworks.add("rayon");
+      }
+      if (this.hasImport(imports, "serde") || content.includes("#[derive(Serialize")) {
+        frameworks.add("serde");
+      }
+      if (this.hasImport(imports, "clap")) {
+        frameworks.add("clap");
+      }
+      if (this.hasImport(imports, "diesel")) {
+        frameworks.add("diesel");
+      }
+      if (this.hasImport(imports, "sqlx")) {
+        frameworks.add("sqlx");
+      }
+    }
+    detectLuaFrameworks(imports, content, frameworks) {
+      const mods = imports.map((i) => i.module).filter((m) => typeof m === "string");
+      const has = (name) => mods.some((m) => m === name || m.startsWith(`${name}.`) || m.includes(`.${name}.`));
+      if (content.includes("love.") || content.includes("love.load")) frameworks.add("Love2D");
+      if (content.includes("ngx.") || content.includes("resty.") || has("resty")) frameworks.add("OpenResty");
+      if (content.includes("game:GetService") || content.includes("Instance.new")) frameworks.add("Roblox");
+      if (content.includes("lapis.Application") || has("lapis") || /require\s*\(?\s*["']lapis(?:[./][^"']*)?["']/.test(content)) {
+        frameworks.add("Lapis");
+      }
+    }
+    analyzeFrameworkPatterns(framework, symbols, relationships, content, language) {
+      const patterns = [];
+      const frameworkPatterns = this.patterns.get(framework) || [];
+      for (const pattern of frameworkPatterns) {
+        if (this.detectPattern(pattern, symbols, relationships, content)) {
+          patterns.push(pattern);
+        }
+      }
+      return patterns;
+    }
+    detectPattern(pattern, symbols, relationships, content) {
+      switch (pattern.name) {
+        case "react-hooks-usage":
+          return this.detectReactHooks(symbols, content);
+        case "redux-store-structure":
+          return this.detectReduxStore(symbols, relationships);
+        case "django-model-relations":
+          return this.detectDjangoModels(symbols, content);
+        case "spring-dependency-injection":
+          return this.detectSpringDI(symbols, content);
+        case "rails-active-record":
+          return this.detectRailsActiveRecord(symbols, content);
+        case "swiftui-declarative":
+          return this.detectSwiftUIPatterns(symbols, content);
+        default:
+          return false;
+      }
+    }
+    detectReactHooks(symbols, content) {
+      const hookPatterns = ["useState", "useEffect", "useContext", "useReducer", "useMemo", "useCallback"];
+      return hookPatterns.some((hook) => content.includes(hook));
+    }
+    detectReduxStore(symbols, relationships) {
+      const hasStore = symbols.some((s) => s.name.includes("store") || s.name.includes("reducer"));
+      const hasActions = symbols.some((s) => s.name.includes("action") || s.name.includes("dispatch"));
+      return hasStore && hasActions;
+    }
+    detectDjangoModels(symbols, content) {
+      return symbols.some(
+        (s) => s.kind === ASTEngine.SymbolKind.Class && (content.includes("models.Model") || content.includes("class Meta:"))
+      );
+    }
+    detectSpringDI(symbols, content) {
+      const diAnnotations = ["@Autowired", "@Component", "@Service", "@Repository", "@Controller"];
+      return diAnnotations.some((annotation) => content.includes(annotation));
+    }
+    detectRailsActiveRecord(symbols, content) {
+      return symbols.some(
+        (s) => s.kind === ASTEngine.SymbolKind.Class && content.includes("< ApplicationRecord")
+      );
+    }
+    detectSwiftUIPatterns(symbols, content) {
+      const swiftuiPatterns = ["@State", "@Binding", "@ObservedObject", "@StateObject", "View"];
+      return swiftuiPatterns.some((pattern) => content.includes(pattern));
+    }
+    generateArchitecturalInsights(symbols, relationships, patterns, content) {
+      this.analyzeComplexity(symbols);
+      this.detectAntiPatterns(symbols, relationships, content);
+      this.analyzeFrameworkUsageQuality(patterns, symbols);
+      this.analyzeSecurityPatterns(symbols, content);
+    }
+    analyzeComplexity(symbols) {
+      const functions = symbols.filter((s) => s.kind === ASTEngine.SymbolKind.Function);
+      for (const func of functions) {
+        const complexity = func.metadata?.cyclomaticComplexity || 0;
+        if (complexity > 10) {
+          this.insights.push({
+            pattern: "high-complexity-function",
+            category: "performance",
+            impact: complexity > 20 ? "critical" : "high",
+            description: `Function ${func.name} has high cyclomatic complexity (${complexity})`,
+            location: func.range,
+            suggestions: [
+              "Break down into smaller functions",
+              "Extract common logic into helper methods",
+              "Consider using strategy pattern for complex conditionals"
+            ]
+          });
+        }
+      }
+    }
+    detectAntiPatterns(symbols, relationships, content) {
+      const classes = symbols.filter((s) => s.kind === ASTEngine.SymbolKind.Class);
+      const methodsByOwner = /* @__PURE__ */ new Map();
+      for (const s of symbols) {
+        if (s.kind === ASTEngine.SymbolKind.Method && s.ownerName) {
+          let list = methodsByOwner.get(s.ownerName);
+          if (!list) {
+            list = [];
+            methodsByOwner.set(s.ownerName, list);
+          }
+          list.push(s);
+        }
+      }
+      for (const cls of classes) {
+        const classMethods = methodsByOwner.get(cls.name) || [];
+        if (classMethods.length > 20) {
+          this.insights.push({
+            pattern: "god-class",
+            category: "anti_pattern",
+            impact: "high",
+            description: `Class ${cls.name} has too many methods (${classMethods.length})`,
+            location: cls.range,
+            suggestions: [
+              "Split class into smaller, focused classes",
+              "Apply Single Responsibility Principle",
+              "Extract related methods into separate classes"
+            ]
+          });
+        }
+      }
+      const functions = symbols.filter((s) => s.kind === ASTEngine.SymbolKind.Function);
+      for (const func of functions) {
+        const paramCount = func.parameters?.length || 0;
+        if (paramCount > 5) {
+          this.insights.push({
+            pattern: "long-parameter-list",
+            category: "anti_pattern",
+            impact: "medium",
+            description: `Function ${func.name} has too many parameters (${paramCount})`,
+            location: func.range,
+            suggestions: [
+              "Group related parameters into objects",
+              "Use builder pattern for complex constructors",
+              "Consider parameter objects or configuration objects"
+            ]
+          });
+        }
+      }
+    }
+    analyzeFrameworkUsageQuality(patterns, symbols) {
+      const antiPatterns = patterns.filter((p) => p.antiPattern);
+      for (const antiPattern of antiPatterns) {
+        this.insights.push({
+          pattern: antiPattern.name,
+          category: "framework_usage",
+          impact: antiPattern.severity === `warning` ? "high" : "medium",
+          description: antiPattern.description,
+          location: { startLine: 1, startColumn: 1, endLine: 1, endColumn: 1 },
+          // TODO: Get actual location
+          suggestions: antiPattern.suggestion ? [antiPattern.suggestion] : []
+        });
+      }
+    }
+    analyzeSecurityPatterns(symbols, content) {
+      if (content.includes("eval(") || content.includes("Function(")) {
+        this.insights.push({
+          pattern: "dangerous-eval-usage",
+          category: "security",
+          impact: "critical",
+          description: "Use of eval() or Function() constructor detected",
+          location: { startLine: 1, startColumn: 1, endLine: 1, endColumn: 1 },
+          suggestions: [
+            "Avoid using eval() - use JSON.parse() for data parsing",
+            "Use safer alternatives like computed properties",
+            "Validate and sanitize all inputs"
+          ]
+        });
+      }
+      if (content.includes("innerHTML") && !content.includes("DOMPurify")) {
+        this.insights.push({
+          pattern: "xss-vulnerability",
+          category: "security",
+          impact: "high",
+          description: "Potential XSS vulnerability through innerHTML usage",
+          location: { startLine: 1, startColumn: 1, endLine: 1, endColumn: 1 },
+          suggestions: [
+            "Use textContent instead of innerHTML when possible",
+            "Sanitize HTML content with libraries like DOMPurify",
+            "Use template engines with automatic escaping"
+          ]
+        });
+      }
+    }
+    calculateArchitecturalScore(patterns, insights) {
+      let score = 100;
+      for (const insight of insights) {
+        switch (insight.impact) {
+          case "critical":
+            score -= 20;
+            break;
+          case "high":
+            score -= 10;
+            break;
+          case "medium":
+            score -= 5;
+            break;
+          case "low":
+            score -= 2;
+            break;
+        }
+      }
+      const goodPatterns = patterns.filter((p) => !p.antiPattern);
+      score += goodPatterns.length * 2;
+      return Math.max(0, Math.min(100, score));
+    }
+    hasImport(imports, module) {
+      return imports.some((imp) => (imp.module || "").includes(module));
+    }
+    /**
+     * Does any import name this MODULE — matched by its root segment or in full, NOT by
+     * substring?
+     *
+     * `hasImport` above is a substring test, and it is the right test for a prefix-shaped
+     * needle like `org.springframework`. It is catastrophically wrong for a SHORT one. The
+     * concrete damage, measured over the python corpus (PY-17):
+     *
+     *   · `"platform".includes("tf")` is **true**, so the TensorFlow alias `tf` fired on every
+     *     file that imports `platform`. 34 corpus files reported `tensorflow` on the strength
+     *     of a stdlib import — including `requests/src/requests/help.py` and
+     *     `ansible/lib/ansible/modules/cron.py`, neither of which has anything to do with it.
+     *   · `"numpydoc".includes("numpy")` is **true**, so `import numpydoc` reported numpy.
+     *
+     * A two-character needle matched against a whole dotted module path matches almost
+     * anything. The fix is not to shorten the table but to match what "imports this framework"
+     * actually means: the import names the framework, optionally with a submodule —
+     * `django.db`, `starlette.applications` — so the root segment must EQUAL the framework,
+     * and a longer module that merely CONTAINS it is a different library.
+     *
+     * ADDITIVE, deliberately: `hasImport` is left exactly as it was, because it is correct for
+     * every other caller in this file and 20-odd other lanes read it. Changing a shared
+     * predicate's semantics to fix one lane's table is the move this repo's own comments keep
+     * warning against; adding the precise one and using it where precision is required is not.
+     */
+    hasModule(imports, module) {
+      const want = module.toLowerCase();
+      return imports.some((imp) => {
+        const m = (imp.module || "").toLowerCase();
+        if (m === want) return true;
+        const dot = m.indexOf(".");
+        return dot > 0 && m.slice(0, dot) === want;
+      });
+    }
+    initializePatterns() {
+      this.patterns.set("react", [
+        {
+          name: "react-hooks-usage",
+          framework: "react",
+          language: "javascript",
+          confidence: 0.9,
+          description: "Proper React Hooks usage for state management",
+          examples: ["useState", "useEffect", "useContext"]
+        },
+        {
+          name: "react-class-components",
+          framework: "react",
+          language: "javascript",
+          confidence: 0.8,
+          description: "Legacy class components detected",
+          antiPattern: true,
+          severity: "warning",
+          suggestion: "Consider migrating to functional components with hooks",
+          examples: ["class Component extends React.Component"]
+        }
+      ]);
+      this.patterns.set("redux", [
+        {
+          name: "redux-store-structure",
+          framework: "redux",
+          language: "javascript",
+          confidence: 0.9,
+          description: "Well-structured Redux store with actions and reducers",
+          examples: ["createStore", "combineReducers", "dispatch"]
+        }
+      ]);
+      this.patterns.set("django", [
+        {
+          name: "django-model-relations",
+          framework: "django",
+          language: "python",
+          confidence: 0.9,
+          description: "Django model relationships and field definitions",
+          examples: ["models.Model", "ForeignKey", "ManyToManyField"]
+        }
+      ]);
+      this.patterns.set("spring", [
+        {
+          name: "spring-dependency-injection",
+          framework: "spring",
+          language: "java",
+          confidence: 0.9,
+          description: "Proper Spring dependency injection usage",
+          examples: ["@Autowired", "@Component", "@Service"]
+        }
+      ]);
+      this.patterns.set("rails", [
+        {
+          name: "rails-active-record",
+          framework: "rails",
+          language: "ruby",
+          confidence: 0.9,
+          description: "Rails Active Record model definitions",
+          examples: ["< ApplicationRecord", "has_many", "belongs_to"]
+        }
+      ]);
+      this.patterns.set("swiftui", [
+        {
+          name: "swiftui-declarative",
+          framework: "swiftui",
+          language: "swift",
+          confidence: 0.9,
+          description: "Declarative SwiftUI view definitions",
+          examples: ["@State", "@Binding", "View"]
+        }
+      ]);
+    }
+  }
+  FrameworkIntelligence2.FrameworkDetector = FrameworkDetector;
+  const FRAMEWORK_ALIASES = {
+    spring_mvc: "spring-mvc",
+    spring_data: "spring-data",
+    spring_core: "spring-core",
+    aspnet: "aspnet-core",
+    entityframework: "entity-framework",
+    aspnet_core: "aspnet-core",
+    entity_framework: "entity-framework",
+    expressjs: "express",
+    fastifyjs: "fastify",
+    reactjs: "react",
+    vuejs: "vue",
+    next_js: "nextjs",
+    nextjs: "nextjs",
+    "flutter-bloc": "flutter-bloc",
+    kotlin_coroutines: "kotlin-coroutines",
+    spring_kotlin: "spring-kotlin",
+    actix_web: "actix-web",
+    async_std: "async-std",
+    "Play Framework": "play",
+    "play framework": "play",
+    gorilla_mux: "gorilla",
+    gorillamux: "gorilla",
+    // #932 — ONE framework, ONE name. The ruby lane publishes `"Ruby on Rails"`
+    // (`RAILS_FRAMEWORK`, whose own header records that the two-spelling defect was
+    // fixed on the patterns surface) while `detectRubyFrameworks` below adds the slug
+    // `"rails"`, and `canonicalizeDetections` dedupes by ALIASED lowercase — `"rails"`
+    // and `"ruby on rails"` are different keys, so both survived into one payload and a
+    // consumer keying on the framework string saw two frameworks. MEASURED through
+    // `ASTEngine.parseFile` on `require 'rails'` + an ActiveRecord subclass: the
+    // published list read `["Ruby on Rails","rails"]`. The alias map is where this
+    // repository already puts exactly this policy (swift's `swiftui` slug, the
+    // `aspnet`/`entityframework` pairs), so the slug is canonicalised HERE rather than
+    // in the detector: the detector's vocabulary may stay a slug table ("rspec",
+    // "nunit", "linq" all live there), but the PUBLISHED list answers to one name.
+    rails: "Ruby on Rails",
+    "ruby on rails": "Ruby on Rails"
+  };
+  function canonicalizeDetections(detections) {
+    const seen = /* @__PURE__ */ new Map();
+    for (const raw of detections) {
+      const name = (raw || "").trim();
+      if (!name) continue;
+      const aliased = FRAMEWORK_ALIASES[name.toLowerCase()] ?? name;
+      const lower = aliased.toLowerCase();
+      if (!seen.has(lower)) seen.set(lower, aliased);
+    }
+    return Array.from(seen.values());
+  }
+  function alignFrameworkPatterns(patterns, detections) {
+    const displayOf = /* @__PURE__ */ new Map();
+    for (const d of detections) {
+      const n = String(d || "").trim();
+      if (n && !displayOf.has(n.toLowerCase())) displayOf.set(n.toLowerCase(), n);
+    }
+    const out = [];
+    for (const p of patterns) {
+      const raw = typeof p?.framework === "string" ? p.framework : "";
+      if (!raw) continue;
+      const canonical = FRAMEWORK_ALIASES[raw.toLowerCase()] ?? raw;
+      const display = displayOf.get(canonical.toLowerCase()) ?? displayOf.get(raw.toLowerCase());
+      if (!display) continue;
+      out.push(display === raw ? p : { ...p, framework: display });
+    }
+    return out;
+  }
+  FrameworkIntelligence2.alignFrameworkPatterns = alignFrameworkPatterns;
+  function enhanceWithFrameworkIntelligence(result, content, language) {
+    const detector = new FrameworkDetector();
+    const analysis = detector.analyzeFrameworkUsage(
+      result.symbols,
+      result.relationships,
+      result.imports,
+      content,
+      language
+    );
+    const prev = result.metadata || {};
+    const found = /* @__PURE__ */ new Set([...prev.detectedFrameworks || [], ...analysis.detectedFrameworks]);
+    const pats = [...prev.frameworkPatterns || [], ...analysis.patterns];
+    const allDetections = canonicalizeDetections(Array.from(found));
+    const mergedDetections = allDetections.filter(
+      (f) => !FrameworkIntelligence2.PURE_LANGUAGE_PRIMARIES.has(f) && !FrameworkIntelligence2.TOOLING_DEFAULTS.has(f)
+    );
+    let primaryFramework = prev.framework;
+    const isReal = (f) => !FrameworkIntelligence2.PURE_LANGUAGE_PRIMARIES.has(f) && !FrameworkIntelligence2.TOOLING_DEFAULTS.has(f);
+    if (!primaryFramework || primaryFramework === "unknown") {
+      primaryFramework = allDetections.find(isReal) ?? allDetections.find((f) => !FrameworkIntelligence2.TOOLING_DEFAULTS.has(f)) ?? allDetections[0] ?? "unknown";
+    } else if (FrameworkIntelligence2.PURE_LANGUAGE_PRIMARIES.has(primaryFramework)) {
+      const real = allDetections.find(isReal);
+      if (real) primaryFramework = real;
+    }
+    if (primaryFramework) {
+      primaryFramework = FRAMEWORK_ALIASES[primaryFramework.toLowerCase()] ?? primaryFramework;
+    }
+    const analyzerInsights = prev.architecturalInsights;
+    const analyzerScore = prev.architecturalScore;
+    const fiFoundNothing = analysis.insights.length === 0 && (pats?.length ?? 0) === 0;
+    const keepAnalyzerInsights = fiFoundNothing && Array.isArray(analyzerInsights) && analyzerInsights.length > 0;
+    const keepAnalyzerScore = fiFoundNothing && typeof analyzerScore === "number" && analysis.architecturalScore >= 100;
+    result.metadata = {
+      ...prev,
+      framework: primaryFramework,
+      detectedFrameworks: mergedDetections,
+      // Aligned with the list this same object publishes, so the three keys are one claim.
+      frameworkPatterns: alignFrameworkPatterns(pats, mergedDetections),
+      architecturalInsights: keepAnalyzerInsights ? analyzerInsights : analysis.insights,
+      architecturalScore: keepAnalyzerScore ? analyzerScore : analysis.architecturalScore,
+      // The case follows the score that was actually kept, so the two can never
+      // disagree (`"Excellent"` from the analyzer against `"excellent"` from here
+      // was the pre-fix state for html).
+      codeQuality: (keepAnalyzerScore ? analyzerScore : analysis.architecturalScore) >= 80 ? "excellent" : (keepAnalyzerScore ? analyzerScore : analysis.architecturalScore) >= 60 ? "good" : (keepAnalyzerScore ? analyzerScore : analysis.architecturalScore) >= 40 ? "fair" : "poor"
+    };
+    return result;
+  }
+  FrameworkIntelligence2.enhanceWithFrameworkIntelligence = enhanceWithFrameworkIntelligence;
+})(FrameworkIntelligence || (FrameworkIntelligence = {}));
+export {
+  FrameworkIntelligence
+};