@laitszkin/apollo-toolkit 3.13.2 → 3.14.1

package/codex/codex-memory-manager/tests/test_extract_recent_conversations.py

@@ -1,177 +0,0 @@
-#!/usr/bin/env python3
-"""Edge-case tests for extract_recent_conversations.py."""
-
-from __future__ import annotations
-
-import json
-import subprocess
-import sys
-import tempfile
-import unittest
-from datetime import datetime, timedelta, timezone
-from pathlib import Path
-
-
-SCRIPT_PATH = (
-    Path(__file__).resolve().parents[1] / "scripts" / "extract_recent_conversations.py"
-)
-
-
-def write_session(path: Path, timestamp: datetime) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    entries = [
-        {
-            "type": "session_meta",
-            "payload": {"timestamp": timestamp.isoformat()},
-        },
-        {
-            "type": "event_msg",
-            "payload": {"type": "user_message", "message": f"user:{path.stem}"},
-        },
-        {
-            "type": "event_msg",
-            "payload": {"type": "agent_message", "message": f"assistant:{path.stem}"},
-        },
-    ]
-    with path.open("w", encoding="utf-8") as handle:
-        for entry in entries:
-            handle.write(json.dumps(entry) + "\n")
-
-
-def run_extractor(
-    sessions_dir: Path,
-    archived_dir: Path | None = None,
-    *extra_args: str,
-) -> str:
-    effective_archived_dir = archived_dir or (sessions_dir.parent / "__isolated_archived_sessions__")
-    cmd = [
-        sys.executable,
-        str(SCRIPT_PATH),
-        "--sessions-dir",
-        str(sessions_dir),
-        "--archived-sessions-dir",
-        str(effective_archived_dir),
-    ]
-    cmd.extend(extra_args)
-    result = subprocess.run(cmd, capture_output=True, text=True, check=True)
-    return result.stdout
-
-
-class ExtractRecentConversationsTests(unittest.TestCase):
-    def test_default_lookback_covers_last_24_hours(self) -> None:
-        with tempfile.TemporaryDirectory() as tmp:
-            sessions_root = Path(tmp) / "sessions"
-            now = datetime.now(timezone.utc)
-            write_session(sessions_root / "recent.jsonl", now - timedelta(hours=3))
-
-            output = run_extractor(sessions_root)
-
-            self.assertIn("RECENT_CONVERSATIONS_FOUND=1", output)
-            self.assertIn("LOOKBACK_MINUTES=1440", output)
-
-    def test_limit_zero_is_treated_as_unlimited(self) -> None:
-        with tempfile.TemporaryDirectory() as tmp:
-            sessions_root = Path(tmp) / "sessions"
-            now = datetime.now(timezone.utc)
-            write_session(sessions_root / "a.jsonl", now - timedelta(minutes=5))
-            write_session(sessions_root / "b.jsonl", now - timedelta(minutes=10))
-            write_session(sessions_root / "c.jsonl", now - timedelta(minutes=15))
-
-            output = run_extractor(
-                sessions_root,
-                None,
-                "--lookback-minutes",
-                "60",
-                "--limit",
-                "0",
-            )
-
-            self.assertIn("RECENT_CONVERSATIONS_FOUND=3", output)
-
-    def test_archived_sessions_are_read_before_cleanup(self) -> None:
-        with tempfile.TemporaryDirectory() as tmp:
-            sessions_root = Path(tmp) / "sessions"
-            archived_root = Path(tmp) / "archived_sessions"
-            now = datetime.now(timezone.utc)
-            archived_file = archived_root / "archived.jsonl"
-            write_session(archived_file, now - timedelta(minutes=30))
-
-            output = run_extractor(
-                sessions_root,
-                archived_root,
-                "--lookback-minutes",
-                "60",
-            )
-
-            self.assertIn("RECENT_CONVERSATIONS_FOUND=1", output)
-            self.assertIn("ARCHIVED_SESSIONS_INCLUDED=true", output)
-            self.assertIn("user:archived", output)
-            self.assertIn("assistant:archived", output)
-            self.assertIn("CLEANUP_REMOVED_ARCHIVED_SESSIONS=1", output)
-            self.assertFalse(archived_file.exists())
-
-    def test_cleanup_removes_only_old_sessions_from_sessions_dir(self) -> None:
-        with tempfile.TemporaryDirectory() as tmp:
-            sessions_root = Path(tmp) / "sessions"
-            now = datetime.now(timezone.utc)
-            recent_file = sessions_root / "recent.jsonl"
-            old_file = sessions_root / "old.jsonl"
-            write_session(recent_file, now - timedelta(hours=6))
-            write_session(old_file, now - timedelta(days=8))
-
-            output = run_extractor(
-                sessions_root,
-                None,
-                "--lookback-minutes",
-                "1440",
-                "--retention-days",
-                "7",
-            )
-
-            self.assertIn("RECENT_CONVERSATIONS_FOUND=1", output)
-            self.assertIn("CLEANUP_REMOVED_OLD_SESSIONS=1", output)
-            self.assertTrue(recent_file.exists())
-            self.assertFalse(old_file.exists())
-
-    def test_archived_cleanup_skips_active_sessions_when_paths_overlap(self) -> None:
-        with tempfile.TemporaryDirectory() as tmp:
-            sessions_root = Path(tmp) / "sessions"
-            now = datetime.now(timezone.utc)
-            recent_file = sessions_root / "recent.jsonl"
-            write_session(recent_file, now - timedelta(minutes=5))
-
-            output = run_extractor(
-                sessions_root,
-                sessions_root,
-                "--lookback-minutes",
-                "60",
-            )
-
-            self.assertIn("RECENT_CONVERSATIONS_FOUND=1", output)
-            self.assertIn("CLEANUP_REMOVED_ARCHIVED_SESSIONS=0", output)
-            self.assertTrue(recent_file.exists())
-
-    def test_limit_one_only_returns_latest_session_across_sources(self) -> None:
-        with tempfile.TemporaryDirectory() as tmp:
-            sessions_root = Path(tmp) / "sessions"
-            archived_root = Path(tmp) / "archived_sessions"
-            now = datetime.now(timezone.utc)
-            write_session(sessions_root / "older.jsonl", now - timedelta(minutes=20))
-            newest = archived_root / "newest.jsonl"
-            write_session(newest, now - timedelta(minutes=5))
-
-            output = run_extractor(
-                sessions_root,
-                archived_root,
-                "--lookback-minutes",
-                "60",
-                "--limit",
-                "1",
-            )
-
-            self.assertIn("RECENT_CONVERSATIONS_FOUND=1", output)
-            self.assertIn("newest.jsonl", output)
-
-
-if __name__ == "__main__":
-    unittest.main()

