switchforge 1.0.0__py3-none-any.whl

forge_core/utils/logger.py

@@ -0,0 +1,89 @@
+"""Rich-based structured logging with progress bars."""
+
+from __future__ import annotations
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
+from rich.table import Table
+
+console = Console()
+
+
+def phase_start(phase: str, title: str) -> None:
+    """Log the start of a pipeline phase."""
+    console.print(f"\n[bold cyan][{phase}][/bold cyan] {title}...")
+
+
+def phase_done(phase: str, summary: str) -> None:
+    """Log the completion of a pipeline phase."""
+    console.print(f"  [green]✓[/green] {summary}")
+
+
+def phase_skip(phase: str, reason: str) -> None:
+    """Log a skipped phase."""
+    console.print(f"  [yellow]⊘[/yellow] Skipped: {reason}")
+
+
+def phase_error(phase: str, error: str) -> None:
+    """Log a phase error."""
+    console.print(f"  [red]✗[/red] Error: {error}")
+
+
+def info(msg: str) -> None:
+    console.print(f"  [dim]{msg}[/dim]")
+
+
+def warn(msg: str) -> None:
+    console.print(f"  [yellow]⚠[/yellow] {msg}")
+
+
+def error(msg: str) -> None:
+    console.print(f"  [red]✗[/red] {msg}")
+
+
+def success(msg: str) -> None:
+    console.print(f"  [green]✓[/green] {msg}")
+
+
+def banner(title: str, subtitle: str = "") -> None:
+    """Display the Forge Core banner."""
+    text = f"[bold blue]{title}[/bold blue]"
+    if subtitle:
+        text += f"\n[dim]{subtitle}[/dim]"
+    console.print(Panel(text, border_style="blue", padding=(1, 4)))
+
+
+def coverage_table(before: float, after: float, tests_before: int, tests_after: int) -> None:
+    """Display a before/after coverage comparison table."""
+    table = Table(title="Coverage Results", border_style="blue")
+    table.add_column("Metric", style="cyan")
+    table.add_column("Before", style="red")
+    table.add_column("After", style="green")
+    table.add_column("Delta", style="yellow")
+
+    table.add_row(
+        "Line Coverage",
+        f"{before:.1f}%",
+        f"{after:.1f}%",
+        f"+{after - before:.1f}%",
+    )
+    table.add_row(
+        "Total Tests",
+        str(tests_before),
+        str(tests_after),
+        f"+{tests_after - tests_before}",
+    )
+    console.print(table)
+
+
+def create_progress() -> Progress:
+    """Create a Rich progress bar for phase tracking."""
+    return Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+        TimeElapsedColumn(),
+        console=console,
+    )

forge_core/utils/reporter.py

