switchforge 1.1.0__tar.gz → 2.0.0__tar.gz

{switchforge-1.1.0 → switchforge-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: switchforge
-Version: 1.1.0
+Version: 2.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
@@ -18,8 +18,6 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Testing
 Requires-Python: >=3.10
 Requires-Dist: httpx>=0.27.0
-Requires-Dist: openai>=1.30.0
-Requires-Dist: pydantic>=2.7.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: rich>=13.7.0
 Requires-Dist: typer>=0.12.0

switchforge-2.0.0/forge_core/ai/provider.py

@@ -0,0 +1,142 @@
+"""AI provider — raw httpx calls, zero native dependencies."""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+
+import httpx
+
+from forge_core.models.config import AIConfig, AIProvider
+from forge_core.utils import logger
+from forge_core.utils.tokens import count_tokens
+
+_TIMEOUT = httpx.Timeout(120.0, connect=10.0)
+
+
+def _get_api_url(config: AIConfig) -> str:
+    """Resolve the API base URL."""
+    if config.base_url:
+        return config.base_url.rstrip("/")
+    if config.provider == AIProvider.ANTHROPIC:
+        return "https://api.anthropic.com/v1"
+    if config.provider == AIProvider.OLLAMA:
+        return "http://localhost:11434/v1"
+    if config.provider == AIProvider.AZURE:
+        return (os.environ.get("AZURE_OPENAI_ENDPOINT", "")).rstrip("/")
+    return "https://api.openai.com/v1"
+
+
+def _get_api_key(config: AIConfig) -> str:
+    """Resolve the API key."""
+    if config.api_key:
+        return config.api_key
+    if config.provider == AIProvider.ANTHROPIC:
+        return os.environ.get("ANTHROPIC_API_KEY", "")
+    if config.provider == AIProvider.AZURE:
+        return os.environ.get("AZURE_OPENAI_API_KEY", "")
+    if config.provider == AIProvider.OLLAMA:
+        return "ollama"
+    return os.environ.get("OPENAI_API_KEY", "")
+
+
+def _resolve_model(config: AIConfig) -> str:
+    """Resolve the model name."""
+    return config.model
+
+
+def _call_chat_api(
+    config: AIConfig,
+    model: str,
+    messages: list[dict[str, str]],
+    temperature: float,
+    max_tokens: int,
+    json_mode: bool = False,
+) -> str:
+    """Make a raw HTTP POST to the chat completions endpoint."""
+    base_url = _get_api_url(config)
+    api_key = _get_api_key(config)
+
+    body: dict[str, Any] = {
+        "model": model,
+        "messages": messages,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+    }
+    if json_mode:
+        body["response_format"] = {"type": "json_object"}
+
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {api_key}",
+    }
+
+    resp = httpx.post(
+        f"{base_url}/chat/completions",
+        json=body,
+        headers=headers,
+        timeout=_TIMEOUT,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+    return data["choices"][0]["message"]["content"] or ""
+
+
+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."""
+    model = _resolve_model(config)
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": user_prompt},
+    ]
+
+    input_tokens = count_tokens(system_prompt + user_prompt, config.model)
+    logger.info(f"AI call → {model} ({input_tokens} input tokens)")
+
+    try:
+        content = _call_chat_api(
+            config, model, messages, config.temperature,
+            max_tokens or config.max_tokens, json_mode,
+        )
+        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."""
+    models = [_resolve_model(config)] + (fallback_models or [])
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": user_prompt},
+    ]
+
+    last_error = None
+    for model in models:
+        try:
+            return _call_chat_api(
+                config, model, messages, config.temperature,
+                config.max_tokens, json_mode,
+            )
+        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-2.0.0/forge_core/ai/structured.py