package/codex/codex-memory-manager/tests/test_memory_template.py

@@ -1,37 +0,0 @@
-#!/usr/bin/env python3
-"""Tests for the codex-memory-manager memory template reference."""
-
-from __future__ import annotations
-
-import unittest
-from pathlib import Path
-
-
-TEMPLATE_PATH = (
-    Path(__file__).resolve().parents[1]
-    / "references"
-    / "templates"
-    / "memory-file.md"
-)
-
-
-class MemoryTemplateTests(unittest.TestCase):
-    def test_template_contains_required_sections(self) -> None:
-        content = TEMPLATE_PATH.read_text(encoding="utf-8")
-
-        self.assertIn("# User Memory - [Category Name]", content)
-        self.assertIn("## Scope", content)
-        self.assertIn("## Preferences", content)
-        self.assertIn("## Maintenance", content)
-        self.assertIn("## Evidence notes", content)
-
-    def test_template_enforces_preference_first_generalization_rules(self) -> None:
-        content = TEMPLATE_PATH.read_text(encoding="utf-8")
-
-        self.assertIn("preference-heavy and reusable across projects", content)
-        self.assertIn("Remove or rewrite project names, issue numbers, branch names", content)
-        self.assertIn("Split the file when it starts mixing unrelated decision domains", content)
-
-
-if __name__ == "__main__":
-    unittest.main()

package/codex/codex-memory-manager/tests/test_sync_memory_index.py

@@ -1,84 +0,0 @@
-#!/usr/bin/env python3
-"""Tests for sync_memory_index.py."""
-
-from __future__ import annotations
-
-import subprocess
-import sys
-import tempfile
-import unittest
-from pathlib import Path
-
-SCRIPT_PATH = Path(__file__).resolve().parents[1] / "scripts" / "sync_memory_index.py"
-
-
-def run_sync(agents_file: Path, memory_dir: Path, *extra_args: str) -> str:
-    cmd = [
-        sys.executable,
-        str(SCRIPT_PATH),
-        "--agents-file",
-        str(agents_file),
-        "--memory-dir",
-        str(memory_dir),
-    ]
-    cmd.extend(extra_args)
-    result = subprocess.run(cmd, capture_output=True, text=True, check=True)
-    return result.stdout
-
-
-class SyncMemoryIndexTests(unittest.TestCase):
-    def test_appends_memory_index_with_sorted_links(self) -> None:
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            agents_file = root / "AGENTS.md"
-            agents_file.write_text("# Base Instructions\n", encoding="utf-8")
-            memory_dir = root / "memory"
-            memory_dir.mkdir()
-            (memory_dir / "workflow-preferences.md").write_text("# Workflow Preferences\n", encoding="utf-8")
-            (memory_dir / "architecture-preferences.md").write_text("# Architecture Preferences\n", encoding="utf-8")
-
-            run_sync(agents_file, memory_dir)
-
-            content = agents_file.read_text(encoding="utf-8")
-            self.assertIn("## User Memory Index", content)
-            self.assertIn("Before starting work, review the index below", content)
-            self.assertLess(
-                content.index("[Architecture Preferences]"),
-                content.index("[Workflow Preferences]"),
-            )
-
-    def test_replaces_existing_managed_section_without_duplication(self) -> None:
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            agents_file = root / "AGENTS.md"
-            agents_file.write_text(
-                "# Base\n\n<!-- codex-memory-manager:start -->\nold\n<!-- codex-memory-manager:end -->\n",
-                encoding="utf-8",
-            )
-            memory_dir = root / "memory"
-            memory_dir.mkdir()
-            (memory_dir / "style-preferences.md").write_text("# Style Preferences\n", encoding="utf-8")
-
-            run_sync(agents_file, memory_dir, "--instruction-line", "Read this first.")
-
-            content = agents_file.read_text(encoding="utf-8")
-            self.assertEqual(content.count("<!-- codex-memory-manager:start -->"), 1)
-            self.assertIn("Read this first.", content)
-            self.assertNotIn("\nold\n", content)
-
-    def test_uses_filename_when_heading_is_missing(self) -> None:
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            agents_file = root / "AGENTS.md"
-            memory_dir = root / "memory"
-            memory_dir.mkdir()
-            (memory_dir / "java-preferences.md").write_text("No heading here\n", encoding="utf-8")
-
-            run_sync(agents_file, memory_dir)
-
-            content = agents_file.read_text(encoding="utf-8")
-            self.assertIn("[Java Preferences]", content)
-
-
-if __name__ == "__main__":
-    unittest.main()

package/codex/learn-skill-from-conversations/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())