iac-code 0.1.0__py3-none-any.whl

iac_code/ui/suggestions/token_extractor.py

@@ -0,0 +1,77 @@
+"""Token extractor for suggestion triggers."""
+
+from __future__ import annotations
+
+import re
+
+from iac_code.ui.suggestions.types import CompletionToken
+
+# Characters that can form part of a token
+_TOKEN_CHARS = re.compile(r"[\w._\-/\\~@#!]")
+
+
+def _is_token_char(ch: str) -> bool:
+    return bool(_TOKEN_CHARS.match(ch))
+
+
+class TokenExtractor:
+    """Extracts completion tokens from input text based on cursor position."""
+
+    def extract(self, text: str, cursor_pos: int) -> CompletionToken | None:
+        """Walk backwards from cursor_pos to find a completion token.
+
+        Returns a CompletionToken if a valid trigger is found, else None.
+        """
+        if not text or cursor_pos == 0:
+            return None
+
+        # Clamp cursor_pos to valid range
+        end = min(cursor_pos, len(text))
+
+        # Walk backwards to find start of token
+        token_start = end
+        while token_start > 0 and _is_token_char(text[token_start - 1]):
+            token_start -= 1
+
+        if token_start == end:
+            # No token characters before cursor
+            return None
+
+        token_text = text[token_start:end]
+
+        if not token_text:
+            return None
+
+        first_char = token_text[0]
+
+        if first_char == "/":
+            # "/" trigger: only valid at line start or after whitespace
+            if token_start == 0 or text[token_start - 1] in (" ", "\t", "\n"):
+                return CompletionToken(
+                    text=token_text,
+                    start=token_start,
+                    end=end,
+                    trigger="/",
+                )
+            return None
+
+        if first_char == "@":
+            return CompletionToken(
+                text=token_text,
+                start=token_start,
+                end=end,
+                trigger="@",
+            )
+
+        if first_char == "!":
+            # "!" trigger: only valid at line start
+            if token_start == 0:
+                return CompletionToken(
+                    text=token_text,
+                    start=token_start,
+                    end=end,
+                    trigger="!",
+                )
+            return None
+
+        return None

iac_code/ui/suggestions/types.py

