promptdiff-cli 0.1.0__py3-none-any.whl

promptdiff/__init__.py

@@ -0,0 +1 @@
+# PromptDiff package

promptdiff/api/__init__.py

@@ -0,0 +1 @@
+# API package

promptdiff/cli/__init__.py

@@ -0,0 +1 @@
+# CLI package

promptdiff/cli/context.py

@@ -0,0 +1,52 @@
+import os
+import json
+from pathlib import Path
+from contextlib import contextmanager
+from typing import Generator
+from sqlalchemy.orm import Session
+import typer
+
+from promptdiff.db.session import get_db
+
+def get_config_dir() -> Path:
+    """Get the configuration directory path, allowing environment override for tests."""
+    env_home = os.environ.get("PROMPTDIFF_HOME")
+    if env_home:
+        return Path(env_home)
+    return Path.home() / ".promptdiff"
+
+def get_config_path() -> Path:
+    """Get the path to the config.json file."""
+    return get_config_dir() / "config.json"
+
+def resolve_project(explicit: str | None) -> str:
+    """Resolve the project name using explicit override or current project config.
+    
+    Raises typer.Exit(code=1) if no project name can be resolved.
+    """
+    if explicit:
+        return explicit
+
+    config_file = get_config_path()
+    if config_file.is_file():
+        try:
+            with open(config_file, "r") as f:
+                data = json.load(f)
+                current = data.get("current_project")
+                if current:
+                    return current
+        except Exception:
+            pass
+
+    typer.secho(
+        "Error: No project specified. Use --project or run `promptdiff use <project>` first.",
+        fg=typer.colors.RED,
+        err=True
+    )
+    raise typer.Exit(code=1)
+
+@contextmanager
+def get_cli_db() -> Generator[Session, None, None]:
+    """Yield a database session and guarantee it closes correctly."""
+    with get_db() as db:
+        yield db

promptdiff/cli/main.py

