mindcode 0.2.0__py3-none-any.whl

mindcode/cli/commands/terminal.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+import time
+from pathlib import Path
+import subprocess
+
+import typer
+from rich.table import Table
+
+from ...terminal_core import (
+    TerminalManager,
+    TerminalStore,
+    build_ghostty_open_argv,
+    tail_text,
+)
+from .._shared import console
+
+
+app = typer.Typer(help="管理本地交互式 terminal session")
+
+
+@app.command("open")
+def terminal_open(
+    cwd: str = typer.Option(".", "--cwd", "-C", help="terminal 工作目录"),
+    command: str | None = typer.Option(None, "--command", "-e", help="启动后执行的命令"),
+    app_path: str = typer.Option(
+        "/Applications/Ghostty.app",
+        "--app-path",
+        help="Ghostty.app 路径",
+    ),
+) -> None:
+    path = Path(cwd).expanduser().resolve()
+    if not path.is_dir():
+        console.print(f"[red]cwd 不存在或不是目录:[/red] {path}")
+        raise typer.Exit(2)
+    argv = build_ghostty_open_argv(cwd=path, command=command, app_path=app_path)
+    try:
+        subprocess.Popen(argv)
+    except FileNotFoundError:
+        console.print("[red]找不到 macOS open 命令[/red]")
+        raise typer.Exit(2)
+    console.print("opened Ghostty")
+
+
+@app.command("new")
+def terminal_new(
+    cwd: str = typer.Option(".", "--cwd", "-C", help="terminal 工作目录"),
+    shell: str | None = typer.Option(None, "--shell", help="shell 路径"),
+) -> None:
+    try:
+        record = TerminalManager().start(cwd=Path(cwd), shell=shell)
+    except ValueError as exc:
+        console.print(f"[red]terminal 创建失败:[/red] {exc}")
+        raise typer.Exit(2)
+    console.print(f"terminal_id={record.terminal_id}")
+    console.print(f"pid={record.pid}")
+
+
+@app.command("list")
+def terminal_list() -> None:
+    store = TerminalStore()
+    table = Table("terminal_id", "status", "pid", "cwd", "shell")
+    for record in store.list():
+        table.add_row(
+            record.terminal_id,
+            record.status,
+            str(record.pid or ""),
+            record.cwd,
+            record.shell,
+        )
+    console.print(table)
+
+
+@app.command("send")
+def terminal_send(
+    terminal_id: str,
+    text: str,
+    no_newline: bool = typer.Option(
+        False,
+        "--no-newline",
+        help="不追加换行",
+    ),
+) -> None:
+    try:
+        TerminalManager().send(terminal_id, text, newline=not no_newline)
+    except (FileNotFoundError, RuntimeError) as exc:
+        console.print(f"[red]send 失败:[/red] {exc}")
+        raise typer.Exit(2)
+    console.print("sent")
+
+
+@app.command("tail")
+def terminal_tail(
+    terminal_id: str,
+    lines: int = typer.Option(40, "--lines", "-n", help="显示最近行数"),
+    follow: bool = typer.Option(False, "--follow", "-f", help="持续追踪"),
+) -> None:
+    store = TerminalStore()
+    path = store.log_path(terminal_id)
+    if not path.exists():
+        console.print(f"[red]terminal log 不存在:[/red] {terminal_id}")
+        raise typer.Exit(2)
+    console.print(tail_text(path, lines))
+    if not follow:
+        return
+    offset = path.stat().st_size
+    while True:
+        time.sleep(1)
+        with path.open("r", encoding="utf-8", errors="replace") as file:
+            file.seek(offset)
+            chunk = file.read()
+            if chunk:
+                console.print(chunk, end="")
+            offset = file.tell()
+
+
+@app.command("close")
+def terminal_close(terminal_id: str) -> None:
+    try:
+        record = TerminalManager().close(terminal_id)
+    except FileNotFoundError:
+        console.print(f"[red]terminal 不存在:[/red] {terminal_id}")
+        raise typer.Exit(2)
+    console.print(f"closed {record.terminal_id}")

mindcode/cli/shell/__init__.py

@@ -0,0 +1,5 @@
+"""Shell 子包入口。"""
+
+from .repl import run_shell
+
+__all__ = ["run_shell"]

