iac-code 0.1.0__py3-none-any.whl

iac_code/services/session_index.py

@@ -0,0 +1,281 @@
+"""Lite session metadata index for the /resume picker.
+
+Reads only the first and last 64 KiB of each session JSONL file and
+extracts metadata via string-search — never parses the whole file.
+This keeps the picker fast even when individual sessions grow into the
+megabytes.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+from iac_code.utils.project_paths import get_project_dir, get_projects_dir, sanitize_path
+
+LITE_READ_BUF_SIZE = 64 * 1024
+
+
+@dataclass
+class LiteMetadata:
+    cwd: str | None = None
+    git_branch: str | None = None
+    last_prompt: str | None = None
+    first_prompt: str | None = None
+
+
+@dataclass
+class SessionEntry:
+    session_id: str
+    cwd: str
+    project_name: str
+    git_branch: str | None
+    title: str
+    mtime: float
+    size_bytes: int
+
+
+# ---------------------------------------------------------------------------
+# Field extraction helpers (string-search; tolerant of truncated chunks)
+# ---------------------------------------------------------------------------
+
+
+def _decode_json_string(raw: str) -> str:
+    """Decode a JSON string body, tolerating partial input.
+
+    ``raw`` is the substring between the opening and closing ``"`` of a
+    JSON string. We round-trip via :func:`json.loads` to honour escapes,
+    falling back to a manual unescape if the string was truncated.
+    """
+    try:
+        return json.loads(f'"{raw}"')
+    except json.JSONDecodeError:
+        return raw.replace(r"\n", "\n").replace(r"\t", "\t").replace(r"\"", '"').replace(r"\\", "\\")
+
+
+def _scan_string_field(chunk: str, field: str, *, last: bool) -> str | None:
+    """Locate a JSON string field by name and return its decoded value."""
+    needle = f'"{field}":'
+    pos = chunk.rfind(needle) if last else chunk.find(needle)
+    if pos < 0:
+        return None
+    i = pos + len(needle)
+    n = len(chunk)
+    while i < n and chunk[i] in " \t":
+        i += 1
+    if i >= n or chunk[i] != '"':
+        return None
+    i += 1
+    start = i
+    while i < n:
+        ch = chunk[i]
+        if ch == "\\":
+            i += 2
+            continue
+        if ch == '"':
+            return _decode_json_string(chunk[start:i])
+        i += 1
+    # Unterminated (chunk truncated) — return what we have.
+    return _decode_json_string(chunk[start:])
+
+
+def extract_first_json_string_field(chunk: str, field: str) -> str | None:
+    return _scan_string_field(chunk, field, last=False)
+
+
+def extract_last_json_string_field(chunk: str, field: str) -> str | None:
+    return _scan_string_field(chunk, field, last=True)
+
+
+# ---------------------------------------------------------------------------
+# Head + tail file reader
+# ---------------------------------------------------------------------------
+
+
+def read_head_and_tail(path: Path, size: int | None = None) -> tuple[str, str]:
+    """Read the first and last :data:`LITE_READ_BUF_SIZE` bytes.
+
+    For files smaller than the buffer, ``head == tail`` and the whole
+    content is returned twice. Decoding is best-effort UTF-8 — partial
+    multibyte sequences at chunk edges are replaced.
+    """
+    actual_size = path.stat().st_size if size is None else size
+    with open(path, "rb") as f:
+        head_bytes = f.read(LITE_READ_BUF_SIZE)
+        if actual_size <= LITE_READ_BUF_SIZE:
+            tail_bytes = head_bytes
+        else:
+            f.seek(max(0, actual_size - LITE_READ_BUF_SIZE))
+            tail_bytes = f.read(LITE_READ_BUF_SIZE)
+    head = head_bytes.decode("utf-8", errors="replace")
+    tail = tail_bytes.decode("utf-8", errors="replace")
+    return head, tail
+
+
+# ---------------------------------------------------------------------------
+# First-user-message scanner (for fallback title)
+# ---------------------------------------------------------------------------
+
+_USER_ROLE_PATTERNS = (re.compile(r'"role"\s*:\s*"user"'),)
+
+
+def _extract_first_user_text(head: str) -> str | None:
+    """Find the first user message's text in a head chunk.
+
+    Skips lite-meta rows (no ``role``), tool_result-only messages, and
+    rows whose content can't be parsed.
+    """
+    for line in head.split("\n"):
+        line = line.strip()
+        if not line:
+            continue
+        if not any(p.search(line) for p in _USER_ROLE_PATTERNS):
+            continue
+        try:
+            obj = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if not isinstance(obj, dict) or obj.get("role") != "user":
+            continue
+        content = obj.get("content")
+        if isinstance(content, str) and content.strip():
+            return content
+        if isinstance(content, list):
+            texts: list[str] = []
+            has_user_text = False
+            for block in content:
+                if not isinstance(block, dict):
+                    continue
+                btype = block.get("type")
+                if btype == "tool_result":
+                    continue
+                if btype == "text":
+                    text = block.get("text") or ""
+                    if text:
+                        texts.append(text)
+                        has_user_text = True
+            if has_user_text:
+                return " ".join(texts)
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Public LiteMetadata extraction
+# ---------------------------------------------------------------------------
+
+
+def read_lite_metadata(path: Path) -> LiteMetadata:
+    """Extract LiteMetadata from a session file via head + tail scan."""
+    try:
+        head, tail = read_head_and_tail(path)
+    except OSError:
+        return LiteMetadata()
+    cwd = extract_first_json_string_field(head, "cwd")
+    git_branch = extract_last_json_string_field(tail, "git_branch") or extract_first_json_string_field(
+        head, "git_branch"
+    )
+    last_prompt = extract_last_json_string_field(tail, "last_prompt")
+    first_prompt = _extract_first_user_text(head)
+    return LiteMetadata(
+        cwd=cwd,
+        git_branch=git_branch,
+        last_prompt=last_prompt,
+        first_prompt=first_prompt,
+    )
+
+
+# ---------------------------------------------------------------------------
+# SessionIndex — list / search session entries across projects
+# ---------------------------------------------------------------------------
+
+
+def _trim_title(text: str, max_len: int = 200) -> str:
+    flat = text.replace("\n", " ").strip()
+    if len(flat) <= max_len:
+        return flat
+    return flat[:max_len].rstrip() + "…"
+
+
+def _build_entry(path: Path, fallback_cwd: str) -> SessionEntry | None:
+    try:
+        stat = path.stat()
+    except OSError:
+        return None
+    meta = read_lite_metadata(path)
+    cwd = meta.cwd or fallback_cwd
+    title_raw = meta.last_prompt or meta.first_prompt or ""
+    title = _trim_title(title_raw) if title_raw else "(empty)"
+    return SessionEntry(
+        session_id=path.stem,
+        cwd=cwd,
+        project_name=os.path.basename(cwd) if cwd else "?",
+        git_branch=meta.git_branch,
+        title=title,
+        mtime=stat.st_mtime,
+        size_bytes=stat.st_size,
+    )
+
+
+class SessionIndex:
+    """List/search session entries across all known project directories."""
+
+    def __init__(self, projects_dir: Path | None = None) -> None:
+        self._projects_dir = projects_dir if projects_dir is not None else get_projects_dir()
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def list_for_cwd(self, cwd: str) -> list[SessionEntry]:
+        """List entries that belong to ``cwd``, mtime-descending."""
+        if self._projects_dir == get_projects_dir():
+            project_dir = get_project_dir(cwd)
+        else:
+            project_dir = self._projects_dir / sanitize_path(cwd)
+        if not project_dir.exists():
+            return []
+        entries: list[SessionEntry] = []
+        for jsonl in project_dir.glob("*.jsonl"):
+            entry = _build_entry(jsonl, fallback_cwd=cwd)
+            if entry is not None:
+                entries.append(entry)
+        entries.sort(key=lambda e: e.mtime, reverse=True)
+        return entries
+
+    def list_all_projects(self) -> list[SessionEntry]:
+        """List entries across every known project, mtime-descending."""
+        if not self._projects_dir.exists():
+            return []
+        entries: list[SessionEntry] = []
+        for proj_dir in self._projects_dir.iterdir():
+            if not proj_dir.is_dir():
+                continue
+            for jsonl in proj_dir.glob("*.jsonl"):
+                entry = _build_entry(jsonl, fallback_cwd="")
+                if entry is not None:
+                    entries.append(entry)
+        entries.sort(key=lambda e: e.mtime, reverse=True)
+        return entries
+
+    def find_by_id_or_prefix(self, arg: str) -> SessionEntry | None:
+        """Locate a single entry by exact session id or unique id prefix."""
+        if not self._projects_dir.exists() or not arg:
+            return None
+        matches: list[SessionEntry] = []
+        for proj_dir in self._projects_dir.iterdir():
+            if not proj_dir.is_dir():
+                continue
+            for jsonl in proj_dir.glob("*.jsonl"):
+                sid = jsonl.stem
+                if sid == arg:
+                    return _build_entry(jsonl, fallback_cwd="")
+                if sid.startswith(arg):
+                    entry = _build_entry(jsonl, fallback_cwd="")
+                    if entry is not None:
+                        matches.append(entry)
+        if len(matches) == 1:
+            return matches[0]
+        return None

iac_code/services/session_storage.py

@@ -0,0 +1,245 @@
+"""Project-partitioned JSONL session storage.
+
+Layout::
+
+    ~/.iac-code/projects/<sanitize(cwd)>/<session_id>.jsonl
+
+Each session file is a stream of two kinds of JSONL lines:
+
+* **Message rows** — one per :class:`Message`, with extra stamp fields
+  (``session_id``, ``cwd``, ``git_branch``, ``version``) appended at write
+  time. ``Message.from_dict`` ignores unknown fields, so loading is
+  schema-agnostic.
+
+* **Lite-meta rows** — special rows without a ``role``, identified by a
+  ``type`` field (``last-prompt``, …). They are appended for the picker
+  to read via tail-scan, without being part of the conversation.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from iac_code import __version__
+from iac_code.agent.message import ContentBlock, Message, ToolResultBlock
+from iac_code.utils.project_paths import (
+    get_project_dir,
+    get_projects_dir,
+    get_session_path,
+)
+
+
+class SessionStorage:
+    """Persist conversation sessions partitioned by working directory."""
+
+    def __init__(self, projects_dir: Path | str | None = None) -> None:
+        self._projects_dir = Path(projects_dir) if projects_dir is not None else get_projects_dir()
+
+    # ------------------------------------------------------------------
+    # Internal path helpers
+    # ------------------------------------------------------------------
+
+    def _session_path(self, cwd: str, session_id: str) -> Path:
+        if self._projects_dir == get_projects_dir():
+            return get_session_path(cwd, session_id)
+        from iac_code.utils.project_paths import sanitize_path
+
+        return self._projects_dir / sanitize_path(cwd) / f"{session_id}.jsonl"
+
+    def _project_dir_for(self, cwd: str) -> Path:
+        if self._projects_dir == get_projects_dir():
+            return get_project_dir(cwd)
+        from iac_code.utils.project_paths import sanitize_path
+
+        return self._projects_dir / sanitize_path(cwd)
+
+    def session_path(self, cwd: str, session_id: str) -> Path:
+        """Public accessor for the on-disk JSONL path of a session."""
+        return self._session_path(cwd, session_id)
+
+    # ------------------------------------------------------------------
+    # Stamp helpers
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _stamp(data: dict[str, Any], cwd: str, session_id: str, git_branch: str | None) -> dict[str, Any]:
+        data["session_id"] = session_id
+        data["cwd"] = cwd
+        if git_branch is not None:
+            data["git_branch"] = git_branch
+        data["version"] = __version__
+        return data
+
+    # ------------------------------------------------------------------
+    # Write
+    # ------------------------------------------------------------------
+
+    def append(
+        self,
+        cwd: str,
+        session_id: str,
+        message: Message,
+        *,
+        git_branch: str | None = None,
+    ) -> None:
+        """Append a single message (real-time persistence)."""
+        path = self._session_path(cwd, session_id)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        data = self._stamp(message.to_dict(), cwd, session_id, git_branch)
+        with open(path, "a", encoding="utf-8") as f:
+            f.write(json.dumps(data, ensure_ascii=False) + "\n")
+
+    def append_meta(self, cwd: str, session_id: str, meta_entry: dict[str, Any]) -> None:
+        """Append a lite-meta row (no ``role``, distinguished by ``type``)."""
+        if "type" not in meta_entry:
+            raise ValueError("meta_entry must include a 'type' field")
+        path = self._session_path(cwd, session_id)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        entry = dict(meta_entry)
+        entry["session_id"] = session_id
+        with open(path, "a", encoding="utf-8") as f:
+            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+
+    def save(
+        self,
+        cwd: str,
+        session_id: str,
+        messages: list[Message],
+        *,
+        git_branch: str | None = None,
+    ) -> None:
+        """Overwrite the session file with the given messages."""
+        path = self._session_path(cwd, session_id)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "w", encoding="utf-8") as f:
+            for msg in messages:
+                data = self._stamp(msg.to_dict(), cwd, session_id, git_branch)
+                f.write(json.dumps(data, ensure_ascii=False) + "\n")
+
+    # ------------------------------------------------------------------
+    # Read
+    # ------------------------------------------------------------------
+
+    def load(self, cwd: str, session_id: str) -> list[Message]:
+        """Return the conversation messages, skipping lite-meta rows."""
+        path = self._session_path(cwd, session_id)
+        if not path.exists():
+            return []
+        messages: list[Message] = []
+        with open(path, encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    obj = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                if not isinstance(obj, dict):
+                    continue
+                if "role" not in obj:
+                    # Lite-meta or unknown row — skip.
+                    continue
+                try:
+                    messages.append(Message.from_dict(obj))
+                except Exception:
+                    continue
+        return messages
+
+    def exists(self, cwd: str, session_id: str) -> bool:
+        return self._session_path(cwd, session_id).exists()
+
+    # ------------------------------------------------------------------
+    # Cross-project lookups (used by CLI --resume / --continue)
+    # ------------------------------------------------------------------
+
+    def find_session_anywhere(self, session_id: str) -> tuple[str, Path] | None:
+        """Locate a session file across all known project dirs.
+
+        Returns ``(cwd, path)`` where ``cwd`` is the *original* working
+        directory of the session (read back from the first stamped
+        message), or ``None`` if the file isn't found.
+        """
+        if not self._projects_dir.exists():
+            return None
+        for proj_dir in self._projects_dir.iterdir():
+            if not proj_dir.is_dir():
+                continue
+            candidate = proj_dir / f"{session_id}.jsonl"
+            if candidate.exists():
+                cwd = self._read_cwd_from_file(candidate) or ""
+                return cwd, candidate
+        return None
+
+    def get_latest_session_anywhere(self) -> tuple[str, str] | None:
+        """Return ``(cwd, session_id)`` for the most-recently-modified session."""
+        if not self._projects_dir.exists():
+            return None
+        latest: tuple[float, Path] | None = None
+        for proj_dir in self._projects_dir.iterdir():
+            if not proj_dir.is_dir():
+                continue
+            for jsonl in proj_dir.glob("*.jsonl"):
+                mtime = jsonl.stat().st_mtime
+                if latest is None or mtime > latest[0]:
+                    latest = (mtime, jsonl)
+        if latest is None:
+            return None
+        path = latest[1]
+        cwd = self._read_cwd_from_file(path) or ""
+        session_id = path.stem
+        return cwd, session_id
+
+    @staticmethod
+    def _read_cwd_from_file(path: Path) -> str | None:
+        """Read the first message-row's ``cwd`` stamp from a session file."""
+        try:
+            with open(path, encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        obj = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+                    if isinstance(obj, dict) and "cwd" in obj:
+                        cwd = obj["cwd"]
+                        if isinstance(cwd, str):
+                            return cwd
+        except OSError:
+            return None
+        return None
+
+    # ------------------------------------------------------------------
+    # Interruption repair
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def detect_interruption(messages: list[Message]) -> bool:
+        """True if the session ends mid-tool-execution (assistant tool_use without results)."""
+        if not messages:
+            return False
+        last = messages[-1]
+        return last.role == "assistant" and last.has_tool_use()
+
+    @classmethod
+    def repair_interrupted(cls, messages: list[Message]) -> list[Message]:
+        """Append synthetic error tool_results for any orphaned tool_use blocks."""
+        if not cls.detect_interruption(messages):
+            return messages
+        last_msg = messages[-1]
+        tool_uses = last_msg.get_tool_use_blocks()
+        repair_results: list[ContentBlock] = [
+            ToolResultBlock(
+                tool_use_id=tu.id,
+                content="Session interrupted before tool execution completed.",
+                is_error=True,
+            )
+            for tu in tool_uses
+        ]
+        repaired = list(messages)
+        repaired.append(Message(role="user", content=repair_results))
+        return repaired

iac_code/services/telemetry/__init__.py

@@ -0,0 +1,66 @@
+"""iac-code telemetry package — zero-dependency public facade."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from iac_code.services.telemetry.client import TelemetryClient
+
+__all__ = [
+    "log_event",
+    "add_metric",
+    "start_span",
+    "bootstrap_telemetry",
+    "graceful_shutdown",
+    "get_client",
+    "set_client",
+    "get_session_id",
+    "get_user_id",
+]
+
+_client: TelemetryClient | None = None
+
+
+def get_client() -> TelemetryClient:
+    """Return the singleton client, creating it on first call."""
+    global _client
+    if _client is None:
+        _client = TelemetryClient()
+    return _client
+
+
+def set_client(client: TelemetryClient | None) -> None:
+    """Replace (or clear) the singleton. Useful for tests."""
+    global _client
+    _client = client
+
+
+def log_event(event_name: str, metadata: dict[str, Any] | None = None) -> None:
+    get_client().log_event(event_name, metadata)
+
+
+def add_metric(name: str, value: int | float, attributes: dict[str, Any] | None = None) -> None:
+    get_client().add_metric(name, value, attributes)
+
+
+def start_span(name: str, attributes: dict[str, Any] | None = None):
+    return get_client().start_span(name, attributes)
+
+
+def bootstrap_telemetry(session_id: str | None = None) -> None:
+    global _client
+    if _client is None:
+        _client = TelemetryClient(session_id=session_id)
+    get_client().bootstrap()
+
+
+def graceful_shutdown() -> None:
+    get_client().shutdown()
+
+
+def get_session_id() -> str:
+    return get_client().get_session_id()
+
+
+def get_user_id() -> str:
+    return get_client().get_user_id()

iac_code/services/telemetry/attributes.py

@@ -0,0 +1,84 @@
+"""AttributeBuilder — build resource and per-event attribute dicts."""
+
+from __future__ import annotations
+
+import itertools
+import os
+import platform
+import socket
+import sys
+from datetime import datetime, timezone
+from threading import Lock
+
+from iac_code.services.telemetry.identity import Identity
+from iac_code.services.telemetry.names import (
+    ARMS_FEATURE_GENAI_APP,
+    FRAMEWORK_IAC_CODE,
+    ArmsResourceAttr,
+)
+
+
+def _detect_service_version() -> str:
+    """Look up installed version; fallback to 0.0.0 for dev."""
+    try:
+        from importlib.metadata import version
+
+        return version("iac-code")
+    except Exception:
+        return "0.0.0"
+
+
+def _detect_host_name() -> str:
+    try:
+        return socket.gethostname() or "unknown"
+    except Exception:
+        return "unknown"
+
+
+class AttributeBuilder:
+    """Assembles the attribute dicts attached to every signal.
+
+    Resource attributes are identity + app + device fields. Event attributes
+    wrap event.name with a timestamp and a monotonic sequence.
+    """
+
+    def __init__(
+        self,
+        identity: Identity,
+        service_name: str,
+        service_version: str | None = None,
+    ) -> None:
+        self._identity = identity
+        self._service_name = service_name
+        self._service_version = service_version or _detect_service_version()
+        self._sequence = itertools.count(1)
+        self._sequence_lock = Lock()
+
+    def build_resource(self) -> dict[str, str]:
+        """Identity + app + device attributes. Called once at startup, usually."""
+        attrs: dict[str, str] = {
+            "service.name": self._service_name,
+            "service.version": self._service_version,
+            "os.type": sys.platform,
+            "host.arch": platform.machine() or "unknown",
+            "host.name": _detect_host_name(),
+            "deployment.environment": os.environ.get("IAC_CODE_ENV", "production"),
+            ArmsResourceAttr.CMS_WORKSPACE: FRAMEWORK_IAC_CODE,
+            ArmsResourceAttr.SERVICE_FEATURE: ARMS_FEATURE_GENAI_APP,
+            "user.id": self._identity.get_user_id(),
+            "session.id": self._identity.get_session_id(),
+        }
+        tenant = self._identity.get_tenant_id()
+        if tenant is not None:
+            attrs["tenant.id"] = tenant
+        return attrs
+
+    def build_event(self, event_name: str) -> dict[str, str | int]:
+        """Per-event envelope."""
+        with self._sequence_lock:
+            seq = next(self._sequence)
+        return {
+            "event.name": event_name,
+            "event.timestamp": datetime.now(timezone.utc).isoformat(),
+            "event.sequence": seq,
+        }