@@ -0,0 +1,338 @@
+import json
+from pathlib import Path
+from typing import List
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+import sys
+
+def get_symbol(char: str, fallback: str) -> str:
+    try:
+        encoding = sys.stdout.encoding or "utf-8"
+        char.encode(encoding)
+        return char
+    except Exception:
+        return fallback
+
+CHECKMARK = get_symbol("✓", "+")
+CROSSMARK = get_symbol("✗", "x")
+
+from promptdiff.cli.context import resolve_project, get_cli_db, get_config_dir, get_config_path
+import promptdiff.core.projects as projects_core
+import promptdiff.core.prompts as prompts_core
+import promptdiff.core.versions as versions_core
+import promptdiff.core.diff as diff_core
+import promptdiff.core.runner as runner_core
+from promptdiff.core.exceptions import (
+    ProjectAlreadyExists,
+    ProjectNotFound,
+    PromptAlreadyExists,
+    PromptNotFound,
+    VersionNotFound,
+    PromptDiffError
+)
+
+app = typer.Typer(no_args_is_help=True, help="PromptDiff — Git-like prompt versioning and LLM testing CLI.")
+project_app = typer.Typer(no_args_is_help=True, help="Manage PromptDiff projects.")
+app.add_typer(project_app, name="project")
+
+console = Console()
+err_console = Console(stderr=True)
+
+# --- Project Commands ---
+
+@project_app.command("create")
+def project_create(
+    name: str = typer.Argument(..., help="Name of the project to create."),
+    description: str = typer.Option(None, "--description", "-d", help="Description of the project.")
+):
+    """Create a new project."""
+    with get_cli_db() as db:
+        try:
+            projects_core.create_project(db, name, description)
+            console.print(f"[bold green]{CHECKMARK}[/bold green] Created project '[bold]{name}[/bold]'")
+        except ProjectAlreadyExists as e:
+            console.print(f"[bold red]Error:[/bold red] {e}")
+            raise typer.Exit(code=1)
+
+@project_app.command("list")
+def project_list():
+    """List all projects."""
+    with get_cli_db() as db:
+        projects = projects_core.list_projects(db)
+        if not projects:
+            console.print("[yellow]No projects found.[/yellow]")
+            return
+
+        table = Table(title="PromptDiff Projects", border_style="cyan")
+        table.add_column("Name", style="bold magenta")
+        table.add_column("Description")
+        table.add_column("Created At", style="dim")
+
+        for p in projects:
+            created_str = p.created_at.strftime("%Y-%m-%d %H:%M:%S") if p.created_at else ""
+            table.add_row(p.name, p.description or "", created_str)
+
+        console.print(table)
+
+# --- Workflow Commands ---
+
+@app.command("use")
+def use_project(
+    name: str = typer.Argument(..., help="Name of the project to use by default.")
+):
+    """Set the current project context."""
+    with get_cli_db() as db:
+        project = projects_core.get_project(db, name)
+        if not project:
+            err_console.print(f"[bold red]Error:[/bold red] Project '{name}' does not exist.")
+            err_console.print(f"[yellow]Suggest running:[/yellow] promptdiff project create {name}")
+            raise typer.Exit(code=1)
+
+        config_dir = get_config_dir()
+        config_dir.mkdir(parents=True, exist_ok=True)
+        config_file = get_config_path()
+        try:
+            with open(config_file, "w") as f:
+                json.dump({"current_project": name}, f)
+            console.print(f"[bold green]{CHECKMARK}[/bold green] Using project '[bold]{name}[/bold]'")
+        except Exception as e:
+            err_console.print(f"[bold red]Error saving config:[/bold red] {e}")
+            raise typer.Exit(code=1)
+
+@app.command("add")
+def add_prompt(
+    prompt_name: str = typer.Argument(..., help="Name of the prompt to add."),
+    project: str = typer.Option(None, "--project", "-p", help="Project name override.")
+):
+    """Add a new prompt to the project."""
+    project_name = resolve_project(project)
+    with get_cli_db() as db:
+        try:
+            prompts_core.create_prompt(db, project_name, prompt_name)
+            console.print(f"[bold green]{CHECKMARK}[/bold green] Added prompt '[bold]{prompt_name}[/bold]' to project '[bold]{project_name}[/bold]'")
+        except (ProjectNotFound, PromptAlreadyExists) as e:
+            console.print(f"[bold red]Error:[/bold red] {e}")
+            raise typer.Exit(code=1)
+
+@app.command("commit")
+def commit_prompt(
+    prompt_name: str = typer.Argument(..., help="Name of the prompt to commit to."),
+    content_or_file: str = typer.Argument(
+        ...,
+        help="Literal prompt content OR path to a text file containing the prompt content."
+    ),
+    message: str = typer.Option(None, "--message", "-m", help="Commit message describing the changes."),
+    project: str = typer.Option(None, "--project", "-p", help="Project name override.")
+):
+    """Commit a new version of a prompt's content."""
+    project_name = resolve_project(project)
+    
+    # Smart check: file vs literal content
+    path = Path(content_or_file)
+    if path.is_file():
+        try:
+            content = path.read_text(encoding="utf-8")
+        except Exception as e:
+            console.print(f"[bold red]Error reading file '{content_or_file}':[/bold red] {e}")
+            raise typer.Exit(code=1)
+    else:
+        content = content_or_file
+
+    with get_cli_db() as db:
+        try:
+            version = versions_core.commit_version(db, project_name, prompt_name, content, message)
+            console.print(f"[bold green]{CHECKMARK}[/bold green] Committed prompt '[bold]{prompt_name}[/bold]' as v{version.version_number}")
+        except PromptNotFound as e:
+            console.print(f"[bold red]Error:[/bold red] {e}")
+            raise typer.Exit(code=1)
+
+@app.command("log")
+def log_prompt(
+    prompt_name: str = typer.Argument(..., help="Name of the prompt to show logs for."),
+    project: str = typer.Option(None, "--project", "-p", help="Project name override.")
+):
+    """Show the version commit history of a prompt."""
+    project_name = resolve_project(project)
+    with get_cli_db() as db:
+        try:
+            versions = versions_core.list_versions(db, project_name, prompt_name)
+            if not versions:
+                console.print(f"[yellow]No commits found for prompt '{prompt_name}'.[/yellow]")
+                return
+
+            table = Table(title=f"Commit Log: {prompt_name} (Project: {project_name})", border_style="cyan")
+            table.add_column("Version", style="bold magenta")
+            table.add_column("Commit Message")
+            table.add_column("Created At", style="dim")
+            table.add_column("Content Preview", style="italic dim")
+
+            for v in versions:
+                created_str = v.created_at.strftime("%Y-%m-%d %H:%M:%S") if v.created_at else ""
+                preview = v.content[:50].replace("\n", " ")
+                if len(v.content) > 50:
+                    preview += "..."
+                table.add_row(f"v{v.version_number}", v.commit_message or "", created_str, preview)
+
+            console.print(table)
+        except PromptNotFound as e:
+            console.print(f"[bold red]Error:[/bold red] {e}")
+            raise typer.Exit(code=1)
+
+@app.command("diff")
+def diff_prompt(
+    prompt_name: str = typer.Argument(..., help="Name of the prompt to compare."),
+    version_a: int = typer.Argument(..., help="Source version number."),
+    version_b: int = typer.Argument(..., help="Target version number."),
+    project: str = typer.Option(None, "--project", "-p", help="Project name override.")
+):
+    """Compare two versions of a prompt."""
+    project_name = resolve_project(project)
+    with get_cli_db() as db:
+        v_a = versions_core.get_version(db, project_name, prompt_name, version_a)
+        if not v_a:
+            console.print(f"[bold red]Error:[/bold red] Version {version_a} of prompt '{prompt_name}' in project '{project_name}' not found.")
+            raise typer.Exit(code=1)
+        v_b = versions_core.get_version(db, project_name, prompt_name, version_b)
+        if not v_b:
+            console.print(f"[bold red]Error:[/bold red] Version {version_b} of prompt '{prompt_name}' in project '{project_name}' not found.")
+            raise typer.Exit(code=1)
+
+        diff_result = diff_core.diff_versions(v_a, v_b)
+        console.print(f"[bold]Diffing prompt '{prompt_name}' (Project: {project_name}) between v{version_a} and v{version_b}:[/bold]\n")
+        
+        for line in diff_result.lines:
+            if line.line_type == "unchanged":
+                console.print(f"  {line.new_content or ''}")
+            elif line.line_type == "added":
+                console.print(f"+ {line.new_content or ''}", style="green")
+            elif line.line_type == "removed":
+                console.print(f"- {line.old_content or ''}", style="red")
+            elif line.line_type == "modified":
+                text = Text()
+                text.append("~ ")
+                for wd in line.word_diffs or []:
+                    if wd.change_type == "unchanged":
+                        text.append(wd.text)
+                    elif wd.change_type == "added":
+                        text.append(wd.text, style="bold green")
+                    elif wd.change_type == "removed":
+                        text.append(wd.text, style="red strike")
+                console.print(text)
+
+@app.command("run")
+def run_prompt_versions(
+    prompt_name: str = typer.Argument(..., help="Name of the prompt to execute."),
+    version_number: int = typer.Argument(..., help="Version number to execute."),
+    model: List[str] = typer.Option(
+        ["gemini/gemini-2.5-flash"],
+        "--model",
+        help="LLM model(s) to run the prompt on. Can be specified multiple times."
+    ),
+    project: str = typer.Option(None, "--project", "-p", help="Project name override.")
+):
+    """Run a prompt version against one or more models."""
+    project_name = resolve_project(project)
+    with get_cli_db() as db:
+        # Check if version exists first
+        version = versions_core.get_version(db, project_name, prompt_name, version_number)
+        if not version:
+            console.print(
+                f"[bold red]Error:[/bold red] Version {version_number} of prompt '{prompt_name}' "
+                f"in project '{project_name}' not found."
+            )
+            raise typer.Exit(code=1)
+
+        for m in model:
+            with console.status(f"Running '{prompt_name}' v{version_number} on {m}..."):
+                run_res = runner_core.run_prompt(db, project_name, prompt_name, version_number, model=m)
+
+            if run_res.status == "success":
+                output_text = f"[bold green]{CHECKMARK}[/bold green] {m}: success in {run_res.latency_ms}ms"
+                token_info = []
+                if run_res.output:
+                    if run_res.output.prompt_tokens is not None:
+                        token_info.append(f"prompt: {run_res.output.prompt_tokens}")
+                    if run_res.output.completion_tokens is not None:
+                        token_info.append(f"completion: {run_res.output.completion_tokens}")
+                if token_info:
+                    output_text += f" ({', '.join(token_info)})"
+                if run_res.output and run_res.output.cost_usd is not None:
+                    output_text += f" | Cost: ${run_res.output.cost_usd:.5f}"
+                console.print(output_text)
+                
+                content = run_res.output.content if run_res.output else ""
+                console.print(Panel(content or "", title=f"Output ({m})", border_style="green"))
+            else:
+                console.print(f"[bold red]{CROSSMARK}[/bold red] {m}: failed in {run_res.latency_ms}ms. Error: {run_res.error_message}")
+
+@app.command("diff-output")
+def diff_output(
+    prompt_name: str = typer.Argument(..., help="Name of the prompt."),
+    version_a: int = typer.Argument(..., help="First version number."),
+    version_b: int = typer.Argument(..., help="Second version number."),
+    model: str = typer.Option(None, "--model", help="Specific model to compare outputs for."),
+    project: str = typer.Option(None, "--project", "-p", help="Project name override.")
+):
+    """Compare the generated outputs of two prompt versions side by side."""
+    project_name = resolve_project(project)
+    with get_cli_db() as db:
+        try:
+            if model:
+                run_a = runner_core.get_latest_successful_run(db, project_name, prompt_name, version_a, model=model)
+                run_b = runner_core.get_latest_successful_run(db, project_name, prompt_name, version_b, model=model)
+                
+                if not run_a:
+                    err_console.print(f"[bold red]Error:[/bold red] No successful run found for version {version_a} with model '{model}'.")
+                    raise typer.Exit(code=1)
+                if not run_b:
+                    err_console.print(f"[bold red]Error:[/bold red] No successful run found for version {version_b} with model '{model}'.")
+                    raise typer.Exit(code=1)
+            else:
+                models_a = runner_core.list_distinct_models_for_version(db, project_name, prompt_name, version_a)
+                models_b = runner_core.list_distinct_models_for_version(db, project_name, prompt_name, version_b)
+                
+                if not models_a:
+                    err_console.print(f"[bold red]Error:[/bold red] No successful execution run found for version {version_a}. Run it first using 'run'.")
+                    raise typer.Exit(code=1)
+                if not models_b:
+                    err_console.print(f"[bold red]Error:[/bold red] No successful execution run found for version {version_b}. Run it first using 'run'.")
+                    raise typer.Exit(code=1)
+                
+                run_a = runner_core.get_latest_successful_run(db, project_name, prompt_name, version_a)
+                run_b = runner_core.get_latest_successful_run(db, project_name, prompt_name, version_b)
+                
+                has_ambiguity = (
+                    len(models_a) > 1 or 
+                    len(models_b) > 1 or 
+                    run_a.model != run_b.model
+                )
+                
+                if has_ambiguity:
+                    err_console.print(f"[bold yellow]Ambiguity detected:[/bold yellow] Multiple models exist across versions.")
+                    err_console.print(f"Version {version_a} models: {', '.join(models_a)}")
+                    err_console.print(f"Version {version_b} models: {', '.join(models_b)}")
+                    err_console.print("\nPlease specify [bold]--model[/bold] to choose which model to compare.")
+                    raise typer.Exit(code=1)
+                
+            table = Table.grid(expand=True, padding=2)
+            table.add_column(ratio=1)
+            table.add_column(ratio=1)
+
+            content_a = run_a.output.content if run_a.output else ""
+            content_b = run_b.output.content if run_b.output else ""
+
+            table.add_row(
+                Panel(content_a or "", title=f"v{version_a} Output ({run_a.model})", border_style="cyan"),
+                Panel(content_b or "", title=f"v{version_b} Output ({run_b.model})", border_style="magenta")
+            )
+            console.print(table)
+            
+        except VersionNotFound as e:
+            err_console.print(f"[bold red]Error:[/bold red] {e}")
+            raise typer.Exit(code=1)
+
+if __name__ == "__main__":
+    app()

