lcode-cli 0.3.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

lcode/__init__.py

@@ -1,3 +1,3 @@
 """lcode — a local-first terminal coding agent powered by open-weight models via Ollama."""
 
-__version__ = "0.3.1"
+__version__ = "0.4.0"

lcode/agent.py

@@ -15,12 +15,14 @@ from pathlib import Path
 
 from rich.console import Console
 from rich.markdown import Markdown
+from rich.markup import escape
 from rich.panel import Panel
 from rich.text import Text
 
 from lcode import catalog, limits, sessions, web
 from lcode.checkpoints import Checkpoints
 from lcode.config import format_tokens
+from lcode.mcp import McpManager
 from lcode.ollama import Ollama, OllamaError
 from lcode.permissions import Permissions
 from lcode.render import MarkdownStreamer
@@ -150,6 +152,8 @@ class Agent:
         self.tools = Toolbox(self)
         self.session_id = self.new_session_id()
         self.checkpoints = Checkpoints(self.console, settings.checkpoints)
+        self.mcp: McpManager | None = None  # set by the CLI when MCP servers are configured
+        self._mcp_prompt = ""  # the MCP part at the end of the system prompt
         self.session_name = ""
         self.session_title = ""
         self.ctx_used = 0
@@ -188,9 +192,32 @@ class Agent:
         return web.resolve_backend(self.settings.search_backend, self.settings.searxng_url)
 
     def tool_schemas(self) -> list[dict]:
-        if self.settings.web == "off":
-            return SCHEMAS
-        return [*SCHEMAS, *([WEB_SEARCH_SCHEMA] if self.search_backend() else []), WEB_FETCH_SCHEMA]
+        schemas = list(SCHEMAS)
+        if self.settings.web != "off":
+            schemas += [*([WEB_SEARCH_SCHEMA] if self.search_backend() else []), WEB_FETCH_SCHEMA]
+        if self.mcp:
+            schemas += self.mcp.schemas(self.settings.context)
+        return schemas
+
+    def prepare_mcp(self) -> None:
+        """Before a request: wait for MCP servers still starting and describe them in the system prompt."""
+        if not self.mcp:
+            return
+        if self.mcp.pending:
+            with self.console.status(f"Starting MCP servers: {', '.join(self.mcp.pending)}", spinner="dots"):
+                self.mcp.wait()
+            for state in self.mcp.servers.values():
+                if state.status in ("failed", "login") and not state.reported:
+                    state.reported = True
+                    self.console.print(f"[yellow]MCP server {state.name}: {escape(state.error)}[/] [dim](/mcp)[/]")
+        self.mcp.refresh_changed()
+        section = self.mcp.prompt_section(self.settings.context)
+        if section != self._mcp_prompt:
+            content = self.messages[0]["content"]
+            if self._mcp_prompt and content.endswith(self._mcp_prompt):
+                content = content[: -len(self._mcp_prompt)]
+            self.messages[0]["content"] = content + section
+            self._mcp_prompt = section
 
     def web_prompt(self) -> str:
         if self.settings.web == "off":
@@ -203,6 +230,7 @@ class Agent:
 
     def reset(self) -> None:
         self.messages = [{"role": "system", "content": self.system_prompt()}]
+        self._mcp_prompt = ""
         self.tools.read_mtimes.clear()
         self.ctx_used = len(self.messages[0]["content"]) // 3
 
@@ -254,6 +282,7 @@ class Agent:
             else:
                 note = f"The session's directory {saved_cwd} no longer exists; staying in {self.cwd}"
         self.messages = [{"role": "system", "content": self.system_prompt()}, *data.get("messages", [])[1:]]
+        self._mcp_prompt = ""
         self.session_id = info.id
         self.checkpoints.load(info.id, data.get("checkpoints") or [])
         self.session_name = data.get("name", "")
@@ -415,6 +444,15 @@ class Agent:
             return f"glob({args.get('pattern', '')})"
         if name == "list_dir":
             return f"list_dir({args.get('path', '.')})"
