@4pm/cli 1.18.0 → 1.19.2

package/dist/project-sample/.claude/hooks/autonomous-history.py

@@ -1,193 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Manage .claude/.autonomous.histories.json — the SINGLE file combining the autonomous workflow's state + history.
-
-Structure:
-{
-  "cron_applied": "*/10 * * * *",     # the cron schedule applied last time (to detect a schedule change)
-  "consecutive_fails": 0,              # number of CONSECUTIVE failed command runs (reset on success)
-  "ticks": {"day": "YYYY-MM-DD", "count": N},  # count of ticks that actually invoked Claude today
-  "records": [ {...}, ... ]            # cron run history, NEWEST LAST, at most 50 records
-}
-
-Each record:
-{
-  "ts": "YYYY-MM-DD HH:MM:SS",
-  "status": "success" | "failure" | "skip",
-  "rc": <int|null>,                    # the command's exit code (null if it didn't run)
-  "gate": "<token-gate string>",
-  "note": "<short note>",
-  "command": "/auto-cycle",
-  "tick": "YYYY-MM-DD #N",             # day + tick number within the day
-  "config": { cron_schedule, model, max_session_pct, max_weekly_pct, quiet_hours,
-              max_ticks_per_day, stop_on_consecutive_failures, paused }
-}
-
-Usage (the file path is the first arg):
-  history.py <file> migrate <cron-applied> <fails> <ticks>   # one-time load from 3 old files (paths)
-  history.py <file> get-cron
-  history.py <file> set-cron <schedule>
-  history.py <file> get-fails
-  history.py <file> set-fails <n>
-  history.py <file> get-ticks <today>         # print the count for 'today' (0 if a different day/missing)
-  history.py <file> set-ticks <day> <count>
-  history.py <file> record <ts> <status> <rc> <gate> <note>   # config is read from the CFG_* env vars
-
-Philosophy: NEVER break on a missing/corrupt file — always initialize the default skeleton.
-"""
-import json
-import os
-import sys
-
-MAX_RECORDS = 50
-
-SKELETON = {
-    "cron_applied": "",
-    "consecutive_fails": 0,
-    "ticks": {"day": "", "count": 0},
-    "records": [],
-}
-
-
-def load(path):
-    try:
-        with open(path, encoding="utf-8") as f:
-            d = json.load(f)
-        if not isinstance(d, dict):
-            raise ValueError("not an object")
-    except Exception:
-        d = {}
-    out = dict(SKELETON)
-    out.update({k: d[k] for k in SKELETON if k in d})
-    if not isinstance(out.get("ticks"), dict):
-        out["ticks"] = dict(SKELETON["ticks"])
-    if not isinstance(out.get("records"), list):
-        out["records"] = []
-    return out
-
-
-def save(path, d):
-    tmp = path + ".tmp"
-    with open(tmp, "w", encoding="utf-8") as f:
-        json.dump(d, f, ensure_ascii=False, indent=2)
-        f.write("\n")
-    os.replace(tmp, path)
-
-
-def cfg_from_env():
-    def g(k, default=""):
-        return os.environ.get(k, default)
-    return {
-        "cron_schedule": g("CFG_CRON_SCHEDULE"),
-        "model": g("CFG_MODEL"),
-        "max_session_pct": g("CFG_MAX_SESSION_PCT"),
-        "max_weekly_pct": g("CFG_MAX_WEEKLY_PCT"),
-        "quiet_hours": g("CFG_QUIET_HOURS"),
-        "max_ticks_per_day": g("CFG_MAX_TICKS_PER_DAY"),
-        "stop_on_consecutive_failures": g("CFG_STOP_ON_CONSEC_FAILURES"),
-        "paused": g("CFG_PAUSED"),
-    }
-
-
-def main():
-    if len(sys.argv) < 3:
-        sys.stderr.write("missing args: <file> <op> [...]\n")
-        return 2
-    path = sys.argv[1]
-    op = sys.argv[2]
-    args = sys.argv[3:]
-    d = load(path)
-
-    if op == "get-cron":
-        sys.stdout.write(str(d.get("cron_applied", "")))
-        return 0
-
-    if op == "set-cron":
-        d["cron_applied"] = args[0] if args else ""
-        save(path, d)
-        return 0
-
-    if op == "get-fails":
-        sys.stdout.write(str(int(d.get("consecutive_fails", 0) or 0)))
-        return 0
-
-    if op == "set-fails":
-        d["consecutive_fails"] = int(args[0]) if args else 0
-        save(path, d)
-        return 0
-
-    if op == "get-ticks":
-        today = args[0] if args else ""
-        t = d.get("ticks", {})
-        sys.stdout.write(str(int(t.get("count", 0) or 0) if t.get("day") == today else 0))
-        return 0
-
-    if op == "set-ticks":
-        day = args[0] if len(args) > 0 else ""
-        count = int(args[1]) if len(args) > 1 else 0
-        d["ticks"] = {"day": day, "count": count}
-        save(path, d)
-        return 0
-
-    if op == "record":
-        ts = args[0] if len(args) > 0 else ""
-        status = args[1] if len(args) > 1 else ""
-        rc_raw = args[2] if len(args) > 2 else ""
-        gate = args[3] if len(args) > 3 else ""
-        note = args[4] if len(args) > 4 else ""
-        try:
-            rc = int(rc_raw)
-        except (ValueError, TypeError):
-            rc = None
-        t = d.get("ticks", {})
-        rec = {
-            "ts": ts,
-            "status": status,
-            "rc": rc,
-            "gate": gate,
-            "note": note,
-            "command": os.environ.get("CFG_COMMAND", ""),
-            "tick": "%s #%s" % (t.get("day", ""), t.get("count", 0)),
-            "config": cfg_from_env(),
-        }
-        d["records"].append(rec)
-        if len(d["records"]) > MAX_RECORDS:
-            d["records"] = d["records"][-MAX_RECORDS:]
-        save(path, d)
-        return 0
-
-    if op == "migrate":
-        # Only load when histories.json has no real data yet (don't overwrite live data).
-        cron_p = args[0] if len(args) > 0 else ""
-        fails_p = args[1] if len(args) > 1 else ""
-        ticks_p = args[2] if len(args) > 2 else ""
-
-        def read_txt(p):
-            try:
-                with open(p, encoding="utf-8") as f:
-                    return f.read().strip()
-            except Exception:
-                return ""
-
-        if cron_p and not d.get("cron_applied"):
-            v = read_txt(cron_p)
-            if v:
-                d["cron_applied"] = v
-        if fails_p and not d.get("consecutive_fails"):
-            v = read_txt(fails_p)
-            if v.isdigit():
-                d["consecutive_fails"] = int(v)
-        if ticks_p and not d.get("ticks", {}).get("day"):
-            parts = read_txt(ticks_p).split()
-            if len(parts) == 2 and parts[1].isdigit():
-                d["ticks"] = {"day": parts[0], "count": int(parts[1])}
-        save(path, d)
-        return 0
-
-    sys.stderr.write("invalid op: %s\n" % op)
-    return 2
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/dist/project-sample/.claude/skills/check-usage/SKILL.md

@@ -1,40 +0,0 @@
----
-name: check-usage
-description: Show Claude Code plan usage limits — current session % and reset time, weekly % and reset time (same data as the built-in /usage screen). Use when the user asks "how much usage left", "khi nao reset", "check usage/quota/limit", or invokes /check-usage.
----
-
-# check-usage — Claude Code plan usage limits
-
-Fetches the same data the built-in `/usage` screen shows (session + weekly utilization and
-reset times), by calling the Anthropic OAuth usage endpoint with the local credentials.
-
-## How to run
-
-Run the bundled script with the Bash tool. It prints a compact bullet list to the console;
-relay that output to the user.
-
-```bash
-python .claude/skills/check-usage/check_usage.py
-```
-
-On Windows if `python` is missing, try `py .claude/skills/check-usage/check_usage.py`.
-
-Add `--json` to dump the raw API response instead of the formatted view:
-
-```bash
-python .claude/skills/check-usage/check_usage.py --json
-```
-
-## Output file
-Every run (the formatted view, not `--json`) rewrites `./output/last-usage-check.json` next to
-the script: it deletes the previous file then creates a fresh one with this run's result. The
-record has machine-readable fields the autonomous workflow reads back:
-`session_pct`, `weekly_pct`, `session_resets_at`, `weekly_resets_at`, `checked_at`, `plan`,
-plus the human `summary` and the full `raw` API payload.
-
-## Notes
-- Reads the OAuth access token from `~/.claude/.credentials.json` (Claude Code keeps it refreshed).
-- If the call returns HTTP 401, the token expired — tell the user to run the real `/usage` once
-  inside Claude Code (or re-login) to refresh credentials, then retry.
-- Reset times are printed in the machine's local timezone with a "con Xh Ym" countdown.
-- Do not print the access token.

package/dist/project-sample/.claude/skills/check-usage/check_usage.py

@@ -1,161 +0,0 @@
-#!/usr/bin/env python3
-"""Fetch Claude Code plan-usage limits (same data as the built-in /usage screen).
-
-Reads the OAuth access token from ~/.claude/.credentials.json and queries the
-Anthropic usage endpoint, then prints session + weekly utilization and reset times
-in the local timezone.
-"""
-import json
-import os
-import subprocess
-import sys
-import urllib.request
-import urllib.error
-from datetime import datetime, timezone
-
-# Windows consoles default to cp1252 which can't encode the emoji/bar glyphs.
-for _s in (sys.stdout, sys.stderr):
-    try:
-        _s.reconfigure(encoding="utf-8")
-    except Exception:
-        pass
-
-CRED_PATH = os.path.expanduser("~/.claude/.credentials.json")
-URL = "https://api.anthropic.com/api/oauth/usage"
-
-
-class UsageError(Exception):
-    """Recoverable failure while loading the token or calling the usage API.
-    Raised (instead of exiting) so the caller can refresh the token and retry once."""
-
-
-def load_token():
-    try:
-        with open(CRED_PATH, "r", encoding="utf-8") as f:
-            data = json.load(f)
-    except FileNotFoundError:
-        raise UsageError(f"Credentials not found: {CRED_PATH} (log in to Claude Code first).")
-    oauth = data.get("claudeAiOauth", data)
-    token = oauth.get("accessToken")
-    if not token:
-        raise UsageError("No accessToken in credentials.")
-    exp = oauth.get("expiresAt")
-    if exp and datetime.now(timezone.utc).timestamp() * 1000 > exp:
-        print("Warning: token may be expired — run /usage once in Claude Code to refresh.\n",
-              file=sys.stderr)
-    return token, oauth.get("subscriptionType", "?")
-
-
-def fetch(token):
-    req = urllib.request.Request(URL, headers={
-        "Authorization": f"Bearer {token}",
-        "anthropic-beta": "oauth-2025-04-20",
-        "User-Agent": "claude-cli/2.0.0 (external, cli)",
-    })
-    try:
-        with urllib.request.urlopen(req, timeout=20) as r:
-            return json.load(r)
-    except urllib.error.HTTPError as e:
-        body = e.read().decode("utf-8", "replace")[:300]
-        raise UsageError(f"API error HTTP {e.code}: {body}")
-    except urllib.error.URLError as e:
-        raise UsageError(f"Could not reach API: {e.reason}")
-
-
-def get_usage():
-    """Load the token and query the usage API. Raises UsageError on any failure."""
-    token, sub = load_token()
-    return fetch(token), sub
-
-
-def refresh_token():
-    """Best-effort token refresh: run `claude /usage`, which refreshes the OAuth
-    token on startup. On Windows we go through `wsl` (the credentials this script
-    reads live in WSL); on POSIX we call `claude` directly. Output is discarded and
-    the call is bounded by a timeout so it can never hang the usage check."""
-    cmd = ["wsl", "claude", "/usage"] if sys.platform == "win32" else ["claude", "/usage"]
-    print(f"Refreshing token via: {' '.join(cmd)}", file=sys.stderr)
-    try:
-        subprocess.run(
-            cmd, timeout=60,
-            stdin=subprocess.DEVNULL,
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-        )
-    except Exception as e:
-        print(f"Token refresh attempt failed: {e}", file=sys.stderr)
-
-
-def fmt_reset(iso):
-    if not iso:
-        return "?"
-    dt = datetime.fromisoformat(iso).astimezone()  # -> local tz
-    return f"{dt:%a %d/%m %H:%M}"
-
-
-def save_last_result(record):
-    """Delete the previous ./output/last-usage-check.json, then write a fresh one
-    holding this run's result. Console output is still printed by the caller."""
-    out_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "output")
-    os.makedirs(out_dir, exist_ok=True)
-    out_path = os.path.join(out_dir, "last-usage-check.json")
-    # Remove the stale file first, then recreate it from scratch.
-    try:
-        os.remove(out_path)
-    except FileNotFoundError:
-        pass
-    with open(out_path, "w", encoding="utf-8") as f:
-        json.dump(record, f, ensure_ascii=False, indent=2)
-    return out_path
-
-
-def main():
-    try:
-        data, sub = get_usage()
-    except UsageError as e:
-        # First attempt failed — try to refresh the token once, then retry once.
-        print(f"Usage check failed: {e}", file=sys.stderr)
-        refresh_token()
-        try:
-            data, sub = get_usage()
-        except UsageError as e2:
-            print(f"Still failing after token refresh — skipping: {e2}", file=sys.stderr)
-            sys.exit(1)
-
-    if "--json" in sys.argv:
-        print(json.dumps(data, indent=2))
-        return
-
-    fh = data.get("five_hour") or {}
-    sd = data.get("seven_day") or {}
-
-    lines = [
-        f"- Plan: {sub}",
-        f"- Session: {fh.get('utilization', 0):.0f}% — reset {fmt_reset(fh.get('resets_at'))}",
-        f"- Weekly: {sd.get('utilization', 0):.0f}% — reset {fmt_reset(sd.get('resets_at'))}",
-    ]
-    extra = data.get("extra_usage") or {}
-    if extra.get("is_enabled") and extra.get("used_credits"):
-        dp = extra.get("decimal_places", 2)
-        lines.append(f"- Extra: {extra['used_credits'] / (10 ** dp):.2f} {extra.get('currency', 'USD')}")
-
-    summary = "\n".join(lines)
-    print(summary)  # keep the console output
-
-    # Persist this run's result so the autonomous workflow can read it back.
-    record = {
-        "checked_at": datetime.now().astimezone().isoformat(timespec="seconds"),
-        "plan": sub,
-        "session_pct": fh.get("utilization", 0),
-        "weekly_pct": sd.get("utilization", 0),
-        "session_resets_at": fh.get("resets_at"),
-        "weekly_resets_at": sd.get("resets_at"),
-        "summary": summary,
-        "raw": data,
-    }
-    out_path = save_last_result(record)
-    print(f"\nSaved result to: {out_path}")
-
-
-if __name__ == "__main__":
-    main()