reporesolve 0.1.0__tar.gz

reporesolve-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Applied Intelligence Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

reporesolve-0.1.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: reporesolve
+Version: 0.1.0
+Summary: Agentic supervisor for building and repairing multi-repository environments
+Author: Your Name
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer>=0.12.0
+Requires-Dist: questionary>=2.0.1
+Requires-Dist: rich>=13.7.0
+Requires-Dist: python-dotenv>=1.0.1
+Dynamic: license-file
+
+# RepoResolve
+
+RepoResolve is an agentic supervisor system that builds and repairs multi-repository environments. It guides you through input collection, analyzes dependency metadata, and iteratively proposes environment changes using a reasoning agent while deterministic tools execute the steps.
+
+## What It Solves
+- Bootstrapping a working environment across multiple repos
+- Identifying dependency conflicts and setup failures
+- Iteratively refining environment proposals until smoke tests pass
+
+## Quickstart
+```bash
+pip install -e .
+reporesolve
+```
+
+## Example Output (Trimmed)
+```
+RepoResolve - Starting supervisor run...
+Cloning repos... OK
+Inspecting repos... OK
+Parsing dependencies... OK
+Attempt 1/3
+Build... OK
+Install... OK
+Smoke tests... OK
+Success
+```
+
+## How the Agent Loop Works (High Level)
+1. Tools inspect repositories and parse dependencies.
+2. The agent proposes an environment decision in strict JSON.
+3. Tools build/install/test the environment.
+4. Failures are summarized and sent back to the agent for revision.
+5. The loop stops on success, agent stop, or max attempts.
+
+## Configuration
+RepoResolve reads API keys from `.env` (if present) or environment variables.
+
+Example `.env`:
+```
+OPENAI_API_KEY=your-key
+ANTHROPIC_API_KEY=your-key
+```
+
+## Commands
+- `reporesolve` (start guided flow)
+- `reporesolve start`
+- `reporesolve config`
+- `reporesolve resume`
+- `reporesolve doctor`
+- `reporesolve version`

reporesolve-0.1.0/README.md

@@ -0,0 +1,51 @@
+# RepoResolve
+
+RepoResolve is an agentic supervisor system that builds and repairs multi-repository environments. It guides you through input collection, analyzes dependency metadata, and iteratively proposes environment changes using a reasoning agent while deterministic tools execute the steps.
+
+## What It Solves
+- Bootstrapping a working environment across multiple repos
+- Identifying dependency conflicts and setup failures
+- Iteratively refining environment proposals until smoke tests pass
+
+## Quickstart
+```bash
+pip install -e .
+reporesolve
+```
+
+## Example Output (Trimmed)
+```
+RepoResolve - Starting supervisor run...
+Cloning repos... OK
+Inspecting repos... OK
+Parsing dependencies... OK
+Attempt 1/3
+Build... OK
+Install... OK
+Smoke tests... OK
+Success
+```
+
+## How the Agent Loop Works (High Level)
+1. Tools inspect repositories and parse dependencies.
+2. The agent proposes an environment decision in strict JSON.
+3. Tools build/install/test the environment.
+4. Failures are summarized and sent back to the agent for revision.
+5. The loop stops on success, agent stop, or max attempts.
+
+## Configuration
+RepoResolve reads API keys from `.env` (if present) or environment variables.
+
+Example `.env`:
+```
+OPENAI_API_KEY=your-key
+ANTHROPIC_API_KEY=your-key
+```
+
+## Commands
+- `reporesolve` (start guided flow)
+- `reporesolve start`
+- `reporesolve config`
+- `reporesolve resume`
+- `reporesolve doctor`
+- `reporesolve version`

reporesolve-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "reporesolve"
+version = "0.1.0"
+description = "Agentic supervisor for building and repairing multi-repository environments"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+  "typer>=0.12.0",
+  "questionary>=2.0.1",
+  "rich>=13.7.0",
+  "python-dotenv>=1.0.1",
+]
+authors = [
+  { name = "Your Name" }
+]
+
+[project.scripts]
+reporesolve = "reporesolve.cli.main:app"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["reporesolve*"]

reporesolve-0.1.0/reporesolve/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

reporesolve-0.1.0/reporesolve/agent/__init__.py

@@ -0,0 +1 @@
+

reporesolve-0.1.0/reporesolve/agent/memory.py

@@ -0,0 +1,16 @@
+"""Agent memory placeholder for future decision history."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List
+
+from .schema import AgentDecision
+
+
+@dataclass
+class AgentMemory:
+    decisions: List[AgentDecision] = field(default_factory=list)
+
+    def record(self, decision: AgentDecision) -> None:
+        self.decisions.append(decision)

reporesolve-0.1.0/reporesolve/agent/planner.py

@@ -0,0 +1,77 @@
+"""Agent planner for structured decision making."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Dict
+
+from .schema import AgentDecision, DecisionError, fallback_decision
+from ..providers.base import BaseProvider
+
+
+_PROMPT_HEADER = (
+    "You are RepoResolve Agent. You must output STRICT JSON only. "
+    "No markdown, no commentary."
+)
+
+_PROMPT_SCHEMA = {
+    "action": "revise_environment | retry | stop | explain",
+    "reason": "string",
+    "changes": "list",
+    "retry": "bool",
+    "confidence": "float between 0 and 1",
+}
+
+
+class AgentPlanner:
+    def __init__(self, provider: BaseProvider) -> None:
+        self._provider = provider
+
+    def plan_initial_environment(self, dependencies: Dict[str, Any]) -> AgentDecision:
+        prompt = self._build_prompt(
+            "Generate an initial environment proposal based on dependencies.",
+            {"dependencies": dependencies},
+        )
+        return self._request_decision(prompt, {"stage": "initial", "dependencies": dependencies})
+
+    def revise_environment(
+        self, previous_attempt: Dict[str, Any], failure: Dict[str, Any]
+    ) -> AgentDecision:
+        prompt = self._build_prompt(
+            "Revise the environment based on the failure summary.",
+            {"previous_attempt": previous_attempt, "failure": failure},
+        )
+        return self._request_decision(
+            prompt,
+            {"stage": "revise", "previous_attempt": previous_attempt, "failure": failure},
+        )
+
+    def decide_next_action(self, state: Dict[str, Any]) -> AgentDecision:
+        prompt = self._build_prompt(
+            "Decide the next action based on current session state.",
+            {"state": state},
+        )
+        return self._request_decision(prompt, {"stage": "decide", "state": state})
+
+    def _build_prompt(self, instruction: str, payload: Dict[str, Any]) -> str:
+        body = json.dumps(payload, indent=2)
+        schema = json.dumps(_PROMPT_SCHEMA, indent=2)
+        return "\n\n".join(
+            [
+                _PROMPT_HEADER,
+                f"Instruction: {instruction}",
+                "Return JSON matching this schema:",
+                schema,
+                "Context:",
+                body,
+            ]
+        )
+
+    def _request_decision(self, prompt: str, context: Dict[str, Any]) -> AgentDecision:
+        try:
+            raw = self._provider.generate_decision(prompt, context)
+            return AgentDecision.from_json(raw)
+        except DecisionError as exc:
+            return fallback_decision(f"Invalid agent output: {exc}")
+        except Exception as exc:  # pragma: no cover - defensive
+            return fallback_decision(f"Provider error: {exc}")

reporesolve-0.1.0/reporesolve/agent/schema.py

@@ -0,0 +1,83 @@
+"""Agent decision schema and validation."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from typing import Any, Dict, List
+
+ALLOWED_ACTIONS = {"revise_environment", "retry", "stop", "explain"}
+
+
+class DecisionError(ValueError):
+    """Raised when an agent decision fails validation."""
+
+
+@dataclass
+class AgentDecision:
+    action: str
+    reason: str
+    changes: List[Dict[str, Any]] = field(default_factory=list)
+    retry: bool = False
+    confidence: float = 0.0
+
+    @classmethod
+    def from_dict(cls, payload: Dict[str, Any]) -> "AgentDecision":
+        if not isinstance(payload, dict):
+            raise DecisionError("Decision payload must be an object.")
+
+        action = payload.get("action")
+        reason = payload.get("reason")
+        changes = payload.get("changes", [])
+        retry = payload.get("retry", False)
+        confidence = payload.get("confidence", 0.0)
+
+        if action not in ALLOWED_ACTIONS:
+            raise DecisionError(f"Invalid action: {action}")
+        if not isinstance(reason, str) or not reason.strip():
+            raise DecisionError("Decision must include a non-empty reason.")
+        if not isinstance(changes, list):
+            raise DecisionError("Changes must be a list.")
+        if not isinstance(retry, bool):
+            raise DecisionError("Retry must be a boolean.")
+        if not isinstance(confidence, (int, float)):
+            raise DecisionError("Confidence must be a number.")
+
+        confidence_value = float(confidence)
+        if confidence_value < 0.0 or confidence_value > 1.0:
+            raise DecisionError("Confidence must be between 0 and 1.")
+
+        return cls(
+            action=action,
+            reason=reason.strip(),
+            changes=changes,
+            retry=retry,
+            confidence=confidence_value,
+        )
+
+    @classmethod
+    def from_json(cls, raw: str) -> "AgentDecision":
+        try:
+            payload = json.loads(raw)
+        except json.JSONDecodeError as exc:
+            raise DecisionError(f"Invalid JSON output: {exc}") from exc
+        return cls.from_dict(payload)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "action": self.action,
+            "reason": self.reason,
+            "changes": self.changes,
+            "retry": self.retry,
+            "confidence": self.confidence,
+        }
+
+
+def fallback_decision(message: str) -> AgentDecision:
+    return AgentDecision(
+        action="explain",
+        reason=message,
+        changes=[],
+        retry=False,
+        confidence=0.0,
+    )

reporesolve-0.1.0/reporesolve/cli/__init__.py

@@ -0,0 +1,5 @@
+"""CLI package for RepoResolve."""
+
+from .main import app
+
+__all__ = ["app"]

reporesolve-0.1.0/reporesolve/cli/main.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+import json
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from .. import __version__
+from ..config.settings import load_settings, settings_summary
+from ..supervisor.supervisor import run_supervisor
+from ..tui.flows import run_guided_flow
+from ..utils.logging import setup_logging
+from ..storage.paths import report_path
+
+app = typer.Typer(add_completion=False, help="RepoResolve - agentic supervisor system")
+console = Console()
+
+
+def _print_settings() -> None:
+    settings = load_settings()
+    summary = settings_summary(settings)
+    print("Current configuration:")
+    for key, value in summary.items():
+        print(f"- {key}: {value}")
+
+
+def _not_implemented(feature: str) -> int:
+    print(f"{feature} is not implemented yet (Phase 1 skeleton).")
+    return 0
+
+
+def _handle_start() -> int:
+    try:
+        state = run_guided_flow()
+        if state is None:
+            return 0
+        result = run_supervisor(state)
+        console.print(Panel(json.dumps(result, indent=2), title="Final Result", expand=False))
+        return 0
+    except Exception as exc:
+        console.print(Panel(f"Unexpected error: {exc}", title="Error", style="red"))
+        return 1
+
+
+def _handle_resume() -> int:
+    path = report_path()
+    if not path.exists():
+        console.print(Panel("No previous report found.", title="Resume"))
+        return 0
+
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        console.print(Panel("Report file is invalid JSON.", title="Resume"))
+        return 1
+    except Exception as exc:
+        console.print(Panel(f"Failed to read report: {exc}", title="Resume", style="red"))
+        return 1
+
+    history = data.get("history", [])
+    result = data.get("result", {})
+
+    console.print(Panel(f"Attempts: {len(history)}", title="Previous Session"))
+    if history:
+        last = history[-1]
+        decision = last.get("decision", {})
+        console.print(
+            Panel(
+                json.dumps(decision, indent=2),
+                title="Last Decision",
+                expand=False,
+            )
+        )
+    console.print(Panel(json.dumps(result, indent=2), title="Last Result", expand=False))
+    return 0
+
+
+def _handle_doctor() -> int:
+    return _not_implemented("Doctor checks")
+
+
+def _handle_config() -> int:
+    _print_settings()
+    print("Config wizard is not implemented yet (Phase 1 skeleton).")
+    return 0
+
+
+def _handle_version() -> int:
+    print(__version__)
+    return 0
+
+
+@app.callback(invoke_without_command=True)
+def _main(ctx: typer.Context) -> None:
+    setup_logging()
+    if ctx.invoked_subcommand is None:
+        raise typer.Exit(code=_handle_start())
+
+
+@app.command()
+def start() -> None:
+    """Start guided flow."""
+    raise typer.Exit(code=_handle_start())
+
+
+@app.command()
+def config() -> None:
+    """Configure provider and model."""
+    raise typer.Exit(code=_handle_config())
+
+
+@app.command()
+def resume() -> None:
+    """Resume the last session."""
+    raise typer.Exit(code=_handle_resume())
+
+
+@app.command()
+def doctor() -> None:
+    """Run system checks."""
+    raise typer.Exit(code=_handle_doctor())
+
+
+@app.command()
+def version() -> None:
+    """Show version."""
+    raise typer.Exit(code=_handle_version())
+
+
+if __name__ == "__main__":
+    app()

reporesolve-0.1.0/reporesolve/config/__init__.py

@@ -0,0 +1 @@
+

reporesolve-0.1.0/reporesolve/config/env.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict
+
+
+def load_dotenv_if_available(path: Path) -> None:
+    try:
+        from dotenv import load_dotenv  # type: ignore
+    except Exception:
+        return
+
+    if path.exists():
+        load_dotenv(path, override=False)
+
+
+def load_env_file(path: Path) -> Dict[str, str]:
+    if not path.exists():
+        return {}
+
+    values: Dict[str, str] = {}
+    for raw_line in path.read_text(encoding="utf-8").splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#"):
+            continue
+        if "=" not in line:
+            continue
+        key, value = line.split("=", 1)
+        values[key.strip()] = value.strip().strip('"').strip("'")
+    return values

reporesolve-0.1.0/reporesolve/config/settings.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Optional
+
+from .env import load_dotenv_if_available, load_env_file
+from ..storage.paths import config_file_path
+
+
+@dataclass
+class Settings:
+    provider: Optional[str] = None
+    model: Optional[str] = None
+    openai_api_key: Optional[str] = None
+    anthropic_api_key: Optional[str] = None
+
+
+def _read_config_file(path: Path) -> Dict[str, str]:
+    if not path.exists():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return {}
+    if not isinstance(data, dict):
+        return {}
+    return {str(k): str(v) for k, v in data.items()}
+
+
+def load_settings() -> Settings:
+    env_file = Path.cwd() / ".env"
+    load_dotenv_if_available(env_file)
+    env_values = load_env_file(env_file)
+
+    config_values = _read_config_file(config_file_path())
+
+    merged: Dict[str, str] = {}
+    merged.update(env_values)
+    merged.update(config_values)
+    merged.update(os.environ)
+
+    return Settings(
+        provider=merged.get("REPORESOLVE_PROVIDER") or merged.get("provider"),
+        model=merged.get("REPORESOLVE_MODEL") or merged.get("model"),
+        openai_api_key=merged.get("OPENAI_API_KEY") or merged.get("openai_api_key"),
+        anthropic_api_key=merged.get("ANTHROPIC_API_KEY")
+        or merged.get("anthropic_api_key"),
+    )
+
+
+def _mask_secret(value: Optional[str]) -> str:
+    if not value:
+        return "(not set)"
+    if len(value) <= 4:
+        return "****"
+    return "*" * (len(value) - 4) + value[-4:]
+
+
+def settings_summary(settings: Settings) -> Dict[str, str]:
+    return {
+        "provider": settings.provider or "(not set)",
+        "model": settings.model or "(not set)",
+        "openai_api_key": _mask_secret(settings.openai_api_key),
+        "anthropic_api_key": _mask_secret(settings.anthropic_api_key),
+    }

reporesolve-0.1.0/reporesolve/providers/__init__.py

@@ -0,0 +1 @@
+

reporesolve-0.1.0/reporesolve/providers/anthropic_provider.py

@@ -0,0 +1,48 @@
+"""Anthropic provider implementation."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Dict
+
+from .base import BaseProvider
+
+
+def _mock_decision(reason: str) -> str:
+    return json.dumps(
+        {
+            "action": "explain",
+            "reason": reason,
+            "changes": [],
+            "retry": False,
+            "confidence": 0.0,
+        }
+    )
+
+
+class AnthropicProvider(BaseProvider):
+    def generate_decision(self, prompt: str, context: Dict[str, Any]) -> str:
+        if not self.api_key:
+            return _mock_decision("Anthropic API key not configured.")
+
+        try:
+            import anthropic  # type: ignore
+        except Exception:
+            return _mock_decision("Anthropic SDK not installed; returning mock decision.")
+
+        try:
+            client = anthropic.Anthropic(api_key=self.api_key)
+            model = self.model or "claude-sonnet-4-6"
+            message = client.messages.create(
+                model=model,
+                max_tokens=512,
+                messages=[{"role": "user", "content": prompt}],
+            )
+            text = None
+            if hasattr(message, "content") and message.content:
+                text = message.content[0].text
+            if not text:
+                return _mock_decision("Anthropic response missing text output.")
+            return text
+        except Exception as exc:
+            return _mock_decision(f"Anthropic call failed: {exc}")

reporesolve-0.1.0/reporesolve/providers/base.py

@@ -0,0 +1,17 @@
+"""Provider interface for agent decisions."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional
+
+
+class BaseProvider(ABC):
+    def __init__(self, api_key: Optional[str] = None, model: Optional[str] = None) -> None:
+        self.api_key = api_key
+        self.model = model
+
+    @abstractmethod
+    def generate_decision(self, prompt: str, context: Dict[str, Any]) -> str:
+        """Return a JSON string matching the AgentDecision schema."""
+        raise NotImplementedError