reducio 0.1.1__py3-none-any.whl

reducio/__init__.py

@@ -0,0 +1,3 @@
+"""reducio — semantic code compression engine."""
+
+__version__ = "0.1.1"

reducio/__main__.py

@@ -0,0 +1,4 @@
+from reducio.cli import main
+
+if __name__ == "__main__":
+    main()

reducio/agents/__init__.py

@@ -0,0 +1,17 @@
+"""
+Agent implementations for code analysis and refactoring.
+"""
+
+from reducio.agents.analyzer import AnalyzerAgent
+from reducio.agents.deduplicator import DeduplicatorAgent
+from reducio.agents.idiomatizer import IdiomatizerAgent
+from reducio.agents.pattern import PatternAgent
+from reducio.agents.quality_checker import QualityCheckerAgent
+
+__all__ = [
+    "AnalyzerAgent",
+    "DeduplicatorAgent",
+    "IdiomatizerAgent",
+    "PatternAgent",
+    "QualityCheckerAgent",
+]

reducio/agents/analyzer.py

@@ -0,0 +1,17 @@
+"""Analyzer agent using the shared, versioned source metrics."""
+
+from reducio.analysis import analyze_files
+from reducio.models import AnalyzeRequest, AnalyzeResult
+from reducio.workspace import Workspace
+
+
+class AnalyzerAgent:
+    def __init__(self, workspace: Workspace):
+        self.workspace = workspace
+
+    async def analyze(self, request: AnalyzeRequest) -> AnalyzeResult:
+        return analyze_files(
+            request.files or self.workspace.list_files(),
+            self.workspace.cfg,
+            request.path,
+        )

reducio/agents/base.py

@@ -0,0 +1,151 @@
+"""Base agent class."""
+
+from __future__ import annotations
+
+import uuid
+from typing import TYPE_CHECKING
+
+from reducio.models import FileChange, PlanDiagnostic, PlanningProvenance, RefactorPlan
+from reducio.plan_review import validate_plan
+from reducio.session import SessionStore
+from reducio.utils.code_utils import strip_code_fence
+from reducio.workspace import Workspace
+
+if TYPE_CHECKING:
+    from reducio.llm.router import LLMClient
+
+
+class ModelRewriteError(RuntimeError):
+    pass
+
+
+class BaseAgent:
+    def __init__(
+        self,
+        workspace: Workspace | None = None,
+        llm_router: LLMClient | None = None,
+        session_store: SessionStore | None = None,
+    ):
+        self.workspace = workspace
+        self.llm = llm_router
+        self.session_store = session_store or SessionStore(
+            str(workspace.root / ".reducio" / "sessions") if workspace else ".reducio/sessions"
+        )
+        self._begin_plan()
+
+    def _begin_plan(self, allow_fallback: bool = False) -> None:
+        self.allow_fallback = allow_fallback
+        self.diagnostics: list[PlanDiagnostic] = []
+        self.provenance: list[PlanningProvenance] = []
+
+    def _generate_session_id(self) -> str:
+        return str(uuid.uuid4())
+
+    def _save_plan(self, plan: RefactorPlan, command_type: str) -> None:
+        self.session_store.save_plan(plan, command_type=command_type)
+
+    def get_plan(self, session_id: str) -> RefactorPlan | None:
+        return self.session_store.load_plan(session_id)
+
+    def _file_content_path(self, file) -> tuple[str, str]:
+        if hasattr(file, "content"):
+            return file.content, file.path
+        return file["content"], file["path"]
+
+    def _llm_enabled(self) -> bool:
+        # An explicit model request must not silently degrade when no router is wired.
+        return bool(
+            self.workspace
+            and (
+                self.workspace.cfg.model
+                or self.workspace.cfg.llm_api
+                or self.workspace.cfg.llm_base_url
+            )
+        )
+
+    async def _llm_rewrite(
+        self, content: str, path: str, instruction: str, description: str
+    ) -> FileChange | None:
+        """Ask the LLM to rewrite a whole module; returns a reviewable change or None."""
+        prompt = (
+            f"{instruction}\nReturn ONLY the complete rewritten module, no prose.\n\n"
+            f"```python\n{content}\n```"
+        )
+        model = self.workspace.cfg.model if self.workspace else ""
+        model = "custom endpoint" if "://" in model else model
+        try:
+            if self.llm is None:
+                raise ModelRewriteError("No model router available")
+            raw = await self.llm.complete(
+                prompt, system_prompt="You are an expert Python engineer."
+            )
+            code = strip_code_fence(raw)
+            if not code.strip():
+                raise ValueError("Empty model response")
+            compile(code, path, "exec")
+        except Exception as error:
+            from reducio.llm.router import LLMError
+
+            detail = f": {error}" if isinstance(error, LLMError) else ""
+            self.diagnostics.append(
+                PlanDiagnostic(
+                    code="model_failed",
+                    file=path,
+                    message="Model rewrite failed or returned empty/invalid Python"
+                    + detail
+                    + (
+                        "; explicit fallback enabled"
+                        if self.allow_fallback
+                        else "; no application permitted"
+                    ),
+                    severity="warning" if self.allow_fallback else "error",
+                )
+            )
+            self.provenance.append(
+                PlanningProvenance(file=path, engine="model", outcome="failed", model=model)
+            )
+            raise ModelRewriteError("Model rewrite unavailable") from None
+        self.provenance.append(
+            PlanningProvenance(
+                file=path,
+                engine="model",
+                outcome="unchanged" if code.strip() == content.strip() else "proposed",
+                model=model,
+            )
+        )
+        if code.strip() == content.strip():
+            return None
+        return FileChange(
+            path=path,
+            original=content,
+            modified=code if code.endswith("\n") else code + "\n",
+            description=description,
+        )
+
+    def _finalize_plan(
+        self, changes: list, description: str, command_type: str, **plan_kw
+    ) -> RefactorPlan:
+        plan = RefactorPlan(
+            schema_version=2,
+            session_id=self._generate_session_id(),
+            changes=changes,
+            description=description,
+            diagnostics=self.diagnostics,
+            provenance=self.provenance,
+            **plan_kw,
+        )
+        for change in plan.changes:
+            if change.operation is None:
+                change.operation = "create" if change.creates_file else "replace"
+        # Coalesce truly identical changes, but never silently pick one conflicting version.
+        unique = []
+        for change in plan.changes:
+            if change not in unique:
+                unique.append(change)
+        plan.changes = unique
+        plan.diagnostics.extend(
+            validate_plan(plan, self.workspace.root if self.workspace else None)
+        )
+        plan.complete = not any(item.severity == "error" for item in plan.diagnostics)
+        self._save_plan(plan, command_type)
+        return plan

reducio/agents/deduplicator.py

@@ -0,0 +1,193 @@
+"""Deduplicator agent — semantic duplicate detection."""
+
+from __future__ import annotations
+
+import ast
+import builtins
+import symtable
+from typing import TYPE_CHECKING
+
+from reducio.agents.base import BaseAgent
+
+if TYPE_CHECKING:
+    from reducio.embeddings.service import EmbeddingService
+from reducio.models import (
+    CodeBlock,
+    DeduplicateRequest,
+    FileChange,
+    FileInfo,
+    Language,
+    PlanDiagnostic,
+    PlanningProvenance,
+    RefactorPlan,
+)
+from reducio.parse import ParserError, get_complexity
+from reducio.plan_review import advisory_path
+from reducio.repo import detect_language
+from reducio.session import SessionStore
+from reducio.workspace import Workspace
+
+
+class DeduplicatorAgent(BaseAgent):
+    workspace: Workspace
+
+    def __init__(
+        self,
+        workspace: Workspace,
+        embedding_service: EmbeddingService,
+        llm_router=None,
+        session_store: SessionStore | None = None,
+    ):
+        super().__init__(workspace, llm_router, session_store)
+        self.embedding_service = embedding_service
+
+    async def find_duplicates(self, request: DeduplicateRequest) -> RefactorPlan:
+        self._begin_plan()
+        files = request.files or self.workspace.list_files()
+        if not self.embedding_service.is_using_real_embeddings:
+            self.diagnostics.append(
+                PlanDiagnostic(
+                    code="embeddings_unavailable",
+                    severity="error",
+                    message="Semantic embeddings unavailable; install reducio[embeddings] and retry.",
+                )
+            )
+            return self._finalize_plan(
+                [],
+                "Semantic embeddings unavailable; no duplicates analyzed. See installation docs for the embeddings extra.",
+                "deduplicate",
+            )
+        blocks = self._extract_blocks(files)
+        try:
+            groups = await self.embedding_service.find_duplicates(
+                blocks, request.similarity_threshold
+            )
+        except Exception:
+            self.diagnostics.append(
+                PlanDiagnostic(
+                    code="embeddings_failed",
+                    severity="error",
+                    message="Semantic duplicate search failed; no application permitted.",
+                )
+            )
+            groups = []
+        self.provenance.append(
+            PlanningProvenance(
+                file="",
+                engine="embeddings",
+                outcome=(
+                    "failed" if any(d.severity == "error" for d in self.diagnostics) else "scanned"
+                ),
+            )
+        )
+        changes = []
+        for group in groups:
+            if len(group) >= 2:
+                ch = self._create_dedup_change(group)
+                if ch:
+                    changes.append(ch)
+        return self._finalize_plan(
+            changes,
+            f"Found {len(groups)} duplicate group(s); proposing {len(changes)} shared-util "
+            "suggestion(s) (review before adopting — call sites are not rewritten).",
+            "deduplicate",
+        )
+
+    def _extract_blocks(self, files: list[FileInfo]) -> list[CodeBlock]:
+        blocks: list[CodeBlock] = []
+        for f in files:
+            lang = detect_language(f.path)
+            if not f.error and lang == Language.UNKNOWN:
+                continue
+            try:
+                tree = f.tree
+                module_scope = symtable.symtable(f.content, f.path, "exec")
+            except ParserError, SyntaxError, ValueError:
+                self.diagnostics.append(
+                    PlanDiagnostic(
+                        code="parser_failed",
+                        file=f.path,
+                        severity="error",
+                        message="Python parsing failed; duplicate analysis is incomplete.",
+                    )
+                )
+                continue
+            top = [n for n in tree.body if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))]
+            for node in ast.walk(tree):
+                if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and node not in top:
+                    self.diagnostics.append(
+                        PlanDiagnostic(
+                            code="unsupported_scope",
+                            file=f.path,
+                            message=f"Skipped {node.name}: methods and nested functions are not standalone utilities.",
+                        )
+                    )
+            for node in top:
+                content = ast.get_source_segment(f.content, node) or ""
+                bindings = {
+                    s.get_name()
+                    for s in module_scope.get_symbols()
+                    if s.is_assigned() or s.is_imported()
+                }
+                dependencies = _dependencies(content, node.name, bindings)
+                if node.decorator_list or dependencies:
+                    self.diagnostics.append(
+                        PlanDiagnostic(
+                            code="dependencies",
+                            file=f.path,
+                            message=f"Skipped {node.name}: decorators or external dependencies require review.",
+                        )
+                    )
+                    continue
+                try:
+                    metrics = get_complexity(content)
+                except SyntaxError, ValueError:
+                    continue  # invalid snippets have no trustworthy numeric score
+                blocks.append(
+                    CodeBlock(
+                        id=f"{f.path}:{node.lineno}:{node.name}",
+                        file=f.path,
+                        start_line=node.lineno,
+                        end_line=node.end_lineno or node.lineno,
+                        content=content,
+                        language=lang,
+                        symbol_type="function",
+                        symbol_name=node.name,
+                        metrics=metrics,
+                    )
+                )
+        return blocks
+
+    def _create_dedup_change(self, group: list[CodeBlock]) -> FileChange | None:
+        primary = group[0]
+        return FileChange(
+            path=advisory_path(
+                "utils", primary.file, f"{primary.symbol_name}_{primary.start_line}_dedup"
+            ),
+            original="",
+            modified=primary.content,
+            description=(
+                f"Proposed shared util for '{primary.symbol_name}' from {len(group)} sites "
+                "(suggestion only; applying writes the utility module; "
+                "originals and call sites are not rewritten)"
+            ),
+        )
+
+
+def _dependencies(content: str, name: str, module_bindings: set[str]) -> set[str]:
+    """Conservatively reject names that need the original module's namespace."""
+    table = symtable.symtable(content, "<advisory>", "exec")
+    required: set[str] = set()
+    pending = [table]
+    while pending:
+        scope = pending.pop()
+        required.update(
+            s.get_name()
+            for s in scope.get_symbols()
+            if (s.is_referenced() or s.is_declared_global()) and s.is_global()
+        )
+        pending.extend(scope.get_children())
+    # Recursion is self-contained; builtins need no accompanying import.
+    dynamic = {"globals", "locals", "eval", "exec", "__import__"}
+    allowed_builtins = set(dir(builtins)) - module_bindings - dynamic
+    return required - allowed_builtins - {name}

reducio/agents/idiomatizer.py

@@ -0,0 +1,85 @@
+"""
+Idiomatizer agent for transforming code to idiomatic patterns (Python heuristics).
+"""
+
+from reducio.agents.base import BaseAgent, ModelRewriteError
+from reducio.models import (
+    FileChange,
+    IdiomatizeRequest,
+    Language,
+    PlanDiagnostic,
+    PlanningProvenance,
+    RefactorPlan,
+)
+from reducio.repo import detect_language
+
+
+class IdiomatizerAgent(BaseAgent):
+    async def idiomatize(self, request: IdiomatizeRequest) -> RefactorPlan:
+        self._begin_plan(request.allow_fallback)
+        changes = []
+        idioms = 0
+        for file in request.files:
+            try:
+                change, count = await self._idiomatize_file(file)
+            except ModelRewriteError:
+                break
+            if change:
+                changes.append(change)
+                idioms += count
+        return self._finalize_plan(
+            changes,
+            f"Found {idioms} opportunities for idiomatic improvements in {len(changes)} file(s).",
+            "idiomatize",
+        )
+
+    async def _idiomatize_file(self, file) -> tuple[FileChange | None, int]:
+        content, path = self._file_content_path(file)
+        if not file.error and detect_language(path) != Language.PYTHON:
+            return None, 0
+        try:
+            file.tree  # Validated once, shared with subsequent analysis.
+        except SyntaxError, ValueError:
+            self.diagnostics.append(
+                PlanDiagnostic(
+                    code="invalid_source",
+                    file=path,
+                    severity="error",
+                    message="Cannot read or parse source; planning incomplete",
+                )
+            )
+            return None, 0
+        if self._llm_enabled():
+            try:
+                change = await self._llm_rewrite(
+                    content,
+                    path,
+                    "Rewrite the following Python module to be more idiomatic and concise without changing behaviour.",
+                    "LLM idiomatic rewrite",
+                )
+                if change:
+                    change.operation, change.encoding = "replace", file.encoding
+                return change, int(change is not None)
+            except ModelRewriteError:
+                if not self.allow_fallback:
+                    raise
+        change, count = self._idiomatize_python(content, path)
+        if change:
+            change.operation, change.encoding = "replace", file.encoding
+        self.provenance.append(
+            PlanningProvenance(
+                file=path, engine="heuristic", outcome="proposed" if change else "unchanged"
+            )
+        )
+        return change, count
+
+    def _idiomatize_python(self, content: str, path: str) -> tuple[FileChange | None, int]:
+        from reducio.idioms import rewrite
+
+        updated, descriptions, diagnostics = rewrite(content, path)
+        self.diagnostics.extend(diagnostics)
+        if updated == content:
+            return None, 0
+        return FileChange(
+            path=path, original=content, modified=updated, description="; ".join(descriptions)
+        ), len(descriptions)