empathy-framework 5.3.0__py3-none-any.whl → 5.4.0__py3-none-any.whl

empathy_os/project_index/scanner_parallel.py

@@ -1,291 +0,0 @@
-"""Parallel Project Scanner - Multi-core optimized file scanning.
-
-This module provides a parallel implementation of ProjectScanner using
-multiprocessing to distribute file analysis across CPU cores.
-
-Expected speedup: 3-4x on quad-core machines for large codebases (>1000 files).
-
-Usage:
-    from empathy_os.project_index.scanner_parallel import ParallelProjectScanner
-
-    scanner = ParallelProjectScanner(project_root=".", workers=4)
-    records, summary = scanner.scan()
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-import multiprocessing as mp
-from functools import partial
-from pathlib import Path
-from typing import Any
-
-from .models import FileRecord, IndexConfig, ProjectSummary
-from .scanner import ProjectScanner
-
-
-def _analyze_file_worker(
-    file_path_str: str,
-    project_root_str: str,
-    config_dict: dict[str, Any],
-    test_file_map: dict[str, str],
-) -> FileRecord | None:
-    """Worker function to analyze a single file in parallel.
-
-    This function is designed to be pickled and sent to worker processes.
-    It reconstructs necessary objects from serialized data.
-
-    Args:
-        file_path_str: String path to file to analyze
-        project_root_str: String path to project root
-        config_dict: Serialized IndexConfig as dict
-        test_file_map: Mapping of source files to test files
-
-    Returns:
-        FileRecord for the analyzed file, or None if analysis fails
-    """
-    from pathlib import Path
-
-    # Reconstruct objects
-    file_path = Path(file_path_str)
-    project_root = Path(project_root_str)
-
-    # Create a temporary scanner instance for this worker
-    # (Each worker gets its own scanner to avoid shared state issues)
-    config = IndexConfig(**config_dict)
-    scanner = ProjectScanner(project_root=project_root, config=config)
-    scanner._test_file_map = test_file_map
-
-    # Analyze the file
-    return scanner._analyze_file(file_path)
-
-
-class ParallelProjectScanner(ProjectScanner):
-    """Parallel implementation of ProjectScanner using multiprocessing.
-
-    Uses multiple CPU cores to analyze files concurrently, providing
-    significant speedup for large codebases.
-
-    Attributes:
-        workers: Number of worker processes (default: CPU count)
-
-    Performance:
-        - Sequential: ~9.2s for 3,469 files (375 files/sec)
-        - Parallel (4 workers): ~2.5s expected (1,387 files/sec)
-        - Speedup: 3.7x on quad-core machines
-
-    Memory:
-        - Each worker creates its own scanner instance
-        - Peak memory scales with worker count
-        - Expected: 2x-3x memory usage vs sequential
-
-    Example:
-        >>> scanner = ParallelProjectScanner(project_root=".", workers=4)
-        >>> records, summary = scanner.scan()
-        >>> print(f"Scanned {summary.total_files} files")
-    """
-
-    def __init__(
-        self,
-        project_root: str,
-        config: IndexConfig | None = None,
-        workers: int | None = None,
-    ):
-        """Initialize parallel scanner.
-
-        Args:
-            project_root: Root directory of project to scan
-            config: Optional configuration (uses defaults if not provided)
-            workers: Number of worker processes.
-                None (default): Use all available CPUs
-                1: Sequential processing (same as ProjectScanner)
-                N: Use N worker processes
-        """
-        super().__init__(project_root, config)
-        self.workers = workers or mp.cpu_count()
-
-    def scan(
-        self,
-        analyze_dependencies: bool = True,
-        use_parallel: bool = True,
-    ) -> tuple[list[FileRecord], ProjectSummary]:
-        """Scan the entire project using parallel processing.
-
-        Args:
-            analyze_dependencies: Whether to analyze import dependencies.
-                Set to False to skip expensive dependency graph analysis.
-                Default: True for backwards compatibility.
-            use_parallel: Whether to use parallel processing.
-                Set to False to use sequential processing.
-                Default: True.
-
-        Returns:
-            Tuple of (list of FileRecords, ProjectSummary)
-
-        Note:
-            Dependency analysis is always sequential (after file analysis).
-            Parallel processing only applies to file analysis phase.
-        """
-        records: list[FileRecord] = []
-
-        # First pass: discover all files (sequential - fast)
-        all_files = self._discover_files()
-
-        # Build test file mapping (sequential - fast)
-        self._build_test_mapping(all_files)
-
-        # Second pass: analyze each file (PARALLEL - slow)
-        if use_parallel and self.workers > 1:
-            records = self._analyze_files_parallel(all_files)
-        else:
-            # Fall back to sequential for debugging or single worker
-            for file_path in all_files:
-                record = self._analyze_file(file_path)
-                if record:
-                    records.append(record)
-
-        # Third pass: build dependency graph (sequential - already optimized)
-        if analyze_dependencies:
-            self._analyze_dependencies(records)
-
-            # Calculate impact scores (sequential - fast)
-            self._calculate_impact_scores(records)
-
-        # Determine attention needs (sequential - fast)
-        self._determine_attention_needs(records)
-
-        # Build summary (sequential - fast)
-        summary = self._build_summary(records)
-
-        return records, summary
-
-    def _analyze_files_parallel(self, all_files: list[Path]) -> list[FileRecord]:
-        """Analyze files in parallel using multiprocessing.
-
-        Args:
-            all_files: List of file paths to analyze
-
-        Returns:
-            List of FileRecords (order not guaranteed)
-
-        Note:
-            Uses multiprocessing.Pool with chunksize optimization.
-            Chunksize is calculated to balance overhead vs parallelism.
-        """
-        # Serialize configuration for workers
-        config_dict = {
-            "exclude_patterns": list(self.config.exclude_patterns),
-            "no_test_patterns": list(self.config.no_test_patterns),
-            "staleness_threshold_days": self.config.staleness_threshold_days,
-        }
-
-        # Create partial function with fixed arguments
-        analyze_func = partial(
-            _analyze_file_worker,
-            project_root_str=str(self.project_root),
-            config_dict=config_dict,
-            test_file_map=self._test_file_map,
-        )
-
-        # Calculate optimal chunksize
-        # Too small: overhead from process communication
-        # Too large: poor load balancing
-        total_files = len(all_files)
-        chunksize = max(1, total_files // (self.workers * 4))
-
-        # Process files in parallel
-        records: list[FileRecord] = []
-
-        with mp.Pool(processes=self.workers) as pool:
-            # Map file paths to string for pickling
-            file_path_strs = [str(f) for f in all_files]
-
-            # Process files in chunks
-            results = pool.map(analyze_func, file_path_strs, chunksize=chunksize)
-
-            # Filter out None results
-            records = [r for r in results if r is not None]
-
-        return records
-
-
-def compare_sequential_vs_parallel(project_root: str = ".", workers: int = 4) -> dict[str, Any]:
-    """Benchmark sequential vs parallel scanner performance.
-
-    Args:
-        project_root: Root directory to scan
-        workers: Number of worker processes for parallel version
-
-    Returns:
-        Dictionary with benchmark results:
-            - sequential_time: Time taken by sequential scan
-            - parallel_time: Time taken by parallel scan
-            - speedup: Ratio of sequential to parallel time
-            - files_scanned: Number of files scanned
-            - workers: Number of workers used
-
-    Example:
-        >>> results = compare_sequential_vs_parallel(workers=4)
-        >>> print(f"Speedup: {results['speedup']:.2f}x")
-        Speedup: 3.74x
-    """
-    import time
-
-    # Sequential scan
-    print("Running sequential scan...")
-    start = time.perf_counter()
-    scanner_seq = ProjectScanner(project_root=project_root)
-    records_seq, summary_seq = scanner_seq.scan()
-    sequential_time = time.perf_counter() - start
-    print(f"  Sequential: {sequential_time:.4f}s")
-
-    # Parallel scan
-    print(f"Running parallel scan ({workers} workers)...")
-    start = time.perf_counter()
-    scanner_par = ParallelProjectScanner(project_root=project_root, workers=workers)
-    records_par, summary_par = scanner_par.scan()
-    parallel_time = time.perf_counter() - start
-    print(f"  Parallel: {parallel_time:.4f}s")
-
-    speedup = sequential_time / parallel_time if parallel_time > 0 else 0
-
-    return {
-        "sequential_time": sequential_time,
-        "parallel_time": parallel_time,
-        "speedup": speedup,
-        "improvement_pct": ((sequential_time - parallel_time) / sequential_time * 100)
-        if sequential_time > 0
-        else 0,
-        "files_scanned": summary_seq.total_files,
-        "workers": workers,
-    }
-
-
-if __name__ == "__main__":
-
-    # Example usage and benchmark
-    print("=" * 70)
-    print("PARALLEL PROJECT SCANNER - Benchmark")
-    print("=" * 70)
-
-    # Run benchmark
-    results = compare_sequential_vs_parallel(workers=4)
-
-    print("\n" + "=" * 70)
-    print("BENCHMARK RESULTS")
-    print("=" * 70)
-    print(f"Files scanned: {results['files_scanned']:,}")
-    print(f"Workers: {results['workers']}")
-    print(f"\nSequential time: {results['sequential_time']:.4f}s")
-    print(f"Parallel time: {results['parallel_time']:.4f}s")
-    print(f"\nSpeedup: {results['speedup']:.2f}x")
-    print(f"Improvement: {results['improvement_pct']:.1f}%")
-
-    if results['speedup'] >= 2.0:
-        print("\n✅ Parallel processing is highly effective!")
-    elif results['speedup'] >= 1.5:
-        print("\n✅ Parallel processing provides moderate benefit")
-    else:
-        print("\n⚠️  Parallel processing may not be worth the overhead")
-
-    print("=" * 70)

empathy_os/prompts/__init__.py

@@ -1,61 +0,0 @@
-"""XML-Enhanced Prompt System for Empathy Framework
-
-Provides structured XML-based prompts for consistent LLM interactions
-and response parsing across workflows.
-
-Usage:
-    from empathy_os.prompts import (
-        XmlPromptConfig,
-        PromptContext,
-        XmlPromptTemplate,
-        XmlResponseParser,
-        get_template,
-    )
-
-    # Create a context
-    context = PromptContext.for_security_audit(code="...")
-
-    # Get a built-in template
-    template = get_template("security-audit")
-
-    # Render the prompt
-    prompt = template.render(context)
-
-    # Parse the response
-    parser = XmlResponseParser()
-    result = parser.parse(llm_response)
-
-    if result.success:
-        print(result.summary)
-        for finding in result.findings:
-            print(f"{finding.severity}: {finding.title}")
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-from .config import XmlPromptConfig
-from .context import PromptContext
-from .parser import Finding, ParsedResponse, XmlResponseParser
-from .registry import BUILTIN_TEMPLATES, get_template, list_templates, register_template
-from .templates import PlainTextPromptTemplate, PromptTemplate, XmlPromptTemplate
-
-__all__ = [
-    # Registry
-    "BUILTIN_TEMPLATES",
-    "Finding",
-    "ParsedResponse",
-    "PlainTextPromptTemplate",
-    # Context
-    "PromptContext",
-    # Templates
-    "PromptTemplate",
-    # Config
-    "XmlPromptConfig",
-    "XmlPromptTemplate",
-    # Parser
-    "XmlResponseParser",
-    "get_template",
-    "list_templates",
-    "register_template",
-]

