somnia 0.1.0__py3-none-any.whl

openagent/__init__.py

@@ -0,0 +1,5 @@
+"""OpenAgent package."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

openagent/__main__.py

@@ -0,0 +1,10 @@
+"""somnia 命令行入口模块.
+
+这个模块允许通过 `python -m openagent` 或 `somnia` 运行。
+"""
+
+from openagent.cli.main import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

openagent/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI entrypoints for OpenAgent."""

openagent/cli/commands.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+import json
+import sys
+from dataclasses import dataclass
+
+from openagent.runtime.agent import OpenAgentRuntime
+from openagent.runtime.messages import MarkdownStreamRenderer, render_markdown_text, render_message_content, render_text_content
+from openagent.cli.prompting import choose_session_interactively, format_session_timestamp
+
+
+ASSISTANT_BULLET = "\u25cf"
+USER_BULLET = "\u276f"
+
+
+def _prefix_first_line(text: str, prefix: str) -> str:
+    if not text:
+        return prefix.rstrip()
+    lines = text.splitlines()
+    if not lines:
+        return prefix.rstrip()
+    lines[0] = f"{prefix}{lines[0]}"
+    return "\n".join(lines)
+
+
+def _assistant_prefix(*, ansi: bool) -> str:
+    if ansi:
+        return "\x1b[37m\u25cf\x1b[0m "
+    return f"{ASSISTANT_BULLET} "
+
+
+def _user_prefix(*, ansi: bool) -> str:
+    if ansi:
+        return "\x1b[38;5;45m\u276f\x1b[0m "
+    return f"{USER_BULLET} "
+
+
+def print_user_message(text: str, *, ansi: bool | None = None) -> None:
+    ansi_enabled = sys.stdout.isatty() if ansi is None else ansi
+    lines = text.splitlines() or [""]
+    first = f"{_user_prefix(ansi=ansi_enabled)}{lines[0]}"
+    remainder = [f"  {line}" if line else "  " for line in lines[1:]]
+    print()
+    print(first)
+    for line in remainder:
+        print(line)
+    print()
+
+
+class ConsoleStreamer:
+    def __init__(
+        self,
+        start_on_new_line: bool = False,
+        line_buffered: bool = False,
+        on_first_output=None,
+    ) -> None:
+        self.has_output = False
+        self.start_on_new_line = start_on_new_line
+        self.line_buffered = line_buffered
+        self.on_first_output = on_first_output
+        self._renderer: MarkdownStreamRenderer | None = None
+        self._started_printing = False
+
+    def __call__(self, text: str) -> None:
+        if not text:
+            return
+        if self._renderer is None:
+            self._renderer = MarkdownStreamRenderer(ansi=sys.stdout.isatty())
+        if not self.has_output and self.on_first_output is not None:
+            self.on_first_output()
+        self._print_rendered(self._renderer.feed(text))
+        self.has_output = True
+
+    def finish(self) -> None:
+        if not self.has_output:
+            return
+        if self._renderer is None:
+            return
+        self._print_rendered(self._renderer.finish())
+
+    def _print_rendered(self, rendered: str) -> None:
+        if not rendered:
+            return
+        if self.start_on_new_line and not self._started_printing:
+            print()
+        if not self._started_printing:
+            rendered = _prefix_first_line(rendered, _assistant_prefix(ansi=sys.stdout.isatty()))
+        print(rendered, end="" if rendered.endswith("\n") else "\n", flush=True)
+        self._started_printing = True
+
+
+@dataclass(slots=True)
+class SessionChoice:
+    session_id: str
+    label: str
+
+
+def _has_visible_exchange(session) -> bool:
+    has_user = False
+    has_assistant = False
+    for message in session.messages:
+        role = message.get("role")
+        content = message.get("content")
+        if role == "user" and isinstance(content, str):
+            if content.startswith("<background-results>") or content.startswith("<inbox>"):
+                continue
+            if content.strip():
+                has_user = True
+        elif role == "assistant":
+            text = render_text_content(content).strip()
+            if text:
+                has_assistant = True
+        if has_user and has_assistant:
+            return True
+    return False
+
+
+def _session_preview(session) -> str:
+    for message in reversed(session.messages):
+        role = message.get("role")
+        content = message.get("content")
+        if role == "assistant":
+            text = render_message_content(content, ansi=False).strip()
+        elif role == "user" and isinstance(content, str):
+            if content.startswith("<background-results>") or content.startswith("<inbox>"):
+                continue
+            text = content.strip()
+        else:
+            continue
+        if text:
+            return " ".join(text.split())[:80]
+    return "[no visible messages]"
+
+
+def _build_session_choices(runtime: OpenAgentRuntime) -> list[SessionChoice]:
+    choices: list[SessionChoice] = []
+    for session in runtime.list_sessions():
+        if not _has_visible_exchange(session):
+            continue
+        stamp = format_session_timestamp(session.updated_at or session.created_at)
+        preview = _session_preview(session)
+        label = f"{session.id} | {stamp} | {preview}"
+        choices.append(SessionChoice(session_id=session.id, label=label))
+    return choices
+
+
+def _select_session(runtime: OpenAgentRuntime):
+    choices = _build_session_choices(runtime)
+    if not choices:
+        print("No saved sessions. Starting a new chat.")
+        return runtime.create_session(), False
+
+    selected_id = choose_session_interactively([(item.session_id, item.label) for item in choices])
+    if not selected_id:
+        print("Session selection cancelled. Starting a new chat.")
+        return runtime.create_session(), False
+    return runtime.load_session(selected_id), True
+
+
+def cmd_chat(runtime: OpenAgentRuntime, resume: bool = False) -> int:
+    from openagent.cli.repl import run_repl
+
+    session, resumed = _select_session(runtime) if resume else (runtime.create_session(), False)
+    return run_repl(runtime, session, resumed=resumed)
+
+
+def cmd_run(runtime: OpenAgentRuntime, prompt: str) -> int:
+    session = runtime.create_session()
+    streamer = ConsoleStreamer()
+    result = runtime.run_turn(session, prompt, text_callback=streamer)
+    if streamer.has_output:
+        streamer.finish()
+    elif result:
+        print(_prefix_first_line(render_markdown_text(result, ansi=sys.stdout.isatty()), _assistant_prefix(ansi=sys.stdout.isatty())))
+    return 0
+
+
+def cmd_tasks_list(runtime: OpenAgentRuntime) -> int:
+    tasks = runtime.task_store.list_all()
+    if not tasks:
+        print("No tasks.")
+    else:
+        for task in tasks:
+            print(json.dumps(task, ensure_ascii=False, indent=2))
+    return 0
+
+
+def cmd_tasks_get(runtime: OpenAgentRuntime, task_id: int) -> int:
+    print(json.dumps(runtime.task_store.get(task_id), ensure_ascii=False, indent=2))
+    return 0
+
+
+def cmd_compact(runtime: OpenAgentRuntime) -> int:
+    session = runtime.latest_session()
+    runtime.compact_session(session)
+    print(f"Compacted session {session.id}")
+    return 0
+
+
+def cmd_doctor(runtime: OpenAgentRuntime) -> int:
+    print(runtime.doctor())
+    return 0

