llmcode-cli 1.0.0__py3-none-any.whl

llm_code/hida/profiles.py

@@ -0,0 +1,95 @@
+"""Default task profiles mapping each TaskType to its tool/memory/governance set."""
+from __future__ import annotations
+
+from llm_code.hida.types import TaskProfile, TaskType
+
+# Core tool sets shared across profiles
+_FILE_READ = frozenset({"read_file", "glob_search", "grep_search"})
+_FILE_WRITE = frozenset({"write_file", "edit_file"})
+_SHELL = frozenset({"bash"})
+_MEMORY = frozenset({"memory_store", "memory_recall", "memory_list"})
+_GIT = frozenset({"git_diff", "git_log", "git_status"})
+_AGENT = frozenset({"agent"})
+
+DEFAULT_PROFILES: dict[TaskType, TaskProfile] = {
+    TaskType.CODING: TaskProfile(
+        task_type=TaskType.CODING,
+        confidence=1.0,
+        tools=_FILE_READ | _FILE_WRITE | _SHELL | _AGENT,
+        memory_keys=frozenset({"project_stack", "coding_style", "architecture"}),
+        governance_categories=frozenset({"coding"}),
+        load_full_prompt=False,
+    ),
+    TaskType.DEBUGGING: TaskProfile(
+        task_type=TaskType.DEBUGGING,
+        confidence=1.0,
+        tools=_FILE_READ | _SHELL | _AGENT,
+        memory_keys=frozenset({"known_issues", "project_stack"}),
+        governance_categories=frozenset({"debugging"}),
+        load_full_prompt=False,
+    ),
+    TaskType.REVIEWING: TaskProfile(
+        task_type=TaskType.REVIEWING,
+        confidence=1.0,
+        tools=_FILE_READ | _GIT,
+        memory_keys=frozenset({"coding_style", "review_guidelines"}),
+        governance_categories=frozenset({"reviewing"}),
+        load_full_prompt=False,
+    ),
+    TaskType.PLANNING: TaskProfile(
+        task_type=TaskType.PLANNING,
+        confidence=1.0,
+        tools=_FILE_READ | _MEMORY | _AGENT,
+        memory_keys=frozenset({"architecture", "project_stack", "roadmap"}),
+        governance_categories=frozenset({"planning"}),
+        load_full_prompt=False,
+    ),
+    TaskType.TESTING: TaskProfile(
+        task_type=TaskType.TESTING,
+        confidence=1.0,
+        tools=_FILE_READ | _FILE_WRITE | _SHELL,
+        memory_keys=frozenset({"project_stack", "test_patterns"}),
+        governance_categories=frozenset({"testing"}),
+        load_full_prompt=False,
+    ),
+    TaskType.REFACTORING: TaskProfile(
+        task_type=TaskType.REFACTORING,
+        confidence=1.0,
+        tools=_FILE_READ | _FILE_WRITE | _SHELL | _GIT,
+        memory_keys=frozenset({"architecture", "coding_style"}),
+        governance_categories=frozenset({"refactoring"}),
+        load_full_prompt=False,
+    ),
+    TaskType.RESEARCH: TaskProfile(
+        task_type=TaskType.RESEARCH,
+        confidence=1.0,
+        tools=_FILE_READ | _SHELL | _MEMORY | _AGENT,
+        memory_keys=frozenset({"project_stack"}),
+        governance_categories=frozenset({"research"}),
+        load_full_prompt=False,
+    ),
+    TaskType.DEPLOYMENT: TaskProfile(
+        task_type=TaskType.DEPLOYMENT,
+        confidence=1.0,
+        tools=_FILE_READ | _FILE_WRITE | _SHELL | _GIT,
+        memory_keys=frozenset({"deployment_config", "infrastructure"}),
+        governance_categories=frozenset({"deployment"}),
+        load_full_prompt=False,
+    ),
+    TaskType.DOCUMENTATION: TaskProfile(
+        task_type=TaskType.DOCUMENTATION,
+        confidence=1.0,
+        tools=_FILE_READ | _FILE_WRITE | _MEMORY,
+        memory_keys=frozenset({"project_stack", "architecture"}),
+        governance_categories=frozenset({"documentation"}),
+        load_full_prompt=False,
+    ),
+    TaskType.CONVERSATION: TaskProfile(
+        task_type=TaskType.CONVERSATION,
+        confidence=1.0,
+        tools=_MEMORY,
+        memory_keys=frozenset(),
+        governance_categories=frozenset({"conversation"}),
+        load_full_prompt=False,
+    ),
+}

llm_code/hida/types.py

@@ -0,0 +1,28 @@
+"""Frozen dataclasses and enums for HIDA task classification."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+
+class TaskType(Enum):
+    CODING = "coding"
+    DEBUGGING = "debugging"
+    REVIEWING = "reviewing"
+    PLANNING = "planning"
+    TESTING = "testing"
+    REFACTORING = "refactoring"
+    RESEARCH = "research"
+    DEPLOYMENT = "deployment"
+    DOCUMENTATION = "documentation"
+    CONVERSATION = "conversation"
+
+
+@dataclass(frozen=True)
+class TaskProfile:
+    task_type: TaskType
+    confidence: float
+    tools: frozenset[str]
+    memory_keys: frozenset[str]
+    governance_categories: frozenset[str]
+    load_full_prompt: bool

llm_code/ide/__init__.py

@@ -0,0 +1 @@
+"""IDE integration package."""

llm_code/ide/bridge.py

@@ -0,0 +1,80 @@
+"""High-level IDE bridge API with graceful fallback."""
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from llm_code.runtime.config import IDEConfig
+from llm_code.ide.server import IDEServer, JsonRpcError
+
+logger = logging.getLogger(__name__)
+
+
+class IDEBridge:
+    """High-level API for IDE communication. Degrades silently when disconnected."""
+
+    def __init__(self, config: IDEConfig) -> None:
+        self._config = config
+        self._server: IDEServer | None = None
+
+    @property
+    def is_enabled(self) -> bool:
+        return self._config.enabled
+
+    @property
+    def is_connected(self) -> bool:
+        if self._server is None:
+            return False
+        return self._server.is_running and len(self._server.connected_ides) > 0
+
+    async def start(self) -> None:
+        """Start the WebSocket server if IDE integration is enabled."""
+        if not self._config.enabled:
+            return
+        self._server = IDEServer(port=self._config.port)
+        await self._server.start()
+        logger.info("IDE bridge listening on port %d", self._server.actual_port)
+
+    async def stop(self) -> None:
+        """Stop the WebSocket server."""
+        if self._server is not None:
+            await self._server.stop()
+            self._server = None
+
+    async def open_file(self, path: str, line: int | None = None) -> bool:
+        """Ask the IDE to open a file. Returns False on failure."""
+        params: dict[str, Any] = {"path": path}
+        if line is not None:
+            params["line"] = line
+        result = await self._safe_request("ide/openFile", params)
+        return result is not None and result.get("ok", False)
+
+    async def get_diagnostics(self, path: str) -> list[dict]:
+        """Get diagnostics for a file from the IDE. Returns [] on failure."""
+        result = await self._safe_request("ide/diagnostics", {"path": path})
+        if result is None:
+            return []
+        return result.get("diagnostics", [])
+
+    async def get_selection(self) -> dict | None:
+        """Get the current editor selection. Returns None on failure."""
+        return await self._safe_request("ide/selection", {})
+
+    async def show_diff(self, path: str, old_text: str, new_text: str) -> bool:
+        """Ask the IDE to show a diff. Returns False on failure."""
+        result = await self._safe_request("ide/showDiff", {
+            "path": path,
+            "old_text": old_text,
+            "new_text": new_text,
+        })
+        return result is not None and result.get("ok", False)
+
+    async def _safe_request(self, method: str, params: dict) -> dict | None:
+        """Send a request, returning None on any failure."""
+        if self._server is None or not self._server.is_running:
+            return None
+        try:
+            return await self._server.send_request(method, params)
+        except (JsonRpcError, OSError, Exception) as exc:
+            logger.debug("IDE request %s failed: %s", method, exc)
+            return None

llm_code/ide/detector.py

@@ -0,0 +1,76 @@
+"""Detect running IDE processes."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class IDEInfo:
+    name: str
+    pid: int
+    workspace_path: str
+
+
+# Process name patterns -> IDE name
+_IDE_PATTERNS: dict[str, str] = {
+    "code": "vscode",
+    "code-insiders": "vscode",
+    "cursor": "vscode",
+    "nvim": "neovim",
+    "neovim": "neovim",
+    "idea": "jetbrains",
+    "pycharm": "jetbrains",
+    "webstorm": "jetbrains",
+    "goland": "jetbrains",
+    "clion": "jetbrains",
+    "rubymine": "jetbrains",
+    "rider": "jetbrains",
+    "phpstorm": "jetbrains",
+    "datagrip": "jetbrains",
+    "subl": "sublime",
+    "sublime_text": "sublime",
+}
+
+
+def _iter_processes() -> list:
+    """Iterate over running processes. Requires psutil."""
+    import psutil  # optional dependency
+    return list(psutil.process_iter(["name", "cmdline"]))
+
+
+def _extract_workspace(cmdline: list[str]) -> str:
+    """Best-effort extraction of workspace path from command line args."""
+    for arg in reversed(cmdline):
+        if arg.startswith("/") and not arg.startswith("--"):
+            return arg
+    return ""
+
+
+def detect_running_ide() -> list[IDEInfo]:
+    """Scan process list for known IDEs. Returns empty list on failure."""
+    try:
+        procs = _iter_processes()
+    except (ImportError, OSError):
+        return []
+
+    results: list[IDEInfo] = []
+    for proc in procs:
+        try:
+            info = proc.info
+            name = (info.get("name") or "").lower()
+            cmdline = info.get("cmdline") or []
+        except (AttributeError, KeyError):
+            continue
+
+        ide_name = _IDE_PATTERNS.get(name)
+        if ide_name is None:
+            continue
+
+        workspace = _extract_workspace(cmdline)
+        results.append(IDEInfo(
+            name=ide_name,
+            pid=proc.pid,
+            workspace_path=workspace,
+        ))
+
+    return results

