iac-code 0.1.0__py3-none-any.whl

iac_code/cli/output_formats.py

@@ -0,0 +1,125 @@
+"""Output format writers for non-interactive (headless) mode.
+
+Each writer consumes StreamEvents and writes formatted output to a file-like stream.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import json
+import sys
+from enum import Enum
+from typing import IO, Any
+
+from iac_code.types.stream_events import (
+    ErrorEvent,
+    MessageEndEvent,
+    StreamEvent,
+    TextDeltaEvent,
+    ToolResultEvent,
+    ToolUseEndEvent,
+    ToolUseStartEvent,
+)
+
+
+class OutputFormat(str, Enum):
+    """Supported output formats for non-interactive mode."""
+
+    TEXT = "text"
+    JSON = "json"
+    STREAM_JSON = "stream-json"
+
+
+class TextWriter:
+    """Writes only assistant text content to the output stream.
+
+    Tool calls and other events are silently consumed.
+    """
+
+    def __init__(self, stream: IO[str] | None = None) -> None:
+        self._stream = stream or sys.stdout
+        self._has_output = False
+
+    def handle(self, event: StreamEvent) -> None:
+        if isinstance(event, TextDeltaEvent):
+            self._stream.write(event.text)
+            self._stream.flush()
+            self._has_output = True
+
+    def finalize(self) -> None:
+        if self._has_output:
+            self._stream.write("\n")
+            self._stream.flush()
+
+
+class JsonWriter:
+    """Collects all events and writes a single JSON object on finalize.
+
+    The output is a JSON object with keys: text, tool_uses, usage, and
+    optionally error. usage is null when no MessageEndEvent was seen.
+    """
+
+    def __init__(self, stream: IO[str] | None = None) -> None:
+        self._stream = stream or sys.stdout
+        self._text_chunks: list[str] = []
+        self._tool_uses: dict[str, dict[str, Any]] = {}
+        self._usage: dict[str, int] | None = None
+        self._error: str | None = None
+
+    def handle(self, event: StreamEvent) -> None:
+        if isinstance(event, TextDeltaEvent):
+            self._text_chunks.append(event.text)
+        elif isinstance(event, ToolUseStartEvent):
+            self._tool_uses.setdefault(event.tool_use_id, {})["name"] = event.name
+        elif isinstance(event, ToolUseEndEvent):
+            self._tool_uses.setdefault(event.tool_use_id, {})["input"] = event.input
+        elif isinstance(event, ToolResultEvent):
+            entry = self._tool_uses.setdefault(event.tool_use_id, {})
+            entry["result"] = event.result
+            entry["is_error"] = event.is_error
+        elif isinstance(event, MessageEndEvent):
+            self._usage = {
+                "input_tokens": event.usage.input_tokens,
+                "output_tokens": event.usage.output_tokens,
+            }
+        elif isinstance(event, ErrorEvent):
+            self._error = event.error
+
+    def finalize(self) -> None:
+        result: dict[str, Any] = {
+            "text": "".join(self._text_chunks),
+            "tool_uses": list(self._tool_uses.values()),
+            "usage": self._usage,
+        }
+        if self._error is not None:
+            result["error"] = self._error
+        self._stream.write(json.dumps(result, ensure_ascii=False))
+        self._stream.write("\n")
+        self._stream.flush()
+
+
+class StreamJsonWriter:
+    """Writes each event as a newline-delimited JSON (NDJSON) line immediately on handle."""
+
+    def __init__(self, stream: IO[str] | None = None) -> None:
+        self._stream = stream or sys.stdout
+
+    def handle(self, event: StreamEvent) -> None:
+        data = dataclasses.asdict(event)
+        self._stream.write(json.dumps(data, ensure_ascii=False, default=str))
+        self._stream.write("\n")
+        self._stream.flush()
+
+    def finalize(self) -> None:
+        pass
+
+
+def create_writer(fmt: OutputFormat, stream: IO[str] | None = None) -> TextWriter | JsonWriter | StreamJsonWriter:
+    """Create the appropriate writer for the given output format."""
+    if fmt == OutputFormat.TEXT:
+        return TextWriter(stream)
+    if fmt == OutputFormat.JSON:
+        return JsonWriter(stream)
+    if fmt == OutputFormat.STREAM_JSON:
+        return StreamJsonWriter(stream)
+    raise ValueError(f"Unknown output format: {fmt}")

iac_code/commands/__init__.py

@@ -0,0 +1,93 @@
+"""Command module"""
+
+from iac_code.commands.auth import auth_command
+from iac_code.commands.clear import clear_command
+from iac_code.commands.compact import compact_command
+from iac_code.commands.debug import debug_command
+from iac_code.commands.effort import effort_command
+from iac_code.commands.exit import exit_command
+from iac_code.commands.help import help_command
+from iac_code.commands.model import model_command
+from iac_code.commands.registry import Command, CommandRegistry, LocalCommand, PromptCommand
+from iac_code.commands.resume import resume_command
+from iac_code.i18n import _
+
+
+def create_default_registry() -> CommandRegistry:
+    """Create and register all default commands"""
+    registry = CommandRegistry()
+    registry.register(
+        LocalCommand(
+            name="help",
+            description=_("Show available commands"),
+            handler=help_command,
+            aliases=["?"],
+        )
+    )
+    registry.register(
+        LocalCommand(
+            name="clear",
+            description=_("Clear conversation history"),
+            handler=clear_command,
+        )
+    )
+    registry.register(
+        LocalCommand(
+            name="model",
+            description=_("Show or switch model"),
+            handler=model_command,
+            arg_names=["model_name"],
+        )
+    )
+    registry.register(
+        LocalCommand(
+            name="effort",
+            description=_("Show or switch thinking effort"),
+            handler=effort_command,
+            arg_names=["level"],
+        )
+    )
+    registry.register(
+        LocalCommand(
+            name="compact",
+            description=_("Compact conversation context"),
+            handler=compact_command,
+            progress_label=_("Compacting conversation"),
+        )
+    )
+    registry.register(
+        LocalCommand(
+            name="exit",
+            description=_("Exit the application"),
+            handler=exit_command,
+            aliases=["quit", "q"],
+        )
+    )
+    registry.register(
+        LocalCommand(
+            name="auth",
+            description=_("Authenticate with LLM provider"),
+            handler=auth_command,
+            aliases=["login"],
+        )
+    )
+    registry.register(
+        LocalCommand(
+            name="debug",
+            description=_("Toggle debug logging"),
+            handler=debug_command,
+            arg_hint="[on|off]",
+        )
+    )
+    registry.register(
+        LocalCommand(
+            name="resume",
+            description=_("Resume a previous session"),
+            handler=resume_command,
+            arg_hint=_("[conversation id or search term]"),
+        )
+    )
+    return registry
+
+
+__all__ = ["Command", "CommandRegistry", "LocalCommand", "PromptCommand", "create_default_registry"]