aria-code 4.1.3__py3-none-any.whl

apps/cli/session_jsonl.py

@@ -0,0 +1,207 @@
+"""JSONL-backed session persistence for Aria Code.
+
+Why JSONL instead of JSON?
+  • Append-per-turn — no need to rewrite the whole file on every message
+  • Crash-safe — partial writes leave previous turns intact
+  • Streamable — readers can tail -f a live session
+
+File layout:  ~/.arthera/sessions/<session_id>.jsonl
+Each line is one JSON object:
+  {"type": "meta",    "id": "...", "title": "...", "created_at": "..."}
+  {"type": "message", "role": "user",      "content": "...", "ts": "..."}
+  {"type": "message", "role": "assistant", "content": "...", "ts": "..."}
+  {"type": "meta",    "updated_at": "..."}   ← appended on each save
+
+Reading: scan all lines, reconstruct conversation from "message" entries.
+Last "meta" wins for title / timestamps.
+"""
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+_SESSIONS_DIR = Path.home() / ".arthera" / "sessions"
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _session_path(session_id: str) -> Path:
+    return _SESSIONS_DIR / f"{session_id}.jsonl"
+
+
+class JsonlSessionStore:
+    """Read/write JSONL session files."""
+
+    def __init__(self, sessions_dir: Optional[Path] = None) -> None:
+        self.root = sessions_dir or _SESSIONS_DIR
+        self.root.mkdir(parents=True, exist_ok=True)
+
+    def _path(self, session_id: str) -> Path:
+        return self.root / f"{session_id}.jsonl"
+
+    # ── Write ─────────────────────────────────────────────────────────────────
+
+    def init_session(self, session_id: str, title: str = "") -> None:
+        """Write the opening meta line. Call once at session start."""
+        p = self._path(session_id)
+        if p.exists():
+            return
+        line = json.dumps({
+            "type": "meta",
+            "id": session_id,
+            "title": title or "",
+            "created_at": _now(),
+        }, ensure_ascii=False)
+        p.write_text(line + "\n", encoding="utf-8")
+
+    def append_message(self, session_id: str, role: str, content: str) -> None:
+        """Append one message turn. Thread-safe for single-process use."""
+        p = self._path(session_id)
+        line = json.dumps({
+            "type": "message",
+            "role": role,
+            "content": content,
+            "ts": _now(),
+        }, ensure_ascii=False)
+        with p.open("a", encoding="utf-8") as f:
+            f.write(line + "\n")
+
+    def flush_meta(self, session_id: str, title: str = "", extra: Optional[dict] = None) -> None:
+        """Append an updated meta line (title, timestamps)."""
+        p = self._path(session_id)
+        meta: dict = {"type": "meta", "updated_at": _now()}
+        if title:
+            meta["title"] = title
+        if extra:
+            meta.update(extra)
+        with p.open("a", encoding="utf-8") as f:
+            f.write(json.dumps(meta, ensure_ascii=False) + "\n")
+
+    def save_conversation(
+        self,
+        session_id: str,
+        conversation: list[dict],
+        title: str = "",
+    ) -> None:
+        """Full rewrite — used when bulk-importing a JSON session into JSONL."""
+        p = self._path(session_id)
+        lines = []
+        lines.append(json.dumps({
+            "type": "meta",
+            "id": session_id,
+            "title": title or "",
+            "created_at": _now(),
+            "updated_at": _now(),
+        }, ensure_ascii=False))
+        for msg in conversation:
+            lines.append(json.dumps({
+                "type": "message",
+                "role": msg.get("role", "user"),
+                "content": str(msg.get("content", "")),
+                "ts": _now(),
+            }, ensure_ascii=False))
+        p.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+    # ── Read ──────────────────────────────────────────────────────────────────
+
+    def load_session(self, session_id: str) -> Optional[dict]:
+        """Load a session; returns None if not found."""
+        p = self._path(session_id)
+        if not p.exists():
+            return None
+
+        messages: list[dict] = []
+        meta: dict = {"id": session_id}
+
+        for raw in p.read_text(encoding="utf-8").splitlines():
+            raw = raw.strip()
+            if not raw:
+                continue
+            try:
+                obj = json.loads(raw)
+            except json.JSONDecodeError:
+                continue
+
+            t = obj.get("type")
+            if t == "meta":
+                meta.update({k: v for k, v in obj.items() if k != "type"})
+            elif t == "message":
+                messages.append({
+                    "role": obj.get("role", "user"),
+                    "content": obj.get("content", ""),
+                })
+
+        return {
+            "id": session_id,
+            "messages": messages,
+            "metadata": {
+                "title": meta.get("title", "Untitled"),
+                "created_at": meta.get("created_at", ""),
+                "updated_at": meta.get("updated_at", ""),
+            },
+        }
+
+    def list_sessions(self, limit: int = 20) -> list[dict]:
+        """Return recent sessions sorted by mtime, newest first."""
+        sessions = []
+        for p in sorted(
+            self.root.glob("*.jsonl"),
+            key=lambda x: x.stat().st_mtime,
+            reverse=True,
+        ):
+            session_id = p.stem
+            meta: dict = {}
+            msg_count = 0
+            try:
+                for raw in p.read_text(encoding="utf-8").splitlines():
+                    raw = raw.strip()
+                    if not raw:
+                        continue
+                    obj = json.loads(raw)
+                    if obj.get("type") == "meta":
+                        meta.update(obj)
+                    elif obj.get("type") == "message":
+                        msg_count += 1
+            except Exception:
+                continue
+
+            sessions.append({
+                "id": session_id,
+                "title": meta.get("title", "Untitled"),
+                "messages": msg_count,
+                "updated": meta.get("updated_at", ""),
+                "created": meta.get("created_at", ""),
+            })
+            if len(sessions) >= limit:
+                break
+
+        return sessions
+
+    def delete_session(self, session_id: str) -> bool:
+        p = self._path(session_id)
+        if p.exists():
+            p.unlink()
+            return True
+        return False
+
+    def search_sessions(self, keyword: str, limit: int = 10) -> list[dict]:
+        """Full-text search across all session JSONL files."""
+        kw = keyword.lower()
+        matches = []
+        for p in self.root.glob("*.jsonl"):
+            try:
+                text = p.read_text(encoding="utf-8")
+                if kw not in text.lower():
+                    continue
+                result = self.load_session(p.stem)
+                if result:
+                    matches.append(result)
+            except Exception:
+                continue
+            if len(matches) >= limit:
+                break
+        return matches

