feat: smart integration detection with package classifier

- Add PackageClassifier with built-in dictionary (~200 popular packages)
- Hardcode Python 3.10+ stdlib list to filter out standard library imports
- Add PyPI API lookup for unknown packages (online mode, 3s timeout)
- Cache PyPI results in .wtismycode/cache/pypi.json
- Add --offline flag to skip PyPI lookups
- Classify packages into: HTTP, Database, Queue, Storage, AI/ML, Auth, Testing, Logging, Internal, Third-party
- User config integration_patterns override auto-detection
- Update renderer to show integrations grouped by category
- Update ARCHITECTURE.md template with new integration format

wtismycode-core/tests/project_analysis.rs

@@ -33,9 +33,11 @@ fn test_project_analysis() {
     // Check that we found calls
     assert!(!core_module.calls.is_empty());
     
-    // Check that integrations are detected
-    let db_integration_found = core_module.symbols.iter().any(|s| s.integrations_flags.db);
-    let http_integration_found = core_module.symbols.iter().any(|s| s.integrations_flags.http);
+    // Integration flags are now set during resolve_symbols, not parse_module
+    // So we resolve and check there
+    let project_model = analyzer.resolve_symbols(&[core_module.clone()]).unwrap();
+    let db_integration_found = project_model.symbols.values().any(|s| s.integrations_flags.db);
+    let http_integration_found = project_model.symbols.values().any(|s| s.integrations_flags.http);
     
     assert!(db_integration_found, "Database integration should be detected");
     assert!(http_integration_found, "HTTP integration should be detected");

wtismycode-core/tests/renderer_tests.rs

@@ -1,89 +1,36 @@
 //! Tests for the renderer functionality
 
 use wtismycode_core::{
-    model::{ProjectModel, Symbol, SymbolKind, IntegrationFlags, SymbolMetrics},
+    model::ProjectModel,
     renderer::Renderer,
 };
-use std::collections::HashMap;
 
 #[test]
 fn test_render_with_integrations() {
-    // Create a mock project model with integration information
     let mut project_model = ProjectModel::new();
-    
-    // Add a symbol with database integration
-    let db_symbol = Symbol {
-        id: "DatabaseManager".to_string(),
-        kind: SymbolKind::Class,
-        module_id: "test_module".to_string(),
-        file_id: "test_file.py".to_string(),
-        qualname: "DatabaseManager".to_string(),
-        signature: "class DatabaseManager".to_string(),
-        annotations: None,
-        docstring_first_line: None,
-        purpose: "test".to_string(),
-        outbound_calls: vec![],
-        inbound_calls: vec![],
-        integrations_flags: IntegrationFlags {
-            db: true,
-            http: false,
-            queue: false,
-            storage: false,
-            ai: false,
-        },
-        metrics: SymbolMetrics {
-            fan_in: 0,
-            fan_out: 0,
-            is_critical: false,
-            cycle_participant: false,
-        },
-    };
-    
-    // Add a symbol with HTTP integration
-    let http_symbol = Symbol {
-        id: "fetch_data".to_string(),
-        kind: SymbolKind::Function,
-        module_id: "test_module".to_string(),
-        file_id: "test_file.py".to_string(),
-        qualname: "fetch_data".to_string(),
-        signature: "def fetch_data()".to_string(),
-        annotations: None,
-        docstring_first_line: None,
-        purpose: "test".to_string(),
-        outbound_calls: vec![],
-        inbound_calls: vec![],
-        integrations_flags: IntegrationFlags {
-            db: false,
-            http: true,
-            queue: false,
-            storage: false,
-            ai: false,
-        },
-        metrics: SymbolMetrics {
-            fan_in: 0,
-            fan_out: 0,
-            is_critical: false,
-            cycle_participant: false,
-        },
-    };
-    
-    project_model.symbols.insert("DatabaseManager".to_string(), db_symbol);
-    project_model.symbols.insert("fetch_data".to_string(), http_symbol);
-    
-    // Initialize renderer
+
+    // Add classified integrations (new format)
+    project_model.classified_integrations.insert(
+        "Database".to_string(),
+        vec!["sqlalchemy".to_string(), "asyncpg".to_string()],
+    );
+    project_model.classified_integrations.insert(
+        "HTTP".to_string(),
+        vec!["fastapi".to_string(), "requests".to_string()],
+    );
+
     let renderer = Renderer::new();
-    
-    // Render architecture documentation
     let result = renderer.render_architecture_md(&project_model, None);
     assert!(result.is_ok());
-    
-    let rendered_content = result.unwrap();
-    println!("Rendered content:\n{}", rendered_content);
-    
-    // Check that integration sections are present
-    assert!(rendered_content.contains("## Integrations"));
-    assert!(rendered_content.contains("### Database Integrations"));
-    assert!(rendered_content.contains("### HTTP/API Integrations"));
-    assert!(rendered_content.contains("DatabaseManager in test_file.py"));
-    assert!(rendered_content.contains("fetch_data in test_file.py"));
-}
+
+    let rendered = result.unwrap();
+    println!("Rendered:\n{}", rendered);
+
+    assert!(rendered.contains("## Integrations"));
+    assert!(rendered.contains("### Database"));
+    assert!(rendered.contains("- sqlalchemy"));
+    assert!(rendered.contains("- asyncpg"));
+    assert!(rendered.contains("### HTTP"));
+    assert!(rendered.contains("- fastapi"));
+    assert!(rendered.contains("- requests"));
+}