cli-dev-tip 0.1.0__py3-none-any.whl

dev_tip/history.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+HISTORY_DIR = Path.home() / ".dev-tip"
+HISTORY_FILE = HISTORY_DIR / "history.json"
+
+
+def _load_history() -> list[str]:
+    """Load the list of seen tip IDs from disk."""
+    if not HISTORY_FILE.exists():
+        return []
+    return json.loads(HISTORY_FILE.read_text())
+
+
+def _save_history(seen: list[str]) -> None:
+    """Save the list of seen tip IDs to disk."""
+    HISTORY_DIR.mkdir(parents=True, exist_ok=True)
+    HISTORY_FILE.write_text(json.dumps(seen))
+
+
+def get_unseen(tips: list[dict]) -> list[dict]:
+    """Filter out already-seen tips. If all are seen, reset but keep the last one."""
+    seen = _load_history()
+    seen_set = set(seen)
+    unseen = [t for t in tips if t["id"] not in seen_set]
+    if not unseen:
+        # Keep only the most recent tip so it won't repeat immediately.
+        _save_history(seen[-1:])
+        return [t for t in tips if t["id"] != seen[-1]] if seen else tips
+    return unseen
+
+
+def all_seen(tips: list[dict]) -> bool:
+    """Check if every tip has been seen."""
+    seen = set(_load_history())
+    return all(t["id"] in seen for t in tips)
+
+
+def mark_seen(tip_id: str) -> None:
+    """Append a tip ID to the history file."""
+    seen = _load_history()
+    if tip_id not in seen:
+        seen.append(tip_id)
+        _save_history(seen)

