switchforge 1.0.0__tar.gz

switchforge-1.0.0/.gitignore

@@ -0,0 +1,36 @@
+# OS
+.DS_Store
+Thumbs.db
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Build outputs
+build/
+dist/
+out/
+target/
+
+# Dependencies
+node_modules/
+__pycache__/
+*.pyc
+.venv/
+venv/
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# Logs
+*.log
+npm-debug.log*
+
+# Coverage
+coverage/
+htmlcov/
+.coverage

switchforge-1.0.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,31 @@
+# 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/forge-core.spec

@@ -0,0 +1,108 @@
+# -*- mode: python ; coding: utf-8 -*-
+"""
+PyInstaller spec for Forge Core CLI.
+Compiles the Python engine into a single standalone binary.
+
+Build:
+  pip install pyinstaller
+  pyinstaller forge-core.spec
+
+Output: dist/forge-core (single binary, ~50-80MB)
+"""
+
+import sys
+from pathlib import Path
+
+block_cipher = None
+
+# Collect all forge_core modules
+a = Analysis(
+    ['forge_core/cli.py'],
+    pathex=[],
+    binaries=[],
+    datas=[
+        # Include prompt templates if bundled
+        ('../.github/prompts', 'prompts'),
+        ('../knowledge-packs', 'knowledge-packs'),
+    ],
+    hiddenimports=[
+        'forge_core',
+        'forge_core.orchestrator',
+        'forge_core.config',
+        'forge_core.auth',
+        'forge_core.ai.provider',
+        'forge_core.ai.prompts',
+        'forge_core.ai.structured',
+        'forge_core.phases.detect_stack',
+        'forge_core.phases.exclusion_scan',
+        'forge_core.phases.analyze_project',
+        'forge_core.phases.journey_mapping',
+        'forge_core.phases.audit_tests',
+        'forge_core.phases.fix_broken',
+        'forge_core.phases.generate_tests',
+        'forge_core.phases.compile_fix',
+        'forge_core.phases.coverage_report',
+        'forge_core.phases.self_learn',
+        'forge_core.core.file_manager',
+        'forge_core.core.coverage',
+        'forge_core.core.agent_manager',
+        'forge_core.models.config',
+        'forge_core.models.project',
+        'forge_core.models.dto',
+        'forge_core.models.test_result',
+        'forge_core.utils.logger',
+        'forge_core.utils.shell',
+        'forge_core.utils.tokens',
+        'forge_core.utils.reporter',
+        # Dependencies
+        'litellm',
+        'instructor',
+        'typer',
+        'rich',
+        'yaml',
+        'tiktoken',
+        'httpx',
+        'pydantic',
+        'tiktoken_ext',
+        'tiktoken_ext.openai_public',
+    ],
+    hookspath=[],
+    hooksconfig={},
+    runtime_hooks=[],
+    excludes=[
+        'tkinter',
+        'matplotlib',
+        'scipy',
+        'numpy',
+        'pandas',
+        'pytest',
+    ],
+    win_no_prefer_redirects=False,
+    win_private_assemblies=False,
+    cipher=block_cipher,
+    noarchive=False,
+)
+
+pyz = PYZ(a.pure, a.zipped_data, cipher=block_cipher)
+
+exe = EXE(
+    pyz,
+    a.scripts,
+    a.binaries,
+    a.zipfiles,
+    a.datas,
+    [],
+    name='forge-core',
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip=True,
+    upx=True,
+    upx_exclude=[],
+    runtime_tmpdir=None,
+    console=True,
+    disable_windowed_traceback=False,
+    argv_emulation=False,
+    target_arch=None,
+    codesign_identity=None,
+    entitlements_file=None,
+)

switchforge-1.0.0/forge_core/__init__.py

@@ -0,0 +1,3 @@
+"""Forge Core — AI-powered backend test generation engine."""
+
+__version__ = "2.0.0"

switchforge-1.0.0/forge_core/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for `python -m forge_core`."""
+
+from forge_core.cli import app
+
+if __name__ == "__main__":
+    app()

switchforge-1.0.0/forge_core/ai/prompts.py

@@ -0,0 +1,87 @@
+"""Load and template .md prompt files for AI consumption."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from forge_core.utils import logger
+
+
+def load_prompt(prompts_dir: Path, prompt_name: str) -> str:
+    """Load a prompt .md file from the prompts directory.
+
+    Args:
+        prompts_dir: Path to the prompts directory.
+        prompt_name: Name of the prompt file (e.g., 'detect-tech-stack').
+
+    Returns:
+        The prompt content as a string.
+    """
+    file_path = prompts_dir / f"{prompt_name}.prompt.md"
+    if not file_path.exists():
+        logger.warn(f"Prompt not found: {file_path}")
+        return ""
+
+    content = file_path.read_text(encoding="utf-8")
+    # Strip YAML frontmatter if present
+    if content.startswith("---"):
+        parts = content.split("---", 2)
+        if len(parts) >= 3:
+            content = parts[2].strip()
+
+    return content
+
+
+def template_prompt(prompt: str, variables: dict[str, str]) -> str:
+    """Replace template variables in a prompt.
+
+    Variables use {{variable_name}} syntax.
+    """
+    result = prompt
+    for key, value in variables.items():
+        result = result.replace(f"{{{{{key}}}}}", value)
+    return result
+
+
+def build_file_context(files: dict[str, str], max_files: int = 50) -> str:
+    """Build a file context string from a dict of {path: content}.
+
+    Formats each file with clear separators for the AI to parse.
+    """
+    parts: list[str] = []
+    for i, (path, content) in enumerate(files.items()):
+        if i >= max_files:
+            parts.append(f"\n... and {len(files) - max_files} more files (truncated)")
+            break
+        parts.append(f"--- {path} ---\n{content}")
+
+    return "\n\n".join(parts)
+
+
+def load_learnings(central_path: str | None, local_path: Path | None) -> str:
+    """Load LEARNINGS.md from central hub and/or local project."""
+    learnings_parts: list[str] = []
+
+    if central_path:
+        central_file = Path(central_path) / "LEARNINGS.md"
+        if central_file.exists():
+            learnings_parts.append(
+                f"=== Central Learnings ===\n{central_file.read_text(encoding='utf-8')}"
+            )
+
+    if local_path:
+        local_file = local_path / "LEARNINGS.md"
+        if local_file.exists():
+            learnings_parts.append(
+                f"=== Project Learnings ===\n{local_file.read_text(encoding='utf-8')}"
+            )
+
+    return "\n\n".join(learnings_parts)
+
+
+def load_knowledge_pack(central_path: str, pack_name: str) -> str:
+    """Load a specific knowledge pack (e.g., kotlin-ktor.md)."""
+    pack_path = Path(central_path) / "knowledge-packs" / f"{pack_name}.md"
+    if pack_path.exists():
+        return pack_path.read_text(encoding="utf-8")
+    return ""

switchforge-1.0.0/forge_core/ai/provider.py

@@ -0,0 +1,121 @@
+"""LiteLLM-based AI provider — unified interface for 100+ models."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import litellm
+
+from forge_core.models.config import AIConfig, AIProvider
+from forge_core.utils import logger
+from forge_core.utils.tokens import count_tokens
+
+# Suppress LiteLLM's verbose logging
+litellm.suppress_debug_info = True
+
+
+def _resolve_model(config: AIConfig) -> str:
+    """Resolve the model string for LiteLLM based on provider."""
+    if config.provider == AIProvider.OLLAMA:
+        return f"ollama/{config.model}"
+    if config.provider == AIProvider.AZURE:
+        return f"azure/{config.model}"
+    if config.provider == AIProvider.BEDROCK:
+        return f"bedrock/{config.model}"
+    return config.model
+
+
+def complete(
+    config: AIConfig,
+    system_prompt: str,
+    user_prompt: str,
+    json_mode: bool = False,
+    max_tokens: int | None = None,
+) -> str:
+    """Send a completion request to the configured AI provider.
+
+    Args:
+        config: AI provider configuration.
+        system_prompt: System-level instructions.
+        user_prompt: User message with code/context.
+        json_mode: If True, request JSON response format.
+        max_tokens: Override max tokens for this call.
+
+    Returns:
+        The AI's response text.
+    """
+    model = _resolve_model(config)
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": user_prompt},
+    ]
+
+    kwargs: dict[str, Any] = {
+        "model": model,
+        "messages": messages,
+        "temperature": config.temperature,
+        "max_tokens": max_tokens or config.max_tokens,
+    }
+
+    if config.api_key:
+        kwargs["api_key"] = config.api_key
+    if config.base_url:
+        kwargs["api_base"] = config.base_url
+    if json_mode:
+        kwargs["response_format"] = {"type": "json_object"}
+
+    # Log token usage
+    input_tokens = count_tokens(system_prompt + user_prompt, config.model)
+    logger.info(f"AI call → {model} ({input_tokens} input tokens)")
+
+    try:
+        response = litellm.completion(**kwargs)
+        content = response.choices[0].message.content or ""
+
+        output_tokens = count_tokens(content, config.model)
+        logger.info(f"AI response ← {output_tokens} output tokens")
+
+        return content
+    except Exception as e:
+        logger.error(f"AI call failed: {e}")
+        raise
+
+
+def complete_with_fallback(
+    config: AIConfig,
+    system_prompt: str,
+    user_prompt: str,
+    fallback_models: list[str] | None = None,
+    json_mode: bool = False,
+) -> str:
+    """Try primary model, fall back to alternatives on failure.
+
+    Useful for complex classes where one model might fail.
+    """
+    models = [_resolve_model(config)] + (fallback_models or [])
+
+    last_error = None
+    for model in models:
+        try:
+            kwargs: dict[str, Any] = {
+                "model": model,
+                "messages": [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt},
+                ],
+                "temperature": config.temperature,
+                "max_tokens": config.max_tokens,
+            }
+            if config.api_key:
+                kwargs["api_key"] = config.api_key
+            if json_mode:
+                kwargs["response_format"] = {"type": "json_object"}
+
+            response = litellm.completion(**kwargs)
+            return response.choices[0].message.content or ""
+        except Exception as e:
+            last_error = e
+            logger.warn(f"Model {model} failed, trying next: {e}")
+            continue
+
+    raise RuntimeError(f"All models failed. Last error: {last_error}")

switchforge-1.0.0/forge_core/ai/structured.py

@@ -0,0 +1,68 @@
+"""Structured AI outputs using instructor + pydantic."""
+
+from __future__ import annotations
+
+from typing import Any, TypeVar
+
+import instructor
+import litellm
+from pydantic import BaseModel
+
+from forge_core.models.config import AIConfig
+from forge_core.ai.provider import _resolve_model
+from forge_core.utils import logger
+
+T = TypeVar("T", bound=BaseModel)
+
+
+def extract(
+    config: AIConfig,
+    system_prompt: str,
+    user_prompt: str,
+    response_model: type[T],
+    max_retries: int = 2,
+) -> T:
+    """Extract structured data from AI using instructor.
+
+    Forces the AI to return data matching a pydantic model schema.
+    Retries on validation failure.
+
+    Args:
+        config: AI provider configuration.
+        system_prompt: System-level instructions.
+        user_prompt: User message with code/context.
+        response_model: Pydantic model class to extract.
+        max_retries: Number of retries on validation failure.
+
+    Returns:
+        An instance of response_model populated by the AI.
+    """
+    model = _resolve_model(config)
+
+    client = instructor.from_litellm(litellm.completion)
+
+    kwargs: dict[str, Any] = {
+        "model": model,
+        "messages": [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt},
+        ],
+        "temperature": config.temperature,
+        "max_retries": max_retries,
+        "response_model": response_model,
+    }
+
+    if config.api_key:
+        kwargs["api_key"] = config.api_key
+    if config.base_url:
+        kwargs["api_base"] = config.base_url
+
+    logger.info(f"Structured extraction → {model} → {response_model.__name__}")
+
+    try:
+        result = client.chat.completions.create(**kwargs)
+        logger.success(f"Extracted {response_model.__name__} successfully")
+        return result
+    except Exception as e:
+        logger.error(f"Structured extraction failed: {e}")
+        raise

switchforge-1.0.0/forge_core/auth.py

@@ -0,0 +1,72 @@
+"""SaaS API authentication and license verification."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+from forge_core.models.config import ForgeConfig, Plan, PlanLimits
+from forge_core.utils import logger
+from forge_core.utils.reporter import check_license
+
+
+def verify_license(config: ForgeConfig) -> ForgeConfig:
+    """Verify license with SaaS API and update plan limits.
+
+    If no auth token is set, runs in free/offline mode.
+    """
+    if not config.auth_token:
+        logger.info("Running in offline mode (no auth token)")
+        config.limits = PlanLimits.for_plan(Plan.FREE)
+        return config
+
+    # Check with SaaS API
+    logger.info("Verifying license with SaaS API...")
+    try:
+        license_info = asyncio.run(check_license(config))
+    except Exception:
+        license_info = {}
+
+    if not license_info:
+        logger.warn("Could not verify license — falling back to free tier limits")
+        config.limits = PlanLimits.for_plan(Plan.FREE)
+        return config
+
+    # Update config from license response
+    plan_str = license_info.get("plan", "free")
+    try:
+        plan = Plan(plan_str)
+    except ValueError:
+        plan = Plan.FREE
+
+    config.limits = PlanLimits.for_plan(plan)
+    config.tenant.org_id = license_info.get("org_id", config.tenant.org_id)
+    config.tenant.org_name = license_info.get("org_name", config.tenant.org_name)
+
+    # If Pro/Enterprise, use SaaS proxy for AI calls
+    if plan in (Plan.PRO, Plan.ENTERPRISE):
+        config.ai.use_saas_proxy = True
+        if not config.ai.api_key:
+            config.ai.api_key = config.auth_token  # SaaS proxy uses auth token
+            config.ai.base_url = f"{config.saas_api_url}/api/v1/ai"
+
+    logger.success(f"License verified: {plan.value} plan ({config.tenant.org_name})")
+    return config
+
+
+def save_auth_token(token: str) -> None:
+    """Save auth token to ~/.forge-core/auth."""
+    auth_dir = Path.home() / ".forge-core"
+    auth_dir.mkdir(exist_ok=True)
+    auth_file = auth_dir / "auth"
+    auth_file.write_text(token, encoding="utf-8")
+    auth_file.chmod(0o600)
+    logger.success("Auth token saved")
+
+
+def load_auth_token() -> str:
+    """Load auth token from ~/.forge-core/auth."""
+    auth_file = Path.home() / ".forge-core" / "auth"
+    if auth_file.exists():
+        return auth_file.read_text(encoding="utf-8").strip()
+    return ""