No actionable comments were generated in the recent review. 🎉

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

Review the following changes in direct dependencies. Learn more about Socket for GitHub.

Diff	Package	Supply Chain Security	Vulnerability	Quality	Maintenance	License
	@​praha/​byethrow-docs@​0.11.2
	@​praha/​byethrow@​0.11.2

View full report

Deploying with    Cloudflare Workers

The latest updates on your project. Learn more about integrating Git with Workers.

Open in StackBlitz

npx https://pkg.pr.new/ryoppippi/ccusage@1041

commit: 6a3f414

ccusage performance comparison

This compares the PR build against the base branch build on the same CI runner.

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Runtime: package ccusage bin from apps/ccusage/package.json through bun -b, --offline --json, measured by hyperfine with 2 warmups and 7 runs.

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/work/_temp/ccusage-large-fixture (1.01 GiB, 2,597 files), Codex /home/runner/work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2,597 files)
Runtime: package ccusage bin from apps/ccusage/package.json through bun -b, --offline --json, measured by hyperfine with 0 warmups and 1 runs.

Package size

Lower medians and smaller packed package sizes are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@coderabbitai review this PR, please. I updated byethrow/docs to 0.11.2, migrated the Result.try API changes, and pushed an additional pass using Result.fn/parse/pipe where it fit.

#!/bin/bash
# Get PR details and diff
gh pr view 1041 --repo ryoppippi/ccusage --json title,body,files,baseRefName,headRefName
echo "---FILES---"
gh pr diff 1041 --repo ryoppippi/ccusage

@ryoppippi Great migration! The diff is clean and consistent throughout. Here's a thorough review:

Review of #1041 — refactor(byethrow): update result handling for 0.11

✅ What's done well

Consistent API migration. Every Result.try({...})() thunk call is correctly removed, and every previously-bare Promise passed as try: is wrapped in async () =>. No missed conversions are visible.

Result.fn extraction. The module-level parseJson / parseJsonLine constants are a nice pattern — they avoid re-creating the same Result.try config on every JSONL line and make the intent clear.

Result.parse over v.safeParse. Removing the direct valibot imports (import * as v from 'valibot') from amp/parser.ts, opencode/loader.ts, pi/parser.ts, and pricing-fetch-utils.ts in favour of Result.parse is clean. The .output → .value property rename is applied consistently.

Result.pipe for control flow. The refactors in shared.ts (safeTimeZone), opencode/paths.ts (hasOpenCodeDatabase), statusline.ts (process.kill), and pricing.ts (loadPricing) replace imperative try/catch with readable pipelines.

loadOfflinePricing → Result.fn. Switching from Result.try (executes immediately) to Result.fn (creates a reusable callable) is correct here — loadOfflinePricing is a class member that gets called later, not at definition time.

🔍 Items worth a second look

1. packages/internal ESLint type changed to 'app'

packages/internal is a library consumed by apps/ccusage. Changing its lint preset from 'lib' to 'app' suppresses the rule that enforces explicit return types on exported functions. The PR description explains this is intentional so byethrow return types can be inferred. This works, but it does mean the public surface of LiteLLMPricingFetcher (e.g., fetchModelPricing, getModelPricing, getModelContextLimit, calculateCost) now has inferred rather than explicit return types. For a library package, the tradeoff is worth tracking — if the inferred types ever drift from what callers expect, the compiler won't catch it at the boundary. A comment (or a TODO) noting this intentional deviation would be useful for future contributors.

2. progress?.stop() / logger.level cleanup in daily/monthly/session/weekly commands

The old pattern used finally {} to guarantee cleanup regardless of outcome. The new pattern duplicates the two cleanup lines in both branches:

// success path:
progress?.stop();
logger.level = originalLoggerLevel;

// failure path:
if (Result.isFailure(...)) {
  progress?.stop();
  logger.level = originalLoggerLevel;
  throw ...;
}

This is behaviorally equivalent ✅, but if a third branch is ever added it would be easy to forget one of the copies. Something like a small cleanup() helper — or just a short comment noting the intentional duplication — would guard against drift.

3. generate-json-schema.ts — runFormat wraps a tagged-template expression