promptdiff/core/__init__.py

@@ -0,0 +1 @@
+# Core package

promptdiff/core/diff.py

@@ -0,0 +1,126 @@
+import re
+from dataclasses import dataclass
+from typing import Literal, List, Optional
+from difflib import SequenceMatcher
+from promptdiff.db.models import Version
+
+@dataclass
+class WordDiff:
+    text: str
+    change_type: Literal["unchanged", "added", "removed"]
+
+@dataclass
+class DiffLine:
+    line_type: Literal["unchanged", "added", "removed", "modified"]
+    old_content: Optional[str]
+    new_content: Optional[str]
+    word_diffs: Optional[List[WordDiff]] = None  # only populated if line_type == "modified"
+
+@dataclass
+class DiffResult:
+    from_version: int
+    to_version: int
+    lines: List[DiffLine]
+
+def _split_words(line: str) -> List[str]:
+    # Match alphanumeric words, whitespace sequences, or individual punctuation marks
+    return re.findall(r'\w+|\s+|[^\w\s]', line)
+
+def _diff_words(old_line: str, new_line: str) -> List[WordDiff]:
+    old_words = _split_words(old_line)
+    new_words = _split_words(new_line)
+    
+    matcher = SequenceMatcher(None, old_words, new_words)
+    word_diffs = []
+    
+    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+        if tag == 'equal':
+            for w in old_words[i1:i2]:
+                word_diffs.append(WordDiff(text=w, change_type="unchanged"))
+        elif tag == 'delete':
+            for w in old_words[i1:i2]:
+                word_diffs.append(WordDiff(text=w, change_type="removed"))
+        elif tag == 'insert':
+            for w in new_words[j1:j2]:
+                word_diffs.append(WordDiff(text=w, change_type="added"))
+        elif tag == 'replace':
+            for w in old_words[i1:i2]:
+                word_diffs.append(WordDiff(text=w, change_type="removed"))
+            for w in new_words[j1:j2]:
+                word_diffs.append(WordDiff(text=w, change_type="added"))
+                
+    return word_diffs
+
+def diff_versions(version_a: Version, version_b: Version) -> DiffResult:
+    """Compare two versions line-by-line, and compute word-level diffs for modified lines.
+    
+    Returns a DiffResult structure detailing the changes.
+    """
+    lines_a = version_a.content.splitlines() if version_a.content else []
+    lines_b = version_b.content.splitlines() if version_b.content else []
+    
+    matcher = SequenceMatcher(None, lines_a, lines_b)
+    diff_lines = []
+    
+    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+        if tag == 'equal':
+            for line in lines_a[i1:i2]:
+                diff_lines.append(DiffLine(
+                    line_type="unchanged",
+                    old_content=line,
+                    new_content=line
+                ))
+        elif tag == 'delete':
+            for line in lines_a[i1:i2]:
+                diff_lines.append(DiffLine(
+                    line_type="removed",
+                    old_content=line,
+                    new_content=None
+                ))
+        elif tag == 'insert':
+            for line in lines_b[j1:j2]:
+                diff_lines.append(DiffLine(
+                    line_type="added",
+                    old_content=None,
+                    new_content=line
+                ))
+        elif tag == 'replace':
+            del_block = lines_a[i1:i2]
+            ins_block = lines_b[j1:j2]
+            
+            # Pair them up where possible
+            min_len = min(len(del_block), len(ins_block))
+            for idx in range(min_len):
+                old_l = del_block[idx]
+                new_l = ins_block[idx]
+                w_diff = _diff_words(old_l, new_l)
+                diff_lines.append(DiffLine(
+                    line_type="modified",
+                    old_content=old_l,
+                    new_content=new_l,
+                    word_diffs=w_diff
+                ))
+            
+            # Remaining deletions (treated as pure removed)
+            if len(del_block) > min_len:
+                for line in del_block[min_len:]:
+                    diff_lines.append(DiffLine(
+                        line_type="removed",
+                        old_content=line,
+                        new_content=None
+                    ))
+            
+            # Remaining insertions (treated as pure added)
+            if len(ins_block) > min_len:
+                for line in ins_block[min_len:]:
+                    diff_lines.append(DiffLine(
+                        line_type="added",
+                        old_content=None,
+                        new_content=line
+                    ))
+                    
+    return DiffResult(
+        from_version=version_a.version_number,
+        to_version=version_b.version_number,
+        lines=diff_lines
+    )

