git2tweet 0.1.0__tar.gz

git2tweet-0.1.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.3
+Name: git2tweet
+Version: 0.1.0
+Summary: Turn your git commits into tweet drafts with an AI agent and human approval
+Author: Vedant
+Author-email: Vedant <vkowdiki@gmail.com>
+Requires-Dist: langchain-core>=1.7.6
+Requires-Dist: langchain-groq>=1.1.3
+Requires-Dist: langgraph>=1.2.20
+Requires-Dist: platformdirs>=4.12.4
+Requires-Dist: python-dotenv>=1.2.4
+Requires-Dist: langchain-ollama>=1.1.0 ; extra == 'ollama'
+Requires-Python: >=3.10
+Provides-Extra: ollama
+Description-Content-Type: text/markdown
+
+# Git2Tweet
+
+Turn your git commits into tweet drafts. You approve every one before it goes out.
+
+![demo](https://raw.githubusercontent.com/Vex-15/git2tweet/main/docs/demo.gif)
+
+## Install
+
+```bash
+pipx install git2tweet     # or: uv tool install git2tweet
+git2tweet config           # pick a model provider, paste your API key (once)
+```
+
+## Use it
+
+```bash
+git commit -m "feat: add retry with backoff to the webhook handler"
+git tweet                  # drafts a tweet, you approve or edit, X opens prefilled
+```
+
+Want a reminder after every commit? Run `git2tweet init` once per repo.
+
+| Command | What it does |
+|---|---|
+| `git tweet` / `g2t` | Draft a tweet for your latest commit |
+| `git tweet <sha>` | Draft for a specific commit |
+| `git tweet --force` | Draft again even if the commit was already handled |
+| `git2tweet config` | Set provider, model and API key |
+| `git2tweet init` | Install the post-commit reminder hook (`--remove` to undo) |
+
+## How it works
+
+An agent (built with LangGraph) reads your commit and diff, decides if it's worth
+sharing, and drafts a tweet. Trivial commits (typos, formatting) are skipped.
+You then approve, edit, or reject it. Approved tweets open in X with the text
+prefilled, so you press Post yourself. Git2Tweet never holds your X credentials.
+
+## Privacy
+
+- The commit message and diff are sent to the model provider you choose (Groq by default).
+- Known secret patterns (API keys, tokens, `password=...`) are redacted first.
+  This is best effort, so don't rely on it for sensitive repos.
+- For fully local use, pick `ollama` in `git2tweet config`: nothing leaves your machine.
+- Git2Tweet sends no telemetry.
+
+## License
+
+MIT
+
+[View full license](https://github.com/Vex-15/git2tweet?tab=MIT-1-ov-file)

git2tweet-0.1.0/README.md

@@ -0,0 +1,50 @@
+# Git2Tweet
+
+Turn your git commits into tweet drafts. You approve every one before it goes out.
+
+![demo](https://raw.githubusercontent.com/Vex-15/git2tweet/main/docs/demo.gif)
+
+## Install
+
+```bash
+pipx install git2tweet     # or: uv tool install git2tweet
+git2tweet config           # pick a model provider, paste your API key (once)
+```
+
+## Use it
+
+```bash
+git commit -m "feat: add retry with backoff to the webhook handler"
+git tweet                  # drafts a tweet, you approve or edit, X opens prefilled
+```
+
+Want a reminder after every commit? Run `git2tweet init` once per repo.
+
+| Command | What it does |
+|---|---|
+| `git tweet` / `g2t` | Draft a tweet for your latest commit |
+| `git tweet <sha>` | Draft for a specific commit |
+| `git tweet --force` | Draft again even if the commit was already handled |
+| `git2tweet config` | Set provider, model and API key |
+| `git2tweet init` | Install the post-commit reminder hook (`--remove` to undo) |
+
+## How it works
+
+An agent (built with LangGraph) reads your commit and diff, decides if it's worth
+sharing, and drafts a tweet. Trivial commits (typos, formatting) are skipped.
+You then approve, edit, or reject it. Approved tweets open in X with the text
+prefilled, so you press Post yourself. Git2Tweet never holds your X credentials.
+
+## Privacy
+
+- The commit message and diff are sent to the model provider you choose (Groq by default).
+- Known secret patterns (API keys, tokens, `password=...`) are redacted first.
+  This is best effort, so don't rely on it for sensitive repos.
+- For fully local use, pick `ollama` in `git2tweet config`: nothing leaves your machine.
+- Git2Tweet sends no telemetry.
+
+## License
+
+MIT
+
+[View full license](https://github.com/Vex-15/git2tweet?tab=MIT-1-ov-file)

git2tweet-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "git2tweet"
+version = "0.1.0"
+description = "Turn your git commits into tweet drafts with an AI agent and human approval"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "langchain-core>=1.7.6",
+    "langchain-groq>=1.1.3",
+    "langgraph>=1.2.20",
+    "platformdirs>=4.12.4",
+    "python-dotenv>=1.2.4",
+]
+
+[[project.authors]]
+name = "Vedant"
+email = "vkowdiki@gmail.com"
+
+[project.scripts]
+git2tweet = "git2tweet.cli:main"
+g2t = "git2tweet.cli:main"
+git-tweet = "git2tweet.cli:main"
+
+[project.optional-dependencies]
+ollama = ["langchain-ollama>=1.1.0"]
+
+[build-system]
+requires = ["uv_build>=0.13.5,<0.14.0"]
+build-backend = "uv_build"

git2tweet-0.1.0/pyproject.toml.orig

@@ -0,0 +1,30 @@
+[project]
+name = "git2tweet"
+version = "0.1.0"
+description = "Turn your git commits into tweet drafts with an AI agent and human approval"
+readme = "README.md"
+authors = [
+    { name = "Vedant", email = "vkowdiki@gmail.com" }
+]
+requires-python = ">=3.10"
+dependencies = [
+    "langchain-core>=1.7.6",
+    "langchain-groq>=1.1.3",
+    "langgraph>=1.2.20",
+    "platformdirs>=4.12.4",
+    "python-dotenv>=1.2.4",
+]
+
+[project.scripts]
+git2tweet = "git2tweet.cli:main"
+g2t = "git2tweet.cli:main"
+git-tweet = "git2tweet.cli:main"
+
+[project.optional-dependencies]
+ollama = [
+    "langchain-ollama>=1.1.0",
+]
+
+[build-system]
+requires = ["uv_build>=0.13.5,<0.14.0"]
+build-backend = "uv_build"

git2tweet-0.1.0/src/git2tweet/__main__.py

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

git2tweet-0.1.0/src/git2tweet/agent.py

@@ -0,0 +1,119 @@
+import json
+import webbrowser
+from typing import Annotated, TypedDict
+from urllib.parse import urlencode
+
+from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_core.tools import tool
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.graph import END, START, StateGraph
+from langgraph.graph.message import add_messages
+from langgraph.prebuilt import ToolNode, tools_condition
+from langgraph.types import Command, interrupt
+
+from . import repo, store
+from .llm import make_llm
+
+SYSTEM = """You write tweets for a developer who builds in public.
+Look at the recent commits, pick the most tweet-worthy one, read its diff,
+then write ONE tweet under 280 characters (first person, casual, max 1 emoji,
+max 2 hashtags, never include secrets).
+If every commit is trivial (typos, formatting, merges), reply with exactly: SKIP
+Output only the tweet text or SKIP."""
+
+
+@tool
+def list_recent_commits(n: int = 3) -> str:
+    """List the most recent commits (sha + first line of message)."""
+    return json.dumps(repo.list_commits(n))
+
+
+@tool
+def get_commit_diff(sha: str) -> str:
+    """Get the full message and code diff for one commit by its sha."""
+    return f"Message: {repo.commit_message(sha)}\n\n{repo.commit_diff(sha)}"
+
+
+TOOLS = [list_recent_commits, get_commit_diff]
+
+
+class State(TypedDict):
+    messages: Annotated[list, add_messages]
+    tweet: str
+    status: str
+
+
+def approve(state: State):
+    draft = state["messages"][-1].content.strip()
+    if draft.strip(" .\"'").upper() == "SKIP":
+        return {"status": "skipped"}
+
+    answer = interrupt({"draft": draft, "chars": len(draft)}).strip()
+
+    if answer.lower() == "y":
+        return {"tweet": draft, "status": "approved"}
+    if answer.lower() == "n":
+        return {"status": "rejected"}
+    return {"tweet": answer, "status": "approved"}  # anything else = your edit
+
+
+def post(state: State):
+    url = "https://twitter.com/intent/tweet?" + urlencode({"text": state["tweet"]})
+    webbrowser.open(url)
+    return {"status": "opened"}
+
+
+def after_approve(state: State):
+    return "post" if state["status"] == "approved" else END
+
+
+def build_graph():
+    llm = make_llm().bind_tools(TOOLS)
+
+    def agent(state: State):
+        reply = llm.invoke([SystemMessage(SYSTEM)] + state["messages"])
+        return {"messages": [reply]}
+
+    builder = StateGraph(State)
+    builder.add_node("agent", agent)
+    builder.add_node("tools", ToolNode(TOOLS))
+    builder.add_node("approve", approve)
+    builder.add_node("post", post)
+
+    builder.add_edge(START, "agent")
+    builder.add_conditional_edges(
+        "agent", tools_condition, {"tools": "tools", END: "approve"}
+    )
+    builder.add_edge("tools", "agent")
+    builder.add_conditional_edges(
+        "approve", after_approve, {"post": "post", END: END}
+    )
+    builder.add_edge("post", END)
+    return builder.compile(checkpointer=MemorySaver())
+
+
+def run(sha: str) -> None:
+    if sha in store.load():
+        print(f"Already handled {sha[:7]}, skipping.")
+        return
+
+    graph = build_graph()
+    config = {"configurable": {"thread_id": sha}, "recursion_limit": 10}
+    task = f"Write a tweet about commit {sha}. Read its diff with get_commit_diff first."
+
+    result = graph.invoke({"messages": [HumanMessage(task)]}, config)
+
+    while "__interrupt__" in result:
+        info = result["__interrupt__"][0].value
+        print(f"\nDRAFT ({info['chars']} chars):\n{info['draft']}\n")
+        answer = input("Post? [y] yes / [n] no / or type your edited tweet: ")
+        result = graph.invoke(Command(resume=answer), config)
+
+    status = result["status"]
+    print("Status:", status)
+
+    if status == "opened":
+        if input("Did you press Post on X? [y/n] ").lower() == "y":
+            store.mark(sha)
+    elif status in ("skipped", "rejected"):
+        store.mark(sha)

git2tweet-0.1.0/src/git2tweet/cli.py

@@ -0,0 +1,108 @@
+import argparse
+import getpass
+import json
+import subprocess
+import sys
+
+from dotenv import load_dotenv
+
+from . import config, hooks, repo, store
+
+COMMANDS = {"draft", "config", "init", "hook"}
+
+
+def configure(show: bool) -> None:
+    cfg = config.load()
+
+    if show:
+        shown = dict(cfg)
+        if "groq_api_key" in shown:
+            shown["groq_api_key"] = "****" + shown["groq_api_key"][-4:]
+        print(json.dumps(shown, indent=2))
+        print(f"\nConfig file: {config.CONFIG_FILE}")
+        return
+
+    current = cfg.get("provider", "groq")
+    provider = input(f"Provider [groq/ollama] ({current}): ").strip().lower() or current
+    if provider not in config.DEFAULT_MODELS:
+        sys.exit(f"Unknown provider '{provider}'. Choose: {', '.join(config.DEFAULT_MODELS)}")
+
+    default_model = (cfg.get("model") if provider == cfg.get("provider") else None) \
+        or config.DEFAULT_MODELS[provider]
+    cfg["provider"] = provider
+    cfg["model"] = input(f"Model ({default_model}): ").strip() or default_model
+
+    if provider == "groq":
+        key = getpass.getpass("Groq API key (hidden, Enter keeps current): ").strip()
+        if key:
+            cfg["groq_api_key"] = key
+
+    config.save(cfg)
+    print(f"Saved to {config.CONFIG_FILE}")
+
+
+def draft(sha: str) -> None:
+    from .agent import run  # imported here so --help, config and hook stay fast
+
+    try:
+        full_sha = repo.resolve(sha)
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        sys.exit("Run this inside a git repository, with a valid commit.")
+    run(full_sha)
+
+
+def init(remove: bool) -> None:
+    try:
+        msg = hooks.remove() if remove else hooks.install()
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        sys.exit("Run this inside a git repository.")
+    print(msg)
+    if msg.startswith("Installed"):
+        print("After each commit you'll see a reminder. Run `git2tweet` to draft a tweet.")
+
+def hook() -> None:
+    """Called by the post-commit hook: must be fast, quiet, and never fail."""
+    try:
+        sha = repo.resolve("HEAD")
+        if sha in store.load() or repo.is_merge(sha):
+            return
+        subject = repo.list_commits(1)[0]["message"]
+        print(f"git2tweet: tweet this? Run `git tweet` ({sha[:7]}: {subject})")
+    except Exception:
+        pass
+
+
+def main() -> None:
+    load_dotenv()  # dev convenience: reads a .env in the current folder
+
+    parser = argparse.ArgumentParser(
+        prog="git2tweet",
+        description="Turn a git commit into a tweet draft you approve before posting.",
+        epilog="Run `git2tweet` alone to draft a tweet for your latest commit.",
+    )
+    sub = parser.add_subparsers(dest="command", metavar="{draft,config,init}")
+
+    p_draft = sub.add_parser("draft", help="draft a tweet for a commit (the default)")
+    p_draft.add_argument("sha", nargs="?", default="HEAD", help="commit to use (default: latest)")
+
+    p_config = sub.add_parser("config", help="set provider, model and API key")
+    p_config.add_argument("--show", action="store_true", help="show current settings")
+
+    p_init = sub.add_parser("init", help="install a git hook that reminds you after each commit")
+    p_init.add_argument("--remove", action="store_true", help="uninstall the hook")
+
+    sub.add_parser("hook", help=argparse.SUPPRESS)  # internal, used by the hook itself
+
+    argv = sys.argv[1:]
+    if not argv or (argv[0] not in COMMANDS and not argv[0].startswith("-")):
+        argv = ["draft", *argv]
+    args = parser.parse_args(argv)
+
+    if args.command == "config":
+        configure(args.show)
+    elif args.command == "init":
+        init(args.remove)
+    elif args.command == "hook":
+        hook()
+    else:
+        draft(args.sha)

git2tweet-0.1.0/src/git2tweet/config.py

@@ -0,0 +1,46 @@
+import json
+import os
+from pathlib import Path
+
+from platformdirs import user_config_dir
+
+CONFIG_FILE = Path(user_config_dir("git2tweet")) / "config.json"
+
+DEFAULT_MODELS = {
+    "groq": "openai/gpt-oss-120b",
+    "ollama": "llama3.1",
+}
+
+
+def load() -> dict:
+    if not CONFIG_FILE.exists():
+        return {}
+    try:
+        return json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return {}
+
+
+def save(cfg: dict) -> None:
+    CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(json.dumps(cfg, indent=2), encoding="utf-8")
+    try:
+        CONFIG_FILE.chmod(0o600)  # owner-only on Mac/Linux
+    except OSError:
+        pass
+
+
+def get_settings() -> dict:
+    """Environment variables win over the config file, which wins over defaults."""
+    cfg = load()
+    provider = os.environ.get("GIT2TWEET_PROVIDER") or cfg.get("provider", "groq")
+    model = (
+        os.environ.get("GIT2TWEET_MODEL")
+        or cfg.get("model")
+        or DEFAULT_MODELS.get(provider, "")
+    )
+    return {"provider": provider, "model": model}
+
+
+def get_groq_key() -> str | None:
+    return os.environ.get("GROQ_API_KEY") or load().get("groq_api_key")

git2tweet-0.1.0/src/git2tweet/hooks.py

@@ -0,0 +1,54 @@
+import stat
+
+from . import repo
+
+MARKER_START = "# >>> git2tweet >>>"
+MARKER_END = "# <<< git2tweet <<<"
+BLOCK = (
+    f"{MARKER_START}\n"
+    "command -v git2tweet >/dev/null 2>&1 && git2tweet hook || true\n"
+    f"{MARKER_END}\n"
+)
+
+
+def _path():
+    return repo.hooks_dir() / "post-commit"
+
+
+def install() -> str:
+    path = _path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    if path.exists():
+        text = path.read_text(encoding="utf-8")
+        if MARKER_START in text:
+            return f"Already installed ({path})"
+        first = text.splitlines()[0] if text else ""
+        if not (first.startswith("#!") and first.rstrip().endswith("sh")):
+            return "A non-shell post-commit hook already exists. Add `git2tweet hook` to it manually."
+        text = text.rstrip("\n") + "\n\n" + BLOCK
+    else:
+        text = "#!/bin/sh\n\n" + BLOCK
+
+    path.write_text(text, encoding="utf-8", newline="\n")  # LF only, or sh breaks on Windows
+    path.chmod(path.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+    return f"Installed post-commit hook ({path})"
+
+
+def remove() -> str:
+    path = _path()
+    if not path.exists():
+        return "No git2tweet hook found."
+    text = path.read_text(encoding="utf-8")
+    if MARKER_START not in text:
+        return "No git2tweet hook found."
+
+    start = text.index(MARKER_START)
+    end = text.index(MARKER_END) + len(MARKER_END)
+    rest = (text[:start] + text[end:]).strip()
+
+    if rest in ("", "#!/bin/sh"):
+        path.unlink()  # the hook was only ours, so delete the file
+    else:
+        path.write_text(rest + "\n", encoding="utf-8", newline="\n")
+    return "Removed git2tweet hook."

git2tweet-0.1.0/src/git2tweet/llm.py

@@ -0,0 +1,22 @@
+from . import config
+
+
+def make_llm():
+    s = config.get_settings()
+
+    if s["provider"] == "groq":
+        from langchain_groq import ChatGroq
+
+        key = config.get_groq_key()
+        if not key:
+            raise SystemExit("No Groq API key found. Run `git2tweet config` or set GROQ_API_KEY.")
+        return ChatGroq(model=s["model"], api_key=key)
+
+    if s["provider"] == "ollama":
+        try:
+            from langchain_ollama import ChatOllama
+        except ImportError:
+            raise SystemExit('Ollama support is not installed. Run: pip install "git2tweet[ollama]"')
+        return ChatOllama(model=s["model"])
+
+    raise SystemExit(f"Unknown provider '{s['provider']}'. Use groq or ollama.")

git2tweet-0.1.0/src/git2tweet/repo.py

@@ -0,0 +1,48 @@
+import subprocess
+
+from .scrub import scrub
+
+
+def _git(*args: str) -> str:
+    result = subprocess.run(
+        ["git", *args],
+        capture_output=True, text=True, encoding="utf-8", errors="replace",
+        check=True,
+    )
+    return result.stdout.strip()
+
+
+def resolve(ref: str = "HEAD") -> str:
+    """Turn HEAD, a short sha, or a branch name into a full sha."""
+    return _git("rev-parse", ref)
+
+
+def list_commits(n: int = 3) -> list[dict]:
+    out = _git("log", f"-{n}", "--pretty=format:%H%x09%s")
+    rows = [line.split("\t", 1) for line in out.splitlines()]
+    return [{"sha": sha, "message": scrub(msg)} for sha, msg in rows]
+
+
+def commit_message(sha: str) -> str:
+    return scrub(_git("show", "-s", "--format=%B", sha))
+
+
+def commit_diff(sha: str, max_chars: int = 6000) -> str:
+    return scrub(_git("show", "--format=", "--patch", sha))[:max_chars]
+
+
+from pathlib import Path
+
+def git_dir() -> Path:
+    """The repo's .git folder (works from any subfolder, worktrees too)."""
+    return Path(_git("rev-parse", "--absolute-git-dir"))
+
+
+def hooks_dir() -> Path:
+    """Where this repo's hooks live (respects a custom core.hooksPath)."""
+    return Path(_git("rev-parse", "--git-path", "hooks")).resolve()
+
+
+def is_merge(sha: str) -> bool:
+    parts = _git("rev-list", "--parents", "-n", "1", sha).split()
+    return len(parts) > 2  # sha + 2 or more parents

git2tweet-0.1.0/src/git2tweet/scrub.py

@@ -0,0 +1,16 @@
+import re
+
+PATTERNS = [
+    r"ghp_[A-Za-z0-9]{36}",
+    r"github_pat_[A-Za-z0-9_]{20,}",
+    r"gsk_[A-Za-z0-9]{20,}",
+    r"sk-[A-Za-z0-9_-]{20,}",
+    r"AKIA[0-9A-Z]{16}",
+    r"(?i)(api[_-]?key|token|secret|password)\s*[=:]\s*\S+",
+]
+
+
+def scrub(text: str) -> str:
+    for p in PATTERNS:
+        text = re.sub(p, "[REDACTED]", text)
+    return text

git2tweet-0.1.0/src/git2tweet/store.py

@@ -0,0 +1,23 @@
+import json
+
+from . import repo
+
+
+def _file():
+    return repo.git_dir() / "git2tweet.json"
+
+
+def load() -> set[str]:
+    f = _file()
+    if not f.exists():
+        return set()
+    try:
+        return set(json.loads(f.read_text(encoding="utf-8")))
+    except (json.JSONDecodeError, TypeError):
+        return set()
+
+
+def mark(sha: str) -> None:
+    shas = load()
+    shas.add(sha)
+    _file().write_text(json.dumps(sorted(shas)), encoding="utf-8")