switchforge 1.0.0__py3-none-any.whl

forge_core/core/agent_manager.py

@@ -0,0 +1,111 @@
+"""Agent manager — heartbeat monitoring, stuck detection, scope splitting."""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+
+from forge_core.utils import logger
+
+
+@dataclass
+class AgentState:
+    """Tracks the state of a generation agent."""
+
+    scope_id: str
+    target_files: list[str]
+    started_at: float = field(default_factory=time.time)
+    tool_calls: int = 0
+    last_progress_at: float = field(default_factory=time.time)
+    errors: list[str] = field(default_factory=list)
+    consecutive_same_error: int = 0
+    last_error: str = ""
+    completed: bool = False
+
+
+class AgentManager:
+    """Manages agent lifecycle with heartbeat and stuck detection.
+
+    Rules from copilot-instructions.md:
+    - Heartbeat every 10 tool calls
+    - Fruitless detection: same error 3x
+    - Auto-termination after 20 fruitless calls
+    - Scope splitting for stuck agents
+    """
+
+    MAX_FRUITLESS_CALLS = 20
+    SAME_ERROR_THRESHOLD = 3
+    HEARTBEAT_INTERVAL = 10
+
+    def __init__(self):
+        self._agents: dict[str, AgentState] = {}
+
+    def register(self, scope_id: str, target_files: list[str]) -> AgentState:
+        """Register a new agent scope."""
+        state = AgentState(scope_id=scope_id, target_files=target_files)
+        self._agents[scope_id] = state
+        return state
+
+    def heartbeat(self, scope_id: str) -> str:
+        """Record a heartbeat. Returns action: 'continue', 'split', or 'terminate'."""
+        state = self._agents.get(scope_id)
+        if not state:
+            return "terminate"
+
+        state.tool_calls += 1
+
+        # Check fruitless threshold
+        if state.consecutive_same_error >= self.SAME_ERROR_THRESHOLD:
+            logger.warn(f"Agent {scope_id}: same error {state.consecutive_same_error}x — splitting scope")
+            return "split"
+
+        if state.tool_calls >= self.MAX_FRUITLESS_CALLS and not state.last_progress_at > state.started_at:
+            logger.warn(f"Agent {scope_id}: {state.tool_calls} calls with no progress — terminating")
+            return "terminate"
+
+        # Periodic heartbeat log
+        if state.tool_calls % self.HEARTBEAT_INTERVAL == 0:
+            elapsed = time.time() - state.started_at
+            logger.info(f"Agent {scope_id}: {state.tool_calls} calls, {elapsed:.0f}s elapsed")
+
+        return "continue"
+
+    def record_error(self, scope_id: str, error: str) -> None:
+        """Record an error from an agent."""
+        state = self._agents.get(scope_id)
+        if not state:
+            return
+
+        state.errors.append(error)
+        if error == state.last_error:
+            state.consecutive_same_error += 1
+        else:
+            state.consecutive_same_error = 1
+            state.last_error = error
+
+    def record_progress(self, scope_id: str) -> None:
+        """Record that an agent made progress (wrote a file, coverage increased)."""
+        state = self._agents.get(scope_id)
+        if state:
+            state.last_progress_at = time.time()
+            state.consecutive_same_error = 0
+
+    def split_scope(self, scope_id: str) -> list[list[str]]:
+        """Split a stuck agent's scope into smaller pieces."""
+        state = self._agents.get(scope_id)
+        if not state or len(state.target_files) <= 1:
+            return []
+
+        files = state.target_files
+        mid = len(files) // 2
+        return [files[:mid], files[mid:]]
+
+    def complete(self, scope_id: str) -> None:
+        """Mark an agent as completed."""
+        state = self._agents.get(scope_id)
+        if state:
+            state.completed = True
+
+    @property
+    def active_count(self) -> int:
+        return sum(1 for s in self._agents.values() if not s.completed)

forge_core/core/coverage.py