promptdiff/core/exceptions.py

@@ -0,0 +1,23 @@
+class PromptDiffError(Exception):
+    """Base exception for all PromptDiff errors."""
+    pass
+
+class ProjectNotFound(PromptDiffError):
+    """Raised when a requested project is not found."""
+    pass
+
+class ProjectAlreadyExists(PromptDiffError):
+    """Raised when trying to create a project that already exists."""
+    pass
+
+class PromptNotFound(PromptDiffError):
+    """Raised when a requested prompt is not found."""
+    pass
+
+class PromptAlreadyExists(PromptDiffError):
+    """Raised when trying to create a prompt that already exists."""
+    pass
+
+class VersionNotFound(PromptDiffError):
+    """Raised when a requested prompt version is not found."""
+    pass

promptdiff/core/projects.py

@@ -0,0 +1,27 @@
+from sqlalchemy.orm import Session
+from sqlalchemy.exc import IntegrityError
+from promptdiff.db.models import Project
+from promptdiff.core.exceptions import ProjectAlreadyExists
+
+def create_project(db: Session, name: str, description: str | None = None) -> Project:
+    """Create a new project.
+    
+    Raises ProjectAlreadyExists if a project with the same name exists.
+    """
+    project = Project(name=name, description=description)
+    db.add(project)
+    try:
+        db.commit()
+        db.refresh(project)
+    except IntegrityError as e:
+        db.rollback()
+        raise ProjectAlreadyExists(f"Project with name '{name}' already exists.") from e
+    return project
+
+def get_project(db: Session, name: str) -> Project | None:
+    """Retrieve a project by its name."""
+    return db.query(Project).filter(Project.name == name).first()
+
+def list_projects(db: Session) -> list[Project]:
+    """List all projects in the database."""
+    return db.query(Project).all()

promptdiff/core/prompts.py

@@ -0,0 +1,45 @@
+from sqlalchemy.orm import Session
+from sqlalchemy.exc import IntegrityError
+from promptdiff.db.models import Prompt, Project
+from promptdiff.core.exceptions import ProjectNotFound, PromptAlreadyExists
+
+def create_prompt(db: Session, project_name: str, prompt_name: str) -> Prompt:
+    """Create a new prompt within a specified project.
+    
+    Raises ProjectNotFound if the project doesn't exist.
+    Raises PromptAlreadyExists if a prompt with the same name exists in the project.
+    """
+    project = db.query(Project).filter(Project.name == project_name).first()
+    if not project:
+        raise ProjectNotFound(f"Project '{project_name}' not found.")
+    
+    prompt = Prompt(project_id=project.id, name=prompt_name)
+    db.add(prompt)
+    try:
+        db.commit()
+        db.refresh(prompt)
+    except IntegrityError as e:
+        db.rollback()
+        raise PromptAlreadyExists(
+            f"Prompt '{prompt_name}' already exists in project '{project_name}'."
+        ) from e
+    return prompt
+
+def get_prompt(db: Session, project_name: str, prompt_name: str) -> Prompt | None:
+    """Retrieve a prompt by project name and prompt name."""
+    return (
+        db.query(Prompt)
+        .join(Project)
+        .filter(Project.name == project_name, Prompt.name == prompt_name)
+        .first()
+    )
+
+def list_prompts(db: Session, project_name: str) -> list[Prompt]:
+    """List all prompts under a specified project.
+    
+    Raises ProjectNotFound if the project doesn't exist.
+    """
+    project = db.query(Project).filter(Project.name == project_name).first()
+    if not project:
+        raise ProjectNotFound(f"Project '{project_name}' not found.")
+    return project.prompts

promptdiff/core/runner.py