+        if self.mcp and self.mcp.owns(name):
+            if name == "mcp_find_tools":
+                return f"mcp_find_tools({args.get('query', '')!r})"
+            try:
+                state, tool, arguments = self.mcp.resolve(name, args)
+            except Exception:
+                return name
+            preview = json.dumps(arguments, ensure_ascii=False)
+            return f"{state.name} › {tool['name']}({preview if len(preview) <= 80 else preview[:79] + '…'})"
         return name
 
     def run_turn(self, user_text: str) -> None:
@@ -429,6 +467,7 @@ class Agent:
         self.checkpoints.before_change(self.cwd)
 
     def _run_turn(self, user_text: str) -> None:
+        self.prepare_mcp()
         self.messages.append({"role": "user", "content": self.expand_mentions(user_text)})
         malformed = 0
         for _ in range(MAX_STEPS_PER_TURN):

lcode/bench.py

@@ -850,31 +850,33 @@ def run_task(
     ollama: Ollama, settings: Settings, task: Task, timeout: float, log: Console, keep: bool, usage: dict
 ) -> TaskResult:
     folder = Path(tempfile.mkdtemp(prefix=f"lcode-bench-{task.id}-"))
-    for rel, content in task.files.items():
-        (folder / rel).parent.mkdir(parents=True, exist_ok=True)
-        (folder / rel).write_text(content)
-    agent = Agent(ollama, settings, folder, console=log)
-    error = None
-    started = time.monotonic()
-    try:
-        with time_limit(timeout):
-            agent.run_turn(task.prompt)
-    except TaskTimeout:
-        error = f"timed out after {timeout:.0f}s"
-    except OllamaError as e:
-        error = str(e).splitlines()[0][:200]
-    seconds = time.monotonic() - started
-    for key, value in agent.usage.items():
-        usage[key] = usage.get(key, 0) + value
-    answer = next((m.get("content", "") for m in reversed(agent.messages) if m.get("role") == "assistant"), "")
     try:
-        check = task.check(folder, answer)
-    except Exception as e:  # a check must never crash the benchmark
-        check = Check(False, f"check failed: {type(e).__name__}: {e}")
-    if keep:
-        (folder / "lcode-bench.log").write_text(log.file.getvalue() if isinstance(log.file, io.StringIO) else "")
-    else:
-        shutil.rmtree(folder, ignore_errors=True)
+        for rel, content in task.files.items():
+            (folder / rel).parent.mkdir(parents=True, exist_ok=True)
+            (folder / rel).write_text(content)
+        agent = Agent(ollama, settings, folder, console=log)
+        error = None
+        started = time.monotonic()
+        try:
+            with time_limit(timeout):
+                agent.run_turn(task.prompt)
+        except TaskTimeout:
+            error = f"timed out after {timeout:.0f}s"
+        except OllamaError as e:
+            error = str(e).splitlines()[0][:200]
+        seconds = time.monotonic() - started
+        for key, value in agent.usage.items():
+            usage[key] = usage.get(key, 0) + value
+        answer = next((m.get("content", "") for m in reversed(agent.messages) if m.get("role") == "assistant"), "")
+        try:
+            check = task.check(folder, answer)
+        except Exception as e:  # a check must never crash the benchmark
+            check = Check(False, f"check failed: {type(e).__name__}: {e}")
+    finally:  # also when Ctrl+C stops the task
+        if keep:
+            (folder / "lcode-bench.log").write_text(log.file.getvalue() if isinstance(log.file, io.StringIO) else "")
+        else:
+            shutil.rmtree(folder, ignore_errors=True)
     return TaskResult(
         id=task.id,
         passed=check.passed and error is None,
@@ -1010,7 +1012,7 @@ def summary_rows(runs: list[ModelRun], tasks: list[Task]) -> list[tuple[str, lis
         return "—" if run.error else value
 
     rows += [
-        ("Passed", [cell(r, f"{r.passed}/{len(r.tasks)}") for r in runs]),
+        ("Passed", [cell(r, f"{r.passed}/{len(r.tasks)}" + (" (stopped)" if r.interrupted else "")) for r in runs]),
         ("Time", [cell(r, duration(r.seconds)) for r in runs]),
         ("Generation", [cell(r, f"{r.generation_tps:.1f} tok/s" if r.generation_tps else "?") for r in runs]),
         ("Prompt reading", [cell(r, f"{r.prompt_tps:,.0f} tok/s" if r.prompt_tps else "?") for r in runs]),

lcode/cli.py

@@ -310,6 +310,19 @@ def cmd_doctor(args) -> None:
         bool(shutil.which("rg")) or None,
     )
     line("git", "found" if shutil.which("git") else "not found", bool(shutil.which("git")) or None)
+    from lcode.mcp import config as mcp_config
+
+    try:
+        servers = mcp_config.load_user()
+        names = ", ".join(n for n, raw in servers.items() if not (isinstance(raw, dict) and raw.get("disabled")))
+        line(
+            "MCP", f"{names} (check them with lcode mcp list)" if names else "no servers (see lcode mcp catalog)", True
+        )
+    except ValueError as e:
+        line("MCP", str(e), False)
+        ok = False
+    node = shutil.which("npx")
+    line("Node.js", "found" if node else "not found (some MCP servers need npx)", True if node else None)
     sys.exit(0 if ok else 1)
 
 
@@ -367,7 +380,14 @@ def cmd_bench(args) -> None:
     console.print(f"[bold]lcode bench[/] · {hw.describe()} · Ollama {version}")
     console.print("[dim]Each task runs in a new temporary folder with every permission granted and web access off.[/]")
     names = args.models or [cfg["model"]]
-    others = [m.get("name", "?") for m in ollama.running()]
+    resolved: dict[str, tuple[str, ModelSpec | None] | NotInstalled] = {}
+    for name in names:
+        try:
+            resolved[name] = resolve_model(ollama, name)
+        except NotInstalled as e:
+            resolved[name] = e
+    benched = {r[0] for r in resolved.values() if isinstance(r, tuple)}
+    others = [m.get("name", "?") for m in ollama.running() if m.get("name", "").removesuffix(":latest") not in benched]
     if others:
         console.print(
             f"[yellow]Already loaded in Ollama: {', '.join(others)}. Models that share the GPU run slower; "
@@ -375,12 +395,12 @@ def cmd_bench(args) -> None:
         )
     runs = []
     for i, name in enumerate(names):
-        try:
-            model, spec = resolve_model(ollama, name)
-        except NotInstalled as e:
-            console.print(f"\n[yellow]Skipping {name}: {e}[/]")
-            runs.append(bench.ModelRun(name, name, error=str(e)))
+        found = resolved[name]
+        if isinstance(found, NotInstalled):
+            console.print(f"\n[yellow]Skipping {name}: {found}[/]")
+            runs.append(bench.ModelRun(name, name, error=str(found)))
             continue
+        model, spec = found
         ctx, note = choose_context(ollama, model, spec, context, hw)
         if note:
             console.print(f"[yellow]{model}, context {format_tokens(ctx)}: {note}[/]")
@@ -467,14 +487,22 @@ def cmd_chat(args) -> None:
         checkpoints=cfg["checkpoints"],
     )
     agent = Agent(ollama, settings, cwd, console=console)
-    repl(agent, prompt=args.prompt, hardware=hw, cont=args.cont, resume=args.resume)
+    if not args.no_mcp:
+        from lcode.mcp.commands import start_session
+
+        agent.mcp = start_session(cwd, cfg["mcp_tools"], console, interactive=not args.prompt)
+    try:
+        repl(agent, prompt=args.prompt, hardware=hw, cont=args.cont, resume=args.resume)
+    finally:
+        if agent.mcp:
+            agent.mcp.close()
 
 
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="lcode",
         description="A local-first terminal coding agent powered by open-weight models via Ollama.",
-        epilog="Subcommands: lcode setup | models | doctor | config | bench  (lcode <subcommand> --help). "
+        epilog="Subcommands: lcode setup | models | doctor | config | bench | mcp  (lcode <subcommand> --help). "
         "Docs: https://nasser1941.github.io/lcode/",
     )
     parser.add_argument("-p", "--prompt", help="run one request non-interactively and exit")
@@ -493,6 +521,7 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--yolo", action="store_true", help="never ask for permission (edits and commands)")
     parser.add_argument("--no-think", action="store_true", help="disable model reasoning (faster, less accurate)")
     parser.add_argument("--no-web", action="store_true", help="don't let the model search or fetch web pages")
+    parser.add_argument("--no-mcp", action="store_true", help="don't start MCP servers in this session")
     parser.add_argument("--show-thinking", action="store_true", help="print the model's reasoning as it streams")
     parser.add_argument("-V", "--version", action="version", version=f"lcode {__version__}")
     return parser
@@ -527,10 +556,26 @@ def build_subparsers() -> dict[str, argparse.ArgumentParser]:
     p.add_argument("-v", "--verbose", action="store_true", help="show the model working, like a normal session")
     p.add_argument("--list", action="store_true", help="list the tasks and exit")
     subs["bench"] = p
+    from lcode.mcp.commands import build_parser as mcp_parser
+
+    subs["mcp"] = mcp_parser()
     return subs
 
 
-COMMANDS = {"setup": cmd_setup, "models": cmd_models, "doctor": cmd_doctor, "config": cmd_config, "bench": cmd_bench}
+def cmd_mcp(args) -> None:
+    from lcode.mcp.commands import run
+
+    sys.exit(run(args, console))
+
+
+COMMANDS = {
+    "setup": cmd_setup,
+    "models": cmd_models,
+    "doctor": cmd_doctor,
+    "config": cmd_config,
+    "bench": cmd_bench,
+    "mcp": cmd_mcp,
+}
 
 
 def main(argv: list[str] | None = None) -> None:

lcode/config.py

@@ -24,6 +24,7 @@ DEFAULT_MODEL = "qwen3.6-35b"
 PERMISSION_MODES = ("ask", "auto-edit", "yolo")
 WEB_MODES = ("on", "ask", "off")
 SEARCH_BACKENDS = ("auto", "ollama", "brave", "tavily", "searxng")
+MCP_TOOL_MODES = ("auto", "direct", "search")
 
 # key -> (default, type, help)
 SETTINGS: dict[str, tuple[object, type, str]] = {
@@ -38,6 +39,7 @@ SETTINGS: dict[str, tuple[object, type, str]] = {
     "search_backend": ("auto", str, "auto | ollama | brave | tavily | searxng (keys come from environment variables)"),
     "searxng_url": (None, str, "your SearXNG instance, e.g. http://localhost:8888"),
     "checkpoints": (True, bool, "snapshot files before the model changes them, so /undo can restore them"),
+    "mcp_tools": ("auto", str, "how MCP tools reach the model: auto | direct | search (on demand, saves context)"),
 }
 ENV_OVERRIDES = {
     "LCODE_MODEL": "model",
@@ -97,6 +99,8 @@ def coerce(key: str, value: object) -> object:
         if value not in WEB_MODES:
             raise ConfigError(f"web must be one of {', '.join(WEB_MODES)}")
         return value
+    if key == "mcp_tools" and value not in MCP_TOOL_MODES:
+        raise ConfigError(f"mcp_tools must be one of {', '.join(MCP_TOOL_MODES)}")
     if key == "search_backend" and value not in SEARCH_BACKENDS:
         raise ConfigError(f"search_backend must be one of {', '.join(SEARCH_BACKENDS)}")
     if key == "permission_mode" and value not in PERMISSION_MODES:

lcode/mcp/__init__.py

@@ -0,0 +1,5 @@
+"""Model Context Protocol support: connect lcode to MCP servers and offer their tools to the model."""
+
+from lcode.mcp.manager import McpManager
+
+__all__ = ["McpManager"]