switchforge 1.0.0__py3-none-any.whl

forge_core/phases/detect_stack.py

@@ -0,0 +1,66 @@
+"""Phase 1 — Detect tech stack by reading build files."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from forge_core.ai.prompts import build_file_context, load_prompt
+from forge_core.ai.structured import extract
+from forge_core.core.file_manager import FileManager
+from forge_core.models.config import ForgeConfig
+from forge_core.models.project import TechStack
+
+# Build files to check for each language ecosystem
+BUILD_FILES = [
+    "build.gradle", "build.gradle.kts", "settings.gradle", "settings.gradle.kts",
+    "pom.xml",
+    "package.json", "tsconfig.json",
+    "pyproject.toml", "setup.py", "requirements.txt", "Pipfile",
+    "go.mod", "go.sum",
+    "Cargo.toml",
+    "*.csproj", "*.sln",
+    "Gemfile",
+    "composer.json",
+    "Makefile", "CMakeLists.txt",
+]
+
+
+def run(
+    config: ForgeConfig,
+    file_manager: FileManager,
+    prompts_dir: Path,
+) -> TechStack:
+    """Detect the project's technology stack."""
+    # Read build/config files
+    build_contents: dict[str, str] = {}
+    for pattern in BUILD_FILES:
+        if "*" in pattern:
+            found = file_manager.read_files(pattern)
+            build_contents.update(found)
+        else:
+            content = file_manager.read_file(pattern)
+            if content:
+                build_contents[pattern] = content
+
+    # Also check for common directory structures
+    project_path = config.project_path
+    dir_hints: list[str] = []
+    for d in ["src/main", "src/test", "src", "lib", "tests", "test", "spec", "app"]:
+        if (project_path / d).exists():
+            dir_hints.append(d)
+
+    # Use AI to analyze
+    prompt = load_prompt(prompts_dir, "detect-tech-stack")
+    file_context = build_file_context(build_contents)
+    user_prompt = (
+        f"Analyze this project's build files and detect the tech stack.\n\n"
+        f"Directory structure hints: {', '.join(dir_hints)}\n\n"
+        f"{file_context}"
+    )
+
+    return extract(
+        config=config.ai,
+        system_prompt=prompt or "You are a build system analyst. Detect the tech stack.",
+        user_prompt=user_prompt,
+        response_model=TechStack,
+    )

forge_core/phases/exclusion_scan.py

@@ -0,0 +1,74 @@
+"""Phase 1.5 — Coverage exclusion scan."""
+
+from __future__ import annotations
+
+from forge_core.core.file_manager import FileManager
+from forge_core.models.config import ForgeConfig
+from forge_core.models.project import TechStack
+from forge_core.utils import logger
+
+
+def run(
+    config: ForgeConfig,
+    file_manager: FileManager,
+    tech_stack: TechStack,
+) -> list[str]:
+    """Scan for coverage exclusions in build/config files.
+
+    Returns list of excluded package/path patterns.
+    """
+    exclusions: list[str] = []
+
+    # Check common exclusion locations based on language
+    if tech_stack.language.lower() in ("kotlin", "java"):
+        _scan_gradle_exclusions(file_manager, exclusions)
+        _scan_jacoco_exclusions(file_manager, exclusions)
+    elif tech_stack.language.lower() == "python":
+        _scan_pytest_exclusions(file_manager, exclusions)
+    elif tech_stack.language.lower() == "go":
+        _scan_go_exclusions(file_manager, exclusions)
+
+    if exclusions:
+        logger.info(f"Exclusions: {', '.join(exclusions[:5])}")
+
+    return exclusions
+
+
+def _scan_gradle_exclusions(fm: FileManager, exclusions: list[str]) -> None:
+    """Scan build.gradle for jacocoTestReport exclusions."""
+    for f in ["build.gradle", "build.gradle.kts"]:
+        content = fm.read_file(f)
+        if "classDirectories" in content and "exclude" in content:
+            # Extract excluded patterns
+            import re
+
+            for m in re.finditer(r"""exclude\s*\(\s*["'](.+?)["']""", content):
+                exclusions.append(m.group(1))
+
+
+def _scan_jacoco_exclusions(fm: FileManager, exclusions: list[str]) -> None:
+    """Scan jacoco config for exclusions."""
+    content = fm.read_file("jacoco.exec")
+    # JaCoCo exclusions are typically in build files, handled above
+
+
+def _scan_pytest_exclusions(fm: FileManager, exclusions: list[str]) -> None:
+    """Scan pyproject.toml or .coveragerc for omit patterns."""
+    import re
+
+    for f in ["pyproject.toml", ".coveragerc", "setup.cfg"]:
+        content = fm.read_file(f)
+        if content:
+            for m in re.finditer(r"omit\s*=\s*(.+?)(?:\n\[|\n\n|\Z)", content, re.DOTALL):
+                paths = m.group(1).strip().split("\n")
+                exclusions.extend(p.strip() for p in paths if p.strip())
+
+
+def _scan_go_exclusions(fm: FileManager, exclusions: list[str]) -> None:
+    """Go doesn't have standard exclusion configs — check Makefile."""
+    content = fm.read_file("Makefile")
+    if content:
+        import re
+
+        for m in re.finditer(r"-coverprofile.*?(?:grep\s+-v\s+)(.+?)(?:\s|$)", content):
+            exclusions.append(m.group(1))

