standupguy 0.1.0__py3-none-any.whl

standupguy/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

standupguy/cli.py

@@ -0,0 +1,134 @@
+"""StandupGuy: kill the tracker trap without leaking data.
+
+Reads local git history and drafts your standup notes, weekly summary,
+and sprint-review bullets as Markdown. Deterministic digest works fully
+offline; --draft uses YOUR local model endpoint (Ollama/freellmapi).
+Your history never touches a cloud SaaS.
+
+  standupguy                  # yesterday's digest
+  standupguy --week           # last 7 days
+  standupguy --draft          # LLM prose: Yesterday / Today / Blockers
+  standupguy --sprint         # sprint-review bullets
+  standupguy mcp              # MCP server: ask "what did I ship this week"
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+
+from . import digest as digest_mod
+from . import draft as draft_mod
+from . import gitlog as gitlog_mod
+from . import mcp as mcp_mod
+from . import push as push_mod
+from . import serve as serve_mod
+
+VERSION = "0.1.0"
+
+
+def _resolve_author(args, root: str) -> str | None:
+    if args.all:
+        return None
+    if args.author:
+        return args.author
+    return gitlog_mod.default_author(root) or None
+
+
+def cmd_digest(args) -> int:
+    root = args.root
+    author = _resolve_author(args, root)
+    if args.week or args.sprint:
+        md = digest_mod.weekly_markdown(root, author)
+        label = "week"
+    else:
+        since = args.since or "yesterday"
+        label = f"since {since}"
+        md = digest_mod.digest_markdown(root, since, label, author)
+    if args.draft:
+        try:
+            md = draft_mod.draft(
+                md, base_url=args.base_url, model=args.model) + "\n"
+        except draft_mod.DraftError as e:
+            print(f"error: {e}", file=sys.stderr)
+            return 2
+    if args.format == "json":
+        commits = gitlog_mod.commits_since(
+            root, "7 days ago" if (args.week or args.sprint) else
+            (args.since or "yesterday"), author)
+        print(json.dumps({
+            "repo": gitlog_mod.repo_name(root), "label": label,
+            "in_progress": gitlog_mod.uncommitted(root),
+            "commits": [{"sha": c.sha, "author": c.author, "date": c.date,
+                         "subject": c.subject, "files": c.files,
+                         "pr": c.pr_number} for c in commits],
+        }, indent=2))
+        return 0
+    if args.push_slack:
+        webhook = args.push_slack if args.push_slack is not True else \
+            os.environ.get("AUTOSTANDUP_SLACK_WEBHOOK", "")
+        if not webhook:
+            print("error: no webhook — pass --push-slack <url> or set "
+                  "AUTOSTANDUP_SLACK_WEBHOOK", file=sys.stderr)
+            return 2
+        try:
+            push_mod.push_slack(webhook, md)
+            print("pushed to Slack ✓")
+        except push_mod.PushError as e:
+            print(f"error: {e}", file=sys.stderr)
+            return 2
+        return 0
+    sys.stdout.write(md)
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="standupguy", description=__doc__)
+    p.add_argument("--version", action="version", version=f"%(prog)s {VERSION}")
+    p.add_argument("--root", default=os.getcwd(), help="Repo path.")
+    p.add_argument("--author", default=None, help="Filter by author.")
+    p.add_argument("--all", action="store_true",
+                   help="Include all authors (default: your git user).")
+    p.add_argument("--since", default=None,
+                   help="git date: 'yesterday' (default), '2026-10-01', …")
+    p.add_argument("--week", action="store_true", help="Last 7 days.")
+    p.add_argument("--sprint", action="store_true",
+                   help="Sprint-review bullets (weekly + highlights).")
+    p.add_argument("--draft", action="store_true",
+                   help="Draft Yesterday/Today/Blockers prose via local model.")
+    p.add_argument("--format", choices=["markdown", "json"],
+                   default="markdown")
+    p.add_argument("--push-slack", nargs="?", const=True, default=None,
+                   metavar="WEBHOOK_URL",
+                   help="POST the notes to a Slack webhook "
+                        "(or AUTOSTANDUP_SLACK_WEBHOOK).")
+    p.add_argument("--base-url", default=None)
+    p.add_argument("--model", default=None)
+    p.add_argument("cmd", nargs="?", choices=["mcp", "serve"],
+                   help="Run the MCP server (mcp) or HTTP bridge (serve) "
+                        "for n8n / workflow tools.")
+    p.add_argument("--port", type=int, default=8765,
+                   help="Port for `serve` (default 8765).")
+    p.add_argument("--host", default="127.0.0.1",
+                   help="Bind host for `serve` (default 127.0.0.1).")
+    return p
+
+
+def main(argv=None) -> int:
+    args = build_parser().parse_args(argv)
+    if args.cmd == "mcp":
+        return mcp_mod.serve(args.root)
+    if args.cmd == "serve":
+        return serve_mod.serve(args.root, args.host, args.port)
+    try:
+        gitlog_mod._git(args.root, "rev-parse", "--git-dir")
+    except RuntimeError:
+        print("error: not a git repo", file=sys.stderr)
+        return 2
+    return cmd_digest(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

standupguy/digest.py

@@ -0,0 +1,95 @@
+"""Digest: turn commits into grouped Markdown. Deterministic, offline.
+
+Groups by conventional-commit prefix (feat/fix/docs/refactor/test/chore),
+falls back to an 'other' bucket. Merge commits surface as shipped PRs.
+"""
+
+from __future__ import annotations
+
+import re
+from collections import OrderedDict
+
+from . import gitlog as gitlog_mod
+
+_PREFIX_RE = re.compile(r"^(\w+)(?:\(.+\))?[:!]\s*(.+)$", re.IGNORECASE)
+
+GROUP_ORDER = ["feat", "fix", "refactor", "docs", "test", "chore", "other"]
+GROUP_TITLES = {
+    "feat": "Features", "fix": "Fixes", "refactor": "Refactors",
+    "docs": "Docs", "test": "Tests", "chore": "Chores", "other": "Other",
+}
+
+
+def classify(subject: str) -> tuple[str, str]:
+    """(group, cleaned subject)."""
+    m = _PREFIX_RE.match(subject.strip())
+    if m and m.group(1).lower() in GROUP_TITLES:
+        return m.group(1).lower(), m.group(2).strip()
+    return "other", subject.strip()
+
+
+def group_commits(commits: list[gitlog_mod.Commit]
+                  ) -> "OrderedDict[str, list[gitlog_mod.Commit]]":
+    groups: OrderedDict[str, list] = OrderedDict(
+        (g, []) for g in GROUP_ORDER)
+    for c in commits:
+        g, _ = classify(c.subject)
+        groups[g].append(c)
+    return groups
+
+
+def _commit_line(c: gitlog_mod.Commit) -> str:
+    _, clean = classify(c.subject)
+    files = f" ({len(c.files)} files)" if c.files else ""
+    pr = f" [PR #{c.pr_number}]" if c.pr_number else ""
+    return f"- {clean}{pr}{files} `{c.sha[:7]}`"
+
+
+def digest_markdown(root: str, since: str, label: str,
+                    author: str | None = None) -> str:
+    commits = gitlog_mod.commits_since(root, since, author)
+    in_progress = gitlog_mod.uncommitted(root)
+    repo = gitlog_mod.repo_name(root)
+    lines = [f"# Standup — {repo}", f"_{label}_", ""]
+    if not commits and not in_progress:
+        lines.append("No commits or uncommitted changes in range. "
+                     "Touch grass. 🌱")
+        return "\n".join(lines) + "\n"
+    if commits:
+        lines.append("## Shipped")
+        for group, items in group_commits(commits).items():
+            if not items:
+                continue
+            lines.append(f"### {GROUP_TITLES[group]}")
+            lines.extend(_commit_line(c) for c in items)
+            lines.append("")
+    if in_progress:
+        lines.append("## In progress (uncommitted)")
+        lines.extend(f"- `{p}`" for p in sorted(in_progress)[:20])
+        if len(in_progress) > 20:
+            lines.append(f"- …and {len(in_progress) - 20} more")
+        lines.append("")
+    lines.append("## Blockers")
+    lines.append("_none reported — fill in yours_")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def weekly_markdown(root: str, author: str | None = None) -> str:
+    commits = gitlog_mod.commits_since(root, "7 days ago", author)
+    repo = gitlog_mod.repo_name(root)
+    by_day: OrderedDict[str, list] = OrderedDict()
+    for c in commits:
+        by_day.setdefault(c.date, []).append(c)
+    lines = [f"# Weekly summary — {repo}",
+             f"_{len(commits)} commits in the last 7 days_", ""]
+    for day in sorted(by_day):
+        lines.append(f"## {day}")
+        for group, items in group_commits(by_day[day]).items():
+            if items:
+                lines.append(f"### {GROUP_TITLES[group]}")
+                lines.extend(_commit_line(c) for c in items)
+        lines.append("")
+    lines.append("## Highlights for sprint review")
+    lines.append("_pick 3–5 bullets from above_")
+    return "\n".join(lines) + "\n"

standupguy/draft.py

@@ -0,0 +1,100 @@
+"""Draft: turn a digest into Yesterday/Today/Blockers prose via a local model.
+
+Local-first: the default endpoint is Ollama on localhost. Point
+AUTOSTANDUP_BASE_URL at freellmapi or any OpenAI-compatible endpoint.
+Your git history never leaves the machine except to the endpoint YOU
+configured. No cloud SaaS, no data-leak ceremony.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.request
+import urllib.error
+
+
+class DraftError(RuntimeError):
+    pass
+
+
+# Largest digest (characters) sent to the model for --draft. A full-repo
+# digest can be hundreds of KB (the Round 2 panel measured 569KB/142k
+# tokens on one repo), so the digest is truncated for the MODEL CALL only;
+# the digest printed to the terminal is untouched.
+MAX_DIGEST_CHARS = 100_000
+
+TRUNCATION_NOTE = (
+    "\n\n[Note: this digest was truncated to 100,000 characters for the "
+    "model call. The full digest is still available above.]")
+
+
+DRAFT_TEMPLATE = """You are writing a developer's daily standup notes. Be terse.
+Use exactly these three sections:
+
+Yesterday:
+- 2-5 bullets of what was accomplished, in plain past tense.
+
+Today:
+- 2-4 bullets of what is in progress or planned next, inferred from the
+  in-progress files and the trajectory of yesterday's work.
+
+Blockers:
+- "None reported." unless the digest clearly shows something stuck.
+
+Rules: no fluff, no emojis, no inventing work that isn't in the digest.
+If the digest is thin, say so in one line and stop.
+
+Digest:
+---
+{digest}
+---
+"""
+
+
+def _cfg(base_url=None, api_key=None, model=None):
+    return {
+        "base_url": (base_url or os.environ.get("AUTOSTANDUP_BASE_URL")
+                     or "http://localhost:11434/v1").rstrip("/"),
+        "api_key": api_key or os.environ.get("AUTOSTANDUP_API_KEY") or "ollama",
+        "model": model or os.environ.get("AUTOSTANDUP_MODEL") or "llama3.1",
+    }
+
+
+def _cap_digest(digest_md: str) -> str:
+    """Truncate the digest for the model call; the terminal copy is full.
+
+    Returns the digest unchanged when it fits; otherwise keeps the first
+    MAX_DIGEST_CHARS characters and appends a note saying so. The note is
+    plain text without {} so DRAFT_TEMPLATE.format() stays safe.
+    """
+    if len(digest_md) <= MAX_DIGEST_CHARS:
+        return digest_md
+    return digest_md[:MAX_DIGEST_CHARS] + TRUNCATION_NOTE
+
+
+def draft(digest_md: str, *, base_url=None, api_key=None, model=None,
+          timeout: int = 120) -> str:
+    digest_md = _cap_digest(digest_md)
+    cfg = _cfg(base_url, api_key, model)
+    body = json.dumps({
+        "model": cfg["model"],
+        "messages": [{"role": "user",
+                      "content": DRAFT_TEMPLATE.format(digest=digest_md)}],
+        "temperature": 0.3,
+    }).encode()
+    req = urllib.request.Request(
+        cfg["base_url"] + "/chat/completions", data=body,
+        headers={"Content-Type": "application/json",
+                 "Authorization": f"Bearer {cfg['api_key']}"})
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            data = json.loads(resp.read().decode())
+    except urllib.error.URLError as e:
+        raise DraftError(
+            f"cannot reach model at {cfg['base_url']} "
+            f"(set AUTOSTANDUP_BASE_URL): {e.reason}")
+    try:
+        return data["choices"][0]["message"]["content"].strip()
+    except (KeyError, IndexError, TypeError) as e:
+        raise DraftError(f"unexpected response shape: {e}")

