Implement multi-location detection for pip detector

Add conditional output structure enabling pip to detect packages from both
virtual environment and system locations simultaneously. When packages exist
in multiple locations, uses nested structure with location-specific metadata.
Single location scenarios maintain existing output format for compatibility.

Key changes:
- Add _get_venv_dependencies() and _get_system_dependencies() methods
- Implement conditional output: single location vs mixed scope structure
- Update orchestrator to handle mixed scope results
- Enhance test infrastructure to support both output formats generically
- Add comprehensive ADR documenting architectural decision
- Update documentation with examples and usage patterns

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: davidkopp

docs/technical/architecture/adr/0006-multi-location-detection.md

@@ -0,0 +1,111 @@
+# ADR-0006: Multi-Location Detection for Package Managers
+
+## Status
+
+Accepted
+
+## Context
+
+Package managers can have dependencies installed in multiple locations simultaneously. For example, pip can have packages installed in both a virtual environment and the system Python installation. The original detector architecture assumed each detector would return dependencies from a single location, missing packages in other locations.
+
+**Problem**: The pip detector prioritized virtual environments over system installations, so when both existed, only virtual environment packages were detected. This prevented comprehensive dependency analysis in mixed environments.
+
+**Alternatives Considered**:
+
+1. **Split into separate detectors**: Create `pip-venv` and `pip-system` detectors
+   - ❌ Breaks existing API expectations
+   - ❌ Requires orchestrator changes
+   - ❌ Confusing output with multiple pip entries
+
+2. **Always merge dependencies**: Combine all packages into single result
+   - ❌ Loses location information for each package
+   - ❌ Cannot track location-specific hashes
+   - ❌ Reduces traceability
+
+3. **Universal nested structure**: Change all detectors to use locations format
+   - ❌ Major breaking change
+   - ❌ Unnecessary complexity for single-location detectors
+   - ❌ Verbose output when most detectors have only one location
+   - ❌ Inconsistent with the principle of simple structures for simple cases
+
+4. **Conditional output structure**: Single location uses existing format, multiple locations use nested format
+   - ✅ Preserves backward compatibility
+   - ✅ Simple structure for simple cases
+   - ✅ Maintains location-specific metadata
+   - ✅ Clear semantic distinction
+   - ✅ Efficient output format
+
+## Decision
+
+We will implement **conditional output structure** for multi-location detection:
+
+### Single Location (Existing Format)
+
+```json
+{
+  "pip": {
+    "scope": "project",
+    "location": "/path/to/venv",
+    "hash": "abc123...",
+    "dependencies": {...}
+  }
+}
+```
+
+### Multiple Locations (New Format)
+
+```json
+{
+  "pip": {
+    "scope": "mixed",
+    "locations": {
+      "/path/to/venv": {
+        "scope": "project",
+        "hash": "abc123...",
+        "dependencies": {...}
+      },
+      "/usr/lib/python3/dist-packages": {
+        "scope": "system",
+        "hash": "def456...",
+        "dependencies": {...}
+      }
+    }
+  }
+}
+```
+
+### Implementation Approach
+
+1. **Detector Interface**: No changes to `PackageManagerDetector` interface
+2. **Conditional Logic**: Detectors return nested structure only when multiple locations exist
+3. **Orchestrator Support**: Enhanced to recognize `scope: "mixed"` pattern
+4. **Generalized Pattern**: Any detector can implement multi-location detection
+
+## Consequences
+
+### Positive
+
+- ✅ **Backward Compatible**: Existing code continues to work unchanged
+- ✅ **Location Transparency**: Each package's source location is preserved
+- ✅ **Hash Preservation**: Location-specific hashes maintained
+- ✅ **Extensible**: Pattern available for future detectors (npm, maven, etc.)
+- ✅ **Self-Documenting**: Output structure indicates single vs. multi-location
+- ✅ **Efficient**: Simple structure for simple cases, complex structure only when needed
+
+### Negative
+
+- ❌ **Complexity**: Consumers must handle two different output formats
+- ❌ **Testing Overhead**: Additional test scenarios for mixed-scope handling
+
+### Neutral
+
+- **New Scope Value**: Introduces `"mixed"` as third scope option alongside `"system"` and `"project"`
+
+## Implementation Notes
+
+- **pip detector**: First implementation targeting venv + system detection
+- **Test Infrastructure**: Updated to handle both output formats generically
+- **Documentation**: Updated to explain conditional structure behavior
+- **Future Detectors**: npm could implement similar pattern for global vs. local node_modules
+
+This approach solves the multi-location problem while minimizing breaking changes and maintaining clear traceability of package origins.

