apps/kimi/src/command-utils.ts (1)

3-8: Type inconsistency: reasoningOutputTokens nullish coalescing vs required type.

Line 7 declares reasoningOutputTokens: number as required, but line 19 uses usage.reasoningOutputTokens ?? 0, implying it could be undefined. Either make the type optional (reasoningOutputTokens?: number) or remove the nullish coalescing if the field is always present.

♻️ Option A: Make type optional

 export type UsageGroup = {
 	inputTokens: number;
 	cachedInputTokens: number;
 	outputTokens: number;
-	reasoningOutputTokens: number;
+	reasoningOutputTokens?: number;
 };

♻️ Option B: Remove nullish coalescing

-	const rawReasoning = usage.reasoningOutputTokens ?? 0;
+	const rawReasoning = usage.reasoningOutputTokens;

Also applies to: 19-19

apps/kimi/src/token-utils.ts (1)

15-21: Consider documenting the mutation behavior.

addUsage mutates target in place rather than returning a new object. This is a valid pattern for performance, but a brief JSDoc comment would clarify intent for future maintainers.

apps/kimi/src/commands/monthly.ts (1)

36-42: Consider preserving error details in logging.

String(error) may lose stack trace information. For better debugging, consider logging the error object directly or checking if it's an Error instance.

♻️ Proposed improvement

 		} catch (error) {
-			logger.error(String(error));
+			logger.error(error instanceof Error ? error.message : String(error));
 			process.exit(1);
 		}

apps/kimi/CLAUDE.md (2)

49-55: Add language specifier to fenced code block.

The markdownlint tool flags this code block for missing a language specifier. Consider adding a language identifier (e.g., text or plaintext) to satisfy MD040.

Suggested fix

-```
+```text
 inputTokens = input_other + input_cache_read + input_cache_creation

---

117-119: Add language specifier to fenced code block.

Same markdownlint MD040 issue - add a language identifier.

Suggested fix

-```
+```text
 {work_directory_path}/{session_file_id}

apps/kimi/src/commands/session.ts (1)

175-177: Missing compact mode notice.

The daily command (lines 166-169 in daily.ts) displays a helpful notice when running in compact mode, informing users to expand terminal width for additional metrics. This session command lacks that notice, creating inconsistent UX.

Suggested fix

 	log(table.toString());
+
+	if (table.isCompactMode()) {
+		logger.info('\nRunning in Compact Mode');
+		logger.info('Expand terminal width to see reasoning and cache metrics');
+	}
 },

apps/kimi/src/daily-report.ts (1)

83-86: Consider parallelizing pricing lookups.

The sequential await in the loop could be parallelized for better performance when there are multiple unique models. While the impact is likely minimal (few unique models), it's a common optimization pattern.

Suggested fix

 const modelPricing = new Map<string, Awaited<ReturnType<PricingSource['getPricing']>>>();
-for (const modelName of uniqueModels) {
-	modelPricing.set(modelName, await pricingSource.getPricing(modelName));
-}
+await Promise.all(
+	Array.from(uniqueModels).map(async (modelName) => {
+		modelPricing.set(modelName, await pricingSource.getPricing(modelName));
+	}),
+);

apps/kimi/src/pricing.ts (2)

4-4: Module-level warnedModels state may affect test isolation.

The warnedModels Set persists across all KimiPricingSource instances and test runs within the same process. While this correctly deduplicates warnings in production, it means:

1. Tests cannot verify the warning is emitted without mocking the logger
2. If a test queries an unknown model, subsequent tests won't see the warning for that same model

Consider either:

• Accepting this as intended behavior (warnings are one-time per process)
• Adding a clearWarnings() method for testing purposes (unexported)

This is a minor concern since the current test uses a unique model name and the behavior is documented.

Also applies to: 65-70

---

12-15: IIFE for lastSegment extraction is unconventional.

The immediately-invoked function expression (IIFE) works but is unusual for this simple operation. A more idiomatic approach would be direct assignment.

Suggested simplification

-const lastSegment = (() => {
-	const idx = trimmed.lastIndexOf('/');
-	return idx >= 0 ? trimmed.slice(idx + 1) : trimmed;
-})();
+const idx = trimmed.lastIndexOf('/');
+const lastSegment = idx >= 0 ? trimmed.slice(idx + 1) : trimmed;