standupguy/gitlog.py

@@ -0,0 +1,122 @@
+"""Git ground truth: commits, files, merges, uncommitted work."""
+
+from __future__ import annotations
+
+import dataclasses
+import re
+import subprocess
+
+
+@dataclasses.dataclass
+class Commit:
+    sha: str
+    author: str
+    email: str
+    date: str          # YYYY-MM-DD
+    subject: str
+    files: list[str]
+    pr_number: int | None = None
+
+
+def _git(root: str, *args: str, env: dict | None = None) -> str:
+    import os
+    full_env = dict(os.environ)
+    if env:
+        full_env.update(env)
+    p = subprocess.run(["git", "-C", root, *args], capture_output=True,
+                       text=True, timeout=60, env=full_env)
+    if p.returncode != 0:
+        raise RuntimeError(f"git {' '.join(args)} failed: {p.stderr.strip()[:200]}")
+    return p.stdout
+
+
+_MERGE_RE = re.compile(r"merge pull request #(\d+)", re.IGNORECASE)
+
+
+def _since_to_arg(since: str) -> str:
+    """Normalize `since` to an unambiguous form for git.
+
+    Git's approxidate parses a bare "2026-10-14" (and words like
+    "yesterday") as NOON, not midnight — silently dropping morning
+    commits. Rewrite the common forms to explicit midnight strings,
+    which git handles correctly. Anything else passes through.
+    """
+    from datetime import datetime, timedelta
+    s = since.strip()
+    now = datetime.now().astimezone()
+    m = re.fullmatch(r"(\d{4})-(\d{2})-(\d{2})", s)
+    if m:
+        return f"{s} 00:00"
+    if s.lower() == "yesterday":
+        day = (now - timedelta(days=1)).strftime("%Y-%m-%d")
+        return f"{day} 00:00"
+    m = re.fullmatch(r"(\d+)\s+days?\s+ago", s.lower())
+    if m:
+        day = (now - timedelta(days=int(m.group(1)))).strftime("%Y-%m-%d")
+        return f"{day} 00:00"
+    return since
+
+
+def commits_since(root: str, since: str, author: str | None = None
+                  ) -> list[Commit]:
+    """since: 'yesterday', '7 days ago', '2026-10-01', or git date syntax."""
+    since = _since_to_arg(since)
+    args = ["log", f"--since={since}", "--date=short",
+            "--pretty=format:COMMIT:%H|%an|%ae|%ad|%s",
+            "--name-only", "HEAD"]
+    if author:
+        args.append(f"--author={author}")
+    try:
+        out = _git(root, *args)
+    except RuntimeError as e:
+        # empty repo (no commits yet) -> no history, not an error
+        if "unknown revision" in str(e):
+            return []
+        raise
+    commits: list[Commit] = []
+    cur: Commit | None = None
+    for line in out.splitlines():
+        if line.startswith("COMMIT:"):
+            if cur:
+                commits.append(cur)
+            _, rest = line.split("COMMIT:", 1)
+            sha, an, ae, ad, subject = rest.split("|", 4)
+            m = _MERGE_RE.search(subject)
+            cur = Commit(sha=sha, author=an, email=ae, date=ad,
+                         subject=subject, files=[],
+                         pr_number=int(m.group(1)) if m else None)
+        elif cur and line.strip():
+            cur.files.append(line.strip())
+    if cur:
+        commits.append(cur)
+    return commits
+
+
+def uncommitted(root: str) -> list[str]:
+    """Repo-relative paths with uncommitted changes."""
+    out = _git(root, "status", "--porcelain")
+    paths = []
+    for line in out.splitlines():
+        line = line.rstrip()
+        if not line:
+            continue
+        # format: XY <path> [-> <newpath>]
+        path = line[3:].split(" -> ")[-1].strip().strip('"')
+        paths.append(path)
+    return paths
+
+
+def default_author(root: str) -> str:
+    try:
+        return _git(root, "config", "user.email").strip()
+    except RuntimeError:
+        return ""
+
+
+def repo_name(root: str) -> str:
+    import os
+    try:
+        out = _git(root, "rev-parse", "--show-toplevel").strip()
+        return os.path.basename(out)
+    except RuntimeError:
+        return root

