xithead 1.4.0 → 1.5.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (86) hide show
  1. package/README.md +108 -72
  2. package/app/api/config/route.ts +22 -0
  3. package/app/api/export/route.ts +83 -0
  4. package/app/api/models/route.ts +12 -0
  5. package/app/api/stats/route.ts +46 -0
  6. package/app/dashboard/page.tsx +445 -0
  7. package/app/globals.css +35 -0
  8. package/app/installation/page.tsx +293 -0
  9. package/app/layout.tsx +35 -0
  10. package/app/master-design-system.css +2076 -0
  11. package/app/master-design-system.source.css +8 -0
  12. package/app/page.tsx +187 -0
  13. package/app/rechtliches/agb/page.tsx +165 -0
  14. package/app/rechtliches/datenschutz/page.tsx +128 -0
  15. package/app/rechtliches/impressum/page.tsx +122 -0
  16. package/app/rechtliches/widerruf/page.tsx +185 -0
  17. package/bin/xithead.js +264 -0
  18. package/components/layout/AppShell.tsx +25 -0
  19. package/components/layout/Footer.tsx +120 -0
  20. package/components/layout/Header.tsx +145 -0
  21. package/components/marketing/LegalHighlights.tsx +45 -0
  22. package/components/marketing/LegalPageShell.tsx +49 -0
  23. package/components/marketing/LegalPanel.tsx +41 -0
  24. package/components/marketing/index.ts +3 -0
  25. package/design-system/README.md +80 -0
  26. package/design-system/base.css +127 -0
  27. package/design-system/components.css +1943 -0
  28. package/design-system/fonts.css +17 -0
  29. package/design-system/tailwind-preset.js +95 -0
  30. package/design-system/tokens.css +48 -0
  31. package/design-system/utilities.css +53 -0
  32. package/lib/config/index.ts +12 -0
  33. package/lib/hooks/index.ts +4 -0
  34. package/lib/hooks/use-mounted.ts +13 -0
  35. package/lib/hooks/use-session.ts +34 -0
  36. package/lib/hooks/use-settings.ts +49 -0
  37. package/lib/utils/index.ts +1 -0
  38. package/lib/utils/settings.ts +162 -0
  39. package/lib/utils/utils.ts +6 -0
  40. package/middleware.ts +26 -0
  41. package/next-env.d.ts +7 -0
  42. package/next.config.ts +12 -0
  43. package/package.json +77 -36
  44. package/postcss.config.mjs +7 -0
  45. package/public/apple-touch-icon.png +0 -0
  46. package/public/logo-transparent.png +0 -0
  47. package/public/xithead.ps1 +937 -0
  48. package/scripts/README.md +77 -0
  49. package/scripts/audit_wheel_glibc_symbols.py +217 -0
  50. package/scripts/build-master-design-system.cjs +33 -0
  51. package/scripts/build_rust_extension.sh +58 -0
  52. package/scripts/changelog-gen.py +203 -0
  53. package/scripts/eval_output_shaper.py +235 -0
  54. package/scripts/export_kompress_v2_onnx.py +267 -0
  55. package/scripts/fixtures/anthropic_replay_body.json +133 -0
  56. package/scripts/fixtures/codex_response_create_frame.json +52 -0
  57. package/scripts/install-git-hooks.sh +104 -0
  58. package/scripts/install.ps1 +1809 -0
  59. package/scripts/install.sh +1673 -0
  60. package/scripts/pr-governance.py +297 -0
  61. package/scripts/record_fixtures.py +59 -0
  62. package/scripts/refresh_model_limits.sh +48 -0
  63. package/scripts/replay_codex_ws_load.py +445 -0
  64. package/scripts/repro_codex_replay.py +699 -0
  65. package/scripts/smoke_issue_327.py +233 -0
  66. package/scripts/sync-plugin-versions.py +116 -0
  67. package/scripts/tests/test_changelog_gen.py +302 -0
  68. package/scripts/tests/test_pr_governance.py +163 -0
  69. package/scripts/tests/test_pr_health_labels.py +94 -0
  70. package/scripts/tests/test_pr_health_workflow.py +14 -0
  71. package/scripts/tests/test_sync_plugin_versions.py +131 -0
  72. package/scripts/tests/test_version_sync.py +291 -0
  73. package/scripts/validate-workflows.sh +39 -0
  74. package/scripts/verify-versions.py +106 -0
  75. package/scripts/version-sync.py +207 -0
  76. package/tailwind.config.js +31 -0
  77. package/tailwind.master.config.cjs +47 -0
  78. package/tsconfig.json +84 -0
  79. package/types/api.ts +12 -0
  80. package/types/config.ts +9 -0
  81. package/types/index.ts +2 -0
  82. package/npm/bin/xithead.js +0 -366
  83. package/npm/index.d.ts +0 -57
  84. package/npm/index.js +0 -139
  85. package/npm/package.json +0 -54
  86. package/npm/postinstall.js +0 -43