dev_tip/hook.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+from textwrap import dedent
+
+from rich.console import Console
+
+from dev_tip.config import CONFIG_DIR, DEFAULT_CONFIG
+
+HOOK_MARKER_START = "# >>> dev-tip hook >>>"
+HOOK_MARKER_END = "# <<< dev-tip hook <<<"
+PAUSE_FILE = CONFIG_DIR / ".paused"
+
+console = Console()
+
+
+def _detect_shell() -> str:
+    """Detect whether user is running zsh or bash."""
+    import os
+
+    shell = os.environ.get("SHELL", "")
+    if "zsh" in shell:
+        return "zsh"
+    return "bash"
+
+
+def _get_rc_file() -> Path:
+    """Detect the user's shell rc file."""
+    shell = _detect_shell()
+    if shell == "zsh":
+        return Path.home() / ".zshrc"
+    return Path.home() / ".bashrc"
+
+
+def _build_hook_command(
+    provider: str | None = None,
+    topic: str | None = None,
+    level: str | None = None,
+    quiet: bool = False,
+) -> str:
+    """Build the dev-tip command for the shell hook."""
+    parts = ["dev-tip"]
+    if provider:
+        parts.append(f"--provider {provider}")
+    if topic:
+        parts.append(f"--topic {topic}")
+    if level:
+        parts.append(f"--level {level}")
+    if quiet:
+        parts.append("--quiet")
+    return " ".join(parts)
+
+
+def _build_hook_block(
+    shell: str,
+    cmd: str,
+    every_commands: int,
+    every_minutes: int,
+) -> str:
+    """Wrap the dev-tip command in a periodic shell function."""
+    pause_path = PAUSE_FILE
+    if shell == "zsh":
+        return dedent(f"""\
+            {HOOK_MARKER_START}
+            _DEV_TIP_CMD_COUNT={every_commands}
+            _DEV_TIP_LAST_SEC=$SECONDS
+            _dev_tip_precmd() {{
+                [ -f {pause_path} ] && return
+                _DEV_TIP_CMD_COUNT=$((_DEV_TIP_CMD_COUNT + 1))
+                if (( _DEV_TIP_CMD_COUNT >= {every_commands} || (SECONDS - _DEV_TIP_LAST_SEC) / 60 >= {every_minutes} )); then
+                    {cmd} 2>/dev/null
+                    _DEV_TIP_CMD_COUNT=0
+                    _DEV_TIP_LAST_SEC=$SECONDS
+                fi
+            }}
+            autoload -Uz add-zsh-hook
+            add-zsh-hook precmd _dev_tip_precmd
+            {HOOK_MARKER_END}
+        """)
+    # bash
+    return dedent(f"""\
+        {HOOK_MARKER_START}
+        _DEV_TIP_CMD_COUNT={every_commands}
+        _DEV_TIP_LAST_SEC=$SECONDS
+        _dev_tip_prompt() {{
+            [ -f {pause_path} ] && return
+            _DEV_TIP_CMD_COUNT=$((_DEV_TIP_CMD_COUNT + 1))
+            if (( _DEV_TIP_CMD_COUNT >= {every_commands} || (SECONDS - _DEV_TIP_LAST_SEC) / 60 >= {every_minutes} )); then
+                {cmd} 2>/dev/null
+                _DEV_TIP_CMD_COUNT=0
+                _DEV_TIP_LAST_SEC=$SECONDS
+            fi
+        }}
+        PROMPT_COMMAND="_dev_tip_prompt${{PROMPT_COMMAND:+;$PROMPT_COMMAND}}"
+        {HOOK_MARKER_END}
+    """)
+
+
+def enable(
+    provider: str | None = None,
+    key: str | None = None,
+    topic: str | None = None,
+    level: str | None = None,
+    every_commands: int | None = None,
+    every_minutes: int | None = None,
+    quiet: bool = False,
+) -> None:
+    """Install the shell hook into the user's rc file."""
+    from dev_tip.config import save_config
+
+    every_commands = every_commands or DEFAULT_CONFIG["every_commands"]
+    every_minutes = every_minutes or DEFAULT_CONFIG["every_minutes"]
+
+    # Save config if anything provided
+    updates: dict = {}
+    if provider:
+        updates["ai_provider"] = provider
+    if key:
+        updates["ai_key"] = key
+    if topic:
+        updates["topic"] = topic
+    if level:
+        updates["level"] = level
+    updates["every_commands"] = every_commands
+    updates["every_minutes"] = every_minutes
+    if quiet:
+        updates["quiet"] = True
+    save_config(updates)
+
+    # Pre-cache AI tips so the first shell prompt is instant
+    if provider and key:
+        topic_arg = str(topic) if topic is not None else "null"
+        level_arg = str(level) if level is not None else "null"
+        try:
+            subprocess.Popen(
+                [sys.executable, "-m", "dev_tip.prefetch", topic_arg, level_arg],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                stdin=subprocess.DEVNULL,
+                start_new_session=True,
+            )
+            console.print("[dim]Pre-caching AI tips in the background...[/dim]")
+        except OSError:
+            pass
+
+    rc_file = _get_rc_file()
+    shell = _detect_shell()
+
+    # Remove existing hook first (so re-running enable updates it)
+    if rc_file.exists():
+        content = rc_file.read_text()
+        if HOOK_MARKER_START in content:
+            start = content.index(HOOK_MARKER_START)
+            end = content.index(HOOK_MARKER_END) + len(HOOK_MARKER_END)
+            content = content[:start].rstrip() + content[end:].lstrip("\n")
+    else:
+        content = ""
+
+    cmd = _build_hook_command(provider, topic, level, quiet=quiet)
+    hook_block = _build_hook_block(shell, cmd, every_commands, every_minutes)
+    content = content.rstrip() + "\n\n" + hook_block
+    rc_file.write_text(content)
+
+    console.print(f"[green]Hook installed in {rc_file}[/green]")
+    console.print(
+        f"Tips will appear every {every_commands} commands "
+        f"or {every_minutes} minutes."
+    )
+    console.print(f"Restart your {shell} or run: [bold]source {rc_file}[/bold]")
+
+
+def disable() -> None:
+    """Remove the shell hook from the user's rc file."""
+    rc_file = _get_rc_file()
+
+    if not rc_file.exists():
+        console.print("[yellow]No rc file found.[/yellow]")
+        return
+
+    content = rc_file.read_text()
+    if HOOK_MARKER_START not in content:
+        console.print("[yellow]Hook not found — nothing to remove.[/yellow]")
+        return
+
+    start = content.index(HOOK_MARKER_START)
+    end = content.index(HOOK_MARKER_END) + len(HOOK_MARKER_END)
+    cleaned = content[:start].rstrip() + content[end:].lstrip("\n")
+    rc_file.write_text(cleaned)
+
+    console.print(f"[green]Hook removed from {rc_file}[/green]")