@@ -0,0 +1,108 @@
+"""Structured AI outputs using JSON mode + dataclass parsing."""
+
+from __future__ import annotations
+
+import dataclasses
+import json
+from typing import Any, TypeVar, get_type_hints
+
+from forge_core.models.config import AIConfig
+from forge_core.ai.provider import complete
+from forge_core.utils import logger
+
+T = TypeVar("T")
+
+
+def _schema_from_dataclass(cls: type) -> dict[str, Any]:
+    """Generate a minimal JSON schema from a dataclass."""
+    hints = get_type_hints(cls)
+    properties: dict[str, Any] = {}
+    for f in dataclasses.fields(cls):
+        hint = hints.get(f.name, str)
+        hint_str = str(hint)
+        if hint_str.startswith("list") or "list[" in hint_str.lower():
+            properties[f.name] = {"type": "array"}
+        elif hint_str.startswith("dict") or "dict[" in hint_str.lower():
+            properties[f.name] = {"type": "object"}
+        elif hint in (int,) or "int" in hint_str:
+            properties[f.name] = {"type": "integer"}
+        elif hint in (float,):
+            properties[f.name] = {"type": "number"}
+        elif hint in (bool,):
+            properties[f.name] = {"type": "boolean"}
+        else:
+            properties[f.name] = {"type": "string"}
+    return {"type": "object", "properties": properties}
+
+
+def _dict_to_dataclass(cls: type[T], data: dict[str, Any]) -> T:
+    """Recursively convert a dict to a dataclass, handling nested dataclasses."""
+    hints = get_type_hints(cls)
+    kwargs: dict[str, Any] = {}
+    for f in dataclasses.fields(cls):
+        if f.name not in data:
+            continue
+        val = data[f.name]
+        hint = hints.get(f.name)
+        # Check if the hint is itself a dataclass
+        if dataclasses.is_dataclass(hint) and isinstance(val, dict):
+            kwargs[f.name] = _dict_to_dataclass(hint, val)
+        elif isinstance(val, list) and val:
+            # Try to detect nested dataclass in list
+            inner = getattr(hint, "__args__", [None])[0] if hasattr(hint, "__args__") else None
+            if inner and dataclasses.is_dataclass(inner):
+                kwargs[f.name] = [_dict_to_dataclass(inner, item) if isinstance(item, dict) else item for item in val]
+            else:
+                kwargs[f.name] = val
+        else:
+            kwargs[f.name] = val
+    return cls(**kwargs)
+
+
+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 JSON mode + dataclass.
+
+    Forces the AI to return data matching a dataclass schema.
+    Retries on validation failure.
+    """
+    schema = _schema_from_dataclass(response_model)
+    structured_prompt = (
+        f"{system_prompt}\n\n"
+        f"You MUST respond with valid JSON matching this schema:\n"
+        f"```json\n{json.dumps(schema, indent=2)}\n```\n"
+        f"Respond ONLY with the JSON object, no other text."
+    )
+
+    logger.info(f"Structured extraction → {config.model} → {response_model.__name__}")
+
+    last_error = None
+    for attempt in range(max_retries + 1):
+        try:
+            raw = complete(config, structured_prompt, user_prompt, json_mode=True)
+            # Strip markdown code fences if present
+            cleaned = raw.strip()
+            if cleaned.startswith("```"):
+                cleaned = cleaned.split("\n", 1)[1] if "\n" in cleaned else cleaned
+                if cleaned.endswith("```"):
+                    cleaned = cleaned[:-3]
+                cleaned = cleaned.strip()
+
+            data = json.loads(cleaned)
+            result = _dict_to_dataclass(response_model, data)
+            logger.success(f"Extracted {response_model.__name__} successfully")
+            return result
+        except Exception as e:
+            last_error = e
+            if attempt < max_retries:
+                logger.warn(f"Extraction attempt {attempt + 1} failed: {e}, retrying...")
+            continue
+
+    raise RuntimeError(
+        f"Structured extraction failed after {max_retries + 1} attempts: {last_error}"
+    )

{switchforge-1.1.0 → switchforge-2.0.0}/forge_core/models/config.py

@@ -1,13 +1,12 @@
-"""Pydantic models for configuration and tenant/plan data."""
+"""Data models for configuration and tenant/plan data."""
 
 from __future__ import annotations
 
+from dataclasses import dataclass, field
 from enum import Enum
 from pathlib import Path
 from typing import Optional
 
-from pydantic import BaseModel, Field
-
 
 class Plan(str, Enum):
     FREE = "free"
@@ -31,7 +30,8 @@ class RunMode(str, Enum):
     ANALYZE_REVIEW = "analyze_review"
 
 
-class TenantInfo(BaseModel):
+@dataclass
+class TenantInfo:
     """Multi-tenant identification — populated by SaaS or CLI."""
 
     org_id: str = ""
@@ -40,7 +40,8 @@ class TenantInfo(BaseModel):
     project_id: str = ""
 
 
-class PlanLimits(BaseModel):
+@dataclass
+class PlanLimits:
     """Usage limits per plan tier."""
 
     plan: Plan = Plan.FREE
@@ -55,7 +56,7 @@ class PlanLimits(BaseModel):
         if plan == Plan.PRO:
             return cls(
                 plan=plan,
-                max_tests_per_month=-1,  # unlimited
+                max_tests_per_month=-1,
                 max_repos=-1,
                 ci_cd_enabled=True,
                 cross_project_learning=True,
@@ -73,7 +74,8 @@ class PlanLimits(BaseModel):
         return cls()
 
 
-class AIConfig(BaseModel):
+@dataclass
+class AIConfig:
     """AI provider configuration."""
 
     provider: AIProvider = AIProvider.AUTO
@@ -82,27 +84,28 @@ class AIConfig(BaseModel):
     base_url: str = ""
     temperature: float = 0.1
     max_tokens: int = 4096
-    use_saas_proxy: bool = False  # True = use our API key via SaaS
+    use_saas_proxy: bool = False
 
 
-class ForgeConfig(BaseModel):
+@dataclass
+class ForgeConfig:
     """Top-level engine configuration."""
 
     # Project
-    project_path: Path = Field(default_factory=lambda: Path("."))
+    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)
+    target_files: list[str] = field(default_factory=list)
 
     # AI
-    ai: AIConfig = Field(default_factory=AIConfig)
+    ai: AIConfig = field(default_factory=AIConfig)
 
     # Tenant
-    tenant: TenantInfo = Field(default_factory=TenantInfo)
+    tenant: TenantInfo = field(default_factory=TenantInfo)
 
     # Plan
-    limits: PlanLimits = Field(default_factory=PlanLimits)
+    limits: PlanLimits = field(default_factory=PlanLimits)
 
     # Engine
     central_agent_path: str = ""

{switchforge-1.1.0 → switchforge-2.0.0}/forge_core/models/dto.py

@@ -1,34 +1,35 @@
-"""Pydantic models for DTO registry."""
+"""Data models for DTO registry."""
 
 from __future__ import annotations
 
+from dataclasses import dataclass, field
 from typing import Optional
 
-from pydantic import BaseModel, Field
 
-
-class DTOParam(BaseModel):
+@dataclass
+class DTOParam:
     """A single constructor/field parameter of a DTO."""
 
-    name: str
-    type: str
+    name: str = ""
+    type: str = ""
     default: str = ""
     nullable: bool = False
 
 
-class DTOEntry(BaseModel):
+@dataclass
+class DTOEntry:
     """A single DTO class registered in the global registry."""
 
-    class_name: str
-    package: str
-    file_path: str
-    params: list[DTOParam] = Field(default_factory=list)
+    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)
+    validation_annotations: list[str] = field(default_factory=list)
+    nested_dtos: list[str] = field(default_factory=list)
+    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."""
@@ -39,15 +40,16 @@ class DTOEntry(BaseModel):
         return f"{self.class_name}({params_str})"
 
 
