reprompt-cli 0.1.1__py3-none-any.whl

reprompt/storage/db.py

@@ -0,0 +1,314 @@
+"""SQLite storage for prompts, patterns, and term statistics."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import sqlite3
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any
+
+
+class PromptDB:
+    """SQLite-backed storage for prompt data."""
+
+    def __init__(self, path: Path) -> None:
+        self.path = path
+        path.parent.mkdir(parents=True, exist_ok=True)
+        self._init_schema()
+
+    def _conn(self) -> sqlite3.Connection:
+        """Get a connection with row_factory set."""
+        conn = sqlite3.connect(str(self.path))
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    def _init_schema(self) -> None:
+        """Create tables if they don't exist."""
+        conn = self._conn()
+        try:
+            conn.executescript("""
+                CREATE TABLE IF NOT EXISTS prompts (
+                    id INTEGER PRIMARY KEY,
+                    hash TEXT UNIQUE,
+                    text TEXT NOT NULL,
+                    source TEXT NOT NULL,
+                    project TEXT,
+                    session_id TEXT,
+                    timestamp TEXT,
+                    char_count INTEGER,
+                    embedding BLOB,
+                    cluster_id INTEGER,
+                    duplicate_of INTEGER REFERENCES prompts(id)
+                );
+                CREATE TABLE IF NOT EXISTS processed_sessions (
+                    file_path TEXT PRIMARY KEY,
+                    processed_at TEXT,
+                    source TEXT
+                );
+                CREATE TABLE IF NOT EXISTS prompt_patterns (
+                    id INTEGER PRIMARY KEY,
+                    pattern_text TEXT,
+                    frequency INTEGER,
+                    avg_length REAL,
+                    projects TEXT,
+                    category TEXT,
+                    first_seen TEXT,
+                    last_seen TEXT,
+                    examples TEXT
+                );
+                CREATE TABLE IF NOT EXISTS term_stats (
+                    term TEXT PRIMARY KEY,
+                    count INTEGER,
+                    df INTEGER,
+                    tfidf_avg REAL
+                );
+            """)
+            conn.commit()
+        finally:
+            conn.close()
+
+    @staticmethod
+    def _hash(text: str) -> str:
+        """SHA-256 hash of stripped text."""
+        return hashlib.sha256(text.strip().encode()).hexdigest()
+
+    def insert_prompt(
+        self,
+        text: str,
+        *,
+        source: str,
+        project: str | None = None,
+        session_id: str = "",
+        timestamp: str = "",
+    ) -> bool:
+        """Insert a prompt. Returns True if new, False if duplicate by hash."""
+        stripped = text.strip()
+        h = self._hash(stripped)
+        conn = self._conn()
+        try:
+            conn.execute(
+                """INSERT INTO prompts (hash, text, source, project, session_id,
+                   timestamp, char_count) VALUES (?, ?, ?, ?, ?, ?, ?)""",
+                (h, stripped, source, project, session_id, timestamp, len(stripped)),
+            )
+            conn.commit()
+            return True
+        except sqlite3.IntegrityError:
+            return False
+        finally:
+            conn.close()
+
+    def get_all_prompts(self) -> list[dict[str, Any]]:
+        """Return all prompts as dicts."""
+        conn = self._conn()
+        try:
+            rows = conn.execute("SELECT * FROM prompts ORDER BY id").fetchall()
+            return [dict(r) for r in rows]
+        finally:
+            conn.close()
+
+    def get_prompts_without_embedding(self) -> list[dict[str, Any]]:
+        """Return prompts that have no embedding yet."""
+        conn = self._conn()
+        try:
+            rows = conn.execute(
+                "SELECT * FROM prompts WHERE embedding IS NULL AND duplicate_of IS NULL ORDER BY id"
+            ).fetchall()
+            return [dict(r) for r in rows]
+        finally:
+            conn.close()
+
+    def update_embedding(self, prompt_id: int, embedding: bytes) -> None:
+        """Store an embedding blob for a prompt."""
+        conn = self._conn()
+        try:
+            conn.execute("UPDATE prompts SET embedding = ? WHERE id = ?", (embedding, prompt_id))
+            conn.commit()
+        finally:
+            conn.close()
+
+    def mark_duplicate(self, prompt_id: int, duplicate_of: int) -> None:
+        """Mark a prompt as a duplicate of another."""
+        conn = self._conn()
+        try:
+            conn.execute(
+                "UPDATE prompts SET duplicate_of = ? WHERE id = ?", (duplicate_of, prompt_id)
+            )
+            conn.commit()
+        finally:
+            conn.close()
+
+    def mark_session_processed(self, file_path: str, source: str = "") -> None:
+        """Record that a session file has been processed."""
+        conn = self._conn()
+        try:
+            conn.execute(
+                "INSERT OR REPLACE INTO processed_sessions (file_path, processed_at, source) "
+                "VALUES (?, ?, ?)",
+                (file_path, datetime.now(timezone.utc).isoformat(), source),
+            )
+            conn.commit()
+        finally:
+            conn.close()
+
+    def is_session_processed(self, file_path: str) -> bool:
+        """Check if a session file has already been processed."""
+        conn = self._conn()
+        try:
+            row = conn.execute(
+                "SELECT 1 FROM processed_sessions WHERE file_path = ?", (file_path,)
+            ).fetchone()
+            return row is not None
+        finally:
+            conn.close()
+
+    def insert_pattern(
+        self,
+        pattern_text: str,
+        frequency: int,
+        avg_length: float,
+        projects: list[str],
+        category: str,
+        first_seen: str,
+        last_seen: str,
+        examples: list[str],
+    ) -> int:
+        """Insert a prompt pattern. Returns the new pattern ID."""
+        conn = self._conn()
+        try:
+            cursor = conn.execute(
+                """INSERT INTO prompt_patterns
+                   (pattern_text, frequency, avg_length, projects, category,
+                    first_seen, last_seen, examples)
+                   VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
+                (
+                    pattern_text,
+                    frequency,
+                    avg_length,
+                    json.dumps(projects),
+                    category,
+                    first_seen,
+                    last_seen,
+                    json.dumps(examples),
+                ),
+            )
+            conn.commit()
+            pattern_id = cursor.lastrowid
+            assert pattern_id is not None
+            return pattern_id
+        finally:
+            conn.close()
+
+    def get_patterns(self, category: str | None = None) -> list[dict[str, Any]]:
+        """Return all patterns, optionally filtered by category."""
+        conn = self._conn()
+        try:
+            if category:
+                rows = conn.execute(
+                    "SELECT * FROM prompt_patterns WHERE category = ? ORDER BY frequency DESC",
+                    (category,),
+                ).fetchall()
+            else:
+                rows = conn.execute(
+                    "SELECT * FROM prompt_patterns ORDER BY frequency DESC"
+                ).fetchall()
+            result = []
+            for r in rows:
+                d = dict(r)
+                d["projects"] = json.loads(d["projects"]) if d["projects"] else []
+                d["examples"] = json.loads(d["examples"]) if d["examples"] else []
+                result.append(d)
+            return result
+        finally:
+            conn.close()
+
+    def clear_patterns(self) -> None:
+        """Delete all stored patterns (called before re-computing)."""
+        conn = self._conn()
+        try:
+            conn.execute("DELETE FROM prompt_patterns")
+            conn.commit()
+        finally:
+            conn.close()
+
+    def upsert_term_stats(self, term: str, count: int, df: int, tfidf_avg: float) -> None:
+        """Insert or update term statistics."""
+        conn = self._conn()
+        try:
+            conn.execute(
+                """INSERT INTO term_stats (term, count, df, tfidf_avg)
+                   VALUES (?, ?, ?, ?)
+                   ON CONFLICT(term) DO UPDATE SET
+                     count = excluded.count,
+                     df = excluded.df,
+                     tfidf_avg = excluded.tfidf_avg""",
+                (term, count, df, tfidf_avg),
+            )
+            conn.commit()
+        finally:
+            conn.close()
+
+    def get_term_stats(self, limit: int = 50) -> list[dict[str, Any]]:
+        """Return top terms by count."""
+        conn = self._conn()
+        try:
+            rows = conn.execute(
+                "SELECT * FROM term_stats ORDER BY count DESC LIMIT ?", (limit,)
+            ).fetchall()
+            return [dict(r) for r in rows]
+        finally:
+            conn.close()
+
+    def purge_old_prompts(self, retention_days: int = 90) -> int:
+        """Delete prompts older than retention_days. Returns count deleted.
+
+        Two-pass: first remove duplicates pointing to old prompts,
+        then remove the old prompts themselves.
+        """
+        cutoff = (datetime.now(timezone.utc) - timedelta(days=retention_days)).isoformat()
+        conn = self._conn()
+        try:
+            # Pass 1: clear duplicate_of references to soon-deleted prompts
+            conn.execute(
+                """UPDATE prompts SET duplicate_of = NULL
+                   WHERE duplicate_of IN (
+                       SELECT id FROM prompts WHERE timestamp < ? AND timestamp != ''
+                   )""",
+                (cutoff,),
+            )
+            # Pass 2: delete old prompts
+            cursor = conn.execute(
+                "DELETE FROM prompts WHERE timestamp < ? AND timestamp != ''",
+                (cutoff,),
+            )
+            deleted = cursor.rowcount
+            conn.commit()
+            return deleted
+        finally:
+            conn.close()
+
+    def get_stats(self) -> dict[str, Any]:
+        """Return summary statistics."""
+        conn = self._conn()
+        try:
+            total = conn.execute("SELECT COUNT(*) FROM prompts").fetchone()[0]
+            unique = conn.execute(
+                "SELECT COUNT(*) FROM prompts WHERE duplicate_of IS NULL"
+            ).fetchone()[0]
+            sessions = conn.execute("SELECT COUNT(*) FROM processed_sessions").fetchone()[0]
+            patterns = conn.execute("SELECT COUNT(*) FROM prompt_patterns").fetchone()[0]
+            date_range = conn.execute(
+                "SELECT MIN(timestamp), MAX(timestamp) FROM prompts WHERE timestamp != ''"
+            ).fetchone()
+            return {
+                "total_prompts": total,
+                "unique_prompts": unique,
+                "sessions_processed": sessions,
+                "patterns": patterns,
+                "earliest": date_range[0] if date_range else None,
+                "latest": date_range[1] if date_range else None,
+            }
+        finally:
+            conn.close()

reprompt_cli-0.1.1.dist-info/METADATA

@@ -0,0 +1,198 @@
+Metadata-Version: 2.4
+Name: reprompt-cli
+Version: 0.1.1
+Summary: Discover, analyze, and evolve your best prompts from AI coding sessions
+Project-URL: Homepage, https://github.com/reprompt-dev/reprompt
+Project-URL: Repository, https://github.com/reprompt-dev/reprompt
+Project-URL: Issues, https://github.com/reprompt-dev/reprompt/issues
+Project-URL: Changelog, https://github.com/reprompt-dev/reprompt/blob/main/CHANGELOG.md
+License: MIT
+License-File: LICENSE
+Keywords: ai,analytics,claude-code,cli,llm,prompt
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: pydantic-settings>=2.0
+Requires-Dist: rich>=13.0
+Requires-Dist: scikit-learn>=1.4
+Requires-Dist: typer>=0.9
+Provides-Extra: dev
+Requires-Dist: mypy>=1.0; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Provides-Extra: local
+Requires-Dist: sentence-transformers>=2.0; extra == 'local'
+Provides-Extra: ollama
+Requires-Dist: requests>=2.31; extra == 'ollama'
+Provides-Extra: openai
+Requires-Dist: openai>=1.0; extra == 'openai'
+Description-Content-Type: text/markdown
+
+# reprompt
+
+[![CI](https://github.com/reprompt-dev/reprompt/actions/workflows/ci.yml/badge.svg)](https://github.com/reprompt-dev/reprompt/actions/workflows/ci.yml)
+[![PyPI version](https://img.shields.io/pypi/v/reprompt-cli)](https://pypi.org/project/reprompt-cli/)
+[![Python](https://img.shields.io/pypi/pyversions/reprompt-cli)](https://pypi.org/project/reprompt-cli/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+> Discover, analyze, and evolve your best prompts from AI coding sessions.
+
+Every developer's AI session history contains reusable prompt patterns -- scattered across hundreds of session files. **reprompt** extracts them, deduplicates, analyzes frequency, and builds a personal prompt library that evolves over time.
+
+## Quick Start
+
+```bash
+pipx install reprompt-cli
+reprompt scan
+reprompt report
+reprompt library
+```
+
+## Features
+
+- **Auto-detection** -- finds Claude Code and OpenClaw sessions automatically
+- **Two-layer dedup** -- SHA-256 exact + TF-IDF semantic similarity
+- **Hot terms analysis** -- TF-IDF discovers your most-used technical terms
+- **K-means clustering** -- groups similar prompts into themes
+- **Prompt library** -- extracts high-frequency patterns, auto-categorizes (debug/implement/test/review/refactor/explain/config)
+- **Rich reports** -- beautiful terminal output with tables and bar charts
+- **Multiple formats** -- terminal, JSON (for pipelines), Markdown (for docs)
+- **Pluggable adapters** -- add support for any AI coding tool
+- **Zero config** -- works out of the box, customize via env vars or TOML
+
+## Supported AI Tools
+
+| Tool | Status | Session Path |
+|------|--------|-------------|
+| Claude Code | Supported | `~/.claude/projects/` |
+| OpenClaw / OpenCode | Supported | `~/.opencode/sessions/` |
+| Cursor | Planned | -- |
+| Codex CLI | Planned | -- |
+| Gemini CLI | Planned | -- |
+
+## Usage
+
+```bash
+# Scan all detected AI tools
+reprompt scan
+
+# Scan specific source
+reprompt scan --source claude-code
+
+# Scan custom path
+reprompt scan --path ~/custom/sessions
+
+# Rich terminal report
+reprompt report
+
+# JSON output (for CI/pipelines)
+reprompt report --format json
+
+# View your prompt library
+reprompt library
+
+# Filter by category
+reprompt library --category debug
+
+# Export prompt library as Markdown
+reprompt library prompts.md
+
+# Database stats
+reprompt status
+
+# Auto-scan after sessions
+reprompt install-hook
+
+# Cleanup old data
+reprompt purge --older-than 90d
+```
+
+## Terminal Report
+
+```
+reprompt -- AI Session Analytics
+========================================
+
+ Overview
+ Total prompts:        1,247
+ Unique (deduped):       832
+ Sessions scanned:       156
+ Sources: claude-code, openclaw
+
+ Top Prompt Patterns
+ #  | Pattern                  | Count | Category
+ 1  | fix the failing test...  |    42 | debug
+ 2  | add unit tests for...    |    38 | test
+ 3  | refactor X to use...     |    27 | refactor
+```
+
+## Configuration
+
+Zero config by default. Customize with environment variables or TOML:
+
+```bash
+# Environment variables (prefix: REPROMPT_)
+REPROMPT_EMBEDDING_BACKEND=ollama reprompt scan
+REPROMPT_DB_PATH=~/custom/reprompt.db reprompt status
+```
+
+```toml
+# ~/.config/reprompt/config.toml
+[embedding]
+backend = "tfidf"  # tfidf | ollama | local | openai
+
+[storage]
+db_path = "~/.local/share/reprompt/reprompt.db"
+
+[dedup]
+semantic_threshold = 0.85
+
+[library]
+min_frequency = 3
+```
+
+## Optional Backends
+
+```bash
+pip install reprompt-cli[ollama]   # Ollama API embeddings
+pip install reprompt-cli[local]    # sentence-transformers (CPU)
+pip install reprompt-cli[openai]   # OpenAI API embeddings
+```
+
+## Adding an Adapter
+
+Create a new adapter by subclassing `BaseAdapter`:
+
+```python
+from reprompt.adapters.base import BaseAdapter
+from reprompt.core.models import Prompt
+
+class MyToolAdapter(BaseAdapter):
+    name = "my-tool"
+    default_session_path = "~/.my-tool/sessions"
+
+    def parse_session(self, path):
+        # Parse session file -> list[Prompt]
+        ...
+
+    def detect_installed(self):
+        return Path(self.default_session_path).expanduser().exists()
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup and guidelines.
+
+## License
+
+MIT

reprompt_cli-0.1.1.dist-info/RECORD

@@ -0,0 +1,29 @@
+reprompt/__init__.py,sha256=ssgV9xNer2bW8O0achjE8LP17vwUmTOMVoX9_T4Ute4,149
+reprompt/cli.py,sha256=GrI_21s6QOpdrcjnF2ERY2N_nJt6eMchPKbOH8QYbDU,5849
+reprompt/config.py,sha256=Wt5MqVKC18jU07lAsa6wKqSktw7FB2k-Kb6Uw7sVLVg,1061
+reprompt/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reprompt/adapters/__init__.py,sha256=_LbAhUS_85bD9weFW9LnM-4x-EkIo-sTPZGP6z1fgVM,88
+reprompt/adapters/base.py,sha256=rdG6yUDB7EWw7i066l2V6WmBE663LNAUdJ29sF3iveU,617
+reprompt/adapters/claude_code.py,sha256=jLQ2zog2N0HBEaeq2xS9k4th5a58UajHmJ601wj8zSI,3825
+reprompt/adapters/openclaw.py,sha256=_yVRT5eKYkE6LB9zGmm-obbqzYg4BRlf3fdO6o52jkM,2555
+reprompt/core/__init__.py,sha256=GuzztUmW-OJWi7iC_4IRg3L_tGAe-dcdyP4URC_s7KE,36
+reprompt/core/analyzer.py,sha256=E9qnq3eHTie5EPRXw0Y6qlVHWlXNnNubQM79dEQ5NM4,2050
+reprompt/core/dedup.py,sha256=z_3_qLjxvqmRJhWr53KkdOCzdaCGs2X_D3vhHSjkS04,2855
+reprompt/core/library.py,sha256=mPIOdz0unBEfuB_fNTzBwkVEv3SVplFg_pPvVavLsXk,3268
+reprompt/core/models.py,sha256=eJsiBe_nN6BkjKCEVy_x12EayVEVa2AlvKVtDuzSKgI,568
+reprompt/core/pipeline.py,sha256=j59JNJZDzzqii9wstpyiwnCHvVjcuK-qLdJhov2SdRw,5209
+reprompt/embeddings/__init__.py,sha256=l1ssUD_h7Y0Ax1lAx3-KI9RUGM1oTFpibDWBSMP-DEM,86
+reprompt/embeddings/base.py,sha256=XvftNdsWiSg67JE_W8zpmO0NL2KJhc0VhYnOH0167Ms,629
+reprompt/embeddings/ollama.py,sha256=Rpi54N4q3t5pwrDzQIy-YaVFoMFwsFH2gHSKjYoovi4,1549
+reprompt/embeddings/tfidf.py,sha256=gJd9Tvf35Nxwbm9Zxm9iSE4tUrAlBcBpRl_FVA-PgFo,702
+reprompt/output/__init__.py,sha256=xwGXiWjcpVgKoLDYwAdN9LbpviSKNnO1qgUBexj5IhQ,46
+reprompt/output/json_out.py,sha256=ip70Oj2EImHepevKCPtf_ztBYH98FEQwVJcDKW96kT0,249
+reprompt/output/markdown.py,sha256=4nCXiBYKS0NQqD_h2p71sqDzWKPFkn1fj1XOfqEuXh0,1656
+reprompt/output/terminal.py,sha256=UFFy715T6IeYZiAz24iIg3ql_Y8Pz6f-mHY5CkO4PMk,2383
+reprompt/storage/__init__.py,sha256=etUD91sg2hoIGrPQUSZWI6jTbaOc_d-lWjlmrxvF9Mk,40
+reprompt/storage/db.py,sha256=Yoh_9G_EC7nfVj1uoODltbVUQHg_UZNxV8BM6iqF1IM,11061
+reprompt_cli-0.1.1.dist-info/METADATA,sha256=VhPTPVFIPe-F1bDXrl6Wmr5nv88Hc3A-BVArE7UuG_0,5848
+reprompt_cli-0.1.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+reprompt_cli-0.1.1.dist-info/entry_points.txt,sha256=VQTi0S-vVU8YIfEZU_aOm6SHBpRPuN3Wh7MzLhemb_Y,46
+reprompt_cli-0.1.1.dist-info/licenses/LICENSE,sha256=5xJBBHKoDOoUfG1iXzCmBScu7I-L4qIxWEm8jaYnzgo,1069
+reprompt_cli-0.1.1.dist-info/RECORD,,

reprompt_cli-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

reprompt_cli-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+reprompt = reprompt.cli:app

reprompt_cli-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 reprompt-dev
+
+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.