openagent/cli/main.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import argparse
+
+from openagent.config.settings import load_settings
+from openagent.runtime.agent import OpenAgentRuntime
+
+
+def _add_provider_overrides(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--provider",
+        default=argparse.SUPPRESS,
+        help="Override the configured provider for this invocation.",
+    )
+    parser.add_argument(
+        "--model",
+        default=argparse.SUPPRESS,
+        help="Override the configured model for this invocation.",
+    )
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="openagent")
+    parser.add_argument("--workspace", default=".", help="Workspace root for the agent.")
+    parser.add_argument(
+        "-r",
+        "-resume",
+        "--resume",
+        dest="resume",
+        action="store_true",
+        help="Open the interactive session picker and resume a saved chat.",
+    )
+    _add_provider_overrides(parser)
+    subparsers = parser.add_subparsers(dest="command")
+
+    chat_parser = subparsers.add_parser("chat", help="Start interactive chat mode.")
+    chat_parser.add_argument(
+        "-r",
+        "-resume",
+        "--resume",
+        dest="resume",
+        action="store_true",
+        help="Open the interactive session picker and resume a saved chat.",
+    )
+    _add_provider_overrides(chat_parser)
+
+    run_parser = subparsers.add_parser("run", help="Run a single prompt.")
+    run_parser.add_argument("prompt", help="Prompt to execute.")
+    _add_provider_overrides(run_parser)
+
+    tasks_parser = subparsers.add_parser("tasks", help="Inspect persistent tasks.")
+    _add_provider_overrides(tasks_parser)
+    tasks_subparsers = tasks_parser.add_subparsers(dest="tasks_command", required=True)
+    tasks_subparsers.add_parser("list", help="List tasks.")
+    get_parser = tasks_subparsers.add_parser("get", help="Get a task by ID.")
+    get_parser.add_argument("task_id", type=int)
+
+    compact_parser = subparsers.add_parser("compact", help="Compact the latest session.")
+    _add_provider_overrides(compact_parser)
+    doctor_parser = subparsers.add_parser("doctor", help="Validate runtime configuration.")
+    _add_provider_overrides(doctor_parser)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    settings = load_settings(
+        args.workspace,
+        provider_override=getattr(args, "provider", None),
+        model_override=getattr(args, "model", None),
+    )
+    runtime = OpenAgentRuntime(settings)
+    try:
+        from openagent.cli.commands import (
+            cmd_chat,
+            cmd_compact,
+            cmd_doctor,
+            cmd_run,
+            cmd_tasks_get,
+            cmd_tasks_list,
+        )
+
+        if args.command in {None, "chat"}:
+            return cmd_chat(runtime, resume=getattr(args, "resume", False))
+        if args.command == "run":
+            return cmd_run(runtime, args.prompt)
+        if args.command == "tasks" and args.tasks_command == "list":
+            return cmd_tasks_list(runtime)
+        if args.command == "tasks" and args.tasks_command == "get":
+            return cmd_tasks_get(runtime, args.task_id)
+        if args.command == "compact":
+            return cmd_compact(runtime)
+        if args.command == "doctor":
+            return cmd_doctor(runtime)
+        parser.error("Unsupported command")
+    finally:
+        runtime.close()
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())