wtf-dev 0.1.0__py3-none-any.whl

src/cli.py

@@ -0,0 +1,246 @@
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import pyperclip
+import typer
+
+from . import formatter, storage
+from .git import (
+    find_git_repos,
+    get_commit_streak,
+    get_current_branch,
+    get_git_commits,
+    get_git_diff,
+    get_git_diff_stat,
+    get_git_user,
+)
+from .llm import analyze_commits, get_model
+from .models import Commit, RepoSummary, StandupResult, TimeStats, WipSummary
+
+app = typer.Typer(add_completion=False, invoke_without_command=True)
+
+
+@app.command()
+def setup():
+    from .setup import run_setup
+
+    run_setup()
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    dir: Optional[Path] = typer.Option(None, "--dir", "-d"),
+    here: bool = typer.Option(False, "--here", "-H"),
+    days: int = typer.Option(1, "--days", "-n"),
+    author: Optional[str] = typer.Option(None, "--author", "-a"),
+    copy: bool = typer.Option(False, "--copy", "-c"),
+    spending: bool = typer.Option(False, "--spending"),
+    history: bool = typer.Option(False, "--history"),
+    json_out: bool = typer.Option(False, "--json"),
+):
+    # if a subcommand was invoked, skip main logic
+    if ctx.invoked_subcommand is not None:
+        return
+
+    # check if configured, run setup if not
+    if not storage.is_configured():
+        formatter.console.print("[yellow]First time? Let's set up wtf.[/yellow]")
+        from .setup import run_setup
+
+        run_setup()
+        return
+
+    # handle --spending
+    if spending:
+        total = storage.get_total_spent()
+        formatter.render_spending(total)
+        return
+
+    # handle --history
+    if history:
+        past = storage.load_history()
+        for item in past:
+            formatter.console.print(f"[dim]{item.generated_at}[/dim]")
+            formatter.console.print(item.llm_response.summary)
+            formatter.console.print()
+        return
+
+    # main flow
+    scan_path = str(dir) if dir else "."
+    git_author = author or get_git_user() or "unknown"
+
+    # handle monday (show fri-sun)
+    if datetime.now().weekday() == 0:
+        days = max(days, 3)
+
+    # find repos and commits
+    if here:
+        repos = [scan_path]
+    else:
+        repos = find_git_repos(scan_path)
+
+    summaries = []
+    wip_summaries = []
+    all_commits = []
+
+    for repo_path in repos:
+        commits = get_commits(repo_path, git_author, f"{days} days ago")
+        branch = get_current_branch(repo_path)
+
+        if commits:
+            summaries.append(
+                RepoSummary(
+                    name=Path(repo_path).name,
+                    path=repo_path,
+                    commits=commits,
+                    branch=branch,
+                )
+            )
+            all_commits.extend(commits)
+
+        # gather wip (uncommitted changes)
+        diff_stat = get_git_diff_stat(repo_path)
+        if diff_stat:
+            diff = get_git_diff(repo_path)
+            wip_summaries.append(
+                WipSummary(
+                    repo_name=Path(repo_path).name,
+                    files_changed=diff_stat,
+                    diff_preview=diff[:2000],
+                )
+            )
+
+    if not summaries and not wip_summaries:
+        formatter.console.print("[yellow]No commits found.[/yellow]")
+        raise typer.Exit()
+
+    # calculate time stats
+    time_stats = calculate_time_stats(all_commits)
+
+    # get streak
+    streak = get_commit_streak(scan_path, git_author) if summaries else 0
+
+    # call llm
+    commits_text = format_for_llm(summaries) if summaries else "No commits."
+    diff_text = format_wip_for_llm(wip_summaries) if wip_summaries else None
+
+    try:
+        llm_response, cost = analyze_commits(commits_text, diff_text)
+        storage.add_spending(cost, get_model())
+    except Exception as e:
+        formatter.console.print(f"[red]LLM error: {e}[/red]")
+        raise typer.Exit(1)
+
+    # build result
+    result = StandupResult(
+        repos=summaries,
+        llm_response=llm_response,
+        generated_at=datetime.now(),
+        cost_usd=cost,
+        wip=wip_summaries,
+        time_stats=time_stats,
+        streak=streak,
+    )
+
+    # save to history
+    storage.save_standup(result)
+
+    # output
+    if json_out:
+        print(
+            json.dumps(
+                {
+                    "summary": result.llm_response.summary,
+                    "roast": result.llm_response.roast,
+                    "repos": [
+                        {"name": r.name, "commits": len(r.commits)} for r in summaries
+                    ],
+                },
+                indent=2,
+            )
+        )
+    else:
+        formatter.render(result)
+
+    # copy to clipboard
+    if copy:
+        pyperclip.copy(result.llm_response.summary)
+        formatter.render_copied()
+
+
+def get_commits(repo_path: str, author: str, since: str) -> list[Commit]:
+    raw = get_git_commits(repo_path, author, since)
+    if not raw:
+        return []
+
+    commits = []
+    for line in raw.split("\n"):
+        if "|" in line:
+            parts = line.split("|")
+            commits.append(
+                Commit(
+                    hash=parts[0],
+                    message=parts[1],
+                    date=parts[2] if len(parts) > 2 else "",
+                    time=parts[3] if len(parts) > 3 else "",
+                    repo_name=Path(repo_path).name,
+                )
+            )
+    return commits
+
+
+def format_for_llm(summaries: list[RepoSummary]) -> str:
+    lines = []
+    for s in summaries:
+        lines.append(f"\n{s.name} ({len(s.commits)} commits):")
+        for c in s.commits:
+            lines.append(f"  - {c.message}")
+    return "\n".join(lines)
+
+
+def format_wip_for_llm(wip_summaries: list[WipSummary]) -> str:
+    lines = []
+    for wip in wip_summaries:
+        lines.append(f"\n{wip.repo_name} ({len(wip.files_changed)} files changed):")
+        for f in wip.files_changed[:10]:
+            lines.append(f"  {f}")
+        if wip.diff_preview:
+            lines.append(f"\nDiff preview:\n{wip.diff_preview[:1500]}")
+    return "\n".join(lines)
+
+
+def calculate_time_stats(commits: list[Commit]) -> TimeStats:
+    if not commits:
+        return TimeStats()
+
+    late_night = 0
+    early_morning = 0
+
+    for c in commits:
+        if c.time:
+            try:
+                # time is in ISO format like 2026-02-02T23:45:00+05:30
+                hour = int(c.time[11:13])
+                if hour >= 22 or hour < 5:
+                    late_night += 1
+                elif hour < 7:
+                    early_morning += 1
+            except (ValueError, IndexError):
+                pass
+
+    # estimate hours: rough heuristic (15 min per commit minimum)
+    estimated_hours = len(commits) * 0.25
+
+    return TimeStats(
+        total_commits=len(commits),
+        late_night_commits=late_night,
+        early_morning_commits=early_morning,
+        estimated_hours=estimated_hours,
+    )
+
+
+if __name__ == "__main__":
+    app()

src/formatter.py

@@ -0,0 +1,111 @@
+import io
+import sys
+from datetime import datetime
+
+from rich.console import Console
+
+from .models import RepoSummary, StandupResult, WipSummary
+
+# force utf-8 for windows (skip during tests)
+if sys.platform == "win32" and "pytest" not in sys.modules:
+    try:
+        sys.stdout = io.TextIOWrapper(
+            sys.stdout.buffer, encoding="utf-8", errors="replace"
+        )
+    except Exception:
+        pass
+
+console = Console(force_terminal=True)
+
+
+def render(result: StandupResult):
+    # header - clean, no box
+    date_str = datetime.now().strftime("%b %d, %Y")
+    console.print()
+    console.print(
+        f"[bold cyan]PREVIOUSLY ON YOUR CODE...[/bold cyan]  [dim]{date_str}[/dim]"
+    )
+
+    # streak
+    if result.streak > 1:
+        console.print(f"  [yellow]* {result.streak} day streak[/yellow]")
+
+    console.print("[dim]" + "─" * 60 + "[/dim]")
+    console.print()
+
+    # repos as trees
+    for repo in result.repos:
+        render_repo(repo)
+
+    # wip section
+    if result.wip:
+        render_wip(result.wip)
+
+    # branches
+    branches = list(set(r.branch for r in result.repos if r.branch))
+    if len(branches) > 1:
+        console.print(f"   [dim]branches: {', '.join(branches)}[/dim]")
+        console.print()
+
+    # time stats
+    if result.time_stats and result.time_stats.late_night_commits > 0:
+        console.print(
+            f"   [dim]* {result.time_stats.late_night_commits} late night commits[/dim]"
+        )
+        console.print()
+
+    # summary - clean, no box
+    console.print("[dim]" + "─" * 60 + "[/dim]")
+    console.print()
+    console.print(f"  {result.llm_response.summary}")
+
+    # wip summary from llm
+    if result.llm_response.wip_summary:
+        console.print()
+        console.print(
+            f"  [magenta]Currently working on:[/magenta] {result.llm_response.wip_summary}"
+        )
+
+    console.print()
+    console.print(f"  [dim italic]{result.llm_response.roast}[/dim italic]")
+    console.print()
+
+
+def render_repo(repo: RepoSummary):
+    # repo header line
+    commit_count = len(repo.commits)
+    branch_str = f" ({repo.branch})" if repo.branch else ""
+    console.print(
+        f"   [bold]{repo.name}[/bold]{branch_str} [dim]─── {commit_count} commits[/dim]"
+    )
+
+    # tree of commits
+    for i, commit in enumerate(repo.commits):
+        is_last = i == len(repo.commits) - 1
+        prefix = "  └─" if is_last else "  ├─"
+        console.print(f"  {prefix} [dim]{commit.message}[/dim]")
+
+    console.print()
+
+
+def render_wip(wip_list: list[WipSummary]):
+    console.print("   [bold magenta][wip][/bold magenta]")
+    for wip in wip_list:
+        console.print(
+            f"   {wip.repo_name} [dim]─── {len(wip.files_changed)} files changed[/dim]"
+        )
+        for i, f in enumerate(wip.files_changed[:5]):
+            is_last = i == len(wip.files_changed[:5]) - 1
+            prefix = "  └─" if is_last else "  ├─"
+            console.print(f"  {prefix} [dim]{f}[/dim]")
+        if len(wip.files_changed) > 5:
+            console.print(f"  [dim]   ... and {len(wip.files_changed) - 5} more[/dim]")
+    console.print()
+
+
+def render_spending(total: float):
+    console.print(f"[dim]Total API spending: ${total:.6f}[/dim]")
+
+
+def render_copied():
+    console.print("[dim]copied to clipboard[/dim]")