docs/technical/detectors/pip_detector.md

@@ -52,15 +52,16 @@ For project-scoped dependencies, generates location-based hashes by scanning the
 
 ## Output Format
 
-**Project Scope** (with virtual environment):
+**Single Location Detection:**
 
-- Includes `scope: "project"`, installation location, and content hash
-- Contains only project-specific packages
+- **Project Scope** (venv only): `scope: "project"`, installation location, and content hash
+- **System Scope** (system only): `scope: "system"` with system-wide packages
 
-**System Scope** (no virtual environment):
+**Multi-Location Detection:**
 
-- Includes `scope: "system"`
-- Contains system-wide Python packages
+- **Mixed Scope** (venv + system): `scope: "mixed"` with nested `locations` structure
+- Each location preserves its own scope, dependencies, and location-specific hash
+- Enables tracking packages from multiple pip installations simultaneously
 
 ## Benefits
 

docs/usage/output-format.md

@@ -85,13 +85,46 @@ Project-specific package managers (pip, npm) output:
 }
 ```
 
+### Mixed-Scope Packages (Multi-Location Detection)
+
+When a detector finds packages in multiple locations (currently only pip supports this):
+
+```json
+{
+  "pip": {
+    "scope": "mixed",
+    "locations": {
+      "/root/venv/lib/python3.12/site-packages": {
+        "scope": "project",
+        "hash": "abc123...",
+        "dependencies": {
+          "venv-package": {
+            "version": "1.0.0"
+          }
+        }
+      },
+      "/usr/local/lib/python3.12/dist-packages": {
+        "scope": "system",
+        "hash": "def456...",
+        "dependencies": {
+          "system-package": {
+            "version": "2.0.0"
+          }
+        }
+      }
+    }
+  }
+}
+```
+
 ## Field Definitions
 
 ### Common Fields
 
-- **scope** - Either `"system"` or `"project"`
+- **scope** - Either `"system"`, `"project"`, or `"mixed"`
   - `system`: System-wide packages affecting the entire environment
   - `project`: Project-specific packages in a local scope
+  - `mixed`: Packages from multiple locations (pip only)
 
 - **dependencies** - Object containing all detected packages
   - Keys: Package names
@@ -246,7 +279,12 @@ system_packages = {k: v for k, v in deps.items()
 project_packages = {k: v for k, v in deps.items()
                    if not k.startswith("_") and v.get("scope") == "project"}
 
-# Count total packages
-total = sum(len(v.get("dependencies", {})) for v in deps.values()
-           if not k.startswith("_"))
+# Handle mixed-scope packages (pip multi-location)
+def count_dependencies(result):
+    if result.get("scope") == "mixed":
+        return sum(len(loc.get("dependencies", {})) for loc in result.get("locations", {}).values())
+    return len(result.get("dependencies", {}))
+
+# Count total packages (including mixed-scope)
+total = sum(count_dependencies(v) for k, v in deps.items() if not k.startswith("_"))
 ```

energy_dependency_inspector/core/orchestrator.py

@@ -98,11 +98,21 @@ def resolve_dependencies(
                             print(f"Found container info for {detector_name}")
                     else:
                         # Standard handling for other detectors
-                        if dependencies.get("dependencies") or self.debug:
+                        # Check if result has dependencies (single location) or locations (mixed scope structure)
+                        has_dependencies = dependencies.get("dependencies") or (
+                            dependencies.get("scope") == "mixed" and dependencies.get("locations")
+                        )
+                        if has_dependencies or self.debug:
                             result[detector_name] = dependencies
 
                         if self.debug:
-                            dep_count = len(dependencies.get("dependencies", {}))
+                            if dependencies.get("scope") == "mixed":
+                                # Count dependencies across all locations for mixed scope
+                                dep_count = 0
+                                for location_data in dependencies.get("locations", {}).values():
+                                    dep_count += len(location_data.get("dependencies", {}))
+                            else:
+                                dep_count = len(dependencies.get("dependencies", {}))
                             print(f"Found {dep_count} dependencies for {detector_name}")
                 else:
                     if self.debug: