xcoding 0.1.0__py3-none-any.whl

xcode/hooks.py

@@ -0,0 +1,74 @@
+"""Hooks + settings: .xcode/settings.json lets you run shell commands after the
+agent does things (e.g. auto-format after every edit), set env vars, and seed
+permission rules. Mirrors the spirit of Claude Code's settings.json hooks.
+
+Example .xcode/settings.json:
+{
+  "env": {"PYTHONWARNINGS": "ignore"},
+  "hooks": {
+    "after_write": ["ruff format {path}"],
+    "after_edit":  ["ruff format {path}"],
+    "after_command": []
+  },
+  "permissions": {"tools": ["read_file"], "commands": ["git", "ls"]}
+}
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+from pathlib import Path
+
+SETTINGS = Path(".xcode") / "settings.json"
+
+
+class Settings:
+    def __init__(self, path: Path = SETTINGS):
+        self.data: dict = {}
+        if path.exists():
+            try:
+                self.data = json.loads(path.read_text(encoding="utf-8"))
+            except Exception:
+                self.data = {}
+        for k, v in (self.data.get("env") or {}).items():
+            os.environ.setdefault(k, str(v))
+
+    @property
+    def loaded(self) -> bool:
+        return bool(self.data)
+
+    def hooks_for(self, event: str) -> list[str]:
+        return (self.data.get("hooks") or {}).get(event, []) or []
+
+    def seed_permissions(self, perms) -> None:
+        block = self.data.get("permissions") or {}
+        for t in block.get("tools", []):
+            perms.tools.add(t)
+        for c in block.get("commands", []):
+            perms.cmd_prefixes.add(c)
+
+
+def run_hooks(settings: Settings, event: str, **vars) -> str:
+    """Run every command registered for an event. Returns a note for the model
+    if anything ran (so it sees formatter output / failures)."""
+    cmds = settings.hooks_for(event)
+    if not cmds:
+        return ""
+    notes = []
+    for tmpl in cmds:
+        try:
+            cmd = tmpl.format(**vars)
+        except (KeyError, IndexError):
+            cmd = tmpl
+        try:
+            p = subprocess.run(cmd, shell=True, capture_output=True,
+                               text=True, timeout=60)
+            tag = "ok" if p.returncode == 0 else f"exit {p.returncode}"
+            out = (p.stdout + p.stderr).strip()
+            notes.append(f"[hook {event}: {cmd}] {tag}"
+                         + (f"\n{out[:500]}" if out else ""))
+        except Exception as e:
+            notes.append(f"[hook {event}: {cmd}] failed: {e}")
+    return "\n".join(notes)

xcode/input_bar.py

@@ -0,0 +1,357 @@
+"""Claude-Code-style input bar: rules above and below the ❯ prompt, with a
+status line below (mode, then the current file + token count).
+
+The rules are sized to FIT THE TEXT on their line — not the full terminal
+width. The top rule matches the `❯ ` prompt + its ghost placeholder; the
+bottom rule matches the status line. The status line packs its segments
+together with small separators rather than pushing the token count to the
+far edge.
+
+There are NO blank lines between the prompt and the status line — the bar is
+exactly: rule / `❯` line / rule / status. On Win32 prompt_toolkit otherwise
+stuffs a column of blanks in there; `_compact_layout()` pins the input window
+to its content height so that slack falls below the bar instead.
+
+⚠️ DO NOT revert these rules back to full terminal width (`"─" * w`),
+re-introduce a large `pad` gap in the status line, or remove
+`_compact_layout()`. "Fit the words, no blank lines" is the intended look and
+must stay this way. See `_rule()`, `_compact_layout()`, `_message()`,
+`_toolbar()`.
+
+Live mode cycling via shift+tab. Falls back to a plain prompt if
+prompt_toolkit isn't available (or isn't on a real console).
+"""
+
+from __future__ import annotations
+
+import random
+import shutil
+
+MODES = ["normal", "auto", "plan"]
+_LABEL = {
+    "normal": ("·· normal", "ask before changes"),
+    "auto":   ("⏵⏵ auto", "run & write without asking"),
+    "plan":   ("◷ plan", "read-only, no changes"),
+}
+
+# Faded "ghost" tips shown inside the empty prompt — they rotate each turn and
+# vanish the moment you start typing.
+PLACEHOLDERS = [
+    'Try "fix typecheck errors"',
+    'Try "how does <filepath> work?"',
+    'Try "add tests for the auth module"',
+    'Try "explain this stack trace"',
+    'Try "refactor this function to be smaller"',
+    'Try "what does this regex do?"',
+    'Try "write a commit message for my changes"',
+    'Try "find where we handle login"',
+    'Try "why is this test flaky?"',
+    'Try "add a --verbose flag to the CLI"',
+    'Ask me to "make it more compact"',
+    'Use @file to attach a file to your message',
+    'Press shift+tab to cycle normal → auto → plan',
+    'Type / to see every slash command',
+    'Hit ctrl+z to undo your last edit',
+    'Run /theme matrix to go full hacker mode',
+]
+
+try:
+    from prompt_toolkit import PromptSession
+    from prompt_toolkit.application import Application
+    from prompt_toolkit.completion import Completer, Completion
+    from prompt_toolkit.formatted_text import FormattedText
+    from prompt_toolkit.key_binding import KeyBindings
+    from prompt_toolkit.layout import HSplit, Layout, Window
+    from prompt_toolkit.layout.controls import FormattedTextControl
+    from prompt_toolkit.styles import Style
+    AVAILABLE = True
+except Exception:  # pragma: no cover
+    AVAILABLE = False
+
+
+def _enable_shift_enter() -> None:
+    """Make Shift+Enter distinguishable from Enter on the Windows console.
+
+    prompt_toolkit's Win32 input reader collapses Shift+Enter into a plain
+    Enter (there is no ShiftEnter key). We wrap it so that, when Shift is held
+    on Return, the key is re-tagged as Ctrl+J — which we then bind to insert a
+    newline. Enter (Ctrl+M) is left alone and still submits.
+    """
+    try:
+        from prompt_toolkit.input.win32 import ConsoleInputReader
+        from prompt_toolkit.keys import Keys
+    except Exception:
+        return  # not on Windows / no win32 reader — nothing to patch
+    orig = ConsoleInputReader._event_to_key_presses
+    if getattr(orig, "_xcode_patched", False):
+        return
+    SHIFT_PRESSED = 0x0010
+
+    def patched(self, ev):
+        presses = orig(self, ev)
+        if ev.ControlKeyState & SHIFT_PRESSED:
+            for kp in presses:
+                if kp.key in (Keys.ControlM, getattr(Keys, "Enter", Keys.ControlM)):
+                    kp.key = Keys.ControlJ
+        return presses
+
+    patched._xcode_patched = True
+    ConsoleInputReader._event_to_key_presses = patched
+
+
+if AVAILABLE:
+    _enable_shift_enter()
+
+
+def cycle(mode: str) -> str:
+    return MODES[(MODES.index(mode) + 1) % len(MODES)] if mode in MODES else "normal"
+
+
+if AVAILABLE:
+    class SlashCompleter(Completer):
+        """Claude-Code-style dropdown: type `/` to see commands + descriptions."""
+
+        def __init__(self, commands):
+            self.commands = commands  # list of (name, description)
+
+        def get_completions(self, document, complete_event):
+            text = document.text_before_cursor
+            if not text.startswith("/") or " " in text:
+                return
+            for name, desc in self.commands:
+                if name.startswith(text):
+                    yield Completion(name, start_position=-len(text),
+                                     display=name, display_meta=desc)
+else:  # pragma: no cover
+    SlashCompleter = None
+
+
+def select_menu(question: str, options: list) -> str:
+    """Show an inline single-choice menu, Claude-Code style. Navigate with
+    ↑/↓ or w/s (or j/k), Enter to pick, Esc to cancel (returns the first
+    option). Returns the chosen *label*.
+
+    `options` may be plain strings, or (label, description) pairs — the
+    description is shown dimmed under each choice.
+    """
+    norm: list[tuple[str, str]] = []
+    for o in options:
+        if isinstance(o, (tuple, list)):
+            label = str(o[0]).strip()
+            desc = str(o[1]).strip() if len(o) > 1 else ""
+        else:
+            label, desc = str(o).strip(), ""
+        if label:
+            norm.append((label, desc))
+    if not norm:
+        return ""
+    labels = [lbl for lbl, _ in norm]
+
+    if not AVAILABLE:  # plain numbered fallback
+        print(question)
+        for i, (lbl, desc) in enumerate(norm, 1):
+            print(f"  {i}. {lbl}" + (f"  — {desc}" if desc else ""))
+        try:
+            s = input("pick a number › ").strip()
+            return labels[int(s) - 1] if s.isdigit() and 1 <= int(s) <= len(labels) else labels[0]
+        except Exception:
+            return labels[0]
+
+    idx = [0]
+
+    def render():
+        frags = [("bold", f"  {question}\n")]
+        for i, (lbl, desc) in enumerate(norm):
+            if i == idx[0]:
+                frags.append(("bold fg:ansiwhite", f"  ❯ {lbl}\n"))
+            else:
+                frags.append(("", f"    {lbl}\n"))
+            if desc:
+                frags.append(("fg:ansibrightblack", f"      {desc}\n"))
+        frags.append(("fg:ansibrightblack",
+                      "  ↑/↓ or w/s · enter to select · esc to cancel"))
+        return FormattedText(frags)
+
+    kb = KeyBindings()
+
+    @kb.add("up")
+    @kb.add("k")
+    @kb.add("w")
+    def _(e):
+        idx[0] = (idx[0] - 1) % len(labels)
+
+    @kb.add("down")
+    @kb.add("j")
+    @kb.add("s")
+    def _(e):
+        idx[0] = (idx[0] + 1) % len(labels)
+
+    @kb.add("enter")
+    def _(e):
+        e.app.exit(result=idx[0])
+
+    @kb.add("escape")
+    @kb.add("c-c")
+    def _(e):
+        e.app.exit(result=None)
+
+    app = Application(
+        layout=Layout(HSplit([
+            Window(FormattedTextControl(render), always_hide_cursor=True)])),
+        key_bindings=kb, full_screen=False)
+    try:
+        res = app.run()
+    except Exception:
+        return labels[0]
+    return labels[res] if res is not None else labels[0]
+
+
+def _width(default: int = 100) -> int:
+    try:
+        from prompt_toolkit.application.current import get_app
+        return get_app().output.get_size().columns
+    except Exception:
+        try:
+            return shutil.get_terminal_size((default, 24)).columns
+        except Exception:
+            return default
+
+
+def _rule(text: str) -> str:
+    """A horizontal rule sized to FIT `text` — never the full terminal width.
+
+    Length = the display width of the line it accompanies, capped to the
+    terminal so a very long line can't overflow and wrap into a blank pad row.
+    """
+    n = max(1, min(len(text), _width() - 1))
+    return "─" * n
+
+
+class InputBar:
+    def __init__(self, uic, on_mode_change=lambda m: None, commands=None):
+        self.uic = uic
+        self.on_mode_change = on_mode_change
+        self.commands = commands or []
+        self.budget = 8000
+        self.model = ""
+        self.tokens = lambda: 0
+        self._ph_text = ""          # current ghost placeholder (sizes the top rule)
+        self._session = None
+        if AVAILABLE:
+            try:
+                self._build()
+            except Exception:
+                self._session = None  # not a real console → plain fallback
+
+    def _build(self) -> None:
+        kb = KeyBindings()
+
+        @kb.add("s-tab")  # shift+tab cycles the mode live
+        def _(event):
+            self.uic.mode = cycle(self.uic.mode)
+            self.on_mode_change(self.uic.mode)
+            event.app.invalidate()
+
+        @kb.add("c-c")
+        def _(event):
+            event.app.exit(exception=KeyboardInterrupt)
+
+        @kb.add("c-z")  # undo the last edit in the input
+        def _(event):
+            event.current_buffer.undo()
+
+        @kb.add("c-j")  # Shift+Enter (remapped) / Ctrl+J → newline, not submit
+        def _(event):
+            event.current_buffer.insert_text("\n")
+
+        style = Style.from_dict({
+            "bottom-toolbar": "bg:default noreverse",
+            "completion-menu.completion": "bg:default",
+            "completion-menu.completion.current": "bg:ansiwhite fg:ansiblack",
+            "completion-menu.meta.completion": "bg:default fg:ansibrightblack",
+            "completion-menu.meta.completion.current": "bg:ansibrightblack fg:ansiwhite",
+        })
+        self._session = PromptSession(
+            key_bindings=kb, style=style, message=self._message,
+            bottom_toolbar=self._toolbar,
+            completer=SlashCompleter(self.commands) if SlashCompleter else None,
+            complete_while_typing=True,
+            # Don't reserve a tall blank block for the completion dropdown —
+            # that's what left all those empty lines under the prompt.
+            reserve_space_for_menu=0)
+        self._compact_layout()
+
+    def _compact_layout(self) -> None:
+        """Kill the blank lines between the ❯ line and the status toolbar.
+
+        On Win32, prompt_toolkit reserves every row below the cursor
+        (renderer: `_min_available_height = get_rows_below_cursor_position()`)
+        and lets the input window stretch to fill it — which stacks a column
+        of blank lines between the prompt and the bottom toolbar. Pinning the
+        input window to its content height makes that slack fall BELOW the bar
+        instead, so the bar stays tight: rule, ❯ line, rule, status — and only
+        ONE line per row of words. ⚠️ Don't remove this; the gap comes back.
+        """
+        try:
+            from prompt_toolkit.filters import to_filter
+            from prompt_toolkit.layout import walk
+            from prompt_toolkit.layout.controls import BufferControl
+            buf = self._session.default_buffer
+            for cont in walk(self._session.layout.container):
+                ctrl = getattr(cont, "content", None)
+                if isinstance(ctrl, BufferControl) and ctrl.buffer is buf:
+                    cont.dont_extend_height = to_filter(True)
+                    break
+        except Exception:
+            pass
+
+    # ---- the top rule + prompt --------------------------------------------
+    def _message(self):
+        # Rule fits the prompt line: "❯ " + the ghost placeholder. NOT full
+        # width — see the module docstring; do not change this back.
+        prompt_line = "❯ " + (self._ph_text or "")
+        return FormattedText([
+            ("fg:ansibrightblack", _rule(prompt_line) + "\n"),
+            ("bold fg:ansiwhite", "❯ "),
+        ])
+
+    # ---- the bottom rule + status line ------------------------------------
+    def _toolbar(self):
+        label, _hint = _LABEL.get(self.uic.mode, _LABEL["normal"])
+        seg_mode = f"  {label} mode on (shift+tab to cycle)"
+        seg_agents = " · ← for agents"
+
+        n = self.tokens()
+        tok = f"{n:,} tokens"
+        fname = getattr(self.uic, "last_file", None)
+        hint = "  ·  ⇧⏎ newline"
+        # Pack the segments together with small separators — no big pad gap.
+        right = "  ·  " + (f"⧉ {fname}  ·  " if fname else "") + tok + hint
+        status_line = seg_mode + seg_agents + right
+
+        return FormattedText([
+            ("fg:ansibrightblack", _rule(status_line) + "\n"),
+            ("bold fg:ansiwhite", seg_mode),
+            ("fg:ansibrightblack", seg_agents),
+            ("fg:ansibrightblack", right),
+        ])
+
+    # ---- ask ---------------------------------------------------------------
+    def ask(self, model: str, tokens_fn, budget: int) -> str:
+        self.model = model
+        self.tokens = tokens_fn
+        self.budget = budget
+        if self._session is not None:
+            # Pick the placeholder now so the top rule can size itself to it.
+            self._ph_text = random.choice(PLACEHOLDERS)
+            ph = FormattedText([("fg:ansibrightblack", self._ph_text)])
+            return self._session.prompt(placeholder=ph).strip()
+        # Fallback: plain prompt with simple rules, also fit to the words.
+        self._ph_text = random.choice(PLACEHOLDERS)
+        rule = _rule("❯ " + self._ph_text)
+        print(rule)
+        try:
+            line = input("❯ ").strip()
+        finally:
+            print(rule)
+        return line

xcode/mcp.py

@@ -0,0 +1,157 @@
+"""Minimal MCP (Model Context Protocol) client.
+
+Launches MCP servers over stdio (newline-delimited JSON-RPC 2.0), lists their
+tools, and lets the agent call them. Servers are declared in
+.xcode/settings.json:
+
+  "mcpServers": {
+    "fs": {"command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]}
+  }
+
+Each server tool is exposed to the model as  mcp__<server>__<tool>.
+"""
+
+from __future__ import annotations
+
+import json
+import queue
+import subprocess
+import threading
+from typing import Optional
+
+PROTOCOL = "2024-11-05"
+
+
+class McpClient:
+    def __init__(self, name: str, command: str, args: list[str],
+                 env: Optional[dict] = None):
+        self.name = name
+        self.tools: list[dict] = []
+        self._id = 0
+        self._inbox: "queue.Queue[dict]" = queue.Queue()
+        self.proc = subprocess.Popen(
+            [command, *args], stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL, text=True, bufsize=1, env=_merged_env(env))
+        threading.Thread(target=self._reader, daemon=True).start()
+
+    # ---- lifecycle ---------------------------------------------------------
+    def initialize(self) -> None:
+        self._request("initialize", {
+            "protocolVersion": PROTOCOL,
+            "capabilities": {},
+            "clientInfo": {"name": "xcode", "version": "0.1"},
+        })
+        self._notify("notifications/initialized", {})
+        res = self._request("tools/list", {})
+        self.tools = (res or {}).get("tools", [])
+
+    def call(self, tool: str, arguments: dict) -> str:
+        res = self._request("tools/call", {"name": tool, "arguments": arguments})
+        if res is None:
+            return f"ERROR: no response from MCP server '{self.name}'"
+        parts = []
+        for block in res.get("content", []):
+            if block.get("type") == "text":
+                parts.append(block.get("text", ""))
+            else:
+                parts.append(json.dumps(block))
+        out = "\n".join(parts) if parts else json.dumps(res)
+        return ("ERROR: " + out) if res.get("isError") else out
+
+    def close(self) -> None:
+        try:
+            self.proc.terminate()
+        except Exception:
+            pass
+
+    # ---- transport ---------------------------------------------------------
+    def _reader(self) -> None:
+        for line in self.proc.stdout:  # type: ignore[union-attr]
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                self._inbox.put(json.loads(line))
+            except json.JSONDecodeError:
+                continue
+
+    def _send(self, obj: dict) -> None:
+        self.proc.stdin.write(json.dumps(obj) + "\n")  # type: ignore[union-attr]
+        self.proc.stdin.flush()                          # type: ignore[union-attr]
+
+    def _notify(self, method: str, params: dict) -> None:
+        self._send({"jsonrpc": "2.0", "method": method, "params": params})
+
+    def _request(self, method: str, params: dict, timeout: float = 30) -> Optional[dict]:
+        self._id += 1
+        rid = self._id
+        self._send({"jsonrpc": "2.0", "id": rid, "method": method, "params": params})
+        # Drain until we see the matching response (skip notifications/logs).
+        while True:
+            try:
+                msg = self._inbox.get(timeout=timeout)
+            except queue.Empty:
+                return None
+            if msg.get("id") == rid:
+                if "error" in msg:
+                    return {"isError": True,
+                            "content": [{"type": "text",
+                                         "text": json.dumps(msg["error"])}]}
+                return msg.get("result", {})
+
+
+class McpManager:
+    """Owns all connected servers and exposes their tools to the agent."""
+
+    def __init__(self):
+        self.clients: dict[str, McpClient] = {}
+
+    def connect_all(self, servers: dict, on_status=lambda s: None) -> None:
+        for name, cfg in (servers or {}).items():
+            try:
+                c = McpClient(name, cfg["command"], cfg.get("args", []),
+                              cfg.get("env"))
+                c.initialize()
+                self.clients[name] = c
+                on_status(f"MCP '{name}': {len(c.tools)} tools")
+            except Exception as e:
+                on_status(f"MCP '{name}' failed: {e}")
+
+    def schemas(self) -> list[dict]:
+        """OpenAI-format tool schemas for every MCP tool, namespaced."""
+        out = []
+        for name, client in self.clients.items():
+            for t in client.tools:
+                out.append({"type": "function", "function": {
+                    "name": f"mcp__{name}__{t['name']}",
+                    "description": f"[{name}] {t.get('description', '')}",
+                    "parameters": t.get("inputSchema",
+                                        {"type": "object", "properties": {}}),
+                }})
+        return out
+
+    def handles(self, tool_name: str) -> bool:
+        return tool_name.startswith("mcp__")
+
+    def call(self, tool_name: str, args: dict) -> str:
+        try:
+            _, server, tool = tool_name.split("__", 2)
+        except ValueError:
+            return f"ERROR: malformed MCP tool name '{tool_name}'"
+        client = self.clients.get(server)
+        if not client:
+            return f"ERROR: no MCP server '{server}'"
+        return client.call(tool, args)
+
+    def close(self) -> None:
+        for c in self.clients.values():
+            c.close()
+
+
+def _merged_env(env: Optional[dict]) -> Optional[dict]:
+    if not env:
+        return None
+    import os
+    merged = dict(os.environ)
+    merged.update({k: str(v) for k, v in env.items()})
+    return merged

xcode/memory.py

@@ -0,0 +1,34 @@
+"""Project memory: an XCODE.md file at the repo root that's auto-loaded into the
+system prompt, so the agent remembers project conventions across sessions.
+
+Mirrors how Claude Code uses CLAUDE.md.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+CANDIDATES = ["XCODE.md", "CLAUDE.md", ".xcode/XCODE.md"]
+
+INIT_INSTRUCTION = (
+    "Explore this project and write an XCODE.md file at the repo root. "
+    "Use list_dir, glob_files, grep and read_file to understand it. The file "
+    "should be concise and cover: what the project is, how to build/run/test it, "
+    "the main directories and entry points, and any conventions a new contributor "
+    "should follow. Keep it under ~60 lines. When done, write the file with "
+    "write_file and give a one-line confirmation."
+)
+
+
+def load() -> str:
+    """Return the contents of the first project-memory file found, or ''."""
+    for name in CANDIDATES:
+        p = Path(name)
+        if p.is_file():
+            try:
+                text = p.read_text(encoding="utf-8", errors="replace").strip()
+                if text:
+                    return f"# Project memory ({name})\n{text}"
+            except Exception:
+                pass
+    return ""