solohq-cli 0.1.0__tar.gz

solohq_cli-0.1.0/.env.example

@@ -0,0 +1,10 @@
+# Provide API keys for the providers you want to use (not all required)
+ANTHROPIC_API_KEY=sk-ant-...
+OPENAI_API_KEY=sk-...
+GOOGLE_API_KEY=...
+
+# SOLOHQ_MODEL=claude-sonnet-4-6
+# SOLOHQ_EMBEDDING_PROVIDER=openai
+# SOLOHQ_DB_PATH=~/.solohq/memory.db
+# SOLOHQ_USER_ID=default
+# SOLOHQ_DEBUG=false

solohq_cli-0.1.0/.gitignore

@@ -0,0 +1,13 @@
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+dist/
+build/
+*.swp
+*.swo
+*~
+.env
+*.db
+.pytest_cache/
+.venv/

solohq_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 SoloHQ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

solohq_cli-0.1.0/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: solohq-cli
+Version: 0.1.0
+Summary: Interactive CLI agent for SoloHQ Context Memory — terminal chat with persistent context memory
+Project-URL: Repository, https://github.com/whaleventure13/solohq-agent
+Author: SoloHQ
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: agno>=2.0
+Requires-Dist: duckduckgo-search>=7.0
+Requires-Dist: prompt-toolkit>=3.0
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: rich>=13.0
+Requires-Dist: solohq-agno>=0.1.0
+Requires-Dist: solohq-memory[all]>=0.1.0
+Requires-Dist: typer>=0.15
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# solohq-cli
+
+Interactive terminal chat agent with persistent context memory powered by [SoloHQ](https://github.com/whaleventure13/solohq-agent).
+
+## Installation
+
+```bash
+pip install solohq-cli
+```
+
+## Quick Start
+
+```bash
+# Set your API key
+export ANTHROPIC_API_KEY=sk-ant-...
+
+# Start chatting
+solohq chat
+```
+
+## Configuration
+
+Create a `.env` file or set environment variables:
+
+```bash
+# LLM provider (pick one)
+ANTHROPIC_API_KEY=sk-ant-...
+OPENAI_API_KEY=sk-...
+GOOGLE_API_KEY=...
+
+# Chat model (optional, auto-detected from API key)
+SOLOHQ_MODEL=claude-sonnet-4-6
+
+# Embedding provider: "openai" (default) or "google"
+SOLOHQ_EMBEDDING_PROVIDER=openai
+
+# Database path (optional)
+SOLOHQ_DB_PATH=~/.solohq/memory.db
+```
+
+## CLI Options
+
+```bash
+solohq chat --help
+
+Options:
+  -m, --model TEXT              Chat model ID (e.g. claude-sonnet-4-6, gpt-4o)
+  --anthropic-api-key TEXT      Anthropic API key
+  --openai-api-key TEXT         OpenAI API key
+  --google-api-key TEXT         Google API key
+  --embedding-provider TEXT     Embedding provider: openai or google
+  --db-path TEXT                SQLite database path
+```
+
+## Features
+
+- Multi-provider support: Anthropic, OpenAI, Google
+- Persistent context memory across conversations
+- Automatic context classification and switching
+- Artifact management with versioning
+- File indexing and search
+- Conversation boundary detection
+- Context relationship graph
+
+## License
+
+MIT

solohq_cli-0.1.0/README.md

@@ -0,0 +1,67 @@
+# solohq-cli
+
+Interactive terminal chat agent with persistent context memory powered by [SoloHQ](https://github.com/whaleventure13/solohq-agent).
+
+## Installation
+
+```bash
+pip install solohq-cli
+```
+
+## Quick Start
+
+```bash
+# Set your API key
+export ANTHROPIC_API_KEY=sk-ant-...
+
+# Start chatting
+solohq chat
+```
+
+## Configuration
+
+Create a `.env` file or set environment variables:
+
+```bash
+# LLM provider (pick one)
+ANTHROPIC_API_KEY=sk-ant-...
+OPENAI_API_KEY=sk-...
+GOOGLE_API_KEY=...
+
+# Chat model (optional, auto-detected from API key)
+SOLOHQ_MODEL=claude-sonnet-4-6
+
+# Embedding provider: "openai" (default) or "google"
+SOLOHQ_EMBEDDING_PROVIDER=openai
+
+# Database path (optional)
+SOLOHQ_DB_PATH=~/.solohq/memory.db
+```
+
+## CLI Options
+
+```bash
+solohq chat --help
+
+Options:
+  -m, --model TEXT              Chat model ID (e.g. claude-sonnet-4-6, gpt-4o)
+  --anthropic-api-key TEXT      Anthropic API key
+  --openai-api-key TEXT         OpenAI API key
+  --google-api-key TEXT         Google API key
+  --embedding-provider TEXT     Embedding provider: openai or google
+  --db-path TEXT                SQLite database path
+```
+
+## Features
+
+- Multi-provider support: Anthropic, OpenAI, Google
+- Persistent context memory across conversations
+- Automatic context classification and switching
+- Artifact management with versioning
+- File indexing and search
+- Conversation boundary detection
+- Context relationship graph
+
+## License
+
+MIT

solohq_cli-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "solohq-cli"
+version = "0.1.0"
+description = "Interactive CLI agent for SoloHQ Context Memory — terminal chat with persistent context memory"
+requires-python = ">=3.11"
+license = "MIT"
+authors = [
+    {name = "SoloHQ"},
+]
+readme = "README.md"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Typing :: Typed",
+]
+dependencies = [
+    "solohq-memory[all]>=0.1.0",
+    "solohq-agno>=0.1.0",
+    "agno>=2.0",
+    "typer>=0.15",
+    "python-dotenv>=1.0",
+    "rich>=13.0",
+    "prompt_toolkit>=3.0",
+    "duckduckgo-search>=7.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "pytest-asyncio>=0.24"]
+
+[project.scripts]
+solohq = "solohq_cli.main:app"
+
+[project.urls]
+Repository = "https://github.com/whaleventure13/solohq-agent"
+
+[tool.pytest.ini_options]
+asyncio_mode = "strict"

solohq_cli-0.1.0/src/solohq_cli/browser.py

@@ -0,0 +1,360 @@
+from __future__ import annotations
+
+import os
+import sys
+from io import StringIO
+from typing import TYPE_CHECKING
+
+from prompt_toolkit import Application
+from prompt_toolkit.formatted_text import ANSI, FormattedText, to_formatted_text
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.layout.containers import HSplit, Window
+from prompt_toolkit.layout.controls import FormattedTextControl
+from prompt_toolkit.layout.layout import Layout
+from prompt_toolkit.styles import Style
+
+from .display import (
+    console,
+    print_artifact_detail,
+    print_context_detail,
+    print_episode_detail,
+    print_info,
+)
+
+if TYPE_CHECKING:
+    from solohq_agno import AgnoContextMemory
+    from solohq_memory import ContextMemoryManager
+
+MAX_VISIBLE = 15
+
+_STYLE = Style.from_dict({
+    "title": "#888888",
+    "selected": "bold #ffffff",
+    "item": "#aaaaaa",
+    "hint": "#666666",
+    "sep": "#555555",
+})
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _clear_up(n: int) -> None:
+    """Move cursor up n lines and clear everything below."""
+    sys.stdout.write(f"\033[{n}A\033[J")
+    sys.stdout.flush()
+
+
+def _term_height() -> int:
+    try:
+        return os.get_terminal_size().lines
+    except (ValueError, OSError):
+        return 24
+
+
+def _capture_rich(fn, *args, **kwargs) -> str:  # noqa: ANN001, ANN003
+    """Call a Rich display function and capture its ANSI output."""
+    from rich.console import Console as RichConsole
+
+    buf = StringIO()
+    capture = RichConsole(
+        file=buf,
+        force_terminal=True,
+        width=console.width or 80,
+        color_system=console.color_system or "256",
+    )
+    import solohq_cli.display as _display
+
+    old = _display.console
+    _display.console = capture
+    try:
+        fn(*args, **kwargs)
+    finally:
+        _display.console = old
+    return buf.getvalue()
+
+
+def _ansi_lines(text: str) -> list[list[tuple[str, str]]]:
+    """Parse ANSI text into lines of prompt_toolkit (style, text) fragments."""
+    raw = to_formatted_text(ANSI(text))
+    merged: list[tuple[str, str]] = []
+    for style, ch in raw:
+        if merged and merged[-1][0] == style:
+            merged[-1] = (style, merged[-1][1] + ch)
+        else:
+            merged.append((style, ch))
+    lines: list[list[tuple[str, str]]] = [[]]
+    for style, chunk in merged:
+        parts = chunk.split("\n")
+        for i, part in enumerate(parts):
+            if i > 0:
+                lines.append([])
+            if part:
+                lines[-1].append((style, part))
+    if lines and not lines[-1]:
+        lines.pop()
+    return lines
+
+
+# ---------------------------------------------------------------------------
+# Full-screen scrollable detail viewer
+# ---------------------------------------------------------------------------
+
+
+async def _show_detail(fn, *args, **kwargs) -> None:  # noqa: ANN001, ANN003
+    """Show Rich output in a full-screen scrollable view."""
+    captured = _capture_rich(fn, *args, **kwargs)
+    lines = _ansi_lines(captured)
+    total = len(lines)
+    if total == 0:
+        return
+
+    view_h = [_term_height() - 2]
+    scroll = [0]
+
+    def _max_scroll() -> int:
+        return max(0, total - view_h[0])
+
+    def get_fragments() -> FormattedText:
+        result: list[tuple[str, str]] = []
+        vis = lines[scroll[0] : scroll[0] + view_h[0]]
+        for line_frags in vis:
+            result.extend(line_frags)
+            result.append(("", "\n"))
+        ms = _max_scroll()
+        if ms > 0:
+            lo = scroll[0] + 1
+            hi = min(scroll[0] + view_h[0], total)
+            result.append(("class:hint", f" [{lo}-{hi}/{total}] \u2191\u2193 scroll  Esc back"))
+        else:
+            result.append(("class:hint", " Esc to go back"))
+        return FormattedText(result)
+
+    control = FormattedTextControl(get_fragments, focusable=True)
+    window = Window(content=control, always_hide_cursor=True)
+
+    kb = KeyBindings()
+
+    @kb.add("up")
+    @kb.add("k")
+    def _up(event) -> None:  # noqa: ANN001
+        if scroll[0] > 0:
+            scroll[0] -= 1
+
+    @kb.add("down")
+    @kb.add("j")
+    def _down(event) -> None:  # noqa: ANN001
+        if scroll[0] < _max_scroll():
+            scroll[0] += 1
+
+    @kb.add("pageup")
+    def _pgup(event) -> None:  # noqa: ANN001
+        scroll[0] = max(0, scroll[0] - view_h[0])
+
+    @kb.add("pagedown")
+    @kb.add(" ")
+    def _pgdn(event) -> None:  # noqa: ANN001
+        scroll[0] = min(_max_scroll(), scroll[0] + view_h[0])
+
+    @kb.add("escape")
+    def _dismiss(event) -> None:  # noqa: ANN001
+        event.app.exit()
+
+    app: Application[None] = Application(
+        layout=Layout(HSplit([window])),
+        key_bindings=kb,
+        style=_STYLE,
+        full_screen=True,
+    )
+    await app.run_async()
+
+
+# ---------------------------------------------------------------------------
+# Inline picker — renders in-place, erases on exit
+# ---------------------------------------------------------------------------
+
+
+async def pick_item(items: list[tuple[str, str]], title: str = "") -> str | None:
+    """Inline vertical picker (\u2191\u2193). Self-cleaning via save/restore."""
+    if not items:
+        return None
+
+    selected = [0]
+    offset = [0]
+
+    def get_fragments() -> FormattedText:
+        frags: list[tuple[str, str]] = []
+        if title:
+            frags.append(("class:title", f" {title}\n"))
+        vis_count = min(len(items), MAX_VISIBLE)
+        for i in range(offset[0], offset[0] + vis_count):
+            if i >= len(items):
+                break
+            _id, label = items[i]
+            if i == selected[0]:
+                frags.append(("class:selected", f" > {label}\n"))
+            else:
+                frags.append(("class:item", f"   {label}\n"))
+        frags.append(("class:hint", " \u2191\u2193 navigate  Enter select  Esc back"))
+        return FormattedText(frags)
+
+    kb = KeyBindings()
+
+    @kb.add("up")
+    @kb.add("k")
+    def _up(event) -> None:  # noqa: ANN001
+        if selected[0] > 0:
+            selected[0] -= 1
+            if selected[0] < offset[0]:
+                offset[0] = selected[0]
+
+    @kb.add("down")
+    @kb.add("j")
+    def _down(event) -> None:  # noqa: ANN001
+        if selected[0] < len(items) - 1:
+            selected[0] += 1
+            if selected[0] >= offset[0] + MAX_VISIBLE:
+                offset[0] = selected[0] - MAX_VISIBLE + 1
+
+    @kb.add("enter")
+    def _select(event) -> None:  # noqa: ANN001
+        event.app.exit(result=items[selected[0]][0])
+
+    @kb.add("escape")
+    def _cancel(event) -> None:  # noqa: ANN001
+        event.app.exit(result=None)
+
+    control = FormattedTextControl(get_fragments, focusable=True)
+    window = Window(content=control, always_hide_cursor=True)
+
+    app: Application[str | None] = Application(
+        layout=Layout(HSplit([window])),
+        key_bindings=kb,
+        style=_STYLE,
+        full_screen=False,
+    )
+
+    result = await app.run_async()
+
+    # Erase picker: title + visible items + hint line.
+    height = (1 if title else 0) + min(len(items), MAX_VISIBLE) + 1
+    _clear_up(height)
+
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Browse functions
+# ---------------------------------------------------------------------------
+
+
+async def browse_contexts(
+    memory: ContextMemoryManager, user_id: str, plugin: AgnoContextMemory
+) -> None:
+    """Interactive context browser."""
+    contexts = await memory._storage.list_contexts(user_id)
+    if not contexts:
+        print_info("No contexts found.")
+        return
+
+    items = [
+        (ctx.id, f"{ctx.title}  {ctx.updated_at:%m-%d %H:%M}")
+        for ctx in contexts
+    ]
+    while True:
+        chosen = await pick_item(items, title="Contexts")
+        if not chosen:
+            return
+        ctx = await memory._storage.get_context(chosen)
+        if not ctx:
+            continue
+        loaded = await memory.load_context(chosen)
+        await _ctx_menu(ctx, loaded, memory, plugin)
+
+
+async def browse_current(
+    ctx, loaded, memory: ContextMemoryManager, plugin: AgnoContextMemory  # noqa: ANN001
+) -> None:
+    """Entry point for /current."""
+    await _ctx_menu(ctx, loaded, memory, plugin)
+
+
+async def _ctx_menu(
+    ctx, loaded, memory: ContextMemoryManager, plugin: AgnoContextMemory  # noqa: ANN001
+) -> None:
+    """Context sub-menu — inline picker with drill-down options."""
+    ep_count = len(loaded.episodes)
+    art_count = len(loaded.artifacts)
+    options: list[tuple[str, str]] = [
+        ("detail", "View details"),
+        ("episodes", f"{ep_count} episodes"),
+        ("artifacts", f"{art_count} artifacts"),
+    ]
+    while True:
+        choice = await pick_item(options, title=ctx.title)
+        match choice:
+            case "detail":
+                await _show_detail(print_context_detail, ctx, loaded)
+            case "episodes":
+                await _episodes_view(loaded.episodes, memory)
+            case "artifacts":
+                await _artifacts_view(loaded.artifacts, memory)
+            case _:
+                return
+
+
+async def browse_artifacts(memory: ContextMemoryManager, ctx_id: str) -> None:
+    """Interactive artifact browser for /artifacts."""
+    artifacts = await memory._storage.list_artifacts_for_context(ctx_id)
+    if not artifacts:
+        print_info("No artifacts in current context.")
+        return
+    await _artifacts_view(list(artifacts), memory)
+
+
+async def _artifacts_view(artifacts: list, memory: ContextMemoryManager) -> None:
+    """Artifact list -> scrollable detail."""
+    if not artifacts:
+        print_info("No artifacts.")
+        return
+    items = [
+        (art.id, f"{art.title}  ({art.type}, v{art.current_version})")
+        for art in artifacts
+    ]
+    while True:
+        chosen = await pick_item(items, title="Artifacts")
+        if not chosen:
+            return
+        art = await memory._storage.get_artifact(chosen)
+        if art:
+            await _show_detail(print_artifact_detail, art)
+
+
+async def browse_episodes(memory: ContextMemoryManager, ctx_id: str) -> None:
+    """Interactive episode browser for /episodes."""
+    episodes = await memory._storage.list_episodes(ctx_id)
+    if not episodes:
+        print_info("No episodes in current context.")
+        return
+    await _episodes_view(list(episodes), memory)
+
+
+async def _episodes_view(episodes: list, memory: ContextMemoryManager) -> None:
+    """Episode list -> scrollable detail."""
+    if not episodes:
+        print_info("No episodes.")
+        return
+    items = [
+        (ep.id, f"{ep.summary[:60]}  {ep.time_start:%m-%d %H:%M}")
+        for ep in episodes
+    ]
+    while True:
+        chosen = await pick_item(items, title="Episodes")
+        if not chosen:
+            return
+        ep = await memory._storage.get_episode(chosen)
+        if ep:
+            messages = await memory._storage.list_messages(ep.id)
+            await _show_detail(print_episode_detail, ep, messages)