standupguy/mcp.py

@@ -0,0 +1,87 @@
+"""Stdio MCP server: let your coding agent ask what you shipped.
+
+Tools:
+  what_did_i_ship {since?, author?} -> standup digest markdown
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+from . import digest as digest_mod
+
+SERVER_INFO = {"name": "standupguy", "version": "0.1.0"}
+
+
+def handle(request: dict, root: str) -> dict | None:
+    req_id = request.get("id")
+    method = request.get("method")
+
+    def ok(result):
+        return {"jsonrpc": "2.0", "id": req_id, "result": result}
+
+    def err(code, message):
+        return {"jsonrpc": "2.0", "id": req_id,
+                "error": {"code": code, "message": message}}
+
+    if method == "initialize":
+        return ok({"protocolVersion": "2024-11-05",
+                   "capabilities": {"tools": {}},
+                   "serverInfo": SERVER_INFO})
+    if method == "notifications/initialized":
+        return None
+    if method == "tools/list":
+        return ok({"tools": [{
+            "name": "what_did_i_ship",
+            "description": ("Get a Markdown digest of what was shipped in a "
+                            "git repo since a date: commits grouped by type, "
+                            "in-progress files. Local-only, no cloud."),
+            "inputSchema": {"type": "object", "properties": {
+                "since": {"type": "string",
+                          "description": "git date: 'yesterday', '7 days ago', "
+                                         "'2026-10-01' (default: yesterday)"},
+                "author": {"type": "string",
+                           "description": "filter by author (default: repo user)"},
+                "root": {"type": "string",
+                         "description": "repo path (default: server's root)"}}},
+        }]})
+    if method == "tools/call":
+        params = request.get("params", {})
+        if params.get("name") != "what_did_i_ship":
+            return err(-32602, f"unknown tool: {params.get('name')}")
+        args = params.get("arguments", {})
+        since = args.get("since") or "yesterday"
+        r = args.get("root") or root
+        try:
+            md = digest_mod.digest_markdown(
+                r, since, f"since {since}", args.get("author"))
+        except Exception as e:
+            return ok({"content": [{"type": "text",
+                                    "text": json.dumps({"error": str(e)})}],
+                       "isError": True})
+        return ok({"content": [{"type": "text", "text": md}]})
+    return err(-32601, f"unknown method: {method}")
+
+
+def serve(root: str | None = None) -> int:
+    root = root or os.getcwd()
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            request = json.loads(line)
+        except ValueError:
+            continue
+        try:
+            response = handle(request, root)
+        except Exception as e:
+            rid = request.get("id") if isinstance(request, dict) else None
+            response = {"jsonrpc": "2.0", "id": rid,
+                        "error": {"code": -32603, "message": str(e)}}
+        if response is not None:
+            sys.stdout.write(json.dumps(response) + "\n")
+            sys.stdout.flush()
+    return 0

standupguy/push.py

@@ -0,0 +1,79 @@
+"""Slack push: POST the notes to an incoming webhook. Opt-in only."""
+
+from __future__ import annotations
+
+import json
+import re
+import unicodedata
+import urllib.request
+import urllib.error
+
+# Max characters per line of pushed text. Commit subjects flow through the
+# digest and (optionally) the LLM draft into Slack, so a hostile commit
+# message is an indirect prompt-injection vector against the team channel.
+# Long commit-derived lines are truncated here before anything is posted.
+MAX_PUSH_LINE_CHARS = 500
+
+# Slack mass-mentions we refuse to forward verbatim. Both forms are covered:
+# the plain @channel style and Slack's markup <!channel> style (which
+# plain-@channel filters miss but Slack still renders as a mass mention),
+# including Slack's optional display label (<!channel|channel>).
+# The word boundary keeps us from rewriting words like @channeling.
+_MASS_MENTION_RE = re.compile(
+    r"<!((?:channel|here|everyone))(?:\|[^<>]*)?>"
+    r"|@(channel|here|everyone)\b",
+    re.IGNORECASE)
+
+
+def sanitize_slack_text(text: str) -> str:
+    """Neutralize risky content before it reaches the team Slack channel.
+
+    - Strips control characters (keeps tab/newline) so hostile messages
+      can't smuggle terminal escapes or invisible layout tricks.
+    - Truncates each line to MAX_PUSH_LINE_CHARS (500) so a giant commit
+      message can't become a giant injected payload.
+    - Rewrites mass mentions as ``[at]channel``-style text: an injected
+      ``@channel`` or ``<!channel>`` must never ping the whole team. We chose
+      the visible ``[at]`` rewrite over a zero-width-space insertion because
+      it is unambiguous in logs, diffs, and every Slack client (zero-width
+      characters can be dropped or re-normalized downstream).
+    """
+    clean_lines = []
+    for line in text.splitlines():
+        line = "".join(
+            ch for ch in line
+            if ch == "\t" or unicodedata.category(ch) != "Cc"
+        )
+        if len(line) > MAX_PUSH_LINE_CHARS:
+            line = line[:MAX_PUSH_LINE_CHARS] + " […]"
+        line = _MASS_MENTION_RE.sub(
+            lambda m: "[at]" + (m.group(1) or m.group(2)).lower(), line)
+        clean_lines.append(line)
+    return "\n".join(clean_lines)
+
+
+class PushError(RuntimeError):
+    pass
+
+
+def push_slack(webhook_url: str, markdown: str, timeout: int = 30) -> None:
+    """POST markdown to a Slack incoming webhook.
+
+    The markdown is passed through :func:`sanitize_slack_text` first:
+    control chars stripped, lines truncated at 500 chars, mass mentions
+    (@channel/@here/@everyone and <!channel>/<!here>/<!everyone>)
+    neutralized to ``[at]channel``-style text —
+    so raw commit messages can never ping the channel or inject
+    formatting surprises.
+    """
+    if not webhook_url.startswith("https://hooks.slack.com/"):
+        raise PushError("refusing: not a Slack webhook URL")
+    body = json.dumps({"text": sanitize_slack_text(markdown)}).encode()
+    req = urllib.request.Request(webhook_url, data=body,
+                                 headers={"Content-Type": "application/json"})
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            if resp.status not in (200, 201, 204):
+                raise PushError(f"Slack returned HTTP {resp.status}")
+    except urllib.error.URLError as e:
+        raise PushError(f"Slack push failed: {e.reason}")

standupguy/serve.py

@@ -0,0 +1,125 @@
+"""HTTP bridge for workflow tools (n8n, Activepieces, etc.).
+
+n8n can't easily call a CLI on a schedule and parse stdout — but its
+HTTP Request node can hit this. Run `standupguy serve`, then point
+n8n at http://localhost:8765/digest.
+
+Endpoints:
+  GET /health                       -> {"ok": true}
+  GET /digest?since=&author=&format= -> standup digest (json|markdown)
+  GET /week?author=&format=          -> weekly summary (json|markdown)
+
+Binds 127.0.0.1 by default. Only open --host 0.0.0.0 if you know why.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from urllib.parse import urlparse, parse_qs
+
+from . import digest as digest_mod
+from . import gitlog as gitlog_mod
+
+
+# Per-connection socket timeout (seconds). A connection that goes quiet for
+# longer than this gets closed instead of holding a thread — and with the
+# single-threaded HTTPServer it previously held the WHOLE bridge hostage.
+CONNECTION_TIMEOUT = 30
+
+
+class ThreadedBridgeServer(ThreadingHTTPServer):
+    """ThreadingHTTPServer with a per-connection socket timeout.
+
+    One thread per connection so a stalled peer can never wedge the
+    bridge; the socket timeout bounds how long a quiet connection can
+    linger.
+    """
+
+    def get_request(self):
+        sock, addr = self.socket.accept()
+        sock.settimeout(CONNECTION_TIMEOUT)
+        return sock, addr
+
+
+def make_server(root: str, host: str = "127.0.0.1",
+                port: int = 8765) -> ThreadedBridgeServer:
+    """Build the configured bridge server (used by serve() and by tests)."""
+    Handler.root = root
+    return ThreadedBridgeServer((host, port), Handler)
+
+
+def _payload(root: str, query: dict, weekly: bool) -> tuple[int, str, str]:
+    """(status, content_type, body)."""
+    author = query.get("author", [None])[0] or None
+    fmt = (query.get("format", ["json"])[0] or "json").lower()
+    if weekly:
+        md = digest_mod.weekly_markdown(root, author)
+        commits = gitlog_mod.commits_since(root, "7 days ago", author)
+        label = "week"
+    else:
+        since = query.get("since", ["yesterday"])[0] or "yesterday"
+        md = digest_mod.digest_markdown(root, since, f"since {since}", author)
+        commits = gitlog_mod.commits_since(root, since, author)
+        label = f"since {since}"
+    if fmt == "markdown":
+        return 200, "text/markdown; charset=utf-8", md
+    body = json.dumps({
+        "repo": gitlog_mod.repo_name(root), "label": label,
+        "in_progress": gitlog_mod.uncommitted(root),
+        "commits": [{"sha": c.sha, "author": c.author, "date": c.date,
+                     "subject": c.subject, "files": c.files,
+                     "pr": c.pr_number} for c in commits],
+        "markdown": md,
+    })
+    return 200, "application/json", body
+
+
+class Handler(BaseHTTPRequestHandler):
+    root = os.getcwd()
+
+    def _send(self, status: int, ctype: str, body: str) -> None:
+        data = body.encode()
+        self.send_response(status)
+        self.send_header("Content-Type", ctype)
+        self.send_header("Content-Length", str(len(data)))
+        self.end_headers()
+        self.wfile.write(data)
+
+    def do_GET(self) -> None:  # noqa: N802
+        parsed = urlparse(self.path)
+        query = parse_qs(parsed.query)
+        if parsed.path == "/health":
+            self._send(200, "application/json", '{"ok": true}')
+        elif parsed.path == "/digest":
+            try:
+                s, t, b = _payload(self.root, query, weekly=False)
+                self._send(s, t, b)
+            except Exception as e:
+                self._send(500, "application/json",
+                           json.dumps({"error": str(e)}))
+        elif parsed.path == "/week":
+            try:
+                s, t, b = _payload(self.root, query, weekly=True)
+                self._send(s, t, b)
+            except Exception as e:
+                self._send(500, "application/json",
+                           json.dumps({"error": str(e)}))
+        else:
+            self._send(404, "application/json",
+                       '{"error": "use /digest, /week, or /health"}')
+
+    def log_message(self, *args):  # noqa: ANN001, ANN202
+        pass
+
+
+def serve(root: str, host: str = "127.0.0.1", port: int = 8765) -> int:
+    server = make_server(root, host, port)
+    print(f"standupguy serving {root} on http://{host}:{port} "
+          f"(/digest, /week, /health)")
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    return 0

standupguy-0.1.0.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: standupguy
+Version: 0.1.0
+Summary: Local-first standup notes from git ground truth.
+Author: Calas Automations Inc.
+License: MIT
+Project-URL: Homepage, https://github.com/calasdan-sketch/standupguy
+Project-URL: Issues, https://github.com/calasdan-sketch/standupguy/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# StandupGuy (`standupguy`)
+
+Kill the tracker trap without leaking data.
+
+Engineers lose up to 2/5 of the week to reporting busywork — duplicating
+updates across Jira, Slack, Confluence, and slide decks. AI note-takers are
+cloud SaaS with data-leak concerns. `standupguy` is the local-first
+alternative: it reads your **git history** (ground truth) and drafts your
+standup notes, weekly summary, and sprint-review bullets as Markdown.
+**Your history never leaves your laptop** — except to the model endpoint
+*you* configure (Ollama on localhost by default).
+
+## Install
+
+Zero dependencies — Python 3.10+ stdlib only.
+
+```bash
+git clone <repo> && cd standupguy
+# no-install alias (run from the repo root):
+alias standupguy="python3 -m standupguy"
+# or: pip install .   # provides the `standupguy` console script
+```
+
+## Usage
+
+```bash
+standupguy                          # yesterday's digest (deterministic, offline)
+standupguy --week                   # last 7 days
+standupguy --sprint                 # sprint-review bullets
+standupguy --since 2026-10-01       # custom range
+standupguy --draft                  # LLM prose: Yesterday / Today / Blockers
+standupguy --format json            # machine-readable digest
+standupguy --author "teammate@co"   # filter (default: your git user)
+standupguy --all                    # everyone
+standupguy --push-slack             # POST to AUTOSTANDUP_SLACK_WEBHOOK
+standupguy mcp                      # MCP server on stdio
+standupguy serve                    # HTTP bridge for Activepieces / workflow tools
+```
+
+## Activepieces
+
+`standupguy serve` exposes the digest over HTTP so Activepieces' HTTP
+Request piece can pull it on a schedule:
+
+```bash
+standupguy serve --root /path/to/repo   # localhost:8765
+```
+
+- `GET /digest?since=yesterday&author=&format=json|markdown`
+- `GET /week?author=&format=json|markdown`
+- `GET /health`
+
+[`workflows/activepieces-standup-digest.json`](workflows/activepieces-standup-digest.json)
+is a documented flow definition (it's a human-readable spec, not a native
+export — build it in Activepieces by adding the steps in order; the file
+carries the exact config for each step and setup notes at the top):
+weekday 9am Schedule trigger → HTTP Request → Branch (skip quiet days) →
+Slack. Connect your Slack connection, set the channel, done. The same
+`serve` endpoints work from n8n's HTTP Request node too — nothing in the
+bridge is platform-specific.
+
+Example output:
+
+```markdown
+# Standup — myrepo
+_since 2026-10-14_
+
+## Shipped
+### Features
+- add login flow (1 files) `6785c87`
+### Fixes
+- null pointer on logout (1 files) `8ce2731`
+
+## In progress (uncommitted)
+- `wip.py`
+
+## Blockers
+_none reported — fill in yours_
+```
+
+## How it works
+
+- **Digest mode (default):** pure Python, fully offline. Commits grouped by
+  conventional-commit prefix (feat/fix/docs/refactor/test/chore); merge
+  commits surface as shipped PRs; `git status` feeds the In-progress section.
+- **Draft mode (`--draft`):** sends the digest to your local model via an
+  OpenAI-compatible endpoint and gets back Yesterday/Today/Blockers prose.
+  Configure with env vars (Ollama defaults shown):
+
+```bash
+export AUTOSTANDUP_BASE_URL="http://localhost:11434/v1"
+export AUTOSTANDUP_MODEL="llama3.1"
+# freellmapi works too — it's OpenAI-compatible:
+export AUTOSTANDUP_BASE_URL="https://api.freellmapi.com/v1"
+export AUTOSTANDUP_API_KEY="<your key>"
+```
+
+- **MCP server:** exposes `what_did_i_ship {since?, author?, root?}` so your
+  coding agent can answer "what did I ship this week" from local git.
+- **Push:** `--push-slack` POSTs the Markdown to a Slack incoming webhook
+  (URL from the flag or `AUTOSTANDUP_SLACK_WEBHOOK`). Commit-derived text
+  is sanitized before posting: control characters stripped, lines
+  truncated at 500 chars, and `@channel`/`@here`/`@everyone` neutralized
+  to `[at]channel`-style text — so a hostile commit message can never ping
+  the channel or inject payloads. Jira/Confluence push
+  is intentionally not built in — paste the Markdown, keep your tokens
+  out of another integration.
+
+## Date handling
+
+Bare dates and words are normalized to explicit midnight (`2026-10-14` →
+`2026-10-14 00:00`, `yesterday` → yesterday 00:00) because git's date parser
+treats them as *noon* — silently dropping morning commits.
+
+## Tests
+
+```bash
+python3 -m unittest discover -s tests   # 36 tests, no network, no model
+```
+
+## License
+
+TBD