src/git.py

@@ -0,0 +1,187 @@
+import os
+import subprocess
+
+
+def find_git_repos(start_path):
+    # find all git repositories in directory and subdirectories
+    repos = []
+    for root, dirs, files in os.walk(start_path):
+        if ".git" in dirs:
+            repos.append(root)
+            # skip searching inside .git folders
+            dirs[:] = [d for d in dirs if d != ".git"]
+    return repos
+
+
+def get_git_user():
+    # fetch configured git user name
+    try:
+        user = subprocess.check_output(["git", "config", "user.name"]).decode().strip()
+    except subprocess.CalledProcessError:
+        user = None
+    return user
+
+
+def get_git_email():
+    # fetch configured git user email
+    try:
+        email = (
+            subprocess.check_output(["git", "config", "user.email"]).decode().strip()
+        )
+    except subprocess.CalledProcessError:
+        email = None
+    return email
+
+
+def get_git_branch():
+    # fetch current git branch
+    try:
+        branch = (
+            subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"])
+            .decode()
+            .strip()
+        )
+    except subprocess.CalledProcessError:
+        branch = None
+    return branch
+
+
+def get_git_status():
+    # fetch current git status
+    try:
+        status = (
+            subprocess.check_output(["git", "status", "--porcelain"]).decode().strip()
+        )
+    except subprocess.CalledProcessError:
+        status = None
+    return status
+
+
+def get_git_commits(repo_path, author, start_date):
+    # fetch git commits for author and date range
+    # format: hash|message|date|iso_time
+    try:
+        commits = (
+            subprocess.check_output(
+                [
+                    "git",
+                    "log",
+                    "--author",
+                    author,
+                    "--since",
+                    start_date,
+                    "--pretty=format:%h|%s|%ad|%aI",
+                    "--date=short",
+                ],
+                cwd=repo_path,
+            )
+            .decode()
+            .strip()
+        )
+    except subprocess.CalledProcessError:
+        commits = None
+    return commits
+
+
+def get_git_diff(repo_path: str) -> str:
+    # get uncommitted changes (staged + unstaged)
+    try:
+        diff = (
+            subprocess.check_output(
+                ["git", "diff", "HEAD"],
+                cwd=repo_path,
+                stderr=subprocess.DEVNULL,
+            )
+            .decode(errors="replace")
+            .strip()
+        )
+    except subprocess.CalledProcessError:
+        diff = ""
+    return diff
+
+
+def get_git_diff_stat(repo_path: str) -> list[str]:
+    # get file change summary (M/A/D with filenames)
+    try:
+        status = (
+            subprocess.check_output(
+                ["git", "status", "--porcelain"],
+                cwd=repo_path,
+            )
+            .decode()
+            .strip()
+        )
+    except subprocess.CalledProcessError:
+        return []
+
+    if not status:
+        return []
+
+    files = []
+    for line in status.split("\n"):
+        if line.strip():
+            files.append(line.strip())
+    return files
+
+
+def get_current_branch(repo_path: str) -> str:
+    # get current branch name
+    try:
+        branch = (
+            subprocess.check_output(
+                ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+                cwd=repo_path,
+            )
+            .decode()
+            .strip()
+        )
+    except subprocess.CalledProcessError:
+        branch = ""
+    return branch
+
+
+def get_commit_streak(repo_path: str, author: str) -> int:
+    # count consecutive days with commits (including today)
+    from datetime import datetime, timedelta
+
+    try:
+        # get all commit dates for author in last 30 days
+        output = (
+            subprocess.check_output(
+                [
+                    "git",
+                    "log",
+                    "--author",
+                    author,
+                    "--since",
+                    "30 days ago",
+                    "--pretty=format:%ad",
+                    "--date=short",
+                ],
+                cwd=repo_path,
+            )
+            .decode()
+            .strip()
+        )
+    except subprocess.CalledProcessError:
+        return 0
+
+    if not output:
+        return 0
+
+    # get unique dates
+    dates = set(output.split("\n"))
+    today = datetime.now().date()
+
+    # count streak from today backwards
+    streak = 0
+    check_date = today
+    while True:
+        date_str = check_date.strftime("%Y-%m-%d")
+        if date_str in dates:
+            streak += 1
+            check_date -= timedelta(days=1)
+        else:
+            break
+
+    return streak