@@ -0,0 +1,241 @@
+"""Coverage runner — execute test commands and parse coverage reports."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from forge_core.models.test_result import CoverageEntry, CoverageReport
+from forge_core.utils import logger
+from forge_core.utils.shell import run
+
+
+def run_tests(project_path: Path, test_command: str) -> tuple[bool, str]:
+    """Run the project's test command. Returns (success, output)."""
+    result = run(test_command, cwd=project_path, timeout=600)
+    return result.success, result.output
+
+
+def run_coverage(project_path: Path, coverage_command: str) -> CoverageReport:
+    """Run the project's coverage command and parse the report."""
+    result = run(coverage_command, cwd=project_path, timeout=600)
+
+    report = CoverageReport()
+
+    # Try parsing various coverage report formats
+    report = _try_parse_jacoco(project_path, report)
+    if report.total_lines == 0:
+        report = _try_parse_cobertura(project_path, report)
+    if report.total_lines == 0:
+        report = _try_parse_lcov(project_path, report)
+    if report.total_lines == 0:
+        report = _try_parse_pytest_cov(result.output, report)
+    if report.total_lines == 0:
+        report = _try_parse_go_cover(result.output, report)
+    if report.total_lines == 0:
+        # Fallback: try to extract percentage from output
+        report = _try_parse_generic(result.output, report)
+
+    # Count tests from output
+    test_counts = _parse_test_counts(result.output)
+    report.total_tests = test_counts.get("total", 0)
+    report.tests_passed = test_counts.get("passed", 0)
+    report.tests_failed = test_counts.get("failed", 0)
+
+    return report
+
+
+def _try_parse_jacoco(project_path: Path, report: CoverageReport) -> CoverageReport:
+    """Parse JaCoCo CSV or XML report (Kotlin/Java)."""
+    # Look for CSV report first
+    csv_patterns = [
+        "build/reports/jacoco/test/jacocoTestReport.csv",
+        "build/reports/jacoco/jacocoTestReport.csv",
+        "target/site/jacoco/jacoco.csv",
+    ]
+    for pattern in csv_patterns:
+        csv_path = project_path / pattern
+        if csv_path.exists():
+            return _parse_jacoco_csv(csv_path, report)
+
+    # Try XML
+    xml_patterns = [
+        "build/reports/jacoco/test/jacocoTestReport.xml",
+        "target/site/jacoco/jacoco.xml",
+    ]
+    for pattern in xml_patterns:
+        xml_path = project_path / pattern
+        if xml_path.exists():
+            return _parse_jacoco_xml(xml_path, report)
+
+    return report
+
+
+def _parse_jacoco_csv(csv_path: Path, report: CoverageReport) -> CoverageReport:
+    """Parse JaCoCo CSV report."""
+    import csv
+
+    total_missed = 0
+    total_covered = 0
+
+    try:
+        with open(csv_path, encoding="utf-8") as f:
+            reader = csv.DictReader(f)
+            for row in reader:
+                missed = int(row.get("LINE_MISSED", 0))
+                covered = int(row.get("LINE_COVERED", 0))
+                total_missed += missed
+                total_covered += covered
+
+                pkg = row.get("PACKAGE", "")
+                cls = row.get("CLASS", "")
+                total = missed + covered
+                if total > 0:
+                    report.files.append(
+                        CoverageEntry(
+                            file_path=f"{pkg}/{cls}",
+                            line_coverage=round(covered / total * 100, 1),
+                            lines_covered=covered,
+                            lines_total=total,
+                        )
+                    )
+
+        total = total_missed + total_covered
+        report.total_lines = total
+        report.total_lines_covered = total_covered
+        if total > 0:
+            report.line_coverage = round(total_covered / total * 100, 1)
+    except Exception as e:
+        logger.warn(f"Failed to parse JaCoCo CSV: {e}")
+
+    return report
+
+
+def _parse_jacoco_xml(xml_path: Path, report: CoverageReport) -> CoverageReport:
+    """Parse JaCoCo XML report — extract LINE counter from root."""
+    import xml.etree.ElementTree as ET
+
+    try:
+        tree = ET.parse(xml_path)
+        root = tree.getroot()
+
+        for counter in root.findall("counter"):
+            if counter.get("type") == "LINE":
+                missed = int(counter.get("missed", 0))
+                covered = int(counter.get("covered", 0))
+                total = missed + covered
+                report.total_lines = total
+                report.total_lines_covered = covered
+                if total > 0:
+                    report.line_coverage = round(covered / total * 100, 1)
+                break
+    except Exception as e:
+        logger.warn(f"Failed to parse JaCoCo XML: {e}")
+
+    return report
+
+
+def _try_parse_cobertura(project_path: Path, report: CoverageReport) -> CoverageReport:
+    """Parse Cobertura XML report."""
+    cobertura_paths = [
+        "coverage.xml",
+        "build/reports/cobertura/coverage.xml",
+        "target/site/cobertura/coverage.xml",
+    ]
+    for pattern in cobertura_paths:
+        xml_path = project_path / pattern
+        if xml_path.exists():
+            try:
+                import xml.etree.ElementTree as ET
+
+                tree = ET.parse(xml_path)
+                root = tree.getroot()
+                rate = float(root.get("line-rate", 0))
+                report.line_coverage = round(rate * 100, 1)
+                return report
+            except Exception:
+                continue
+    return report
+
+
+def _try_parse_lcov(project_path: Path, report: CoverageReport) -> CoverageReport:
+    """Parse LCOV info file."""
+    lcov_paths = ["coverage/lcov.info", "lcov.info"]
+    for pattern in lcov_paths:
+        lcov_path = project_path / pattern
+        if lcov_path.exists():
+            try:
+                content = lcov_path.read_text(encoding="utf-8")
+                lf = sum(int(m.group(1)) for m in re.finditer(r"LF:(\d+)", content))
+                lh = sum(int(m.group(1)) for m in re.finditer(r"LH:(\d+)", content))
+                if lf > 0:
+                    report.total_lines = lf
+                    report.total_lines_covered = lh
+                    report.line_coverage = round(lh / lf * 100, 1)
+                return report
+            except Exception:
+                continue
+    return report
+
+
+def _try_parse_pytest_cov(output: str, report: CoverageReport) -> CoverageReport:
+    """Parse pytest-cov output for TOTAL line."""
+    match = re.search(r"TOTAL\s+\d+\s+\d+\s+(\d+)%", output)
+    if match:
+        report.line_coverage = float(match.group(1))
+    return report
+
+
+def _try_parse_go_cover(output: str, report: CoverageReport) -> CoverageReport:
+    """Parse go test -cover output."""
+    match = re.search(r"coverage:\s+([\d.]+)%", output)
+    if match:
+        report.line_coverage = float(match.group(1))
+    return report
+
+
+def _try_parse_generic(output: str, report: CoverageReport) -> CoverageReport:
+    """Try to extract any coverage percentage from output."""
+    patterns = [
+        r"(?:line|statement|code)\s*coverage[:\s]+(\d+(?:\.\d+)?)\s*%",
+        r"(\d+(?:\.\d+)?)\s*%\s*(?:line|statement|code)\s*coverage",
+        r"Total[:\s]+(\d+(?:\.\d+)?)\s*%",
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, output, re.IGNORECASE)
+        if match:
+            report.line_coverage = float(match.group(1))
+            return report
+    return report
+
+
+def _parse_test_counts(output: str) -> dict[str, int]:
+    """Extract test pass/fail counts from build output."""
+    counts: dict[str, int] = {"total": 0, "passed": 0, "failed": 0}
+
+    # Gradle/JUnit style
+    m = re.search(r"(\d+)\s+tests?\s+completed,\s+(\d+)\s+failed", output)
+    if m:
+        counts["total"] = int(m.group(1))
+        counts["failed"] = int(m.group(2))
+        counts["passed"] = counts["total"] - counts["failed"]
+        return counts
+
+    # pytest style
+    m = re.search(r"(\d+)\s+passed", output)
+    if m:
+        counts["passed"] = int(m.group(1))
+    m = re.search(r"(\d+)\s+failed", output)
+    if m:
+        counts["failed"] = int(m.group(1))
+    counts["total"] = counts["passed"] + counts["failed"]
+
+    # Go style
+    m = re.search(r"ok\s+.+\s+([\d.]+)s", output)
+    if m and counts["total"] == 0:
+        # go test doesn't show counts easily, estimate from "--- PASS:" lines
+        counts["passed"] = len(re.findall(r"--- PASS:", output))
+        counts["failed"] = len(re.findall(r"--- FAIL:", output))
+        counts["total"] = counts["passed"] + counts["failed"]
+
+    return counts