llm_code/ide/server.py

@@ -0,0 +1,169 @@
+"""WebSocket JSON-RPC server for IDE communication."""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from dataclasses import dataclass
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_PORT = 9876
+
+
+class JsonRpcError(Exception):
+    """Raised when a JSON-RPC operation fails."""
+
+    def __init__(self, code: int, message: str) -> None:
+        super().__init__(message)
+        self.code = code
+
+
+@dataclass
+class _ConnectedIDE:
+    name: str
+    pid: int
+    workspace_path: str
+    websocket: Any  # websockets.WebSocketServerProtocol
+
+
+class IDEServer:
+    """WebSocket JSON-RPC server that IDE extensions connect to."""
+
+    def __init__(self, port: int = _DEFAULT_PORT) -> None:
+        self._port = port
+        self._server: Any | None = None
+        self._ides: list[_ConnectedIDE] = []
+        self._pending: dict[int, asyncio.Future] = {}
+        self._next_id = 1000
+        self._actual_port: int | None = None
+
+    @property
+    def is_running(self) -> bool:
+        return self._server is not None
+
+    @property
+    def actual_port(self) -> int:
+        if self._actual_port is None:
+            raise RuntimeError("Server not started")
+        return self._actual_port
+
+    @property
+    def connected_ides(self) -> list[_ConnectedIDE]:
+        return list(self._ides)
+
+    async def start(self) -> None:
+        import websockets
+
+        self._server = await websockets.serve(
+            self._handle_connection,
+            "127.0.0.1",
+            self._port,
+        )
+        # Resolve actual port (important when port=0)
+        for sock in self._server.sockets:
+            addr = sock.getsockname()
+            self._actual_port = addr[1]
+            break
+
+    async def stop(self) -> None:
+        if self._server is not None:
+            self._server.close()
+            await self._server.wait_closed()
+            self._server = None
+        self._ides.clear()
+        for fut in self._pending.values():
+            if not fut.done():
+                fut.set_exception(JsonRpcError(-32000, "Server shutting down"))
+        self._pending.clear()
+
+    async def send_request(self, method: str, params: dict) -> dict:
+        """Send a JSON-RPC request to the first connected IDE."""
+        if not self._ides:
+            raise JsonRpcError(-32000, "No IDE connected")
+
+        ide = self._ides[-1]  # most recently registered
+        req_id = self._next_id
+        self._next_id += 1
+
+        msg = json.dumps({
+            "jsonrpc": "2.0",
+            "method": method,
+            "params": params,
+            "id": req_id,
+        })
+
+        fut: asyncio.Future[dict] = asyncio.get_event_loop().create_future()
+        self._pending[req_id] = fut
+
+        try:
+            await ide.websocket.send(msg)
+            return await asyncio.wait_for(fut, timeout=10.0)
+        except asyncio.TimeoutError:
+            self._pending.pop(req_id, None)
+            raise JsonRpcError(-32000, f"IDE did not respond to {method} within 10s")
+
+    async def _handle_connection(self, websocket: Any) -> None:
+        """Handle a single IDE WebSocket connection."""
+        ide_entry: _ConnectedIDE | None = None
+        try:
+            async for raw in websocket:
+                try:
+                    msg = json.loads(raw)
+                except json.JSONDecodeError:
+                    await self._send_error(websocket, None, -32700, "Parse error")
+                    continue
+
+                msg_id = msg.get("id")
+                method = msg.get("method")
+
+                # If this is a response to our request (no method field)
+                if method is None and msg_id is not None:
+                    fut = self._pending.pop(msg_id, None)
+                    if fut is not None and not fut.done():
+                        if "error" in msg:
+                            fut.set_exception(JsonRpcError(
+                                msg["error"].get("code", -32000),
+                                msg["error"].get("message", "Unknown error"),
+                            ))
+                        else:
+                            fut.set_result(msg.get("result", {}))
+                    continue
+
+                # Handle incoming methods from IDE
+                if method == "ide/register":
+                    params = msg.get("params", {})
+                    ide_entry = _ConnectedIDE(
+                        name=params.get("name", "unknown"),
+                        pid=params.get("pid", 0),
+                        workspace_path=params.get("workspace_path", ""),
+                        websocket=websocket,
+                    )
+                    self._ides.append(ide_entry)
+                    await self._send_result(websocket, msg_id, {"ok": True})
+                    logger.info("IDE registered: %s (pid=%d)", ide_entry.name, ide_entry.pid)
+                else:
+                    await self._send_error(websocket, msg_id, -32601, f"Method not found: {method}")
+
+        except Exception:
+            logger.debug("IDE connection closed", exc_info=True)
+        finally:
+            if ide_entry is not None and ide_entry in self._ides:
+                self._ides.remove(ide_entry)
+
+    @staticmethod
+    async def _send_result(websocket: Any, msg_id: int | None, result: dict) -> None:
+        await websocket.send(json.dumps({
+            "jsonrpc": "2.0",
+            "result": result,
+            "id": msg_id,
+        }))
+
+    @staticmethod
+    async def _send_error(websocket: Any, msg_id: int | None, code: int, message: str) -> None:
+        await websocket.send(json.dumps({
+            "jsonrpc": "2.0",
+            "error": {"code": code, "message": message},
+            "id": msg_id,
+        }))

llm_code/logging.py

@@ -0,0 +1,29 @@
+"""Structured logging for llm-code."""
+from __future__ import annotations
+
+import logging
+import sys
+
+
+def setup_logging(verbose: bool = False) -> logging.Logger:
+    """Configure root llm_code logger. Safe to call multiple times."""
+    logger = logging.getLogger("llm_code")
+    if logger.handlers:
+        return logger
+
+    level = logging.DEBUG if verbose else logging.WARNING
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setFormatter(
+        logging.Formatter(
+            "%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+            datefmt="%H:%M:%S",
+        )
+    )
+    logger.addHandler(handler)
+    logger.setLevel(level)
+    return logger
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Return a child logger under the llm_code namespace."""
+    return logging.getLogger(f"llm_code.{name}")