src/llm.py

@@ -0,0 +1,110 @@
+import json
+
+import requests
+
+from . import storage
+from .models import LLMResponse
+
+OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions"
+DEFAULT_MODEL = "anthropic/claude-3.5-sonnet"
+
+
+def get_api_key() -> str:
+    # get api key from config
+    config = storage.load_config()
+    if config and config.get("api_key"):
+        return config["api_key"]
+    return ""
+
+
+def get_model() -> str:
+    # get model from config
+    config = storage.load_config()
+    if config and config.get("model"):
+        return config["model"]
+    return DEFAULT_MODEL
+
+
+SCHEMA = {
+    "name": "standup",
+    "strict": True,
+    "schema": {
+        "type": "object",
+        "properties": {
+            "summary": {
+                "type": "string",
+                "description": "Standup-ready summary, 2-3 sentences max",
+            },
+            "roast": {
+                "type": "string",
+                "description": "One snarky but friendly observation",
+            },
+            "wip_summary": {
+                "type": "string",
+                "description": "1 sentence about what uncommitted changes suggest you're working on. Empty string if no diff provided.",
+            },
+        },
+        "required": ["summary", "roast", "wip_summary"],
+        "additionalProperties": False,
+    },
+}
+
+SYSTEM_PROMPT = """You generate standup summaries from git commits.
+
+Rules:
+- Summary: 2-3 sentences about committed work, professional but casual
+- Roast: One witty observation about patterns you notice
+- WIP Summary: If diff/uncommitted changes provided, 1 sentence about what's being worked on. Empty if no diff.
+- Be brief. No fluff.
+- Notice: repeated fixes, vague commits, late night work, scattered focus
+"""
+
+
+def analyze_commits(
+    commits_text: str, diff_text: str | None = None
+) -> tuple[LLMResponse, float]:
+    # call openrouter
+    api_key = get_api_key()
+    model = get_model()
+
+    # build user message with commits and optional diff
+    user_content = f"COMMITS:\n{commits_text}"
+    if diff_text:
+        user_content += f"\n\nUNCOMMITTED CHANGES (diff):\n{diff_text}"
+
+    payload = {
+        "model": model,
+        "messages": [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": user_content},
+        ],
+        "response_format": {"type": "json_schema", "json_schema": SCHEMA},
+    }
+
+    # use deepinfra provider for gpt-oss model (cheap + fast)
+    if model == "openai/gpt-oss-120b":
+        payload["provider"] = {"order": ["DeepInfra"]}
+
+    response = requests.post(
+        OPENROUTER_URL,
+        headers={
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+        },
+        json=payload,
+    )
+    response.raise_for_status()
+    data = response.json()
+
+    content = json.loads(data["choices"][0]["message"]["content"])
+    usage = data.get("usage", {})
+    cost = calc_cost(usage)
+
+    return LLMResponse(**content), cost
+
+
+def calc_cost(usage: dict) -> float:
+    # gpt-oss-120b via deepinfra is very cheap
+    prompt = usage.get("prompt_tokens", 0) * 0.0000001
+    completion = usage.get("completion_tokens", 0) * 0.0000002
+    return prompt + completion