forge_core/core/file_manager.py

@@ -0,0 +1,104 @@
+"""Safe file read/write with rollback protection."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+from forge_core.utils import logger
+
+
+class FileManager:
+    """Manages file operations with rollback support.
+
+    Tracks all written files so they can be reverted if coverage drops.
+    """
+
+    def __init__(self, project_path: Path):
+        self.project_path = project_path
+        self._written_files: dict[str, str | None] = {}  # path → original content (None if new)
+        self._backup_dir: Path | None = None
+
+    def read_file(self, relative_path: str) -> str:
+        """Read a file from the project."""
+        full_path = self.project_path / relative_path
+        if not full_path.exists():
+            return ""
+        return full_path.read_text(encoding="utf-8")
+
+    def read_files(self, glob_pattern: str) -> dict[str, str]:
+        """Read multiple files matching a glob pattern. Returns {relative_path: content}."""
+        results: dict[str, str] = {}
+        for path in sorted(self.project_path.glob(glob_pattern)):
+            if path.is_file():
+                rel = str(path.relative_to(self.project_path))
+                try:
+                    results[rel] = path.read_text(encoding="utf-8")
+                except (UnicodeDecodeError, PermissionError):
+                    continue
+        return results
+
+    def write_file(self, relative_path: str, content: str) -> None:
+        """Write a file, tracking it for potential rollback."""
+        full_path = self.project_path / relative_path
+
+        # Store original state for rollback
+        if relative_path not in self._written_files:
+            if full_path.exists():
+                self._written_files[relative_path] = full_path.read_text(encoding="utf-8")
+            else:
+                self._written_files[relative_path] = None
+
+        # Ensure parent dirs exist
+        full_path.parent.mkdir(parents=True, exist_ok=True)
+        full_path.write_text(content, encoding="utf-8")
+
+    def rollback(self) -> int:
+        """Rollback all files written since last checkpoint. Returns count of files rolled back."""
+        count = 0
+        for rel_path, original in self._written_files.items():
+            full_path = self.project_path / rel_path
+            if original is None:
+                # File was newly created — delete it
+                if full_path.exists():
+                    full_path.unlink()
+                    count += 1
+            else:
+                # File was modified — restore original
+                full_path.write_text(original, encoding="utf-8")
+                count += 1
+
+        if count:
+            logger.warn(f"Rolled back {count} files")
+        self._written_files.clear()
+        return count
+
+    def checkpoint(self) -> None:
+        """Accept current state — clear rollback history."""
+        self._written_files.clear()
+
+    def list_source_files(self, source_root: str = "src") -> list[str]:
+        """List all source files under the source root."""
+        root = self.project_path / source_root
+        if not root.exists():
+            return []
+        return [
+            str(p.relative_to(self.project_path))
+            for p in sorted(root.rglob("*"))
+            if p.is_file() and not p.name.startswith(".")
+        ]
+
+    def list_test_files(self, test_root: str = "src/test") -> list[str]:
+        """List all test files under the test root."""
+        root = self.project_path / test_root
+        if not root.exists():
+            return []
+        return [
+            str(p.relative_to(self.project_path))
+            for p in sorted(root.rglob("*"))
+            if p.is_file() and not p.name.startswith(".")
+        ]
+
+    @property
+    def pending_rollback_count(self) -> int:
+        return len(self._written_files)

forge_core/models/config.py

@@ -0,0 +1,115 @@
+"""Pydantic models for configuration and tenant/plan data."""
+
+from __future__ import annotations
+
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class Plan(str, Enum):
+    FREE = "free"
+    PRO = "pro"
+    ENTERPRISE = "enterprise"
+
+
+class AIProvider(str, Enum):
+    OPENAI = "openai"
+    ANTHROPIC = "anthropic"
+    AZURE = "azure"
+    BEDROCK = "bedrock"
+    OLLAMA = "ollama"
+    AUTO = "auto"
+
+
+class RunMode(str, Enum):
+    FULL = "full"
+    TARGETED = "targeted"
+    ANALYZE_ONLY = "analyze_only"
+    ANALYZE_REVIEW = "analyze_review"
+
+
+class TenantInfo(BaseModel):
+    """Multi-tenant identification — populated by SaaS or CLI."""
+
+    org_id: str = ""
+    org_name: str = ""
+    user_id: str = ""
+    project_id: str = ""
+
+
+class PlanLimits(BaseModel):
+    """Usage limits per plan tier."""
+
+    plan: Plan = Plan.FREE
+    max_tests_per_month: int = 500
+    max_repos: int = 1
+    ci_cd_enabled: bool = False
+    cross_project_learning: bool = False
+    max_parallel_agents: int = 2
+
+    @classmethod
+    def for_plan(cls, plan: Plan) -> PlanLimits:
+        if plan == Plan.PRO:
+            return cls(
+                plan=plan,
+                max_tests_per_month=-1,  # unlimited
+                max_repos=-1,
+                ci_cd_enabled=True,
+                cross_project_learning=True,
+                max_parallel_agents=4,
+            )
+        elif plan == Plan.ENTERPRISE:
+            return cls(
+                plan=plan,
+                max_tests_per_month=-1,
+                max_repos=-1,
+                ci_cd_enabled=True,
+                cross_project_learning=True,
+                max_parallel_agents=8,
+            )
+        return cls()
+
+
+class AIConfig(BaseModel):
+    """AI provider configuration."""
+
+    provider: AIProvider = AIProvider.AUTO
+    model: str = "gpt-4o"
+    api_key: str = ""
+    base_url: str = ""
+    temperature: float = 0.1
+    max_tokens: int = 4096
+    use_saas_proxy: bool = False  # True = use our API key via SaaS
+
+
+class ForgeConfig(BaseModel):
+    """Top-level engine configuration."""
+
+    # Project
+    project_path: Path = Field(default_factory=lambda: Path("."))
+    target_coverage: float = 90.0
+    max_iterations: int = 10
+    mode: RunMode = RunMode.FULL
+    target_files: list[str] = Field(default_factory=list)
+
+    # AI
+    ai: AIConfig = Field(default_factory=AIConfig)
+
+    # Tenant
+    tenant: TenantInfo = Field(default_factory=TenantInfo)
+
+    # Plan
+    limits: PlanLimits = Field(default_factory=PlanLimits)
+
+    # Engine
+    central_agent_path: str = ""
+    knowledge_packs_dir: str = "knowledge-packs"
+    cache_dir: str = ".forge-cache"
+    prompts_dir: str = ".github/prompts"
+
+    # SaaS
+    saas_api_url: str = "https://api.theswitchcompany.online"
+    auth_token: str = ""

forge_core/models/dto.py

@@ -0,0 +1,58 @@
+"""Pydantic models for DTO registry."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class DTOParam(BaseModel):
+    """A single constructor/field parameter of a DTO."""
+
+    name: str
+    type: str
+    default: str = ""
+    nullable: bool = False
+
+
+class DTOEntry(BaseModel):
+    """A single DTO class registered in the global registry."""
+
+    class_name: str
+    package: str
+    file_path: str
+    params: list[DTOParam] = Field(default_factory=list)
+    has_builder: bool = False
+    has_factory: bool = False
+    validation_annotations: list[str] = Field(default_factory=list)
+    nested_dtos: list[str] = Field(default_factory=list)  # class names of nested DTOs
+    used_in_journeys: list[str] = Field(default_factory=list)
+    used_in_layers: list[str] = Field(default_factory=list)
+
+    def mock_snippet(self) -> str:
+        """Generate a minimal mock/test instance snippet."""
+        params_str = ", ".join(
+            f'{p.name}={"null" if p.nullable else repr(p.default) if p.default else "TODO"}'
+            for p in self.params
+        )
+        return f"{self.class_name}({params_str})"
+
+
+class DTORegistry(BaseModel):
+    """Global registry of all DTOs in the project — read once, shared everywhere."""
+
+    entries: dict[str, DTOEntry] = Field(default_factory=dict)  # class_name → DTOEntry
+
+    def register(self, entry: DTOEntry) -> None:
+        self.entries[entry.class_name] = entry
+
+    def get(self, class_name: str) -> "Optional[DTOEntry]":
+        return self.entries.get(class_name)
+
+    def for_journey(self, journey_name: str) -> list[DTOEntry]:
+        return [e for e in self.entries.values() if journey_name in e.used_in_journeys]
+
+    @property
+    def count(self) -> int:
+        return len(self.entries)