archapi 0.3.0__py3-none-any.whl

archapi/frameworks/express_ts/adapter.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, List
+
+from archapi.frameworks.generic import GenericAdapter
+from archapi.types import APIPlan, APIGenome, GeneratedFile, ScanResult, ValidationReport
+
+
+class ExpressTypeScriptAdapter(GenericAdapter):
+    name = "express-typescript"
+
+    def scan(self, project_path: Path) -> ScanResult:
+        result = super().scan(project_path)
+        result.framework = self.name
+        return result
+
+    def extract_genome(self, maps: Dict[str, Any], scan_result: ScanResult) -> APIGenome:
+        genome = super().extract_genome(maps, scan_result)
+        genome.framework = self.name
+
+        package_json = scan_result.project_path / "package.json"
+        package_text = ""
+        if package_json.exists():
+            package_text = package_json.read_text(
+                encoding="utf-8",
+                errors="ignore",
+            ).lower()
+
+        if "zod" in package_text:
+            genome.schema_style = "zod"
+        elif "joi" in package_text:
+            genome.schema_style = "joi"
+
+        if "jest" in package_text and "supertest" in package_text:
+            genome.test_style = "jest-supertest"
+
+        genome.route_style = "express-router" if scan_result.routes else "unknown"
+        genome.controller_style = "express-controller" if scan_result.controllers else "unknown"
+        genome.service_style = "service-layer" if scan_result.services else "unknown"
+        genome.metadata["language"] = "typescript"
+        genome.metadata["project_path"] = str(scan_result.project_path)
+
+        required_layers = [
+            bool(scan_result.routes),
+            bool(scan_result.controllers),
+            bool(scan_result.services),
+        ]
+
+        has_express_package = "express" in package_text
+
+        if not any(required_layers):
+            genome.confidence = min(genome.confidence, 0.10)
+        elif not has_express_package:
+            # If route/controller/service layers are present but package.json is missing
+            # at project root, allow generation with warning-level confidence.
+            # This supports config-hint mode for monorepos or unusual layouts.
+            genome.confidence = min(genome.confidence, 0.65)
+            genome.metadata["package_json_warning"] = "Express package.json not found at project root."
+
+        return genome
+
+    def generate_code(
+        self,
+        plan: APIPlan,
+        genome: APIGenome,
+        maps: Dict[str, Any],
+    ) -> List[GeneratedFile]:
+        if not plan.generation_allowed:
+            return []
+
+        entity = plan.entities[-1] if plan.entities else "Resource"
+        entity_pascal = entity[0].upper() + entity[1:]
+        entity_lower = entity_pascal[0].lower() + entity_pascal[1:]
+        entity_file = entity_lower.lower()
+
+        route_dir = self._output_dir(maps, "route_map", "src/routes")
+        controller_dir = self._output_dir(maps, "controller_map", "src/controllers")
+        service_dir = self._output_dir(maps, "service_map", "src/services")
+        schema_dir = self._output_dir(maps, "schema_map", "src/schemas")
+        test_dir = self._output_dir(maps, "test_map", "tests")
+
+        route_path = route_dir / f"{entity_file}.routes.ts"
+        controller_path = controller_dir / f"{entity_file}.controller.ts"
+        service_path = service_dir / f"{entity_file}.service.ts"
+        schema_path = schema_dir / f"{entity_file}.schema.ts"
+        test_path = test_dir / f"{entity_file}.test.ts"
+
+        express_path = (
+            plan.path
+            .replace("{user_id}", ":userId")
+            .replace("{product_id}", ":productId")
+            .replace("{id}", ":id")
+        )
+
+        status_code = int(plan.metadata.get("response_status", 200))
+        action = plan.metadata.get("action", "unknown")
+
+        route_content = f"""import {{ Router, Request, Response, NextFunction }} from "express";
+import {{ {entity_lower}Controller }} from "../controllers/{entity_file}.controller";
+import {{ {entity_lower}RequestSchema }} from "../schemas/{entity_file}.schema";
+
+const router = Router();
+
+function validate{entity_pascal}Request(req: Request, res: Response, next: NextFunction) {{
+  const parsed = {entity_lower}RequestSchema.safeParse({{
+    params: req.params,
+    query: req.query,
+    body: req.body,
+  }});
+
+  if (!parsed.success) {{
+    return res.status(400).json({{ errors: parsed.error.flatten() }});
+  }}
+
+  return next();
+}}
+
+router.{plan.method.lower()}("{express_path}", validate{entity_pascal}Request, {entity_lower}Controller.handle);
+
+export default router;
+"""
+
+        controller_content = f"""import {{ Request, Response, NextFunction }} from "express";
+import {{ {entity_lower}Service }} from "../services/{entity_file}.service";
+
+export const {entity_lower}Controller = {{
+  async handle(req: Request, res: Response, next: NextFunction) {{
+    try {{
+      const result = await {entity_lower}Service.execute({{
+        params: req.params,
+        query: req.query,
+        body: req.body,
+      }});
+
+      return res.status({status_code}).json({{ data: result }});
+    }} catch (error) {{
+      return next(error);
+    }}
+  }},
+}};
+"""
+
+        service_content = f"""type {entity_pascal}ServiceInput = {{
+  params: Record<string, unknown>;
+  query: Record<string, unknown>;
+  body: unknown;
+}};
+
+export const {entity_lower}Service = {{
+  async execute(input: {entity_pascal}ServiceInput) {{
+    // TODO: Replace this placeholder with project-specific business logic.
+    return {{
+      message: "{entity_pascal} API placeholder response",
+      action: "{action}",
+      params: input.params,
+      query: input.query,
+      body: input.body,
+    }};
+  }},
+}};
+"""
+
+        schema_content = f"""import {{ z }} from "zod";
+
+export const {entity_lower}RequestSchema = z.object({{
+  params: z.record(z.unknown()).optional(),
+  query: z.record(z.unknown()).optional(),
+  body: z.unknown().optional(),
+}});
+
+export type {entity_pascal}Request = z.infer<typeof {entity_lower}RequestSchema>;
+"""
+
+        test_content = f"""describe("{entity_pascal} API", () => {{
+  it("should have a generated placeholder test", () => {{
+    // TODO: Replace this placeholder with a real Supertest request.
+    expect(true).toBe(true);
+  }});
+}});
+"""
+
+        return [
+            GeneratedFile(route_path, route_content),
+            GeneratedFile(controller_path, controller_content),
+            GeneratedFile(service_path, service_content),
+            GeneratedFile(schema_path, schema_content),
+            GeneratedFile(test_path, test_content),
+        ]
+
+    def _output_dir(self, maps: Dict[str, Any], map_key: str, fallback: str) -> Path:
+        values = maps.get(map_key, {})
+        project_path = Path(maps.get("_project_path", "."))
+
+        if isinstance(values, dict) and values:
+            first_path = Path(next(iter(values.values()))).resolve()
+            parent = first_path.parent
+
+            try:
+                return parent.relative_to(project_path)
+            except ValueError:
+                return Path(fallback)
+
+        return Path(fallback)
+
+    def validate_generated_code(
+        self,
+        files: List[GeneratedFile],
+        plan: APIPlan,
+        genome: APIGenome,
+    ) -> ValidationReport:
+        errors: List[str] = []
+        warnings: List[str] = []
+
+        if not plan.generation_allowed:
+            errors.append(plan.reason or "Generation not allowed.")
+
+        required_layers = ["routes", "controllers", "services", "schemas", "tests"]
+        generated_paths = [str(file.path) for file in files]
+
+        for layer in required_layers:
+            if not any(layer in path for path in generated_paths):
+                errors.append(f"Missing generated {layer} layer.")
+
+        for file in files:
+            if not file.content.strip():
+                errors.append(f"Generated file is empty: {file.path}")
+
+            if Path(file.path).exists():
+                warnings.append(
+                    f"Generated file path already exists relative to current directory: {file.path}"
+                )
+
+        if genome.confidence < 0.75:
+            warnings.append("Architecture confidence is moderate; review generated files before applying.")
+
+        return ValidationReport(success=not errors, errors=errors, warnings=warnings)