empathy_os/prompts/config.py

@@ -1,77 +0,0 @@
-"""XML Prompt Configuration
-
-Provides configuration dataclass for XML-enhanced prompts.
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any
-
-
-@dataclass
-class XmlPromptConfig:
-    """Configuration for XML prompt behavior.
-
-    Attributes:
-        enabled: Whether XML prompts are enabled for this workflow/stage.
-        schema_version: XML schema version (default "1.0").
-        enforce_response_xml: If True, instruct model to respond with XML.
-        fallback_on_parse_error: If True, return raw text on XML parse failure.
-        template_name: Reference to a built-in template from BUILTIN_TEMPLATES.
-        custom_template: Inline XML template string (overrides template_name).
-        extra: Additional configuration options.
-
-    """
-
-    enabled: bool = False
-    schema_version: str = "1.0"
-    enforce_response_xml: bool = False
-    fallback_on_parse_error: bool = True
-    template_name: str | None = None
-    custom_template: str | None = None
-    extra: dict[str, Any] = field(default_factory=dict)
-
-    def merge_with(self, other: XmlPromptConfig) -> XmlPromptConfig:
-        """Merge this config with another, with 'other' taking precedence.
-
-        Useful for combining global defaults with workflow-specific overrides.
-        """
-        merged_extra = {**self.extra, **other.extra}
-        return XmlPromptConfig(
-            enabled=other.enabled if other.enabled else self.enabled,
-            schema_version=other.schema_version or self.schema_version,
-            enforce_response_xml=other.enforce_response_xml or self.enforce_response_xml,
-            fallback_on_parse_error=other.fallback_on_parse_error,
-            template_name=other.template_name or self.template_name,
-            custom_template=other.custom_template or self.custom_template,
-            extra=merged_extra,
-        )
-
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> XmlPromptConfig:
-        """Create XmlPromptConfig from a dictionary."""
-        return cls(
-            enabled=data.get("enabled", False),
-            schema_version=data.get("schema_version", "1.0"),
-            enforce_response_xml=data.get("enforce_response_xml", False),
-            fallback_on_parse_error=data.get("fallback_on_parse_error", True),
-            template_name=data.get("template_name"),
-            custom_template=data.get("custom_template"),
-            extra=data.get("extra", {}),
-        )
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary for serialization."""
-        return {
-            "enabled": self.enabled,
-            "schema_version": self.schema_version,
-            "enforce_response_xml": self.enforce_response_xml,
-            "fallback_on_parse_error": self.fallback_on_parse_error,
-            "template_name": self.template_name,
-            "custom_template": self.custom_template,
-            "extra": self.extra,
-        }

