aria-code 0.52.0__py3-none-any.whl

aria_code/apps/cli/session_export.py

@@ -0,0 +1,120 @@
+"""Session export helpers for Aria Code."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from typing import Any, Optional, Sequence
+
+from aria_code.artifacts import artifact_summary as build_artifact_summary
+from aria_code.apps.cli.config_paths import config_snapshot
+from aria_code.packages.aria_core import build_session_diagnostic_bundle
+
+
+def _safe_title_from_conversation(conversation: Sequence[dict]) -> str:
+    for msg in conversation:
+        if msg.get("role") == "user":
+            return str(msg.get("content", ""))[:60]
+    return "Aria Code Session"
+
+
+def build_session_export_payload(
+    fmt: str,
+    conversation: Sequence[dict],
+    *,
+    session_id: str = "",
+    config: Optional[dict] = None,
+    paths: Optional[dict] = None,
+    trace: Any = None,
+    provider_health: Optional[list] = None,
+    doctor_report: Any = None,
+    mcp_status: Optional[list] = None,
+    context_health: Optional[dict] = None,
+) -> tuple[str, str, str]:
+    """Return (content, extension, suggested_filename_prefix)."""
+    fmt = (fmt or "json").lower().strip()
+
+    if fmt == "json":
+        content = json.dumps(list(conversation), indent=2, ensure_ascii=False)
+        return content, "json", "aria_code_chat"
+
+    if fmt == "csv":
+        lines = ["role,content"]
+        for msg in conversation:
+            escaped = str(msg.get("content", "")).replace('"', '""').replace("\n", " ")
+            lines.append(f'{msg.get("role", "user")},"{escaped}"')
+        return "\n".join(lines), "csv", "aria_code_chat"
+
+    if fmt == "md":
+        lines = [f"# Aria Code Chat Export — {datetime.now().strftime('%Y-%m-%d %H:%M')}\n"]
+        for msg in conversation:
+            prefix = "**You:**" if msg.get("role") == "user" else "**Aria:**"
+            lines.append(f"{prefix}\n{msg.get('content', '')}\n")
+        return "\n".join(lines), "md", "aria_code_chat"
+
+    if fmt == "sft":
+        pairs = []
+        conv = list(conversation)
+        i = 0
+        while i < len(conv) - 1:
+            if conv[i].get("role") == "user" and conv[i + 1].get("role") == "assistant":
+                user_text = str(conv[i].get("content", "")).strip()
+                assistant_text = str(conv[i + 1].get("content", "")).strip()
+                if len(user_text) > 10 and len(assistant_text) > 20 and not user_text.startswith("Tool results:"):
+                    pairs.append({
+                        "instruction": user_text,
+                        "input": "",
+                        "output": assistant_text,
+                        "source": "aria_cli_export",
+                        "timestamp": datetime.now().strftime("%Y-%m-%d"),
+                    })
+                i += 2
+            else:
+                i += 1
+        if not pairs:
+            raise ValueError("No user→assistant pairs to export")
+        return json.dumps(pairs, indent=2, ensure_ascii=False), "json", "aria_sft"
+
+    if fmt == "ipynb":
+        cells = [{
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [f"# Aria Code Chat Export — {datetime.now().strftime('%Y-%m-%d %H:%M')}\n\n", "*(This notebook contains the conversation history. Math formulas and LaTeX will render natively here.)*"]
+        }]
+        for msg in conversation:
+            if msg.get("role") not in ("user", "assistant"):
+                continue
+            prefix = "**You:**\n\n" if msg.get("role") == "user" else "**Aria:**\n\n"
+            cells.append({
+                "cell_type": "markdown",
+                "metadata": {},
+                "source": [prefix + str(msg.get("content", ""))]
+            })
+        
+        notebook = {
+            "cells": cells,
+            "metadata": {
+                "kernelspec": {"display_name": "Python 3", "language": "python", "name": "python3"},
+                "language_info": {"name": "python"}
+            },
+            "nbformat": 4,
+            "nbformat_minor": 4
+        }
+        return json.dumps(notebook, indent=2, ensure_ascii=False), "ipynb", "aria_code_chat"
+
+    if fmt == "bundle":
+        bundle = build_session_diagnostic_bundle(
+            session_id=session_id,
+            conversation=conversation,
+            config=config,
+            paths=paths or config_snapshot(),
+            trace=trace,
+            provider_health=provider_health,
+            artifact_summary=build_artifact_summary(),
+            doctor_report=doctor_report,
+            mcp_status=mcp_status,
+            context_health=context_health,
+        )
+        return json.dumps(bundle, indent=2, ensure_ascii=False), "json", "aria_bundle"
+
+    raise ValueError("Unsupported export format")

aria_code/apps/cli/session_jsonl.py

@@ -0,0 +1,208 @@
+"""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
+from aria_code.packages.aria_core.paths import aria_home
+
+_SESSIONS_DIR = aria_home() / "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

aria_code/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 aria_code.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