@@ -0,0 +1,77 @@
1
+ # scripts/
2
+
3
+ Utility scripts bundled with the Headroom repo. Most are one-off operator
4
+ tools; a few are runnable as part of development workflows.
5
+
6
+ ## Reproducing the reconnect storm
7
+
8
+ `repro_codex_replay.py` reproduces the multi-agent Codex reconnect/retry storm
9
+ against a local Xtream Head proxy (default `http://127.0.0.1:8787`), as described
10
+ in `wiki/plans/2026-04-17-codex-proxy-runtime-analysis.md` under "Latest
11
+ Correction". Use it to:
12
+
13
+ - Regression-check that `/livez` stays responsive under a cold-start storm.
14
+ - Empirically tune the Unit 4 pre-upstream semaphore default
15
+ (`HEADROOM_ANTHROPIC_PRE_UPSTREAM_CONCURRENCY`).
16
+ - Exercise the Codex WS lifecycle + Anthropic HTTP path simultaneously
17
+ without needing to replay captured production traffic.
18
+
19
+ ### Run
20
+
21
+ ```bash
22
+ # Default: 8 WS + 4 HTTP clients, 30s storm, p99 /livez must stay <= 500ms.
23
+ python scripts/repro_codex_replay.py
24
+
25
+ # Tighter budget, shorter run:
26
+ python scripts/repro_codex_replay.py \
27
+ --url http://127.0.0.1:8787 \
28
+ --ws-clients 16 \
29
+ --anthropic-clients 8 \
30
+ --duration 60 \
31
+ --livez-threshold-ms 100
32
+
33
+ # Dump the full summary as JSON for downstream tooling:
34
+ python scripts/repro_codex_replay.py --json
35
+ ```
36
+
37
+ Exit code:
38
+
39
+ - `0` — warmup succeeded (or was skipped), storm ran for the requested
40
+ duration, and `/livez` p99 stayed under `--livez-threshold-ms`.
41
+ - `1` — soft assertion failed, proxy unreachable, or unhandled exception.
42
+ Proxy-unreachable is detected and reported within ~5 seconds.
43
+
44
+ ### Fixtures
45
+
46
+ The script loads two hand-crafted, fully synthetic JSON fixtures:
47
+
48
+ - `scripts/fixtures/anthropic_replay_body.json` — shape of a large agent
49
+ reconnect replay `/v1/messages?beta=true` POST body.
50
+ - `scripts/fixtures/codex_response_create_frame.json` — first Codex WS frame
51
+ with the `{"type": "response.create", "response": {...}}` envelope.
52
+
53
+ Override via `--ws-frame-fixture` / `--anthropic-body-fixture` if you have
54
+ captured traffic to replay instead.
55
+
56
+ ### Interpretation
57
+
58
+ - `/livez p99` under threshold means the event loop is not starved during the
59
+ storm. If it rises with the semaphore unbounded
60
+ (`HEADROOM_ANTHROPIC_PRE_UPSTREAM_CONCURRENCY=10000`) and drops back under
61
+ the default, Unit 4's backpressure is working.
62
+ - `Codex WS: opened` should equal `--ws-clients`. `response.completed`
63
+ typically stays low when upstream auth isn't configured locally — the goal
64
+ is handshake + relay wiring, not real upstream traffic.
65
+ - `Anthropic HTTP: ok_2xx + non_2xx + timed_out + errors` should roughly equal
66
+ `attempted`. Sustained non-zero `timed_out` during the storm is the failure
67
+ signal the plan targets.
68
+
69
+ A smoke test at `tests/test_scripts/test_repro_codex_replay_smoke.py`
70
+ exercises the script against a mock FastAPI server on every PR.
71
+
72
+ ## Install scripts
73
+
74
+ - `install.sh` — POSIX installer.
75
+ - `install.ps1` — Windows PowerShell installer.
76
+
77
+ These are generated by the release pipeline; edit with care.
@@ -0,0 +1,217 @@
1
+ #!/usr/bin/env python3
2
+ """Audit a manylinux Python wheel for glibc symbol references that exceed
3
+ the wheel's declared manylinux ABI floor.
4
+
5
+ This catches the bug class from issue #355: a wheel tagged
6
+ `manylinux_2_28_x86_64` whose `_core.so` references `__isoc23_strtoll`
7
+ (introduced in glibc 2.38) — the link succeeds because the manylinux
8
+ build host has 2.38+, but every end user with glibc < 2.38 sees an
9
+ `ImportError: undefined symbol` at `import headroom._core`.
10
+
11
+ How it works
12
+ ------------
13
+
14
+ 1. Parse the wheel filename to extract the manylinux tag
15
+ (`manylinux_2_28` → glibc floor 2.28).
16
+ 2. Run `objdump -T` (or `nm -D`) on every `.so` inside the wheel.
17
+ 3. For every `UND` symbol, check whether it's allowed at the glibc
18
+ floor. Allowed:
19
+ - Symbols with a `GLIBC_x.y` version tag where `x.y <= floor`.
20
+ - Symbols defined by us locally (i.e. NOT marked `UND`).
21
+ 4. Reject any `UND` symbol that's:
22
+ - Tagged with a GLIBC version > floor.
23
+ - Or in the `__isoc23_*` family (no version tag, but introduced
24
+ in glibc 2.38 — special-cased).
25
+ - Or in any other known "introduced after floor" symbol list
26
+ (extensible).
27
+
28
+ Exit 0 = wheel is portable. Exit 1 = wheel will break on some users.
29
+
30
+ Usage
31
+ -----
32
+
33
+ scripts/audit_wheel_glibc_symbols.py path/to/headroom_ai-*.whl
34
+
35
+ Run on Linux only — `objdump` from binutils is the audit tool. macOS's
36
+ default `objdump` is llvm-objdump, also works on ELF.
37
+ """
38
+
39
+ from __future__ import annotations
40
+
41
+ import argparse
42
+ import re
43
+ import shutil
44
+ import subprocess
45
+ import sys
46
+ import tempfile
47
+ import zipfile
48
+ from pathlib import Path
49
+
50
+ # Symbols introduced after specific glibc versions, beyond what
51
+ # `auditwheel` already checks (auditwheel relies on the GLIBC_x.y
52
+ # version tag baked into versioned symbols; the entries below are
53
+ # either tagless or family-tagged, neither of which auditwheel
54
+ # catches). Add here as new bug classes surface.
55
+ #
56
+ # Each entry is `(symbol_name_prefix, min_glibc_version_introduced, justification_url)`.
57
+ # `startswith(prefix)` is used to match — for a single symbol use the
58
+ # full name as the prefix (no other symbol starts with it).
59
+ POST_FLOOR_SYMBOLS = [
60
+ # C23 strtol family. Issue #355.
61
+ (
62
+ "__isoc23_",
63
+ (2, 38),
64
+ "https://sourceware.org/glibc/wiki/Release/2.38",
65
+ ),
66
+ # Single-threaded fast-path flag read by libstdc++ (gcc 11+).
67
+ # Caught by the X1 smoke gate on PR #396 (X2 dry-run) on the
68
+ # manylinux_2_28 floor entry — the audit had let the wheel
69
+ # through because it didn't know about this symbol.
70
+ (
71
+ "__libc_single_threaded",
72
+ (2, 32),
73
+ "https://sourceware.org/glibc/wiki/Release/2.32",
74
+ ),
75
+ ]
76
+
77
+
78
+ def parse_manylinux_floor(wheel_filename: str) -> tuple[int, int] | None:
79
+ """Extract glibc floor from a manylinux wheel filename.
80
+
81
+ `headroom_ai-0.20.26-cp312-cp312-manylinux_2_28_x86_64.whl` → (2, 28).
82
+ Returns None for non-manylinux wheels (macOS, Windows, sdist).
83
+ """
84
+ m = re.search(r"manylinux_(\d+)_(\d+)_", wheel_filename)
85
+ if m:
86
+ return (int(m.group(1)), int(m.group(2)))
87
+ # `manylinux2014_x86_64` is the legacy alias for manylinux_2_17.
88
+ if "manylinux2014_" in wheel_filename:
89
+ return (2, 17)
90
+ if "manylinux1_" in wheel_filename:
91
+ return (2, 5)
92
+ return None
93
+
94
+
95
+ def list_undef_symbols(so_path: Path) -> list[tuple[str, str]]:
96
+ """Return [(symbol_name, glibc_version_or_empty), ...] for every
97
+ UND (undefined) dynamic symbol in `so_path`.
98
+ """
99
+ objdump = shutil.which("objdump") or shutil.which("llvm-objdump")
100
+ if not objdump:
101
+ raise RuntimeError(
102
+ "neither `objdump` nor `llvm-objdump` is on PATH; "
103
+ "install binutils (Linux) or LLVM (macOS) to run this audit"
104
+ )
105
+ out = subprocess.run(
106
+ [objdump, "-T", str(so_path)],
107
+ check=True,
108
+ capture_output=True,
109
+ text=True,
110
+ ).stdout
111
+ found = []
112
+ for line in out.splitlines():
113
+ # `objdump -T` lines: `address SECTION ... NAME` where SECTION
114
+ # contains `*UND*` for undefined references and a versioned
115
+ # symbol name like `__isoc23_strtoll@GLIBC_2.38` or unversioned.
116
+ if "*UND*" not in line:
117
+ continue
118
+ # The last whitespace-separated token is the (versioned) symbol.
119
+ token = line.split()[-1]
120
+ if "@" in token:
121
+ name, _, ver = token.partition("@")
122
+ # `@@` indicates the default version; strip the second `@`.
123
+ ver = ver.lstrip("@")
124
+ else:
125
+ name, ver = token, ""
126
+ found.append((name, ver))
127
+ return found
128
+
129
+
130
+ def glibc_version_from_token(ver: str) -> tuple[int, int] | None:
131
+ """`GLIBC_2.28` → (2, 28). Returns None for non-GLIBC tokens."""
132
+ m = re.match(r"^GLIBC_(\d+)\.(\d+)", ver)
133
+ if m:
134
+ return (int(m.group(1)), int(m.group(2)))
135
+ return None
136
+
137
+
138
+ def audit_so(so_path: Path, floor: tuple[int, int]) -> list[str]:
139
+ """Return a list of human-readable violation strings."""
140
+ violations: list[str] = []
141
+ for name, ver in list_undef_symbols(so_path):
142
+ v = glibc_version_from_token(ver)
143
+ if v is not None and v > floor:
144
+ violations.append(
145
+ f" {name}@{ver} requires glibc {v[0]}.{v[1]} > floor {floor[0]}.{floor[1]}"
146
+ )
147
+ continue
148
+ # Versionless symbols: cross-check the post-floor list.
149
+ for prefix, introduced, url in POST_FLOOR_SYMBOLS:
150
+ if name.startswith(prefix) and introduced > floor:
151
+ violations.append(
152
+ f" {name} (no version tag, introduced in glibc "
153
+ f"{introduced[0]}.{introduced[1]} > floor "
154
+ f"{floor[0]}.{floor[1]} — see {url})"
155
+ )
156
+ break
157
+ return violations
158
+
159
+
160
+ def main() -> int:
161
+ parser = argparse.ArgumentParser(description=__doc__)
162
+ parser.add_argument("wheel", type=Path, help="path to the .whl to audit")
163
+ args = parser.parse_args()
164
+
165
+ wheel: Path = args.wheel
166
+ if not wheel.exists():
167
+ print(f"ERROR: wheel not found: {wheel}", file=sys.stderr)
168
+ return 1
169
+
170
+ floor = parse_manylinux_floor(wheel.name)
171
+ if floor is None:
172
+ print(
173
+ f"OK: {wheel.name} is not a manylinux wheel; nothing to audit "
174
+ "(macOS / Windows / sdist run on a different runtime ABI)."
175
+ )
176
+ return 0
177
+
178
+ print(f"Auditing {wheel.name} (glibc floor: {floor[0]}.{floor[1]})")
179
+ with tempfile.TemporaryDirectory() as td:
180
+ td_path = Path(td)
181
+ with zipfile.ZipFile(wheel) as zf:
182
+ so_members = [m for m in zf.namelist() if m.endswith(".so")]
183
+ if not so_members:
184
+ print(
185
+ f"WARN: {wheel.name} contains no .so files; "
186
+ "nothing to audit (pure-Python wheel?)"
187
+ )
188
+ return 0
189
+ zf.extractall(td_path, members=so_members)
190
+
191
+ all_violations: list[tuple[str, list[str]]] = []
192
+ for so_rel in so_members:
193
+ so_path = td_path / so_rel
194
+ violations = audit_so(so_path, floor)
195
+ if violations:
196
+ all_violations.append((so_rel, violations))
197
+
198
+ if not all_violations:
199
+ print(f"OK: all .so files in {wheel.name} are within glibc {floor[0]}.{floor[1]}.")
200
+ return 0
201
+
202
+ print(f"\nFAIL: {wheel.name} references symbols above its glibc floor:")
203
+ for so_name, viols in all_violations:
204
+ print(f"\n {so_name}:")
205
+ for v in viols:
206
+ print(f" {v}")
207
+ print(
208
+ "\nThis wheel will fail to import on end-user systems with the "
209
+ "older glibc. Fix the build (or add a compat shim) before "
210
+ "publishing to PyPI. See issue #355 for the canonical example "
211
+ "and `crates/headroom-py/glibc_compat.c` for the shim pattern."
212
+ )
213
+ return 1
214
+
215
+
216
+ if __name__ == "__main__":
217
+ sys.exit(main())
@@ -0,0 +1,33 @@
1
+ const fs = require('node:fs/promises');
2
+ const path = require('node:path');
3
+ const postcss = require('postcss');
4
+ const atImport = require('postcss-import');
5
+ const tailwindcss = require('tailwindcss-v3');
6
+ const autoprefixer = require('autoprefixer');
7
+
8
+ const root = path.resolve(__dirname, '..');
9
+
10
+ async function build() {
11
+ const sourcePath = path.join(root, 'app', 'master-design-system.source.css');
12
+ const configPath = path.join(root, 'tailwind.master.config.cjs');
13
+ const config = require(configPath);
14
+
15
+ const result = await postcss([
16
+ atImport(),
17
+ tailwindcss(config),
18
+ autoprefixer(),
19
+ ]).process(await fs.readFile(sourcePath, 'utf8'), {
20
+ from: sourcePath,
21
+ to: path.join(root, 'app', 'master-design-system.css'),
22
+ });
23
+
24
+ await fs.writeFile(path.join(root, 'app', 'master-design-system.css'), result.css);
25
+ if (result.warnings().length) {
26
+ console.warn(result.warnings().map((warning) => warning.toString()).join('\n'));
27
+ }
28
+ }
29
+
30
+ build().catch((error) => {
31
+ console.error(error);
32
+ process.exitCode = 1;
33
+ });
@@ -0,0 +1,58 @@
1
+ #!/usr/bin/env bash
2
+ # Build + install the Rust extension (headroom._core) into the active venv.
3
+ #
4
+ # With single-wheel architecture (post-#355), `pip install -e .` invokes
5
+ # maturin (declared in pyproject.toml's `[build-system]`) which builds the
6
+ # Rust extension and installs it into site-packages alongside the Python
7
+ # source. Earlier versions of this script symlinked the .so into the
8
+ # in-tree `headroom/` directory because the dual-package layout left the
9
+ # .so in `crates/headroom-py/python/headroom/`. That dance is no longer
10
+ # needed — maturin places the .so directly in the editable install's
11
+ # overlay and Python's import system finds it.
12
+ #
13
+ # Idempotent. Safe to run repeatedly.
14
+
15
+ set -euo pipefail
16
+
17
+ cd "$(dirname "$0")/.."
18
+
19
+ log() {
20
+ printf '[build_rust_extension] %s\n' "$*" >&2
21
+ }
22
+
23
+ fail() {
24
+ printf '[build_rust_extension] error: %s\n' "$*" >&2
25
+ exit 1
26
+ }
27
+
28
+ # Pre-flight: a venv should be active. The install would otherwise write
29
+ # into the system Python.
30
+ if [[ -z "${VIRTUAL_ENV:-}" ]]; then
31
+ log "warning: VIRTUAL_ENV is unset; pip will install into the system Python."
32
+ log " If that is not what you want, abort and 'source .venv/bin/activate' first."
33
+ fi
34
+
35
+ if ! command -v cargo >/dev/null 2>&1; then
36
+ fail "cargo not found on PATH. Install Rust toolchain (rustup) first."
37
+ fi
38
+
39
+ # Build + install in one shot. The `[build-system] build-backend = "maturin"`
40
+ # in pyproject.toml means pip drives maturin under the hood. The resulting
41
+ # wheel contains both the Python source and the compiled `headroom/_core.so`,
42
+ # and pip installs them into the editable overlay together.
43
+ log "pip install -e . (drives maturin via build-backend)"
44
+ python -m pip install -e . || fail "pip install -e . failed (see output above)"
45
+
46
+ # End-to-end verification — same shape as Phase A0's startup smoke check.
47
+ log "verifying \`from headroom._core import DiffCompressor, SmartCrusher\`"
48
+ python -c '
49
+ import sys
50
+ try:
51
+ from headroom._core import DiffCompressor, SmartCrusher
52
+ except Exception as exc:
53
+ print(f"verify FAILED: {type(exc).__name__}: {exc}", file=sys.stderr)
54
+ sys.exit(1)
55
+ print(f"verify OK: DiffCompressor={DiffCompressor!r}, SmartCrusher={SmartCrusher!r}")
56
+ ' || fail "import verification failed (see above)"
57
+
58
+ log "headroom._core build + install + verify: OK"
@@ -0,0 +1,203 @@
1
+ #!/usr/bin/env python3
2
+ """Generate changelog from conventional commits."""
3
+
4
+ from __future__ import annotations
5
+
6
+ import argparse
7
+ import re
8
+ import subprocess
9
+ from datetime import date
10
+ from pathlib import Path
11
+ from typing import NamedTuple
12
+
13
+ ROOT = Path(__file__).parent.parent
14
+
15
+ COMMIT_PATTERN = re.compile(
16
+ r"^(feat|fix|ci|chore|perf|refactor|docs|style|test)(\(.+\))?(!)?:\s*(.+)$"
17
+ )
18
+ BREAKING_CHANGE_PATTERN = re.compile(r"^BREAKING CHANGE:\s*(.+)$", re.MULTILINE)
19
+ COMMIT_ENTRY_PATTERN = re.compile(r"^(.+?)(?:\n(.+))?\|(\w+)$", re.MULTILINE)
20
+ FIELD_SEP = "\x1f"
21
+ RECORD_SEP = "\x1e"
22
+ GIT_LOG_FORMAT = "%s%x1f%b%x1f%h%x1e"
23
+
24
+ TYPE_LABELS: dict[str, str] = {
25
+ "feat": "Features",
26
+ "fix": "Bug Fixes",
27
+ "ci": "CI/CD",
28
+ "chore": "Chores",
29
+ "perf": "Performance",
30
+ "refactor": "Refactors",
31
+ "docs": "Documentation",
32
+ "style": "Styles",
33
+ "test": "Tests",
34
+ "other": "Other Changes",
35
+ }
36
+
37
+
38
+ class ParsedCommit(NamedTuple):
39
+ type: str
40
+ scope: str | None
41
+ breaking: bool
42
+ message: str
43
+ hash: str
44
+
45
+
46
+ def iter_commit_entries(log_output: str) -> list[tuple[str, str, str]]:
47
+ """Split raw git log output into (subject, body, hash) tuples."""
48
+
49
+ if not log_output.strip():
50
+ return []
51
+
52
+ if RECORD_SEP in log_output and FIELD_SEP in log_output:
53
+ entries: list[tuple[str, str, str]] = []
54
+ for raw_entry in log_output.split(RECORD_SEP):
55
+ if not raw_entry:
56
+ continue
57
+ if FIELD_SEP not in raw_entry:
58
+ continue
59
+ subject, body_and_hash = raw_entry.split(FIELD_SEP, 1)
60
+ if FIELD_SEP not in body_and_hash:
61
+ continue
62
+ body, commit_hash = body_and_hash.rsplit(FIELD_SEP, 1)
63
+ entries.append((subject.strip(), body.strip(), commit_hash.strip()))
64
+ return entries
65
+
66
+ return [
67
+ (
68
+ match.group(1).strip(),
69
+ (match.group(2) or "").strip(),
70
+ match.group(3).strip(),
71
+ )
72
+ for match in COMMIT_ENTRY_PATTERN.finditer(log_output)
73
+ ]
74
+
75
+
76
+ def get_merge_summary(subject: str, body: str) -> str:
77
+ """Return the first meaningful summary line for a merge commit."""
78
+
79
+ if not subject.startswith("Merge "):
80
+ return ""
81
+
82
+ for line in body.splitlines():
83
+ stripped = line.strip()
84
+ if stripped:
85
+ return stripped
86
+ return ""
87
+
88
+
89
+ def parse_commits(log_output: str) -> list[ParsedCommit]:
90
+ """Parse git log output into structured commits."""
91
+
92
+ commits: list[ParsedCommit] = []
93
+
94
+ for subject, body, commit_hash in iter_commit_entries(log_output):
95
+ is_breaking = bool(BREAKING_CHANGE_PATTERN.search(body))
96
+ merge_summary = get_merge_summary(subject, body)
97
+ candidates = [subject]
98
+ if merge_summary:
99
+ candidates.insert(0, merge_summary)
100
+
101
+ for candidate in candidates:
102
+ commit_match = COMMIT_PATTERN.match(candidate)
103
+ if not commit_match:
104
+ continue
105
+
106
+ scope = commit_match.group(2)
107
+ if scope:
108
+ scope = scope[1:-1]
109
+ commits.append(
110
+ ParsedCommit(
111
+ type=commit_match.group(1),
112
+ scope=scope,
113
+ breaking=is_breaking or bool(commit_match.group(3)),
114
+ message=commit_match.group(4),
115
+ hash=commit_hash,
116
+ )
117
+ )
118
+ break
119
+ else:
120
+ fallback_message = merge_summary or subject
121
+ if not fallback_message or fallback_message.startswith("Merge "):
122
+ continue
123
+ commits.append(
124
+ ParsedCommit(
125
+ type="other",
126
+ scope=None,
127
+ breaking=is_breaking,
128
+ message=fallback_message,
129
+ hash=commit_hash,
130
+ )
131
+ )
132
+
133
+ return commits
134
+
135
+
136
+ def generate_changelog(version: str, commits: list[ParsedCommit]) -> str:
137
+ """Generate markdown changelog from parsed commits."""
138
+ today = date.today().isoformat()
139
+ lines = [f"## [{version}] - {today}", ""]
140
+
141
+ # Collect breaking changes
142
+ breaking_commits = [c for c in commits if c.breaking]
143
+ if breaking_commits:
144
+ lines.append("### Breaking Changes")
145
+ for commit in breaking_commits:
146
+ if commit.scope:
147
+ lines.append(f"- **{commit.scope}**: {commit.message} ({commit.hash})")
148
+ else:
149
+ lines.append(f"- {commit.message} ({commit.hash})")
150
+ lines.append("")
151
+
152
+ # Group by type
153
+ by_type: dict[str, list[ParsedCommit]] = {}
154
+ for commit in commits:
155
+ by_type.setdefault(commit.type, []).append(commit)
156
+
157
+ for commit_type, label in TYPE_LABELS.items():
158
+ type_commits = by_type.get(commit_type, [])
159
+ if not type_commits:
160
+ continue
161
+ lines.append(f"### {label}")
162
+ for commit in type_commits:
163
+ if commit.scope:
164
+ lines.append(f"- **{commit.scope}**: {commit.message} ({commit.hash})")
165
+ else:
166
+ lines.append(f"- {commit.message} ({commit.hash})")
167
+ lines.append("")
168
+
169
+ return "\n".join(lines) + "\n"
170
+
171
+
172
+ def run_git_log(since: str | None, cwd: Path) -> str:
173
+ """Run git log command and return output."""
174
+ cmd = ["git", "log", "--first-parent", f"--pretty=format:{GIT_LOG_FORMAT}"]
175
+ if since:
176
+ cmd.append(f"{since}..HEAD")
177
+ else:
178
+ cmd.append("HEAD")
179
+ result = subprocess.run(cmd, cwd=cwd, capture_output=True, text=True)
180
+ return result.stdout
181
+
182
+
183
+ def main() -> None:
184
+ parser = argparse.ArgumentParser(description="Generate changelog from conventional commits")
185
+ parser.add_argument("--version", required=True, help="Version number (e.g., 0.6.0)")
186
+ parser.add_argument("--since", help="Starting tag (exclusive)")
187
+ parser.add_argument("--dry-run", action="store_true", help="Print to stdout instead of writing")
188
+ args = parser.parse_args()
189
+
190
+ log_output = run_git_log(args.since, ROOT)
191
+ commits = parse_commits(log_output)
192
+ changelog = generate_changelog(args.version, commits)
193
+
194
+ if args.dry_run:
195
+ print(changelog)
196
+ else:
197
+ output_path = ROOT / ".changelog.md"
198
+ output_path.write_text(changelog, encoding="utf-8")
199
+ print(f"Changelog written to {output_path}")
200
+
201
+
202
+ if __name__ == "__main__":
203
+ main()