@@ -0,0 +1,70 @@
+"""Upload run reports to the SaaS API."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from forge_core.models.config import ForgeConfig
+from forge_core.utils import logger
+
+
+async def upload_report(config: ForgeConfig, report: dict[str, Any]) -> bool:
+    """Upload a run report to the SaaS dashboard.
+
+    Returns True if upload succeeded, False otherwise.
+    Reports are optional — engine works fully offline.
+    """
+    if not config.auth_token:
+        logger.info("No auth token — skipping report upload (offline mode)")
+        return False
+
+    url = f"{config.saas_api_url}/api/v1/runs"
+    headers = {
+        "Authorization": f"Bearer {config.auth_token}",
+        "Content-Type": "application/json",
+    }
+    payload = {
+        "org_id": config.tenant.org_id,
+        "user_id": config.tenant.user_id,
+        "project_id": config.tenant.project_id,
+        "report": report,
+    }
+
+    try:
+        async with httpx.AsyncClient(timeout=30) as client:
+            resp = await client.post(url, json=payload, headers=headers)
+            if resp.status_code == 200:
+                data = resp.json()
+                report_url = data.get("url", "")
+                logger.success(f"Report uploaded: {report_url}")
+                return True
+            else:
+                logger.warn(f"Report upload failed ({resp.status_code}): {resp.text[:200]}")
+                return False
+    except Exception as e:
+        logger.warn(f"Report upload failed (network): {e}")
+        return False
+
+
+async def check_license(config: ForgeConfig) -> dict[str, Any]:
+    """Check license and plan limits with the SaaS API.
+
+    Returns plan info dict or empty dict if offline/failed.
+    """
+    if not config.auth_token:
+        return {}
+
+    url = f"{config.saas_api_url}/api/v1/license"
+    headers = {"Authorization": f"Bearer {config.auth_token}"}
+
+    try:
+        async with httpx.AsyncClient(timeout=10) as client:
+            resp = await client.get(url, headers=headers)
+            if resp.status_code == 200:
+                return resp.json()
+    except Exception:
+        pass
+
+    return {}

forge_core/utils/shell.py

@@ -0,0 +1,93 @@
+"""Subprocess wrapper for running build/test commands safely."""
+
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+from forge_core.utils import logger
+
+
+@dataclass
+class ShellResult:
+    """Result of a shell command execution."""
+
+    command: str
+    returncode: int
+    stdout: str
+    stderr: str
+    duration_seconds: float = 0.0
+
+    @property
+    def success(self) -> bool:
+        return self.returncode == 0
+
+    @property
+    def output(self) -> str:
+        return self.stdout + self.stderr
+
+
+def run(
+    command: str,
+    cwd: Path | str | None = None,
+    timeout: int = 600,
+    capture: bool = True,
+    env: dict[str, str] | None = None,
+) -> ShellResult:
+    """Run a shell command and return structured result.
+
+    Args:
+        command: Shell command to execute.
+        cwd: Working directory.
+        timeout: Max seconds before kill (default 10 min).
+        capture: Whether to capture stdout/stderr.
+        env: Extra environment variables (merged with current env).
+    """
+    import os
+    import time
+
+    full_env = {**os.environ, **(env or {})}
+
+    logger.info(f"$ {command}")
+
+    start = time.time()
+    try:
+        result = subprocess.run(
+            command,
+            shell=True,
+            cwd=str(cwd) if cwd else None,
+            capture_output=capture,
+            text=True,
+            timeout=timeout,
+            env=full_env,
+        )
+        duration = time.time() - start
+
+        return ShellResult(
+            command=command,
+            returncode=result.returncode,
+            stdout=result.stdout or "",
+            stderr=result.stderr or "",
+            duration_seconds=duration,
+        )
+    except subprocess.TimeoutExpired:
+        duration = time.time() - start
+        logger.warn(f"Command timed out after {timeout}s: {command}")
+        return ShellResult(
+            command=command,
+            returncode=-1,
+            stdout="",
+            stderr=f"TIMEOUT after {timeout}s",
+            duration_seconds=duration,
+        )
+    except Exception as e:
+        duration = time.time() - start
+        logger.error(f"Command failed: {e}")
+        return ShellResult(
+            command=command,
+            returncode=-1,
+            stdout="",
+            stderr=str(e),
+            duration_seconds=duration,
+        )

forge_core/utils/tokens.py

@@ -0,0 +1,67 @@
+"""Token counting and prompt size management using tiktoken."""
+
+from __future__ import annotations
+
+import tiktoken
+
+
+def count_tokens(text: str, model: str = "gpt-4o") -> int:
+    """Count tokens in text for a given model."""
+    try:
+        enc = tiktoken.encoding_for_model(model)
+    except KeyError:
+        enc = tiktoken.get_encoding("cl100k_base")
+    return len(enc.encode(text))
+
+
+def truncate_to_tokens(text: str, max_tokens: int, model: str = "gpt-4o") -> str:
+    """Truncate text to fit within max_tokens."""
+    try:
+        enc = tiktoken.encoding_for_model(model)
+    except KeyError:
+        enc = tiktoken.get_encoding("cl100k_base")
+
+    tokens = enc.encode(text)
+    if len(tokens) <= max_tokens:
+        return text
+    return enc.decode(tokens[:max_tokens])
+
+
+def fits_in_context(
+    system_prompt: str,
+    user_content: str,
+    model: str = "gpt-4o",
+    max_context: int = 128_000,
+    reserve_for_response: int = 4096,
+) -> bool:
+    """Check if system + user content fits in the model's context window."""
+    total = count_tokens(system_prompt, model) + count_tokens(user_content, model)
+    return total <= (max_context - reserve_for_response)
+
+
+def split_for_context(
+    files: dict[str, str],
+    max_tokens: int,
+    model: str = "gpt-4o",
+) -> list[dict[str, str]]:
+    """Split a dict of {path: content} into batches that fit in context.
+
+    Returns list of batches, each a dict of {path: content}.
+    """
+    batches: list[dict[str, str]] = []
+    current_batch: dict[str, str] = {}
+    current_tokens = 0
+
+    for path, content in files.items():
+        file_tokens = count_tokens(f"--- {path} ---\n{content}\n", model)
+        if current_tokens + file_tokens > max_tokens and current_batch:
+            batches.append(current_batch)
+            current_batch = {}
+            current_tokens = 0
+        current_batch[path] = content
+        current_tokens += file_tokens
+
+    if current_batch:
+        batches.append(current_batch)
+
+    return batches

