quicksnap 0.2.0__py3-none-any.whl

quicksnap/__init__.py

@@ -0,0 +1,3 @@
+"""QuickSnap - Never forget the engineering stories behind your code."""
+
+__version__ = "0.2.0"

quicksnap/__main__.py

@@ -0,0 +1,3 @@
+from .cli import app
+
+app()

quicksnap/ai.py

@@ -0,0 +1,256 @@
+from __future__ import annotations
+
+import json
+import os
+from typing import Optional
+
+
+def _has_httpx() -> bool:
+    try:
+        import httpx
+        return True
+    except ImportError:
+        return False
+
+
+class AIServiceError(Exception):
+    def __init__(self, message: str, status_code: int = 0):
+        super().__init__(message)
+        self.status_code = status_code
+
+
+def generate_with_local_ai(context: dict, model: str = "llama3") -> Optional[dict]:
+    if not _has_httpx():
+        return None
+    import httpx
+
+    prompt = _build_prompt(context)
+    try:
+        resp = httpx.post(
+            "http://localhost:11434/api/generate",
+            json={"model": model, "prompt": prompt, "stream": False},
+            timeout=120,
+        )
+        if resp.status_code == 200:
+            text = resp.json().get("response", "")
+            return _parse_ai_response(text)
+        return None
+    except httpx.ConnectError:
+        return None
+    except httpx.TimeoutException:
+        return None
+    except Exception:
+        return None
+
+
+def generate_with_openai(context: dict, model: str = "gpt-4o-mini") -> Optional[dict]:
+    if not _has_httpx():
+        return None
+    import httpx
+
+    api_key = os.environ.get("OPENAI_API_KEY")
+    if not api_key:
+        return None
+
+    prompt = _build_prompt(context)
+    try:
+        resp = httpx.post(
+            "https://api.openai.com/v1/chat/completions",
+            headers={"Authorization": f"Bearer {api_key}"},
+            json={
+                "model": model,
+                "messages": [{"role": "user", "content": prompt}],
+                "temperature": 0.3,
+            },
+            timeout=60,
+        )
+        if resp.status_code == 401:
+            raise AIServiceError("Invalid OpenAI API key", 401)
+        if resp.status_code == 429:
+            raise AIServiceError("OpenAI rate limited", 429)
+        resp.raise_for_status()
+        text = resp.json()["choices"][0]["message"]["content"]
+        return _parse_ai_response(text)
+    except AIServiceError:
+        raise
+    except Exception:
+        return None
+
+
+def generate_with_anthropic(context: dict, model: str = "claude-3-5-sonnet-20241022") -> Optional[dict]:
+    if not _has_httpx():
+        return None
+    import httpx
+
+    api_key = os.environ.get("ANTHROPIC_API_KEY")
+    if not api_key:
+        return None
+
+    prompt = _build_prompt(context)
+    try:
+        resp = httpx.post(
+            "https://api.anthropic.com/v1/messages",
+            headers={
+                "x-api-key": api_key,
+                "anthropic-version": "2023-06-01",
+            },
+            json={
+                "model": model,
+                "max_tokens": 2000,
+                "messages": [{"role": "user", "content": prompt}],
+            },
+            timeout=60,
+        )
+        if resp.status_code == 401:
+            raise AIServiceError("Invalid Anthropic API key", 401)
+        if resp.status_code == 429:
+            raise AIServiceError("Anthropic rate limited", 429)
+        resp.raise_for_status()
+        text = resp.json()["content"][0]["text"]
+        return _parse_ai_response(text)
+    except AIServiceError:
+        raise
+    except Exception:
+        return None
+
+
+def generate_with_gemini(context: dict, model: str = "gemini-1.5-flash") -> Optional[dict]:
+    if not _has_httpx():
+        return None
+    import httpx
+
+    api_key = os.environ.get("GEMINI_API_KEY")
+    if not api_key:
+        return None
+
+    prompt = _build_prompt(context)
+    try:
+        resp = httpx.post(
+            f"https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent",
+            headers={"x-goog-api-key": api_key},
+            json={"contents": [{"parts": [{"text": prompt}]}]},
+            timeout=60,
+        )
+        if resp.status_code == 400:
+            raise AIServiceError("Invalid Gemini API key or model", 400)
+        resp.raise_for_status()
+        data = resp.json()
+        candidates = data.get("candidates", [])
+        if candidates:
+            text = candidates[0].get("content", {}).get("parts", [{}])[0].get("text", "")
+            return _parse_ai_response(text)
+        return None
+    except AIServiceError:
+        raise
+    except Exception:
+        return None
+
+
+def generate_ai_summary(context: dict, mode: str = "auto") -> tuple[Optional[dict], str]:
+    try:
+        if mode == "local":
+            return generate_with_local_ai(context), ""
+        elif mode == "openai":
+            return generate_with_openai(context), ""
+        elif mode == "anthropic":
+            return generate_with_anthropic(context), ""
+        elif mode == "gemini":
+            return generate_with_gemini(context), ""
+
+        if os.environ.get("OPENAI_API_KEY"):
+            return generate_with_openai(context), ""
+        if os.environ.get("ANTHROPIC_API_KEY"):
+            return generate_with_anthropic(context), ""
+        if os.environ.get("GEMINI_API_KEY"):
+            return generate_with_gemini(context), ""
+        result = generate_with_local_ai(context)
+        if result is None:
+            return None, "No AI configured. Set OPENAI_API_KEY, ANTHROPIC_API_KEY, GEMINI_API_KEY, or install Ollama."
+        return result, ""
+    except AIServiceError as e:
+        error_map = {
+            401: "Invalid API key. Check your environment variable.",
+            429: "Rate limited. Wait a moment and try again.",
+            400: "Invalid request. Check your API key and model name.",
+        }
+        msg = error_map.get(e.status_code, f"AI error: {e}")
+        return None, msg
+    except Exception as e:
+        return None, f"Unexpected error: {e}"
+
+
+def _build_prompt(context: dict) -> str:
+    diff = context.get("diff", "")[:3000]
+    commits = "\n".join(context.get("commit_messages", []))
+    files = "\n".join(context.get("files_changed", []))
+
+    return f"""You are helping an engineer document their work for future interviews.
+
+Git repository: {context.get('repo_name', 'unknown')}
+Branch: {context.get('branch', 'unknown')}
+Files changed: {files}
+Recent commits: {commits}
+
+Diff:
+{diff}
+
+Generate a JSON response with these fields:
+{{
+  "title": "A concise, descriptive title for this change",
+  "problem": "What problem was being solved (2-3 sentences)",
+  "context": "Technical context and scale",
+  "challenge": "What made this difficult",
+  "alternatives": ["alternative 1", "alternative 2", "alternative 3"],
+  "decision": "Why this approach was chosen",
+  "tradeoffs": ["tradeoff 1", "tradeoff 2"],
+  "result": "Measurable outcome if possible",
+  "lessons": "Key lessons learned",
+  "surprises": "What surprised you during this work?",
+  "risks_taken": "What was the biggest risk you took?",
+  "assumptions": "What assumption did you make that proved correct or incorrect?",
+  "almost_failed": "What almost went wrong?",
+  "advice": "What advice would you give your future self about this?",
+  "tags": ["tag1", "tag2", "tag3"],
+  "star": {{
+    "situation": "...",
+    "task": "...",
+    "action": "...",
+    "result": "..."
+  }},
+  "bullets": [
+    "Resume bullet point 1",
+    "Resume bullet point 2"
+  ]
+}}
+
+Respond ONLY with valid JSON. Be specific and technical."""
+
+
+def _parse_ai_response(text: str) -> Optional[dict]:
+    text = text.strip()
+    if text.startswith("```"):
+        lines = text.splitlines()
+        lines = lines[1:]
+        if lines and lines[-1].strip() == "```":
+            lines = lines[:-1]
+        text = "\n".join(lines)
+
+    try:
+        result = json.loads(text)
+        if isinstance(result, dict):
+            return result
+        return None
+    except json.JSONDecodeError:
+        pass
+
+    start = text.find("{")
+    end = text.rfind("}")
+    if start != -1 and end != -1 and end > start:
+        try:
+            result = json.loads(text[start:end + 1])
+            if isinstance(result, dict):
+                return result
+        except json.JSONDecodeError:
+            pass
+
+    return None