async function runFormat(files: string[]) {
    return Result.try({
        try: async () => $`pnpm exec oxfmt ${files}`,
        catch: (error) => error,
    });
}

$\...`(Bun's shell tag) returns aShellPromisesynchronously and begins execution immediately upon evaluation. Wrapping it inasync () =>defers evaluation to whenResult.tryruns internally, which is the correct and safe behaviour under the 0.11 API. Just noting it explicitly since the oldtry: $`...`(eager Promise) would have started the subprocess beforeResult.try` even ran — the new form is actually more correct.

🏷️ Minor nit

In apps/ccusage/src/debug.ts the variable was renamed from parseParser → parseResult, which is a nice cleanup — but it was a bonus change not mentioned in the PR summary. No issue, just worth confirming it was intentional.

Summary

The migration is mechanically correct, well-scoped, and passes the stated testing steps. The two items above (packages/internal ESLint mode and finally-equivalent cleanup) are low-severity observations rather than bugs.

Thanks @coderabbitai. I reviewed the observations: packages/internal using ESLint type app is intentional for this PR per the requested inferred byethrow-facing types, and I am keeping that without an inline TODO to match the repository comment policy. The duplicated cleanup branches are behaviorally equivalent and small, so no follow-up change is needed.

@ryoppippi Understood — thanks for the clear explanations! Both decisions make sense:

• ESLint app mode in packages/internal: intentional to allow byethrow return type inference; noted.
• Duplicated cleanup branches: behaviorally equivalent and small enough to leave as-is; noted.
• No inline TODOs: consistent with the repo's comment policy.

The PR looks good to me.

(ᵔᴥᵔ)🐇✨

Learnt from: ryoppippi
URL: https://github.com/ryoppippi/ccusage/pull/1041

Timestamp: 2026-05-17T18:51:46.168Z
Learning: In the `ryoppippi/ccusage` repository, the codebase has a comment policy against adding inline TODO comments. Do not suggest adding `// TODO` or similar inline comment annotations when reviewing code in this repo.

Learnt from: ryoppippi
URL: https://github.com/ryoppippi/ccusage/pull/1041

Timestamp: 2026-05-17T18:51:46.168Z
Learning: In `ryoppippi/ccusage`, the `packages/internal` package intentionally uses ESLint preset mode `'app'` (instead of `'lib'`) to allow byethrow (`praha/byethrow`) return types to be inferred rather than explicitly annotated. This is an intentional design decision, not an oversight.

@coderabbitai review this update, please. I restored Valibot schema checks to v.safeParse where the code only skips invalid records, and kept byethrow focused on recoverable I/O/JSON parsing and Result.pipe flows.

#!/bin/bash
gh pr diff 1041 --repo ryoppippi/ccusage

@ryoppippi This update looks excellent. The design boundary is now crisp and well-applied throughout:

✅ What's done well in this pass

v.safeParse correctly restored for record-skipping. In pi/parser.ts, v.safeParse(piAgentMessageSchema, parseResult.value) is the right tool — it's a per-record filter where invalid entries are silently skipped, not an I/O failure. Byethrow would add no value there.

Result.fn for module-level parsers. The parseJson / parseJsonLine constants in amp/parser.ts, opencode/loader.ts, codex/parser.ts, and pi/parser.ts are clean and reusable. No closure created per-call.

codex/parser.ts layering. Outer processJSONLFileByMarkers is wrapped in a single Result.try/Result.pipe for file-level I/O errors, while per-line JSON parse failures go through parseJsonLine and return early. The two failure modes are now correctly separated.

generate-json-schema.ts simplification. writeFile and runFormat already return Result, so they compose directly into Result.pipe without a redundant Result.try({ try: writeFile(...), safe: true }) wrapper — the removal is correct and cleaner.

process.kill(pid, 0) in statusline.ts. Uses a sync try: (not async () =>), which is correct since process.kill is synchronous and throws on missing process.

loadOfflinePricing = Result.fn(...). Creates a reusable callable class member rather than immediately invoking Result.try at assignment time — exactly right.

The separation of concerns is now solid: byethrow handles recoverable I/O / JSON-parse failures and pipeline control flow; Valibot handles schema validation where invalid records are simply filtered. The PR is clean.

[approve]