-class DTORegistry(BaseModel):
-    """Global registry of all DTOs in the project — read once, shared everywhere."""
+@dataclass
+class DTORegistry:
+    """Global registry of all DTOs in the project."""
 
-    entries: dict[str, DTOEntry] = Field(default_factory=dict)  # class_name → DTOEntry
+    entries: dict[str, DTOEntry] = field(default_factory=dict)
 
     def register(self, entry: DTOEntry) -> None:
         self.entries[entry.class_name] = entry
 
-    def get(self, class_name: str) -> "Optional[DTOEntry]":
+    def get(self, class_name: str) -> Optional[DTOEntry]:
         return self.entries.get(class_name)
 
     def for_journey(self, journey_name: str) -> list[DTOEntry]:

switchforge-2.0.0/forge_core/models/project.py

@@ -0,0 +1,78 @@
+"""Data models for project structure — 4-Level DAG."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Component:
+    """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
+
+
+@dataclass
+class Journey:
+    """A traced user journey across layers."""
+
+    name: str = ""
+    entry_point: str = ""
+    entry_type: str = ""
+    components: list[str] = field(default_factory=list)
+    priority: int = 1
+    description: str = ""
+
+
+@dataclass
+class Layer:
+    """A functional layer within a module."""
+
+    name: str = ""
+    components: list[Component] = field(default_factory=list)
+
+
+@dataclass
+class Module:
+    """A module/package within the project."""
+
+    name: str = ""
+    path: str = ""
+    layers: list[Layer] = field(default_factory=list)
+    journeys: list[Journey] = field(default_factory=list)
+
+
+@dataclass
+class TechStack:
+    """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)
+
+
+@dataclass
+class ProjectGraph:
+    """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

{switchforge-1.1.0 → switchforge-2.0.0}/forge_core/models/test_result.py

@@ -1,40 +1,42 @@
-"""Pydantic models for test results and coverage reports."""
+"""Data models for test results and coverage reports."""
 
 from __future__ import annotations
 
+from dataclasses import dataclass, field
 from datetime import datetime
 from typing import Optional
 
-from pydantic import BaseModel, Field
 
-
-class TestFileResult(BaseModel):
+@dataclass
+class TestFileResult:
     """Result of a single generated test file."""
 
-    file_path: str
+    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)
+    errors: list[str] = field(default_factory=list)
+    compile_errors: list[str] = field(default_factory=list)
 
 
-class CoverageEntry(BaseModel):
+@dataclass
+class CoverageEntry:
     """Coverage data for a single source file."""
 
-    file_path: str
+    file_path: str = ""
     line_coverage: float = 0.0
     branch_coverage: float = 0.0
     lines_covered: int = 0
     lines_total: int = 0
 
 
-class CoverageReport(BaseModel):
+@dataclass
+class CoverageReport:
     """Aggregated coverage report."""
 
     line_coverage: float = 0.0
     branch_coverage: float = 0.0
-    files: list[CoverageEntry] = Field(default_factory=list)
+    files: list[CoverageEntry] = field(default_factory=list)
     total_lines_covered: int = 0
     total_lines: int = 0
     total_tests: int = 0
@@ -42,11 +44,12 @@ class CoverageReport(BaseModel):
     tests_failed: int = 0
 
 
-class IterationResult(BaseModel):
+@dataclass
+class IterationResult:
     """Result of a single generation iteration."""
 
-    iteration: int
-    tests_generated: list[TestFileResult] = Field(default_factory=list)
+    iteration: int = 0
+    tests_generated: list[TestFileResult] = field(default_factory=list)
     coverage_before: float = 0.0
     coverage_after: float = 0.0
     coverage_delta: float = 0.0
@@ -54,14 +57,15 @@ class IterationResult(BaseModel):
     duration_seconds: float = 0.0
 
 
