superqode 0.1.5__py3-none-any.whl

superqode/history.py

@@ -0,0 +1,279 @@
+"""
+SuperQode History Manager - Command & Session History
+
+Manages command history with:
+- JSON-based persistent storage
+- Async file operations
+- Search and filtering
+- Session tracking
+"""
+
+from __future__ import annotations
+
+import json
+import asyncio
+from dataclasses import dataclass, field, asdict
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional, Dict, Any
+
+
+@dataclass
+class HistoryEntry:
+    """A single history entry."""
+
+    input: str
+    timestamp: float
+    session_id: Optional[str] = None
+    mode: Optional[str] = None
+    agent: Optional[str] = None
+    success: bool = True
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class SessionInfo:
+    """Information about a session."""
+
+    session_id: str
+    started_at: datetime
+    ended_at: Optional[datetime] = None
+    mode: Optional[str] = None
+    agent: Optional[str] = None
+    command_count: int = 0
+
+
+class HistoryManager:
+    """Manages command history with persistence."""
+
+    def __init__(self, history_file: Optional[Path] = None):
+        self.history_file = history_file or Path.home() / ".superqode" / "history.jsonl"
+        self._entries: List[HistoryEntry] = []
+        self._loaded = False
+        self._current_session: Optional[str] = None
+        self._position = 0  # For navigation
+
+    async def load(self) -> bool:
+        """Load history from file."""
+        if self._loaded:
+            return True
+
+        def _read_history() -> List[HistoryEntry]:
+            entries = []
+            try:
+                self.history_file.parent.mkdir(parents=True, exist_ok=True)
+                self.history_file.touch(exist_ok=True)
+
+                with self.history_file.open("r") as f:
+                    for line in f:
+                        line = line.strip()
+                        if line:
+                            try:
+                                data = json.loads(line)
+                                entries.append(HistoryEntry(**data))
+                            except (json.JSONDecodeError, TypeError):
+                                continue
+            except Exception:
+                pass
+            return entries
+
+        self._entries = await asyncio.to_thread(_read_history)
+        self._loaded = True
+        self._position = len(self._entries)
+        return True
+
+    async def append(
+        self,
+        input_text: str,
+        mode: Optional[str] = None,
+        agent: Optional[str] = None,
+        success: bool = True,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> HistoryEntry:
+        """Append a new entry to history."""
+        if not input_text.strip():
+            return None
+
+        entry = HistoryEntry(
+            input=input_text,
+            timestamp=datetime.now().timestamp(),
+            session_id=self._current_session,
+            mode=mode,
+            agent=agent,
+            success=success,
+            metadata=metadata or {},
+        )
+
+        self._entries.append(entry)
+        self._position = len(self._entries)
+
+        # Write to file
+        def _write_entry():
+            try:
+                with self.history_file.open("a") as f:
+                    f.write(json.dumps(asdict(entry)) + "\n")
+            except Exception:
+                pass
+
+        await asyncio.to_thread(_write_entry)
+        return entry
+
+    def append_sync(
+        self,
+        input_text: str,
+        mode: Optional[str] = None,
+        agent: Optional[str] = None,
+        success: bool = True,
+    ) -> Optional[HistoryEntry]:
+        """Synchronous version of append."""
+        if not input_text.strip():
+            return None
+
+        entry = HistoryEntry(
+            input=input_text,
+            timestamp=datetime.now().timestamp(),
+            session_id=self._current_session,
+            mode=mode,
+            agent=agent,
+            success=success,
+        )
+
+        self._entries.append(entry)
+        self._position = len(self._entries)
+
+        try:
+            self.history_file.parent.mkdir(parents=True, exist_ok=True)
+            with self.history_file.open("a") as f:
+                f.write(json.dumps(asdict(entry)) + "\n")
+        except Exception:
+            pass
+
+        return entry
+
+    def get_previous(self) -> Optional[str]:
+        """Get previous history entry (for up arrow)."""
+        if not self._entries or self._position <= 0:
+            return None
+
+        self._position -= 1
+        return self._entries[self._position].input
+
+    def get_next(self) -> Optional[str]:
+        """Get next history entry (for down arrow)."""
+        if self._position >= len(self._entries) - 1:
+            self._position = len(self._entries)
+            return ""
+
+        self._position += 1
+        return self._entries[self._position].input
+
+    def reset_position(self) -> None:
+        """Reset navigation position to end."""
+        self._position = len(self._entries)
+
+    def search(self, query: str, limit: int = 20) -> List[HistoryEntry]:
+        """Search history entries."""
+        query_lower = query.lower()
+        results = []
+
+        for entry in reversed(self._entries):
+            if query_lower in entry.input.lower():
+                results.append(entry)
+                if len(results) >= limit:
+                    break
+
+        return results
+
+    def get_recent(self, count: int = 20) -> List[HistoryEntry]:
+        """Get most recent entries."""
+        return list(reversed(self._entries[-count:]))
+
+    def get_by_mode(self, mode: str, limit: int = 20) -> List[HistoryEntry]:
+        """Get entries for a specific mode."""
+        results = []
+        for entry in reversed(self._entries):
+            if entry.mode == mode:
+                results.append(entry)
+                if len(results) >= limit:
+                    break
+        return results
+
+    def get_by_agent(self, agent: str, limit: int = 20) -> List[HistoryEntry]:
+        """Get entries for a specific agent."""
+        results = []
+        for entry in reversed(self._entries):
+            if entry.agent == agent:
+                results.append(entry)
+                if len(results) >= limit:
+                    break
+        return results
+
+    def clear(self) -> None:
+        """Clear all history."""
+        self._entries.clear()
+        self._position = 0
+        try:
+            self.history_file.unlink(missing_ok=True)
+        except Exception:
+            pass
+
+    def set_session(self, session_id: str) -> None:
+        """Set the current session ID."""
+        self._current_session = session_id
+
+    @property
+    def size(self) -> int:
+        """Get the number of history entries."""
+        return len(self._entries)
+
+    @property
+    def entries(self) -> List[HistoryEntry]:
+        """Get all entries."""
+        return self._entries.copy()
+
+
+def render_history(
+    entries: List[HistoryEntry], console, limit: int = 20, show_metadata: bool = False
+) -> None:
+    """Render history entries."""
+    from rich.text import Text
+    from rich.panel import Panel
+    from rich.box import ROUNDED
+
+    if not entries:
+        console.print("  [dim]No history[/dim]")
+        return
+
+    header = Text()
+    header.append(" 📜 ", style="bold")
+    header.append("Command History", style="bold white")
+    header.append(f" ({len(entries)} entries)", style="dim")
+
+    console.print(Panel(header, border_style="#a855f7", box=ROUNDED, padding=(0, 1)))
+
+    for i, entry in enumerate(entries[:limit]):
+        line = Text()
+
+        # Timestamp
+        dt = datetime.fromtimestamp(entry.timestamp)
+        time_str = dt.strftime("%H:%M:%S")
+        line.append(f"  {time_str} ", style="dim")
+
+        # Mode/Agent indicator
+        if entry.agent:
+            line.append(f"[{entry.agent}] ", style="bold cyan")
+        elif entry.mode:
+            line.append(f"[{entry.mode}] ", style="bold green")
+
+        # Success indicator
+        if not entry.success:
+            line.append("✗ ", style="red")
+
+        # Command
+        cmd = entry.input[:60] + "..." if len(entry.input) > 60 else entry.input
+        line.append(cmd, style="white")
+
+        console.print(line)
+
+    if len(entries) > limit:
+        console.print(f"  [dim]... and {len(entries) - limit} more[/dim]")

superqode/integrations/superopt_runner.py

@@ -0,0 +1,124 @@
+"""SuperOpt command-based runner for OSS."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from superopt import AgenticEnvironment, ExecutionTrace, SuperOpt
+from superopt.core.environment import PromptConfig, RetrievalConfig, ToolSchema
+
+from superqode.agent.system_prompts import SystemPromptLevel, get_system_prompt
+from superqode.config import load_config
+from superqode.tools.base import ToolRegistry
+
+
+def _pick_job_description(project_root: Path) -> str:
+    try:
+        config = load_config(project_root)
+    except Exception:
+        return "You are a QE agent."
+
+    qe_mode = config.team.modes.get("qe") if config.team else None
+    if qe_mode and qe_mode.roles:
+        for role in qe_mode.roles.values():
+            if role.enabled and role.job_description:
+                return role.job_description.strip()
+
+    if config.default and config.default.job_description:
+        return config.default.job_description.strip()
+
+    return "You are a QE agent."
+
+
+def _build_environment(project_root: Path) -> AgenticEnvironment:
+    system_prompt = get_system_prompt(
+        level=SystemPromptLevel.STANDARD,
+        working_directory=project_root,
+    )
+    job_description = _pick_job_description(project_root)
+
+    prompt_config = PromptConfig(
+        system_prompt=system_prompt,
+        instruction_policy=job_description,
+    )
+
+    registry = ToolRegistry.default()
+    tools: Dict[str, ToolSchema] = {}
+    for tool in registry.list():
+        tools[tool.name] = ToolSchema(
+            name=tool.name,
+            description=tool.description,
+            arguments=tool.parameters,
+        )
+
+    retrieval_config = RetrievalConfig()
+
+    return AgenticEnvironment(
+        prompts=prompt_config,
+        tools=tools,
+        retrieval=retrieval_config,
+        memory=[],
+    )
+
+
+def _build_trace(result: Dict[str, Any]) -> ExecutionTrace:
+    findings = result.get("findings", [])
+    critical = [f for f in findings if f.get("severity") == "critical"]
+    tests_failed = result.get("tests_failed", 0)
+    status = result.get("status", "")
+
+    success = status == "completed" and tests_failed == 0 and not critical
+    failure_message = result.get("verdict") if not success else None
+
+    trace = ExecutionTrace(
+        task_description=f"QE session {result.get('session_id', 'unknown')}",
+        success=success,
+        failure_message=failure_message,
+    )
+
+    if tests_failed:
+        trace.test_failures = [f"{tests_failed} test(s) failed"]
+
+    errors = result.get("errors", [])
+    if errors:
+        trace.runtime_exceptions = list(errors)
+
+    return trace
+
+
+def run_superopt(trace_path: Path, output_path: Path, project_root: Path) -> int:
+    try:
+        result = json.loads(trace_path.read_text())
+    except Exception as exc:
+        raise SystemExit(f"Failed to read trace: {exc}") from exc
+
+    environment = _build_environment(project_root)
+    trace = _build_trace(result)
+
+    optimizer = SuperOpt(environment=environment)
+    optimizer.step(trace)
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(json.dumps(optimizer.environment.to_dict(), indent=2))
+    return 0
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run SuperOpt optimization.")
+    parser.add_argument("--trace", required=True, help="Path to QE result JSON")
+    parser.add_argument("--out", required=True, help="Output path for environment JSON")
+    parser.add_argument("--project-root", default=".", help="Project root")
+    args = parser.parse_args()
+
+    trace_path = Path(args.trace).resolve()
+    output_path = Path(args.out).resolve()
+    project_root = Path(args.project_root).resolve()
+
+    raise SystemExit(run_superopt(trace_path, output_path, project_root))
+
+
+if __name__ == "__main__":
+    main()

superqode/logging/__init__.py

@@ -0,0 +1,49 @@
+"""
+SuperQode Unified Logging System.
+
+Provides consistent logging across all provider modes (ACP, BYOK, Local).
+"""
+
+from superqode.logging.unified_log import (
+    LogVerbosity,
+    LogConfig,
+    LogEntry,
+    LogKind,
+    LogSource,
+    UnifiedLogger,
+    LogSink,
+)
+from superqode.logging.formatter import UnifiedLogFormatter
+from superqode.logging.sinks import ConversationLogSink, BufferSink, CallbackSink
+from superqode.logging.adapters import (
+    BYOKAdapter,
+    LocalAdapter,
+    ACPAdapter,
+    create_adapter,
+)
+from superqode.logging.integration import TUILoggerManager, create_tui_logger
+
+__all__ = [
+    # Core
+    "LogVerbosity",
+    "LogConfig",
+    "LogEntry",
+    "LogKind",
+    "LogSource",
+    "UnifiedLogger",
+    "LogSink",
+    # Formatting
+    "UnifiedLogFormatter",
+    # Sinks
+    "ConversationLogSink",
+    "BufferSink",
+    "CallbackSink",
+    # Adapters
+    "BYOKAdapter",
+    "LocalAdapter",
+    "ACPAdapter",
+    "create_adapter",
+    # TUI Integration
+    "TUILoggerManager",
+    "create_tui_logger",
+]

superqode/logging/adapters.py

@@ -0,0 +1,219 @@
+"""
+Provider Adapters for SuperQode Unified Logging.
+
+These adapters bridge existing callback interfaces to the unified logging system.
+Each adapter converts provider-specific events into LogEntry objects.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Awaitable, Callable, Optional, TYPE_CHECKING
+import asyncio
+
+from superqode.logging.unified_log import LogEntry, LogSource, UnifiedLogger
+
+if TYPE_CHECKING:
+    from superqode.tools.base import ToolResult
+
+
+class BYOKAdapter:
+    """
+    Adapter for BYOK (LiteLLM Gateway) mode.
+
+    Bridges on_tool_call, on_tool_result, and on_thinking callbacks
+    to the unified logging system.
+    """
+
+    def __init__(self, logger: UnifiedLogger):
+        self.logger = logger
+        self._span_ids: dict[str, str] = {}  # tool_name -> span_id
+
+    def on_tool_call(self, name: str, args: dict) -> None:
+        """Handle tool call - emit to unified logger."""
+        span_id = self.logger.tool_call(name, args, source="byok")
+        self._span_ids[name] = span_id
+
+    def on_tool_result(self, name: str, result: Any) -> None:
+        """Handle tool result - emit to unified logger."""
+        from superqode.tools.base import ToolResult
+
+        span_id = self._span_ids.pop(name, None)
+
+        if isinstance(result, ToolResult):
+            success = result.success
+            output = str(result.output) if result.output else ""
+            if not success and result.error:
+                output = str(result.error)
+        else:
+            success = True
+            output = str(result) if result else ""
+
+        self.logger.tool_result(name, output, success, source="byok", span_id=span_id)
+
+    async def on_thinking_async(self, text: str) -> None:
+        """Handle thinking text - emit to unified logger."""
+        if text and text.strip():
+            self.logger.thinking(text, source="byok")
+
+    def on_thinking_sync(self, text: str) -> None:
+        """Synchronous thinking handler."""
+        if text and text.strip():
+            self.logger.thinking(text, source="byok")
+
+    def get_callbacks(self) -> dict[str, Callable]:
+        """Get callback functions for use with pure_mode."""
+        return {
+            "on_tool_call": self.on_tool_call,
+            "on_tool_result": self.on_tool_result,
+            "on_thinking": self.on_thinking_async,
+        }
+
+
+class LocalAdapter:
+    """
+    Adapter for Local models (Ollama, etc.).
+
+    Handles streaming responses with code block detection and formatting.
+    """
+
+    def __init__(self, logger: UnifiedLogger):
+        self.logger = logger
+        self._response_buffer = ""
+        self._in_code_block = False
+        self._code_language = ""
+        self._code_buffer = ""
+
+    def on_tool_call(self, name: str, args: dict) -> None:
+        """Handle tool call."""
+        self.logger.tool_call(name, args, source="local")
+
+    def on_tool_result(self, name: str, result: Any) -> None:
+        """Handle tool result."""
+        from superqode.tools.base import ToolResult
+
+        if isinstance(result, ToolResult):
+            self.logger.tool_result(
+                name,
+                str(result.output) if result.output else "",
+                result.success,
+                source="local",
+            )
+        else:
+            self.logger.tool_result(name, str(result), True, source="local")
+
+    async def on_thinking_async(self, text: str) -> None:
+        """Handle thinking text."""
+        if text and text.strip():
+            self.logger.thinking(text, source="local")
+
+    def on_response_chunk(self, text: str) -> None:
+        """Handle streaming response chunk with code detection."""
+        if not text:
+            return
+
+        self._response_buffer += text
+        self.logger.response_chunk(text, source="local")
+
+    def on_response_complete(self) -> str:
+        """Complete response and return full text."""
+        response = self._response_buffer
+        self._response_buffer = ""
+        self.logger.response_complete(source="local")
+        return response
+
+    def get_callbacks(self) -> dict[str, Callable]:
+        """Get callback functions."""
+        return {
+            "on_tool_call": self.on_tool_call,
+            "on_tool_result": self.on_tool_result,
+            "on_thinking": self.on_thinking_async,
+        }
+
+
+class ACPAdapter:
+    """
+    Adapter for ACP (Agent Client Protocol) mode.
+
+    Bridges ACP session updates to the unified logging system.
+    """
+
+    def __init__(self, logger: UnifiedLogger):
+        self.logger = logger
+        self._span_ids: dict[str, str] = {}  # tool_call_id -> span_id
+        self._message_buffer = ""
+
+    async def on_message(self, text: str) -> None:
+        """Handle agent message chunks."""
+        if text:
+            self._message_buffer += text
+            self.logger.response_chunk(text, source="acp", agent="Agent")
+
+    async def on_thinking(self, text: str) -> None:
+        """Handle agent thinking."""
+        if text and text.strip():
+            # ACP thinking often comes with prefixes like [agent], strip them
+            clean_text = text
+            if clean_text.startswith("[agent] "):
+                clean_text = clean_text[8:]
+            elif clean_text.startswith("["):
+                # Remove other prefixes like [startup error], [model switch error], etc.
+                bracket_end = clean_text.find("] ")
+                if bracket_end > 0:
+                    clean_text = clean_text[bracket_end + 2 :]
+
+            self.logger.thinking(clean_text, source="acp")
+
+    async def on_tool_call(self, tool_call: dict) -> None:
+        """Handle ACP tool call."""
+        title = tool_call.get("title", "tool")
+        raw_input = tool_call.get("rawInput", {})
+        tool_call_id = tool_call.get("toolCallId", "")
+
+        span_id = self.logger.tool_call(title, raw_input, source="acp")
+        if tool_call_id:
+            self._span_ids[tool_call_id] = span_id
+
+    async def on_tool_update(self, update: dict) -> None:
+        """Handle ACP tool update."""
+        status = update.get("status", "")
+        tool_call_id = update.get("toolCallId", "")
+        output = update.get("rawOutput") or update.get("output") or update.get("result")
+
+        span_id = self._span_ids.get(tool_call_id)
+        title = update.get("title", "tool")
+
+        if status in ("completed", "done", "success"):
+            self.logger.tool_result(
+                title, str(output) if output else "", True, source="acp", span_id=span_id
+            )
+        elif status in ("error", "failed"):
+            self.logger.tool_result(
+                title, str(output) if output else "failed", False, source="acp", span_id=span_id
+            )
+
+    def on_session_complete(self) -> str:
+        """Complete session and return full message."""
+        message = self._message_buffer
+        self._message_buffer = ""
+        self.logger.response_complete(source="acp", agent="Agent")
+        return message
+
+    def get_callbacks(self) -> dict[str, Callable]:
+        """Get callback functions for use with ACPClient."""
+        return {
+            "on_message": self.on_message,
+            "on_thinking": self.on_thinking,
+        }
+
+
+def create_adapter(
+    logger: UnifiedLogger,
+    source: LogSource,
+) -> BYOKAdapter | LocalAdapter | ACPAdapter:
+    """Create an adapter for the given source."""
+    if source == "acp":
+        return ACPAdapter(logger)
+    elif source == "local":
+        return LocalAdapter(logger)
+    else:
+        return BYOKAdapter(logger)