forgeoptimizer 1.0.0__py3-none-any.whl

forgecli/engine/stages/validation_engine.py

@@ -0,0 +1,89 @@
+"""Stage 7 — Validation Engine.
+
+Applies the extracted diff to disk, runs tests, and produces a
+summary of the results. Combines :func:`forgecli.build.apply.apply_diff`,
+:func:`forgecli.build.test_run.run_tests`, and
+:func:`forgecli.build.summarize.summarize` into a single stage.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from forgecli.build import BuildContext
+from forgecli.build.apply import apply_diff
+from forgecli.build.summarize import summarize
+from forgecli.build.test_run import run_tests
+from forgecli.engine.execution import StageContext, StageResult, StageStatus
+
+
+class ValidationEngineStage:
+    """Apply the diff, run tests, and produce a summary."""
+
+    name = "validation-engine"
+
+    def __init__(self, test_command: str | None = None) -> None:
+        self._test_command = test_command
+
+    async def __call__(self, context: StageContext) -> StageResult:
+        decision = context.engine.extras.get("decision")
+        build_ctx = BuildContext(
+            prompt=context.engine.prompt,
+            root=Path(context.engine.cwd),
+            decision=decision,
+        )
+        build_ctx.diff_text = context.engine.diff_text
+        if context.engine.retrieval is not None:
+            build_ctx.retrieval = context.engine.retrieval.context_text
+
+        test_command = (
+            self._test_command or context.engine.extras.get("test_command")
+        )
+        if test_command:
+            build_ctx.extras["test_command"] = test_command
+        test_timeout = context.engine.extras.get("test_timeout")
+        if test_timeout:
+            build_ctx.extras["test_timeout"] = test_timeout
+
+        build_ctx = await apply_diff(build_ctx)
+        build_ctx = await run_tests(build_ctx)
+        build_ctx = await summarize(build_ctx)
+
+        context.engine.applied_files = build_ctx.applied_files
+        context.engine.diff_text = build_ctx.diff_text
+        context.engine.test_stdout = build_ctx.test_stdout
+        context.engine.test_stderr = build_ctx.test_stderr
+        context.engine.test_returncode = build_ctx.test_returncode
+        context.engine.extras["summary"] = build_ctx.summary
+
+        notes: list[str] = []
+        if build_ctx.applied_files:
+            notes.append(f"applied {len(build_ctx.applied_files)} files")
+        else:
+            notes.append("no files applied")
+
+        if build_ctx.test_returncode is None:
+            notes.append("tests skipped")
+        elif build_ctx.test_returncode == 0:
+            notes.append("tests passed")
+        else:
+            notes.append(f"tests FAILED (exit {build_ctx.test_returncode})")
+            return StageResult(
+                status=StageStatus.FAILED,
+                data={
+                    "applied_files": [str(p) for p in build_ctx.applied_files],
+                    "test_returncode": build_ctx.test_returncode,
+                    "test_stderr": build_ctx.test_stderr[-500:],
+                },
+                notes=tuple(notes),
+                error=f"tests failed with exit code {build_ctx.test_returncode}",
+            )
+
+        return StageResult(
+            status=StageStatus.SUCCEEDED,
+            data={
+                "applied_files": [str(p) for p in build_ctx.applied_files],
+                "test_returncode": build_ctx.test_returncode,
+            },
+            notes=tuple(notes),
+        )

forgecli/git/__init__.py

@@ -0,0 +1,9 @@
+"""Git automation layer built on top of GitPython."""
+
+from forgecli.git.repo import GitRepo
+from forgecli.git.service import GitService
+
+__all__ = [
+    "GitRepo",
+    "GitService",
+]

forgecli/git/repo.py

@@ -0,0 +1,55 @@
+"""Thin wrapper around GitPython's :class:`Repo`."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from git import Repo as _PyRepo
+from git.exc import GitError as _PyGitError
+
+from forgecli.core.errors import GitError
+
+
+class GitRepo:
+    """Wrapper around GitPython's :class:`Repo` with typed errors."""
+
+    def __init__(self, path: str | Path) -> None:
+        self._path = Path(path)
+        try:
+            self._repo = _PyRepo(str(self._path))
+        except _PyGitError as exc:
+            raise GitError(f"Not a git repository: {self._path}") from exc
+        except Exception as exc:
+            raise GitError(f"Failed to open repository at {self._path}: {exc}") from exc
+
+    @property
+    def path(self) -> Path:
+        return self._path
+
+    @property
+    def raw(self) -> _PyRepo:
+        return self._repo
+
+    @property
+    def head(self) -> str:
+        try:
+            return str(self._repo.head.commit)
+        except _PyGitError as exc:
+            raise GitError(f"Unable to read HEAD: {exc}") from exc
+
+    def is_clean(self) -> bool:
+        return not self._repo.is_dirty(untracked_files=True)
+
+    def status(self) -> dict[str, Any]:
+        """Return a small status summary; placeholder for richer UX."""
+        return {
+            "branch": self._safe_branch(),
+            "clean": self.is_clean(),
+        }
+
+    def _safe_branch(self) -> str:
+        try:
+            return self._repo.active_branch.name
+        except Exception:
+            return "detached"

forgecli/git/service.py

@@ -0,0 +1,45 @@
+"""High-level git operations: stage, branch, push, diff."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Any
+
+from forgecli.core.errors import GitError
+from forgecli.core.service import Service
+from forgecli.git.repo import GitRepo
+
+
+class GitService(Service):
+    """Convenience operations built on top of :class:`GitRepo`."""
+
+    name = "git.service"
+
+    def __init__(
+        self,
+        repo: GitRepo,
+        *,
+        default_branch: str = "main",
+    ) -> None:
+        super().__init__()
+        self._repo = repo
+        self._default_branch = default_branch
+
+    @property
+    def repo(self) -> GitRepo:
+        return self._repo
+
+    def stage(self, paths: Iterable[str | Path]) -> None:
+        """Add ``paths`` to the index."""
+        try:
+            self._repo.raw.index.add([str(p) for p in paths])
+        except Exception as exc:
+            raise GitError(f"Failed to stage files: {exc}") from exc
+
+    def current_branch(self) -> str:
+        return self._repo._safe_branch()
+
+    def diff(self, *args: Any) -> str:
+        """Return ``git diff`` output; placeholder."""
+        raise NotImplementedError("GitService.diff() is a scaffold placeholder")

forgecli/graph/__init__.py

@@ -0,0 +1,56 @@
+"""Repository graph: indexing, parsing, code intelligence.
+
+The package exposes two layers:
+
+* A small in-memory graph (:class:`CodeGraph`, :class:`Node`, :class:`Edge`)
+  used by lightweight callers and tests.
+* A back-end abstraction (:class:`RepositoryGraph`) implemented by
+  :class:`GraphifyRepositoryGraph`, which delegates to the external
+  Graphify CLI.
+"""
+
+from forgecli.graph.backend_graphify import GraphifyRepositoryGraph
+from forgecli.graph.edge import Edge, EdgeKind
+from forgecli.graph.graph import CodeGraph
+from forgecli.graph.graphify import (
+    GraphifyArtifacts,
+    GraphifyBuildOutcome,
+    GraphifyClient,
+    GraphifyInvocationError,
+    GraphifyNotFoundError,
+)
+from forgecli.graph.indexer import Indexer
+from forgecli.graph.node import Node, NodeKind
+from forgecli.graph.repository import (
+    BuildResult,
+    ExplainResult,
+    GraphCommunity,
+    GraphEdge,
+    GraphNode,
+    GraphSnapshot,
+    QueryResult,
+    RepositoryGraph,
+)
+
+__all__ = [
+    "BuildResult",
+    "CodeGraph",
+    "Edge",
+    "EdgeKind",
+    "ExplainResult",
+    "GraphCommunity",
+    "GraphEdge",
+    "GraphNode",
+    "GraphSnapshot",
+    "GraphifyArtifacts",
+    "GraphifyBuildOutcome",
+    "GraphifyClient",
+    "GraphifyInvocationError",
+    "GraphifyNotFoundError",
+    "GraphifyRepositoryGraph",
+    "Indexer",
+    "Node",
+    "NodeKind",
+    "QueryResult",
+    "RepositoryGraph",
+]