switchforge-1.0.0.dist-info/METADATA

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: switchforge
+Version: 1.0.0
+Summary: AI-powered backend test generation engine
+Project-URL: Homepage, https://theswitchcompany.online/products/forge/core
+Project-URL: Repository, https://github.com/switchcompany/forge-core
+Project-URL: Documentation, https://theswitchcompany.online/docs/forge-core
+Author-email: TheSwitchCompany <hello@theswitchcompany.online>
+License-Expression: MIT
+Keywords: ai,backend,code-generation,testing,unit-tests
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: instructor>=1.3.0
+Requires-Dist: litellm>=1.40.0
+Requires-Dist: pydantic>=2.7.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.7.0
+Requires-Dist: tiktoken>=0.7.0
+Requires-Dist: typer>=0.12.0
+Provides-Extra: dev
+Requires-Dist: pyinstaller>=6.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.5.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Switchforge (Forge Core CLI)
+
+AI-powered backend test generation engine by [TheSwitchCompany](https://theswitchcompany.online).
+
+## Install
+
+```bash
+pip install switchforge
+```
+
+## Quick Start
+
+```bash
+switchforge login --token YOUR_API_TOKEN
+switchforge init
+switchforge run . --target 90
+```
+
+### Windows Users
+
+If `switchforge` is not recognized, use `python -m forge_core`:
+
+```powershell
+python -m forge_core login --token YOUR_API_TOKEN
+python -m forge_core init
+python -m forge_core run . --target 90
+```
+
+## Documentation
+
+[theswitchcompany.online/docs/forge-core](https://theswitchcompany.online/docs/forge-core)

switchforge-1.0.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+forge_core/__init__.py,sha256=M73aKzgrfrqVz1KEj2PCvF2he8e-pPA-CisRqUiqrTc,87
+forge_core/__main__.py,sha256=Bgjh1sswksrd2aWTaOCPlGUGKh2M49VQ_QEB28ysRfw,116
+forge_core/auth.py,sha256=HarMTW4dwSr-7MnJ2Fa-wYPaY2VlXMP_7Q_G6LW3syA,2391
+forge_core/cli.py,sha256=Rqx52EKLpqaN2t4PRa7x-1-Idm9-aq7OU4nSu3-Dcxc,6405
+forge_core/config.py,sha256=SjnHrXiuPoF-2Zl4lqpdym-6jC-53iRzUEY3GE7LyoQ,3637
+forge_core/orchestrator.py,sha256=SlXuzoAXzllxu9BM9cWfk3HglIpAe2bLXG7M-dOXSTI,9048
+forge_core/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+forge_core/ai/prompts.py,sha256=1_MCoN_xDlULDEz_7uUasxaYbRSTb1pi2alk469KNQw,2733
+forge_core/ai/provider.py,sha256=XQSCFdF9Md5p6r69vzyI7hCY4BtlfXKKf3wIPDhPoIM,3705
+forge_core/ai/structured.py,sha256=EaS1Kig4XTofSWjQrm52HZRUzWtKbrbr8_npGk4GKOQ,1930
+forge_core/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+forge_core/core/agent_manager.py,sha256=gMk8NqgYfSBk1b2-ok_nsdr1Rznlgh_pUXUJwCHGz_A,3718
+forge_core/core/coverage.py,sha256=zmQ4x-QSEQVEpaiMFMoWWs4iuZaEwxSxPcxrdj2WCPw,8488
+forge_core/core/file_manager.py,sha256=2JUpLYkgonkCa1pYtI0ZASxtEZ0tnQxpMN8eQuqpAC8,3820
+forge_core/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+forge_core/models/config.py,sha256=JZ4oGzkHfdB91XaGe_fb0DQhx2iU3Y5gIcWkXDLTtzE,2832
+forge_core/models/dto.py,sha256=ooVsfeNtsxsfyjl8pg6xShChE9oDvp0rzc1FNXyLEuo,1808
+forge_core/models/project.py,sha256=w1TkrqHkaM_XGtlQVcu2A0WDRna9dod3QPohAPgIAr0,1895
+forge_core/models/test_result.py,sha256=YOYW9iKIqFz1HQWa084KDOJcwsipvl4MXoRsHrsagU4,2381
+forge_core/phases/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+forge_core/phases/analyze_project.py,sha256=GAVWGdpHsrh4RViZ67sSaQ7N2-zCwgIssTVRg-2EwUU,5412
+forge_core/phases/audit_tests.py,sha256=zzWV7x9Q3S1iZ6szju94BhZCnZXAWiUASowYZYnPbaQ,1082
+forge_core/phases/compile_fix.py,sha256=DQgy-yhUybddLJhut6G5FLicrrWyD8qzTXve8E0-isQ,2499
+forge_core/phases/coverage_report.py,sha256=KveXSwoVQb-KokDnJS1EGxNidwOmyPNWv9i75b2ZJUw,648
+forge_core/phases/detect_stack.py,sha256=vbJqxwCw1sT7pryRpP0iKd9bpPH8pQcU-2rLceTPa8E,2128
+forge_core/phases/exclusion_scan.py,sha256=Z3vlwbaXpmlsWKJ9FS4d_d-WcuPM5eaAE05eplCQJSc,2636
+forge_core/phases/fix_broken.py,sha256=NcovciAHgRnkV9RLcO7V2uS1CPK43liTlJkKJbFywlQ,2676
+forge_core/phases/generate_tests.py,sha256=lWA0rozpU6nbeMV-ag2coEO-Nu7LPJDmPK75CGcYww8,7782
+forge_core/phases/journey_mapping.py,sha256=BmBA3yYRaWUNgOsqdMvQtZ41W_Te0FKTgX9G5TebqcU,4299
+forge_core/phases/self_learn.py,sha256=HK_CagBIRjn9eeWpr5bUCvfN29HRD5E7CjblUyXVXZk,3317
+forge_core/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+forge_core/utils/logger.py,sha256=b_PaZgxdERw0lAaWLFsnrnfffrCSUhn4UpESj97crAs,2533
+forge_core/utils/reporter.py,sha256=yhzaMoByj9tM0RAHefcv8sPcEWbTESiev98usm9zgzk,2145
+forge_core/utils/shell.py,sha256=mRn2tNMRtdOxXkst6DWasVBd0pRVGJmaqKukU-QHd_c,2367
+forge_core/utils/tokens.py,sha256=YQZ4AOkuOwUYghFZicGC6isnLdyro-3j3tDNEkI3lM0,1997
+switchforge-1.0.0.dist-info/METADATA,sha256=WvYw-iz4eBiQ_Kh4ZlXQgdb1bK18fjTOP_Rf4NXpQSE,1995
+switchforge-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+switchforge-1.0.0.dist-info/entry_points.txt,sha256=PwgdQo8NrcBuvyW3DlkfyF2Wa0XXNkHyir20DsD86dY,51
+switchforge-1.0.0.dist-info/RECORD,,

switchforge-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

switchforge-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+switchforge = forge_core.cli:app