apps/cli/session_store.py

@@ -0,0 +1,112 @@
+"""JSON-backed session persistence for Aria Code."""
+
+from __future__ import annotations
+
+import os
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+from apps.cli.config_paths import resolve_config_dir
+
+
+class SessionManager:
+    """Manage chat sessions with local file persistence."""
+
+    def __init__(self, sessions_dir: Optional[Path] = None):
+        self.root = sessions_dir or (resolve_config_dir() / "sessions")
+        self.root.mkdir(parents=True, exist_ok=True)
+
+    def _path(self, session_id: str) -> Path:
+        return self.root / f"{session_id}.json"
+
+    def save_session(self, session_id: str, conversation: list, metadata: dict = None):
+        meta = dict(metadata or {})
+        if not meta.get("created_at"):
+            meta["created_at"] = datetime.now().isoformat()
+        for msg in conversation:
+            if msg.get("role") == "user":
+                meta.setdefault("title", str(msg.get("content", ""))[:60])
+                break
+        data = {
+            "id": session_id,
+            "messages": conversation,
+            "metadata": meta,
+            "updated_at": datetime.now().isoformat(),
+        }
+        path = self._path(session_id)
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+
+    def load_session(self, session_id: str) -> Optional[dict]:
+        path = self._path(session_id)
+        if path.exists():
+            with open(path, encoding="utf-8") as f:
+                return json.load(f)
+        return None
+
+    def list_sessions(self, limit: int = 20) -> list:
+        sessions = []
+        for path in sorted(self.root.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True):
+            try:
+                with open(path, encoding="utf-8") as f:
+                    data = json.load(f)
+                sessions.append({
+                    "id": data.get("id", path.stem),
+                    "title": data.get("metadata", {}).get("title", "Untitled"),
+                    "messages": len(data.get("messages", [])),
+                    "updated": data.get("updated_at", ""),
+                })
+            except Exception:
+                continue
+            if len(sessions) >= limit:
+                break
+        return sessions
+
+    def search_sessions(self, query: str, limit: int = 20) -> list:
+        """Full-text search through session message content."""
+        q = query.lower()
+        results = []
+        for path in sorted(self.root.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True):
+            try:
+                with open(path, encoding="utf-8") as f:
+                    data = json.load(f)
+                messages = data.get("messages", [])
+                hits = []
+                for msg in messages:
+                    content = msg.get("content", "")
+                    if isinstance(content, str):
+                        if q in content.lower():
+                            idx = content.lower().index(q)
+                            start = max(0, idx - 20)
+                            end = min(len(content), idx + len(q) + 80)
+                            hits.append(content[start:end])
+                    elif isinstance(content, list):
+                        for block in content:
+                            if isinstance(block, dict):
+                                text = block.get("text", "")
+                                if text and q in text.lower():
+                                    idx = text.lower().index(q)
+                                    start = max(0, idx - 20)
+                                    end = min(len(text), idx + len(q) + 80)
+                                    hits.append(text[start:end])
+                if hits:
+                    results.append({
+                        "id": data.get("id", path.stem),
+                        "title": data.get("metadata", {}).get("title", "Untitled"),
+                        "updated": data.get("updated_at", ""),
+                        "match_count": len(hits),
+                        "preview": hits[0],
+                    })
+            except Exception:
+                continue
+            if len(results) >= limit:
+                break
+        return sorted(results, key=lambda r: r["match_count"], reverse=True)
+
+    def delete_session(self, session_id: str) -> bool:
+        path = self._path(session_id)
+        if path.exists():
+            path.unlink()
+            return True
+        return False