@@ -0,0 +1,45 @@
+"""Suggestion system types."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class CompletionToken:
+    """A token extracted from user input that triggers suggestions."""
+
+    text: str  # e.g. "/mod" or "@src/u"
+    start: int  # start position in input
+    end: int  # end position in input
+    trigger: str  # "/" | "@" | "!"
+
+
+@dataclass(slots=True)
+class SuggestionItem:
+    """A single suggestion shown in the overlay."""
+
+    id: str  # e.g. "cmd:model", "file:src/ui/input.py"
+    display_text: str
+    completion: str  # full text after completion
+    description: str
+    icon: str  # "/" command, "+" file, "◇" directory, "↑" history
+    source: str  # "command" | "file" | "directory" | "shell"
+    score: float
+    arg_hint: str | None = None  # inline ghost-text hint shown after the full command
+
+
+class SuggestionProvider(ABC):
+    """Base class for suggestion providers."""
+
+    @property
+    @abstractmethod
+    def trigger(self) -> str:
+        """The trigger character(s) for this provider."""
+        ...
+
+    @abstractmethod
+    def provide(self, token: CompletionToken) -> list[SuggestionItem]:
+        """Return suggestions for the given token."""
+        ...

iac_code/ui/transcript_view.py

@@ -0,0 +1,199 @@
+"""Alternate-screen transcript viewer for Ctrl+O.
+
+Renders the whole conversation with all tool calls expanded (sub-agent
+children fully listed, subagent prompts shown) while keeping tool *results*
+compact — no full file dumps. Ctrl+O enters, Ctrl+O/Esc/Ctrl+C exits, no
+scrolling. If the content overflows the viewport, the oldest rows are
+dropped first.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from rich.text import Text
+
+from iac_code.i18n import _
+from iac_code.ui.core.key_event import KeyEvent
+from iac_code.ui.core.raw_input import RawInputCapture
+from iac_code.ui.core.screen import ScreenManager
+
+if TYPE_CHECKING:
+    from iac_code.ui.renderer import Renderer, _Segment, _ToolCallRecord
+
+
+class TranscriptView:
+    """Modal transcript view rendered in the alternate screen buffer."""
+
+    def __init__(
+        self,
+        renderer: "Renderer",
+        current_segments: "list[_Segment] | None" = None,
+    ) -> None:
+        self._renderer = renderer
+        self._console = renderer.console
+        self._screen = ScreenManager(self._console)
+        # Segments of the in-progress turn that haven't been archived yet
+        # (typically present when Ctrl+O is pressed mid-stream).
+        self._current_segments = list(current_segments) if current_segments else []
+
+    # ── Public entry ──────────────────────────────────────────────────
+
+    def run(self) -> None:
+        lines = self._render_lines()
+        if not lines:
+            return
+
+        self._screen.enter_alternate_screen()
+        try:
+            with RawInputCapture() as cap:
+                self._draw(lines)
+                while True:
+                    event = cap.read_key(timeout=None)
+                    if event is None:
+                        continue
+                    if self._should_exit(event):
+                        break
+        finally:
+            self._screen.leave_alternate_screen()
+
+    # ── Rendering ─────────────────────────────────────────────────────
+
+    def _render_lines(self) -> list[str]:
+        """Render every turn and return a list of terminal rows."""
+        r = self._renderer
+        with self._console.capture() as cap:
+            first = True
+            for turn in r._message_history:
+                if not first:
+                    self._console.print()
+                first = False
+                if turn.role == "user":
+                    line = Text()
+                    line.append("❯ ", style="bold cyan")
+                    line.append(turn.text)
+                    self._console.print(line)
+                else:
+                    self._render_assistant_turn(turn.segments)
+
+            # Un-archived live segments from the currently streaming turn.
+            if self._current_segments:
+                # Only emit a separator if there's prior history AND the
+                # last history turn wasn't already an assistant turn being
+                # extended (we'd end up double-spacing otherwise).
+                if not first:
+                    last = r._message_history[-1] if r._message_history else None
+                    if last is None or last.role == "user":
+                        self._console.print()
+                self._render_assistant_turn(self._current_segments)
+
+        raw = cap.get()
+        lines = raw.split("\n")
+        if lines and lines[-1] == "":
+            lines.pop()
+        return lines
+
+    def _render_assistant_turn(self, segments: "list[_Segment]") -> None:
+        r = self._renderer
+        has_content = False
+        text_flushed = False
+        for seg in segments:
+            if seg.kind == "text" and seg.text:
+                if has_content:
+                    self._console.print()
+                for part in r._render_text_block(seg.text, continuation=text_flushed):
+                    self._console.print(part)
+                text_flushed = True
+                has_content = True
+            elif seg.kind == "tool" and seg.tool:
+                if has_content:
+                    self._console.print()
+                self._render_tool(seg.tool)
+                has_content = True
+                text_flushed = False
+
+    def _render_tool(self, rec: "_ToolCallRecord") -> None:
+        """Print one tool call: verbose header (all children), compact result.
+
+        For agent-style tools the sub-agent prompt is inserted between the
+        tool-name line and the child-tool tree so the reader sees *what was
+        asked* before *what ran*.
+        """
+        r = self._renderer
+        # Header with verbose=True so every sub-agent child is listed (not
+        # capped at 3) and tool-use detail is fully shown.
+        saved = r._verbose
+        r._verbose = True
+        try:
+            header = r._render_tool_header(rec)
+        finally:
+            r._verbose = saved
+
+        # _render_tool_header returns a single Text with embedded newlines —
+        # first line is "● Tool(detail)", the rest are child-tool rows.
+        # Split so we can slide the prompt block in between.
+        header_lines = header.split("\n")
+        if header_lines:
+            self._console.print(header_lines[0])
+        self._render_subagent_prompt(rec)
+        for line in header_lines[1:]:
+            self._console.print(line)
+
+        # Result stays compact so we never dump full file contents.
+        result_line = r._render_tool_result(rec)
+        if result_line:
+            self._console.print(result_line)
+
+    def _render_subagent_prompt(self, rec: "_ToolCallRecord") -> None:
+        """For agent-style tools, print the prompt handed to the subagent."""
+        prompt = ""
+        if isinstance(rec.tool_input, dict):
+            raw = rec.tool_input.get("prompt")
+            if isinstance(raw, str):
+                prompt = raw.strip()
+        if not prompt:
+            return
+        label = Text()
+        label.append("  ⎿  ", style="dim")
+        label.append(_("Prompt:"), style="bold dim")
+        self._console.print(label)
+        for raw_line in prompt.splitlines() or [""]:
+            row = Text("     ", style="dim")
+            row.append(raw_line, style="dim")
+            self._console.print(row)
+
+    # ── Drawing ───────────────────────────────────────────────────────
+
+    def _draw(self, lines: list[str]) -> None:
+        _cols, rows = self._screen.get_size()
+        # Last row is the footer; leave one blank row above it as a spacer.
+        content_rows = max(1, rows - 2)
+        visible = lines[-content_rows:] if len(lines) > content_rows else lines
+
+        out = self._console.file
+        out.write("\x1b[H\x1b[2J")
+        for line in visible:
+            out.write(line)
+            out.write("\r\n")
+        for _i in range(content_rows - len(visible)):
+            out.write("\r\n")
+        # Spacer row before the footer.
+        out.write("\r\n")
+        out.write(self._footer(rows))
+        out.flush()
+
+    def _footer(self, rows: int) -> str:
+        hint = _("Showing transcript · ctrl+o to toggle")
+        # `\x1b[K` clears the rest of the row so no left-over characters
+        # remain after the hint (simpler + CJK-safe than padding with spaces,
+        # which len() measures wrong for wide glyphs).
+        return f"\x1b[{rows};1H\x1b[2K\x1b[2m{hint}\x1b[0m"
+
+    # ── Input ─────────────────────────────────────────────────────────
+
+    def _should_exit(self, event: KeyEvent) -> bool:
+        if event.ctrl and event.key in ("o", "c"):
+            return True
+        if event.key == "escape":
+            return True
+        return False

iac_code/utils/background_housekeeping.py

@@ -0,0 +1,53 @@
+"""Background housekeeping — delayed cleanup of old tool result files."""
+
+from __future__ import annotations
+
+import threading
+import time
+
+from loguru import logger
+
+from iac_code.utils.cleanup import cleanup_old_session_files
+
+# Delay before running cleanup after session starts (seconds).
+DELAY_SECONDS = 10 * 60  # 10 minutes
+
+_BASE_DIR = None
+
+
+def _get_default_base_dir() -> str:
+    from iac_code.config import get_config_dir
+
+    return _BASE_DIR or str(get_config_dir() / "tool-results")
+
+
+def _run_cleanup(base_dir: str, delay_seconds: float) -> None:
+    time.sleep(delay_seconds)
+    try:
+        result = cleanup_old_session_files(base_dir)
+        if result["deleted"] > 0:
+            logger.debug(
+                "Background cleanup: deleted {} expired tool result file(s)",
+                result["deleted"],
+            )
+    except Exception:
+        logger.opt(exception=True).debug("Background cleanup failed")
+
+
+def start_background_housekeeping(
+    base_dir: str | None = None,
+    delay_seconds: float = DELAY_SECONDS,
+) -> threading.Thread:
+    """Start a daemon thread that cleans up old tool result files after a delay.
+
+    Returns the thread so callers can join() in tests.
+    """
+    target_dir = base_dir or _get_default_base_dir()
+    thread = threading.Thread(
+        target=_run_cleanup,
+        args=(target_dir, delay_seconds),
+        daemon=True,
+        name="iac-code-housekeeping",
+    )
+    thread.start()
+    return thread

iac_code/utils/cleanup.py

@@ -0,0 +1,68 @@
+"""Clean up old tool result files from previous sessions."""
+
+from __future__ import annotations
+
+import os
+import time
+
+DEFAULT_CLEANUP_PERIOD_DAYS = 30
+
+
+def cleanup_old_session_files(
+    base_dir: str,
+    max_age_days: int = DEFAULT_CLEANUP_PERIOD_DAYS,
+) -> dict[str, int]:
+    """Delete tool result files older than *max_age_days* under *base_dir*.
+
+    Directory layout expected::
+
+        base_dir/
+            <session_id>/
+                <tool_use_id>.txt
+                ...
+
+    Returns a dict with ``deleted`` and ``errors`` counts.
+    """
+    result: dict[str, int] = {"deleted": 0, "errors": 0}
+    cutoff = time.time() - max_age_days * 86400
+
+    try:
+        session_names = os.listdir(base_dir)
+    except FileNotFoundError:
+        return result
+
+    for session_name in session_names:
+        session_dir = os.path.join(base_dir, session_name)
+        if not os.path.isdir(session_dir):
+            continue
+
+        try:
+            filenames = os.listdir(session_dir)
+        except OSError:
+            result["errors"] += 1
+            continue
+
+        for filename in filenames:
+            file_path = os.path.join(session_dir, filename)
+            if not os.path.isfile(file_path):
+                continue
+            try:
+                if os.stat(file_path).st_mtime < cutoff:
+                    os.remove(file_path)
+                    result["deleted"] += 1
+            except OSError:
+                result["errors"] += 1
+
+        # Remove empty session directory
+        try:
+            os.rmdir(session_dir)
+        except OSError:
+            pass  # not empty or already removed
+
+    # Remove base_dir if empty
+    try:
+        os.rmdir(base_dir)
+    except OSError:
+        pass
+
+    return result

iac_code/utils/json_utils.py

