aline-ai 0.1.0__py3-none-any.whl

aline_ai-0.1.0.dist-info/METADATA

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: aline-ai
+Version: 0.1.0
+Summary: Shared AI memory; everyone knows everything in teams
+Author: Sharemind
+License: MIT
+Project-URL: Homepage, https://github.com/human-re/aline
+Project-URL: Repository, https://github.com/human-re/aline
+Project-URL: Documentation, https://github.com/human-re/aline#readme
+Project-URL: Bug Tracker, https://github.com/human-re/aline/issues
+Keywords: ai,agent,chat,history,mcp,claude,session-tracking,context-preservation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+License-File: LICENSE
+Requires-Dist: typer>=0.9.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: anthropic>=0.18.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: detect-secrets>=1.4.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: bump-my-version>=0.26.0; extra == "dev"
+Dynamic: license-file

aline_ai-0.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+aline_ai-0.1.0.dist-info/licenses/LICENSE,sha256=H8wTqV5IF1oHw_HbBtS1PSDU8G_q81yblEIL_JfV8Vo,1077
+realign/__init__.py,sha256=yt4R6O6rr0ImHHhNF1YOZbJxsINC7-45rDxl0OXK7ig,68
+realign/claude_detector.py,sha256=NLxI0zJWcqNxNha9jAy9AslTMwHKakCc9yPGdkrbiFE,3028
+realign/cli.py,sha256=bkwS329jMDEkrUEihXRN2DDyeTKE6HbAysoDxxskZ8g,941
+realign/codex_detector.py,sha256=RI3JbZgebrhoqpRfTBMfclYCAISN7hZAHVW3bgftJpU,4428
+realign/config.py,sha256=jarinbr0mA6e5DmgY19b_VpMnxk6SOYTwyvB9luq0ww,7207
+realign/hooks.py,sha256=qhAeuln_62OgTq0vboZcUAuP2apOrNn58vSZqKwNmWQ,36456
+realign/logging_config.py,sha256=KvkKktF-bkUu031y9vgUoHpsbnOw7ud25jhpzliNZwA,4929
+realign/mcp_server.py,sha256=NaT1c7dCNfOvmBPkBMpWI63wqmJQ3wQP2MiMqNUmFIQ,15346
+realign/mcp_watcher.py,sha256=AN5skK8qoVkXLCABkAsEcWC7lx2zJi24lwJQSXn2Ixk,13143
+realign/redactor.py,sha256=uZvLKKGrRGJm-qM8S4XJyJK6i0CSSby_wbKiay7VGJw,8148
+realign/commands/__init__.py,sha256=GG6IMw6fUBQAXGJDFJvOOQgv6pkiRSfMh8z3AYXTyRM,31
+realign/commands/auto_commit.py,sha256=_DOw7nt9q3tD_Y3qDL9IFKAUG1hM4qH_xZ-9nyBc2Bc,7451
+realign/commands/commit.py,sha256=_A2znDOLldtlkB4RfAc-otLa0soOYv5SSQgtKq7Qbk4,6580
+realign/commands/config.py,sha256=oarvn6UuGT8svd2h5_8M_ueV5QWOCUOn8SYoa4XYjs8,6500
+realign/commands/init.py,sha256=EpSzh2Dd2EmEQ_wo3vAsg6Uq7_YOlQWIpzIkZa_2y0A,11863
+realign/commands/search.py,sha256=0CZaXll99wtd01MRiZk5NAblxgogc4RUAzMyJunvckE,18044
+realign/commands/show.py,sha256=P1waa94-AKJr9XjagkE40OHMXzE6IwC74DpeDKqwsqw,16693
+aline_ai-0.1.0.dist-info/METADATA,sha256=ZVUw6gLA1LJr34rmE7uVtdylss85X6PgGwBHRU17mGY,1398
+aline_ai-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aline_ai-0.1.0.dist-info/entry_points.txt,sha256=h-NocHDzSueXfsepHTIdRPNQzhNZQPAztJfldd-mQTE,202
+aline_ai-0.1.0.dist-info/top_level.txt,sha256=yIL3s2xv9nf1GwD5n71Aq_JEIV4AfzCIDNKBzewuRm4,8
+aline_ai-0.1.0.dist-info/RECORD,,

aline_ai-0.1.0.dist-info/WHEEL

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

aline_ai-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+aline = realign.cli:app
+aline-hook-pre-commit = realign.hooks:pre_commit_hook
+aline-hook-prepare-commit-msg = realign.hooks:prepare_commit_msg_hook
+aline-mcp = realign.mcp_server:main

aline_ai-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ReAlign Contributors
+
+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.

aline_ai-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+realign

realign/__init__.py

@@ -0,0 +1,3 @@
+"""Aline - AI Agent Chat Session Tracker."""
+
+__version__ = "0.1.0"

realign/claude_detector.py

@@ -0,0 +1,99 @@
+"""Utility functions for detecting and integrating with Claude Code."""
+
+import os
+from pathlib import Path
+from typing import Optional
+
+
+def get_claude_project_name(project_path: Path) -> str:
+    """
+    Convert a project path to Claude Code's project directory name format.
+
+    Claude Code transforms project paths by replacing '/' with '-' (excluding root '/').
+    For example: /Users/alice/Projects/MyApp -> -Users-alice-Projects-MyApp
+
+    Args:
+        project_path: The absolute path to the project
+
+    Returns:
+        The transformed project name used by Claude Code
+    """
+    # Convert to absolute path and normalize
+    abs_path = project_path.resolve()
+
+    # Convert path to string and replace separators
+    # Remove leading '/' and replace all '/' and '_' with '-'
+    # Claude Code replaces both slashes and underscores with dashes
+    path_str = str(abs_path)
+    if path_str.startswith('/'):
+        path_str = path_str[1:]
+
+    return '-' + path_str.replace('/', '-').replace('_', '-')
+
+
+def find_claude_sessions_dir(project_path: Path) -> Optional[Path]:
+    """
+    Find the Claude Code sessions directory for a given project path.
+
+    Claude Code stores project sessions in:
+    ~/.claude/projects/{project_name}/
+
+    where project_name is the project path with '/' replaced by '-'.
+
+    Args:
+        project_path: The absolute path to the project
+
+    Returns:
+        Path to the Claude sessions directory if it exists, None otherwise
+    """
+    # Get Claude base directory
+    claude_base = Path.home() / ".claude" / "projects"
+
+    if not claude_base.exists():
+        return None
+
+    # Get the project name in Claude's format
+    project_name = get_claude_project_name(project_path)
+
+    # Check if the project directory exists
+    claude_project_dir = claude_base / project_name
+
+    if claude_project_dir.exists() and claude_project_dir.is_dir():
+        return claude_project_dir
+
+    return None
+
+
+def auto_detect_sessions_path(project_path: Path, fallback_path: Optional[str] = None) -> Path:
+    """
+    Auto-detect the best sessions path to use.
+
+    Priority:
+    1. REALIGN_LOCAL_HISTORY_PATH environment variable
+    2. Claude Code sessions directory (if exists)
+    3. fallback_path parameter (if provided)
+    4. Default: ~/.local/share/realign/histories
+
+    Args:
+        project_path: The absolute path to the project
+        fallback_path: Optional fallback path if auto-detection fails
+
+    Returns:
+        Path to use for session history
+    """
+    # Check environment variable first (highest priority)
+    env_path = os.getenv("REALIGN_LOCAL_HISTORY_PATH")
+    if env_path:
+        return Path(os.path.expanduser(env_path))
+
+    # Try to find Claude sessions directory
+    claude_dir = find_claude_sessions_dir(project_path)
+    if claude_dir:
+        return claude_dir
+
+    # Use fallback if provided
+    if fallback_path:
+        return Path(os.path.expanduser(fallback_path))
+
+    # Default path
+    return Path.home() / ".local" / "share" / "realign" / "histories"

