ctrlcode 0.1.0__py3-none-any.whl

ctrlcode/tools/update.py

@@ -0,0 +1,266 @@
+"""Built-in file update tools for modifying existing files."""
+
+import fcntl
+import re
+from pathlib import Path
+from typing import Any
+import signal
+from contextlib import contextmanager
+
+
+class UpdateFileTools:
+    """Built-in tools for updating file contents."""
+
+    def __init__(self, workspace_root: str | Path):
+        """
+        Initialize update tools.
+
+        Args:
+            workspace_root: Root directory for file operations
+        """
+        self.workspace_root = Path(workspace_root).resolve()
+
+    @staticmethod
+    def _validate_regex_pattern(pattern: str) -> tuple[bool, str]:
+        """
+        Validate regex pattern to prevent ReDoS attacks.
+
+        Args:
+            pattern: Regex pattern to validate
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        # Length limit to prevent excessive complexity
+        if len(pattern) > 500:
+            return False, "Pattern too long (max 500 chars)"
+
+        # Check for dangerous nested quantifiers that cause catastrophic backtracking
+        dangerous_patterns = [
+            r'\([^)]*\+[^)]*\)\+',  # (a+)+ style
+            r'\([^)]*\*[^)]*\)\+',  # (a*)+ style
+            r'\([^)]*\+[^)]*\)\*',  # (a+)* style
+            r'\([^)]*\*[^)]*\)\*',  # (a*)* style
+        ]
+
+        for dangerous in dangerous_patterns:
+            if re.search(dangerous, pattern):
+                return False, "Pattern contains nested quantifiers that may cause ReDoS"
+
+        # Try to compile pattern to check validity
+        try:
+            re.compile(pattern)
+        except re.error as e:
+            return False, f"Invalid regex pattern: {e}"
+
+        return True, ""
+
+    @contextmanager
+    def _regex_timeout(self, seconds: int = 1):
+        """Context manager to timeout regex operations."""
+        def timeout_handler(signum, frame):
+            raise TimeoutError("Regex search timed out")
+
+        # Set alarm (Unix only)
+        old_handler = signal.signal(signal.SIGALRM, timeout_handler)
+        signal.alarm(seconds)
+        try:
+            yield
+        finally:
+            signal.alarm(0)
+            signal.signal(signal.SIGALRM, old_handler)
+
+    def update_file(
+        self,
+        path: str,
+        operation: str,
+        start_line: int | None = None,
+        end_line: int | None = None,
+        content: str | None = None,
+        search_pattern: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Update a file by replacing, inserting, or deleting lines.
+
+        Args:
+            path: File path relative to workspace root
+            operation: Operation to perform (replace, insert, delete)
+            start_line: Start line number (1-indexed, inclusive)
+            end_line: End line number (1-indexed, inclusive)
+            content: Content for replace/insert operations
+            search_pattern: Regex pattern to find target lines (alternative to line numbers)
+
+        Returns:
+            Dict with success status and metadata
+        """
+        try:
+            file_path = (self.workspace_root / path).resolve()
+
+            # Security: ensure path is within workspace
+            if not str(file_path).startswith(str(self.workspace_root)):
+                return {"error": "Path outside workspace"}
+
+            if not file_path.exists():
+                return {"error": "File not found"}
+
+            if not file_path.is_file():
+                return {"error": "Not a file"}
+
+            # Validate operation
+            if operation not in ["replace", "insert", "delete"]:
+                return {"error": f"Invalid operation: {operation}"}
+
+            # Read file
+            with open(file_path, "r", encoding="utf-8") as f:
+                lines = f.readlines()
+
+            total_lines = len(lines)
+            original_line_count = total_lines
+
+            # Determine target line range
+            if search_pattern:
+                # Security: validate regex pattern to prevent ReDoS
+                is_valid, error_msg = self._validate_regex_pattern(search_pattern)
+                if not is_valid:
+                    return {"error": f"Invalid search pattern: {error_msg}"}
+
+                # Find lines matching pattern with timeout protection
+                matches = []
+                try:
+                    with self._regex_timeout(seconds=2):
+                        compiled_pattern = re.compile(search_pattern)
+                        for i, line in enumerate(lines, 1):
+                            if compiled_pattern.search(line):
+                                matches.append(i)
+                except TimeoutError:
+                    return {"error": "Regex search timed out - pattern may be too complex"}
+
+                if not matches:
+                    return {"error": f"Pattern '{search_pattern}' not found"}
+
+                # Use first match for single-line operations, or all matches for multi-line
+                if operation == "delete" and len(matches) > 1:
+                    # Delete all matching lines
+                    start_line = matches[0]
+                    end_line = matches[-1]
+                else:
+                    start_line = matches[0]
+                    end_line = matches[0]
+
+            # Validate line numbers
+            if start_line is None:
+                return {"error": "start_line or search_pattern required"}
+
+            if start_line < 1 or start_line > total_lines:
+                return {"error": f"start_line {start_line} out of range (1-{total_lines})"}
+
+            if end_line is None:
+                end_line = start_line
+
+            if end_line < start_line or end_line > total_lines:
+                return {"error": f"end_line {end_line} invalid (must be {start_line}-{total_lines})"}
+
+            # Perform operation
+            if operation == "replace":
+                if content is None:
+                    return {"error": "content required for replace operation"}
+
+                # Ensure content ends with newline
+                if not content.endswith("\n"):
+                    content += "\n"
+
+                # Replace lines
+                new_lines = lines[: start_line - 1] + [content] + lines[end_line:]
+
+            elif operation == "insert":
+                if content is None:
+                    return {"error": "content required for insert operation"}
+
+                # Ensure content ends with newline
+                if not content.endswith("\n"):
+                    content += "\n"
+
+                # Insert at line (before start_line)
+                new_lines = lines[: start_line - 1] + [content] + lines[start_line - 1 :]
+
+            elif operation == "delete":
+                # Delete lines
+                new_lines = lines[: start_line - 1] + lines[end_line:]
+
+            else:
+                return {"error": f"Unsupported operation: {operation}"}
+
+            # Write file atomically with locking
+            temp_path = file_path.with_suffix(file_path.suffix + ".tmp")
+
+            try:
+                # Write to temp file with exclusive lock
+                with open(temp_path, "w", encoding="utf-8") as f:
+                    fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+                    try:
+                        f.writelines(new_lines)
+                        f.flush()
+                    finally:
+                        fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+
+                # Atomic rename
+                temp_path.replace(file_path)
+
+            except Exception as e:
+                if temp_path.exists():
+                    temp_path.unlink()
+                raise e
+
+            return {
+                "success": True,
+                "path": str(file_path),  # Return absolute path so TUI can read it back
+                "operation": operation,
+                "lines_before": original_line_count,
+                "lines_after": len(new_lines),
+                "affected_range": f"{start_line}-{end_line}",
+            }
+
+        except UnicodeDecodeError:
+            return {"error": "File is binary or uses unsupported encoding"}
+        except Exception as e:
+            return {"error": str(e)}
+
+
+# Tool schemas for LLM providers (Anthropic/OpenAI format)
+UPDATE_TOOL_SCHEMAS = [
+    {
+        "name": "update_file",
+        "description": "**USE THIS** to modify existing files. Replaces, inserts, or deletes specific line ranges. WORKFLOW: (1) read_file to see current content, (2) determine which lines to modify, (3) call update_file with line numbers and new content.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string",
+                    "description": "File path relative to workspace root",
+                },
+                "operation": {
+                    "type": "string",
+                    "description": "Operation to perform",
+                    "enum": ["replace", "insert", "delete"],
+                },
+                "start_line": {
+                    "type": "integer",
+                    "description": "Start line number (1-indexed, inclusive). Required unless using search_pattern.",
+                },
+                "end_line": {
+                    "type": "integer",
+                    "description": "End line number (1-indexed, inclusive). Defaults to start_line if not specified.",
+                },
+                "content": {
+                    "type": "string",
+                    "description": "Content for replace/insert operations",
+                },
+                "search_pattern": {
+                    "type": "string",
+                    "description": "Regex pattern to find target lines (alternative to line numbers)",
+                },
+            },
+            "required": ["path", "operation"],
+        },
+    },
+]

ctrlcode/tools/webfetch.py

@@ -0,0 +1,147 @@
+"""Built-in web fetch tools for making HTTP requests."""
+
+import urllib.request
+import urllib.error
+from typing import Any
+
+
+class WebFetchTools:
+    """Built-in tools for fetching web content."""
+
+    def fetch(
+        self,
+        url: str,
+        method: str = "GET",
+        headers: dict[str, str] | None = None,
+        body: str | None = None,
+        timeout: int = 30,
+    ) -> dict[str, Any]:
+        """
+        Make an HTTP request.
+
+        Args:
+            url: URL to fetch
+            method: HTTP method (GET, POST, PUT, DELETE)
+            headers: Optional HTTP headers
+            body: Optional request body (for POST/PUT)
+            timeout: Timeout in seconds (default 30, max 120)
+
+        Returns:
+            Dict with response body, status code, and headers
+        """
+        try:
+            # Validate URL protocol
+            if not url.startswith(("http://", "https://")):
+                return {"error": "Only http and https protocols are supported"}
+
+            # Basic SSRF protection - block localhost
+            if any(
+                host in url.lower()
+                for host in ["localhost", "127.0.0.1", "0.0.0.0", "[::1]"]
+            ):
+                return {"error": "Cannot fetch from localhost"}
+
+            # Enforce timeout limits
+            if timeout > 120:
+                timeout = 120
+            if timeout < 1:
+                timeout = 1
+
+            # Validate HTTP method
+            method = method.upper()
+            if method not in ["GET", "POST", "PUT", "DELETE", "HEAD", "PATCH"]:
+                return {"error": f"Unsupported HTTP method: {method}"}
+
+            # Prepare request
+            request_headers = headers or {}
+            request_body = body.encode("utf-8") if body else None
+
+            req = urllib.request.Request(
+                url,
+                data=request_body,
+                headers=request_headers,
+                method=method,
+            )
+
+            # Execute request
+            with urllib.request.urlopen(req, timeout=timeout) as response:
+                response_body = response.read().decode("utf-8")
+                response_headers = dict(response.headers)
+                status_code = response.status
+
+            return {
+                "body": response_body,
+                "status_code": status_code,
+                "headers": response_headers,
+                "url": url,
+                "method": method,
+                "success": True,
+            }
+
+        except urllib.error.HTTPError as e:
+            # HTTP errors (4xx, 5xx)
+            error_body = e.read().decode("utf-8") if e.fp else ""
+            return {
+                "error": f"HTTP {e.code}: {e.reason}",
+                "status_code": e.code,
+                "body": error_body,
+                "url": url,
+                "success": False,
+            }
+
+        except urllib.error.URLError as e:
+            # Network errors (DNS, connection, etc.)
+            return {
+                "error": f"Request failed: {str(e.reason)}",
+                "url": url,
+                "success": False,
+            }
+
+        except TimeoutError:
+            return {
+                "error": f"Request timed out after {timeout} seconds",
+                "url": url,
+                "success": False,
+            }
+
+        except Exception as e:
+            return {"error": str(e), "url": url, "success": False}
+
+
+# Tool schemas for LLM providers (Anthropic/OpenAI format)
+WEBFETCH_TOOL_SCHEMAS = [
+    {
+        "name": "fetch",
+        "description": "Make HTTP requests to fetch web content or call APIs. Supports GET, POST, PUT, DELETE with custom headers and body.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "url": {
+                    "type": "string",
+                    "description": "URL to fetch (must be http or https)",
+                },
+                "method": {
+                    "type": "string",
+                    "description": "HTTP method",
+                    "enum": ["GET", "POST", "PUT", "DELETE", "HEAD", "PATCH"],
+                    "default": "GET",
+                },
+                "headers": {
+                    "type": "object",
+                    "description": "Optional HTTP headers as key-value pairs",
+                    "additionalProperties": {"type": "string"},
+                },
+                "body": {
+                    "type": "string",
+                    "description": "Optional request body (for POST/PUT/PATCH)",
+                },
+                "timeout": {
+                    "type": "integer",
+                    "description": "Timeout in seconds (default 30, max 120)",
+                    "default": 30,
+                },
+            },
+            "required": ["url"],
+        },
+    },
+]

ctrlcode-0.1.0.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: ctrlcode
+Version: 0.1.0
+Summary: Adaptive coding harness with differential fuzzing - transforms AI slop into production-ready code
+Requires-Python: >=3.12
+Requires-Dist: aiohttp>=3.10.0
+Requires-Dist: anthropic>=0.40.0
+Requires-Dist: apscheduler>=3.11.2
+Requires-Dist: ctrlcode-tui
+Requires-Dist: faiss-cpu>=1.13.2
+Requires-Dist: harness-utils>=0.3.1
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: networkx>=3.6.1
+Requires-Dist: openai>=1.54.0
+Requires-Dist: platformdirs>=4.5.1
+Requires-Dist: playwright>=1.58.0
+Requires-Dist: sentence-transformers>=5.2.2
+Requires-Dist: tiktoken>=0.12.0
+Description-Content-Type: text/markdown
+
+# ctrl+code
+
+Adaptive coding harness with differential fuzzing - transforms AI slop into production-ready code.
+
+## Configuration
+
+ctrl+code follows platform conventions for config and data storage:
+
+| Platform | Config | Data | Cache |
+|----------|--------|------|-------|
+| **Linux** | `~/.config/ctrlcode/` | `~/.local/share/ctrlcode/` | `~/.cache/ctrlcode/` |
+| **macOS** | `~/Library/Application Support/ctrlcode/` | `~/Library/Application Support/ctrlcode/` | `~/Library/Caches/ctrlcode/` |
+| **Windows** | `%APPDATA%\ctrlcode\` | `%LOCALAPPDATA%\ctrlcode\` | `%LOCALAPPDATA%\ctrlcode\Cache\` |
+
+### Environment Variables
+
+Override default directories:
+- `CTRLCODE_CONFIG_DIR`: Config file location
+- `CTRLCODE_DATA_DIR`: Session logs and persistent data
+- `CTRLCODE_CACHE_DIR`: Conversation storage and temp files
+
+### Configuration File
+
+Copy `config.example.toml` to your config directory as `config.toml` and fill in your API keys.
+
+### Agent Instructions (AGENT.md)
+
+Customize agent behavior with `AGENT.md` files, loaded hierarchically:
+
+1. **Global** (`~/.config/ctrlcode/AGENT.md`) - Your personal defaults across all projects
+2. **Project** (`<workspace>/AGENT.md`) - Project-specific instructions
+
+Example global `AGENT.md`:
+```markdown
+# Global Agent Defaults
+
+- Always use semantic commit messages
+- Show tool results explicitly
+- Prefer built-in tools over scripts
+```
+
+Example project `AGENT.md`:
+```markdown
+# MyProject Instructions
+
+## Architecture
+- Frontend: React + TypeScript
+- Backend: FastAPI + PostgreSQL
+
+## Style
+- Use async/await for all I/O
+- Prefer functional components
+```
+
+Instructions are injected into the system prompt, giving the agent context about your preferences and project structure.
+
+## Installation
+
+```bash
+uv pip install ctrlcode
+```
+
+## Usage
+
+Start the TUI (auto-launches server):
+```bash
+ctrlcode
+```
+
+Or start server separately:
+```bash
+ctrlcode-server
+```

ctrlcode-0.1.0.dist-info/RECORD

@@ -0,0 +1,75 @@
+ctrlcode/__init__.py,sha256=kAT6NmF-Gb1M3VNRna0be9CzF8JHROpvCI9wYFNZbgk,207
+ctrlcode/config.py,sha256=fNcAh9oP39Iv1IMbGa-KymAt_qWSTX_MbQKiAsqOc6o,13332
+ctrlcode/paths.py,sha256=eD-RWOra2aGkhhBYbfqHHh2BaGvljZjIJdeO9N2Cuxg,2046
+ctrlcode/permissions.py,sha256=Y4fqYK9iuGH9bqHbYrEpbpc38_PgkKNkjhM8lYaXmkU,5600
+ctrlcode/server.py,sha256=ArRA_mfHRPqYtws66ag_jV1hgGyfTO3nLaPByjAQ3rg,31722
+ctrlcode/agents/__init__.py,sha256=CS7JCKjxLV9uZOvcfX6yE6pBgf9Y2j2FWPIwgAL6-Z4,747
+ctrlcode/agents/cleanup.py,sha256=tq7PVLX1UIGi1EtvtLk-DzKwg3u8fG4nDGLAaOHyJw8,11548
+ctrlcode/agents/communication.py,sha256=9jD1Zz3fDXL4sK_RjjfXuw1AHW3saWnivZ1aI_6iH84,14196
+ctrlcode/agents/observability.py,sha256=m1iNfmSKy_AuKzU4nAq7CetTLJqME69VUz8y61h7768,11950
+ctrlcode/agents/react_loop.py,sha256=meOb1t7P_a6cACDCWhzEFpZyAmyqO_kSiHAHn1JQYfE,12214
+ctrlcode/agents/registry.py,sha256=ulR0r_ulFrLMmMCORhH0mu9pDWtGUI2jjO1e-sMIi58,6638
+ctrlcode/agents/result_parser.py,sha256=NN9QxL2iaRDN_SAaVLRT65NJhW2MkkzqmAAuQ75SFvw,8615
+ctrlcode/agents/workflow.py,sha256=8rMmndcpjQYxJ9MnDL3ueCswHPHiJqKkAZpNUM9i5D4,22973
+ctrlcode/analysis/__init__.py,sha256=ALlJjhWNH6i7I0V_eOOzxvxgpyapvOXH0dv7Yy6ojVo,798
+ctrlcode/analysis/ast_diff.py,sha256=7VslujMfOjWKLwL-aBJq9bueFXoJWWn4o8QppRETBH0,4977
+ctrlcode/analysis/bug_detector.py,sha256=ZMUf81G1VQl5zWFWRX87oB-LVvAfJ-ibaPphhqcmZxQ,4814
+ctrlcode/analysis/code_graphs.py,sha256=eoDPpnx-daupny37Z_ls8JZHpnKUmy3F8RyayurNlcM,10827
+ctrlcode/analysis/semantic.py,sha256=ebZQOlEepW7kTpAxONXSeuJZqGD0gyVVW0a2CZXUJ8I,5647
+ctrlcode/analysis/static.py,sha256=MwMMbyyff2bcz5lCwmOxgQPrH0JxYzlvN39axRm-2EY,5215
+ctrlcode/analysis/synthesizer.py,sha256=wzgIvc6U4paWvj6zaHsOI5YJYf8T2Lg6orL3n97v8VY,9322
+ctrlcode/analysis/tests.py,sha256=xfFv6fjcPxQTwaTBSkq2c6k_X2y3oXtdVtSGEdECCY0,5077
+ctrlcode/cleanup/__init__.py,sha256=op6vMRW6qfwdrXfxKfa-ryUO9zQA1mZde0ebD_lXrjg,410
+ctrlcode/cleanup/auto_merge.py,sha256=wn3P_n_GzxDIWUVQF7Xdr7Y3MlWiOi8qJCOHUT0DFeU,11563
+ctrlcode/cleanup/doc_gardening.py,sha256=---B8_vHiLEdbR_ixyp0tIXcBLdZMdkMVdKMY1Vsd1E,12948
+ctrlcode/cleanup/pr_automation.py,sha256=jg2-sjU-bGuoFVsS8G2560dvrVERptFMWw0ORpvM5dY,9742
+ctrlcode/cleanup/scheduler.py,sha256=Oz1DPFYK3xfmSmWBBWhWHHWqLpJexnxhPDGq4VXfznw,11953
+ctrlcode/embeddings/__init__.py,sha256=ONEGtZi3GHk_KzUYDPU0GPEDTui2QkzPGLdxkWqS4ZI,238
+ctrlcode/embeddings/embedder.py,sha256=XAFWzniSrjEmnCFENtWIjWgvLCfcxEbi3-essUpKHJ8,6233
+ctrlcode/embeddings/vector_store.py,sha256=EGQSFFsdSilWfhN-KoYP4ow96BlCFjermOWE0Uyezk4,7112
+ctrlcode/fuzzing/__init__.py,sha256=7m7q9GS67Wy30lxePFzlt_j77A3UMExArsrLQuvyKZY,846
+ctrlcode/fuzzing/analyzer.py,sha256=4daiYnRIbLQz_cwGajajBJVQOd225-IoGEjgIajxwrg,9300
+ctrlcode/fuzzing/budget.py,sha256=MN-E9DnUXR2KG68C2IfrfptzhnyeN0NY08RRWrD4feU,3076
+ctrlcode/fuzzing/context.py,sha256=RKHBCFpp39X0FijvX3c2MujCOiXSNRKpGM9Ds_6ZwSY,24181
+ctrlcode/fuzzing/context_fuzzer.py,sha256=m0GH9jRPEQJmceBSOxMc9k26rWk-vYQX33oorVBJ0nw,17436
+ctrlcode/fuzzing/derived_orchestrator.py,sha256=lcwivhUIENxmpv8QWDsD69zZkUXC7rYODmCXjl_Fvag,28302
+ctrlcode/fuzzing/oracle_adapter.py,sha256=_rO_ylebUnjT5nS_2Z0P1KTkhJMh9MLGEeXBa-9Tj2g,4210
+ctrlcode/linters/__init__.py,sha256=L3bleyJIZr2foHrOQBufhErhlUnKV8UiVto4gwyBeg4,304
+ctrlcode/linters/hand_rolled_utils.py,sha256=zCmb5Wd2ixteaSGMU85qrJUeIvY3290aEiTdwEKs2CU,6232
+ctrlcode/linters/yolo_parsing.py,sha256=nn187KRVio9WniJMy0NFqA4TnyGCw8rXgWkEJYCSnCk,6433
+ctrlcode/metrics/__init__.py,sha256=6S4RCHT6leSY0ONzB4-bvufBIkKcvK_PbDV2SANeHU0,241
+ctrlcode/metrics/dashboard.py,sha256=M2kOQKvtV7UQ_Uz2lVPJsWJRMXByAxsiOg00xNWgdrE,9903
+ctrlcode/metrics/tech_debt.py,sha256=gFTIdg2r39U1LuGkElI1J2km8vnQyqziQ6PPtKKqv8A,21299
+ctrlcode/providers/__init__.py,sha256=xJcoWTMOd5EZYNctGDuRy3GRJudW6TwDGG78crEtPII,361
+ctrlcode/providers/anthropic.py,sha256=SNaA2eZ_An9xO9zk9BQtaHxrUPPBngMcA-DP5FZf-6Y,5188
+ctrlcode/providers/base.py,sha256=fubYqGjj5twihic28wg8PIBwFOBIp3fQD9sNK5y53_M,1994
+ctrlcode/providers/openai.py,sha256=H1lwPfnLO7I7h7Hs6zTEAmdsJkTO7Ud48miH23EAv-c,7560
+ctrlcode/providers/parallel.py,sha256=ucYh8byJKM0Rq1YA9eHURh99nxMPp_bDoDZSoavepqE,3041
+ctrlcode/session/__init__.py,sha256=Kv-V1cPLJVCh0Oal9_d4i-JJ6A-8hZUzbKe3TRgG6fY,206
+ctrlcode/session/baseline.py,sha256=3fok8n0SeI3IaqiPfO3t9rl7uA72SmhvgOULHUjHQY4,1700
+ctrlcode/session/manager.py,sha256=MgwzXxqCt8Z6dT62n3sP2Hz1FN-qJjIDKhHVxcQfKJY,43271
+ctrlcode/skills/__init__.py,sha256=p-62spnGJNkZqBsjHKVvvycXiUjEG3s7vgqWY5x_YYo,179
+ctrlcode/skills/loader.py,sha256=kauoPOFuuaCwkIS66zufdADKVWRFgY2NjLmKfcS_b4o,3055
+ctrlcode/skills/registry.py,sha256=2SCo8n1p_Nu1FNuW05WxotKTQCgUuHpVTKPkVvQZR88,3565
+ctrlcode/skills/builtin/commit.toml,sha256=biDWNESOCzlJ8s555_dQtZl6AiYgz3cU2yxeWmPNITI,984
+ctrlcode/skills/builtin/docs.toml,sha256=VdJ5O1iCVZCnC_fh-vOSqvhn3z_oCaPr5W6OtUBcIxw,651
+ctrlcode/skills/builtin/refactor.toml,sha256=aXIZ_0alp54IAjhbKBxbhQzkyixebqtdmYtE5nXMJLs,797
+ctrlcode/skills/builtin/review.toml,sha256=h3Kmo29vmz7lDrkCne8QpFwZMUR-MWyLL4GManisfkI,711
+ctrlcode/skills/builtin/test.toml,sha256=NgYPf9v_pVwGSU-zaANAGRsbsvlLcxdkGjRowP8HFnA,637
+ctrlcode/storage/__init__.py,sha256=t8_whfiyzIpXwDkSqz_woKsIZDLiGCzmwx5ENHleKBI,347
+ctrlcode/storage/history_db.py,sha256=Ih9X1Dsx0AjwwrfgXSfInf7zDn-gwbnCT8p9JkdgD9A,22429
+ctrlcode/tools/__init__.py,sha256=KvK2ED4OiesYQUNsSv0sq3a-0dbM_ZzjI1_QARypoRs,6240
+ctrlcode/tools/bash.py,sha256=8k-qSFLU-r6j8-IgfiCWTHzv0ZQUS4HE2K8n_AEsI-8,3586
+ctrlcode/tools/browser.py,sha256=SPOUX3zfNPBn1UIvX7USt_6rgLoJY2BYMZBKr1_BM0k,12155
+ctrlcode/tools/executor.py,sha256=ybRPyKlW4sA8bLyYwXf7vofX4NF0le1ur--bvvQ9VQw,4749
+ctrlcode/tools/explore.py,sha256=WLChsk4KO_Ulaqb2XZNhxKdZPSoCM6r3KWOVEVDZB_E,16252
+ctrlcode/tools/mcp.py,sha256=ijCMVKmrvRH4tjUHxvBdpq2FAI2VVqw0Z5Ry1WFZtX8,3131
+ctrlcode/tools/observability.py,sha256=ubeKxqD--Vdy8a3I7N0Mofn4_8aS6tQq_pzUTHJTv2g,18333
+ctrlcode/tools/registry.py,sha256=6g08SGzYLHmQwta9Q-89WJh8frC_owwcJIYQX5Eu8Fc,5643
+ctrlcode/tools/todo.py,sha256=LyNmZzgSVaBzL5FO0MEroQ4WDgWnIYri2TymsKjCQuk,10315
+ctrlcode/tools/update.py,sha256=TZsmdugryoWKdcZyKEe2wZbaG5NzLIotdIbj2OGDvBE,9817
+ctrlcode/tools/webfetch.py,sha256=tMOoMA9zr3ErZbKPdsu5XxTvdA_QHZ1kja6J56n-RgE,4834
+ctrlcode-0.1.0.dist-info/METADATA,sha256=cwVabi2IcF61b3OFVbW5PkzTYm6QqVYr-StJUV21Y7k,2564
+ctrlcode-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+ctrlcode-0.1.0.dist-info/entry_points.txt,sha256=Q2-XnFYshpszkPxrw0dFD59SDJRnrNs32QpAQdoR-C4,90
+ctrlcode-0.1.0.dist-info/RECORD,,

ctrlcode-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

ctrlcode-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+ctrlcode = ctrlcode_tui.app:main
+ctrlcode-server = ctrlcode.server:main