goodturn 26.5.0__tar.gz

goodturn-26.5.0/.gitignore

@@ -0,0 +1,114 @@
+.omp/extensions/*.bak
+.claude/extensions/*.bak
+
+
+client/.sveltekit
+server/theory/*.json
+.hypothesis/
+prof/
+.cache
+.parcel-cache
+_stuff/
+*x.ipynb
+tmp/
+tmp_*.db*
+**/attic/*.json
+tmp*.json
+nohup.out
+ff_uploads/
+tmp_schema*.sql
+minio_data/
+biz_data/tmp_*
+nb/tmp_*
+nb/.ipynb_checkpoints
+nb/fonts/
+nb/_cells/
+
+# python
+
+venv
+.venv
+__pycache__
+docs/_build
+tmp.py
+htmlcov/
+.coverage.*
+test.db
+app.db
+node_modules
+stats.html
+
+*.py[cod]
+.pytest_cache
+
+.~lock.*
+
+
+# emacs
+*~
+._*
+.\#*
+\#*\#
+
+# C extensions
+*.so
+
+# Packages
+*.egg
+*.egg-info
+dist
+build
+eggs
+parts
+bin
+var
+sdist
+develop-eggs
+.installed.cfg
+lib64
+
+# Installer logs
+pip-log.txt
+
+# Unit test / coverage reports
+.coverage
+.tox
+nosetests.xml
+
+# Translations
+*.mo
+
+# Mr Developer
+.mr.developer.cfg
+.project
+.pydevproject
+
+# Vim
+*.sw[op]
+
+.cache/
+
+
+# Editor/tool artifacts
+.cursor/
+.omp/*
+!.omp/extensions/
+!.omp/mcp.json
+!.omp/settings.json
+
+# Secrets
+.env
+
+# Benchmark results (generated)
+bench/results/
+
+# Bulk data & caches
+biz_data/r29_cache/
+biz_data/r29_diary_urls.json
+biz_data/diary_*
+biz_data/gtm_*
+
+# Notebook cell extracts
+nb/_cells/omp-session-*.html
+web/node_modules
+web/.env

goodturn-26.5.0/CHANGELOG.md

@@ -0,0 +1,17 @@
+# goodturn Changelog
+
+## 26.5.0
+
+_(May 2, 2026)_
+
+- Initial PyPI release
+- Session harvester: extract lessons and fixes from AI coding sessions (Claude Code, OMP)
+- Session analyzer: multi-depth analysis (scan/focused/thorough) with signal detection
+- Insight detector: regex-based learning-moment detection (corrections, realizations, frustration, repeated errors)
+- Security advisory scanner: typosquatting, insecure HTTP, hardcoded credentials, dangerous code patterns
+- Outbox system: draft/review/submit workflow with deduplication and frontmatter management
+- `gt eval` command for batch session evaluation with per-session scoring
+- `gt review` command for interactive post review before submission
+- CI signal pipeline with GitHub OIDC zero-config auth
+- `stale` signal type for outdated solutions
+- CalVer versioning (YY.MM.MICRO)

goodturn-26.5.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: goodturn
+Version: 26.5.0
+Summary: Harvest and contribute knowledge from AI coding sessions
+License-Expression: BSD-3-Clause
+Requires-Python: >=3.10
+Requires-Dist: face>=24.0.0
+Requires-Dist: httpx<1.0,>=0.25
+Provides-Extra: dev
+Requires-Dist: pytest-xdist>=3.5; extra == 'dev'
+Requires-Dist: pytest>=7.4; extra == 'dev'

goodturn-26.5.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "goodturn"
+version = "26.5.0"
+description = "Harvest and contribute knowledge from AI coding sessions"
+requires-python = ">=3.10"
+license = "BSD-3-Clause"
+dependencies = [
+    "face>=24.0.0",
+    "httpx>=0.25,<1.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.4", "pytest-xdist>=3.5"]
+
+[project.scripts]
+goodturn = "goodturn.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/goodturn"]

goodturn-26.5.0/src/goodturn/__init__.py

@@ -0,0 +1,3 @@
+"""GoodTurn — harvest and contribute knowledge from AI coding sessions."""
+
+__version__ = "26.5.0"

goodturn-26.5.0/src/goodturn/__main__.py

@@ -0,0 +1,6 @@
+"""Support `python -m goodturn`."""
+
+from goodturn.cli import main
+
+if __name__ == "__main__":
+    main()

goodturn-26.5.0/src/goodturn/_parse_duration.py

@@ -0,0 +1,34 @@
+"""Regex-based duration string parser.
+
+Replaces ``boltons.timeutils.parse_timedelta`` with a stdlib-only
+implementation that handles the patterns we actually use: ``7d``,
+``2w``, ``1d12h``, ``3h``, ``30m``.
+"""
+
+from __future__ import annotations
+
+import re
+from datetime import timedelta
+
+_DURATION_RE = re.compile(
+    r"(?:(\d+)w)?(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?$"
+)
+
+
+def parse_duration(s: str) -> timedelta:
+    """Parse a human duration string into a :class:`~datetime.timedelta`.
+
+    Supported units: weeks (``w``), days (``d``), hours (``h``),
+    minutes (``m``).  Units may be combined: ``1d12h``.
+
+    Raises :class:`ValueError` on unparseable input.
+    """
+    s = s.strip()
+    m = _DURATION_RE.fullmatch(s)
+    if m is None or not any(m.groups()):
+        raise ValueError(f"cannot parse duration: {s!r}")
+    weeks = int(m.group(1) or 0)
+    days = int(m.group(2) or 0)
+    hours = int(m.group(3) or 0)
+    minutes = int(m.group(4) or 0)
+    return timedelta(weeks=weeks, days=days, hours=hours, minutes=minutes)

goodturn-26.5.0/src/goodturn/_yaml.py

@@ -0,0 +1,111 @@
+"""Minimal YAML serialization and parsing for frontmatter-style metadata.
+
+Handles only the constrained schema we produce: flat scalars, flow
+sequences ``[a, b]``, and inline dicts ``{k: v}``.  No full YAML parser
+needed.
+"""
+
+from __future__ import annotations
+
+
+def _yaml_scalar(value: object) -> str:
+    """Format a scalar for YAML output.  Strings are double-quoted."""
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, (int, float)):
+        return str(value)
+    # String: double-quote, escaping internal quotes and backslashes.
+    s = str(value).replace("\\", "\\\\").replace('"', '\\"')
+    return f'"{s}"'
+
+
+def _yaml_list(items: list[str]) -> str:
+    """Format a list as YAML flow sequence ``[a, b, c]``."""
+    inner = ", ".join(_yaml_scalar(i) for i in items)
+    return f"[{inner}]"
+
+
+def _yaml_dict(d: dict[str, str]) -> str:
+    """Format a dict as inline YAML ``{"k": "v", ...}``."""
+    parts = ", ".join(
+        f"{_yaml_scalar(k)}: {_yaml_scalar(v)}" for k, v in d.items()
+    )
+    return f"{{{parts}}}"
+
+
+# ---------------------------------------------------------------------------
+# Parsing
+# ---------------------------------------------------------------------------
+
+
+def _parse_frontmatter(text: str) -> tuple[dict[str, str], str]:
+    """Parse a ``---``-delimited YAML frontmatter block from *text*.
+
+    Returns ``(metadata_dict, body)`` where metadata values are raw strings.
+    Only handles the constrained schema we produce: flat scalars and
+    bracket-delimited string lists.
+    """
+    if not text.startswith("---"):
+        return {}, text
+
+    # Find closing '---' (must be on its own line after the opening).
+    end = text.find("\n---", 3)
+    if end == -1:
+        return {}, text
+
+    fm_block = text[4:end]  # skip opening '---\n'
+    body = text[end + 4 :]  # skip '\n---'
+    if body.startswith("\n"):
+        body = body[1:]
+
+    meta: dict[str, str] = {}
+    for line in fm_block.strip().split("\n"):
+        colon = line.find(":")
+        if colon == -1:
+            continue
+        key = line[:colon].strip()
+        val = line[colon + 1 :].strip()
+        meta[key] = val
+    return meta, body
+
+
+def _unquote(s: str) -> str:
+    """Remove surrounding double quotes and unescape."""
+    if len(s) >= 2 and s[0] == '"' and s[-1] == '"':
+        return s[1:-1].replace('\\"', '"').replace("\\\\", "\\")
+    return s
+
+
+def _parse_yaml_list(s: str) -> list[str]:
+    """Parse a YAML flow sequence ``[a, b, c]`` into a list of strings."""
+    s = s.strip()
+    if not s.startswith("[") or not s.endswith("]"):
+        return [_unquote(s)] if s else []
+    inner = s[1:-1].strip()
+    if not inner:
+        return []
+    return [_unquote(item.strip()) for item in inner.split(",")]
+
+
+def _parse_yaml_dict(s: str) -> dict[str, str]:
+    """Parse an inline YAML dict ``{key: "val", key2: "val2"}``.
+
+    Returns an empty dict for missing or malformed input.
+    """
+    s = s.strip()
+    if not s.startswith("{") or not s.endswith("}"):
+        return {}
+    inner = s[1:-1].strip()
+    if not inner:
+        return {}
+    result: dict[str, str] = {}
+    for part in inner.split(","):
+        part = part.strip()
+        colon = part.find(":")
+        if colon == -1:
+            continue
+        key = _unquote(part[:colon].strip())
+        val = _unquote(part[colon + 1 :].strip())
+        if key:
+            result[key] = val
+    return result