@@ -0,0 +1,213 @@
+import time
+import litellm
+from sqlalchemy.orm import Session
+from dotenv import load_dotenv
+
+from promptdiff.db.models import Version, Run, Output, Prompt, Project
+from promptdiff.core.exceptions import VersionNotFound
+
+# Load environment variables (such as API keys)
+load_dotenv()
+
+def run_prompt(
+    db: Session,
+    project_name: str,
+    prompt_name: str,
+    version_number: int,
+    model: str = "gemini/gemini-2.5-flash"
+) -> Run:
+    """Run a prompt version using LiteLLM and store results.
+    
+    Creates a pending run, executes it, measures latency, and registers the outcome.
+    On success, creates an Output record with response metadata.
+    On failure, logs the error details.
+    Raises VersionNotFound if the version does not exist.
+    """
+    version = (
+        db.query(Version)
+        .join(Prompt)
+        .join(Project)
+        .filter(
+            Project.name == project_name,
+            Prompt.name == prompt_name,
+            Version.version_number == version_number
+        )
+        .first()
+    )
+    if not version:
+        raise VersionNotFound(
+            f"Version {version_number} of prompt '{prompt_name}' in project '{project_name}' not found."
+        )
+
+    # Insert pending Run record
+    run = Run(
+        version_id=version.id,
+        model=model,
+        status="pending"
+    )
+    db.add(run)
+    db.commit()
+    db.refresh(run)
+
+    start_time = time.monotonic()
+    try:
+        # Call LiteLLM completion
+        response = litellm.completion(
+            model=model,
+            messages=[{"role": "user", "content": version.content}]
+        )
+        latency_ms = int((time.monotonic() - start_time) * 1000)
+
+        # Extract content, token counts, and cost
+        resp_content = None
+        prompt_tokens = None
+        completion_tokens = None
+
+        if hasattr(response, "choices") and response.choices:
+            resp_content = response.choices[0].message.content
+        elif isinstance(response, dict) and "choices" in response and response["choices"]:
+            resp_content = response["choices"][0]["message"]["content"]
+
+        if hasattr(response, "usage") and response.usage:
+            prompt_tokens = getattr(response.usage, "prompt_tokens", None)
+            completion_tokens = getattr(response.usage, "completion_tokens", None)
+        elif isinstance(response, dict) and "usage" in response:
+            prompt_tokens = response["usage"].get("prompt_tokens")
+            completion_tokens = response["usage"].get("completion_tokens")
+
+        cost_usd = None
+        try:
+            cost_usd = litellm.completion_cost(completion_response=response)
+        except Exception:
+            pass
+
+        # Update run to success
+        run.status = "success"
+        run.latency_ms = latency_ms
+        db.commit()
+
+        # Save run output details
+        output = Output(
+            run_id=run.id,
+            content=resp_content,
+            prompt_tokens=prompt_tokens,
+            completion_tokens=completion_tokens,
+            cost_usd=cost_usd
+        )
+        db.add(output)
+        db.commit()
+        db.refresh(run)
+
+    except Exception as e:
+        latency_ms = int((time.monotonic() - start_time) * 1000)
+        db.rollback()
+        
+        # Clean error string representation
+        error_msg = str(e)[:1000]
+
+        # Update run as failed
+        run.status = "failed"
+        run.error_message = error_msg
+        run.latency_ms = latency_ms
+        db.commit()
+        db.refresh(run)
+
+    return run
+
+def list_runs_for_version(
+    db: Session,
+    project_name: str,
+    prompt_name: str,
+    version_number: int
+) -> list[Run]:
+    """List all execution runs for a specific version.
+    
+    Raises VersionNotFound if the version does not exist.
+    """
+    version = (
+        db.query(Version)
+        .join(Prompt)
+        .join(Project)
+        .filter(
+            Project.name == project_name,
+            Prompt.name == prompt_name,
+            Version.version_number == version_number
+        )
+        .first()
+    )
+    if not version:
+        raise VersionNotFound(
+            f"Version {version_number} of prompt '{prompt_name}' in project '{project_name}' not found."
+        )
+
+    return (
+        db.query(Run)
+        .filter(Run.version_id == version.id)
+        .order_by(Run.created_at.desc())
+        .all()
+    )
+
+def get_run_output(db: Session, run_id: str) -> Output | None:
+    """Retrieve output details of a specific run."""
+    return db.query(Output).filter(Output.run_id == run_id).first()
+
+def get_latest_successful_run(
+    db: Session,
+    project_name: str,
+    prompt_name: str,
+    version_number: int,
+    model: str | None = None
+) -> Run | None:
+    """Get the latest successful execution run for a specific version, optionally filtered by model."""
+    version = (
+        db.query(Version)
+        .join(Prompt)
+        .join(Project)
+        .filter(
+            Project.name == project_name,
+            Prompt.name == prompt_name,
+            Version.version_number == version_number
+        )
+        .first()
+    )
+    if not version:
+        raise VersionNotFound(
+            f"Version {version_number} of prompt '{prompt_name}' in project '{project_name}' not found."
+        )
+    
+    query = db.query(Run).filter(Run.version_id == version.id, Run.status == "success")
+    if model:
+        query = query.filter(Run.model == model)
+    
+    return query.order_by(Run.created_at.desc()).first()
+
+def list_distinct_models_for_version(
+    db: Session,
+    project_name: str,
+    prompt_name: str,
+    version_number: int
+) -> list[str]:
+    """Get list of distinct models that have successful runs for a specific version."""
+    version = (
+        db.query(Version)
+        .join(Prompt)
+        .join(Project)
+        .filter(
+            Project.name == project_name,
+            Prompt.name == prompt_name,
+            Version.version_number == version_number
+        )
+        .first()
+    )
+    if not version:
+        raise VersionNotFound(
+            f"Version {version_number} of prompt '{prompt_name}' in project '{project_name}' not found."
+        )
+    
+    results = (
+        db.query(Run.model)
+        .filter(Run.version_id == version.id, Run.status == "success")
+        .distinct()
+        .all()
+    )
+    return [r[0] for r in results]

promptdiff/core/versions.py

@@ -0,0 +1,113 @@
+from sqlalchemy import func
+from sqlalchemy.orm import Session
+from promptdiff.db.models import Prompt, Project, Version
+from promptdiff.core.exceptions import PromptNotFound
+
+def commit_version(
+    db: Session,
+    project_name: str,
+    prompt_name: str,
+    content: str,
+    message: str | None = None
+) -> Version:
+    """Commit a new version of the prompt content.
+    
+    Correctly auto-increments version_number scoped per-prompt.
+    Raises PromptNotFound if the prompt doesn't exist.
+    """
+    prompt = (
+        db.query(Prompt)
+        .join(Project)
+        .filter(Project.name == project_name, Prompt.name == prompt_name)
+        .first()
+    )
+    if not prompt:
+        raise PromptNotFound(f"Prompt '{prompt_name}' in project '{project_name}' not found.")
+    
+    # Auto-increment version number per prompt
+    max_version = (
+        db.query(func.max(Version.version_number))
+        .filter(Version.prompt_id == prompt.id)
+        .scalar()
+    )
+    new_version_number = (max_version or 0) + 1
+    
+    version = Version(
+        prompt_id=prompt.id,
+        version_number=new_version_number,
+        content=content,
+        commit_message=message
+    )
+    db.add(version)
+    db.commit()
+    db.refresh(version)
+    return version
+
+def get_version(
+    db: Session,
+    project_name: str,
+    prompt_name: str,
+    version_number: int
+) -> Version | None:
+    """Retrieve a specific version of a prompt by its number."""
+    return (
+        db.query(Version)
+        .join(Prompt)
+        .join(Project)
+        .filter(
+            Project.name == project_name,
+            Prompt.name == prompt_name,
+            Version.version_number == version_number
+        )
+        .first()
+    )
+
+def list_versions(
+    db: Session,
+    project_name: str,
+    prompt_name: str
+) -> list[Version]:
+    """List all versions of a prompt, ordered by version_number ascending.
+    
+    Raises PromptNotFound if the prompt doesn't exist.
+    """
+    prompt = (
+        db.query(Prompt)
+        .join(Project)
+        .filter(Project.name == project_name, Prompt.name == prompt_name)
+        .first()
+    )
+    if not prompt:
+        raise PromptNotFound(f"Prompt '{prompt_name}' in project '{project_name}' not found.")
+    
+    return (
+        db.query(Version)
+        .filter(Version.prompt_id == prompt.id)
+        .order_by(Version.version_number.asc())
+        .all()
+    )
+
+def get_latest_version(
+    db: Session,
+    project_name: str,
+    prompt_name: str
+) -> Version | None:
+    """Retrieve the most recent version of a prompt.
+    
+    Raises PromptNotFound if the prompt doesn't exist.
+    """
+    prompt = (
+        db.query(Prompt)
+        .join(Project)
+        .filter(Project.name == project_name, Prompt.name == prompt_name)
+        .first()
+    )
+    if not prompt:
+        raise PromptNotFound(f"Prompt '{prompt_name}' in project '{project_name}' not found.")
+    
+    return (
+        db.query(Version)
+        .filter(Version.prompt_id == prompt.id)
+        .order_by(Version.version_number.desc())
+        .first()
+    )

promptdiff/db/__init__.py

@@ -0,0 +1 @@
+# DB package

promptdiff/db/base.py

@@ -0,0 +1,4 @@
+from sqlalchemy.orm import DeclarativeBase
+
+class Base(DeclarativeBase):
+    pass

promptdiff/db/models.py

@@ -0,0 +1,105 @@
+import uuid
+from datetime import datetime, timezone
+from typing import List, Optional
+from sqlalchemy import ForeignKey, String, Text, DateTime, UniqueConstraint, Uuid
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from promptdiff.db.base import Base
+
+def get_utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+class Project(Base):
+    __tablename__ = "projects"
+
+    id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, default=uuid.uuid4)
+    name: Mapped[str] = mapped_column(String, unique=True, nullable=False)
+    description: Mapped[Optional[str]] = mapped_column(String, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=get_utc_now)
+
+    # Relationship to Prompt
+    prompts: Mapped[List["Prompt"]] = relationship(
+        back_populates="project",
+        cascade="all, delete-orphan"
+    )
+
+class Prompt(Base):
+    __tablename__ = "prompts"
+
+    id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, default=uuid.uuid4)
+    project_id: Mapped[uuid.UUID] = mapped_column(
+        Uuid, ForeignKey("projects.id", ondelete="CASCADE"), nullable=False
+    )
+    name: Mapped[str] = mapped_column(String, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=get_utc_now)
+
+    # Relationships
+    project: Mapped["Project"] = relationship(back_populates="prompts")
+    versions: Mapped[List["Version"]] = relationship(
+        back_populates="prompt",
+        cascade="all, delete-orphan"
+    )
+
+    __table_args__ = (
+        UniqueConstraint("project_id", "name", name="uq_prompt_project_name"),
+    )
+
+class Version(Base):
+    __tablename__ = "versions"
+
+    id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, default=uuid.uuid4)
+    prompt_id: Mapped[uuid.UUID] = mapped_column(
+        Uuid, ForeignKey("prompts.id", ondelete="CASCADE"), nullable=False
+    )
+    version_number: Mapped[int] = mapped_column(nullable=False)
+    content: Mapped[str] = mapped_column(Text, nullable=False)
+    commit_message: Mapped[Optional[str]] = mapped_column(String, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=get_utc_now)
+
+    # Relationships
+    prompt: Mapped["Prompt"] = relationship(back_populates="versions")
+    runs: Mapped[List["Run"]] = relationship(
+        back_populates="version",
+        cascade="all, delete-orphan"
+    )
+
+    __table_args__ = (
+        UniqueConstraint("prompt_id", "version_number", name="uq_version_prompt_number"),
+    )
+
+class Run(Base):
+    __tablename__ = "runs"
+
+    id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, default=uuid.uuid4)
+    version_id: Mapped[uuid.UUID] = mapped_column(
+        Uuid, ForeignKey("versions.id", ondelete="CASCADE"), nullable=False
+    )
+    model: Mapped[str] = mapped_column(String, nullable=False)
+    status: Mapped[str] = mapped_column(String, nullable=False)  # pending, success, failed
+    error_message: Mapped[Optional[str]] = mapped_column(String, nullable=True)
+    latency_ms: Mapped[Optional[int]] = mapped_column(nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=get_utc_now)
+
+    # Relationships
+    version: Mapped["Version"] = relationship(back_populates="runs")
+    output: Mapped[Optional["Output"]] = relationship(
+        back_populates="run",
+        cascade="all, delete-orphan",
+        uselist=False
+    )
+
+class Output(Base):
+    __tablename__ = "outputs"
+
+    id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, default=uuid.uuid4)
+    run_id: Mapped[uuid.UUID] = mapped_column(
+        Uuid, ForeignKey("runs.id", ondelete="CASCADE"), unique=True, nullable=False
+    )
+    content: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
+    prompt_tokens: Mapped[Optional[int]] = mapped_column(nullable=True)
+    completion_tokens: Mapped[Optional[int]] = mapped_column(nullable=True)
+    cost_usd: Mapped[Optional[float]] = mapped_column(nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=get_utc_now)
+
+    # Relationships
+    run: Mapped["Run"] = relationship(back_populates="output")

