reprompt-cli 0.1.1__py3-none-any.whl

reprompt/__init__.py

@@ -0,0 +1,5 @@
+"""reprompt - Discover, analyze, and evolve your best prompts from AI coding sessions."""
+
+from __future__ import annotations
+
+__version__ = "0.1.1"

reprompt/adapters/__init__.py

@@ -0,0 +1,3 @@
+"""Session adapters for various AI coding tools."""
+
+from __future__ import annotations

reprompt/adapters/base.py

@@ -0,0 +1,25 @@
+"""Base adapter interface for AI coding session parsers."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+from reprompt.core.models import Prompt
+
+
+class BaseAdapter(ABC):
+    """Abstract base class for session adapters."""
+
+    name: str
+    default_session_path: str
+
+    @abstractmethod
+    def parse_session(self, path: Path) -> list[Prompt]:
+        """Parse a session file and return a list of Prompt objects."""
+        ...
+
+    @abstractmethod
+    def detect_installed(self) -> bool:
+        """Check if the tool's session directory exists."""
+        ...

reprompt/adapters/claude_code.py

@@ -0,0 +1,140 @@
+"""Claude Code session adapter."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from pathlib import Path
+
+from reprompt.adapters.base import BaseAdapter
+from reprompt.core.models import Prompt
+
+SKIP_EXACT = {
+    "\u597d\u7684",
+    "OK",
+    "ok",
+    "Ok",
+    "\u662f\u7684",
+    "\u53ef\u4ee5",
+    "sure",
+    "Sure",
+    "yes",
+    "Yes",
+    "Done",
+    "done",
+    "Sent",
+    "sent",
+    "\u597d",
+    "\u5bf9",
+    "\u884c",
+    "\u55ef",
+    "Tool loaded.",
+    "1",
+    "2",
+    "3",
+    "A",
+    "B",
+    "C",
+    "D",
+}
+
+SKIP_PREFIXES = (
+    "<",
+    "Tool loaded",
+    "Base directory for this skill",
+)
+
+
+def should_keep_prompt(text: str) -> bool:
+    """Filter out noise prompts -- short messages, exact matches, prefixes."""
+    text = text.strip()
+    if len(text) < 10:
+        return False
+    if text in SKIP_EXACT:
+        return False
+    if any(text.startswith(p) for p in SKIP_PREFIXES):
+        return False
+    if not re.search(r"[a-zA-Z\u4e00-\u9fff]", text):
+        return False
+    return True
+
+
+def _extract_text(message: dict[str, object]) -> str:
+    """Extract text from a message, handling both string and list content."""
+    content = message.get("content", "")
+    if isinstance(content, list):
+        parts = [
+            p.get("text", "") for p in content if isinstance(p, dict) and p.get("type") == "text"
+        ]
+        return " ".join(parts).strip()
+    return str(content).strip()
+
+
+class ClaudeCodeAdapter(BaseAdapter):
+    """Adapter for Claude Code JSONL session files."""
+
+    name = "claude-code"
+    default_session_path = "~/.claude/projects"
+
+    def __init__(self, session_path: Path | None = None) -> None:
+        self._session_path = session_path or Path(os.path.expanduser(self.default_session_path))
+
+    def detect_installed(self) -> bool:
+        """Check if Claude Code session directory exists."""
+        return self._session_path.is_dir()
+
+    def parse_session(self, path: Path) -> list[Prompt]:
+        """Parse a Claude Code JSONL session file into Prompt objects."""
+        prompts: list[Prompt] = []
+        session_id = path.stem
+
+        with open(path, encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    entry = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+
+                # Only process user messages
+                if entry.get("type") != "user":
+                    continue
+
+                message = entry.get("message", {})
+                if message.get("role") != "user":
+                    continue
+
+                text = _extract_text(message)
+                if not should_keep_prompt(text):
+                    continue
+
+                project = self._project_from_path(str(path))
+                timestamp = entry.get("timestamp", "")
+
+                prompts.append(
+                    Prompt(
+                        text=text,
+                        source=self.name,
+                        session_id=session_id,
+                        project=project,
+                        timestamp=timestamp,
+                    )
+                )
+
+        return prompts
+
+    def _project_from_path(self, file_path: str) -> str:
+        """Extract project name from Claude Code session path.
+
+        Path format: ~/.claude/projects/-Users-chris-projects-myproject/session.jsonl
+        The parent directory name has dashes replacing path separators.
+        """
+        parent = os.path.basename(os.path.dirname(file_path))
+        parts = parent.split("-")
+        for i, p in enumerate(parts):
+            if p == "projects" and i + 1 < len(parts):
+                return "-".join(parts[i + 1 :])
+        return parent

reprompt/adapters/openclaw.py

@@ -0,0 +1,79 @@
+"""OpenClaw/OpenCode session adapter."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+from reprompt.adapters.base import BaseAdapter
+from reprompt.adapters.claude_code import should_keep_prompt
+from reprompt.core.models import Prompt
+
+
+class OpenClawAdapter(BaseAdapter):
+    """Adapter for OpenClaw/OpenCode JSONL session files.
+
+    OpenClaw sessions use a simpler format than Claude Code:
+    - No 'type' wrapper -- directly has 'role' field
+    - 'content' is always a string (not list)
+    - Session path: ~/.opencode/sessions/
+    """
+
+    name = "openclaw"
+    default_session_path = "~/.opencode/sessions"
+
+    def __init__(self, session_path: Path | None = None) -> None:
+        self._session_path = session_path or Path(os.path.expanduser(self.default_session_path))
+
+    def detect_installed(self) -> bool:
+        """Check if OpenClaw session directory exists."""
+        return self._session_path.is_dir()
+
+    def parse_session(self, path: Path) -> list[Prompt]:
+        """Parse an OpenClaw JSONL session file into Prompt objects."""
+        prompts: list[Prompt] = []
+
+        with open(path, encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    entry = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+
+                # Only process user messages
+                if entry.get("role") != "user":
+                    continue
+
+                text = str(entry.get("content", "")).strip()
+                if not should_keep_prompt(text):
+                    continue
+
+                session_id = entry.get("session_id", path.stem)
+                timestamp = entry.get("timestamp", "")
+                project = self._project_from_path(str(path))
+
+                prompts.append(
+                    Prompt(
+                        text=text,
+                        source=self.name,
+                        session_id=session_id,
+                        project=project,
+                        timestamp=timestamp,
+                    )
+                )
+
+        return prompts
+
+    def _project_from_path(self, file_path: str) -> str:
+        """Extract project name from OpenClaw session path.
+
+        Path format: ~/.opencode/sessions/<project-name>/session.jsonl
+        """
+        parent = os.path.basename(os.path.dirname(file_path))
+        if parent == "sessions":
+            return ""
+        return parent

reprompt/cli.py

@@ -0,0 +1,177 @@
+"""CLI entry point."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from reprompt import __version__
+
+app = typer.Typer(
+    name="reprompt",
+    help="Discover, analyze, and evolve your best prompts from AI coding sessions.",
+    no_args_is_help=True,
+)
+console = Console()
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"reprompt {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        False, "--version", "-V", callback=_version_callback, is_eager=True
+    ),
+) -> None:
+    """reprompt -- Discover, analyze, and evolve your best prompts from AI coding sessions."""
+
+
+@app.command()
+def scan(
+    source: str | None = typer.Option(None, help="Source adapter (claude-code, openclaw)"),
+    path: str | None = typer.Option(None, help="Custom session path"),
+) -> None:
+    """Scan AI tool sessions for prompts."""
+    from reprompt.config import Settings
+    from reprompt.core.pipeline import run_scan
+
+    settings = Settings()
+    result = run_scan(source=source, path=path, settings=settings)
+
+    console.print("[bold]Scan complete[/bold]")
+    console.print(f"  Sessions scanned: {result.sessions_scanned}")
+    console.print(f"  Prompts found:    {result.total_parsed}")
+    console.print(f"  Unique:           {result.unique_after_dedup}")
+    console.print(f"  Duplicates:       {result.duplicates}")
+    console.print(f"  New stored:       {result.new_stored}")
+
+
+@app.command()
+def report(
+    format: str = typer.Option("terminal", help="Output format: terminal, json"),
+    top: int = typer.Option(20, help="Number of top terms to show"),
+) -> None:
+    """Generate analytics report."""
+    from reprompt.config import Settings
+    from reprompt.core.pipeline import build_report_data
+    from reprompt.output.json_out import format_json_report
+    from reprompt.output.terminal import render_report
+
+    settings = Settings()
+    data = build_report_data(settings=settings)
+
+    if format == "json":
+        console.print(format_json_report(data))
+    else:
+        console.print(render_report(data))
+
+
+@app.command()
+def library(
+    category: str | None = typer.Option(None, help="Filter by category"),
+    export: str | None = typer.Argument(None, help="Export to file path (Markdown)"),
+) -> None:
+    """Show or export your prompt library."""
+    from reprompt.config import Settings
+    from reprompt.output.markdown import export_library_markdown
+    from reprompt.storage.db import PromptDB
+
+    settings = Settings()
+    db = PromptDB(settings.db_path)
+    patterns = db.get_patterns(category=category)
+
+    if export:
+        md = export_library_markdown(patterns)
+        Path(export).write_text(md)
+        console.print(f"Library exported to {export}")
+    else:
+        if not patterns:
+            console.print("No patterns yet. Run [bold]reprompt scan[/bold] first.")
+            return
+        from rich.table import Table
+
+        table = Table(title="Prompt Library")
+        table.add_column("#", style="dim", width=4)
+        table.add_column("Pattern", max_width=50)
+        table.add_column("Uses", justify="right")
+        table.add_column("Category")
+        for i, p in enumerate(patterns, 1):
+            table.add_row(
+                str(i),
+                str(p.get("pattern_text", ""))[:50],
+                str(p.get("frequency", 0)),
+                str(p.get("category", "")),
+            )
+        console.print(table)
+
+
+@app.command()
+def status() -> None:
+    """Show database statistics."""
+    from reprompt.config import Settings
+    from reprompt.storage.db import PromptDB
+
+    settings = Settings()
+    db = PromptDB(settings.db_path)
+    stats = db.get_stats()
+
+    console.print("[bold]reprompt status[/bold]")
+    console.print(f"  Total prompts:    {stats.get('total_prompts', 0)}")
+    console.print(f"  Unique prompts:   {stats.get('unique_prompts', 0)}")
+    console.print(f"  Sessions:         {stats.get('sessions_processed', 0)}")
+    console.print(f"  Patterns:         {stats.get('patterns', 0)}")
+    console.print(f"  DB path:          {settings.db_path}")
+
+
+@app.command()
+def purge(
+    older_than: str = typer.Option("90d", help="Delete prompts older than (e.g. 90d)"),
+) -> None:
+    """Clean up old data."""
+    import re
+
+    from reprompt.config import Settings
+    from reprompt.storage.db import PromptDB
+
+    m = re.fullmatch(r"(\d+)d?", older_than.strip(), re.IGNORECASE)
+    if not m:
+        raise typer.BadParameter("Use format like '90d' or '30'")
+    days = int(m.group(1))
+    settings = Settings()
+    db = PromptDB(settings.db_path)
+    deleted = db.purge_old_prompts(days)
+    console.print(f"Purged {deleted} prompts older than {days} days")
+
+
+@app.command("install-hook")
+def install_hook(
+    source: str = typer.Option("claude-code", help="AI tool to install hook for"),
+) -> None:
+    """Install post-session hook for automatic scanning."""
+    home = Path.home()
+
+    if source == "claude-code":
+        hooks_dir = home / ".claude" / "hooks"
+        hook_path = hooks_dir / "reprompt-scan.sh"
+
+        if hook_path.exists():
+            console.print(f"Hook already exists at {hook_path}")
+            return
+
+        if not (home / ".claude").exists():
+            console.print("[yellow]Claude Code not detected (~/.claude/ not found)[/yellow]")
+            return
+
+        hooks_dir.mkdir(parents=True, exist_ok=True)
+        hook_path.write_text("#!/bin/sh\nreprompt scan --source claude-code\n")
+        hook_path.chmod(0o755)
+        console.print(f"[green]Hook installed at {hook_path}[/green]")
+        console.print("reprompt will automatically scan after Claude Code sessions.")
+    else:
+        console.print(f"[yellow]Hook installation for '{source}' not yet supported[/yellow]")

reprompt/config.py

@@ -0,0 +1,44 @@
+"""Configuration with env var override support."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from pydantic_settings import BaseSettings
+
+
+def _default_db_path() -> str:
+    if os.name == "nt":
+        base = Path(os.environ.get("LOCALAPPDATA", "~"))
+    elif hasattr(os, "uname") and os.uname().sysname == "Darwin":
+        base = Path("~/Library/Application Support")
+    else:
+        base = Path(os.environ.get("XDG_DATA_HOME", "~/.local/share"))
+    return str(base / "reprompt" / "reprompt.db")
+
+
+class Settings(BaseSettings):
+    model_config = {"env_prefix": "REPROMPT_"}
+
+    # Embedding
+    embedding_backend: str = "tfidf"
+    ollama_url: str = "http://localhost:11434"
+
+    # Storage
+    db_path: Path = Path(os.path.expanduser(_default_db_path()))
+
+    # Dedup
+    dedup_threshold: float = 0.85
+
+    # Library
+    library_min_frequency: int = 3
+    library_categories: list[str] = [
+        "debug",
+        "implement",
+        "review",
+        "test",
+        "refactor",
+        "explain",
+        "config",
+    ]

reprompt/core/__init__.py

@@ -0,0 +1 @@
+"""Core domain models and logic."""

reprompt/core/analyzer.py

@@ -0,0 +1,68 @@
+"""TF-IDF analysis and K-means clustering."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+from sklearn.cluster import KMeans
+from sklearn.feature_extraction.text import TfidfVectorizer
+
+
+def compute_tfidf_stats(texts: list[str], top_n: int = 20) -> list[dict[str, Any]]:
+    """Compute TF-IDF stats, return top N terms with scores.
+
+    Returns list of dicts: [{"term": str, "count": int, "df": int, "tfidf_avg": float}]
+    """
+    if not texts:
+        return []
+
+    vectorizer = TfidfVectorizer(max_features=5000)
+    tfidf_matrix = vectorizer.fit_transform(texts)
+    feature_names = vectorizer.get_feature_names_out()
+
+    # Average TF-IDF score per term across all documents
+    avg_scores = np.asarray(tfidf_matrix.mean(axis=0)).flatten()
+
+    # Document frequency (number of docs containing each term)
+    df = np.asarray((tfidf_matrix > 0).sum(axis=0)).flatten()
+
+    # Sum of TF-IDF weights (approximate count)
+    count = np.asarray(tfidf_matrix.sum(axis=0)).flatten()
+
+    results = []
+    for i, term in enumerate(feature_names):
+        results.append(
+            {
+                "term": term,
+                "count": int(count[i] * len(texts)),
+                "df": int(df[i]),
+                "tfidf_avg": float(avg_scores[i]),
+            }
+        )
+
+    results.sort(key=lambda x: x["tfidf_avg"], reverse=True)
+    return results[:top_n]
+
+
+def cluster_prompts(texts: list[str], n_clusters: int = 5) -> dict[int, list[str]]:
+    """Cluster prompts using K-means on TF-IDF vectors.
+
+    Returns {cluster_id: [texts]}
+    """
+    if not texts:
+        return {}
+
+    n_clusters = min(n_clusters, len(texts))
+
+    vectorizer = TfidfVectorizer(max_features=5000)
+    tfidf_matrix = vectorizer.fit_transform(texts)
+
+    kmeans = KMeans(n_clusters=n_clusters, random_state=42, n_init=10)
+    labels = kmeans.fit_predict(tfidf_matrix)
+
+    clusters: dict[int, list[str]] = {}
+    for text, label in zip(texts, labels):
+        clusters.setdefault(int(label), []).append(text)
+
+    return clusters

reprompt/core/dedup.py

@@ -0,0 +1,89 @@
+"""Two-layer deduplication engine.
+
+L0: SHA-256 exact hash dedup (always runs)
+L1: TF-IDF cosine similarity dedup (runs on hash-unique prompts)
+"""
+
+from __future__ import annotations
+
+from reprompt.core.models import Prompt
+from reprompt.embeddings.base import BaseEmbedder
+
+
+def _get_embedder(backend: str) -> BaseEmbedder:
+    """Factory function to create an embedder by name."""
+    if backend == "tfidf":
+        from reprompt.embeddings.tfidf import TfidfEmbedder
+
+        return TfidfEmbedder()
+    elif backend == "ollama":
+        from reprompt.embeddings.ollama import OllamaEmbedder
+
+        return OllamaEmbedder()
+    else:
+        raise ValueError(f"Unknown embedding backend: {backend}")
+
+
+class DedupEngine:
+    """Two-layer deduplication: exact hash then semantic similarity."""
+
+    def __init__(self, backend: str = "tfidf", threshold: float = 0.85) -> None:
+        self._backend = backend
+        self._threshold = threshold
+
+    def deduplicate(self, prompts: list[Prompt]) -> tuple[list[Prompt], list[Prompt]]:
+        """Deduplicate prompts using hash then semantic similarity.
+
+        Returns:
+            (unique_prompts, duplicate_prompts)
+        """
+        if not prompts:
+            return [], []
+
+        # L0: Exact hash dedup -- keep first occurrence per hash
+        seen_hashes: dict[str, int] = {}
+        hash_unique: list[Prompt] = []
+        hash_dupes: list[Prompt] = []
+
+        for prompt in prompts:
+            if prompt.hash in seen_hashes:
+                hash_dupes.append(prompt)
+            else:
+                seen_hashes[prompt.hash] = len(hash_unique)
+                hash_unique.append(prompt)
+
+        # L1: Semantic dedup on hash-unique prompts
+        if len(hash_unique) < 2:
+            return hash_unique, hash_dupes
+
+        embedder = _get_embedder(self._backend)
+        texts = [p.text for p in hash_unique]
+        embeddings = embedder.embed(texts)
+
+        if embeddings.size == 0:
+            return hash_unique, hash_dupes
+
+        # Mark semantic duplicates (later items are dupes of earlier ones)
+        is_dupe = [False] * len(hash_unique)
+
+        for i in range(len(hash_unique)):
+            if is_dupe[i]:
+                continue
+            for j in range(i + 1, len(hash_unique)):
+                if is_dupe[j]:
+                    continue
+                sim = embedder.cosine_similarity(embeddings[i], embeddings[j])
+                if sim >= self._threshold:
+                    is_dupe[j] = True
+
+        semantic_unique: list[Prompt] = []
+        semantic_dupes: list[Prompt] = []
+
+        for idx, prompt in enumerate(hash_unique):
+            if is_dupe[idx]:
+                semantic_dupes.append(prompt)
+            else:
+                semantic_unique.append(prompt)
+
+        all_dupes = hash_dupes + semantic_dupes
+        return semantic_unique, all_dupes