forge_core/phases/fix_broken.py

@@ -0,0 +1,83 @@
+"""Phase 4 — Fix broken tests."""
+
+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 ProjectGraph
+from forge_core.models.test_result import CoverageReport
+from forge_core.utils import logger
+from forge_core.utils.shell import run as shell_run
+
+
+def run(
+    config: ForgeConfig,
+    file_manager: FileManager,
+    prompts_dir: Path,
+    project_graph: ProjectGraph,
+    baseline: CoverageReport,
+    learnings: str = "",
+) -> int:
+    """Fix broken tests. Returns count of tests fixed."""
+    tech = project_graph.tech_stack
+
+    # Run tests to get failure output
+    result = shell_run(tech.test_command, cwd=config.project_path, timeout=300)
+    if result.success:
+        return 0  # No broken tests
+
+    # Read failing test files
+    test_root = tech.test_root or "src/test"
+    test_files = file_manager.read_files(f"{test_root}/**/*")
+
+    prompt = load_prompt(prompts_dir, "fix-broken-tests")
+    system_prompt = prompt or (
+        "You are a test repair specialist. Fix the broken tests based on the error output.\n"
+        "Rules: never modify production code, never delete passing tests.\n"
+        "Return JSON with fixed_files: [{path, content}]."
+    )
+
+    if learnings:
+        system_prompt += f"\n\nPast learnings:\n{learnings[:2000]}"
+
+    file_context = build_file_context(test_files, max_files=30)
+
+    response = complete(
+        config=config.ai,
+        system_prompt=system_prompt,
+        user_prompt=(
+            f"Fix the broken tests. Here is the error output:\n\n"
+            f"```\n{result.output[:5000]}\n```\n\n"
+            f"Test files:\n{file_context}"
+        ),
+        json_mode=True,
+    )
+
+    # Parse and write fixed files
+    import json
+
+    fixed_count = 0
+    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)
+                fixed_count += 1
+    except json.JSONDecodeError:
+        logger.warn("Failed to parse fix response")
+
+    # Verify fixes don't break more tests
+    verify = shell_run(tech.test_command, cwd=config.project_path, timeout=300)
+    if not verify.success:
+        logger.warn("Fixes introduced new failures — rolling back")
+        file_manager.rollback()
+        return 0
+
+    file_manager.checkpoint()
+    return fixed_count

forge_core/phases/generate_tests.py

@@ -0,0 +1,218 @@
+"""Phase 5 — Iterative test generation with journey-weighted prioritization."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+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.agent_manager import AgentManager
+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.dto import DTORegistry
+from forge_core.models.project import Component, ProjectGraph
+from forge_core.models.test_result import IterationResult, TestFileResult
+from forge_core.utils import logger
+
+
+@dataclass
+class GenerationResult:
+    """Aggregate result of the generation loop."""
+
+    iterations: list[IterationResult] = field(default_factory=list)
+    total_tests_generated: int = 0
+
+
+def run(
+    config: ForgeConfig,
+    file_manager: FileManager,
+    prompts_dir: Path,
+    project_graph: ProjectGraph,
+    dto_registry: DTORegistry,
+    agent_manager: AgentManager,
+    baseline_coverage: float,
+    learnings: str = "",
+) -> GenerationResult:
+    """Run the iterative test generation loop."""
+    result = GenerationResult()
+    tech = project_graph.tech_stack
+
+    # Build prioritized target list (journey-weighted)
+    targets = _prioritize_targets(project_graph)
+    if not targets:
+        logger.warn("No generation targets found")
+        return result
+
+    logger.info(f"Targets: {len(targets)} components to test")
+
+    # Load prompts
+    write_prompt = load_prompt(prompts_dir, "write-unit-tests")
+    system_prompt = write_prompt or (
+        "You are a backend test engineer. Write unit tests for the given source code.\n"
+        "Rules: idiomatic tests, proper mocking, no production code changes.\n"
+        "Return JSON with test_files: [{path, content}]."
+    )
+
+    if learnings:
+        system_prompt += f"\n\nPast learnings:\n{learnings[:2000]}"
+
+    # Add DTO registry context
+    if dto_registry.count > 0:
+        dto_context = _build_dto_context(dto_registry)
+        system_prompt += f"\n\nDTO Registry (use these exact constructors):\n{dto_context}"
+
+    # Iterative loop
+    current_coverage = baseline_coverage
+    best_coverage = baseline_coverage
+    stall_count = 0
+    batch_size = 5
+
+    for iteration in range(1, config.max_iterations + 1):
+        batch_start = (iteration - 1) * batch_size
+        batch_targets = targets[batch_start : batch_start + batch_size]
+
+        if not batch_targets:
+            logger.info(f"All targets covered after {iteration - 1} iterations")
+            break
+
+        logger.info(f"Iteration {iteration}/{config.max_iterations}: {len(batch_targets)} targets")
+
+        # Register agent scope
+        scope_id = f"gen-iter-{iteration}"
+        agent_manager.register(scope_id, [t.file_path for t in batch_targets])
+
+        # Read source files for this batch
+        batch_files: dict[str, str] = {}
+        for target in batch_targets:
+            content = file_manager.read_file(target.file_path)
+            if content:
+                batch_files[target.file_path] = content
+
+        file_context = build_file_context(batch_files)
+
+        # Generate tests
+        response = complete(
+            config=config.ai,
+            system_prompt=system_prompt,
+            user_prompt=(
+                f"Write unit tests for these source files.\n\n"
+                f"Language: {tech.language}\n"
+                f"Framework: {tech.framework}\n"
+                f"Test framework: {tech.test_framework}\n"
+                f"Mock library: {tech.mock_library}\n\n"
+                f"{file_context}"
+            ),
+            json_mode=True,
+            max_tokens=8192,
+        )
+
+        # Parse and write test files
+        iter_result = IterationResult(iteration=iteration, coverage_before=current_coverage)
+        tests_written = _write_generated_tests(response, file_manager, iter_result)
+
+        if tests_written == 0:
+            agent_manager.record_error(scope_id, "no_tests_generated")
+            action = agent_manager.heartbeat(scope_id)
+            if action in ("split", "terminate"):
+                logger.warn(f"Agent {scope_id}: {action} — moving to next batch")
+                continue
+
+        # Run coverage check
+        coverage = run_coverage(config.project_path, tech.coverage_command)
+        iter_result.coverage_after = coverage.line_coverage
+        iter_result.coverage_delta = coverage.line_coverage - current_coverage
+
+        # Rollback protection
+        if coverage.line_coverage < best_coverage:
+            logger.warn(
+                f"Coverage dropped {best_coverage:.1f}% → {coverage.line_coverage:.1f}% — rolling back"
+            )
+            file_manager.rollback()
+            iter_result.rolled_back = True
+        else:
+            file_manager.checkpoint()
+            agent_manager.record_progress(scope_id)
+            if coverage.line_coverage > best_coverage:
+                best_coverage = coverage.line_coverage
+            current_coverage = coverage.line_coverage
+
+        agent_manager.complete(scope_id)
+        result.iterations.append(iter_result)
+
+        # Early exit if target reached
+        if current_coverage >= config.target_coverage:
+            logger.success(f"Target coverage {config.target_coverage}% reached!")
+            break
+
+        # Stall detection
+        if iter_result.coverage_delta < 0.5:
+            stall_count += 1
+            if stall_count >= 3:
+                logger.warn("Coverage stalled for 3 iterations — stopping")
+                break
+        else:
+            stall_count = 0
+
+    return result
+
+
+def _prioritize_targets(graph: ProjectGraph) -> list[Component]:
+    """Build journey-weighted priority list of components to test."""
+    all_components: list[Component] = []
+
+    # Collect all components
+    for module in graph.modules:
+        # Components in journeys get highest priority
+        journey_components = set()
+        for journey in module.journeys:
+            journey_components.update(journey.components)
+
+        for layer in module.layers:
+            for comp in layer.components:
+                if not comp.is_tested:
+                    # Boost priority for journey components
+                    if comp.name in journey_components:
+                        all_components.insert(0, comp)
+                    else:
+                        all_components.append(comp)
+
+    return all_components
+
+
+def _build_dto_context(registry: DTORegistry) -> str:
+    """Build a compact DTO reference for the system prompt."""
+    lines: list[str] = []
+    for entry in list(registry.entries.values())[:50]:  # cap at 50 DTOs
+        params = ", ".join(f"{p.name}: {p.type}" for p in entry.params)
+        lines.append(f"- {entry.class_name}({params})")
+    return "\n".join(lines)
+
+
+def _write_generated_tests(
+    response: str, file_manager: FileManager, iter_result: IterationResult
+) -> int:
+    """Parse AI response and write test files. Returns count written."""
+    count = 0
+    try:
+        data = json.loads(response)
+    except json.JSONDecodeError:
+        logger.warn("Failed to parse test generation JSON")
+        return 0
+
+    for test in data.get("test_files", []):
+        path = test.get("path", "")
+        content = test.get("content", "")
+        if path and content:
+            file_manager.write_file(path, content)
+            iter_result.tests_generated.append(
+                TestFileResult(
+                    file_path=path,
+                    test_count=content.count("@Test") + content.count("def test_") + content.count("func Test"),
+                )
+            )
+            count += 1
+
+    return count

forge_core/phases/journey_mapping.py

@@ -0,0 +1,120 @@
+"""Phase 2.5 — Journey mapping & DTO registry building."""
+
+from __future__ import annotations
+
+import json
+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.dto import DTOEntry, DTOParam, DTORegistry
+from forge_core.models.project import Journey, ProjectGraph
+from forge_core.utils import logger
+
+
+def run(
+    config: ForgeConfig,
+    file_manager: FileManager,
+    prompts_dir: Path,
+    project_graph: ProjectGraph,
+    learnings: str = "",
+) -> DTORegistry:
+    """Map journeys and build the DTO registry."""
+    registry = DTORegistry()
+    tech = project_graph.tech_stack
+
+    # Read all source files for journey tracing
+    source_root = tech.source_root or "src"
+    source_files = file_manager.read_files(f"{source_root}/**/*")
+    code_exts = _code_exts(tech.language)
+    source_files = {k: v for k, v in source_files.items() if any(k.endswith(e) for e in code_exts)}
+
+    prompt = load_prompt(prompts_dir, "journey-mapping")
+    system_prompt = prompt or (
+        "You are a senior backend engineer. Trace all user journeys through this codebase.\n"
+        "For each journey: identify entry point, trace through all layers, catalog every DTO.\n"
+        "Return JSON with journeys and dto_registry."
+    )
+
+    if learnings:
+        system_prompt += f"\n\nPast learnings:\n{learnings[:2000]}"
+
+    file_context = build_file_context(source_files, max_files=80)
+
+    response = complete(
+        config=config.ai,
+        system_prompt=system_prompt,
+        user_prompt=(
+            f"Trace all user journeys and catalog all DTOs in this project.\n\n"
+            f"Project: {config.project_path.name}\n"
+            f"Language: {tech.language}\n"
+            f"Framework: {tech.framework}\n\n"
+            f"{file_context}"
+        ),
+        json_mode=True,
+        max_tokens=8192,
+    )
+
+    _parse_journey_response(response, project_graph, registry)
+
+    return registry
+
+
+def _parse_journey_response(
+    response: str, graph: ProjectGraph, registry: DTORegistry
+) -> None:
+    """Parse AI response into journeys and DTO registry."""
+    try:
+        data = json.loads(response)
+    except json.JSONDecodeError:
+        logger.warn("Failed to parse journey mapping JSON")
+        return
+
+    # Parse journeys
+    for j_data in data.get("journeys", []):
+        journey = Journey(
+            name=j_data.get("name", ""),
+            entry_point=j_data.get("entry_point", ""),
+            entry_type=j_data.get("entry_type", ""),
+            components=j_data.get("components", []),
+            priority=j_data.get("priority", 3),
+            description=j_data.get("description", ""),
+        )
+        # Add to first module (or create default)
+        if graph.modules:
+            graph.modules[0].journeys.append(journey)
+
+    # Parse DTOs
+    for dto_data in data.get("dto_registry", data.get("dtos", [])):
+        params = [
+            DTOParam(
+                name=p.get("name", ""),
+                type=p.get("type", ""),
+                default=p.get("default", ""),
+                nullable=p.get("nullable", False),
+            )
+            for p in dto_data.get("params", dto_data.get("constructor_params", []))
+        ]
+        entry = DTOEntry(
+            class_name=dto_data.get("class_name", dto_data.get("name", "")),
+            package=dto_data.get("package", ""),
+            file_path=dto_data.get("file_path", ""),
+            params=params,
+            has_builder=dto_data.get("has_builder", False),
+            has_factory=dto_data.get("has_factory", False),
+            nested_dtos=dto_data.get("nested_dtos", []),
+            used_in_journeys=dto_data.get("used_in_journeys", []),
+            used_in_layers=dto_data.get("used_in_layers", []),
+        )
+        registry.register(entry)
+
+
+def _code_exts(language: str) -> list[str]:
+    ext_map = {
+        "kotlin": [".kt"], "java": [".java"], "python": [".py"],
+        "go": [".go"], "typescript": [".ts"], "javascript": [".js"],
+        "rust": [".rs"], "csharp": [".cs"], "ruby": [".rb"], "php": [".php"],
+    }
+    return ext_map.get(language.lower(), [".py", ".java", ".kt"])

forge_core/phases/self_learn.py

@@ -0,0 +1,93 @@
+"""Phase 7 — Self-learning: record patterns to LEARNINGS.md."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from pathlib import Path
+
+from forge_core.ai.prompts import 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 ProjectGraph
+from forge_core.models.test_result import RunReport
+from forge_core.utils import logger
+
+
+def run(
+    config: ForgeConfig,
+    file_manager: FileManager,
+    prompts_dir: Path,
+    project_graph: ProjectGraph,
+    report: RunReport,
+    learnings: str = "",
+) -> int:
+    """Record patterns learned from this run. Returns count of new patterns."""
+    prompt = load_prompt(prompts_dir, "self-learn")
+    system_prompt = prompt or (
+        "You are a learning engine. Analyze the test generation run and extract reusable patterns.\n"
+        "Focus on: mocking patterns, assertion styles, framework quirks, error patterns.\n"
+        "Return JSON with patterns: [{name, description, language, example}]."
+    )
+
+    # Build run summary for AI
+    run_summary = (
+        f"Project: {report.project_name}\n"
+        f"Language: {report.language}, Framework: {report.framework}\n"
+        f"Coverage: {report.coverage_before:.1f}% → {report.coverage_after:.1f}%\n"
+        f"Tests generated: {report.tests_generated}, Fixed: {report.tests_fixed}\n"
+        f"Iterations: {report.total_iterations}, Rollbacks: {report.rollbacks}\n"
+        f"Journeys mapped: {report.journeys_mapped}, DTOs: {report.dtos_registered}\n"
+    )
+
+    if learnings:
+        run_summary += f"\nExisting learnings (don't duplicate):\n{learnings[:3000]}"
+
+    response = complete(
+        config=config.ai,
+        system_prompt=system_prompt,
+        user_prompt=f"Extract patterns from this run:\n\n{run_summary}",
+        json_mode=True,
+    )
+
+    # Parse patterns
+    new_patterns: list[dict] = []
+    try:
+        data = json.loads(response)
+        new_patterns = data.get("patterns", [])
+    except json.JSONDecodeError:
+        logger.warn("Failed to parse self-learn response")
+        return 0
+
+    if not new_patterns:
+        return 0
+
+    # Append to LEARNINGS.md
+    learnings_path = config.project_path / "LEARNINGS.md"
+    _append_learnings(learnings_path, report, new_patterns)
+
+    # Sync to central hub if configured
+    if config.central_agent_path:
+        central_path = Path(config.central_agent_path) / "LEARNINGS.md"
+        _append_learnings(central_path, report, new_patterns)
+
+    return len(new_patterns)
+
+
+def _append_learnings(
+    path: Path, report: RunReport, patterns: list[dict]
+) -> None:
+    """Append new patterns to a LEARNINGS.md file."""
+    existing = path.read_text(encoding="utf-8") if path.exists() else ""
+
+    section = f"\n\n## Run: {report.project_name} ({datetime.now().strftime('%Y-%m-%d %H:%M')})\n"
+    section += f"- Coverage: {report.coverage_before:.1f}% → {report.coverage_after:.1f}%\n"
+    section += f"- Language: {report.language}/{report.framework}\n\n"
+
+    for p in patterns:
+        name = p.get("name", "Pattern")
+        desc = p.get("description", "")
+        section += f"### {name}\n{desc}\n\n"
+
+    path.write_text(existing + section, encoding="utf-8")