src/models.py

@@ -0,0 +1,47 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+
+class Commit(BaseModel):
+    hash: str
+    message: str
+    date: str
+    time: str
+    repo_name: str
+
+
+class RepoSummary(BaseModel):
+    name: str
+    path: str
+    commits: list[Commit]
+    branch: str = ""
+
+
+class WipSummary(BaseModel):
+    repo_name: str
+    files_changed: list[str]
+    diff_preview: str
+
+
+class TimeStats(BaseModel):
+    total_commits: int = 0
+    late_night_commits: int = 0
+    early_morning_commits: int = 0
+    estimated_hours: float = 0.0
+
+
+class LLMResponse(BaseModel):
+    summary: str
+    roast: str
+    wip_summary: str | None = None
+
+
+class StandupResult(BaseModel):
+    repos: list[RepoSummary]
+    llm_response: LLMResponse
+    generated_at: datetime
+    cost_usd: float
+    wip: list[WipSummary] = []
+    time_stats: TimeStats | None = None
+    streak: int = 0

src/setup.py

@@ -0,0 +1,106 @@
+import requests
+from InquirerPy import inquirer
+from rich.console import Console
+from rich.prompt import Prompt
+
+from . import storage
+
+console = Console()
+
+# popular models to show in selection (cheap + fast first)
+POPULAR_MODELS = [
+    "openai/gpt-oss-120b",
+    "anthropic/claude-sonnet-4",
+    "anthropic/claude-3.5-sonnet",
+    "openai/gpt-4o",
+    "openai/gpt-4o-mini",
+    "google/gemini-2.0-flash-001",
+    "meta-llama/llama-3.3-70b-instruct",
+    "deepseek/deepseek-chat-v3-0324",
+    "deepseek/deepseek-r1",
+    "qwen/qwen-2.5-72b-instruct",
+    "mistralai/mistral-large-2411",
+]
+
+
+def fetch_models(api_key: str) -> list[dict]:
+    # fetch models from openrouter api
+    response = requests.get(
+        "https://openrouter.ai/api/v1/models",
+        headers={"Authorization": f"Bearer {api_key}"},
+    )
+    response.raise_for_status()
+    return response.json().get("data", [])
+
+
+def filter_models(models: list[dict]) -> list[dict]:
+    # filter to popular models and sort by our preferred order
+    model_map = {m["id"]: m for m in models}
+    filtered = []
+    for model_id in POPULAR_MODELS:
+        if model_id in model_map:
+            filtered.append(model_map[model_id])
+    return filtered
+
+
+def format_price(pricing: dict) -> str:
+    # format pricing as $X/$Y (input/output per 1M tokens)
+    prompt = float(pricing.get("prompt", 0)) * 1_000_000
+    completion = float(pricing.get("completion", 0)) * 1_000_000
+    return f"${prompt:.2f}/${completion:.2f}"
+
+
+def run_setup():
+    # main setup flow
+    console.print("\n[bold]wtf setup[/bold]\n")
+
+    # prompt for api key
+    console.print("Get your API key from: [link]https://openrouter.ai/keys[/link]\n")
+    api_key = Prompt.ask("Enter your OpenRouter API key", password=True)
+
+    if not api_key.strip():
+        console.print("[red]API key cannot be empty.[/red]")
+        return
+
+    # validate by fetching models
+    console.print("\n[dim]Validating...[/dim]", end=" ")
+    try:
+        models = fetch_models(api_key)
+        console.print("[green]done[/green]\n")
+    except requests.exceptions.HTTPError as e:
+        if e.response.status_code == 401:
+            console.print("[red]invalid key[/red]")
+        else:
+            console.print(f"[red]error: {e}[/red]")
+        return
+    except Exception as e:
+        console.print(f"[red]error: {e}[/red]")
+        return
+
+    # filter to popular models
+    filtered = filter_models(models)
+    if not filtered:
+        filtered = models[:15]
+
+    # build choices for interactive picker
+    choices = []
+    for model in filtered:
+        price = format_price(model.get("pricing", {}))
+        label = f"{model['id']:<42} {price}"
+        choices.append({"name": label, "value": model["id"]})
+
+    # interactive model picker with arrow keys
+    selected_model = inquirer.select(
+        message="Select a model:",
+        choices=choices,
+        default=choices[0]["value"],
+        pointer="›",
+    ).execute()
+
+    # save config
+    storage.save_config(api_key, selected_model)
+
+    console.print(
+        f"\n[green]Setup complete![/green] Using [bold]{selected_model}[/bold]"
+    )
+    console.print("[dim]Run `wtf` to get started.[/dim]\n")