dev_tip/prefetch.py

@@ -0,0 +1,98 @@
+"""Background prefetch worker: python -m dev_tip.prefetch <topic> <level>
+
+Fetches a fresh batch of AI tips and appends them to the cache.
+Uses a lock file to prevent concurrent prefetch processes.
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+LOCK_FILE = Path.home() / ".dev-tip" / ".prefetch.lock"
+LOCK_MAX_AGE = 120  # seconds
+
+
+def _acquire_lock() -> bool:
+    """Try to acquire the lock file. Return True on success."""
+    LOCK_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+    if LOCK_FILE.exists():
+        try:
+            info = json.loads(LOCK_FILE.read_text())
+            pid = info.get("pid", 0)
+            ts = info.get("time", 0)
+
+            # Check if lock is stale
+            if time.time() - ts < LOCK_MAX_AGE:
+                # Check if process is still alive
+                try:
+                    os.kill(pid, 0)
+                    return False  # Process alive, lock held
+                except OSError:
+                    pass  # Process dead, stale lock
+        except (json.JSONDecodeError, KeyError):
+            pass  # Corrupt lock file, take over
+
+    LOCK_FILE.write_text(json.dumps({"pid": os.getpid(), "time": time.time()}))
+    return True
+
+
+def _release_lock() -> None:
+    """Remove the lock file."""
+    try:
+        LOCK_FILE.unlink(missing_ok=True)
+    except OSError:
+        pass
+
+
+def main() -> None:
+    args = sys.argv[1:]
+    if len(args) != 2:
+        return
+
+    topic = None if args[0] == "null" else args[0]
+    level = None if args[1] == "null" else args[1]
+
+    if not _acquire_lock():
+        return
+
+    try:
+        from dev_tip.ai.cache import is_on_cooldown, mark_failure, save_cache
+        from dev_tip.ai.provider import create_provider
+        from dev_tip.config import load_config
+
+        if is_on_cooldown():
+            return
+
+        config = load_config()
+        provider_name = config.get("ai_provider")
+        if not provider_name:
+            return
+
+        api_key = config.get("ai_key")
+        if not api_key:
+            env_keys = {"gemini": "GEMINI_API_KEY", "openrouter": "OPENROUTER_API_KEY"}
+            env_var = env_keys.get(provider_name)
+            if env_var:
+                api_key = os.environ.get(env_var)
+        if not api_key:
+            return
+
+        provider = create_provider(provider_name, api_key, model=config.get("ai_model"))
+        try:
+            new_tips = provider.generate_tips(topic, level, 10)
+        except Exception:
+            mark_failure()
+            return
+
+        # save_cache merges and deduplicates automatically
+        save_cache(new_tips, topic, level)
+    finally:
+        _release_lock()
+
+
+if __name__ == "__main__":
+    main()

dev_tip/tips.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import random
+from importlib.resources import files
+from typing import Optional
+
+import yaml
+
+VALID_TOPICS = {
+    "python", "git", "docker", "sql", "linux",
+    "kubernetes", "vim", "javascript", "terraform", "rust",
+}
+VALID_LEVELS = {"beginner", "intermediate", "advanced"}
+
+
+def load_tips() -> list[dict]:
+    """Load all tips from the bundled YAML file."""
+    tip_file = files("dev_tip.data").joinpath("tips.yaml")
+    return yaml.safe_load(tip_file.read_text())
+
+
+def filter_tips(
+    tips: list[dict],
+    topic: Optional[str] = None,
+    level: Optional[str] = None,
+) -> list[dict]:
+    """Filter tips by topic and/or level."""
+    filtered = tips
+    if topic:
+        filtered = [t for t in filtered if t["topic"] == topic]
+    if level:
+        filtered = [t for t in filtered if t["level"] == level]
+    return filtered
+
+
+def get_random_tip(
+    tips: list[dict],
+    topic: Optional[str] = None,
+    level: Optional[str] = None,
+) -> Optional[dict]:
+    """Return a random tip matching the given filters, or None if no match."""
+    filtered = filter_tips(tips, topic=topic, level=level)
+    if not filtered:
+        return None
+    return random.choice(filtered)