archapi/frameworks/fastapi_adapter.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, List
+
+from archapi.frameworks.generic import GenericAdapter
+from archapi.types import APIPlan, APIGenome, GeneratedFile, ScanResult, ValidationReport
+
+
+class FastAPIAdapter(GenericAdapter):
+    name = "fastapi"
+
+    def scan(self, project_path: Path) -> ScanResult:
+        result = super().scan(project_path)
+        result.framework = self.name
+        return result
+
+    def extract_genome(self, maps: Dict[str, Any], scan_result: ScanResult) -> APIGenome:
+        genome = super().extract_genome(maps, scan_result)
+        genome.framework = self.name
+
+        req = scan_result.project_path / "requirements.txt"
+        pyproject = scan_result.project_path / "pyproject.toml"
+
+        dep_text = ""
+        if req.exists():
+            dep_text += req.read_text(encoding="utf-8", errors="ignore").lower()
+        if pyproject.exists():
+            dep_text += pyproject.read_text(encoding="utf-8", errors="ignore").lower()
+
+        genome.route_style = "fastapi-apirouter" if scan_result.routes else "unknown"
+        genome.controller_style = "fastapi-endpoint" if scan_result.controllers or scan_result.routes else "unknown"
+        genome.service_style = "service-layer" if scan_result.services else "unknown"
+        genome.schema_style = "pydantic" if "pydantic" in dep_text or scan_result.schemas else "unknown"
+        genome.test_style = "pytest" if "pytest" in dep_text or scan_result.tests else "unknown"
+        genome.metadata["language"] = "python"
+        genome.metadata["project_path"] = str(scan_result.project_path)
+
+        has_fastapi_dependency = "fastapi" in dep_text
+
+        if not scan_result.routes and not scan_result.services:
+            genome.confidence = min(genome.confidence, 0.10)
+        elif not has_fastapi_dependency:
+            genome.confidence = min(genome.confidence, 0.65)
+            genome.metadata["dependency_warning"] = "FastAPI dependency not found at project root."
+
+        return genome
+
+    def generate_code(
+        self,
+        plan: APIPlan,
+        genome: APIGenome,
+        maps: Dict[str, Any],
+    ) -> List[GeneratedFile]:
+        if not plan.generation_allowed:
+            return []
+
+        entity = plan.entities[-1] if plan.entities else "Resource"
+        entity_pascal = entity[0].upper() + entity[1:]
+        entity_lower = entity_pascal[0].lower() + entity_pascal[1:]
+        entity_file = entity_lower.lower()
+
+        router_dir = self._output_dir(maps, "route_map", "app/routers")
+        service_dir = self._output_dir(maps, "service_map", "app/services")
+        schema_dir = self._output_dir(maps, "schema_map", "app/schemas")
+        test_dir = self._output_dir(maps, "test_map", "tests")
+
+        router_path = router_dir / f"{entity_file}_router.py"
+        service_path = service_dir / f"{entity_file}_service.py"
+        schema_path = schema_dir / f"{entity_file}_schema.py"
+        test_path = test_dir / f"test_{entity_file}.py"
+
+        method = plan.method.lower()
+        status_code = int(plan.metadata.get("response_status", 200))
+        action = plan.metadata.get("action", "unknown")
+
+        router_content = f'''from fastapi import APIRouter, HTTPException
+from app.schemas.{entity_file}_schema import {entity_pascal}Request, {entity_pascal}Response
+from app.services.{entity_file}_service import {entity_lower}_service
+
+router = APIRouter()
+
+
+@router.{method}("{plan.path}", response_model={entity_pascal}Response, status_code={status_code})
+async def handle_{entity_lower}(request: {entity_pascal}Request = None):
+    try:
+        result = await {entity_lower}_service.execute(request)
+        return result
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=str(exc))
+'''
+
+        service_content = f'''from app.schemas.{entity_file}_schema import {entity_pascal}Request, {entity_pascal}Response
+
+
+class {entity_pascal}Service:
+    async def execute(self, request: {entity_pascal}Request | None) -> {entity_pascal}Response:
+        # TODO: Replace this placeholder with project-specific business logic.
+        return {entity_pascal}Response(
+            message="{entity_pascal} API placeholder response",
+            action="{action}",
+        )
+
+
+{entity_lower}_service = {entity_pascal}Service()
+'''
+
+        schema_content = f'''from pydantic import BaseModel
+from typing import Optional, Any, Dict
+
+
+class {entity_pascal}Request(BaseModel):
+    params: Optional[Dict[str, Any]] = None
+    query: Optional[Dict[str, Any]] = None
+    body: Optional[Any] = None
+
+
+class {entity_pascal}Response(BaseModel):
+    message: str
+    action: str
+'''
+
+        test_content = f'''def test_{entity_lower}_generated_placeholder():
+    # TODO: Replace this placeholder with a real TestClient request.
+    assert True
+'''
+
+        return [
+            GeneratedFile(router_path, router_content),
+            GeneratedFile(service_path, service_content),
+            GeneratedFile(schema_path, schema_content),
+            GeneratedFile(test_path, test_content),
+        ]
+
+    def _output_dir(self, maps: Dict[str, Any], map_key: str, fallback: str) -> Path:
+        values = maps.get(map_key, {})
+        project_path = Path(maps.get("_project_path", "."))
+
+        if isinstance(values, dict) and values:
+            first_path = Path(next(iter(values.values()))).resolve()
+            parent = first_path.parent
+
+            try:
+                return parent.relative_to(project_path)
+            except ValueError:
+                return Path(fallback)
+
+        return Path(fallback)
+
+    def validate_generated_code(
+        self,
+        files: List[GeneratedFile],
+        plan: APIPlan,
+        genome: APIGenome,
+    ) -> ValidationReport:
+        errors: List[str] = []
+        warnings: List[str] = []
+
+        if not plan.generation_allowed:
+            errors.append(plan.reason or "Generation not allowed.")
+
+        required_suffixes = ["_router.py", "_service.py", "_schema.py"]
+        generated_paths = [str(file.path) for file in files]
+
+        for suffix in required_suffixes:
+            if not any(path.endswith(suffix) for path in generated_paths):
+                errors.append(f"Missing generated FastAPI layer: {suffix}")
+
+        if not any("/test_" in path or path.startswith("tests/test_") for path in generated_paths):
+            errors.append("Missing generated FastAPI test layer.")
+
+        for file in files:
+            if not file.content.strip():
+                errors.append(f"Generated file is empty: {file.path}")
+
+            if Path(file.path).exists():
+                warnings.append(
+                    f"Generated file path already exists relative to current directory: {file.path}"
+                )
+
+        if genome.confidence < 0.75:
+            warnings.append("Architecture confidence is moderate; review generated files before applying.")
+
+        return ValidationReport(success=not errors, errors=errors, warnings=warnings)

