@laitszkin/apollo-toolkit 3.13.2 → 3.14.0

package/analyse-app-logs/tests/test_search_logs.py

@@ -1,100 +0,0 @@
-#!/usr/bin/env python3
-
-from __future__ import annotations
-
-import importlib.util
-import io
-import tempfile
-import unittest
-from argparse import Namespace
-from pathlib import Path
-from unittest.mock import patch
-
-
-SCRIPT_PATH = Path(__file__).resolve().parents[1] / "scripts" / "search_logs.py"
-SCRIPT_DIR = SCRIPT_PATH.parent
-if str(SCRIPT_DIR) not in __import__("sys").path:
-    __import__("sys").path.insert(0, str(SCRIPT_DIR))
-SPEC = importlib.util.spec_from_file_location("search_logs", SCRIPT_PATH)
-MODULE = importlib.util.module_from_spec(SPEC)
-SPEC.loader.exec_module(MODULE)
-
-
-class SearchLogsTests(unittest.TestCase):
-    def test_keyword_search_respects_time_window(self) -> None:
-        with tempfile.NamedTemporaryFile("w+", encoding="utf-8", delete=False) as handle:
-            handle.write(
-                "2026-03-24T10:00:00Z INFO boot\n"
-                "2026-03-24T10:05:00Z ERROR payment timeout\n"
-                "2026-03-24T10:10:00Z ERROR payment timeout\n"
-            )
-            path = handle.name
-
-        args = Namespace(
-            paths=[path],
-            keyword=["timeout"],
-            regex=[],
-            mode="any",
-            ignore_case=False,
-            start="2026-03-24T10:01:00Z",
-            end="2026-03-24T10:06:00Z",
-            assume_timezone="UTC",
-            before_context=0,
-            after_context=0,
-            count_only=False,
-        )
-
-        with patch.object(MODULE, "parse_args", return_value=args), patch(
-            "sys.stdout", new_callable=io.StringIO
-        ) as stdout:
-            code = MODULE.main()
-
-        self.assertEqual(code, 0)
-        self.assertEqual(
-            stdout.getvalue().strip(),
-            "2026-03-24T10:05:00Z ERROR payment timeout",
-        )
-
-    def test_all_mode_requires_every_matcher(self) -> None:
-        matchers = [
-            lambda line: "timeout" in line,
-            lambda line: "payment" in line,
-        ]
-
-        self.assertTrue(MODULE.line_matches("payment timeout", matchers, "all"))
-        self.assertFalse(MODULE.line_matches("timeout only", matchers, "all"))
-
-    def test_count_only_reports_match_total(self) -> None:
-        with tempfile.NamedTemporaryFile("w+", encoding="utf-8", delete=False) as handle:
-            handle.write(
-                "2026-03-24T10:00:00Z INFO boot\n"
-                "2026-03-24T10:05:00Z ERROR payment timeout\n"
-                "2026-03-24T10:06:00Z WARN retry timeout\n"
-            )
-            path = handle.name
-
-        args = Namespace(
-            paths=[path],
-            keyword=["timeout"],
-            regex=[],
-            mode="any",
-            ignore_case=True,
-            start=None,
-            end=None,
-            assume_timezone="UTC",
-            before_context=0,
-            after_context=0,
-            count_only=True,
-        )
-
-        with patch.object(MODULE, "parse_args", return_value=args), patch(
-            "sys.stdout", new_callable=io.StringIO
-        ) as stdout:
-            code = MODULE.main()
-
-        self.assertEqual(code, 0)
-        self.assertEqual(stdout.getvalue().strip(), "2")
-
-
-if __name__ == "__main__":
-    unittest.main()

package/codex/codex-memory-manager/scripts/extract_recent_conversations.py

@@ -1,369 +0,0 @@
-#!/usr/bin/env python3
-"""Extract recent Codex conversation history from Codex session stores."""
-
-from __future__ import annotations
-
-import argparse
-import json
-from dataclasses import dataclass
-from datetime import datetime, timedelta, timezone
-from pathlib import Path
-from typing import Iterable, List, Optional, Sequence, Tuple
-
-DEFAULT_LOOKBACK_MINUTES = 24 * 60
-DEFAULT_RETENTION_DAYS = 7
-
-
-@dataclass
-class SessionRecord:
-    path: Path
-    timestamp_utc: datetime
-    messages: Optional[List[Tuple[str, str]]] = None
-
-
-def parse_iso_timestamp(raw: Optional[str]) -> Optional[datetime]:
-    if not raw:
-        return None
-    value = raw.strip()
-    if not value:
-        return None
-    if value.endswith("Z"):
-        value = value[:-1] + "+00:00"
-    try:
-        parsed = datetime.fromisoformat(value)
-    except ValueError:
-        return None
-    if parsed.tzinfo is None:
-        parsed = parsed.replace(tzinfo=timezone.utc)
-    return parsed.astimezone(timezone.utc)
-
-
-def read_session_timestamp(path: Path) -> Optional[datetime]:
-    try:
-        with path.open("r", encoding="utf-8") as handle:
-            first_line = handle.readline().strip()
-    except OSError:
-        return None
-
-    if not first_line:
-        return None
-
-    try:
-        first_entry = json.loads(first_line)
-    except json.JSONDecodeError:
-        return None
-
-    if first_entry.get("type") != "session_meta":
-        return None
-
-    payload = first_entry.get("payload", {})
-    if not isinstance(payload, dict):
-        return None
-
-    return parse_iso_timestamp(payload.get("timestamp")) or parse_iso_timestamp(first_entry.get("timestamp"))
-
-
-def iter_session_paths(root: Path) -> Iterable[Path]:
-    if not root.exists() or not root.is_dir():
-        return
-    yield from root.rglob("*.jsonl")
-
-
-def find_recent_sessions(
-    session_roots: Sequence[Path],
-    cutoff_utc: datetime,
-    limit: Optional[int],
-) -> List[SessionRecord]:
-    candidates: List[SessionRecord] = []
-    seen_paths = set()
-
-    for root in session_roots:
-        for path in iter_session_paths(root):
-            resolved_path = path.resolve()
-            if resolved_path in seen_paths:
-                continue
-            seen_paths.add(resolved_path)
-
-            timestamp_utc = read_session_timestamp(path)
-            if timestamp_utc is None:
-                continue
-            if timestamp_utc < cutoff_utc:
-                continue
-            candidates.append(SessionRecord(path=path, timestamp_utc=timestamp_utc))
-
-    candidates.sort(key=lambda record: record.timestamp_utc, reverse=True)
-    if limit is None:
-        return candidates
-    return candidates[:limit]
-
-
-def sanitize_text(text: str, max_chars: int) -> str:
-    cleaned = text.replace("\r\n", "\n").replace("\r", "\n").strip()
-    if max_chars <= 0:
-        return cleaned
-    if len(cleaned) <= max_chars:
-        return cleaned
-    return cleaned[: max_chars - 1].rstrip() + "..."
-
-
-def looks_like_wrapper_message(text: str) -> bool:
-    stripped = text.strip()
-    if not stripped:
-        return True
-    lower = stripped.lower()
-    return (
-        stripped.startswith("# AGENTS.md instructions for")
-        or stripped.startswith("<environment_context>")
-        or "<collaboration_mode>" in lower
-        or stripped.startswith("<permissions instructions>")
-        or stripped.startswith("<app-context>")
-    )
-
-
-def extract_text_from_content(content: Sequence[object]) -> str:
-    texts: List[str] = []
-    for part in content:
-        if not isinstance(part, dict):
-            continue
-        part_type = part.get("type")
-        if part_type in {"input_text", "output_text", "text"}:
-            value = part.get("text", "")
-            if isinstance(value, str) and value.strip():
-                texts.append(value)
-    return "\n".join(texts).strip()
-
-
-def extract_messages_from_event_entries(entries: Iterable[dict], max_chars: int) -> List[Tuple[str, str]]:
-    messages: List[Tuple[str, str]] = []
-    for entry in entries:
-        if entry.get("type") != "event_msg":
-            continue
-        payload = entry.get("payload", {})
-        if not isinstance(payload, dict):
-            continue
-
-        payload_type = payload.get("type")
-        if payload_type == "user_message":
-            text = payload.get("message", "")
-            if isinstance(text, str) and text.strip():
-                messages.append(("user", sanitize_text(text, max_chars)))
-        elif payload_type == "agent_message":
-            text = payload.get("message", "")
-            if isinstance(text, str) and text.strip():
-                messages.append(("assistant", sanitize_text(text, max_chars)))
-    return messages
-
-
-def extract_messages_from_response_items(entries: Iterable[dict], max_chars: int) -> List[Tuple[str, str]]:
-    messages: List[Tuple[str, str]] = []
-    for entry in entries:
-        if entry.get("type") != "response_item":
-            continue
-        payload = entry.get("payload", {})
-        if not isinstance(payload, dict):
-            continue
-        if payload.get("type") != "message":
-            continue
-
-        role = payload.get("role")
-        if role not in {"user", "assistant"}:
-            continue
-
-        text = extract_text_from_content(payload.get("content", []))
-        if not text or looks_like_wrapper_message(text):
-            continue
-        messages.append((role, sanitize_text(text, max_chars)))
-    return messages
-
-
-def extract_session_messages(path: Path, max_chars: int) -> List[Tuple[str, str]]:
-    entries: List[dict] = []
-    try:
-        with path.open("r", encoding="utf-8") as handle:
-            for line in handle:
-                line = line.strip()
-                if not line:
-                    continue
-                try:
-                    entries.append(json.loads(line))
-                except json.JSONDecodeError:
-                    continue
-    except OSError:
-        return []
-
-    event_messages = extract_messages_from_event_entries(entries, max_chars)
-    if event_messages:
-        return event_messages
-    return extract_messages_from_response_items(entries, max_chars)
-
-
-def delete_matching_files(root: Path, predicate) -> int:
-    if not root.exists() or not root.is_dir():
-        return 0
-
-    deleted_count = 0
-    for path in root.rglob("*.jsonl"):
-        if not predicate(path):
-            continue
-        try:
-            path.unlink()
-        except OSError:
-            continue
-        deleted_count += 1
-    return deleted_count
-
-
-def path_is_same_or_nested(path: Path, root: Optional[Path]) -> bool:
-    if root is None:
-        return False
-    try:
-        path.resolve().relative_to(root.resolve())
-        return True
-    except ValueError:
-        return False
-
-
-def cleanup_session_history(
-    sessions_dir: Path,
-    archived_sessions_dir: Path,
-    retention_cutoff_utc: datetime,
-) -> Tuple[int, int]:
-    sessions_root = sessions_dir.resolve() if sessions_dir.exists() else None
-    removed_old_sessions = delete_matching_files(
-        sessions_dir,
-        lambda path: (
-            (timestamp := read_session_timestamp(path)) is not None
-            and timestamp < retention_cutoff_utc
-        ),
-    )
-    removed_archived_sessions = delete_matching_files(
-        archived_sessions_dir,
-        lambda path: not path_is_same_or_nested(path, sessions_root),
-    )
-    return removed_old_sessions, removed_archived_sessions
-
-
-def render_text_output(
-    records: Sequence[SessionRecord],
-    lookback_minutes: int,
-    max_message_chars: int,
-    removed_old_sessions: int,
-    removed_archived_sessions: int,
-) -> str:
-    if not records:
-        return "NO_RECENT_CONVERSATIONS"
-
-    lines: List[str] = [
-        f"RECENT_CONVERSATIONS_FOUND={len(records)}",
-        f"LOOKBACK_MINUTES={lookback_minutes}",
-        "ARCHIVED_SESSIONS_INCLUDED=true",
-        f"CLEANUP_REMOVED_OLD_SESSIONS={removed_old_sessions}",
-        f"CLEANUP_REMOVED_ARCHIVED_SESSIONS={removed_archived_sessions}",
-    ]
-
-    for index, record in enumerate(records, start=1):
-        lines.append(f"=== SESSION {index} ===")
-        lines.append(f"TIMESTAMP_UTC={record.timestamp_utc.isoformat()}")
-        lines.append(f"FILE={record.path}")
-
-        messages = record.messages
-        if messages is None:
-            messages = extract_session_messages(record.path, max_message_chars)
-        if not messages:
-            lines.append("MESSAGES=NONE")
-            continue
-
-        for role, message in messages:
-            tag = "USER" if role == "user" else "ASSISTANT"
-            lines.append(f"[{tag}]")
-            lines.append(message)
-            lines.append(f"[/{tag}]")
-
-    return "\n".join(lines)
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description="Extract the latest conversation history from Codex session stores",
-    )
-    parser.add_argument(
-        "--sessions-dir",
-        default="~/.codex/sessions",
-        help="Path to the Codex sessions directory (default: ~/.codex/sessions)",
-    )
-    parser.add_argument(
-        "--archived-sessions-dir",
-        default="~/.codex/archived_sessions",
-        help="Path to archived Codex sessions (default: ~/.codex/archived_sessions)",
-    )
-    parser.add_argument(
-        "--lookback-minutes",
-        type=int,
-        default=DEFAULT_LOOKBACK_MINUTES,
-        help=f"How far back to look for sessions (default: {DEFAULT_LOOKBACK_MINUTES})",
-    )
-    parser.add_argument(
-        "--limit",
-        type=int,
-        default=None,
-        help="Maximum number of sessions to return (default: all within lookback window)",
-    )
-    parser.add_argument(
-        "--max-message-chars",
-        type=int,
-        default=1600,
-        help="Maximum characters per extracted message (default: 1600)",
-    )
-    parser.add_argument(
-        "--retention-days",
-        type=int,
-        default=DEFAULT_RETENTION_DAYS,
-        help=f"Delete sessions older than this many days after reading (default: {DEFAULT_RETENTION_DAYS})",
-    )
-    return parser.parse_args()
-
-
-def main() -> int:
-    args = parse_args()
-
-    sessions_dir = Path(args.sessions_dir).expanduser().resolve()
-    archived_sessions_dir = Path(args.archived_sessions_dir).expanduser().resolve()
-    lookback_minutes = max(args.lookback_minutes, 1)
-    limit = args.limit if args.limit is not None and args.limit > 0 else None
-    max_message_chars = max(args.max_message_chars, 100)
-    retention_days = max(args.retention_days, 1)
-    now_utc = datetime.now(timezone.utc)
-
-    if (
-        (not sessions_dir.exists() or not sessions_dir.is_dir())
-        and (not archived_sessions_dir.exists() or not archived_sessions_dir.is_dir())
-    ):
-        print("NO_RECENT_CONVERSATIONS")
-        return 0
-
-    cutoff_utc = now_utc - timedelta(minutes=lookback_minutes)
-    recent_records = find_recent_sessions((sessions_dir, archived_sessions_dir), cutoff_utc, limit)
-    for record in recent_records:
-        record.messages = extract_session_messages(record.path, max_message_chars)
-
-    retention_cutoff_utc = now_utc - timedelta(days=retention_days)
-    removed_old_sessions, removed_archived_sessions = cleanup_session_history(
-        sessions_dir,
-        archived_sessions_dir,
-        retention_cutoff_utc,
-    )
-
-    print(
-        render_text_output(
-            recent_records,
-            lookback_minutes,
-            max_message_chars,
-            removed_old_sessions,
-            removed_archived_sessions,
-        )
-    )
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/codex/codex-memory-manager/scripts/sync_memory_index.py

@@ -1,130 +0,0 @@
-#!/usr/bin/env python3
-"""Synchronize a normalized memory index section into ~/.codex/AGENTS.md."""
-
-from __future__ import annotations
-
-import argparse
-import re
-from pathlib import Path
-from typing import Iterable
-
-START_MARKER = "<!-- codex-memory-manager:start -->"
-END_MARKER = "<!-- codex-memory-manager:end -->"
-DEFAULT_SECTION_TITLE = "## User Memory Index"
-DEFAULT_INSTRUCTIONS = [
-    "Before starting work, review the index below and open any relevant user preference files.",
-    "When a new preference category appears, create or update the matching memory file and refresh this index.",
-]
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description="Sync the Codex user memory index section inside AGENTS.md",
-    )
-    parser.add_argument(
-        "--agents-file",
-        default="~/.codex/AGENTS.md",
-        help="Path to AGENTS.md (default: ~/.codex/AGENTS.md)",
-    )
-    parser.add_argument(
-        "--memory-dir",
-        default="~/.codex/memory",
-        help="Directory that stores memory markdown files (default: ~/.codex/memory)",
-    )
-    parser.add_argument(
-        "--section-title",
-        default=DEFAULT_SECTION_TITLE,
-        help=f"Heading to use for the index section (default: {DEFAULT_SECTION_TITLE!r})",
-    )
-    parser.add_argument(
-        "--instruction-line",
-        action="append",
-        dest="instruction_lines",
-        help="Instruction line to place before the index bullets. Repeat to add more lines.",
-    )
-    return parser.parse_args()
-
-
-def title_from_memory_file(path: Path) -> str:
-    try:
-        content = path.read_text(encoding="utf-8")
-    except OSError:
-        return path.stem.replace("-", " ").title()
-
-    for line in content.splitlines():
-        stripped = line.strip()
-        if stripped.startswith("# "):
-            return stripped[2:].strip() or path.stem.replace("-", " ").title()
-
-    return path.stem.replace("-", " ").title()
-
-
-def iter_memory_files(memory_dir: Path) -> Iterable[Path]:
-    if not memory_dir.exists() or not memory_dir.is_dir():
-        return []
-    return sorted(
-        (path for path in memory_dir.glob("*.md") if path.is_file()),
-        key=lambda path: path.name.lower(),
-    )
-
-
-def render_section(memory_files: list[Path], section_title: str, instruction_lines: list[str]) -> str:
-    lines = [START_MARKER, section_title.strip(), ""]
-
-    cleaned_instructions = [line.strip() for line in instruction_lines if line and line.strip()]
-    for line in cleaned_instructions:
-        lines.append(line)
-    if cleaned_instructions:
-        lines.append("")
-
-    if memory_files:
-        entries = sorted(
-            ((title_from_memory_file(path), path.expanduser().resolve()) for path in memory_files),
-            key=lambda item: (item[0].lower(), str(item[1]).lower()),
-        )
-        for title, path in entries:
-            lines.append(f"- [{title}]({path})")
-    else:
-        lines.append("- No memory files are currently indexed.")
-
-    lines.append(END_MARKER)
-    return "\n".join(lines)
-
-
-def remove_existing_section(content: str) -> str:
-    pattern = re.compile(
-        rf"\n*{re.escape(START_MARKER)}.*?{re.escape(END_MARKER)}\n*",
-        re.DOTALL,
-    )
-    return re.sub(pattern, "\n\n", content).rstrip()
-
-
-def sync_agents_file(agents_file: Path, section_text: str) -> None:
-    agents_file.parent.mkdir(parents=True, exist_ok=True)
-    try:
-        original = agents_file.read_text(encoding="utf-8")
-    except FileNotFoundError:
-        original = ""
-
-    base = remove_existing_section(original)
-    if base:
-        updated = f"{base}\n\n{section_text}\n"
-    else:
-        updated = f"{section_text}\n"
-    agents_file.write_text(updated, encoding="utf-8")
-
-
-def main() -> int:
-    args = parse_args()
-    agents_file = Path(args.agents_file).expanduser()
-    memory_dir = Path(args.memory_dir).expanduser()
-    instruction_lines = args.instruction_lines or DEFAULT_INSTRUCTIONS
-    section_text = render_section(list(iter_memory_files(memory_dir)), args.section_title, instruction_lines)
-    sync_agents_file(agents_file, section_text)
-    print(f"SYNCED_AGENTS_FILE={agents_file.resolve()}")
-    print(f"MEMORY_FILES_INDEXED={len(list(iter_memory_files(memory_dir)))}")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())