fix-cli 0.4.0__py3-none-any.whl

agent.py

@@ -0,0 +1,232 @@
+"""Agent mode for fix v3 — polls platform for contracts, investigates, proposes fixes.
+
+Runs via `fix serve`. Connects to the platform via FixClient,
+polls for open contracts, accepts compatible ones, runs LLM-driven
+investigation loop, and proposes fixes.
+"""
+
+import asyncio
+import json
+import re
+import sys
+import os
+from decimal import Decimal
+
+sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)))
+
+from protocol import MAX_INVESTIGATION_ROUNDS
+from client import FixClient
+from contract import validate_contract, contract_for_prompt
+
+
+# --- Helper functions ---
+
+def parse_llm_investigation(response: str) -> list[str]:
+    """Extract INVESTIGATE: commands from LLM response."""
+    commands = []
+    for line in response.splitlines():
+        stripped = line.strip()
+        m = re.match(r'^INVESTIGATE:\s*(.+)$', stripped, re.IGNORECASE)
+        if m:
+            cmd = m.group(1).strip()
+            if cmd:
+                commands.append(cmd)
+    return commands
+
+
+def build_agent_prompt(contract: dict, investigation_results: list[dict]) -> str:
+    """Build the prompt for the LLM with contract and investigation context."""
+    parts = []
+    parts.append("You are a fix agent. Your job is to diagnose and fix the problem described in this contract.\n")
+    parts.append("## Contract\n")
+    parts.append(json.dumps(contract, indent=2))
+    parts.append("")
+
+    if investigation_results:
+        parts.append("## Investigation Results So Far\n")
+        for i, r in enumerate(investigation_results, 1):
+            parts.append(f"### Round {i}: `{r['command']}`")
+            parts.append(f"```\n{r['output']}\n```")
+            parts.append("")
+
+    parts.append("## Instructions\n")
+    parts.append(
+        "If you need more information, output one or more lines starting with "
+        "'INVESTIGATE: <command>' where <command> is a shell command to run on "
+        "the principal's machine.\n"
+    )
+    parts.append(
+        "When you have enough information to propose a fix, output a JSON block:\n"
+        "```json\n"
+        '{"fix": "<shell command or script>", "explanation": "<why this fixes it>"}\n'
+        "```\n"
+    )
+    return "\n".join(parts)
+
+
+def capabilities_match(agent_caps: dict, contract: dict) -> tuple[bool, str]:
+    """Check if agent capabilities satisfy contract requirements."""
+    contract_caps = contract.get("capabilities", {})
+    if not contract_caps:
+        return True, ""
+
+    for cap_name, cap_spec in contract_caps.items():
+        if not isinstance(cap_spec, dict):
+            continue
+        required = cap_spec.get("available", False)
+        if not required:
+            continue
+        agent_cap = agent_caps.get(cap_name, {})
+        if not isinstance(agent_cap, dict):
+            return False, f"missing capability: {cap_name}"
+        if not agent_cap.get("available", False):
+            return False, f"capability not available: {cap_name}"
+
+    return True, ""
+
+
+class FixAgent:
+    """Agent that polls the fix platform for contracts and processes them."""
+
+    def __init__(self, config: dict):
+        """
+        config keys:
+        - platform_url: str (URL of the fix platform, default http://localhost:8000)
+        - api_key: str (platform API key)
+        - pubkey: str (agent's public key identifier)
+        - capabilities: dict
+        - min_bounty: str (minimum bounty to accept, default "0")
+        - llm_call: async callable(prompt) -> str
+        - poll_interval: float (seconds between polls, default 5.0)
+        """
+        self.platform_url = config.get("platform_url", "https://fix.notruefireman.org")
+        self.api_key = config.get("api_key", "")
+        self.pubkey = config.get("pubkey", "agent-default")
+        self.capabilities = config.get("capabilities", {})
+        self.min_bounty = Decimal(config.get("min_bounty", "0"))
+        self._llm_call = config.get("llm_call")
+        self.poll_interval = config.get("poll_interval", 5.0)
+        self._running = False
+        self.client = FixClient(base_url=self.platform_url)
+
+    async def serve(self):
+        """Main loop: poll platform for open contracts, process them."""
+        self._running = True
+        while self._running:
+            try:
+                contracts = await self.client.list_contracts(status="open")
+                for entry in contracts:
+                    contract = entry.get("contract", {})
+                    contract_id = entry.get("id", "")
+                    valid, errors = validate_contract(contract)
+                    if not valid:
+                        continue
+                    can, reason = self.can_handle(contract)
+                    if not can:
+                        continue
+                    await self.handle_contract(contract_id, contract)
+            except Exception:
+                pass  # Log and continue
+            await asyncio.sleep(self.poll_interval)
+
+    def stop(self):
+        self._running = False
+
+    async def handle_contract(self, contract_id: str, contract: dict):
+        """Process a single contract: accept, investigate, propose fix."""
+        # 1. Accept
+        await self.client.accept_contract(contract_id, self.pubkey)
+
+        # 2. Investigation loop
+        investigation_results = []
+        prompt_contract = contract_for_prompt(contract)
+        max_rounds = contract.get("execution", {}).get(
+            "investigation_rounds", MAX_INVESTIGATION_ROUNDS
+        )
+
+        fix_data = None
+        for _round in range(max_rounds):
+            prompt = build_agent_prompt(prompt_contract, investigation_results)
+            llm_response = await self._call_llm(prompt)
+
+            fix_data = self._extract_fix_proposal(llm_response)
+            if fix_data:
+                break
+
+            commands = parse_llm_investigation(llm_response)
+            if not commands:
+                break
+
+            for cmd in commands:
+                await self.client.request_investigation(contract_id, cmd, self.pubkey)
+                # Poll for result
+                result_output = await self._wait_for_result(contract_id, cmd)
+                if result_output is not None:
+                    investigation_results.append({"command": cmd, "output": result_output})
+        else:
+            # Exhausted rounds — one final LLM call
+            prompt = build_agent_prompt(prompt_contract, investigation_results)
+            llm_response = await self._call_llm(prompt)
+            fix_data = self._extract_fix_proposal(llm_response)
+
+        # 3. Submit fix
+        if not fix_data:
+            fix_data = {"fix": "", "explanation": "Unable to determine a fix within investigation rounds."}
+
+        await self.client.submit_fix(
+            contract_id,
+            fix_data["fix"],
+            fix_data.get("explanation", ""),
+            self.pubkey,
+        )
+
+    def can_handle(self, contract: dict) -> tuple[bool, str]:
+        """Check if this agent can handle the contract."""
+        escrow = contract.get("escrow", {})
+        if escrow:
+            bounty = Decimal(escrow.get("bounty", "0"))
+            if bounty < self.min_bounty:
+                return False, f"bounty {bounty} below minimum {self.min_bounty}"
+        match, reason = capabilities_match(self.capabilities, contract)
+        if not match:
+            return False, reason
+        return True, ""
+
+    async def _call_llm(self, prompt: str) -> str:
+        if self._llm_call:
+            return await self._llm_call(prompt)
+        raise NotImplementedError("LLM backend not configured. Inject llm_call in config.")
+
+    @staticmethod
+    def _extract_fix_proposal(llm_response: str) -> dict | None:
+        """Try to extract a JSON fix proposal from LLM response."""
+        m = re.search(r'```(?:json)?\s*\n?({.*?})\s*\n?```', llm_response, re.DOTALL)
+        if m:
+            try:
+                data = json.loads(m.group(1))
+                if "fix" in data and "explanation" in data:
+                    return data
+            except json.JSONDecodeError:
+                pass
+        m = re.search(r'(\{[^{}]*"fix"[^{}]*"explanation"[^{}]*\})', llm_response, re.DOTALL)
+        if m:
+            try:
+                data = json.loads(m.group(1))
+                if "fix" in data and "explanation" in data:
+                    return data
+            except json.JSONDecodeError:
+                pass
+        return None
+
+    async def _wait_for_result(self, contract_id: str, command: str, timeout: float = 60.0, poll: float = 1.0) -> str | None:
+        """Poll for investigation result from principal."""
+        import time
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            data = await self.client.get_contract(contract_id)
+            if data:
+                for msg in reversed(data.get("transcript", [])):
+                    if msg.get("type") == "result" and msg.get("command") == command:
+                        return msg.get("output", "")
+            await asyncio.sleep(poll)
+        return None

client.py

@@ -0,0 +1,160 @@
+"""Platform API client for fix protocol.
+
+Thin HTTP client with a pluggable transport interface.
+Default transport: HTTP to our centralized platform.
+"""
+
+import json
+from abc import ABC, abstractmethod
+
+import httpx
+
+
+class Transport(ABC):
+    """Override this to use Nostr, gRPC, pigeons, whatever."""
+
+    @abstractmethod
+    async def post(self, path: str, data: dict) -> dict:
+        ...
+
+    @abstractmethod
+    async def get(self, path: str, params: dict | None = None) -> dict:
+        ...
+
+
+class HTTPTransport(Transport):
+    """Default. Talks to our centralized platform over HTTP."""
+
+    def __init__(self, base_url: str = "http://localhost:8000", api_key: str = ""):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+
+    def _headers(self) -> dict:
+        h = {"Content-Type": "application/json"}
+        if self.api_key:
+            h["Authorization"] = f"Bearer {self.api_key}"
+        return h
+
+    async def post(self, path: str, data: dict) -> dict:
+        async with httpx.AsyncClient() as client:
+            resp = await client.post(
+                f"{self.base_url}{path}",
+                json=data,
+                headers=self._headers(),
+                timeout=30.0,
+            )
+            resp.raise_for_status()
+            return resp.json()
+
+    async def get(self, path: str, params: dict | None = None) -> dict:
+        async with httpx.AsyncClient() as client:
+            resp = await client.get(
+                f"{self.base_url}{path}",
+                params=params,
+                headers=self._headers(),
+                timeout=30.0,
+            )
+            resp.raise_for_status()
+            return resp.json()
+
+
+class FixClient:
+    """High-level client for the fix platform."""
+
+    def __init__(self, transport: Transport | None = None, base_url: str = "http://localhost:8000"):
+        self.transport = transport or HTTPTransport(base_url)
+
+    async def post_contract(self, contract: dict, principal_pubkey: str = "") -> str:
+        """Post a contract. Returns contract_id."""
+        resp = await self.transport.post("/contracts", {
+            "contract": contract,
+            "principal_pubkey": principal_pubkey,
+        })
+        return resp["contract_id"]
+
+    async def list_contracts(self, status: str = "open", limit: int = 50) -> list[dict]:
+        """List contracts by status."""
+        resp = await self.transport.get("/contracts", {"status": status, "limit": limit})
+        return resp["contracts"]
+
+    async def get_contract(self, contract_id: str) -> dict:
+        """Get contract details."""
+        return await self.transport.get(f"/contracts/{contract_id}")
+
+    async def accept_contract(self, contract_id: str, agent_pubkey: str) -> dict:
+        """Agent accepts a contract."""
+        return await self.transport.post(f"/contracts/{contract_id}/accept", {
+            "agent_pubkey": agent_pubkey,
+        })
+
+    async def request_investigation(self, contract_id: str, command: str, agent_pubkey: str = "") -> dict:
+        """Agent requests investigation."""
+        return await self.transport.post(f"/contracts/{contract_id}/investigate", {
+            "command": command,
+            "agent_pubkey": agent_pubkey,
+        })
+
+    async def submit_investigation_result(self, contract_id: str, command: str, output: str) -> dict:
+        """Principal submits investigation result."""
+        return await self.transport.post(f"/contracts/{contract_id}/result", {
+            "command": command,
+            "output": output,
+        })
+
+    async def submit_fix(self, contract_id: str, fix: str, explanation: str = "", agent_pubkey: str = "") -> dict:
+        """Agent submits a fix."""
+        return await self.transport.post(f"/contracts/{contract_id}/fix", {
+            "fix": fix,
+            "explanation": explanation,
+            "agent_pubkey": agent_pubkey,
+        })
+
+    async def verify(self, contract_id: str, success: bool, explanation: str = "") -> dict:
+        """Principal reports verification result."""
+        return await self.transport.post(f"/contracts/{contract_id}/verify", {
+            "success": success,
+            "explanation": explanation,
+        })
+
+    async def dispute(self, contract_id: str, argument: str, side: str = "principal") -> dict:
+        """File a dispute. Returns awaiting_response status with deadline.
+        Other side has 30s to respond before judge rules in absentia."""
+        return await self.transport.post(f"/contracts/{contract_id}/dispute", {
+            "argument": argument,
+            "side": side,
+        })
+
+    async def respond(self, contract_id: str, argument: str, side: str) -> dict:
+        """Respond to a pending dispute. Triggers judge ruling with both arguments."""
+        return await self.transport.post(f"/contracts/{contract_id}/respond", {
+            "argument": argument,
+            "side": side,
+        })
+
+    async def dispute_status(self, contract_id: str) -> dict:
+        """Check status of a pending dispute."""
+        return await self.transport.get(f"/contracts/{contract_id}/dispute_status")
+
+    async def chat(self, contract_id: str, message: str, from_side: str = "principal",
+                   msg_type: str = "message") -> dict:
+        """Send a chat message."""
+        return await self.transport.post(f"/contracts/{contract_id}/chat", {
+            "message": message,
+            "from_side": from_side,
+            "msg_type": msg_type,
+        })
+
+    async def halt(self, contract_id: str, reason: str, principal_pubkey: str = "") -> dict:
+        """Emergency halt -- freeze contract and escalate to judge."""
+        return await self.transport.post(f"/contracts/{contract_id}/halt", {
+            "reason": reason,
+            "principal_pubkey": principal_pubkey,
+        })
+
+    async def get_ruling(self, contract_id: str) -> dict | None:
+        """Get ruling for a contract."""
+        return await self.transport.get(f"/contracts/{contract_id}/ruling")
+
+    async def get_reputation(self, pubkey: str) -> dict:
+        """Get reputation stats."""
+        return await self.transport.get(f"/reputation/{pubkey}")

contract.py

@@ -0,0 +1,293 @@
+"""Contract builder and validator for fix v2.
+
+Builds, validates, and transforms contract objects used by the fix protocol.
+Contracts define what needs fixing, what the agent is allowed to do, and how
+to verify the result.
+"""
+
+import os
+import re
+import shutil
+import subprocess
+
+from protocol import DEFAULT_MAX_ATTEMPTS
+
+from scrubber import scrub
+
+
+# --- Capability detection ---
+
+def detect_capabilities():
+    """Auto-detect what tools/permissions are available on this system."""
+    caps = {}
+
+    # sudo
+    has_sudo = shutil.which("sudo") is not None
+    passwordless = False
+    if has_sudo:
+        try:
+            subprocess.run(
+                ["sudo", "-n", "true"],
+                capture_output=True, timeout=5
+            )
+            passwordless = True
+        except (subprocess.SubprocessError, OSError):
+            pass
+    caps["sudo"] = {
+        "available": False,
+        "scope": [],
+    }
+
+    # network — always available (used for package fetches)
+    caps["network"] = {"available": True, "scope": ["packages"]}
+
+    # docker
+    caps["docker"] = {"available": shutil.which("docker") is not None}
+
+    # make
+    caps["make"] = {"available": shutil.which("make") is not None}
+
+    return caps
+
+
+# --- Verification spec parsing ---
+
+def _parse_verify_spec(spec):
+    """Turn a verify_spec into a verification list.
+
+    None          -> [{"method": "exit_code", "expected": 0}]
+    "human"       -> [{"method": "human_judgment"}]
+    "contains 'X'" -> [{"method": "output_match", "pattern": "X"}]
+    list          -> recurse each element
+    dict          -> pass through as-is
+    """
+    if spec is None:
+        return [{"method": "exit_code", "expected": 0}]
+
+    if isinstance(spec, list):
+        out = []
+        for s in spec:
+            out.extend(_parse_verify_spec(s))
+        return out
+
+    if isinstance(spec, dict):
+        return [spec]
+
+    if isinstance(spec, str):
+        if spec == "human":
+            return [{"method": "human_judgment"}]
+        m = re.match(r"^contains\s+['\"](.+)['\"]$", spec)
+        if m:
+            return [{"method": "output_match", "pattern": m.group(1)}]
+        # Fallback: treat as custom method name
+        return [{"method": spec}]
+
+    return [{"method": "exit_code", "expected": 0}]
+
+
+# --- Contract builder ---
+
+def build_contract(command, stderr, env_info, **kwargs):
+    """Build a v2 fix contract.
+
+    Args:
+        command: The command that failed.
+        stderr: Raw stderr output from the failure.
+        env_info: Dict from get_env_fingerprint().
+        **kwargs: Optional overrides (see module docstring).
+
+    Returns:
+        Contract dict (v2 schema).
+    """
+    verify_spec = kwargs.get("verify_spec")
+    safe_mode = kwargs.get("safe_mode", False)
+    attempt = kwargs.get("attempt", 0)
+    prior_failures = kwargs.get("prior_failures")
+    root = kwargs.get("root")
+    bounty = kwargs.get("bounty")
+    judge = kwargs.get("judge")
+    remote = kwargs.get("remote", False)
+    redaction_config = kwargs.get("redaction_config")
+
+    # Scrub stderr — always, even local
+    scrubbed_stderr, matched_cats = scrub(stderr, redaction_config)
+    scrubbed_stderr = scrubbed_stderr[:1000]
+
+    # Scrub environment fields
+    os_str = env_info.get("os", "")
+    release = env_info.get("release", "")
+    distro = env_info.get("distro", "")
+    os_display = f"{distro} ({os_str})" if distro else os_str
+    os_display, _ = scrub(os_display, redaction_config)
+
+    arch = env_info.get("machine", "")
+
+    pkg_managers = env_info.get("package_managers", [])
+
+    contract = {
+        "version": 2,
+        "protocol": "fix",
+        "task": {
+            "type": "fix_command",
+            "command": command,
+            "error": scrubbed_stderr,
+        },
+        "environment": {
+            "os": os_display,
+            "arch": arch,
+            "package_managers": pkg_managers,
+        },
+        "capabilities": detect_capabilities(),
+        "verification": _parse_verify_spec(verify_spec),
+        "execution": {
+            "sandbox": safe_mode,
+            "root": root,
+            "max_attempts": DEFAULT_MAX_ATTEMPTS,
+            "investigation_rounds": 5,
+            "timeout": 300,
+        },
+        "redaction": {
+            "enabled": bool(matched_cats) or redaction_config is not None,
+            "categories": sorted(matched_cats) if matched_cats else [
+                "env_vars", "tokens", "paths", "ips", "emails"
+            ],
+            "custom_patterns": (
+                redaction_config.get("custom_patterns", [])
+                if redaction_config else []
+            ),
+        },
+    }
+
+    # Prior failures (scrubbed)
+    if prior_failures:
+        scrubbed_failures = []
+        for f in prior_failures:
+            sf, _ = scrub(str(f), redaction_config)
+            scrubbed_failures.append(sf[:500])
+        contract["prior_failures"] = scrubbed_failures
+
+    # Remote mode: add escrow + terms
+    if remote:
+        bounty_str = str(bounty) if bounty else "0.01"
+        contract["escrow"] = {
+            "bounty": bounty_str,
+            "currency": "XNO",
+            "chain": "nano",
+            "settle": "nano_direct",
+        }
+        contract["terms"] = {
+            "cancellation": {
+                "agent_fee": "0.002",
+                "principal_fee": "0.002",
+                "grace_period": 30,
+            },
+            "abandonment": {
+                "timeout": 120,
+                "ruling": "escalate",
+            },
+            "platform": {
+                "evidence_hash_algo": "sha256",
+            },
+        }
+        if judge:
+            contract["terms"]["judge"] = judge
+
+    return contract
+
+
+# --- Validator ---
+
+def validate_contract(contract):
+    """Validate a v2 contract dict.
+
+    Returns:
+        (True, []) if valid, (False, [errors]) otherwise.
+    """
+    errors = []
+
+    if not isinstance(contract, dict):
+        return False, ["contract is not a dict"]
+
+    # Version
+    if contract.get("version") != 2:
+        errors.append(f"version must be 2, got {contract.get('version')}")
+
+    # Task fields
+    task = contract.get("task", {})
+    if not isinstance(task, dict):
+        errors.append("task must be a dict")
+        task = {}
+    if not task.get("command"):
+        errors.append("task.command is required")
+    if "error" not in task:
+        errors.append("task.error is required")
+
+    # Environment
+    env = contract.get("environment", {})
+    if not isinstance(env, dict):
+        errors.append("environment must be a dict")
+        env = {}
+    if not env.get("os"):
+        errors.append("environment.os is required")
+    if not env.get("arch"):
+        errors.append("environment.arch is required")
+
+    # Verification
+    verification = contract.get("verification")
+    if not isinstance(verification, list) or len(verification) == 0:
+        errors.append("verification must be a non-empty list")
+
+    # Execution
+    execution = contract.get("execution", {})
+    if not isinstance(execution, dict):
+        errors.append("execution must be a dict")
+        execution = {}
+    if not isinstance(execution.get("sandbox"), bool):
+        errors.append("execution.sandbox must be a bool")
+    max_att = execution.get("max_attempts")
+    if not isinstance(max_att, int) or max_att <= 0:
+        errors.append("execution.max_attempts must be an int > 0")
+
+    # Escrow (if present)
+    escrow = contract.get("escrow")
+    if escrow is not None:
+        if not isinstance(escrow, dict):
+            errors.append("escrow must be a dict")
+        else:
+            b = escrow.get("bounty", "")
+            try:
+                float(b)
+            except (ValueError, TypeError):
+                errors.append(f"escrow.bounty must be a numeric string, got '{b}'")
+            if not escrow.get("currency"):
+                errors.append("escrow.currency is required when escrow is present")
+
+    return (len(errors) == 0, errors)
+
+
+# --- Prompt projection ---
+
+def contract_for_prompt(contract):
+    """Strip internal fields, return a copy suitable for LLM consumption.
+
+    Removes: redaction config internals, agent metadata.
+    Keeps: task, environment, capabilities, verification, execution basics, escrow/terms.
+    """
+    keep_keys = {
+        "version", "protocol", "task", "environment", "capabilities",
+        "verification", "execution", "prior_failures", "escrow", "terms",
+    }
+    out = {k: v for k, v in contract.items() if k in keep_keys}
+
+    # Strip redaction internals but note if redaction is active
+    if contract.get("redaction", {}).get("enabled"):
+        out["redaction"] = {"enabled": True}
+
+    # Strip execution internals that the LLM doesn't need
+    if "execution" in out:
+        out["execution"] = {
+            k: v for k, v in out["execution"].items()
+            if k in ("sandbox", "root", "max_attempts", "investigation_rounds", "timeout")
+        }
+
+    return out