@pkprosol/coach 1.0.5 → 1.0.6

package/dist/bin/coach.js

@@ -3,8 +3,8 @@ import { createInterface } from "node:readline";
 import ora from "ora";
 import chalk from "chalk";
 import { collectToday } from "../src/collector.js";
-import { analyze, runClaude, buildHandoffPrompt, buildFocusPrompt } from "../src/analyzer.js";
-import { renderInsight, renderStreak, renderHistory, renderNoData, renderError, renderHandoff, renderFocus, renderRecap, renderGoals, renderCompare, renderWelcome, } from "../src/display.js";
+import { analyze, runClaude, buildHandoffPrompt, buildFocusPrompt, buildCostsPrompt, estimateCosts } from "../src/analyzer.js";
+import { renderInsight, renderStreak, renderHistory, renderNoData, renderError, renderHandoff, renderFocus, renderRecap, renderGoals, renderCompare, renderWelcome, renderCosts, } from "../src/display.js";
 import { isFirstRun, loadState, saveState, loadInsights, appendInsight, updateLastInsightRating, updateStreak, recordDimension, addGoal, completeGoal, clearCompletedGoals, recordDailyStat, } from "../src/storage.js";
 function askQuestion(prompt) {
     const rl = createInterface({ input: process.stdin, output: process.stdout });
@@ -176,6 +176,36 @@ async function handleFocus() {
         }
     }
 }