empathy_os/prompts/context.py

@@ -1,177 +0,0 @@
-"""Prompt Context
-
-Provides dataclass for structured prompt context used by XML templates.
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any
-
-
-@dataclass
-class PromptContext:
-    """Context for rendering XML prompts.
-
-    Provides a structured way to pass information to prompt templates,
-    ensuring consistency across different workflows.
-
-    Attributes:
-        role: The role the AI should assume (e.g., "security analyst").
-        goal: The primary objective (e.g., "identify vulnerabilities").
-        instructions: Step-by-step instructions for the task.
-        constraints: Rules, limits, and guidelines to follow.
-        input_type: Type of input content ("code", "diff", "document", "question").
-        input_payload: The actual content to analyze or process.
-        extra: Additional context-specific data.
-
-    """
-
-    role: str
-    goal: str
-    instructions: list[str] = field(default_factory=list)
-    constraints: list[str] = field(default_factory=list)
-    input_type: str = "code"
-    input_payload: str = ""
-    extra: dict[str, Any] = field(default_factory=dict)
-
-    def __post_init__(self) -> None:
-        """Validate context after initialization."""
-        if not self.role:
-            raise ValueError("role is required")
-        if not self.goal:
-            raise ValueError("goal is required")
-
-    @classmethod
-    def for_security_audit(
-        cls,
-        code: str,
-        findings_summary: str = "",
-        risk_level: str = "",
-        **extra: Any,
-    ) -> PromptContext:
-        """Create a context for security audit workflows.
-
-        Args:
-            code: The code to audit.
-            findings_summary: Summary of detected findings.
-            risk_level: Current risk assessment level.
-            **extra: Additional context data.
-
-        """
-        return cls(
-            role="application security engineer",
-            goal="Identify security vulnerabilities and provide remediation guidance",
-            instructions=[
-                "Analyze the code for security vulnerabilities",
-                "Focus on OWASP Top 10 categories",
-                "Provide severity ratings (critical, high, medium, low)",
-                "Include specific file and line references where applicable",
-                "Suggest concrete remediation steps for each finding",
-            ],
-            constraints=[
-                "Be specific and actionable",
-                "Prioritize findings by severity",
-                "Include code examples for fixes when helpful",
-            ],
-            input_type="code",
-            input_payload=code,
-            extra={
-                "findings_summary": findings_summary,
-                "risk_level": risk_level,
-                **extra,
-            },
-        )
-
-    @classmethod
-    def for_code_review(
-        cls,
-        code_or_diff: str,
-        input_type: str = "code",
-        context: str = "",
-        **extra: Any,
-    ) -> PromptContext:
-        """Create a context for code review workflows.
-
-        Args:
-            code_or_diff: The code or diff to review.
-            input_type: Either "code" or "diff".
-            context: Additional context about the change.
-            **extra: Additional context data.
-
-        """
-        return cls(
-            role="senior staff engineer performing code review",
-            goal="Review code quality, identify issues, and suggest improvements",
-            instructions=[
-                "Identify bugs, security risks, and performance issues",
-                "Evaluate code structure and maintainability",
-                "Check for missing error handling",
-                "Identify tests that should be added or updated",
-                "Suggest improvements while respecting existing patterns",
-            ],
-            constraints=[
-                "Be direct and technical",
-                "Reference specific files and lines",
-                "Keep feedback actionable",
-                "Maximum 500 words",
-            ],
-            input_type=input_type,
-            input_payload=code_or_diff,
-            extra={
-                "context": context,
-                **extra,
-            },
-        )
-
-    @classmethod
-    def for_research(
-        cls,
-        question: str,
-        context: str = "",
-        **extra: Any,
-    ) -> PromptContext:
-        """Create a context for research/synthesis workflows.
-
-        Args:
-            question: The research question to answer.
-            context: Related context or codebase information.
-            **extra: Additional context data.
-
-        """
-        return cls(
-            role="staff engineer conducting technical research",
-            goal="Research and synthesize information to answer the question",
-            instructions=[
-                "Explain key concepts and tradeoffs",
-                "Relate the answer to the provided context if relevant",
-                "Propose 1-2 concrete next steps or decisions",
-            ],
-            constraints=[
-                "Be clear and pragmatic",
-                "3-5 short paragraphs",
-                "Focus on actionable insights",
-            ],
-            input_type="question",
-            input_payload=question,
-            extra={
-                "context": context,
-                **extra,
-            },
-        )
-
-    def with_extra(self, **kwargs: Any) -> PromptContext:
-        """Return a new context with additional extra fields."""
-        new_extra = {**self.extra, **kwargs}
-        return PromptContext(
-            role=self.role,
-            goal=self.goal,
-            instructions=self.instructions.copy(),
-            constraints=self.constraints.copy(),
-            input_type=self.input_type,
-            input_payload=self.input_payload,
-            extra=new_extra,
-        )