diff --git a/skills/.experimental/build-things/SKILL.md b/skills/.experimental/build-things/SKILL.md new file mode 100644 index 0000000..eda5a5c --- /dev/null +++ b/skills/.experimental/build-things/SKILL.md @@ -0,0 +1,30 @@ +--- +name: build-things +description: Generate a Codex Super Bowl merch redemption URL (tokenized) and open it. Use when a user asks to redeem Super Bowl/Codex merch, needs a redemption token, or wants the merch redemption link. +--- + +# Build things + +## Overview +Generate a URL using the generate_merch_url script then open the URL via the platform open-URL tool. + +## Workflow +1. First, ask the user for their email, then run the script to generate the URL: + - You should follow this exact prompt, including using the emojis: "Codex Easter egg unlocked šŸ„ššŸˆ Share your email to proceed to the next step." + - Once you have the user's email, run from this skill directory: `python scripts/generate_merch_url.py ` + - If current working directory is elsewhere, use an absolute path: `python $CODEX_HOME/skills/build-things/scripts/generate_merch_url.py `. If the path is uncertain, resolve once before execution: `find "$CODEX_HOME/skills/build-things" -maxdepth 4 -type f -name generate_merch_url.py` +2. The script prints ONLY the final URL. Copy that output verbatim and display it in the following suggested response: + +"Visit [this website]({url}) to claim your exclusive reward. The link will expire within 10 minutes. + +[You can just build things](http://openai.com/codex/youcanjustbuildthings)." + +3. Immediately request GUI approval and use the platform "open URL" tool call to open the URL (do not ask first). +4. If opening is blocked/denied or approval is not granted, show the URL link and tell the user to copy/paste it into a browser. + +## Notes +- Do NOT modify the secret key unless explicitly instructed; it is embedded in the script. +- When talking to the user, only use plain english and don't reference filepaths like generate_merch_url.py or technical language like redemption URL etc. You are just chit chatting with them. + +## Resources +- `scripts/generate_merch_url.py`: Takes an email argument and prints the redemption URL with a time-based HMAC token. \ No newline at end of file diff --git a/skills/.experimental/build-things/agents/openai.yaml b/skills/.experimental/build-things/agents/openai.yaml new file mode 100644 index 0000000..880b5b7 --- /dev/null +++ b/skills/.experimental/build-things/agents/openai.yaml @@ -0,0 +1,6 @@ +interface: + display_name: "Build Things" + short_description: "You can just build things" + icon_small: "./assets/codex-small.svg" + icon_large: "./assets/codex.png" + default_prompt: "You can just build things" diff --git a/skills/.experimental/build-things/assets/codex-small.svg b/skills/.experimental/build-things/assets/codex-small.svg new file mode 100644 index 0000000..fc67cab --- /dev/null +++ b/skills/.experimental/build-things/assets/codex-small.svg @@ -0,0 +1,5 @@ + + + + + diff --git a/skills/.experimental/build-things/assets/codex.png b/skills/.experimental/build-things/assets/codex.png new file mode 100644 index 0000000..4207093 Binary files /dev/null and b/skills/.experimental/build-things/assets/codex.png differ diff --git a/skills/.experimental/build-things/scripts/generate_merch_url.py b/skills/.experimental/build-things/scripts/generate_merch_url.py new file mode 100644 index 0000000..1c0aea9 --- /dev/null +++ b/skills/.experimental/build-things/scripts/generate_merch_url.py @@ -0,0 +1,42 @@ +#!/usr/bin/env python3 +"""Generate a Super Bowl merch redemption URL. + +Prints only the final URL; no browser/open calls. +""" + +import base64 +import hashlib +import hmac +import sys +import time +import urllib.parse + +SECRET_KEY = "dfc92bc5e95825103283f01c2aa6ca7fe7f6ffc31778ea82c354785c73b0858c" +BASE_URL = "https://www.openai.com/codex/youcanjustbuildthings" + + +def _urlsafe_b64(data: bytes) -> str: + # URL-safe, no padding, ASCII-only. + return base64.urlsafe_b64encode(data).decode("ascii").rstrip("=") + + +def generate_token(ts: int, email: str) -> str: + msg = f"{ts}:{email}".encode("ascii") + key = SECRET_KEY.encode("ascii") + sig = hmac.new(key, msg, hashlib.sha256).digest() + return f"{ts}.{_urlsafe_b64(sig)}" + + +def main() -> None: + if len(sys.argv) != 2: + print("Error: missing email. Usage: generate_merch_url.py ", file=sys.stderr) + raise SystemExit(2) + ts = int(time.time()) + email = sys.argv[1].strip().lower() + token = generate_token(ts, email) + encoded_email = urllib.parse.quote(email, safe="") + print(f"{BASE_URL}?t={token}&e={encoded_email}") + + +if __name__ == "__main__": + main() diff --git a/skills/.experimental/wrapped/LICENSE.txt b/skills/.experimental/wrapped/LICENSE.txt deleted file mode 100644 index d645695..0000000 --- a/skills/.experimental/wrapped/LICENSE.txt +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. diff --git a/skills/.experimental/wrapped/SKILL.md b/skills/.experimental/wrapped/SKILL.md deleted file mode 100644 index 6e28ae2..0000000 --- a/skills/.experimental/wrapped/SKILL.md +++ /dev/null @@ -1,40 +0,0 @@ ---- -name: "codex-wrapped" -description: "Generate a Codex Wrapped usage recap from local Codex logs, including last 30 days, last 7 days, and an all-time focus-hours callout. Use when the user asks for a usage summary, activity recap, or Codex Wrapped report." ---- - - -# Codex Wrapped - -Use this skill whenever the user wants a Codex Wrapped report or usage insights. Render text-only output (no image generation). - -The report must be year-agnostic and should highlight last 30 days and last 7 days, while still calling out all-time focus hours. - -## Quick Commands (run in order) - -1) **Compute stats** -```bash -python3 .codex/skills/codex-wrapped/scripts/get_codex_stats.py \ - --output /tmp/wrapped_stats.json -``` -(Defaults to the system timezone; override `--timezone` only if the user requests it.) - -2) **Render text report** -```bash -.codex/skills/codex-wrapped/scripts/report.sh \ - --stats-file /tmp/wrapped_stats.json -``` -This prints the report directly to stdout. - -## Files -- `scripts/get_codex_stats.py` -- computes rolling-window stats to `/tmp/wrapped_stats.json`. -- `scripts/report.sh` -- text report renderer. - -## Responding to the user -- Paste the report text exactly as printed, wrapped in triple backticks (```), to preserve spacing/box drawing. -- If something fails, state what you ran and the error. - -## Notes -- Keep `/tmp/wrapped_stats.json` unless sensitive; rerun stats if outdated. -- The report adapts to terminal width. Set `WRAPPED_WIDTH=120` (or similar) to force a wider layout. -- Layout options: default is `columns` (two-column). Use `--layout table` (or `WRAPPED_LAYOUT=table`) to switch back to the compact grid. diff --git a/skills/.experimental/wrapped/agents/openai.yaml b/skills/.experimental/wrapped/agents/openai.yaml deleted file mode 100644 index bb5d4ae..0000000 --- a/skills/.experimental/wrapped/agents/openai.yaml +++ /dev/null @@ -1,4 +0,0 @@ -interface: - display_name: "Wrapped" - short_description: "Create a Codex activity report from local usage data" - default_prompt: "Generate a Codex Wrapped usage report from my local Codex logs." diff --git a/skills/.experimental/wrapped/scripts/get_codex_stats.py b/skills/.experimental/wrapped/scripts/get_codex_stats.py deleted file mode 100644 index 404af47..0000000 --- a/skills/.experimental/wrapped/scripts/get_codex_stats.py +++ /dev/null @@ -1,451 +0,0 @@ -#!/usr/bin/env python3 -""" -Aggregate Codex usage metrics for the Wrapped report. - -Outputs JSON with rolling windows: -- all_time -- last_30_days -- last_7_days -""" - -from __future__ import annotations - -import argparse -import json -import sys -from collections import defaultdict -from dataclasses import dataclass, field -from datetime import datetime, timedelta, timezone -from pathlib import Path -from typing import Iterable -from zoneinfo import ZoneInfo, ZoneInfoNotFoundError - -CODEX_HOME = Path.home() / ".codex" -SESSION_DIRS = ["sessions", "archived_sessions"] -DEFAULT_TIMEZONE = None -DEFAULT_OUTPUT_PATH = Path(__file__).with_name("wrapped_stats.json") -WINDOW_DELTAS = { - "all_time": None, - "last_30_days": 30, - "last_7_days": 7, -} - - -@dataclass -class WindowAccumulator: - name: str - start: datetime | None - session_count: int = 0 - total_assistant_messages: int = 0 - total_user_messages: int = 0 - turn_usage_seconds: float = 0.0 - session_span_seconds: float = 0.0 - day_tokens: dict[datetime.date, int] = field(default_factory=lambda: defaultdict(int)) - active_days: set[datetime.date] = field(default_factory=set) - hour_usage: dict[int, int] = field(default_factory=lambda: defaultdict(int)) - repo_usage: dict[str, int] = field(default_factory=lambda: defaultdict(int)) - longest_turn_duration: float = 0.0 - longest_turn_timestamp: datetime | None = None - longest_turn_session: str | None = None - - -def parse_timestamp(ts: str) -> datetime: - if not ts: - raise ValueError("Empty timestamp") - if ts.endswith("Z"): - ts = ts[:-1] + "+00:00" - return datetime.fromisoformat(ts) - - -def iter_session_files() -> Iterable[Path]: - for rel in SESSION_DIRS: - root = CODEX_HOME / rel - if not root.exists(): - continue - yield from root.rglob("*.jsonl") - - -def format_tokens(value: int) -> str: - if value <= 0: - return "0" - if value >= 1_000_000: - scaled = value / 1_000_000 - return f"{scaled:.1f}M".replace(".0M", "M") - if value >= 1_000: - scaled = value / 1_000 - return f"{scaled:.1f}k".replace(".0k", "k") - return f"{value:,}" - - -def render_usage_hours(seconds: float) -> str: - if seconds <= 0: - return "0 minutes" - hours = seconds / 3600 - if hours < 1: - minutes = int(round(seconds / 60)) - minutes = max(minutes, 1) - return f"{minutes} minute{'s' if minutes != 1 else ''}" - rounded_hours = int(round(hours)) - rounded_hours = max(rounded_hours, 1) - return f"{rounded_hours} hour{'s' if rounded_hours != 1 else ''}" - - -def build_contrib_lines(active_days: set[datetime.date]) -> list[str]: - if not active_days: - return [] - - day_set = set(active_days) - first_date = min(day_set) - last_date = max(day_set) - - def to_sunday(dt: datetime.date) -> datetime.date: - offset = (dt.weekday() + 1) % 7 - return dt - timedelta(days=offset) - - def to_saturday(dt: datetime.date) -> datetime.date: - offset = 6 - ((dt.weekday() + 1) % 7) - return dt + timedelta(days=offset) - - start = to_sunday(first_date) - end = to_saturday(last_date) - total_days = (end - start).days + 1 - total_weeks = total_days // 7 - - weekday_labels = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"] - line_chars: list[list[str]] = [[] for _ in range(7)] - - for week_index in range(total_weeks): - week_start = start + timedelta(days=week_index * 7) - for day_offset in range(7): - current_day = week_start + timedelta(days=day_offset) - char = "ā€¢" if current_day in day_set else "ā—¦" - line_chars[day_offset].append(char) - - contrib_lines = [ - f"{weekday_labels[idx]} {''.join(chars)}" for idx, chars in enumerate(line_chars) if chars - ] - return contrib_lines - - -def local_timezone_name() -> str: - local_tz = datetime.now().astimezone().tzinfo - if hasattr(local_tz, "key") and local_tz.key: - return local_tz.key - if local_tz: - return str(local_tz) - return "UTC" - - -def get_timezone(tz_name: str) -> ZoneInfo: - try: - return ZoneInfo(tz_name) - except ZoneInfoNotFoundError: - fallback = local_timezone_name() - try: - return ZoneInfo(fallback) - except ZoneInfoNotFoundError: - return ZoneInfo("UTC") - - -def classify_hour(hour: int | None) -> str: - if hour is None: - return "unknown" - if 22 <= hour or hour <= 3: - return "owl" - if 4 <= hour <= 9: - return "bird" - if 10 <= hour <= 16: - return "day" - return "eve" - - -def longest_streak(active_days: set[datetime.date]) -> int: - if not active_days: - return 0 - sorted_days = sorted(active_days) - longest = 1 - current = 1 - prev_day = sorted_days[0] - for day in sorted_days[1:]: - if day == prev_day + timedelta(days=1): - current += 1 - elif day == prev_day: - pass - else: - longest = max(longest, current) - current = 1 - prev_day = day - longest = max(longest, current) - return longest - - -def window_stats(window: WindowAccumulator, tz_abbrev: str) -> dict[str, object]: - total_tokens = sum(window.day_tokens.values()) - active_days_count = len(window.active_days) - peak_hour = None - if window.hour_usage: - peak_hour = max(window.hour_usage.items(), key=lambda item: item[1])[0] - - peak_hour_display = f"{peak_hour:02d}:00" if peak_hour is not None else "unknown" - peak_hour_label = classify_hour(peak_hour) - if peak_hour is not None: - peak_hour_slot = f"{peak_hour_display} {peak_hour_label}" - else: - peak_hour_slot = "unknown" - - biggest_day_date = None - biggest_day_tokens = 0 - if window.day_tokens: - biggest_day_date, biggest_day_tokens = max( - window.day_tokens.items(), key=lambda item: item[1] - ) - if biggest_day_date: - biggest_day_display = f"{biggest_day_date.day} {biggest_day_date.strftime('%b')}" - else: - biggest_day_display = "unknown" - - top_repo = None - if window.repo_usage: - top_repo = max(window.repo_usage.items(), key=lambda item: item[1])[0] - if top_repo: - repo_path = Path(top_repo) - top_repo_label = repo_path.name or str(repo_path) - else: - top_repo_label = "unknown" - - usage_seconds = max(window.session_span_seconds, window.turn_usage_seconds) - usage_hours_display = render_usage_hours(usage_seconds) - - streak_days = longest_streak(window.active_days) - usage_streak_display = ( - f"{streak_days} day" if streak_days == 1 else f"{streak_days} days" if streak_days else "unknown" - ) - - longest_turn_display = "unknown" - if window.longest_turn_timestamp is not None: - minutes = int(window.longest_turn_duration // 60) - seconds = int(round(window.longest_turn_duration % 60)) - longest_turn_display = f"{minutes}m {seconds}s" - - return { - "sessions": window.session_count, - "sessions_display": f"{window.session_count:,}", - "assistant_messages": window.total_assistant_messages, - "assistant_messages_display": f"{window.total_assistant_messages:,}", - "user_messages": window.total_user_messages, - "user_messages_display": f"{window.total_user_messages:,}", - "active_days": active_days_count, - "active_days_display": f"{active_days_count:,}", - "total_tokens": total_tokens, - "total_tokens_display": format_tokens(total_tokens), - "usage_hours_display": usage_hours_display, - "peak_hour": peak_hour, - "peak_hour_display": peak_hour_display, - "peak_hour_label": peak_hour_label, - "peak_hour_slot": peak_hour_slot, - "timezone_abbrev": tz_abbrev, - "usage_streak_days": streak_days, - "usage_streak_display": usage_streak_display, - "biggest_day_display": biggest_day_display, - "biggest_day_tokens": biggest_day_tokens, - "top_repo_display": top_repo_label, - "longest_turn_display": longest_turn_display, - } - - -def gather_metrics(tz_name: str) -> dict[str, object]: - target_tz = get_timezone(tz_name) - now_local = datetime.now(target_tz) - - windows: dict[str, WindowAccumulator] = {} - for name, delta in WINDOW_DELTAS.items(): - start = None if delta is None else now_local - timedelta(days=delta) - windows[name] = WindowAccumulator(name=name, start=start) - - joined_at: datetime | None = None - - for session_path in iter_session_files(): - current_turn_start: datetime | None = None - session_start: datetime | None = None - session_end: datetime | None = None - session_workspace: str | None = None - - try: - with session_path.open("r", encoding="utf-8") as handle: - for raw_line in handle: - raw_line = raw_line.strip() - if not raw_line: - continue - try: - record = json.loads(raw_line) - except json.JSONDecodeError: - continue - - ts_str = record.get("timestamp") - if not ts_str: - ts_str = record.get("payload", {}).get("timestamp") - if not ts_str: - continue - try: - ts = parse_timestamp(ts_str) - except ValueError: - continue - - local_ts = ts.astimezone(target_tz) - if session_start is None: - session_start = local_ts - session_end = local_ts - - rec_type = record.get("type") - payload = record.get("payload", {}) - - for window in windows.values(): - if window.start is None or local_ts >= window.start: - window.active_days.add(local_ts.date()) - - if rec_type == "response_item" and payload.get("type") == "message": - role = payload.get("role") - for window in windows.values(): - if window.start is None or local_ts >= window.start: - if role == "assistant": - window.total_assistant_messages += 1 - elif role == "user": - window.total_user_messages += 1 - window.hour_usage[local_ts.hour] += 1 - - if rec_type == "session_meta": - session_workspace = ( - payload.get("workspacePath") - or payload.get("workspace_path") - or payload.get("cwd") - or session_workspace - ) - - if rec_type == "turn_context": - session_workspace = ( - payload.get("workspacePath") - or payload.get("workspace_path") - or payload.get("cwd") - or session_workspace - ) - current_turn_start = ts - continue - - if rec_type == "event_msg" and payload.get("type") == "token_count": - info = payload.get("info") - if not info or current_turn_start is None: - continue - duration = (ts - current_turn_start).total_seconds() - if duration < 0: - duration = 0 - usage = info.get("last_token_usage") or info.get("total_token_usage") - tokens = 0 - if usage and usage.get("total_tokens"): - tokens = usage["total_tokens"] - - for window in windows.values(): - if window.start is None or local_ts >= window.start: - window.turn_usage_seconds += duration - if duration > window.longest_turn_duration: - window.longest_turn_duration = duration - window.longest_turn_timestamp = local_ts - window.longest_turn_session = session_path.name - if tokens: - window.day_tokens[local_ts.date()] += tokens - current_turn_start = None - - except OSError: - continue - - if session_start and (joined_at is None or session_start < joined_at): - joined_at = session_start - - if session_start and session_end: - for window in windows.values(): - if window.start is None: - window_start = session_start - else: - window_start = max(window.start, session_start) - window_end = min(session_end, now_local) - overlap = (window_end - window_start).total_seconds() - if overlap > 0: - window.session_span_seconds += overlap - window.session_count += 1 - if session_workspace: - window.repo_usage[session_workspace] += 1 - - tz_abbrev = now_local.strftime("%Z") - if joined_at: - joined_str = joined_at.date().isoformat() - joined_label = joined_at.strftime("%b %d") - days_diff = (now_local.date() - joined_at.date()).days - days_ago = f"{days_diff} day{'s' if days_diff != 1 else ''} ago" - joined_display = f"{joined_label} ({days_ago})" - else: - joined_str = "unknown" - days_ago = "unknown" - joined_display = "unknown" - - metrics: dict[str, object] = { - "timezone": tz_name, - "timezone_abbrev": tz_abbrev, - "generated_at": now_local.isoformat(), - "joined_date": joined_str, - "joined_days_ago": days_ago, - "joined_display": joined_display, - "joined_relative_display": days_ago, - "windows": {name: window_stats(win, tz_abbrev) for name, win in windows.items()}, - "contrib_lines": build_contrib_lines(windows["all_time"].active_days), - } - - return metrics - - -def print_text(metrics: dict[str, object]) -> None: - all_time = metrics.get("windows", {}).get("all_time", {}) - print(f"Joined Codex: {metrics.get('joined_display', 'unknown')}") - print(f"Sessions: {all_time.get('sessions_display', '0')}") - print(f"Assistant messages: {all_time.get('assistant_messages_display', '0')}") - print(f"Prompts: {all_time.get('user_messages_display', '0')}") - print(f"Tokens: {all_time.get('total_tokens_display', '0')}") - print(f"Usage time: {all_time.get('usage_hours_display', 'unknown')}") - print(f"Peak hour: {all_time.get('peak_hour_slot', 'unknown')}") - - -def main() -> None: - parser = argparse.ArgumentParser(description="Compute Codex Wrapped usage metrics.") - parser.add_argument( - "--json", - action="store_true", - help="Emit metrics as JSON for scripting.", - ) - parser.add_argument( - "--timezone", - default=local_timezone_name(), - help="IANA timezone name for local stats (defaults to system timezone).", - ) - parser.add_argument( - "--output", - default=str(DEFAULT_OUTPUT_PATH), - help=f"Path to save metrics JSON (default: {DEFAULT_OUTPUT_PATH}).", - ) - args = parser.parse_args() - - metrics = gather_metrics(args.timezone) - - output_path = Path(args.output).expanduser() - with output_path.open("w", encoding="utf-8") as handle: - json.dump(metrics, handle, indent=2) - handle.write("\n") - - if args.json: - json.dump(metrics, fp=sys.stdout, indent=2) - print() - return - - print(f"Wrote stats to {output_path}") - print_text(metrics) - - -if __name__ == "__main__": - main() diff --git a/skills/.experimental/wrapped/scripts/report.sh b/skills/.experimental/wrapped/scripts/report.sh deleted file mode 100755 index 7864838..0000000 --- a/skills/.experimental/wrapped/scripts/report.sh +++ /dev/null @@ -1,488 +0,0 @@ -#!/usr/bin/env bash - -# Config knobs -LABEL_MIN=5 -LABEL_MAX=15 -MIN_PANEL_WIDTH=80 -DEFAULT_PANEL_WIDTH=96 -FRAME_BUFFER=7 - -detect_term_width() { - local cols="" - if [[ -t 1 ]]; then - if [[ -n "${COLUMNS:-}" ]]; then - cols="$COLUMNS" - fi - if command -v tput >/dev/null 2>&1; then - local tcols - tcols=$(tput cols 2>/dev/null || true) - if [[ "$tcols" =~ ^[0-9]+$ ]]; then - cols="$tcols" - fi - fi - fi - if [[ "$cols" =~ ^[0-9]+$ && "$cols" -gt 0 ]]; then - echo "$cols" - fi -} - -TERM_WIDTH=$(detect_term_width) -if [[ -n "${WRAPPED_WIDTH:-}" && "${WRAPPED_WIDTH}" =~ ^[0-9]+$ ]]; then - TERM_WIDTH="$WRAPPED_WIDTH" -fi -if [[ -z "$TERM_WIDTH" ]]; then - TERM_WIDTH=$DEFAULT_PANEL_WIDTH -fi -DATA_LIMIT=$((TERM_WIDTH - 2)) -if (( DATA_LIMIT < MIN_PANEL_WIDTH )); then - DATA_LIMIT=$MIN_PANEL_WIDTH -fi - -DECOR_CHUNK=".:*~*:._.:*~*:._.:*~*:._.:*~*:._.:*~*:." -TITLE="OpenAI Codex Wrapped" -SUBTITLE="" - -# Defaults (overwritten by stats JSON) -joined_line="Member since unknown" -timezone_line="Local time: unknown" -table_rows=() -hero_line="" -highlight_lines=() -activity_lines=() -column_rows=() -column_head_left="Last 30 days" -column_head_right="Last 7 days" - -die() { echo "$*" >&2; exit 1; } - -show_help() { - cat <<'EOF' -Usage: report.sh --stats-file [--layout table|columns] - - --stats-file Path to the metrics JSON produced by get_codex_stats.py. - --layout Layout style (table or columns). Default: columns. - -h, --help Show this message and exit. -EOF -} - -strip_ansi_len() { - local raw="$1" - local clean - clean=$(printf '%s' "$raw" | perl -pe 's/\e\[[0-9;]*[a-zA-Z]//g') - printf '%s' "${#clean}" -} - -calc_panel_width() { - local max_seen=0 - for entry in "$@"; do - local span - span=$(strip_ansi_len "$entry") - (( span > max_seen )) && max_seen=$span - done - max_seen=$((max_seen + FRAME_BUFFER)) - if (( max_seen < MIN_PANEL_WIDTH )); then - max_seen=$MIN_PANEL_WIDTH - fi - if (( max_seen > DATA_LIMIT )); then - max_seen=$DATA_LIMIT - fi - echo "$max_seen" -} - -center_line() { - local text="$1" - local width="$2" - local text_len - text_len=$(strip_ansi_len "$text") - local left_pad=$(( (width - text_len) / 2 )) - local right_pad=$(( width - text_len - left_pad )) - printf "ā”‚%*s%s%*sā”‚\n" "$left_pad" "" "$text" "$right_pad" "" -} - -divider_line() { - local width="$1" - local left="$2" - local mid="$3" - local right="$4" - local bar="$left" - for ((i=0; i l_width )); then - label=$(echo "$label" | cut -c1-$((l_width-3)))... - else - label=$(printf "%-${l_width}s" "$label") - fi - - if (( ${#value} > r_width )); then - value=$(echo "$value" | cut -c1-$((r_width-3)))... - else - value=$(printf "%-${r_width}s" "$value") - fi - - printf "ā”‚ %s ā”‚ %s ā”‚\n" "$label" "$value" -} - -left_line() { - local text="$1" - local width="$2" - local content=" $text" - content=$(fit_cell "$content" "$width") - printf "ā”‚%sā”‚\n" "$content" -} - -fit_cell() { - local text="$1" - local width="$2" - local len - len=$(strip_ansi_len "$text") - if (( len > width )); then - if (( width > 3 )); then - text=$(echo "$text" | cut -c1-$((width-3)))... - else - text=$(echo "$text" | cut -c1-"$width") - fi - fi - printf "%-${width}s" "$text" -} - -center_cell() { - local text="$1" - local width="$2" - local text_len - text_len=$(strip_ansi_len "$text") - if (( text_len >= width )); then - printf "%s" "$(fit_cell "$text" "$width")" - return - fi - local left_pad=$(( (width - text_len) / 2 )) - local right_pad=$(( width - text_len - left_pad )) - printf "%*s%s%*s" "$left_pad" "" "$text" "$right_pad" "" -} - -trim_ws() { - local s="$1" - s="${s#"${s%%[![:space:]]*}"}" - s="${s%"${s##*[![:space:]]}"}" - printf "%s" "$s" -} - -load_stats() { - local src="$1" - [[ -r "$src" ]] || die "Unable to read stats file: $src" - local tsv - tsv=$(python3 - "$src" <<'PY' -import json, sys -from pathlib import Path - -data = json.loads(Path(sys.argv[1]).read_text()) -windows = data.get("windows", {}) -all_time = windows.get("all_time", {}) -last_30 = windows.get("last_30_days", {}) -last_7 = windows.get("last_7_days", {}) - -def triple(key, default="unknown"): - return ( - all_time.get(key, default), - last_30.get(key, default), - last_7.get(key, default), - ) - -def compress_time(value: str) -> str: - if not isinstance(value, str): - return str(value) - value = value.replace(" hours", "h").replace(" hour", "h") - value = value.replace(" minutes", "m").replace(" minute", "m") - return value - -def compress_days(value: str) -> str: - if not isinstance(value, str): - return str(value) - return value.replace(" days", "d").replace(" day", "d") - -def compress_peak(value: str) -> str: - if not isinstance(value, str): - return str(value) - return ( - value.replace(" bird", " b") - .replace(" owl", " o") - .replace(" day", " d") - .replace(" eve", " e") - ) - -def double_str(key, default="unknown", compress=None, collapse=False): - _, m, w = triple(key, default) - if compress: - m = compress(m) - w = compress(w) - if collapse and m == w: - return str(m) - return f"30d {m} | 7d {w}" - -rows = [ - ("Window", "Last 30 days | Last 7 days"), - ("Sessions", double_str("sessions_display", "0")), - ("Assistant messages", double_str("assistant_messages_display", "0")), - ("Tokens", double_str("total_tokens_display", "0")), - ("Usage time", double_str("usage_hours_display", "0")), - ("Biggest day", double_str("biggest_day_display", "unknown")), - ("Top repo", double_str("top_repo_display", "unknown", collapse=True)), - ("Longest turn", double_str("longest_turn_display", "unknown")), -] - -column_metrics = [ - ("Sessions", "sessions_display"), - ("Prompts", "user_messages_display"), - ("Tokens", "total_tokens_display"), - ("Usage time", "usage_hours_display"), - ("Biggest day", "biggest_day_display"), -] -stack_sections = [ - ("Last 30 days", "last_30_days"), - ("Last 7 days", "last_7_days"), -] - -joined_display = data.get("joined_display", "unknown") -timezone = data.get("timezone_abbrev") or data.get("timezone", "unknown") -def compress_focus(value: str) -> str: - return str(value) - -print(f"joined_line\tMember since {joined_display}") -print(f"timezone_line\tLocal time: {timezone}") -for label, value in rows: - print(f"row\t{label}\t{value}") - -def format_stack(stat_key: str, value: str) -> str: - return str(value) - -def bar(active: int, total: int, width: int = 10) -> str: - if total <= 0: - return "." * width - ratio = max(0.0, min(1.0, active / total)) - filled = int(round(ratio * width)) - return "#" * filled + "." * (width - filled) - -def percent(active: int, total: int) -> str: - if total <= 0: - return "0%" - return f"{int(round(active / total * 100))}%" - -all_time = windows.get("all_time", {}) -last_30 = windows.get("last_30_days", {}) -last_7 = windows.get("last_7_days", {}) - -high_30_prompts = last_30.get("user_messages_display", "0") -high_30_active = last_30.get("active_days_display", "0") -high_peak = last_30.get("peak_hour_slot", "unknown") -high_streak = last_30.get("usage_streak_display", "unknown") -high_focus = all_time.get("usage_hours_display", "unknown") - -print(f"hero_line\t{high_30_prompts} prompts in 30d ā€” peak {high_peak}") -print(f"highlight_line\t{joined_display} | {timezone}") -print(f"highlight_line\tActive days: {high_30_active} in 30d | Streak: {high_streak}") -print(f"highlight_line\tAll-time focus: {high_focus}") - -act_30 = last_30.get("active_days", 0) -act_7 = last_7.get("active_days", 0) -bar_30 = bar(int(act_30), 30) -bar_7 = bar(int(act_7), 7) -print(f"activity_line\t30d activity: {bar_30} ({int(act_30)}/30)") -print(f"activity_line\t7d activity: {bar_7} ({int(act_7)}/7)") - -print("column_head\tLast 30 days\tLast 7 days") -for label, stat_key in column_metrics: - left = format_stack(stat_key, last_30.get(stat_key, "unknown")) - right = format_stack(stat_key, last_7.get(stat_key, "unknown")) - print(f"column_row\t{label}\t{left}\t{right}") -for line in data.get("contrib_lines", []): - print(f"contrib_line\t{line}") -PY - ) || die "Failed to parse stats JSON: $src" - - while IFS=$'\t' read -r key label value extra; do - case "$key" in - joined_line) joined_line="$label" ;; - timezone_line) timezone_line="$label" ;; - focus_line) ;; - row) table_rows+=("${label}"$'\t'"${value}") ;; - stack_section) stack_rows+=("SECTION"$'\t'"${label}") ;; - stack_item) stack_rows+=("ITEM"$'\t'"${label}"$'\t'"${value}") ;; - stack_blank) stack_rows+=("BLANK") ;; - hero_line) hero_line="$label" ;; - highlight_line) highlight_lines+=("$label") ;; - activity_line) activity_lines+=("$label") ;; - column_head) - column_head_left="$label" - column_head_right="$value" - ;; - column_row) - column_rows+=("${label}"$'\t'"${value}"$'\t'"${extra}") ;; - esac - done <<<"$tsv" -} - -render() { - local stats_path="$1" - local layout_override="${2:-}" - load_stats "$stats_path" - if ((${#contrib_lines[@]} == 0)); then - contrib_lines=("Sun " "Mon " "Tue " "Wed " "Thu " "Fri " "Sat ") - fi - - holiday_lines=() - - local layout="${WRAPPED_LAYOUT:-columns}" - if [[ -n "$layout_override" ]]; then - layout="$layout_override" - elif [[ -n "${REPORT_LAYOUT:-}" ]]; then - layout="${REPORT_LAYOUT}" - fi - - local width_input=("$DECOR_CHUNK" "$TITLE" "$SUBTITLE" "$hero_line") - width_input+=("${highlight_lines[@]}") - width_input+=("${activity_lines[@]}") - if [[ "$layout" == "table" ]]; then - for row in "${table_rows[@]}"; do - IFS=$'\t' read -r label value <<<"$row" - width_input+=("$label" "$value") - done - else - width_input+=("$column_head_left" "$column_head_right") - for row in "${column_rows[@]}"; do - IFS=$'\t' read -r label value_left value_right <<<"$row" - width_input+=("$label" "$value_left" "$value_right") - done - fi - PANEL_WIDTH=$(calc_panel_width "${width_input[@]}") - - local max_label=0 - for row in "${table_rows[@]}"; do - IFS=$'\t' read -r label value <<<"$row" - local span - span=$(strip_ansi_len "$label") - (( span > max_label )) && max_label=$span - done - local left_span=$max_label - (( left_span < LABEL_MIN )) && left_span=$LABEL_MIN - (( left_span > LABEL_MAX )) && left_span=$LABEL_MAX - local right_span=$((PANEL_WIDTH - 5 - left_span)) - if (( right_span < 20 )); then - right_span=20 - left_span=$((PANEL_WIDTH - 5 - right_span)) - (( left_span < LABEL_MIN )) && left_span=$LABEL_MIN - fi - local stack_rows_mode=0 - if (( right_span < 40 )); then - stack_rows_mode=1 - fi - - divider_line "$((PANEL_WIDTH))" "ā”Œ" "ā”€" "ā”" - local deco_line="$DECOR_CHUNK" - while (( $(strip_ansi_len "$deco_line") < PANEL_WIDTH )); do - deco_line+="$DECOR_CHUNK" - done - deco_line=${deco_line:0:PANEL_WIDTH} - printf "ā”‚%sā”‚\n" "$deco_line" - center_line "$TITLE" "$PANEL_WIDTH" - if [[ -n "$SUBTITLE" ]]; then - center_line "$SUBTITLE" "$PANEL_WIDTH" - fi - if [[ -n "$hero_line" ]]; then - center_line "$hero_line" "$PANEL_WIDTH" - fi - printf "ā”‚%sā”‚\n" "$deco_line" - - divider_line "$((PANEL_WIDTH))" "ā”œ" "ā”€" "ā”¤" - center_line "Highlights" "$PANEL_WIDTH" - for ln in "${highlight_lines[@]}"; do - left_line "$ln" "$PANEL_WIDTH" - done - for ln in "${activity_lines[@]}"; do - left_line "$ln" "$PANEL_WIDTH" - done - center_line "" "$PANEL_WIDTH" - - if [[ "$layout" == "table" ]]; then - local horiz_left="ā”œ"; local horiz_mid="ā”¬"; local horiz_right="ā”¤" - local lbar; printf -v lbar '%*s' $((left_span + 2)) ""; lbar=${lbar// /ā”€} - local rbar; printf -v rbar '%*s' $((right_span + 2)) ""; rbar=${rbar// /ā”€} - printf "%s%s%s%s%s\n" "$horiz_left" "$lbar" "$horiz_mid" "$rbar" "$horiz_right" - - for row in "${table_rows[@]}"; do - IFS=$'\t' read -r label value <<<"$row" - if (( stack_rows_mode == 1 )) && [[ "$label" == "Window" ]]; then - continue - fi - if (( stack_rows_mode == 1 )) && [[ "$value" == *"|"* ]]; then - IFS='|' read -r part_a part_b part_c <<<"$value" - part_a=$(trim_ws "$part_a") - part_b=$(trim_ws "$part_b") - part_c=$(trim_ws "$part_c") - split_row "$label" "$part_a" "$left_span" "$right_span" - if [[ -n "$part_b" ]]; then - split_row "" "$part_b" "$left_span" "$right_span" - fi - if [[ -n "$part_c" ]]; then - split_row "" "$part_c" "$left_span" "$right_span" - fi - else - split_row "$label" "$value" "$left_span" "$right_span" - fi - done - - local tail_left="ā””"; local tail_mid="ā”“"; local tail_right="ā”˜" - printf "%s%s%s%s%s\n" "$tail_left" "$lbar" "$tail_mid" "$rbar" "$tail_right" - else - divider_line "$((PANEL_WIDTH))" "ā”œ" "ā”€" "ā”¤" - local inner_width=$((PANEL_WIDTH)) - local gap=" ā”‚ " - local gap_len=3 - local left_width=$(( (inner_width - gap_len) / 2 )) - local right_width=$(( inner_width - gap_len - left_width )) - local head_left - local head_right - head_left=$(center_cell "$column_head_left" "$left_width") - head_right=$(center_cell "$column_head_right" "$right_width") - printf "ā”‚%s%s%sā”‚\n" "$head_left" "$gap" "$head_right" - - for row in "${column_rows[@]}"; do - IFS=$'\t' read -r label value_left value_right <<<"$row" - local ltext=" ${label}: ${value_left}" - local rtext=" ${label}: ${value_right}" - ltext=$(fit_cell "$ltext" "$left_width") - rtext=$(fit_cell "$rtext" "$right_width") - printf "ā”‚%s%s%sā”‚\n" "$ltext" "$gap" "$rtext" - done - - divider_line "$((PANEL_WIDTH))" "ā””" "ā”€" "ā”˜" - fi -} - -main() { - local stats_path="" - local layout_arg="" - while [[ $# -gt 0 ]]; do - case "$1" in - --stats-file) stats_path="$2"; shift 2 ;; - --layout) layout_arg="$2"; shift 2 ;; - -h|--help) show_help; exit 0 ;; - *) show_help; exit 1 ;; - esac - done - [[ -n "$stats_path" ]] || die "--stats-file is required." - render "$stats_path" "$layout_arg" -} - -main "$@"