src/storage.py

@@ -0,0 +1,85 @@
+import json
+from datetime import datetime
+from pathlib import Path
+
+from .models import StandupResult
+
+WTF_DIR = Path.home() / ".wtf"
+HISTORY_DIR = WTF_DIR / "history"
+SPENDING_FILE = WTF_DIR / "spending.json"
+CONFIG_FILE = WTF_DIR / "config.json"
+
+
+def init_storage():
+    # create directories if they don't exist
+    WTF_DIR.mkdir(exist_ok=True)
+    HISTORY_DIR.mkdir(exist_ok=True)
+
+
+def save_standup(result: StandupResult):
+    # save standup to history
+    init_storage()
+    filename = f"{datetime.now().strftime('%Y-%m-%d_%H%M%S')}.json"
+    path = HISTORY_DIR / filename
+    path.write_text(result.model_dump_json(indent=2), encoding="utf-8")
+
+
+def load_history(limit: int = 10) -> list[StandupResult]:
+    # load recent standups
+    init_storage()
+    files = sorted(HISTORY_DIR.glob("*.json"), reverse=True)[:limit]
+    results = []
+    for f in files:
+        try:
+            results.append(
+                StandupResult.model_validate_json(f.read_text(encoding="utf-8"))
+            )
+        except Exception:
+            # skip invalid files
+            continue
+    return results
+
+
+def add_spending(cost: float, model: str):
+    # append spending record
+    init_storage()
+    records = load_spending()
+    records.append(
+        {"timestamp": datetime.now().isoformat(), "model": model, "cost": cost}
+    )
+    SPENDING_FILE.write_text(json.dumps(records, indent=2), encoding="utf-8")
+
+
+def get_total_spent() -> float:
+    # calculate cumulative spending
+    records = load_spending()
+    return sum(r.get("cost", 0) for r in records)
+
+
+def load_spending() -> list:
+    if not SPENDING_FILE.exists():
+        return []
+    return json.loads(SPENDING_FILE.read_text(encoding="utf-8"))
+
+
+def save_config(api_key: str, model: str):
+    # save api key and model to config file
+    init_storage()
+    config = {"api_key": api_key, "model": model}
+    CONFIG_FILE.write_text(json.dumps(config, indent=2), encoding="utf-8")
+
+
+def load_config() -> dict | None:
+    # load config from file
+    if not CONFIG_FILE.exists():
+        return None
+    try:
+        return json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+    except Exception:
+        return None
+
+
+def is_configured() -> bool:
+    # check if api key is configured
+    config = load_config()
+    return config is not None and bool(config.get("api_key"))