standupguy-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+standupguy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+standupguy/__main__.py,sha256=MHKZ_ae3fSLGTLUUMOx15fWdeOnJSHhq-zslRP5F5Lc,79
+standupguy/cli.py,sha256=COWdznA7602_5i-4MM6hcC7Ycc7NAdYPN-Gbh9hQISU,5145
+standupguy/digest.py,sha256=L3ruE3nIb11NRjDbvkNdemcvPpKSbmdoXsZAMvSov-E,3519
+standupguy/draft.py,sha256=Y8M0aZtuWPHvEcTy-dR4FYBbbyRy56-mpGa1n4gFIuU,3430
+standupguy/gitlog.py,sha256=DEwVhRegCIIrJwei3Q8TXIunP0g5BYhaZWyTkmNG2qQ,3764
+standupguy/mcp.py,sha256=UQ7SnXhl6D3KJukSVWN9WAM6TMLZN8SvKfvFTiFaY60,3218
+standupguy/push.py,sha256=nTQ1VHYznudXIArIhgDHLgbNSTxwJXgTDPGD1-vJNE8,3373
+standupguy/serve.py,sha256=f7QcCJFwdWQBwgMrszYtjlYclze8k05NEO8OIOERMJY,4534
+standupguy-0.1.0.dist-info/licenses/LICENSE,sha256=f-qFLkEfvZidBgKv2YINOOKS7Trk_gj1c6Cy718D8F0,1079
+standupguy-0.1.0.dist-info/METADATA,sha256=dfoUHiu8ra-_y0WgVsSuoL6udZE49JaaZl9GdaowJEY,4844
+standupguy-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+standupguy-0.1.0.dist-info/entry_points.txt,sha256=BDo9dF-bhfVsCeyKsSua8SH2GHI3svG_QuhzJQzzob0,51
+standupguy-0.1.0.dist-info/top_level.txt,sha256=WpKcSamOiLVk4KtEp608GLvAuChV990S9ORpBaoGMhs,11
+standupguy-0.1.0.dist-info/RECORD,,

standupguy-0.1.0.dist-info/WHEEL

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

standupguy-0.1.0.dist-info/entry_points.txt

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

standupguy-0.1.0.dist-info/licenses/LICENSE

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

standupguy-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+standupguy