aline-ai 0.5.1__py3-none-any.whl → 0.5.4__py3-none-any.whl

realign/commands/add.py

@@ -251,10 +251,233 @@ Use this skill when the user wants to:
 - Send Slack updates about completed work
 """
 
+# Aline Import History Sessions skill definition for Claude Code
+# Installed to ~/.claude/skills/aline-import-history-sessions/SKILL.md
+ALINE_IMPORT_HISTORY_SESSIONS_SKILL_MD = """---
+name: aline-import-history-sessions
+description: Guide users through importing Claude Code session history into Aline database. Use this for first-time setup, onboarding new users, or when users want to selectively import historical sessions. Provides interactive workflow with progress checking.
+---
+
+# Aline Import History Sessions Skill
+
+This skill guides users through the process of importing Claude Code session history into Aline's database. It provides an interactive, step-by-step workflow to help users discover, select, and import their historical sessions.
+
+## Workflow Overview
+
+```
+Analyze Unimported Sessions → Present Summary → User Selection → Import Sessions → Verify Success → Continue or Finish
+```
+
+## Step-by-Step Guide
+
+### Step 1: Analyze Current Status
+
+First, list all sessions to understand what hasn't been imported yet:
+
+```bash
+aline watcher session list --detect-turns
+```
+
+**Internal analysis (do NOT expose status terminology to user):**
+- Count sessions with status `new` → these are "unimported sessions"
+- Count sessions with status `partial` → these have "updates available"
+- Count sessions with status `tracked` → these are "already imported"
+
+Parse the output to extract:
+- Total number of unimported sessions
+- Their session IDs (use these for import, NOT index numbers)
+- Project paths they belong to
+
+### Step 2: Present Summary to User
+
+Present a user-friendly summary WITHOUT mentioning internal status labels:
+
+Example:
+> "I found **47 sessions** in your Claude Code history:
+> - **12 sessions** haven't been imported yet
+> - **3 sessions** have updates since last import
+> - **32 sessions** are already fully imported
+>
+> The unimported sessions span these projects:
+> - `/Users/you/Projects/ProjectA` (5 sessions)
+> - `/Users/you/Projects/ProjectB` (7 sessions)"
+
+### Step 3: Ask User Import Preferences
+
+Use `AskUserQuestion` to understand what the user wants to import:
+
+```json
+{
+  "questions": [{
+    "header": "Import scope",
+    "question": "Which sessions would you like to import?",
+    "options": [
+      {"label": "All unimported (Recommended)", "description": "Import all 12 sessions that haven't been imported yet"},
+      {"label": "Include updates", "description": "Import unimported sessions + update 3 sessions with new content"},
+      {"label": "Select by project", "description": "Choose which project's sessions to import"},
+      {"label": "Select specific", "description": "I'll review and pick individual sessions"}
+    ],
+    "multiSelect": false
+  }]
+}
+```
+
+### Step 4: Handle User Selection
+
+#### If "All unimported":
+Confirm the import with session count:
+```json
+{
+  "questions": [{
+    "header": "Confirm",
+    "question": "Ready to import 12 sessions. Proceed?",
+    "options": [
+      {"label": "Yes, import", "description": "Start importing all unimported sessions"},
+      {"label": "Let me review first", "description": "Show me the session list to review"}
+    ],
+    "multiSelect": false
+  }]
+}
+```
+
+#### If "Select by project":
+List the projects with unimported sessions and ask:
+```json
+{
+  "questions": [{
+    "header": "Project",
+    "question": "Which project's sessions should I import?",
+    "options": [
+      {"label": "ProjectA", "description": "5 unimported sessions"},
+      {"label": "ProjectB", "description": "7 unimported sessions"},
+      {"label": "Current directory", "description": "Import sessions from the current working directory"}
+    ],
+    "multiSelect": true
+  }]
+}
+```
+
+#### If "Select specific":
+Show the session list with details (project path, turn count, last modified) and let user specify which ones. When user provides selection, map their choice back to session IDs.
+
+### Step 5: Execute Import
+
+**IMPORTANT: Always use session_id for imports, NOT index numbers.** Index numbers can change between list operations and cause wrong sessions to be imported.
+
+```bash
+# Import by session ID (PREFERRED - always use this)
+aline watcher session import abc12345-6789-...
+
+# Import multiple by session ID
+aline watcher session import abc12345,def67890,ghi11111
+
+# With force flag (re-import already tracked)
+aline watcher session import abc12345 --force
+
+# With regenerate flag (update summaries)
+aline watcher session import abc12345 --regenerate
+
+# Synchronous import to wait for completion
+aline watcher session import abc12345 --sync
+```
+
+For importing multiple sessions, collect all the session IDs from your analysis and pass them comma-separated.
+
+### Step 6: Verify Import Success
+
+After import, check the status again:
+
+```bash
+aline watcher session list --detect-turns
+```
+
+Verify:
+- Previously unimported sessions should now show as imported
+- Check for any errors in the import output
+- Report success/failure count to user
+
+### Step 7: Ask If User Is Satisfied
+
+```json
+{
+  "questions": [{
+    "header": "Continue?",
+    "question": "Successfully imported X sessions. What would you like to do next?",
+    "options": [
+      {"label": "Import more", "description": "Select additional sessions to import"},
+      {"label": "View imported", "description": "Show details of imported sessions"},
+      {"label": "Done", "description": "Finish the import process"}
+    ],
+    "multiSelect": false
+  }]
+}
+```
+
+If user wants to import more, loop back to Step 1.
+
+### Step 8: Final Summary
+
+When the user is done, provide a summary:
+- Total sessions imported in this session
+- Sessions that were updated
+- Any errors encountered
+- Next steps: suggest `aline search` to explore their imported history
+
+## Command Reference
+
+| Command | Purpose |
+|---------|---------|
+| `aline watcher session list` | List all discovered sessions with status |
+| `aline watcher session list --detect-turns` | Include turn counts in listing |
+| `aline watcher session list -p N -n M` | Paginate: page N with M items per page |
+| `aline watcher session import <session_id>` | Import by session ID (recommended) |
+| `aline watcher session import <id1>,<id2>` | Import multiple sessions by ID |
+| `aline watcher session import <id> -f` | Force re-import |
+| `aline watcher session import <id> -r` | Regenerate LLM summaries |
+| `aline watcher session import <id> --sync` | Synchronous import (wait for completion) |
+| `aline watcher session show <session_id>` | View details of a specific session |
+
+## Important: Use Session IDs, Not Index Numbers
+
+**Always use session_id (UUID) for import operations.**
+
+Why:
+- Index numbers are assigned dynamically and can change between list commands
+- Using wrong index could import unintended sessions
+- Session IDs are stable and unique identifiers
+
+Example session ID format: `e58f67bf-ebba-47bd-9371-5ef9e06697d3`
+
+You can use UUID prefix for convenience: `e58f67bf` (first 8 characters)
+
+## Error Handling
+
+- **No sessions found**: Check if Claude Code history exists at `~/.claude/projects/`. Suggest running some Claude Code sessions first.
+- **Import fails**: Check disk space, database permissions at `~/.aline/db/aline.db`
+- **Partial import**: Some sessions may fail due to corrupted JSONL files. Report specific errors and suggest `--force` retry.
+- **Watcher not running**: If async import doesn't complete, suggest `aline watcher start` or use `--sync` flag.
+
+## Tips for Large Imports
+
+- For many sessions (50+), import in batches to track progress
+- Use `--sync` flag to see real-time progress for smaller batches
+- Check `~/.aline/.logs/watcher.log` for detailed import logs
+
+## When to Use This Skill
+
+Use this skill when:
+- User is setting up Aline for the first time
+- User wants to import historical Claude Code sessions
+- User asks "how do I import my history?" or similar
+- User wants to selectively import specific project sessions
+- User needs to re-import or update existing sessions
+"""
+
 # Registry of all skills to install
 SKILLS_REGISTRY: dict[str, str] = {
     "aline": ALINE_SKILL_MD,
     "aline-share": ALINE_SHARE_SKILL_MD,
+    "aline-import-history-sessions": ALINE_IMPORT_HISTORY_SESSIONS_SKILL_MD,
 }
 
 
@@ -365,3 +588,83 @@ def add_skills_command(force: bool = False) -> int:
 
     return 1 if failed_skills else 0
 
+
+def add_skills_dev_command(force: bool = False) -> int:
+    """Install developer skills from skill-dev/ directory.
+
+    Scans the skill-dev/ folder in the project root for SKILL.md files
+    and installs them to ~/.claude/skills/
+
+    This is for developer use only - skills in development that are not
+    yet bundled into the package.
+
+    Args:
+        force: Overwrite existing skills if they exist
+
+    Returns:
+        Exit code (0 for success, 1 for failure)
+    """
+    # Find skill-dev directory relative to this file's package location
+    # Go up from src/realign/commands/add.py to project root
+    package_root = Path(__file__).parent.parent.parent.parent
+    skill_dev_dir = package_root / "skill-dev"
+
+    if not skill_dev_dir.exists():
+        console.print(f"[red]skill-dev/ directory not found at:[/red] {skill_dev_dir}")
+        console.print("[dim]This command is for developer use only.[/dim]")
+        return 1
+
+    claude_skill_root = Path.home() / ".claude" / "skills"
+    installed_skills: list[str] = []
+    skipped_skills: list[str] = []
+    failed_skills: list[tuple[str, str]] = []
+
+    # Scan skill-dev for directories containing SKILL.md
+    for skill_dir in skill_dev_dir.iterdir():
+        if not skill_dir.is_dir():
+            continue
+
+        skill_file = skill_dir / "SKILL.md"
+        if not skill_file.exists():
+            continue
+
+        skill_name = skill_dir.name
+        dest_path = claude_skill_root / skill_name / "SKILL.md"
+
+        # Check if skill already exists
+        if dest_path.exists() and not force:
+            skipped_skills.append(skill_name)
+            continue
+
+        try:
+            skill_content = skill_file.read_text(encoding="utf-8")
+            _install_skill_to_path(claude_skill_root, skill_name, skill_content)
+            installed_skills.append(skill_name)
+        except Exception as e:
+            failed_skills.append((skill_name, str(e)))
+
+    if not installed_skills and not skipped_skills and not failed_skills:
+        console.print("[yellow]No skills found in skill-dev/[/yellow]")
+        console.print("[dim]Each skill should be in its own directory with a SKILL.md file.[/dim]")
+        return 0
+
+    # Report results
+    for skill_name in installed_skills:
+        skill_path = claude_skill_root / skill_name / "SKILL.md"
+        console.print(f"[green]✓[/green] Installed: [cyan]{skill_path}[/cyan]")
+
+    for skill_name in skipped_skills:
+        skill_path = claude_skill_root / skill_name / "SKILL.md"
+        console.print(f"[yellow]⊘[/yellow] Already exists: [dim]{skill_path}[/dim]")
+
+    for skill_name, error in failed_skills:
+        console.print(f"[red]✗[/red] Failed to install {skill_name}: {error}")
+
+    if skipped_skills and not installed_skills:
+        console.print("[dim]Use --force to overwrite existing skills[/dim]")
+    elif installed_skills:
+        skill_names = ", ".join(f"/{s}" for s in installed_skills)
+        console.print(f"[dim]Restart Claude Code to activate: {skill_names}[/dim]")
+
+    return 1 if failed_skills else 0
+

realign/commands/init.py

@@ -425,6 +425,48 @@ def _initialize_skills() -> Path:
     return skill_root
 
 
+def _initialize_claude_hooks() -> Tuple[bool, list]:
+    """Initialize Claude Code hooks (Stop, UserPromptSubmit, PermissionRequest).
+
+    Installs all Aline hooks to the global Claude Code settings.
+    Does not overwrite existing hooks.
+
+    Returns:
+        (all_success, list of installed hook names)
+    """
+    installed_hooks = []
+    all_success = True
+
+    try:
+        from ..claude_hooks.stop_hook_installer import ensure_stop_hook_installed
+        if ensure_stop_hook_installed(quiet=True):
+            installed_hooks.append("Stop")
+        else:
+            all_success = False
+    except Exception:
+        all_success = False
+
+    try:
+        from ..claude_hooks.user_prompt_submit_hook_installer import ensure_user_prompt_submit_hook_installed
+        if ensure_user_prompt_submit_hook_installed(quiet=True):
+            installed_hooks.append("UserPromptSubmit")
+        else:
+            all_success = False
+    except Exception:
+        all_success = False
+
+    try:
+        from ..claude_hooks.permission_request_hook_installer import ensure_permission_request_hook_installed
+        if ensure_permission_request_hook_installed(quiet=True):
+            installed_hooks.append("PermissionRequest")
+        else:
+            all_success = False
+    except Exception:
+        all_success = False
+
+    return all_success, installed_hooks
+
+
 def init_global(
     force: bool = False,
 ) -> Dict[str, Any]:
@@ -444,6 +486,7 @@ def init_global(
         "prompts_dir": None,
         "tmux_conf": None,
         "skills_path": None,
+        "hooks_installed": None,
         "message": "",
         "errors": [],
     }
@@ -512,8 +555,14 @@ def init_global(
         skills_path = _initialize_skills()
         result["skills_path"] = str(skills_path)
 
+        # Initialize Claude Code hooks (Stop, UserPromptSubmit, PermissionRequest)
+        hooks_success, hooks_installed = _initialize_claude_hooks()
+        result["hooks_installed"] = hooks_installed
+        if not hooks_success:
+            result["errors"].append("Some Claude Code hooks failed to install")
+
         result["success"] = True
-        result["message"] = "Aline initialized successfully (global config + database + prompts + tmux + skills ready)"
+        result["message"] = "Aline initialized successfully (global config + database + prompts + tmux + skills + hooks ready)"
 
     except Exception as e:
         result["errors"].append(f"Initialization failed: {e}")
@@ -589,6 +638,12 @@ def init_command(
     console.print(f"  Tmux: [cyan]{result.get('tmux_conf', 'N/A')}[/cyan]")
     console.print(f"  Skills: [cyan]{result.get('skills_path', 'N/A')}[/cyan]")
 
+    hooks_installed = result.get("hooks_installed") or []
+    if hooks_installed:
+        console.print(f"  Hooks: [cyan]{', '.join(hooks_installed)}[/cyan]")
+    else:
+        console.print("  Hooks: [yellow]None installed[/yellow]")
+
     if result.get("success") and should_start:
         console.print("\n[bold]Watcher:[/bold]")
         if watcher_started:

realign/dashboard/tmux_manager.py

@@ -14,6 +14,7 @@ import shutil
 import stat
 import subprocess
 import sys
+import time
 import uuid
 from dataclasses import dataclass
 from pathlib import Path
@@ -38,6 +39,8 @@ OPT_SESSION_TYPE = "@aline_session_type"
 OPT_SESSION_ID = "@aline_session_id"
 OPT_TRANSCRIPT_PATH = "@aline_transcript_path"
 OPT_CONTEXT_ID = "@aline_context_id"
+OPT_ATTENTION = "@aline_attention"
+OPT_CREATED_AT = "@aline_created_at"
 
 
 @dataclass(frozen=True)
@@ -49,7 +52,10 @@ class InnerWindow:
     provider: str | None = None
     session_type: str | None = None
     session_id: str | None = None
+    transcript_path: str | None = None
     context_id: str | None = None
+    attention: str | None = None  # "permission_request", "stop", or None
+    created_at: float | None = None  # Unix timestamp when window was created
 
 
 def tmux_available() -> bool:
@@ -144,8 +150,35 @@ def new_context_id(prefix: str = "cc") -> str:
 def shell_command_with_env(command: str, env: dict[str, str]) -> str:
     if not env:
         return command
-    prefix = " ".join(f"{k}={shlex.quote(v)}" for k, v in env.items())
-    return f"{prefix} {command}"
+    # Important: callers often pass compound shell commands like `cd ... && zsh -lc ...`.
+    # `VAR=... cd ... && ...` only applies VAR to the first command (`cd`) in POSIX sh.
+    # Wrap in a subshell so env vars apply to the entire script.
+    assignments = " ".join(f"{k}={shlex.quote(v)}" for k, v in env.items())
+    return f"env {assignments} sh -lc {shlex.quote(command)}"
+
+
+_SESSION_ID_FROM_TRANSCRIPT_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9_-]{7,}$")
+
+
+def _session_id_from_transcript_path(transcript_path: str | None) -> str | None:
+    raw = (transcript_path or "").strip()
+    if not raw:
+        return None
+    try:
+        path = Path(raw)
+    except Exception:
+        return None
+    if path.suffix != ".jsonl":
+        return None
+    stem = (path.stem or "").strip()
+    if not stem:
+        return None
+    # Heuristic guard: avoid overwriting with generic filenames like "transcript.jsonl".
+    if not _SESSION_ID_FROM_TRANSCRIPT_RE.fullmatch(stem):
+        return None
+    if not any(ch.isdigit() for ch in stem):
+        return None
+    return stem
 
 
 def _load_terminal_state() -> dict[str, dict[str, str]]:
@@ -449,7 +482,13 @@ def list_inner_windows() -> list[InnerWindow]:
                 + "}\t#{"
                 + OPT_SESSION_ID
                 + "}\t#{"
+                + OPT_TRANSCRIPT_PATH
+                + "}\t#{"
                 + OPT_CONTEXT_ID
+                + "}\t#{"
+                + OPT_ATTENTION
+                + "}\t#{"
+                + OPT_CREATED_AT
                 + "}",
             ],
             capture=True,
@@ -468,7 +507,16 @@ def list_inner_windows() -> list[InnerWindow]:
         provider = parts[4] if len(parts) > 4 and parts[4] else None
         session_type = parts[5] if len(parts) > 5 and parts[5] else None
         session_id = parts[6] if len(parts) > 6 and parts[6] else None
-        context_id = parts[7] if len(parts) > 7 and parts[7] else None
+        transcript_path = parts[7] if len(parts) > 7 and parts[7] else None
+        context_id = parts[8] if len(parts) > 8 and parts[8] else None
+        attention = parts[9] if len(parts) > 9 and parts[9] else None
+        created_at_str = parts[10] if len(parts) > 10 and parts[10] else None
+        created_at: float | None = None
+        if created_at_str:
+            try:
+                created_at = float(created_at_str)
+            except ValueError:
+                pass
 
         if terminal_id:
             persisted = state.get(terminal_id) or {}
@@ -478,9 +526,15 @@ def list_inner_windows() -> list[InnerWindow]:
                 session_type = persisted.get("session_type") or session_type
             if not session_id:
                 session_id = persisted.get("session_id") or session_id
+            if not transcript_path:
+                transcript_path = persisted.get("transcript_path") or transcript_path
             if not context_id:
                 context_id = persisted.get("context_id") or context_id
 
+        transcript_session_id = _session_id_from_transcript_path(transcript_path)
+        if transcript_session_id:
+            session_id = transcript_session_id
+
         windows.append(
             InnerWindow(
                 window_id=window_id,
@@ -490,9 +544,14 @@ def list_inner_windows() -> list[InnerWindow]:
                 provider=provider,
                 session_type=session_type,
                 session_id=session_id,
+                transcript_path=transcript_path,
                 context_id=context_id,
+                attention=attention,
+                created_at=created_at,
             )
         )
+    # Sort by creation time (newest first). Windows without created_at go to the bottom.
+    windows.sort(key=lambda w: w.created_at if w.created_at is not None else 0, reverse=True)
     return windows
 
 
@@ -527,6 +586,9 @@ def create_inner_window(
     existing = list_inner_windows()
     name = _unique_name((w.window_name for w in existing), base_name)
 
+    # Record creation time before creating the window
+    created_at = time.time()
+
     proc = _run_inner_tmux(
         [
             "new-window",
@@ -549,18 +611,18 @@ def create_inner_window(
         return None
     window_id, window_name = (created[0].split("\t", 1) + [""])[:2]
 
-    if terminal_id or provider or context_id:
-        opts: dict[str, str] = {}
-        if terminal_id:
-            opts[OPT_TERMINAL_ID] = terminal_id
-        if provider:
-            opts[OPT_PROVIDER] = provider
-        if context_id:
-            opts[OPT_CONTEXT_ID] = context_id
-        opts.setdefault(OPT_SESSION_TYPE, "")
-        opts.setdefault(OPT_SESSION_ID, "")
-        opts.setdefault(OPT_TRANSCRIPT_PATH, "")
-        set_inner_window_options(window_id, opts)
+    # Always set options including the creation timestamp
+    opts: dict[str, str] = {OPT_CREATED_AT: str(created_at)}
+    if terminal_id:
+        opts[OPT_TERMINAL_ID] = terminal_id
+    if provider:
+        opts[OPT_PROVIDER] = provider
+    if context_id:
+        opts[OPT_CONTEXT_ID] = context_id
+    opts.setdefault(OPT_SESSION_TYPE, "")
+    opts.setdefault(OPT_SESSION_ID, "")
+    opts.setdefault(OPT_TRANSCRIPT_PATH, "")
+    set_inner_window_options(window_id, opts)
 
     _run_inner_tmux(["select-window", "-t", window_id])
 
@@ -571,6 +633,7 @@ def create_inner_window(
         terminal_id=terminal_id,
         provider=provider,
         context_id=context_id,
+        created_at=created_at,
     )
 
 
@@ -580,6 +643,16 @@ def select_inner_window(window_id: str) -> bool:
     return _run_inner_tmux(["select-window", "-t", window_id]).returncode == 0
 
 
+def clear_attention(window_id: str) -> bool:
+    """Clear the attention state for a window (e.g., after user acknowledges permission request)."""
+    if not ensure_inner_session():
+        return False
+    return (
+        _run_inner_tmux(["set-option", "-w", "-t", window_id, OPT_ATTENTION, ""]).returncode
+        == 0
+    )
+
+
 def get_active_claude_context_id() -> str | None:
     """Return the active inner tmux window's Claude ALINE_CONTEXT_ID (if any)."""
     try: