fcp-python 0.1.0__py3-none-any.whl

fcp_python/__init__.py

@@ -0,0 +1 @@
+"""fcp-python — Python Code Intelligence FCP server."""

fcp_python/bridge.py

@@ -0,0 +1,195 @@
+"""Slipstream bridge — connects FCP server to daemon via Unix socket.
+
+Runs in a daemon thread so it never blocks the main MCP server.
+Silently returns on any connection failure (bridge is invisible
+when Slipstream isn't running).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import threading
+from typing import Any, Awaitable, Callable
+
+_AGENT_HELP = """\
+### python — LSP-powered Python navigation and refactoring
+
+#### Session
+```
+slipstream fcp python "open /path/to/project"
+slipstream fcp python "status"
+slipstream fcp python "close"
+```
+
+#### Navigation
+```
+slipstream fcp python_query "find MyClass"
+slipstream fcp python_query "find process kind:function"
+slipstream fcp python_query "def main @file:src/app.py"
+slipstream fcp python_query "refs Config @file:models.py"
+slipstream fcp python_query "symbols src/utils.py"
+slipstream fcp python_query "impl BaseHandler"
+```
+
+#### Inspection
+```
+slipstream fcp python_query "inspect MyClass"
+slipstream fcp python_query "callers process_data"
+slipstream fcp python_query "callees handle_request"
+slipstream fcp python_query "diagnose"
+slipstream fcp python_query "diagnose src/main.py"
+slipstream fcp python_query "map"
+slipstream fcp python_query "unused @file:src/utils.py"
+```
+
+#### Refactoring
+```
+slipstream fcp python "rename Config Settings"
+slipstream fcp python "extract validate @file:server.py @lines:15-30"
+slipstream fcp python "import os @file:main.py @line:5"
+```
+
+#### Selectors
+- `@file:PATH` — filter by file path
+- `@class:NAME` — filter by containing class
+- `@module:NAME` — filter by module
+- `@kind:KIND` — function, class, method, variable, constant, module, property
+- `@line:N` — filter by line number
+- `@lines:N-M` — line range (for extract)
+- `@decorator:NAME` — filter by decorator (e.g. `@decorator:staticmethod`)
+"""
+
+
+def start_bridge(
+    handle_session: Callable[[str], Awaitable[str]],
+    handle_query: Callable[[str], Awaitable[str]],
+    handle_mutation: Callable[[list[str]], Awaitable[str]],
+) -> None:
+    """Connect to Slipstream daemon if available.
+
+    Spawns a daemon thread with its own event loop. Silently returns
+    if the socket is not found or any connection error occurs.
+    """
+    try:
+        path = _discover_socket()
+        if path is None:
+            return
+        t = threading.Thread(
+            target=_bridge_thread,
+            args=(path, handle_session, handle_query, handle_mutation),
+            daemon=True,
+        )
+        t.start()
+    except Exception:  # noqa: BLE001
+        pass
+
+
+def _bridge_thread(
+    path: str,
+    handle_session: Callable[[str], Awaitable[str]],
+    handle_query: Callable[[str], Awaitable[str]],
+    handle_mutation: Callable[[list[str]], Awaitable[str]],
+) -> None:
+    """Entry point for the daemon thread."""
+    try:
+        asyncio.run(_run_bridge_at(path, handle_session, handle_query, handle_mutation))
+    except Exception:  # noqa: BLE001
+        pass
+
+
+def _discover_socket() -> str | None:
+    """Find daemon socket path."""
+    # 1. SLIPSTREAM_SOCKET env var
+    path = os.environ.get("SLIPSTREAM_SOCKET")
+    if path and os.path.exists(path):
+        return path
+
+    # 2. XDG_RUNTIME_DIR/slipstream/daemon.sock
+    xdg = os.environ.get("XDG_RUNTIME_DIR")
+    if xdg:
+        path = os.path.join(xdg, "slipstream", "daemon.sock")
+        if os.path.exists(path):
+            return path
+
+    # 3. /tmp/slipstream-{uid}/daemon.sock
+    uid = os.getuid()
+    path = f"/tmp/slipstream-{uid}/daemon.sock"
+    if os.path.exists(path):
+        return path
+
+    return None
+
+
+async def _run_bridge_at(
+    path: str,
+    handle_session: Callable[[str], Awaitable[str]],
+    handle_query: Callable[[str], Awaitable[str]],
+    handle_mutation: Callable[[list[str]], Awaitable[str]],
+) -> None:
+    """Async loop: connect, register, then handle NDJSON requests."""
+    reader, writer = await asyncio.open_unix_connection(path)
+
+    # Send registration
+    register = {
+        "jsonrpc": "2.0",
+        "method": "fcp.register",
+        "params": {
+            "handler_name": "fcp-py",
+            "extensions": ["py"],
+            "capabilities": ["ops", "query", "session"],
+            "agent_help": _AGENT_HELP,
+        },
+    }
+    writer.write((json.dumps(register) + "\n").encode())
+    await writer.drain()
+
+    # Request loop (newline-delimited JSON)
+    while True:
+        line = await reader.readline()
+        if not line:
+            break
+
+        try:
+            req = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+
+        req_id = req.get("id")
+        method = req.get("method", "")
+        params = req.get("params") or {}
+
+        text = await _handle_request(
+            method, params, handle_session, handle_query, handle_mutation
+        )
+
+        response = {
+            "jsonrpc": "2.0",
+            "id": req_id,
+            "result": {"text": text},
+        }
+        writer.write((json.dumps(response) + "\n").encode())
+        await writer.drain()
+
+    writer.close()
+
+
+async def _handle_request(
+    method: str,
+    params: dict[str, Any],
+    handle_session: Callable[[str], Awaitable[str]],
+    handle_query: Callable[[str], Awaitable[str]],
+    handle_mutation: Callable[[list[str]], Awaitable[str]],
+) -> str:
+    if method == "fcp.session":
+        action = params.get("action", "")
+        return await handle_session(action)
+    elif method == "fcp.ops":
+        ops = params.get("ops", [])
+        return await handle_mutation(ops)
+    elif method == "fcp.query":
+        q = params.get("q", "")
+        return await handle_query(q)
+    else:
+        return f"unknown method: {method}"

fcp_python/domain/format.py

@@ -0,0 +1,221 @@
+"""Output formatting for query results."""
+
+from __future__ import annotations
+
+from fcp_python.lsp.types import (
+    CallHierarchyIncomingCall,
+    CallHierarchyOutgoingCall,
+    CodeAction,
+    Diagnostic,
+    DiagnosticSeverity,
+    DocumentSymbol,
+    Location,
+    Range,
+)
+from fcp_python.lsp.workspace_edit import ApplyResult
+from fcp_python.resolver.index import SymbolEntry
+
+
+def format_navigation_result(locations: list[Location], description: str) -> str:
+    if not locations:
+        return f"No {description} found."
+    lines = [f"{description} ({len(locations)}):"]
+    for loc in locations:
+        lines.append(
+            f"  {short_uri(loc.uri)} L{loc.range.start.line + 1}:{loc.range.start.character + 1}"
+        )
+    return "\n".join(lines)
+
+
+def format_definition(uri: str, range_: Range, source_snippet: str | None = None) -> str:
+    result = f"Definition: {short_uri(uri)} L{range_.start.line + 1}:{range_.start.character + 1}"
+    if source_snippet:
+        result += f"\n\n{source_snippet}"
+    return result
+
+
+def format_symbol_outline(file: str, symbols: list[DocumentSymbol], indent: int) -> str:
+    lines: list[str] = []
+    if indent == 0:
+        lines.append(f"Symbols in {short_uri(file)}:")
+    prefix = "  " * (indent + 1)
+    for sym in symbols:
+        kind_str = sym.kind.display_name()
+        lines.append(f"{prefix}{sym.name} ({kind_str}) L{sym.range.start.line + 1}")
+        if sym.children:
+            lines.append(format_symbol_outline(file, sym.children, indent + 1))
+    return "\n".join(lines)
+
+
+def format_diagnostics(uri: str, diagnostics: list[Diagnostic]) -> str:
+    if not diagnostics:
+        return f"{short_uri(uri)}: clean"
+    lines = [f"{short_uri(uri)} ({len(diagnostics)} issues):"]
+    for d in diagnostics:
+        severity = {
+            DiagnosticSeverity.Error: "ERROR",
+            DiagnosticSeverity.Warning: "WARN",
+            DiagnosticSeverity.Information: "INFO",
+            DiagnosticSeverity.Hint: "HINT",
+        }.get(d.severity, "???")  # type: ignore[arg-type]
+        lines.append(
+            f"  L{d.range.start.line + 1}: [{severity}] {summarize_diagnostic_message(d.message)}"
+        )
+    return "\n".join(lines)
+
+
+def format_disambiguation(name: str, entries: list[SymbolEntry]) -> str:
+    lines = [f"? Multiple matches for '{name}'. Narrow with a selector:"]
+    for i, entry in enumerate(entries):
+        container = f" in {entry.container_name}" if entry.container_name else ""
+        lines.append(
+            f"  {i + 1}. {entry.name} ({entry.kind!r}){container} — {short_uri(entry.uri)}"
+        )
+    return "\n".join(lines)
+
+
+def format_hover(
+    name: str, kind: str, uri: str, range_: Range, contents: str
+) -> str:
+    lines = [f"{name} ({kind}) — {short_uri(uri)} L{range_.start.line + 1}"]
+    if contents:
+        lines.append("")
+        lines.append(contents)
+    return "\n".join(lines)
+
+
+def format_callers(name: str, calls: list[CallHierarchyIncomingCall]) -> str:
+    if not calls:
+        return f"No callers of '{name}'."
+    lines = [f"Callers of '{name}' ({len(calls)}):"]
+    for call in calls:
+        lines.append(
+            f"  {call.from_item.name} ({call.from_item.kind!r}) — "
+            f"{short_uri(call.from_item.uri)} L{call.from_item.range.start.line + 1}"
+        )
+    return "\n".join(lines)
+
+
+def format_callees(name: str, calls: list[CallHierarchyOutgoingCall]) -> str:
+    if not calls:
+        return f"No callees of '{name}'."
+    lines = [f"Callees of '{name}' ({len(calls)}):"]
+    for call in calls:
+        lines.append(
+            f"  {call.to.name} ({call.to.kind!r}) — "
+            f"{short_uri(call.to.uri)} L{call.to.range.start.line + 1}"
+        )
+    return "\n".join(lines)
+
+
+def format_implementations(name: str, locations: list[Location]) -> str:
+    if not locations:
+        return f"No implementations of '{name}'."
+    lines = [f"Implementations of '{name}' ({len(locations)}):"]
+    for loc in locations:
+        lines.append(
+            f"  {short_uri(loc.uri)} L{loc.range.start.line + 1}:{loc.range.start.character + 1}"
+        )
+    return "\n".join(lines)
+
+
+def format_workspace_map(
+    root_uri: str,
+    file_count: int,
+    symbol_count: int,
+    errors: int,
+    warnings: int,
+) -> str:
+    lines = [
+        f"Workspace: {short_uri(root_uri)}",
+        f"  Files: {file_count}",
+        f"  Symbols: {symbol_count}",
+    ]
+    if errors > 0 or warnings > 0:
+        lines.append(f"  Diagnostics: {errors} errors, {warnings} warnings")
+    else:
+        lines.append("  Diagnostics: clean")
+    return "\n".join(lines)
+
+
+def format_unused(items: list[tuple[str, Diagnostic]]) -> str:
+    if not items:
+        return "No unused symbols found."
+    lines = [f"Unused symbols ({len(items)}):"]
+    for uri, diag in items:
+        classification = _classify_unused(diag.message)
+        lines.append(
+            f"  {short_uri(uri)} L{diag.range.start.line + 1}: "
+            f"[{classification}] {summarize_diagnostic_message(diag.message)}"
+        )
+    return "\n".join(lines)
+
+
+def format_mutation_result(
+    verb: str, description: str, result: ApplyResult, root_uri: str
+) -> str:
+    total = result.total_edits()
+    file_count = len(result.files_changed)
+    lines = [
+        f"{verb}: {description} ({file_count} {'file' if file_count == 1 else 'files'}, "
+        f"{total} {'edit' if total == 1 else 'edits'})"
+    ]
+    for uri, count in result.files_changed:
+        lines.append(
+            f"  {relative_path(uri, root_uri)}: {count} {'edit' if count == 1 else 'edits'}"
+        )
+    for uri in result.files_created:
+        lines.append(f"  {relative_path(uri, root_uri)} (created)")
+    for old, new in result.files_renamed:
+        lines.append(
+            f"  {relative_path(old, root_uri)} → {relative_path(new, root_uri)} (renamed)"
+        )
+    return "\n".join(lines)
+
+
+def format_code_action_choices(actions: list[CodeAction]) -> str:
+    lines = [f"? Multiple code actions available ({len(actions)}):"]
+    for i, action in enumerate(actions):
+        kind = action.kind or "unknown"
+        preferred = " (preferred)" if action.is_preferred else ""
+        lines.append(f"  {i + 1}. [{kind}] {action.title}{preferred}")
+    return "\n".join(lines)
+
+
+def _classify_unused(message: str) -> str:
+    lower = message.lower()
+    if "dead_code" in lower or "never constructed" in lower:
+        return "dead_code"
+    if "never read" in lower:
+        return "never_read"
+    return "unused"
+
+
+def format_error(message: str, suggestion: str | None = None) -> str:
+    if suggestion:
+        return f"! {message} Did you mean '{suggestion}'?"
+    return f"! {message}"
+
+
+def summarize_diagnostic_message(raw: str) -> str:
+    # Strip Python error code prefixes like "E0308: "
+    if raw.startswith("E") and len(raw) > 5:
+        code = raw[1:5]
+        if code.isdigit():
+            after = raw[5:]
+            if after.startswith(": "):
+                return after[2:]
+    return raw
+
+
+def short_uri(uri: str) -> str:
+    return uri.removeprefix("file://")
+
+
+def relative_path(uri: str, root_uri: str) -> str:
+    path = short_uri(uri)
+    root = short_uri(root_uri).rstrip("/")
+    if path.startswith(root):
+        rel = path[len(root):]
+        return rel.lstrip("/")
+    return path

fcp_python/domain/model.py

@@ -0,0 +1,42 @@
+"""Domain model for Python workspace."""
+
+from __future__ import annotations
+
+import time
+
+from fcp_python.lsp.client import LspClient
+from fcp_python.lsp.lifecycle import ServerStatus
+from fcp_python.lsp.types import Diagnostic, DiagnosticSeverity
+from fcp_python.resolver.index import SymbolIndex
+
+
+class PythonModel:
+    def __init__(self, root_uri: str) -> None:
+        self.root_uri = root_uri
+        self.lsp_client: LspClient | None = None
+        self.symbol_index = SymbolIndex()
+        self.diagnostics: dict[str, list[Diagnostic]] = {}
+        self.open_documents: dict[str, int] = {}  # uri -> version
+        self.server_status = ServerStatus.NotStarted
+        self.py_file_count = 0
+        self.last_reload: float | None = None
+
+    def update_diagnostics(self, uri: str, diagnostics: list[Diagnostic]) -> None:
+        if not diagnostics:
+            self.diagnostics.pop(uri, None)
+        else:
+            self.diagnostics[uri] = diagnostics
+
+    def total_diagnostics(self) -> tuple[int, int]:
+        errors = 0
+        warnings = 0
+        for diags in self.diagnostics.values():
+            for d in diags:
+                if d.severity == DiagnosticSeverity.Error:
+                    errors += 1
+                elif d.severity == DiagnosticSeverity.Warning:
+                    warnings += 1
+        return (errors, warnings)
+
+    def diagnostic_count(self) -> int:
+        return sum(len(v) for v in self.diagnostics.values())