apps/cli/todo_tracker.py

@@ -0,0 +1,190 @@
+"""Structured task tracking for the Aria agent loop (Claude Code TodoWrite parity).
+
+The model calls the ``update_todos`` tool with the full current task list each
+time progress changes. We keep the latest list in a module-global so the
+renderer (and any UI surface) can show a live checklist of multi-step work.
+
+Design notes
+------------
+* State is intentionally a process-global, mirroring how the screenshot tool
+  stashes a pending image. Tool handlers only receive ``params``; they have no
+  reference to the terminal, so a module global is the pragmatic channel.
+* The list is replaced wholesale on every call (not merged) so the model owns
+  the source of truth and we never drift out of sync with its plan.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+_VALID_STATUS = ("pending", "in_progress", "completed")
+
+# Latest task list the model published this turn.
+_ACTIVE_TODOS: List[Dict[str, str]] = []
+
+
+def get_active_todos() -> List[Dict[str, str]]:
+    """Return a copy of the current task list."""
+    return list(_ACTIVE_TODOS)
+
+
+def clear_todos() -> None:
+    """Reset the task list (call at the start of a new user turn)."""
+    _ACTIVE_TODOS.clear()
+
+
+def _normalize(todos: Any) -> List[Dict[str, str]]:
+    """Coerce model-supplied todos into a clean list of {content, status}."""
+    out: List[Dict[str, str]] = []
+    if not isinstance(todos, list):
+        return out
+    for item in todos:
+        if isinstance(item, str):
+            content, status = item, "pending"
+        elif isinstance(item, dict):
+            content = str(
+                item.get("content")
+                or item.get("task")
+                or item.get("title")
+                or item.get("step")
+                or ""
+            ).strip()
+            status = str(item.get("status", "pending")).strip().lower()
+        else:
+            continue
+        if not content:
+            continue
+        if status not in _VALID_STATUS:
+            # Accept a few common synonyms
+            status = {
+                "done": "completed", "complete": "completed", "finished": "completed",
+                "doing": "in_progress", "active": "in_progress", "wip": "in_progress",
+                "todo": "pending", "open": "pending", "not_started": "pending",
+            }.get(status, "pending")
+        out.append({"content": content, "status": status})
+    return out
+
+
+def update_todos(params: dict) -> dict:
+    """Tool handler: replace the active task list with the model's latest plan."""
+    todos = _normalize(params.get("todos", params.get("tasks", [])))
+    if not todos:
+        return {
+            "success": False,
+            "error": "update_todos 需要非空的 todos 数组，每项形如 "
+                     "{\"content\": \"步骤描述\", \"status\": \"pending|in_progress|completed\"}",
+        }
+
+    # At most one in_progress is the convention — demote extras to pending order
+    seen_in_progress = False
+    for t in todos:
+        if t["status"] == "in_progress":
+            if seen_in_progress:
+                t["status"] = "pending"
+            else:
+                seen_in_progress = True
+
+    _ACTIVE_TODOS.clear()
+    _ACTIVE_TODOS.extend(todos)
+
+    _render(todos)
+
+    done = sum(1 for t in todos if t["status"] == "completed")
+    total = len(todos)
+    return {
+        "success": True,
+        "data": {
+            "total": total,
+            "completed": done,
+            "in_progress": sum(1 for t in todos if t["status"] == "in_progress"),
+            "pending": sum(1 for t in todos if t["status"] == "pending"),
+            "todos": todos,
+        },
+        # Compact text the model reads back so it knows the tracked state
+        "summary": f"任务进度 {done}/{total} 已完成",
+    }
+
+
+def _render(todos: List[Dict[str, str]]) -> None:
+    """Print the task list as a checklist. Uses rich when available."""
+    try:
+        import aria_cli as _ac
+        console = getattr(_ac, "console", None)
+        has_rich = getattr(_ac, "HAS_RICH", False)
+    except Exception:
+        console, has_rich = None, False
+
+    _icons = {
+        "completed":   ("[green]✓[/green]", "✓"),
+        "in_progress": ("[yellow]▶[/yellow]", "▶"),
+        "pending":     ("[dim]○[/dim]", "○"),
+    }
+    done = sum(1 for t in todos if t["status"] == "completed")
+    total = len(todos)
+
+    if has_rich and console is not None:
+        from rich.panel import Panel
+        from rich.text import Text
+        body = Text()
+        for i, t in enumerate(todos):
+            icon_rich, _ = _icons.get(t["status"], _icons["pending"])
+            style = (
+                "green" if t["status"] == "completed"
+                else "bold yellow" if t["status"] == "in_progress"
+                else "dim"
+            )
+            line = Text.from_markup(f"{icon_rich} ")
+            content = t["content"]
+            if t["status"] == "completed":
+                line.append(content, style="dim strike")
+            else:
+                line.append(content, style=style)
+            body.append_text(line)
+            if i < len(todos) - 1:
+                body.append("\n")
+        console.print(Panel(
+            body,
+            title=f"[bold]任务清单[/bold]  [dim]{done}/{total}[/dim]",
+            border_style="cyan",
+            padding=(0, 1),
+        ))
+    else:
+        print(f"\n任务清单 ({done}/{total}):")
+        for t in todos:
+            _, icon_plain = _icons.get(t["status"], _icons["pending"])
+            print(f"  {icon_plain} {t['content']}")
+
+
+UPDATE_TODOS_SCHEMA = {
+    "type": "function",
+    "function": {
+        "name": "update_todos",
+        "description": (
+            "Track progress on a multi-step task as a live checklist. Call this when a task "
+            "has 3+ distinct steps: first to lay out the plan (all pending), then again each "
+            "time you start a step (mark it in_progress) or finish one (mark it completed). "
+            "Keep exactly one step in_progress at a time. Always send the FULL list every call."
+        ),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "todos": {
+                    "type": "array",
+                    "description": "The complete current task list (replaces the previous list).",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "content": {"type": "string", "description": "Short step description"},
+                            "status": {
+                                "type": "string",
+                                "enum": list(_VALID_STATUS),
+                                "description": "pending | in_progress | completed",
+                            },
+                        },
+                        "required": ["content", "status"],
+                    },
+                },
+            },
+            "required": ["todos"],
+        },
+    },
+}

