ai-session-manager 0.1.3__py3-none-any.whl

ai_session_manager/__init__.py

@@ -0,0 +1 @@
+"""ai-session-manager package."""

ai_session_manager/cli.py

@@ -0,0 +1,281 @@
+"""
+ai-session-manager CLI — manage wrapper-based session persistence for AI CLIs.
+
+Commands:
+  setup     Rename the real tool binary to <tool>-real and install wrappers.
+  teardown  Restore original tool binaries.
+  status    Show installation state for supported tools.
+  reset     Delete persisted wrapper state for supported tools.
+"""
+
+from __future__ import annotations
+
+import argparse
+import platform
+import shutil
+import stat
+import sys
+import textwrap
+from pathlib import Path
+
+from ai_session_manager.wrapper import (
+    LEGACY_FOLDER_SESSION_FILE,
+    LEGACY_REPO_SESSION_FILE,
+    TOOLS,
+    ToolSpec,
+    _legacy_copilot_session_file,
+    _legacy_repo_state_file,
+    _state_file,
+)
+
+
+IS_WINDOWS = platform.system() == "Windows"
+ALL_TOOLS = tuple(sorted(TOOLS))
+TOOL_CHOICES = (*ALL_TOOLS, "all")
+
+_UNIX_WRAPPER = textwrap.dedent(
+    """\
+    #!/usr/bin/env python3
+    # Auto-generated by ai-session-manager setup
+    from ai_session_manager.wrapper import run
+    run({tool_key!r})
+    """
+)
+
+_WINDOWS_CMD_WRAPPER = textwrap.dedent(
+    """\
+    @echo off
+    set "AI_SESSION_MANAGER_REAL_BIN=%~dp0{real_name}"
+    set "AI_SESSION_MANAGER_TOOL={tool_key}"
+    python -c "from ai_session_manager.wrapper import run; run()" %*
+    """
+)
+
+
+def _find_binary(name: str) -> Path | None:
+    found = shutil.which(name)
+    return Path(found) if found else None
+
+
+def _real_bin_path(tool: ToolSpec, binary_path: Path) -> Path:
+    """Return the path where the real binary is stored alongside the wrapper."""
+    if IS_WINDOWS:
+        return binary_path.parent / (binary_path.stem + "-real" + binary_path.suffix)
+    return binary_path.parent / f"{tool.binary_name}-real"
+
+
+def _wrapper_path(binary_path: Path) -> Path:
+    """Return the path of the wrapper file to install."""
+    if IS_WINDOWS:
+        return binary_path.parent / (binary_path.stem + ".cmd")
+    return binary_path
+
+
+def _is_wrapper(path: Path) -> bool:
+    """Return True if the file at path is our wrapper."""
+    try:
+        contents = path.read_text(errors="replace")
+    except OSError:
+        return False
+    return "ai_session_manager.wrapper" in contents
+
+
+def _write_wrapper(tool: ToolSpec, wrapper_path: Path, real_bin: Path) -> None:
+    if IS_WINDOWS:
+        wrapper_path.write_text(
+            _WINDOWS_CMD_WRAPPER.format(real_name=real_bin.name, tool_key=tool.key)
+        )
+        return
+
+    wrapper_path.write_text(_UNIX_WRAPPER.format(tool_key=tool.key))
+    wrapper_path.chmod(real_bin.stat().st_mode | stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH)
+
+
+def _resolve_tools(requested: list[str]) -> list[ToolSpec]:
+    if not requested or "all" in requested:
+        return [TOOLS[name] for name in ALL_TOOLS]
+    return [TOOLS[name] for name in requested]
+
+
+def _tool_header(tool: ToolSpec) -> None:
+    print(f"[{tool.binary_name}]")
+
+
+def cmd_setup(args: argparse.Namespace) -> int:
+    explicit = bool(args.tools and "all" not in args.tools)
+    exit_code = 0
+    processed = 0
+
+    for tool in _resolve_tools(args.tools):
+        _tool_header(tool)
+        binary_path = _find_binary(tool.binary_name)
+        if binary_path is None:
+            print(f"Skipping: '{tool.binary_name}' not found in PATH.")
+            if explicit:
+                exit_code = 1
+            continue
+
+        processed += 1
+        binary_path = binary_path.resolve()
+        real_bin = _real_bin_path(tool, binary_path)
+        wrapper = _wrapper_path(binary_path)
+        wrapper_active = _is_wrapper(wrapper)
+
+        if wrapper_active and real_bin.exists():
+            print(f"Already set up: real binary is {real_bin}")
+            print(f"Wrapper is at:  {wrapper}")
+            continue
+
+        if not wrapper_active and real_bin.exists():
+            print(f"Detected {tool.binary_name} was reinstalled — updating {real_bin.name}.")
+            binary_path.replace(real_bin)
+        elif not wrapper_active:
+            binary_path.rename(real_bin)
+            print(f"Renamed {binary_path.name} -> {real_bin.name}")
+
+        _write_wrapper(tool, wrapper, real_bin)
+        print(f"Wrapper installed at {wrapper}")
+
+    if processed == 0:
+        print("No supported tool binaries were found.")
+        return 1
+    return exit_code
+
+
+def cmd_teardown(args: argparse.Namespace) -> int:
+    explicit = bool(args.tools and "all" not in args.tools)
+    exit_code = 0
+    processed = 0
+
+    for tool in _resolve_tools(args.tools):
+        _tool_header(tool)
+        binary_path = _find_binary(tool.binary_name)
+        if binary_path is None:
+            fallback = _find_binary(f"{tool.binary_name}-real")
+            if fallback is None:
+                print(f"Skipping: neither '{tool.binary_name}' nor '{tool.binary_name}-real' found.")
+                if explicit:
+                    exit_code = 1
+                continue
+            binary_path = fallback
+
+        processed += 1
+        binary_path = binary_path.resolve()
+        if binary_path.name.startswith(f"{tool.binary_name}-real"):
+            real_bin = binary_path
+            wrapper = _wrapper_path(binary_path.with_name(tool.binary_name + binary_path.suffix))
+            restored_binary = binary_path.with_name(tool.binary_name + binary_path.suffix)
+        else:
+            restored_binary = binary_path
+            real_bin = _real_bin_path(tool, binary_path)
+            wrapper = _wrapper_path(binary_path)
+
+        if not real_bin.exists():
+            print("Nothing to undo: real binary not found alongside wrapper.")
+            continue
+
+        wrapper.unlink(missing_ok=True)
+        real_bin.rename(restored_binary)
+        print(f"Restored {real_bin.name} -> {restored_binary.name}")
+
+    if processed == 0:
+        print("No supported tool binaries were found.")
+        return 1
+    return exit_code
+
+
+def cmd_status(args: argparse.Namespace) -> int:
+    for index, tool in enumerate(_resolve_tools(args.tools)):
+        if index:
+            print()
+
+        binary_path = _find_binary(tool.binary_name)
+        real_bin = _find_binary(f"{tool.binary_name}-real")
+        _, state_path, _ = _state_file(tool.key)
+
+        print(f"Tool         : {tool.binary_name}")
+        print(f"Platform     : {platform.system()}")
+        print(f"Binary       : {binary_path or 'not found'}")
+        print(f"Real binary  : {real_bin or 'not found'}")
+        print(f"State file   : {state_path}")
+        print(f"State        : {'present' if state_path.exists() else 'missing'}")
+
+        if binary_path:
+            wrapper = _wrapper_path(binary_path.resolve())
+            if _is_wrapper(wrapper):
+                print("Status       : wrapper active")
+            else:
+                print("Status       : real binary")
+        else:
+            print("Status       : not installed")
+
+    return 0
+
+
+def cmd_reset(args: argparse.Namespace) -> int:
+    for tool in _resolve_tools(args.tools):
+        _tool_header(tool)
+        scope_dir, state_path, scope_kind = _state_file(tool.key)
+        removed_paths: list[Path] = []
+
+        if state_path.exists():
+            state_path.unlink()
+            removed_paths.append(state_path)
+
+        legacy_repo_state_path = _legacy_repo_state_file(tool.key)
+        if legacy_repo_state_path is not None and legacy_repo_state_path.exists():
+            legacy_repo_state_path.unlink()
+            removed_paths.append(legacy_repo_state_path)
+
+        if tool.key == "copilot":
+            legacy_path = _legacy_copilot_session_file()
+            if legacy_path.exists():
+                legacy_path.unlink()
+                removed_paths.append(legacy_path)
+
+        if removed_paths:
+            for removed_path in removed_paths:
+                print(f"Removed: {removed_path}")
+            print(f"Next '{tool.binary_name}' in this {scope_kind} will start fresh.")
+        else:
+            legacy_hint = ""
+            if legacy_repo_state_path is not None:
+                legacy_hint = f" or migrated legacy {legacy_repo_state_path.name}"
+            if tool.key == "copilot":
+                legacy_name = LEGACY_REPO_SESSION_FILE if scope_kind == "repo" else LEGACY_FOLDER_SESSION_FILE
+                legacy_hint = f"{legacy_hint} or legacy {legacy_name}"
+            print(f"No state file found for this {scope_kind}: {scope_dir}{legacy_hint}")
+
+    return 0
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="ai-session-manager",
+        description="Manage per-project session persistence for AI CLI tools.",
+    )
+    sub = parser.add_subparsers(dest="command", metavar="COMMAND")
+
+    for name, help_text in (
+        ("setup", "Install wrappers for supported tools"),
+        ("teardown", "Remove wrappers and restore original binaries"),
+        ("status", "Show current installation state"),
+        ("reset", "Delete persisted wrapper state"),
+    ):
+        subparser = sub.add_parser(name, help=help_text)
+        subparser.add_argument("tools", nargs="*", choices=TOOL_CHOICES, help="Tools to target")
+
+    args = parser.parse_args()
+
+    dispatch = {
+        "setup": cmd_setup,
+        "teardown": cmd_teardown,
+        "status": cmd_status,
+        "reset": cmd_reset,
+    }
+
+    if args.command not in dispatch:
+        parser.print_help()
+        sys.exit(0)
+
+    sys.exit(dispatch[args.command](args))