apps/mcp/src/kimi.ts (1)

145-163: Wrap JSON parsing with Result.try() for consistent error handling.

JSON.parse can throw; using @praha/byethrow keeps failures consistent with project guidelines.

♻️ Suggested refactor

-import { z } from 'zod';
+import { Result } from '@praha/byethrow';
+import { z } from 'zod';
@@
 const kimiWeeklyResponseSchema = z.object({
 	weekly: z.array(kimiWeeklyRowSchema),
 	totals: kimiTotalsSchema.nullable(),
 });
+
+function parseKimiJson<T>(raw: string, schema: z.ZodType<T>): T {
+	const parsed = Result.try({
+		try: () => JSON.parse(raw) as unknown,
+		catch: (error) => error,
+	})();
+	if (Result.isFailure(parsed)) {
+		throw parsed.error;
+	}
+	return schema.parse(parsed.value);
+}
@@
 export async function getKimiDaily(parameters: z.infer<typeof kimiParametersSchema>) {
 	const raw = await runKimiCliJson('daily', parameters);
-	return kimiDailyResponseSchema.parse(JSON.parse(raw));
+	return parseKimiJson(raw, kimiDailyResponseSchema);
 }
@@
 export async function getKimiMonthly(parameters: z.infer<typeof kimiParametersSchema>) {
 	const raw = await runKimiCliJson('monthly', parameters);
-	return kimiMonthlyResponseSchema.parse(JSON.parse(raw));
+	return parseKimiJson(raw, kimiMonthlyResponseSchema);
 }
@@
 export async function getKimiSession(parameters: z.infer<typeof kimiParametersSchema>) {
 	const raw = await runKimiCliJson('session', parameters);
-	return kimiSessionResponseSchema.parse(JSON.parse(raw));
+	return parseKimiJson(raw, kimiSessionResponseSchema);
 }
@@
 export async function getKimiWeekly(parameters: z.infer<typeof kimiParametersSchema>) {
 	const raw = await runKimiCliJson('weekly', parameters);
-	return kimiWeeklyResponseSchema.parse(JSON.parse(raw));
+	return parseKimiJson(raw, kimiWeeklyResponseSchema);
 }

apps/kimi/README.md (1)

2-2: Use relative paths for images stored in /docs/public/.

These two images are served from docs/public but use absolute CDN URLs. Per the markdown guideline, switch to relative paths.
As per coding guidelines: "Use relative image paths like /screenshot.png for images stored in /docs/public/."

🔧 Suggested fix

-    <img src="https://cdn.jsdelivr.net/gh/ryoppippi/ccusage@main/docs/public/logo.svg" alt="ccusage logo" width="256" height="256">
+    <img src="/logo.svg" alt="ccusage logo" width="256" height="256">

-        <img src="https://cdn.jsdelivr.net/gh/ryoppippi/ccusage@main/docs/public/ccusage_thumbnail.png" alt="ccusage: The Claude Code cost scorecard that went viral" width="600">
+        <img src="/ccusage_thumbnail.png" alt="ccusage: The Claude Code cost scorecard that went viral" width="600">

Also applies to: 117-117

apps/kimi/src/data-loader.ts (1)

7-7: Consider moving test-only import inside the vitest block.

createFixture is only used within the import.meta.vitest block but is imported at module top-level. While tree-shaking should handle this in production builds, moving it inside the test block makes the test dependency scope explicit:

if (import.meta.vitest != null) {
    const { createFixture } = await import('fs-fixture');
    // ...tests
}

However, given the coding guideline against dynamic imports, the current approach is acceptable if the bundler handles tree-shaking correctly.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@apps/kimi/src/data-loader.ts` at line 7, The top-level import of
createFixture should be moved into the test-only block so the test dependency is
scoped to import.meta.vitest: remove the top-level "import { createFixture }
from 'fs-fixture';" and inside the "if (import.meta.vitest != null) { ... }"
block dynamically import it (e.g. const { createFixture } = await
import('fs-fixture');) and use that local symbol for tests; if your project
forbids dynamic imports, leave the top-level import but add a comment explaining
it's test-only and relies on bundler tree-shaking.

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes