fix-cli 0.4.0__tar.gz

fix_cli-0.4.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Karan Sharma
+
+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.

fix_cli-0.4.0/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: fix-cli
+Version: 0.4.0
+Summary: AI-powered command fixer with contract-based dispute resolution
+Author-email: Karan Sharma <karans4@protonmail.com>
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.24
+Provides-Extra: server
+Requires-Dist: fastapi>=0.100; extra == "server"
+Requires-Dist: uvicorn>=0.20; extra == "server"
+Requires-Dist: starlette>=0.27; extra == "server"
+Dynamic: license-file
+
+# fix
+
+AI-powered command fixer. A command fails, an LLM diagnoses it, proposes a fix, and a contract system tracks the whole thing. Disputes go to an AI judge.
+
+## Quick start
+
+```sh
+pip install git+https://github.com/karans4/fix.git
+```
+
+### Local mode (you need an API key)
+
+```sh
+export ANTHROPIC_API_KEY=sk-ant-...   # or OPENAI_API_KEY, or run Ollama
+
+fix "gcc foo.c"         # run command, fix if it fails
+fix it                  # fix the last failed command
+fix --explain "make"    # just explain the error
+fix --dry-run "make"    # show fix without running
+fix --local "make"      # force Ollama (free, local)
+```
+
+### Remote mode (free platform agent)
+
+Post a contract to the platform. A free AI agent picks it up and proposes a fix.
+
+```sh
+fix --remote "gcc foo.c"
+```
+
+Platform: `https://fix.notruefireman.org` (free during testing)
+
+Configure in `~/.fix/config.py`:
+```python
+platform_url = "https://fix.notruefireman.org"
+remote = True  # default to remote mode
+```
+
+## Shell integration
+
+For `fix it` / `fix !!` to work, add to your shell config:
+
+```sh
+# bash/zsh
+eval "$(fix shell)"
+
+# fish
+fix shell fish | source
+
+# or auto-install
+fix shell --install
+```
+
+## Safe mode (sandbox)
+
+Default on Linux. Runs fixes in OverlayFS -- changes only committed if verification passes.
+
+```sh
+fix "make build"          # sandbox on Linux by default
+fix --no-safe "make"      # skip sandbox
+fix --safe "make"         # force sandbox
+```
+
+## Verification
+
+```sh
+fix "gcc foo.c"                              # default: re-run, exit 0 = success
+fix --verify=human "python3 render.py"       # human judges
+fix --verify="pytest tests/" "pip install x"  # custom command
+```
+
+## How it works
+
+1. Command fails, stderr captured
+2. Contract built (task, environment, verification terms, escrow)
+3. Agent investigates (read-only commands), then proposes fix
+4. Fix applied, verified mechanically
+5. Multi-attempt: up to 3 tries, feeding failures back as context
+6. Disputes go to an AI judge who reviews the full transcript
+
+## Architecture
+
+- `fix` -- CLI entry point
+- `server/` -- FastAPI platform (contracts, escrow, reputation, judge)
+- `protocol.py` -- state machine, constants
+- `scrubber.py` -- redacts secrets from error output before sending to LLM
+- `contract.py` -- builds structured contracts
+- `client.py` / `agent.py` -- remote mode client and agent
+
+## License
+
+MIT

fix_cli-0.4.0/README.md

@@ -0,0 +1,92 @@
+# fix
+
+AI-powered command fixer. A command fails, an LLM diagnoses it, proposes a fix, and a contract system tracks the whole thing. Disputes go to an AI judge.
+
+## Quick start
+
+```sh
+pip install git+https://github.com/karans4/fix.git
+```
+
+### Local mode (you need an API key)
+
+```sh
+export ANTHROPIC_API_KEY=sk-ant-...   # or OPENAI_API_KEY, or run Ollama
+
+fix "gcc foo.c"         # run command, fix if it fails
+fix it                  # fix the last failed command
+fix --explain "make"    # just explain the error
+fix --dry-run "make"    # show fix without running
+fix --local "make"      # force Ollama (free, local)
+```
+
+### Remote mode (free platform agent)
+
+Post a contract to the platform. A free AI agent picks it up and proposes a fix.
+
+```sh
+fix --remote "gcc foo.c"
+```
+
+Platform: `https://fix.notruefireman.org` (free during testing)
+
+Configure in `~/.fix/config.py`:
+```python
+platform_url = "https://fix.notruefireman.org"
+remote = True  # default to remote mode
+```
+
+## Shell integration
+
+For `fix it` / `fix !!` to work, add to your shell config:
+
+```sh
+# bash/zsh
+eval "$(fix shell)"
+
+# fish
+fix shell fish | source
+
+# or auto-install
+fix shell --install
+```
+
+## Safe mode (sandbox)
+
+Default on Linux. Runs fixes in OverlayFS -- changes only committed if verification passes.
+
+```sh
+fix "make build"          # sandbox on Linux by default
+fix --no-safe "make"      # skip sandbox
+fix --safe "make"         # force sandbox
+```
+
+## Verification
+
+```sh
+fix "gcc foo.c"                              # default: re-run, exit 0 = success
+fix --verify=human "python3 render.py"       # human judges
+fix --verify="pytest tests/" "pip install x"  # custom command
+```
+
+## How it works
+
+1. Command fails, stderr captured
+2. Contract built (task, environment, verification terms, escrow)
+3. Agent investigates (read-only commands), then proposes fix
+4. Fix applied, verified mechanically
+5. Multi-attempt: up to 3 tries, feeding failures back as context
+6. Disputes go to an AI judge who reviews the full transcript
+
+## Architecture
+
+- `fix` -- CLI entry point
+- `server/` -- FastAPI platform (contracts, escrow, reputation, judge)
+- `protocol.py` -- state machine, constants
+- `scrubber.py` -- redacts secrets from error output before sending to LLM
+- `contract.py` -- builds structured contracts
+- `client.py` / `agent.py` -- remote mode client and agent
+
+## License
+
+MIT

fix_cli-0.4.0/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

fix_cli-0.4.0/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}")