promptdiff/db/session.py

@@ -0,0 +1,24 @@
+import os
+from contextlib import contextmanager
+from typing import Generator
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, Session
+
+# Resolve absolute path to project root to keep DB file location consistent
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+DATABASE_URL = f"sqlite:///{os.path.join(BASE_DIR, 'promptdiff.db')}"
+
+engine = create_engine(
+    DATABASE_URL,
+    connect_args={"check_same_thread": False}
+)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+@contextmanager
+def get_db() -> Generator[Session, None, None]:
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

promptdiff_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: promptdiff-cli
+Version: 0.1.0
+Summary: Git for prompts - version, diff, and test your LLM prompts across any model
+Author: Raguram R
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Ragu3175/promptdiff
+Project-URL: Repository, https://github.com/Ragu3175/promptdiff
+Project-URL: Issues, https://github.com/Ragu3175/promptdiff/issues
+Keywords: llm,prompt-engineering,prompt-versioning,cli,litellm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Version Control
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.110.0
+Requires-Dist: uvicorn>=0.28.0
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: alembic>=1.13.0
+Requires-Dist: typer>=0.9.0
+Requires-Dist: rich>=13.7.0
+Requires-Dist: litellm>=1.30.0
+Requires-Dist: python-dotenv>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-mock; extra == "dev"
+Dynamic: license-file
+
+# PromptDiff
+
+**Git for prompts.** Version your LLM prompts, diff them word-by-word, and run any version against Gemini, Groq, or any other LiteLLM-supported model — all from the terminal.
+
+```bash
+promptdiff commit summarizer "Summarize: {text}" -m "v1: baseline"
+promptdiff commit summarizer "Summarize concisely in one sentence: {text}" -m "v2: tighter constraint"
+promptdiff diff summarizer 1 2
+promptdiff run summarizer 2 --model gemini/gemini-2.5-flash
+```
+
+## Why PromptDiff
+
+If you've ever overwritten a prompt and lost the version that actually worked, or pasted two prompt drafts into a doc just to eyeball what changed — PromptDiff is the tool for that. It treats prompts as versioned, diffable artifacts the same way Git treats code, and adds one thing Git can't: running any version against a real LLM and recording exactly what it produced, so you can trace output back to the exact prompt and model that generated it.
+
+## How it's different from other prompt tools
+
+The prompt-tooling space has grown a lot — [Promptfoo](https://github.com/promptfoo/promptfoo) is a mature, YAML-config-based open-source tool with strong CI/eval integration, and platforms like PromptLayer, Langfuse, and Braintrust offer hosted, full-lifecycle prompt management with branching, RBAC, and observability.
+
+PromptDiff isn't trying to compete with those. It's deliberately smaller: a local-first CLI for a single developer iterating on prompts, with zero config files, zero hosted accounts, and zero cost beyond free-tier LLM API usage. If you outgrow it — multiple collaborators, non-engineer prompt editors, compliance requirements — those other tools are the right next step. If you're a solo developer who just wants `git commit`-style version control for prompts without standing up infrastructure, PromptDiff is built for exactly that.
+
+## Features
+
+- **Version control for prompts** — every `commit` is an immutable, numbered version (v1, v2, v3...) scoped per prompt
+- **Word-level diffs** — see exactly which words changed between versions, rendered with color in your terminal (green additions, red strikethrough removals)
+- **Multi-model runs** — execute any prompt version against multiple LLMs in a single command and compare cost, latency, and output side by side
+- **Output comparison** — `diff-output` shows what two versions actually *produced*, not just what their text looks like
+- **Free-tier friendly** — built and tested against Gemini and Groq's free tiers; rate-limit and quota failures are recorded gracefully, never crash the tool
+- **Local-first** — everything lives in a local SQLite database, no account or server required
+
+## Installation
+
+```bash
+pip install promptdiff-cli
+```
+
+(Or, to run from source — see [Development](#development) below.)
+
+## Quick start
+
+```bash
+# Create a project and switch to it
+promptdiff project create my-app
+promptdiff use my-app
+
+# Create a prompt and commit your first version
+promptdiff add summarizer
+promptdiff commit summarizer "Summarize this in one sentence: {text}" -m "v1: baseline"
+
+# Edit and commit a new version
+promptdiff commit summarizer "Summarize concisely, max 20 words: {text}" -m "v2: tighter constraint"
+
+# See version history
+promptdiff log summarizer
+
+# See exactly what changed
+promptdiff diff summarizer 1 2
+
+# Run a version against a model (needs an API key — see below)
+promptdiff run summarizer 2 --model gemini/gemini-2.5-flash
+
+# Run the same version against multiple models at once
+promptdiff run summarizer 2 --model gemini/gemini-2.5-flash --model groq/llama-3.3-70b-versatile
+
+# Compare what two versions actually produced
+promptdiff diff-output summarizer 1 2 --model gemini/gemini-2.5-flash
+```
+
+## API keys
+
+PromptDiff uses [LiteLLM](https://github.com/BerriAI/litellm) under the hood, so it works with any LiteLLM-supported provider. It's built and tested primarily against free tiers:
+
+- **Gemini** — get a free key at [aistudio.google.com/apikey](https://aistudio.google.com/apikey)
+- **Groq** — get a free key at [console.groq.com/keys](https://console.groq.com/keys)
+
+Copy `.env.example` to `.env` in your project directory and fill in the keys you have:
+
+```
+GEMINI_API_KEY=your_key_here
+GROQ_API_KEY=your_key_here
+```
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `promptdiff project create <name>` | Create a new project |
+| `promptdiff project list` | List all projects |
+| `promptdiff use <project>` | Set the current project (so you don't need `--project` on every command) |
+| `promptdiff add <prompt>` | Add a new prompt to the current project |
+| `promptdiff commit <prompt> <content_or_file> -m "<message>"` | Commit a new version. Accepts a literal string or a path to a file |
+| `promptdiff log <prompt>` | Show version history |
+| `promptdiff diff <prompt> <v1> <v2>` | Word-level diff between two versions |
+| `promptdiff run <prompt> <version> --model <model>` | Run a version against one or more models (repeat `--model` to run against several at once) |
+| `promptdiff diff-output <prompt> <v1> <v2> [--model <model>]` | Compare what two versions actually produced. If a version was run against multiple models, `--model` is required to avoid an ambiguous comparison |
+
+Every command accepts `-p` / `--project` to override the current project for that one call.
+
+## Architecture
+
+- **Database**: SQLite, 5 tables (`projects`, `prompts`, `versions`, `runs`, `outputs`) via SQLAlchemy + Alembic migrations
+- **Diff engine**: Python's `difflib`, line-level structure with word-level precision inside changed lines
+- **Runner**: [LiteLLM](https://github.com/BerriAI/litellm) for provider-agnostic model calls; failures (rate limits, timeouts, bad keys) are recorded as failed runs rather than crashing the CLI
+- **CLI**: [Typer](https://typer.tiangolo.com/) + [Rich](https://github.com/Textualize/rich)
+
+## Development
+
+```bash
+git clone https://github.com/Ragu3175/promptdiff.git
+cd promptdiff
+python -m venv venv
+venv\Scripts\activate   # Windows
+# source venv/bin/activate   # macOS/Linux
+pip install -r requirements.txt
+pip install -e .
+pytest -v
+```
+
+## Status
+
+Core CLI is complete and tested: `commit`, `log`, `diff`, `run`, and `diff-output` all work end-to-end against real Gemini and Groq calls. A REST API layer and web UI are planned but not yet built — the CLI is fully usable on its own today.
+
+## Contributing
+
+Issues and PRs welcome. This is an early-stage solo project — if you run into something broken or have an idea, please open an issue.
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+## Author
+
+Built by [Raguram R](https://github.com/Ragu3175).

promptdiff_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+promptdiff/__init__.py,sha256=-ElmcZBCJkYwpgk1LAVKt8XFCpUlV3f2Jf69tV9QiZQ,21
+promptdiff/api/__init__.py,sha256=-HTwAJ8O401KTSPm8ZYja2d0RRn6oj1_SOFX75w-mT0,14
+promptdiff/cli/__init__.py,sha256=23Mz_sVEtHKRAxopQaFKt6FYDaYj4ZG3S9ag1JIlIbA,14
+promptdiff/cli/context.py,sha256=2ROnd8QOpXWUNrlG1-zApjHhO2A45AZ6tE4c7pk9-hc,1534
+promptdiff/cli/main.py,sha256=0j7UhSj-janrZ0X4QQWU4UMHrZ20VEdrfrFvhQ1eK7k,15535
+promptdiff/core/__init__.py,sha256=TETStgToTe7QSsCZgRHDk2oSErlLJoeGN0sFg4Yx2_c,15
+promptdiff/core/diff.py,sha256=8i-wQI4T2hp4x3hP7jfRojR7HCvEz0LIkgsDjqatGhI,4566
+promptdiff/core/exceptions.py,sha256=R2HaS5BgEEadEbSoRg0U7eTD9EYOxg8cdJVAt1WnEHQ,666
+promptdiff/core/projects.py,sha256=glWvok10qPD6jqHOW3_3IvquA-34pPw-J8yYFxoWIXM,975
+promptdiff/core/prompts.py,sha256=KNhAn1Og7yZshzpInkGDCJ4vsTjfjzDnaXwm3BKhsKw,1691
+promptdiff/core/runner.py,sha256=YlHu5pe6gO0EFwIe0C5Ex0SO7vS9XmVZywclULwdH3k,6327
+promptdiff/core/versions.py,sha256=i_L4oCQtcnYzBvMk1Ks4YlLhHYT8FXKoYw82GC-4M20,3066
+promptdiff/db/__init__.py,sha256=k1h6E6ObbcwbVkENlopOZaprvznmy7zTFRjFmddK7Hk,13
+promptdiff/db/base.py,sha256=aCH8LR0m4jZ-wIKkAf1qXAaWt4lckE0hmqWSiFiB7a0,82
+promptdiff/db/models.py,sha256=W5JEYwAt24rPg5PWvlLlMRBswctAzMMCehOf9bS21Vo,4203
+promptdiff/db/session.py,sha256=yRFiET_2lF7Zl1sViCSH8U5lEneyLgQLcDEhs5xeEVs,713
+promptdiff_cli-0.1.0.dist-info/licenses/LICENSE,sha256=iEDhVNZPUT5wbGJybB3oMUeKO_H5cRukGFTLWvZcnL4,1066
+promptdiff_cli-0.1.0.dist-info/METADATA,sha256=Hco7p37LFPKnG7MgIA0UxMQF47WKwbn9zJXulPWu0K8,8050
+promptdiff_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+promptdiff_cli-0.1.0.dist-info/entry_points.txt,sha256=dOnK6W9jqJAFXWkFO6nf0oThPxVDVnViSaBWMZ-5JjM,55
+promptdiff_cli-0.1.0.dist-info/top_level.txt,sha256=o21R8uUq_ASJoZ2e4vALVjGHzLsBznMuj9YgR7mJeLU,11
+promptdiff_cli-0.1.0.dist-info/RECORD,,

promptdiff_cli-0.1.0.dist-info/WHEEL

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

promptdiff_cli-0.1.0.dist-info/entry_points.txt

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

promptdiff_cli-0.1.0.dist-info/licenses/LICENSE

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

promptdiff_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+promptdiff