-class RunReport(BaseModel):
+@dataclass
+class RunReport:
     """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)
+    started_at: datetime = field(default_factory=datetime.now)
     completed_at: Optional[datetime] = None
     duration_seconds: float = 0.0
 
@@ -75,10 +79,10 @@ class RunReport(BaseModel):
     total_tests_after: int = 0
     tests_generated: int = 0
     tests_fixed: int = 0
-    test_files_created: list[str] = Field(default_factory=list)
+    test_files_created: list[str] = field(default_factory=list)
 
     # Iterations
-    iterations: list[IterationResult] = Field(default_factory=list)
+    iterations: list[IterationResult] = field(default_factory=list)
     total_iterations: int = 0
     rollbacks: int = 0
 
@@ -90,4 +94,4 @@ class RunReport(BaseModel):
     # Metadata
     mode: str = "full"
     target_coverage: float = 90.0
-    production_files_changed: int = 0  # must always be 0
+    production_files_changed: int = 0

{switchforge-1.1.0 → switchforge-2.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "switchforge"
-version = "1.1.0"
+version = "2.0.0"
 description = "AI-powered backend test generation engine"
 readme = "README.md"
 license = "MIT"
@@ -25,12 +25,10 @@ classifiers = [
 ]
 
 dependencies = [
-    "openai>=1.30.0",
     "typer>=0.12.0",
     "rich>=13.7.0",
     "pyyaml>=6.0",
     "httpx>=0.27.0",
-    "pydantic>=2.7.0",
 ]
 
 [project.optional-dependencies]

switchforge-1.1.0/forge_core/ai/provider.py

@@ -1,120 +0,0 @@
-"""AI provider — direct OpenAI SDK, zero native dependencies."""
-
-from __future__ import annotations
-
-import os
-from typing import Any
-
-from openai import OpenAI
-
-from forge_core.models.config import AIConfig, AIProvider
-from forge_core.utils import logger
-from forge_core.utils.tokens import count_tokens
-
-
-def _get_client(config: AIConfig) -> OpenAI:
-    """Create an OpenAI-compatible client for any provider."""
-    api_key = config.api_key or os.environ.get("OPENAI_API_KEY", "")
-
-    if config.provider == AIProvider.ANTHROPIC:
-        base_url = config.base_url or "https://api.anthropic.com/v1"
-        api_key = config.api_key or os.environ.get("ANTHROPIC_API_KEY", "")
-    elif config.provider == AIProvider.OLLAMA:
-        base_url = config.base_url or "http://localhost:11434/v1"
-        api_key = "ollama"
-    elif config.provider == AIProvider.AZURE:
-        base_url = config.base_url or os.environ.get("AZURE_OPENAI_ENDPOINT", "")
-        api_key = config.api_key or os.environ.get("AZURE_OPENAI_API_KEY", "")
-    elif config.base_url:
-        base_url = config.base_url
-    else:
-        base_url = None  # default OpenAI
-
-    kwargs: dict[str, Any] = {"api_key": api_key}
-    if base_url:
-        kwargs["base_url"] = base_url
-
-    return OpenAI(**kwargs)
-
-
-def _resolve_model(config: AIConfig) -> str:
-    """Resolve the model name."""
-    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."""
-    model = _resolve_model(config)
-    client = _get_client(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 json_mode:
-        kwargs["response_format"] = {"type": "json_object"}
-
-    input_tokens = count_tokens(system_prompt + user_prompt, config.model)
-    logger.info(f"AI call → {model} ({input_tokens} input tokens)")
-
-    try:
-        response = client.chat.completions.create(**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."""
-    models = [_resolve_model(config)] + (fallback_models or [])
-    client = _get_client(config)
-
-    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 json_mode:
-                kwargs["response_format"] = {"type": "json_object"}
-
-            response = client.chat.completions.create(**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.1.0/forge_core/ai/structured.py

@@ -1,62 +0,0 @@
-"""Structured AI outputs using OpenAI JSON mode + pydantic parsing."""
-
-from __future__ import annotations
-
-import json
-from typing import TypeVar
-
-from pydantic import BaseModel
-
-from forge_core.models.config import AIConfig
-from forge_core.ai.provider import complete
-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 JSON mode + pydantic.
-
-    Forces the AI to return data matching a pydantic model schema.
-    Retries on validation failure.
-    """
-    schema = response_model.model_json_schema()
-    structured_prompt = (
-        f"{system_prompt}\n\n"
-        f"You MUST respond with valid JSON matching this schema:\n"
-        f"```json\n{json.dumps(schema, indent=2)}\n```\n"
-        f"Respond ONLY with the JSON object, no other text."
-    )
-
-    logger.info(f"Structured extraction → {config.model} → {response_model.__name__}")
-
-    last_error = None
-    for attempt in range(max_retries + 1):
-        try:
-            raw = complete(config, structured_prompt, user_prompt, json_mode=True)
-            # Strip markdown code fences if present
-            cleaned = raw.strip()
-            if cleaned.startswith("```"):
-                cleaned = cleaned.split("\n", 1)[1] if "\n" in cleaned else cleaned
-                if cleaned.endswith("```"):
-                    cleaned = cleaned[:-3]
-                cleaned = cleaned.strip()
-
-            result = response_model.model_validate_json(cleaned)
-            logger.success(f"Extracted {response_model.__name__} successfully")
-            return result
-        except Exception as e:
-            last_error = e
-            if attempt < max_retries:
-                logger.warn(f"Extraction attempt {attempt + 1} failed: {e}, retrying...")
-            continue
-
-    raise RuntimeError(
-        f"Structured extraction failed after {max_retries + 1} attempts: {last_error}"
-    )

switchforge-1.1.0/forge_core/models/project.py

@@ -1,72 +0,0 @@
-"""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