apps/cli/tools/__init__.py

@@ -0,0 +1,40 @@
+"""apps/cli/tools — stateless tool implementations extracted from aria_cli.py."""
+from .file_tools import tool_read_file, tool_list_files, tool_search_code, tool_glob
+from .context import ToolContext
+from .system_tools import tool_run_command, tool_web_fetch, tool_github
+from .notebook_tools import (
+    tool_glob as tool_glob_nb,
+    tool_notebook_read,
+    tool_notebook_edit,
+)
+from .market_tools import (
+    tool_get_market_data,
+    tool_get_market_history,
+    tool_broker_query,
+    tool_broker_order,
+)
+from .write_tools import tool_write_file, tool_edit_file
+
+__all__ = [
+    "ToolContext",
+    # file tools (stateless)
+    "tool_read_file",
+    "tool_list_files",
+    "tool_search_code",
+    "tool_glob",
+    # write / edit tools (use lazy imports to avoid circular dep)
+    "tool_write_file",
+    "tool_edit_file",
+    # system tools
+    "tool_run_command",
+    "tool_web_fetch",
+    "tool_github",
+    # notebook tools
+    "tool_notebook_read",
+    "tool_notebook_edit",
+    # market / broker tools
+    "tool_get_market_data",
+    "tool_get_market_history",
+    "tool_broker_query",
+    "tool_broker_order",
+]