mindcode/cli/shell/completion.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from typing import Any
+
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.document import Document
+
+
+SLASH_COMMANDS = {
+    "models": "切换当前模型",
+    "compact": "压缩整理当前会话上下文",
+    "permissions": "切换权限模式",
+    "status": "显示当前会话状态",
+    "config": "显示配置",
+    "sessions": "列出本地会话",
+    "history": "打印当前会话消息",
+    "diff": "显示最后一次 diff",
+    "clear": "清空当前会话历史",
+    "help": "显示帮助",
+    "exit": "退出",
+}
+
+
+class MindcodeCompleter(Completer):
+    def __init__(self, state: Any):
+        self.state = state
+
+    def get_completions(self, document: Document, complete_event):
+        text = document.text_before_cursor
+        if not text.startswith("/"):
+            return
+
+        body = text[1:]
+        parts = body.split()
+        command_prefix = body if " " not in body else parts[0]
+
+        if " " not in body:
+            yield from _complete_words(
+                [f"/{name}" for name in SLASH_COMMANDS],
+                "/" + command_prefix,
+                descriptions=SLASH_COMMANDS,
+            )
+            return
+
+        command = parts[0] if parts else ""
+        arg_prefix = body[len(command):].lstrip()
+        if command == "models":
+            provider = self.state.config.providers.get(self.state.active_provider)
+            if provider:
+                yield from _complete_words(provider.models, arg_prefix)
+            return
+        if command == "permissions":
+            yield from _complete_words(["ask_user", "full_accept"], arg_prefix)
+
+
+def _complete_words(
+    options: list[str],
+    prefix: str,
+    *,
+    descriptions: dict[str, str] | None = None,
+):
+    for option in options:
+        if not option.startswith(prefix):
+            continue
+        display_meta = ""
+        if descriptions:
+            display_meta = descriptions.get(option.lstrip("/"), "")
+        yield Completion(
+            option,
+            start_position=-len(prefix),
+            display_meta=display_meta,
+        )

mindcode/cli/shell/menu.py

@@ -0,0 +1,88 @@
+"""交互式方向键选择菜单（prompt_toolkit ChoiceInput 包装）。"""
+
+from __future__ import annotations
+
+
+async def interactive_menu(
+    title: str,
+    options: list[tuple[str, str]],
+    default: str | None = None,
+) -> str | None:
+    """Show a navigable menu and return the selected value.
+
+    Args:
+        title: prompt message
+        options: list of (value, label); label supports Rich markup but
+            ChoiceInput only renders plain text — keep labels short
+        default: optional default value
+
+    Returns:
+        selected value, or None if user cancelled (Ctrl-C / Ctrl-D / empty)
+    """
+    try:
+        from prompt_toolkit.shortcuts.choice_input import ChoiceInput
+    except ImportError:
+        return await _fallback_menu(title, options, default)
+
+    try:
+        result = await ChoiceInput(
+            message=title,
+            options=options,
+            default=default if default in [v for v, _ in options] else None,
+        ).prompt_async()
+        return result
+    except (EOFError, KeyboardInterrupt):
+        return None
+
+
+async def _fallback_menu(
+    title: str,
+    options: list[tuple[str, str]],
+    default: str | None,
+) -> str | None:
+    """序号输入 fallback（无 prompt_toolkit 时用）。"""
+    import asyncio
+
+    print(f"\n{title}")
+    for idx, (_value, label) in enumerate(options, 1):
+        mark = " *" if default and options[idx - 1][0] == default else ""
+        print(f"  [{idx}] {label}{mark}")
+    answer = await asyncio.to_thread(
+        input, f"选择 [1-{len(options)}]，回车退出: "
+    )
+    answer = answer.strip()
+    if not answer:
+        return None
+    try:
+        idx = int(answer) - 1
+    except ValueError:
+        # 按名字匹配
+        for value, _label in options:
+            if value == answer:
+                return value
+        return None
+    if 0 <= idx < len(options):
+        return options[idx][0]
+    return None
+
+
+async def prompt_string(message: str, *, default: str = "") -> str:
+    """简单字符串输入；使用 prompt_toolkit 保留方向键编辑能力。"""
+    try:
+        from prompt_toolkit import PromptSession
+
+        return (
+            await PromptSession(message=message).prompt_async(default=default)
+        ).strip()
+    except (EOFError, KeyboardInterrupt):
+        return ""
+
+
+async def prompt_yes_no(message: str, *, default_yes: bool = True) -> bool:
+    """Y/N 确认，回车走 default。"""
+    hint = "[Y/n]" if default_yes else "[y/N]"
+    answer = await prompt_string(f"{message} {hint} ")
+    answer = answer.strip().lower()
+    if not answer:
+        return default_yes
+    return answer in {"y", "yes"}