archapi/frameworks/generic.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, List
+
+from archapi.frameworks.base import FrameworkAdapter
+from archapi.planning.intent_planner import IntentPlanner
+from archapi.types import (
+    APIPlan,
+    APIGenome,
+    DetectionResult,
+    GeneratedFile,
+    ScanResult,
+    ValidationReport,
+)
+
+
+IGNORED_DIRS = {
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    "coverage",
+    ".venv",
+    "__pycache__",
+    "vendor",
+    "target",
+    ".archapi",
+    "sample_projects",
+    "archapi.egg-info",
+}
+
+
+class GenericAdapter(FrameworkAdapter):
+    name = "generic"
+
+    def detect(self, project_path: Path) -> DetectionResult:
+        return DetectionResult("generic", 0.10, ["Fallback generic adapter"])
+
+    def scan(self, project_path: Path) -> ScanResult:
+        result = ScanResult(framework=self.name, project_path=project_path)
+
+        for path in self._walk_files(project_path):
+            lower = str(path).lower()
+
+            if "route" in lower or "url" in lower:
+                result.routes.append(path)
+            elif "controller" in lower or "handler" in lower or "view" in lower:
+                result.controllers.append(path)
+            elif "service" in lower:
+                result.services.append(path)
+            elif "model" in lower or "entity" in lower:
+                result.models.append(path)
+            elif "schema" in lower or "serializer" in lower or "dto" in lower:
+                result.schemas.append(path)
+            elif "middleware" in lower or "permission" in lower or "auth" in lower:
+                result.middleware.append(path)
+            elif "test" in lower or "spec" in lower:
+                result.tests.append(path)
+            elif path.name in {
+                "package.json",
+                "pyproject.toml",
+                "requirements.txt",
+                "pom.xml",
+                "build.gradle",
+                "go.mod",
+                "composer.json",
+                "Gemfile",
+            }:
+                result.config_files.append(path)
+            else:
+                result.unknown.append(path)
+
+        return result
+
+    def build_maps(self, scan_result: ScanResult) -> Dict[str, Any]:
+        return {
+            "_project_path": str(scan_result.project_path),
+            "file_map": {
+                str(path.relative_to(scan_result.project_path)): str(path)
+                for path in (
+                    scan_result.routes
+                    + scan_result.controllers
+                    + scan_result.services
+                    + scan_result.models
+                    + scan_result.schemas
+                    + scan_result.middleware
+                    + scan_result.tests
+                )
+            },
+            "route_map": self._name_map(scan_result.routes),
+            "controller_map": self._name_map(scan_result.controllers),
+            "service_map": self._name_map(scan_result.services),
+            "model_map": self._name_map(scan_result.models),
+            "schema_map": self._name_map(scan_result.schemas),
+            "middleware_map": self._name_map(scan_result.middleware),
+            "test_map": self._name_map(scan_result.tests),
+        }
+
+    def extract_genome(self, maps: Dict[str, Any], scan_result: ScanResult) -> APIGenome:
+        confidence = 0.0
+        confidence += 0.20 if scan_result.routes else 0
+        confidence += 0.20 if scan_result.controllers else 0
+        confidence += 0.20 if scan_result.services else 0
+        confidence += 0.15 if scan_result.models else 0
+        confidence += 0.15 if scan_result.schemas else 0
+        confidence += 0.10 if scan_result.tests else 0
+
+        return APIGenome(
+            framework=self.name,
+            route_style="detected" if scan_result.routes else "unknown",
+            controller_style="detected" if scan_result.controllers else "unknown",
+            service_style="detected" if scan_result.services else "unknown",
+            model_style="detected" if scan_result.models else "unknown",
+            schema_style="detected" if scan_result.schemas else "unknown",
+            auth_style="detected" if scan_result.middleware else "unknown",
+            test_style="detected" if scan_result.tests else "unknown",
+            confidence=round(confidence, 2),
+        )
+
+    def plan_api(self, request: str, genome: APIGenome, maps: Dict[str, Any]) -> APIPlan:
+        intent = IntentPlanner().plan(request)
+
+        generation_allowed = genome.confidence >= 0.45
+        reason = None if generation_allowed else "Architecture confidence too low; returning plan only."
+
+        return APIPlan(
+            request=request,
+            method=intent.method,
+            path=intent.path,
+            entities=intent.entities,
+            layers=["route", "controller", "service", "schema", "test"],
+            generation_allowed=generation_allowed,
+            reason=reason,
+            metadata={
+                "adapter": self.name,
+                "resource": intent.resource,
+                "action": intent.action,
+                "response_status": intent.response_status,
+                **intent.metadata,
+            },
+        )
+
+    def generate_code(
+        self,
+        plan: APIPlan,
+        genome: APIGenome,
+        maps: Dict[str, Any],
+    ) -> List[GeneratedFile]:
+        if not plan.generation_allowed:
+            return []
+
+        entity = plan.entities[-1] if plan.entities else "Resource"
+        lower = entity.lower()
+
+        return [
+            GeneratedFile(
+                path=Path(f"generated/{lower}_api.txt"),
+                content=(
+                    "# Generated API plan\n"
+                    f"method: {plan.method}\n"
+                    f"path: {plan.path}\n"
+                    f"entity: {entity}\n"
+                    "note: Generic framework fallback was used.\n"
+                ),
+            )
+        ]
+
+    def validate_generated_code(
+        self,
+        files: List[GeneratedFile],
+        plan: APIPlan,
+        genome: APIGenome,
+    ) -> ValidationReport:
+        errors = []
+        warnings = []
+
+        if not plan.generation_allowed:
+            errors.append(plan.reason or "Generation not allowed.")
+
+        if plan.generation_allowed and not files:
+            errors.append("No files generated.")
+
+        for file in files:
+            if not file.content.strip():
+                errors.append(f"Generated file is empty: {file.path}")
+
+        return ValidationReport(success=not errors, errors=errors, warnings=warnings)
+
+    def _walk_files(self, root: Path) -> List[Path]:
+        files = []
+        root = Path(root)
+
+        for path in root.rglob("*"):
+            if path.is_dir():
+                continue
+
+            try:
+                rel_parts = path.relative_to(root).parts
+            except ValueError:
+                rel_parts = path.parts
+
+            if any(part in IGNORED_DIRS for part in rel_parts):
+                continue
+
+            files.append(path)
+
+        return files
+
+    def _name_map(self, paths: List[Path]) -> Dict[str, str]:
+        return {path.stem: str(path) for path in paths}

archapi/frameworks/registry.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from archapi.frameworks.generic import GenericAdapter
+from archapi.frameworks.express_ts.adapter import ExpressTypeScriptAdapter
+from archapi.frameworks.fastapi_adapter import FastAPIAdapter
+
+
+class FrameworkRegistry:
+    def __init__(self) -> None:
+        generic = GenericAdapter()
+
+        self._adapters = {
+            "generic": generic,
+            "express-typescript": ExpressTypeScriptAdapter(),
+            "nestjs": generic,
+            "fastapi": FastAPIAdapter(),
+            "django-drf": generic,
+            "flask": generic,
+            "spring-boot": generic,
+            "dotnet-core": generic,
+            "laravel": generic,
+            "rails": generic,
+            "go-api": generic,
+            "node-unknown": generic,
+        }
+
+    def get(self, framework: str):
+        return self._adapters.get(framework, self._adapters["generic"])