realign/cli.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+"""ReAlign CLI - Main command-line interface."""
+
+import typer
+from pathlib import Path
+from typing import Optional
+from rich.console import Console
+from rich.syntax import Syntax
+
+from .commands import init, search, show, config, commit, auto_commit
+
+app = typer.Typer(
+    name="realign",
+    help="Track and version AI agent chat sessions with git commits",
+    add_completion=False,
+)
+console = Console()
+
+# Register commands
+app.command(name="init")(init.init_command)
+app.command(name="search")(search.search_command)
+app.command(name="show")(show.show_command)
+app.command(name="config")(config.config_command)
+app.command(name="commit")(commit.commit_command)
+app.command(name="auto-commit")(auto_commit.auto_commit_command)
+
+
+@app.command()
+def version():
+    """Show ReAlign version."""
+    from . import __version__
+    console.print(f"ReAlign version {__version__}")
+
+
+if __name__ == "__main__":
+    app()

realign/codex_detector.py

@@ -0,0 +1,131 @@
+"""Utility functions for detecting and integrating with Codex."""
+
+import json
+import os
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Optional, List
+
+
+def find_codex_sessions_for_project(
+    project_path: Path,
+    days_back: int = 7
+) -> List[Path]:
+    """
+    Find Codex sessions for a given project path.
+
+    Codex stores sessions in ~/.codex/sessions/{YYYY}/{MM}/{DD}/
+    with all projects mixed together. We need to search by date
+    and filter by the 'cwd' field in session metadata.
+
+    Args:
+        project_path: The absolute path to the project
+        days_back: Number of days to look back (default: 7)
+
+    Returns:
+        List of session file paths that match the project, sorted by timestamp (newest first)
+    """
+    codex_sessions_base = Path.home() / ".codex" / "sessions"
+
+    if not codex_sessions_base.exists():
+        return []
+
+    # Normalize project path for comparison
+    abs_project_path = str(project_path.resolve())
+
+    matching_sessions = []
+
+    # Search through recent days
+    for days_ago in range(days_back + 1):
+        target_date = datetime.now() - timedelta(days=days_ago)
+        date_path = codex_sessions_base / str(target_date.year) / f"{target_date.month:02d}" / f"{target_date.day:02d}"
+
+        if not date_path.exists():
+            continue
+
+        # Check all session files in this date directory
+        for session_file in date_path.glob("rollout-*.jsonl"):
+            try:
+                # Read first line to get session metadata
+                with open(session_file, 'r', encoding='utf-8') as f:
+                    first_line = f.readline()
+                    if first_line:
+                        data = json.loads(first_line)
+                        if data.get('type') == 'session_meta':
+                            session_cwd = data.get('payload', {}).get('cwd', '')
+                            # Match the project path
+                            if session_cwd == abs_project_path:
+                                matching_sessions.append(session_file)
+            except (json.JSONDecodeError, IOError):
+                # Skip malformed or unreadable files
+                continue
+
+    # Sort by modification time, newest first
+    matching_sessions.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+
+    return matching_sessions
+
+
+def get_latest_codex_session(project_path: Path, days_back: int = 7) -> Optional[Path]:
+    """
+    Get the most recent Codex session for a given project.
+
+    Args:
+        project_path: The absolute path to the project
+        days_back: Number of days to look back (default: 7)
+
+    Returns:
+        Path to the most recent session file, or None if not found
+    """
+    sessions = find_codex_sessions_for_project(project_path, days_back)
+    return sessions[0] if sessions else None
+
+
+def get_codex_sessions_dir() -> Optional[Path]:
+    """
+    Get the Codex sessions base directory if it exists.
+
+    Returns:
+        Path to ~/.codex/sessions if it exists, None otherwise
+    """
+    codex_sessions = Path.home() / ".codex" / "sessions"
+    return codex_sessions if codex_sessions.exists() else None
+
+
+def auto_detect_codex_sessions(
+    project_path: Path,
+    fallback_path: Optional[str] = None,
+    days_back: int = 7
+) -> Optional[Path]:
+    """
+    Auto-detect the most recent Codex session for a project.
+
+    Priority:
+    1. REALIGN_LOCAL_HISTORY_PATH environment variable (disables auto-detection)
+    2. Most recent Codex session matching project path
+    3. fallback_path parameter (if provided)
+    4. Default: None (let caller decide fallback)
+
+    Args:
+        project_path: The absolute path to the project
+        fallback_path: Optional fallback path if auto-detection fails
+        days_back: Number of days to look back for sessions (default: 7)
+
+    Returns:
+        Path to use for session history, or None if not found
+    """
+    # Check environment variable first (highest priority, disables auto-detection)
+    env_path = os.getenv("REALIGN_LOCAL_HISTORY_PATH")
+    if env_path:
+        return Path(os.path.expanduser(env_path))
+
+    # Try to find the latest Codex session for this project
+    latest_session = get_latest_codex_session(project_path, days_back)
+    if latest_session:
+        return latest_session
+
+    # Use fallback if provided
+    if fallback_path:
+        return Path(os.path.expanduser(fallback_path))
+
+    return None

realign/commands/__init__.py

@@ -0,0 +1 @@
+"""ReAlign commands module."""

realign/commands/auto_commit.py

@@ -0,0 +1,231 @@
+"""ReAlign auto-commit command - Automatically commit after each chat round."""
+
+import os
+import subprocess
+import time
+from pathlib import Path
+from typing import Optional, Set
+import typer
+from rich.console import Console
+from rich.live import Live
+from rich.panel import Panel
+from rich.text import Text
+
+from ..config import ReAlignConfig
+from ..hooks import find_all_active_sessions
+from ..commands.init import init_command
+from ..commands.commit import commit_command as manual_commit
+
+console = Console()
+
+
+def is_realign_initialized() -> bool:
+    """Check if ReAlign is initialized in the current repository."""
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        repo_root = Path(result.stdout.strip())
+
+        # Check if .realign directory exists
+        realign_dir = repo_root / ".realign"
+        if not realign_dir.exists():
+            return False
+
+        # Check if hooks are installed
+        result = subprocess.run(
+            ["git", "config", "core.hooksPath"],
+            capture_output=True,
+            text=True,
+        )
+        hooks_path = result.stdout.strip()
+
+        return ".realign/hooks" in hooks_path
+    except subprocess.CalledProcessError:
+        return False
+
+
+def auto_initialize():
+    """Automatically initialize ReAlign if not already initialized."""
+    if not is_realign_initialized():
+        console.print("[yellow]⚙️  ReAlign not initialized. Initializing...[/yellow]")
+        try:
+            # Call init command with auto-yes
+            result = subprocess.run(
+                ["realign", "init", "--yes"],
+                capture_output=True,
+                text=True,
+            )
+            if result.returncode == 0:
+                console.print("[green]✓[/green] ReAlign initialized successfully")
+                return True
+            else:
+                console.print(f"[red]✗[/red] Failed to initialize ReAlign:\n{result.stderr}")
+                return False
+        except Exception as e:
+            console.print(f"[red]✗[/red] Error initializing ReAlign: {e}")
+            return False
+    return True
+
+
+def get_session_mtimes(repo_root: Path) -> dict:
+    """Get modification times for all active session files."""
+    config = ReAlignConfig.load()
+    session_files = find_all_active_sessions(config, repo_root)
+
+    mtimes = {}
+    for session_file in session_files:
+        if session_file.exists():
+            mtimes[str(session_file)] = session_file.stat().st_mtime
+
+    return mtimes
+
+
+def generate_commit_message() -> str:
+    """Generate an automatic commit message."""
+    from datetime import datetime
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    return f"chore: Auto-commit chat session ({timestamp})"
+
+
+def auto_commit_once(repo_root: Path, message: Optional[str] = None, silent: bool = False) -> bool:
+    """
+    Perform a single auto-commit.
+
+    Args:
+        repo_root: Path to the repository root
+        message: Custom commit message (auto-generated if not provided)
+        silent: If True, suppress console output (for watcher mode)
+
+    Returns:
+        True if commit was successful, False otherwise
+    """
+    commit_message = message or generate_commit_message()
+
+    try:
+        # Stage all changes including sessions
+        subprocess.run(
+            ["git", "add", "-A"],
+            cwd=repo_root,
+            check=True,
+            capture_output=True,
+        )
+
+        # Run realign commit
+        result = subprocess.run(
+            ["realign", "commit", "-m", commit_message],
+            cwd=repo_root,
+            capture_output=True,
+            text=True,
+        )
+
+        if result.returncode == 0:
+            if not silent:
+                console.print(f"[green]✓[/green] Auto-committed: {commit_message}")
+            return True
+        else:
+            # Check if it's just "no changes" error
+            if "No changes detected" in result.stdout or "No changes detected" in result.stderr:
+                if not silent:
+                    console.print("[dim]No changes to commit[/dim]")
+                return True
+            else:
+                if not silent:
+                    console.print(f"[red]✗[/red] Commit failed:\n{result.stderr}")
+                return False
+    except subprocess.CalledProcessError as e:
+        if not silent:
+            console.print(f"[red]✗[/red] Error during commit: {e}")
+        return False
+
+
+def auto_commit_command(
+    watch: bool = typer.Option(
+        False,
+        "--watch",
+        "-w",
+        help="Watch for changes and auto-commit continuously"
+    ),
+    interval: int = typer.Option(
+        5,
+        "--interval",
+        "-i",
+        help="Check interval in seconds (default: 5)"
+    ),
+    message: Optional[str] = typer.Option(
+        None,
+        "--message",
+        "-m",
+        help="Custom commit message (auto-generated if not provided)"
+    ),
+):
+    """
+    Automatically commit after each chat round.
+
+    By default, performs a single commit. Use --watch to continuously monitor
+    and commit changes as they happen.
+    """
+    # Check if in git repository
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        repo_root = Path(result.stdout.strip())
+    except subprocess.CalledProcessError:
+        console.print("[red]Error: Not in a git repository[/red]")
+        raise typer.Exit(1)
+
+    # Auto-initialize if needed
+    if not auto_initialize():
+        console.print("[red]Failed to initialize ReAlign[/red]")
+        raise typer.Exit(1)
+
+    if not watch:
+        # Single commit mode
+        console.print("[cyan]🔄 Performing auto-commit...[/cyan]")
+        success = auto_commit_once(repo_root, message)
+        if success:
+            console.print("[green]✓[/green] Done")
+        else:
+            raise typer.Exit(1)
+        return
+
+    # Watch mode
+    console.print("[cyan]👁️  Watching for session changes...[/cyan]")
+    console.print(f"[dim]   Check interval: {interval} seconds[/dim]")
+    console.print("[dim]   Press Ctrl+C to stop[/dim]\n")
+
+    # Track last known modification times
+    last_mtimes = get_session_mtimes(repo_root)
+    commit_count = 0
+
+    try:
+        while True:
+            time.sleep(interval)
+
+            # Check for changes
+            current_mtimes = get_session_mtimes(repo_root)
+
+            # Detect if any session file was modified
+            has_changes = False
+            for session_path, mtime in current_mtimes.items():
+                if session_path not in last_mtimes or last_mtimes[session_path] < mtime:
+                    has_changes = True
+                    console.print(f"[yellow]📝 Session change detected: {Path(session_path).name}[/yellow]")
+                    break
+
+            if has_changes:
+                console.print("[cyan]🔄 Auto-committing...[/cyan]")
+                if auto_commit_once(repo_root, message):
+                    commit_count += 1
+                    console.print(f"[green]✓[/green] Total commits: {commit_count}\n")
+                last_mtimes = current_mtimes
+
+    except KeyboardInterrupt:
+        console.print(f"\n[cyan]👋 Stopped watching. Total commits: {commit_count}[/cyan]")