@@ -0,0 +1,60 @@
+"""Safe JSON parsing utilities.
+
+Design:
+- safe_parse_json() never raises exceptions
+- Returns None on failure or empty/None input (caller decides fallback)
+- Logs debug when non-empty input fails to parse (callers handle warning)
+- parse_concatenated_json() handles model edge case where multiple JSON
+  objects are concatenated (e.g. '{"a":1}{"b":2}'), indicating the model
+  intended parallel tool calls with different parameters.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from loguru import logger
+
+
+def safe_parse_json(raw: str | None) -> Any | None:
+    """Parse a JSON string safely, never raises.
+
+    Returns:
+        Parsed value on success, None on failure or empty/None input.
+    """
+    if not raw:
+        return None
+    try:
+        return json.loads(raw)
+    except (json.JSONDecodeError, ValueError):
+        logger.error("Failed to parse JSON, raw=%s", raw[:200])
+        return None
+
+
+def parse_concatenated_json(raw: str) -> list[dict[str, Any]]:
+    """Parse concatenated JSON objects like '{"a":1}{"b":2}' into a list.
+
+    Uses json.JSONDecoder.raw_decode to read one object at a time.
+
+    Returns:
+        List of parsed dicts. Empty list if nothing could be parsed.
+    """
+    decoder = json.JSONDecoder()
+    results: list[dict[str, Any]] = []
+    pos = 0
+    length = len(raw)
+    while pos < length:
+        # Skip whitespace
+        while pos < length and raw[pos] in " \t\n\r":
+            pos += 1
+        if pos >= length:
+            break
+        try:
+            obj, end_pos = decoder.raw_decode(raw, pos)
+            if isinstance(obj, dict):
+                results.append(obj)
+            pos = end_pos
+        except json.JSONDecodeError:
+            break
+    return results

iac_code/utils/log.py

@@ -0,0 +1,150 @@
+"""Logging setup for iac-code using loguru."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from loguru import logger
+
+from iac_code.config import get_config_dir
+
+_LOG_FORMAT = "{time:YYYY-MM-DDTHH:mm:ss.SSS} [{level:<5}] {name}:{function}:{line} - {message}"
+
+_startup_handler_id: int | None = None
+_runtime_debug_handler_ids: list[int] = []
+_debug_enabled: bool = False
+_current_log_file: Path | None = None
+
+
+class _StdlibToLoguruHandler(logging.Handler):
+    """Route stdlib logging records to loguru so OTel SDK logs are visible."""
+
+    _LEVEL_MAP = {
+        logging.DEBUG: "DEBUG",
+        logging.INFO: "INFO",
+        logging.WARNING: "WARNING",
+        logging.ERROR: "ERROR",
+        logging.CRITICAL: "CRITICAL",
+    }
+
+    def emit(self, record: logging.LogRecord) -> None:
+        level = self._LEVEL_MAP.get(record.levelno, "INFO")
+        logger.opt(depth=6, exception=record.exc_info).log(level, record.getMessage())
+
+
+def setup_logging(
+    session_id: str,
+    debug: bool = False,
+) -> None:
+    """Configure loguru for the application.
+
+    Args:
+        session_id: Current session ID, used in log filenames.
+        debug: Enable debug file logging.
+    """
+    global _startup_handler_id, _runtime_debug_handler_ids, _debug_enabled, _current_log_file
+
+    logger.remove()
+    _runtime_debug_handler_ids = []
+
+    log_dir = get_config_dir() / "logs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    log_file = log_dir / f"{session_id}.log"
+    level = "DEBUG" if debug else "INFO"
+
+    _startup_handler_id = logger.add(
+        str(log_file),
+        level=level,
+        format=_LOG_FORMAT,
+        encoding="utf-8",
+    )
+    _debug_enabled = debug
+    _current_log_file = log_file
+
+    latest = log_dir / "latest.log"
+    latest.unlink(missing_ok=True)
+    latest.symlink_to(log_file.name)
+
+    _install_stdlib_bridge()
+
+
+def _install_stdlib_bridge() -> None:
+    """Install the stdlib → loguru bridge on key namespaces."""
+    handler = _StdlibToLoguruHandler()
+    for name in ("opentelemetry", "iac_code"):
+        stdlib_logger = logging.getLogger(name)
+        if not any(isinstance(h, _StdlibToLoguruHandler) for h in stdlib_logger.handlers):
+            stdlib_logger.addHandler(handler)
+            stdlib_logger.setLevel(logging.DEBUG)
+
+
+def enable_debug_at_runtime(session_id: str) -> Path:
+    """Enable debug logging mid-session (for /debug command).
+
+    Returns:
+        Path to the log file.
+    """
+    global _debug_enabled, _current_log_file
+
+    log_dir = get_config_dir() / "logs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    log_file = log_dir / f"{session_id}.log"
+    _current_log_file = log_file
+
+    if _debug_enabled:
+        return log_file
+
+    handler_id = logger.add(
+        str(log_file),
+        level="DEBUG",
+        format=_LOG_FORMAT,
+        encoding="utf-8",
+    )
+    _runtime_debug_handler_ids.append(handler_id)
+    _debug_enabled = True
+
+    latest = log_dir / "latest.log"
+    latest.unlink(missing_ok=True)
+    latest.symlink_to(log_file.name)
+
+    return log_file
+
+
+def disable_debug_at_runtime() -> None:
+    """Disable debug logging mid-session (for /debug off)."""
+    global _debug_enabled, _startup_handler_id, _runtime_debug_handler_ids
+
+    if not _debug_enabled:
+        return
+
+    for hid in _runtime_debug_handler_ids:
+        try:
+            logger.remove(hid)
+        except ValueError:
+            pass
+    _runtime_debug_handler_ids = []
+
+    if _startup_handler_id is not None and _current_log_file is not None:
+        try:
+            logger.remove(_startup_handler_id)
+        except ValueError:
+            pass
+        _startup_handler_id = logger.add(
+            str(_current_log_file),
+            level="INFO",
+            format=_LOG_FORMAT,
+            encoding="utf-8",
+        )
+
+    _debug_enabled = False
+
+
+def is_debug_enabled() -> bool:
+    """Return whether debug-level logging is currently active."""
+    return _debug_enabled
+
+
+def current_log_file() -> Path | None:
+    """Return the current session log file path, if setup_logging has been called."""
+    return _current_log_file