wtf_dev-0.1.0.dist-info/METADATA

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: wtf-dev
+Version: 0.1.0
+Summary: What did I work on? A snarky standup generator.
+Requires-Python: >=3.11
+Requires-Dist: inquirerpy>=0.3.4
+Requires-Dist: pydantic-settings>=2.12.0
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: pyperclip>=1.11.0
+Requires-Dist: python-dotenv>=1.2.1
+Requires-Dist: requests>=2.32.5
+Requires-Dist: rich>=14.3.1
+Requires-Dist: typer>=0.21.1
+Description-Content-Type: text/markdown
+
+# wtf-dev
+
+A CLI tool that tells you what you worked on - with personality.
+
+## Install
+
+```bash
+pip install wtf-dev
+```
+
+## Setup
+
+```bash
+wtf setup
+```
+
+This will prompt for your OpenRouter API key and let you pick a model.
+
+## Usage
+
+```bash
+# what did I do today?
+wtf
+
+# look back N days
+wtf --days 3
+
+# only current repo
+wtf --here
+
+# copy to clipboard
+wtf --copy
+```
+
+## Features
+
+- **Standup summary** - LLM-generated summary of your commits
+- **WIP tracking** - Shows uncommitted changes + what you're currently working on
+- **Streak counter** - Track your commit streak
+- **Late night detection** - Spots those 2am coding sessions
+- **Branch context** - Shows which branches you touched
+- **History** - View past standups with `wtf --history`
+- **Cost tracking** - Track API spending with `wtf --spending`
+
+## Output
+
+```
+PREVIOUSLY ON YOUR CODE...  Feb 02, 2026
+  * 5 day streak
+────────────────────────────────────────────────────────────
+
+   ai-platform (main) ─── 2 commits
+  ├─ feat(sdr): add langsmith tracing
+  └─ feat(sdr): add automatic follow-up
+
+   [wip]
+   ai-platform ─── 3 files changed
+  ├─ M src/api/routes.py
+  └─ A src/new_feature.py
+
+────────────────────────────────────────────────────────────
+
+  Added LangSmith tracing and automatic follow-up for stale
+  conversations in the SDR pipeline.
+
+  Currently working on: Adding new API routes for validation.
+
+  Two features down, infinite bugs to go.
+```
+
+## Flags
+
+| Flag | Short | Description |
+|------|-------|-------------|
+| `--dir PATH` | `-d` | Scan a specific directory |
+| `--here` | `-H` | Only current repo |
+| `--days N` | `-n` | Look back N days (default: 1) |
+| `--author NAME` | `-a` | Filter by author |
+| `--copy` | `-c` | Copy to clipboard |
+| `--history` | | View past standups |
+| `--spending` | | Show API costs |
+| `--json` | | Output as JSON |

wtf_dev-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+src/cli.py,sha256=fUu7qNE-Ds_7q5lLGpOFKGzwbEy44u5QheL0Q0a0pO4,7188
+src/formatter.py,sha256=ugcK1yRTBnJhDvKLFyk_6zObYHHa_2PTQdcFl7fQmSg,3306
+src/git.py,sha256=GcAdMGFLoi9VPYWsGkj8vEZu3xHvd-2PfLPxb_vJSy4,4847
+src/llm.py,sha256=JVeUgN72UyRcq7NGPkyxwR6fxAB75tLOaCiHJlRvNlw,3307
+src/models.py,sha256=vyPOKJHqV2aRAxpKq8QXyXzTOjXO7F9SREkGXUw2J-A,909
+src/setup.py,sha256=B42Q_HE4pUiUD4KT6-yjuRUyaBsC66zGmqLBnrGANrM,3185
+src/storage.py,sha256=k7ZxoDvAiC627qmjyDB5VNjXKV1gkALd8oim0rFnPeo,2414
+wtf_dev-0.1.0.dist-info/METADATA,sha256=e9MVp1Tj7KlmlWERzAIwytPzQSzi_-irlclOfYpK-hs,2548
+wtf_dev-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+wtf_dev-0.1.0.dist-info/entry_points.txt,sha256=v7-4hGNrcQvwi7y499ExK1_1PCnNMijBSfFUj5dsRMQ,36
+wtf_dev-0.1.0.dist-info/RECORD,,

wtf_dev-0.1.0.dist-info/WHEEL

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

wtf_dev-0.1.0.dist-info/entry_points.txt

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