switchforge 1.0.0__py3-none-any.whl

forge_core/models/project.py

@@ -0,0 +1,72 @@
+"""Pydantic models for project structure — 4-Level DAG."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+
+class Component(BaseModel):
+    """A single class/file within a layer."""
+
+    name: str
+    file_path: str
+    layer: str = ""
+    dependencies: list[str] = Field(default_factory=list)
+    is_tested: bool = False
+    existing_test_file: str = ""
+    coverage_pct: float = 0.0
+
+
+class Journey(BaseModel):
+    """A traced user journey across layers."""
+
+    name: str
+    entry_point: str
+    entry_type: str = ""  # route, consumer, job, grpc, cli
+    components: list[str] = Field(default_factory=list)  # ordered list of component names
+    priority: int = 1  # 1 = critical, 5 = low
+    description: str = ""
+
+
+class Layer(BaseModel):
+    """A functional layer within a module (e.g., controllers, services, adapters)."""
+
+    name: str
+    components: list[Component] = Field(default_factory=list)
+
+
+class Module(BaseModel):
+    """A module/package within the project."""
+
+    name: str
+    path: str
+    layers: list[Layer] = Field(default_factory=list)
+    journeys: list[Journey] = Field(default_factory=list)
+
+
+class TechStack(BaseModel):
+    """Detected technology stack."""
+
+    language: str = ""
+    framework: str = ""
+    build_tool: str = ""
+    test_framework: str = ""
+    mock_library: str = ""
+    coverage_tool: str = ""
+    source_root: str = ""
+    test_root: str = ""
+    test_command: str = ""
+    coverage_command: str = ""
+    is_monorepo: bool = False
+    modules: list[str] = Field(default_factory=list)
+
+
+class ProjectGraph(BaseModel):
+    """4-Level DAG: Project → Modules → Layers → Components."""
+
+    name: str = ""
+    root_path: str = ""
+    tech_stack: TechStack = Field(default_factory=TechStack)
+    modules: list[Module] = Field(default_factory=list)
+    total_source_files: int = 0
+    total_test_files: int = 0

forge_core/models/test_result.py

@@ -0,0 +1,93 @@
+"""Pydantic models for test results and coverage reports."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class TestFileResult(BaseModel):
+    """Result of a single generated test file."""
+
+    file_path: str
+    test_count: int = 0
+    passed: int = 0
+    failed: int = 0
+    errors: list[str] = Field(default_factory=list)
+    compile_errors: list[str] = Field(default_factory=list)
+
+
+class CoverageEntry(BaseModel):
+    """Coverage data for a single source file."""
+
+    file_path: str
+    line_coverage: float = 0.0
+    branch_coverage: float = 0.0
+    lines_covered: int = 0
+    lines_total: int = 0
+
+
+class CoverageReport(BaseModel):
+    """Aggregated coverage report."""
+
+    line_coverage: float = 0.0
+    branch_coverage: float = 0.0
+    files: list[CoverageEntry] = Field(default_factory=list)
+    total_lines_covered: int = 0
+    total_lines: int = 0
+    total_tests: int = 0
+    tests_passed: int = 0
+    tests_failed: int = 0
+
+
+class IterationResult(BaseModel):
+    """Result of a single generation iteration."""
+
+    iteration: int
+    tests_generated: list[TestFileResult] = Field(default_factory=list)
+    coverage_before: float = 0.0
+    coverage_after: float = 0.0
+    coverage_delta: float = 0.0
+    rolled_back: bool = False
+    duration_seconds: float = 0.0
+
+
+class RunReport(BaseModel):
+    """Final report for a complete Forge Core run."""
+
+    project_name: str = ""
+    project_path: str = ""
+    language: str = ""
+    framework: str = ""
+    started_at: datetime = Field(default_factory=datetime.now)
+    completed_at: Optional[datetime] = None
+    duration_seconds: float = 0.0
+
+    # Coverage
+    coverage_before: float = 0.0
+    coverage_after: float = 0.0
+    coverage_delta: float = 0.0
+
+    # Tests
+    total_tests_before: int = 0
+    total_tests_after: int = 0
+    tests_generated: int = 0
+    tests_fixed: int = 0
+    test_files_created: list[str] = Field(default_factory=list)
+
+    # Iterations
+    iterations: list[IterationResult] = Field(default_factory=list)
+    total_iterations: int = 0
+    rollbacks: int = 0
+
+    # Learning
+    patterns_discovered: int = 0
+    journeys_mapped: int = 0
+    dtos_registered: int = 0
+
+    # Metadata
+    mode: str = "full"
+    target_coverage: float = 90.0
+    production_files_changed: int = 0  # must always be 0