ai_session_manager/wrapper.py

@@ -0,0 +1,309 @@
+"""Core wrapper logic for supported AI CLI tools."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+import os
+import platform
+import subprocess
+import sys
+import uuid
+from pathlib import Path
+
+
+IS_WINDOWS = platform.system() == "Windows"
+STATE_DIR_NAME = "ai-session-manager"
+LEGACY_REPO_SESSION_FILE = "copilot-session"
+LEGACY_FOLDER_SESSION_FILE = ".copilot-session"
+REAL_BIN_ENV = "AI_SESSION_MANAGER_REAL_BIN"
+TOOL_KEY_ENV = "AI_SESSION_MANAGER_TOOL"
+
+
+@dataclass(frozen=True)
+class ToolSpec:
+    key: str
+    binary_name: str
+    display_name: str
+    session_mode: str
+    resume_args: tuple[str, ...] = ()
+    bypass_flags: frozenset[str] = frozenset()
+    passthrough_commands: frozenset[str] = frozenset()
+
+
+TOOLS = {
+    "agy": ToolSpec(
+        key="agy",
+        binary_name="agy",
+        display_name="Antigravity CLI",
+        session_mode="auto-resume",
+        resume_args=("-c",),
+        bypass_flags=frozenset({"-c", "--conversation"}),
+        passthrough_commands=frozenset({"auth"}),
+    ),
+    "claude": ToolSpec(
+        key="claude",
+        binary_name="claude",
+        display_name="Claude Code",
+        session_mode="auto-resume",
+        resume_args=("-c",),
+        bypass_flags=frozenset({"-c", "--continue", "-r", "--resume"}),
+        passthrough_commands=frozenset({"agents", "attach", "auth", "install", "update"}),
+    ),
+    "codex": ToolSpec(
+        key="codex",
+        binary_name="codex",
+        display_name="Codex",
+        session_mode="auto-resume",
+        resume_args=("resume", "--last"),
+        passthrough_commands=frozenset(
+            {"app", "debug", "exec", "mcp", "resume", "review", "sandbox"}
+        ),
+    ),
+    "copilot": ToolSpec(
+        key="copilot",
+        binary_name="copilot",
+        display_name="GitHub Copilot CLI",
+        session_mode="managed-id",
+        bypass_flags=frozenset(
+            {"--session-id", "--resume", "--continue", "--clear", "-p", "--prompt"}
+        ),
+        passthrough_commands=frozenset({"update"}),
+    ),
+    "gemini": ToolSpec(
+        key="gemini",
+        binary_name="gemini",
+        display_name="Gemini CLI",
+        session_mode="auto-resume",
+        resume_args=("--resume",),
+        bypass_flags=frozenset({"-r", "--resume", "--list-sessions", "--delete-session"}),
+    ),
+}
+
+UNIVERSAL_BYPASS_FLAGS = frozenset({"-h", "--help", "-V", "--version"})
+
+
+def get_tool(tool_key: str) -> ToolSpec:
+    try:
+        return TOOLS[tool_key]
+    except KeyError as exc:
+        raise ValueError(f"Unsupported tool: {tool_key}") from exc
+
+
+def _git_root(cwd: Path | None = None) -> Path | None:
+    """Return the root of the current git repo, or None if not in one."""
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            capture_output=True,
+            text=True,
+            cwd=cwd,
+        )
+    except FileNotFoundError:
+        return None
+
+    if result.returncode == 0:
+        return Path(result.stdout.strip())
+    return None
+
+
+def _state_root(cwd: Path | None = None) -> tuple[Path, Path, str]:
+    """Return the current scope directory, state root, and scope kind."""
+    scope_dir = (cwd or Path.cwd()).resolve()
+    git_root = _git_root(scope_dir)
+    if git_root is not None:
+        return git_root, git_root / f".{STATE_DIR_NAME}", "repo"
+    return scope_dir, scope_dir / f".{STATE_DIR_NAME}", "folder"
+
+
+def _state_file(tool_key: str, cwd: Path | None = None) -> tuple[Path, Path, str]:
+    """Return the scope directory, tool state path, and scope kind."""
+    scope_dir, state_root, scope_kind = _state_root(cwd)
+    return scope_dir, state_root / f"{tool_key}.json", scope_kind
+
+
+def _legacy_repo_state_file(tool_key: str, cwd: Path | None = None) -> Path | None:
+    """Return the previous repo-only state file path, if applicable."""
+    scope_dir = (cwd or Path.cwd()).resolve()
+    git_root = _git_root(scope_dir)
+    if git_root is None:
+        return None
+    return git_root / ".git" / STATE_DIR_NAME / f"{tool_key}.json"
+
+
+def _legacy_copilot_session_file(cwd: Path | None = None) -> Path:
+    """Return the pre-refactor Copilot state file path."""
+    scope_dir = (cwd or Path.cwd()).resolve()
+    git_root = _git_root(scope_dir)
+    if git_root is not None:
+        return git_root / ".git" / LEGACY_REPO_SESSION_FILE
+    return scope_dir / LEGACY_FOLDER_SESSION_FILE
+
+
+def _state_payload(spec: ToolSpec, resume_target: str | None = None) -> dict[str, object]:
+    payload: dict[str, object] = {
+        "version": 1,
+        "tool": spec.key,
+        "session_mode": spec.session_mode,
+    }
+    if resume_target is not None:
+        payload["resume_target"] = resume_target
+    return payload
+
+
+def _write_state(path: Path, payload: dict[str, object]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2) + "\n")
+
+
+def _load_state(spec: ToolSpec, cwd: Path | None = None) -> dict[str, object] | None:
+    _, path, _ = _state_file(spec.key, cwd)
+    if path.exists():
+        return json.loads(path.read_text())
+
+    legacy_repo_path = _legacy_repo_state_file(spec.key, cwd)
+    if legacy_repo_path is not None and legacy_repo_path.exists():
+        payload = json.loads(legacy_repo_path.read_text())
+        _write_state(path, payload)
+        return payload
+
+    if spec.key != "copilot":
+        return None
+
+    legacy_path = _legacy_copilot_session_file(cwd)
+    if not legacy_path.exists():
+        return None
+
+    session_id = legacy_path.read_text().strip()
+    if not session_id:
+        return None
+
+    payload = _state_payload(spec, session_id)
+    _write_state(path, payload)
+    return payload
+
+
+def _create_state(spec: ToolSpec, cwd: Path | None = None) -> dict[str, object]:
+    _, path, _ = _state_file(spec.key, cwd)
+    resume_target = str(uuid.uuid4()) if spec.session_mode == "managed-id" else None
+    payload = _state_payload(spec, resume_target)
+    _write_state(path, payload)
+    return payload
+
+
+def _real_bin_name(spec: ToolSpec, wrapper_path: Path) -> Path:
+    """Return the expected path of the real binary alongside the wrapper."""
+    if IS_WINDOWS:
+        return wrapper_path.parent / (wrapper_path.stem + "-real" + wrapper_path.suffix)
+    return wrapper_path.parent / f"{spec.binary_name}-real"
+
+
+def _find_real_binary(spec: ToolSpec) -> str:
+    """
+    Find the real tool binary by checking a sibling '<tool>-real' first, then PATH.
+    """
+    script_path = Path(sys.argv[0]).resolve()
+    sibling = _real_bin_name(spec, script_path)
+    if sibling.exists() and os.access(sibling, os.X_OK):
+        return str(sibling)
+
+    candidates = [f"{spec.binary_name}-real.exe", f"{spec.binary_name}-real"]
+    if not IS_WINDOWS:
+        candidates = [f"{spec.binary_name}-real"]
+
+    for directory in os.environ.get("PATH", "").split(os.pathsep):
+        for name in candidates:
+            candidate = Path(directory) / name
+            if candidate.exists() and os.access(candidate, os.X_OK):
+                return str(candidate)
+
+    raise FileNotFoundError(
+        f"Cannot find '{spec.binary_name}-real'. Run 'ai-session-manager setup {spec.key}' first."
+    )
+
+
+def _first_positional_arg(args: list[str]) -> str | None:
+    for arg in args:
+        if arg == "--":
+            return None
+        if not arg.startswith("-") or arg == "-":
+            return arg
+    return None
+
+
+def _should_bypass(spec: ToolSpec, args: list[str]) -> bool:
+    for arg in args:
+        base = arg.split("=", 1)[0]
+        if base in UNIVERSAL_BYPASS_FLAGS or base in spec.bypass_flags:
+            return True
+
+    first_positional = _first_positional_arg(args)
+    return first_positional in spec.passthrough_commands
+
+
+def _resume_invocation(spec: ToolSpec, state: dict[str, object], user_args: list[str]) -> list[str]:
+    if spec.session_mode == "managed-id":
+        resume_target = state["resume_target"]
+        return ["--session-id", str(resume_target), *user_args]
+    return [*spec.resume_args, *user_args]
+
+
+def _exec(real: str, args: list[str]) -> None:
+    """Replace the current process with the real tool (Unix) or spawn it (Windows)."""
+    if IS_WINDOWS:
+        result = subprocess.run([real] + args)
+        sys.exit(result.returncode)
+    os.execv(real, [real] + args)
+
+
+def _tool_from_invocation(tool_key: str | None) -> ToolSpec:
+    if tool_key is not None:
+        return get_tool(tool_key)
+
+    env_tool = os.environ.get(TOOL_KEY_ENV)
+    if env_tool:
+        return get_tool(env_tool)
+
+    script_name = Path(sys.argv[0]).stem
+    return get_tool(script_name)
+
+
+def run(tool_key: str | None = None) -> None:
+    """Entry point for installed tool wrappers."""
+    spec = _tool_from_invocation(tool_key)
+    real = os.environ.get(REAL_BIN_ENV) or _find_real_binary(spec)
+    user_args = sys.argv[1:]
+
+    if _should_bypass(spec, user_args):
+        _exec(real, user_args)
+        return
+
+    scope_dir, _, _scope_kind = _state_file(spec.key)
+    state = _load_state(spec)
+
+    if state is None:
+        state = _create_state(spec)
+        if spec.session_mode == "managed-id":
+            session_id = str(state["resume_target"])
+            print(f"[ai-session-manager] New session {session_id} ({scope_dir.name})", flush=True)
+            _exec(real, _resume_invocation(spec, state, user_args))
+            return
+
+        print(
+            f"[ai-session-manager] Starting new {spec.display_name} session ({scope_dir.name})",
+            flush=True,
+        )
+        _exec(real, user_args)
+        return
+
+    if spec.session_mode == "managed-id":
+        session_id = str(state["resume_target"])
+        print(f"[ai-session-manager] Resuming session {session_id} ({scope_dir.name})", flush=True)
+    else:
+        print(
+            f"[ai-session-manager] Resuming latest {spec.display_name} session ({scope_dir.name})",
+            flush=True,
+        )
+
+    _exec(real, _resume_invocation(spec, state, user_args))
+    return

ai_session_manager-0.1.3.dist-info/METADATA

@@ -0,0 +1,231 @@
+Metadata-Version: 2.4
+Name: ai-session-manager
+Version: 0.1.3
+Summary: Per-project session persistence for AI CLI tools
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/DrFatihTekin/ai-session-manager
+Project-URL: Repository, https://github.com/DrFatihTekin/ai-session-manager
+Keywords: ai,cli,session,wrapper,copilot,claude,codex,gemini
+Classifier: Environment :: Console
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ai-session-manager
+
+> Per-project session persistence for AI CLI tools.
+
+`ai-session-manager` adds automatic project-scoped resume behavior to supported AI CLIs so you can leave a project and come back without manually reopening the right conversation.
+
+Works on **Linux**, **macOS**, and **Windows**.
+
+> [!WARNING]
+> This tool renames installed CLI binaries and replaces them with wrapper scripts. Use it at your own risk, and make sure you understand how to restore the original binaries with `ai-session-manager teardown`.
+
+---
+
+## Why
+
+Most AI CLIs support sessions, but they do not all resume the same way and they do not all make project-scoped resume automatic. This project adds one consistent wrapper layer across tools.
+
+Today it supports:
+
+| Tool | Auto-resume behavior |
+|---|---|
+| `agy` | After first run, launches `agy -c` in the same project |
+| `copilot` | Stores a stable session UUID and launches `copilot --session-id <uuid>` |
+| `claude` | After first run, launches `claude -c` in the same project |
+| `gemini` | After first run, launches `gemini --resume` in the same project |
+| `codex` | After first run, launches `codex resume --last` in the same project |
+
+Project-scoped state lives in:
+
+- `.ai-session-manager/` inside the project root, whether it is a git repo or a plain folder
+
+Existing state is still recognized and migrated from:
+
+- `.git/ai-session-manager/`
+
+Copilot legacy state is also recognized and migrated from:
+
+- `.git/copilot-session`
+- `.copilot-session`
+
+---
+
+## Requirements
+
+- Python 3.8+
+- One or more supported CLIs installed: Antigravity, Copilot, Claude Code, Gemini CLI, or Codex CLI
+
+---
+
+## Installation
+
+```bash
+pip install --editable ~/ai-session-manager
+```
+
+Once published:
+
+```bash
+pip install ai-session-manager
+```
+
+---
+
+## Setup
+
+Install wrappers for every supported tool found in `PATH`:
+
+```bash
+ai-session-manager setup
+```
+
+Or target specific tools:
+
+```bash
+ai-session-manager setup agy copilot claude gemini codex
+```
+
+Each selected binary is renamed to `<tool>-real` and replaced with a thin Python wrapper. From that point on, keep using the original command name.
+
+---
+
+## Usage
+
+### Copilot
+
+```bash
+cd ~/my-project
+copilot
+# [ai-session-manager] New session 4f1a2b3c-... (my-project)
+
+cd ~/my-project
+copilot
+# [ai-session-manager] Resuming session 4f1a2b3c-... (my-project)
+```
+
+### AGY / Claude / Gemini / Codex
+
+```bash
+agy
+# [ai-session-manager] Starting new Antigravity CLI session (my-project)
+agy
+# [ai-session-manager] Resuming latest Antigravity CLI session (my-project)
+
+claude
+# [ai-session-manager] Starting new Claude Code session (my-project)
+claude
+# [ai-session-manager] Resuming latest Claude Code session (my-project)
+
+gemini
+# [ai-session-manager] Starting new Gemini CLI session (my-project)
+gemini
+# [ai-session-manager] Resuming latest Gemini CLI session (my-project)
+
+codex
+# [ai-session-manager] Starting new Codex session (my-project)
+codex
+# [ai-session-manager] Resuming latest Codex session (my-project)
+```
+
+Supported tools are still fully usable with their own native session commands. If you pass an explicit resume or session-management flag/subcommand, the wrapper gets out of the way.
+
+For example:
+
+```bash
+agy --conversation 123e4567-e89b-12d3-a456-426614174000
+copilot --resume
+claude -r my-session
+gemini --list-sessions
+codex resume --last
+```
+
+### Start fresh in the current project
+
+```bash
+ai-session-manager reset
+```
+
+Or reset one tool only:
+
+```bash
+ai-session-manager reset claude
+```
+
+---
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `ai-session-manager setup [tools...]` | Install wrappers for all detected or selected tools |
+| `ai-session-manager teardown [tools...]` | Remove wrappers and restore original binaries |
+| `ai-session-manager status [tools...]` | Show platform, binary paths, and state files |
+| `ai-session-manager reset [tools...]` | Delete persisted wrapper state for the current project |
+
+---
+
+## State layout
+
+```text
+project root:
+  .ai-session-manager/
+    copilot.json
+    claude.json
+    codex.json
+    gemini.json
+    agy.json
+```
+
+Copilot stores a generated UUID in its state file. The other tools use the file as an on/off marker that tells the wrapper to invoke the tool's native resume-latest behavior on future launches.
+
+### Platform details
+
+| | Linux | macOS | Windows |
+|---|---|---|---|
+| Wrapper file | tool name (shebang script) | tool name (shebang script) | tool `.cmd` wrapper |
+| Real binary | `<tool>-real` | `<tool>-real` | `<tool>-real.exe` or `<tool>-real.cmd` |
+| Process launch | `os.execv` (true replace) | `os.execv` (true replace) | `subprocess` + exit code |
+
+### Project structure
+
+```text
+ai-session-manager/
+├── pyproject.toml
+├── README.md
+└── src/
+    ├── ai_session_manager/
+    │   ├── wrapper.py
+    │   └── cli.py
+```
+
+---
+
+## Reinstalling a tool CLI
+
+If a wrapped tool is manually reinstalled and overwrites the wrapper, run setup again:
+
+```bash
+ai-session-manager setup copilot
+```
+
+---
+
+## Uninstall
+
+```bash
+ai-session-manager teardown
+pip uninstall ai-session-manager
+```
+
+---
+
+## License
+
+MIT

ai_session_manager-0.1.3.dist-info/RECORD

@@ -0,0 +1,9 @@
+ai_session_manager/__init__.py,sha256=yO7GoVFttbdGZxf5qcy1BGl-6re28L3aWEpLHpH9GFo,34
+ai_session_manager/cli.py,sha256=0wRXtO3QHKXm5jjz5wDVa6TAr6LmdKPIJXkTg__lXMg,9279
+ai_session_manager/wrapper.py,sha256=6z4cUJobhpt3kQLYPBF1m0Q8qpnxt1kUuqUUy6BXBlg,9978
+ai_session_manager-0.1.3.dist-info/licenses/LICENSE,sha256=uzvGcd0cdmgZarGW6VSFAeXEGuZpgCOzYE_dZtaM9oo,1068
+ai_session_manager-0.1.3.dist-info/METADATA,sha256=y9xrk5Nxyzgtg5zPo7jc1dNsY_BnvAs_5ru5I0PFRdU,5782
+ai_session_manager-0.1.3.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+ai_session_manager-0.1.3.dist-info/entry_points.txt,sha256=9uYte5zEfbPt8tyDg2rDHyu7SwalIGad2XaNgwUgUfM,67
+ai_session_manager-0.1.3.dist-info/top_level.txt,sha256=KghIz3mtpyywCdG0DdTwU97zI_A_YbI43mSE9uQRlHI,19
+ai_session_manager-0.1.3.dist-info/RECORD,,

ai_session_manager-0.1.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ai_session_manager-0.1.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ai-session-manager = ai_session_manager.cli:main

ai_session_manager-0.1.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fatih Tekin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ai_session_manager-0.1.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+ai_session_manager