+async function handleCosts() {
+    const spinner = ora({ text: "Analyzing costs and token usage...", color: "cyan" }).start();
+    const data = collectToday();
+    if (data.prompts.length === 0) {
+        spinner.stop();
+        console.log(renderNoData());
+        return;
+    }
+    spinner.text = "Crunching cost data...";
+    try {
+        const costs = estimateCosts(data);
+        const prompt = buildCostsPrompt(data, costs);
+        const text = await runClaude(prompt);
+        spinner.stop();
+        const cleaned = text.replace(/^```json?\s*/, "").replace(/\s*```$/, "").trim();
+        const analysis = JSON.parse(cleaned);
+        console.log("");
+        console.log(renderCosts(analysis));
+        console.log("");
+    }
+    catch (err) {
+        spinner.stop();
+        if (err.message?.includes("claude CLI not found")) {
+            console.log(renderError("claude CLI not found. Install Claude Code first: https://docs.anthropic.com/en/docs/claude-code"));
+        }
+        else {
+            console.log(renderError(err.message ?? "Cost analysis failed."));
+        }
+    }
+}
 function handleRecap() {
     const data = collectToday();
     if (data.prompts.length === 0) {
@@ -275,6 +305,7 @@ ${chalk.bold("Usage:")}
   coach            Today's lesson + tip (default)
   coach handoff    Generate a handoff note for your current work
   coach focus      Analyze context-switching and focus patterns
+  coach costs      Token costs, prompt engineering tips & LLM insights
   coach recap      Quick summary of today's stats (no AI)
   coach goals      Show current goals
   coach goals set  Add a goal: coach goals set "finish auth"
@@ -303,6 +334,9 @@ async function main() {
         case "focus":
             await handleFocus();
             break;
+        case "costs":
+            await handleCosts();
+            break;
         case "recap":
             handleRecap();
             break;

package/dist/src/analyzer.d.ts

@@ -1,5 +1,7 @@
-import type { CollectedData, Dimension, Insight, StoredInsight } from "./types.js";
+import type { CollectedData, CostEstimate, Dimension, Insight, StoredInsight } from "./types.js";
+export declare function estimateCosts(data: CollectedData): CostEstimate[];
 export declare function runClaude(prompt: string): Promise<string>;
 export declare function buildHandoffPrompt(data: CollectedData): string;
 export declare function buildFocusPrompt(data: CollectedData): string;
+export declare function buildCostsPrompt(data: CollectedData, costs: CostEstimate[]): string;
 export declare function analyze(data: CollectedData, recentDimensions: Dimension[], pastInsights: StoredInsight[]): Promise<Insight>;

package/dist/src/analyzer.js

@@ -1,5 +1,23 @@
 import { spawn } from "node:child_process";
 import { DIMENSIONS } from "./types.js";
+// Claude Sonnet pricing (most common for Claude Code)
+const INPUT_COST_PER_MTOK = 3; // $3 per million input tokens
+const OUTPUT_COST_PER_MTOK = 15; // $15 per million output tokens
+export function estimateCosts(data) {
+    return data.sessions.map((s) => {
+        const inputCost = (s.inputTokens / 1_000_000) * INPUT_COST_PER_MTOK;
+        const outputCost = (s.outputTokens / 1_000_000) * OUTPUT_COST_PER_MTOK;
+        return {
+            sessionId: s.sessionId.slice(0, 8),
+            project: s.project,
+            inputCost,
+            outputCost,
+            totalCost: inputCost + outputCost,
+            inputTokens: s.inputTokens,
+            outputTokens: s.outputTokens,
+        };
+    });
+}
 export function runClaude(prompt) {
     return new Promise((resolve, reject) => {
         const proc = spawn("claude", ["-p", "--output-format", "text"], {
@@ -75,6 +93,9 @@ function pickDimension(recentDimensions, data) {
     if (data.sessions.length === 1 && data.prompts.length > 5) {
         scores.set("Problem Decomposition", (scores.get("Problem Decomposition") ?? 0) + 1.5);
     }
+    if (data.totalTokens > 100000) {
+        scores.set("Cost Awareness", (scores.get("Cost Awareness") ?? 0) + 1.5);
+    }
     // Pick highest scoring available dimension
     let best = pool[0];
     let bestScore = -1;
@@ -93,13 +114,15 @@ function buildPrompt(data, dimension, pastInsights) {
         project: p.project,
         sessionId: p.sessionId.slice(0, 8),
     }));
-    const sessionSummaries = data.sessions.map((s) => ({
+    const costs = estimateCosts(data);
+    const sessionSummaries = data.sessions.map((s, i) => ({
         project: s.project,
         messages: s.messageCount,
         userMessages: s.userMessageCount,
         toolCalls: s.toolCallCount,
         tools: s.toolNames,
         tokens: s.inputTokens + s.outputTokens,
+        estimatedCost: `$${costs[i]?.totalCost.toFixed(4) ?? "0.0000"}`,
         duration: s.startTime && s.endTime
             ? `${Math.round((new Date(s.endTime).getTime() - new Date(s.startTime).getTime()) / 60000)}min`
             : "unknown",
@@ -127,6 +150,7 @@ Dimension descriptions:
 - Communication Style: how problems are described to Claude
 - Tool Leverage: effective use of Claude's capabilities (tools, features)
 - Problem Decomposition: breaking down vs monolithic asks
+- Cost Awareness: token efficiency, cost-effective prompting, understanding what makes prompts expensive or cheap
 
 ## Today's Session Data
 
@@ -136,6 +160,7 @@ Total sessions: ${data.sessions.length}
 Total messages: ${data.totalMessages}
 Total tool calls: ${data.totalToolCalls}
 Total tokens: ${data.totalTokens.toLocaleString()}
+Estimated total cost: $${costs.reduce((s, c) => s + c.totalCost, 0).toFixed(4)} (Sonnet pricing)
 
 ### User Prompts (chronological)
 ${JSON.stringify(samplePrompts, null, 2)}
@@ -251,6 +276,63 @@ Analyze the patterns and return a JSON object:
 }
 
 Be specific and reference actual project names and times.
+Respond with ONLY the JSON object, no markdown fences or other text.`;
+}
+export function buildCostsPrompt(data, costs) {
+    const totalCost = costs.reduce((s, c) => s + c.totalCost, 0);
+    const totalInput = costs.reduce((s, c) => s + c.inputTokens, 0);
+    const totalOutput = costs.reduce((s, c) => s + c.outputTokens, 0);
+    const totalInputCost = costs.reduce((s, c) => s + c.inputCost, 0);
+    const totalOutputCost = costs.reduce((s, c) => s + c.outputCost, 0);
+    const samplePrompts = data.prompts.slice(0, 30).map((p) => ({
+        text: p.text.slice(0, 400),
+        project: p.project,
+        charLength: p.text.length,
+    }));
+    const sessionCosts = costs.map((c) => ({
+        project: c.project,
+        inputTokens: c.inputTokens,
+        outputTokens: c.outputTokens,
+        estimatedCost: `$${c.totalCost.toFixed(4)}`,
+    }));
+    return `You are a cost and prompt engineering analyst for Claude Code usage. Analyze this developer's token usage and costs to provide actionable insights about efficiency, prompt engineering, and how LLMs process their requests.
+
+## Today's Cost Data
+
+Date: ${data.date}
+Total estimated cost: $${totalCost.toFixed(4)} (using Sonnet pricing: $${INPUT_COST_PER_MTOK}/MTok input, $${OUTPUT_COST_PER_MTOK}/MTok output)
+Total input tokens: ${totalInput.toLocaleString()} ($${totalInputCost.toFixed(4)})
+Total output tokens: ${totalOutput.toLocaleString()} ($${totalOutputCost.toFixed(4)})
+Total sessions: ${data.sessions.length}
+Total prompts: ${data.prompts.length}
+Total tool calls: ${data.totalToolCalls}
+
+### Per-Session Costs
+${JSON.stringify(sessionCosts, null, 2)}
+
+### User Prompts (with character lengths)
+${JSON.stringify(samplePrompts, null, 2)}
+
+## Your Task
+
+Analyze the cost patterns and return a JSON object with exactly these fields:
+
+{
+  "estimatedCost": "Total estimated cost as a readable string (e.g. '$0.42')",
+  "mostExpensiveSession": "Describe which session cost the most and why (project name, what drove the cost — long prompts, many tool calls, etc). 2-3 sentences.",
+  "costBreakdown": "Explain the input vs output token split and what it means. Are they paying more for long prompts (input) or for Claude's responses (output)? What does the ratio tell us? 2-3 sentences.",
+  "surprisingFact": "One interesting or surprising observation about their usage — could be about token economics, how LLMs tokenize text, why certain prompts cost more, context window mechanics, or prompt caching. Make it genuinely educational. 2-3 sentences.",
+  "efficiencyTips": ["Tip 1", "Tip 2", "Tip 3"],
+  "promptEngineeringInsight": "A genuinely interesting insight about prompt engineering, how LLMs work, or token economics that relates to their specific usage patterns. Teach them something they probably don't know. 2-3 sentences."
+}
+
+Guidelines:
+- Be specific — reference actual projects, prompt lengths, and cost numbers from the data.
+- For efficiencyTips, give concrete, actionable advice (not generic "write shorter prompts").
+- For surprisingFact and promptEngineeringInsight, teach something genuinely interesting about LLMs, tokenization, attention mechanisms, or prompt engineering that connects to their data.
+- Keep costs in perspective — compare to a cup of coffee, a SaaS subscription, etc.
+- If tool calls are a significant portion of the work, explain how tool use affects costs (each tool result is input tokens on the next turn).
+
 Respond with ONLY the JSON object, no markdown fences or other text.`;
 }
 export async function analyze(data, recentDimensions, pastInsights) {

package/dist/src/display.d.ts

@@ -1,4 +1,4 @@
-import type { Insight, CoachState, StoredInsight, Goal, CollectedData, DailyStat } from "./types.js";
+import type { Insight, CoachState, StoredInsight, Goal, CollectedData, DailyStat, CostAnalysis } from "./types.js";
 export declare function renderInsight(insight: Insight, state: CoachState): string;
 export declare function renderStreak(state: CoachState): string;
 export declare function renderHistory(insights: StoredInsight[]): string;
@@ -22,3 +22,4 @@ export declare function renderFocus(focus: {
 export declare function renderRecap(data: CollectedData): string;
 export declare function renderGoals(goals: Goal[]): string;
 export declare function renderCompare(today: DailyStat, avg: DailyStat): string;
+export declare function renderCosts(analysis: CostAnalysis): string;

package/dist/src/display.js

@@ -145,6 +145,7 @@ export function renderWelcome() {
     out.push(padLine("  " + chalk.cyan("coach") + "           Today's lesson + tip"));
     out.push(padLine("  " + chalk.cyan("coach handoff") + "   Handoff note for your work"));
     out.push(padLine("  " + chalk.cyan("coach focus") + "     Focus & context-switching"));
+    out.push(padLine("  " + chalk.cyan("coach costs") + "     Cost analysis & LLM tips"));
     out.push(padLine("  " + chalk.cyan("coach recap") + "     Quick stats (no AI)"));
     out.push(padLine("  " + chalk.cyan("coach goals") + "     Track your goals"));
     out.push(padLine("  " + chalk.cyan("coach compare") + "   Today vs recent averages"));
@@ -314,3 +315,42 @@ export function renderCompare(today, avg) {
     out.push(boxBot());
     return out.join("\n");
 }
+// === Cost Analysis ===
+export function renderCosts(analysis) {
+    const out = [];
+    out.push(boxTop());
+    out.push(padLine(chalk.bold.white("  COST ANALYSIS")));
+    out.push(boxMid());
+    // Estimated cost
+    out.push(padLine(""));
+    out.push(padLine(`  💰 Estimated cost today: ${chalk.bold.yellow(analysis.estimatedCost)}`));
+    // Most expensive session
+    out.push(...renderSection("  📊 Most Expensive Session", analysis.mostExpensiveSession));
+    // Cost breakdown
+    out.push(...renderSection("  ⚖️  Input vs Output", analysis.costBreakdown));
+    // Surprising fact
+    out.push(padLine(""));
+    out.push(padLine(chalk.bold("  🤯 Did You Know?")));
+    for (const line of wrapText(analysis.surprisingFact, WIDTH - 4)) {
+        out.push(padLine("  " + chalk.cyan(line)));
+    }
+    // Efficiency tips
+    if (analysis.efficiencyTips.length > 0) {
+        out.push(padLine(""));
+        out.push(padLine(chalk.bold("  💡 Efficiency Tips")));
+        for (const tip of analysis.efficiencyTips) {
+            for (const line of wrapText(`- ${tip}`, WIDTH - 6)) {
+                out.push(padLine("    " + line));
+            }
+        }
+    }
+    // Prompt engineering insight
+    out.push(padLine(""));
+    out.push(padLine(chalk.bold("  🧠 Prompt Engineering")));
+    for (const line of wrapText(analysis.promptEngineeringInsight, WIDTH - 4)) {
+        out.push(padLine("  " + chalk.italic(line)));
+    }
+    out.push(padLine(""));
+    out.push(boxBot());
+    return out.join("\n");
+}

package/dist/src/types.d.ts

@@ -1,4 +1,4 @@
-export declare const DIMENSIONS: readonly ["Prompting Craft", "Workflow Efficiency", "Architecture Thinking", "Learning Patterns", "Focus & Deep Work", "Communication Style", "Tool Leverage", "Problem Decomposition"];
+export declare const DIMENSIONS: readonly ["Prompting Craft", "Workflow Efficiency", "Architecture Thinking", "Learning Patterns", "Focus & Deep Work", "Communication Style", "Tool Leverage", "Problem Decomposition", "Cost Awareness"];
 export type Dimension = (typeof DIMENSIONS)[number];
 export interface UserPrompt {
     text: string;
@@ -70,6 +70,23 @@ export interface CoachState {
     goals: Goal[];
     dailyStats: DailyStat[];
 }
+export interface CostEstimate {
+    sessionId: string;
+    project: string;
+    inputCost: number;
+    outputCost: number;
+    totalCost: number;
+    inputTokens: number;
+    outputTokens: number;
+}
+export interface CostAnalysis {
+    estimatedCost: string;
+    mostExpensiveSession: string;
+    costBreakdown: string;
+    surprisingFact: string;
+    efficiencyTips: string[];
+    promptEngineeringInsight: string;
+}
 export interface HistoryEntry {
     display: string;
     pastedContents: Record<string, unknown>;

package/dist/src/types.js

@@ -8,4 +8,5 @@ export const DIMENSIONS = [
     "Communication Style",
     "Tool Leverage",
     "Problem Decomposition",
+    "Cost Awareness",
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pkprosol/coach",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Daily AI work coach — analyzes your Claude Code & Claude App sessions to deliver one lesson + one tip daily",
   "type": "module",
   "bin": {