forge_core/orchestrator.py

@@ -0,0 +1,233 @@
+"""8-Phase pipeline orchestrator — the heart of Forge Core."""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+
+from forge_core.ai.prompts import load_learnings, load_prompt
+from forge_core.config import load_config
+from forge_core.core.agent_manager import AgentManager
+from forge_core.core.coverage import run_coverage, run_tests
+from forge_core.core.file_manager import FileManager
+from forge_core.models.config import ForgeConfig, RunMode
+from forge_core.models.dto import DTORegistry
+from forge_core.models.project import ProjectGraph
+from forge_core.models.test_result import CoverageReport, IterationResult, RunReport
+from forge_core.phases import (
+    analyze_project,
+    audit_tests,
+    compile_fix,
+    coverage_report,
+    detect_stack,
+    exclusion_scan,
+    fix_broken,
+    generate_tests,
+    journey_mapping,
+    self_learn,
+)
+from forge_core.utils import logger
+
+
+class Orchestrator:
+    """Runs the full 8-phase Forge Core pipeline."""
+
+    def __init__(self, config: ForgeConfig):
+        self.config = config
+        self.file_manager = FileManager(config.project_path)
+        self.agent_manager = AgentManager()
+        self.project_graph = ProjectGraph()
+        self.dto_registry = DTORegistry()
+        self.report = RunReport(
+            project_path=str(config.project_path),
+            mode=config.mode.value,
+            target_coverage=config.target_coverage,
+        )
+
+    def run(self) -> RunReport:
+        """Execute the full pipeline and return the run report."""
+        start_time = time.time()
+        self.report.started_at = __import__("datetime").datetime.now()
+
+        logger.banner("Forge Core v2.0", "AI-Powered Backend Test Generation Engine")
+
+        prompts_dir = Path(self.config.prompts_dir)
+
+        # Phase -1: Load past learnings
+        logger.phase_start("-1", "Loading past learnings")
+        learnings = load_learnings(
+            self.config.central_agent_path or None,
+            self.config.project_path,
+        )
+        if learnings:
+            logger.phase_done("-1", f"Loaded {len(learnings)} chars of learnings")
+        else:
+            logger.phase_done("-1", "No prior learnings found")
+
+        # Phase 1: Detect tech stack
+        logger.phase_start("1/8", "Detecting tech stack")
+        tech_stack = detect_stack.run(
+            config=self.config,
+            file_manager=self.file_manager,
+            prompts_dir=prompts_dir,
+        )
+        self.project_graph.tech_stack = tech_stack
+        self.report.language = tech_stack.language
+        self.report.framework = tech_stack.framework
+        self.report.project_name = self.config.project_path.name
+        logger.phase_done("1/8", f"{tech_stack.language}/{tech_stack.framework} detected")
+
+        # Phase 1.5: Coverage exclusion scan
+        logger.phase_start("1.5/8", "Scanning coverage exclusions")
+        exclusions = exclusion_scan.run(
+            config=self.config,
+            file_manager=self.file_manager,
+            tech_stack=tech_stack,
+        )
+        logger.phase_done("1.5/8", f"{len(exclusions)} exclusions found")
+
+        # Phase 2: Analyze architecture
+        logger.phase_start("2/8", "Analyzing architecture & building project graph")
+        self.project_graph = analyze_project.run(
+            config=self.config,
+            file_manager=self.file_manager,
+            prompts_dir=prompts_dir,
+            tech_stack=tech_stack,
+            learnings=learnings,
+        )
+        logger.phase_done(
+            "2/8",
+            f"{len(self.project_graph.modules)} modules, "
+            f"{self.project_graph.total_source_files} source files",
+        )
+
+        # Phase 2.5: Journey mapping & DTO registry
+        logger.phase_start("2.5/8", "Mapping journeys & building DTO registry")
+        self.dto_registry = journey_mapping.run(
+            config=self.config,
+            file_manager=self.file_manager,
+            prompts_dir=prompts_dir,
+            project_graph=self.project_graph,
+            learnings=learnings,
+        )
+        journey_count = sum(len(m.journeys) for m in self.project_graph.modules)
+        self.report.journeys_mapped = journey_count
+        self.report.dtos_registered = self.dto_registry.count
+        logger.phase_done(
+            "2.5/8",
+            f"{journey_count} journeys mapped, {self.dto_registry.count} DTOs registered",
+        )
+
+        # Stop here for analyze-only modes
+        if self.config.mode == RunMode.ANALYZE_ONLY:
+            logger.success("Analysis complete (analyze-only mode)")
+            self.report.duration_seconds = time.time() - start_time
+            return self.report
+
+        # Phase 3: Audit existing tests
+        logger.phase_start("3/8", "Auditing existing tests")
+        baseline = audit_tests.run(
+            config=self.config,
+            file_manager=self.file_manager,
+            prompts_dir=prompts_dir,
+            project_graph=self.project_graph,
+        )
+        self.report.coverage_before = baseline.line_coverage
+        self.report.total_tests_before = baseline.total_tests
+        logger.phase_done(
+            "3/8",
+            f"Baseline: {baseline.line_coverage:.1f}% coverage, "
+            f"{baseline.total_tests} tests ({baseline.tests_failed} failing)",
+        )
+
+        if self.config.mode == RunMode.ANALYZE_REVIEW:
+            logger.success("Analysis + review complete")
+            self.report.duration_seconds = time.time() - start_time
+            return self.report
+
+        # Phase 4: Fix broken tests
+        if baseline.tests_failed > 0:
+            logger.phase_start("4/8", "Fixing broken tests")
+            fixed_count = fix_broken.run(
+                config=self.config,
+                file_manager=self.file_manager,
+                prompts_dir=prompts_dir,
+                project_graph=self.project_graph,
+                baseline=baseline,
+                learnings=learnings,
+            )
+            self.report.tests_fixed = fixed_count
+            logger.phase_done("4/8", f"Fixed {fixed_count} broken tests")
+        else:
+            logger.phase_skip("4/8", "No broken tests found")
+
+        # Get post-fix coverage as new baseline
+        post_fix = run_coverage(
+            self.config.project_path,
+            self.project_graph.tech_stack.coverage_command,
+        )
+        best_coverage = max(baseline.line_coverage, post_fix.line_coverage)
+
+        # Phase 5: Iterative test generation
+        logger.phase_start("5/8", "Generating tests (journey-weighted)")
+        generation_result = generate_tests.run(
+            config=self.config,
+            file_manager=self.file_manager,
+            prompts_dir=prompts_dir,
+            project_graph=self.project_graph,
+            dto_registry=self.dto_registry,
+            agent_manager=self.agent_manager,
+            baseline_coverage=best_coverage,
+            learnings=learnings,
+        )
+        self.report.iterations = generation_result.iterations
+        self.report.total_iterations = len(generation_result.iterations)
+        self.report.rollbacks = sum(1 for i in generation_result.iterations if i.rolled_back)
+
+        # Phase 6: Final coverage report
+        logger.phase_start("6/8", "Generating final coverage report")
+        final = coverage_report.run(
+            config=self.config,
+            project_graph=self.project_graph,
+        )
+        self.report.coverage_after = final.line_coverage
+        self.report.coverage_delta = final.line_coverage - self.report.coverage_before
+        self.report.total_tests_after = final.total_tests
+        self.report.tests_generated = final.total_tests - self.report.total_tests_before
+        logger.phase_done("6/8", f"Final coverage: {final.line_coverage:.1f}%")
+
+        logger.coverage_table(
+            self.report.coverage_before,
+            self.report.coverage_after,
+            self.report.total_tests_before,
+            self.report.total_tests_after,
+        )
+
+        # Phase 7: Self-learn
+        logger.phase_start("7/8", "Self-learning")
+        patterns = self_learn.run(
+            config=self.config,
+            file_manager=self.file_manager,
+            prompts_dir=prompts_dir,
+            project_graph=self.project_graph,
+            report=self.report,
+            learnings=learnings,
+        )
+        self.report.patterns_discovered = patterns
+        logger.phase_done("7/8", f"{patterns} new patterns recorded")
+
+        # Finalize
+        self.report.duration_seconds = time.time() - start_time
+        self.report.completed_at = __import__("datetime").datetime.now()
+        self.report.production_files_changed = 0  # always 0
+
+        mins = self.report.duration_seconds / 60
+        logger.banner(
+            "✅ Forge Core Complete",
+            f"{self.report.coverage_before:.1f}% → {self.report.coverage_after:.1f}% "
+            f"in {mins:.1f} minutes | "
+            f"+{self.report.tests_generated} tests | "
+            f"{self.report.patterns_discovered} patterns learned",
+        )
+
+        return self.report

forge_core/phases/analyze_project.py

@@ -0,0 +1,149 @@
+"""Phase 2 — Analyze project architecture and build project graph."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from forge_core.ai.prompts import build_file_context, load_prompt
+from forge_core.ai.provider import complete
+from forge_core.core.file_manager import FileManager
+from forge_core.models.config import ForgeConfig
+from forge_core.models.project import Component, Layer, Module, ProjectGraph, TechStack
+from forge_core.utils import logger
+from forge_core.utils.tokens import split_for_context
+
+import json
+
+
+def run(
+    config: ForgeConfig,
+    file_manager: FileManager,
+    prompts_dir: Path,
+    tech_stack: TechStack,
+    learnings: str = "",
+) -> ProjectGraph:
+    """Analyze the project and build the 4-Level DAG."""
+    # Read all source files
+    source_root = tech_stack.source_root or "src"
+    source_files = file_manager.read_files(f"{source_root}/**/*")
+    test_files = file_manager.read_files(f"{tech_stack.test_root or 'src/test'}/**/*")
+
+    # Filter to code files only
+    code_extensions = _get_code_extensions(tech_stack.language)
+    source_files = {
+        k: v for k, v in source_files.items()
+        if any(k.endswith(ext) for ext in code_extensions)
+    }
+
+    graph = ProjectGraph(
+        name=config.project_path.name,
+        root_path=str(config.project_path),
+        tech_stack=tech_stack,
+        total_source_files=len(source_files),
+        total_test_files=len(test_files),
+    )
+
+    # Split files into batches that fit in context
+    batches = split_for_context(source_files, max_tokens=80_000, model=config.ai.model)
+
+    prompt = load_prompt(prompts_dir, "analyze-project")
+    system_prompt = prompt or (
+        "You are a software architect. Analyze this codebase and identify:\n"
+        "1. Modules/packages\n2. Layers (controllers, services, adapters, models)\n"
+        "3. Key components per layer\n4. Dependencies between components\n"
+        "Return JSON with modules, layers, and components."
+    )
+
+    if learnings:
+        system_prompt += f"\n\nPast learnings:\n{learnings[:2000]}"
+
+    # Process each batch
+    all_modules: dict[str, Module] = {}
+    for i, batch in enumerate(batches):
+        logger.info(f"Analyzing batch {i + 1}/{len(batches)} ({len(batch)} files)")
+        file_context = build_file_context(batch)
+
+        response = complete(
+            config=config.ai,
+            system_prompt=system_prompt,
+            user_prompt=(
+                f"Analyze these source files and return the architecture as JSON.\n\n"
+                f"Project: {config.project_path.name}\n"
+                f"Language: {tech_stack.language}\n"
+                f"Framework: {tech_stack.framework}\n\n"
+                f"{file_context}"
+            ),
+            json_mode=True,
+        )
+
+        _parse_architecture_response(response, all_modules, batch)
+
+    graph.modules = list(all_modules.values())
+    return graph
+
+
+def _parse_architecture_response(
+    response: str, modules: dict[str, Module], files: dict[str, str]
+) -> None:
+    """Parse AI's architecture analysis response and merge into modules dict."""
+    try:
+        data = json.loads(response)
+    except json.JSONDecodeError:
+        logger.warn("Failed to parse architecture JSON — using file-based fallback")
+        _fallback_from_files(modules, files)
+        return
+
+    for mod_data in data.get("modules", [data] if "layers" in data else []):
+        mod_name = mod_data.get("name", "main")
+        if mod_name not in modules:
+            modules[mod_name] = Module(name=mod_name, path=mod_data.get("path", ""))
+
+        mod = modules[mod_name]
+        for layer_data in mod_data.get("layers", []):
+            layer = Layer(name=layer_data.get("name", ""))
+            for comp_data in layer_data.get("components", []):
+                layer.components.append(
+                    Component(
+                        name=comp_data.get("name", ""),
+                        file_path=comp_data.get("file_path", ""),
+                        layer=layer.name,
+                        dependencies=comp_data.get("dependencies", []),
+                    )
+                )
+            mod.layers.append(layer)
+
+
+def _fallback_from_files(modules: dict[str, Module], files: dict[str, str]) -> None:
+    """Build a basic module structure from file paths when AI parsing fails."""
+    mod = modules.setdefault("main", Module(name="main", path="src"))
+    layers: dict[str, Layer] = {}
+
+    for path in files:
+        parts = Path(path).parts
+        layer_name = parts[2] if len(parts) > 2 else "root"
+        if layer_name not in layers:
+            layers[layer_name] = Layer(name=layer_name)
+        layers[layer_name].components.append(
+            Component(name=Path(path).stem, file_path=path, layer=layer_name)
+        )
+
+    mod.layers = list(layers.values())
+
+
+def _get_code_extensions(language: str) -> list[str]:
+    """Get relevant file extensions for a language."""
+    ext_map = {
+        "kotlin": [".kt", ".kts"],
+        "java": [".java"],
+        "python": [".py"],
+        "go": [".go"],
+        "typescript": [".ts", ".tsx"],
+        "javascript": [".js", ".jsx"],
+        "rust": [".rs"],
+        "csharp": [".cs"],
+        "c#": [".cs"],
+        "ruby": [".rb"],
+        "php": [".php"],
+        "c++": [".cpp", ".hpp", ".cc", ".h"],
+    }
+    return ext_map.get(language.lower(), [".py", ".java", ".kt", ".go", ".ts", ".js"])

forge_core/phases/audit_tests.py

@@ -0,0 +1,35 @@
+"""Phase 3 — Audit existing tests and establish baseline."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from forge_core.core.coverage import run_coverage
+from forge_core.core.file_manager import FileManager
+from forge_core.models.config import ForgeConfig
+from forge_core.models.project import ProjectGraph
+from forge_core.models.test_result import CoverageReport
+from forge_core.utils import logger
+
+
+def run(
+    config: ForgeConfig,
+    file_manager: FileManager,
+    prompts_dir: Path,
+    project_graph: ProjectGraph,
+) -> CoverageReport:
+    """Audit existing tests and get baseline coverage."""
+    tech = project_graph.tech_stack
+
+    if not tech.coverage_command:
+        logger.warn("No coverage command detected — using test command")
+        tech.coverage_command = tech.test_command
+
+    if not tech.coverage_command:
+        logger.warn("No test/coverage command found")
+        return CoverageReport()
+
+    # Run existing tests and get baseline coverage
+    report = run_coverage(config.project_path, tech.coverage_command)
+
+    return report

forge_core/phases/compile_fix.py

@@ -0,0 +1,79 @@
+"""Phase 5b — Auto compile-fix loop."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from forge_core.ai.provider import complete
+from forge_core.core.file_manager import FileManager
+from forge_core.models.config import ForgeConfig
+from forge_core.utils import logger
+from forge_core.utils.shell import run as shell_run
+
+import json
+
+
+def fix_compilation_errors(
+    config: ForgeConfig,
+    file_manager: FileManager,
+    test_command: str,
+    max_attempts: int = 3,
+) -> bool:
+    """Attempt to fix compilation errors in generated tests.
+
+    Returns True if tests compile after fixes.
+    """
+    for attempt in range(1, max_attempts + 1):
+        result = shell_run(test_command, cwd=config.project_path, timeout=300)
+
+        if result.success:
+            return True
+
+        # Check if it's a compilation error (not a test failure)
+        if not _is_compile_error(result.output):
+            return True  # Tests compiled but some failed — that's okay
+
+        logger.info(f"Compile-fix attempt {attempt}/{max_attempts}")
+
+        # Ask AI to fix
+        response = complete(
+            config=config.ai,
+            system_prompt=(
+                "Fix the compilation errors in these test files. "
+                "Return JSON with fixed_files: [{path, content}]. "
+                "Only fix imports, types, and syntax — don't change test logic."
+            ),
+            user_prompt=f"Compilation errors:\n```\n{result.output[:4000]}\n```",
+            json_mode=True,
+        )
+
+        try:
+            data = json.loads(response)
+            for fix in data.get("fixed_files", []):
+                path = fix.get("path", "")
+                content = fix.get("content", "")
+                if path and content:
+                    file_manager.write_file(path, content)
+        except json.JSONDecodeError:
+            logger.warn("Failed to parse compile-fix response")
+            continue
+
+    return False
+
+
+def _is_compile_error(output: str) -> bool:
+    """Detect if the output contains compilation errors (vs test failures)."""
+    compile_indicators = [
+        "Compilation failed",
+        "COMPILE ERROR",
+        "error: cannot find symbol",
+        "Unresolved reference",
+        "SyntaxError",
+        "IndentationError",
+        "ImportError",
+        "ModuleNotFoundError",
+        "error TS",
+        "cannot resolve",
+        "does not exist",
+    ]
+    return any(indicator.lower() in output.lower() for indicator in compile_indicators)

forge_core/phases/coverage_report.py

@@ -0,0 +1,19 @@
+"""Phase 6 — Generate final coverage report."""
+
+from __future__ import annotations
+
+from forge_core.core.coverage import run_coverage
+from forge_core.models.config import ForgeConfig
+from forge_core.models.project import ProjectGraph
+from forge_core.models.test_result import CoverageReport
+
+
+def run(config: ForgeConfig, project_graph: ProjectGraph) -> CoverageReport:
+    """Run the full test suite and generate the final coverage report."""
+    tech = project_graph.tech_stack
+    command = tech.coverage_command or tech.test_command
+
+    if not command:
+        return CoverageReport()
+
+    return run_coverage(config.project_path, command)