apps/cli/tools/context.py

@@ -0,0 +1,46 @@
+"""ToolContext — dependency bundle for tools that need write/display state."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from apps.cli.config_paths import resolve_config_dir
+
+if TYPE_CHECKING:
+    from rich.console import Console
+
+
+@dataclass
+class ToolContext:
+    """Passed to write-capable tools so they don't need aria_cli.py globals.
+
+    Instantiate once in ``ArtheraTerminal.__init__`` and share via reference:
+
+        self._tool_ctx = ToolContext(
+            console=console,
+            has_rich=HAS_RICH,
+            write_policy=_ACTIVE_WRITE_POLICY,
+            change_store=GLOBAL_CHANGE_STORE,
+            config_dir=CONFIG_DIR,
+            sessions_dir=SESSIONS_DIR,
+        )
+    """
+    console: "Console | None" = None
+    has_rich: bool = True
+    write_policy: list[str] = field(default_factory=lambda: ["desktop_only"])
+    change_store: Any = None   # GLOBAL_CHANGE_STORE
+    config_dir: Path = field(default_factory=resolve_config_dir)
+    sessions_dir: Path = field(default_factory=lambda: resolve_config_dir() / "sessions")
+
+    # ── helpers ──────────────────────────────────────────────────────
+    def print(self, *args, **kwargs) -> None:
+        if self.has_rich and self.console is not None:
+            self.console.print(*args, **kwargs)
+        else:
+            import builtins
+            builtins.print(*args)
+
+    @property
+    def policy(self) -> str:
+        return self.write_policy[0] if self.write_policy else "desktop_only"