@pkprosol/coach 1.0.0 → 1.0.1

package/README.md

@@ -1,6 +1,6 @@
 # Coach — Daily AI Work Coach
 
-Analyzes your **Claude Code** and **Claude App** sessions to deliver one lesson + one tip daily. Built around the [Hooked model](https://www.nirandfar.com/hooked/) to make self-improvement habitual.
+Analyzes your **Claude Code** and **Claude App** sessions to deliver insights, handoff notes, focus analysis, and more. A swiss army knife for developer productivity.
 
 ```
 ┌──────────────────────────────────────────────────┐
@@ -32,28 +32,52 @@ npm install -g @pkprosol/coach
 
 This installs the `coach` CLI and auto-registers `/coach` as a slash command in Claude Code.
 
-## Setup
+## Requirements
+
+- Node.js 18+
+- [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) installed and authenticated
+- Claude Code and/or Claude Desktop App (for session data)
+
+## Usage
+
+### Core
 
 ```bash
-coach setup   # paste your Anthropic API key
+coach              # Today's lesson + tip (AI-powered)
+coach handoff      # Generate a handoff note for your current work
+coach focus        # Analyze context-switching and focus patterns
 ```
 
-Or set `ANTHROPIC_API_KEY` in your environment.
+### Quick Stats (no AI)
 
-## Usage
+```bash
+coach recap        # Summary of today's sessions, prompts, tokens, tools
+coach compare      # Compare today vs your 7-day averages
+```
+
+### Goals
 
-### Terminal
 ```bash
-coach            # today's lesson + tip
-coach streak     # current streak + stats
-coach history    # browse past insights
+coach goals              # Show current goals
+coach goals set "text"   # Add a new goal
+coach goals done 1       # Mark goal #1 complete
+coach goals clear        # Clear completed goals
+```
+
+### Meta
+
+```bash
+coach history      # Browse past insights
+coach streak       # Current streak + stats
+coach help         # Show all commands
 ```
 
 ### Claude Code
+
 ```
-/coach           # same thing, right inside Claude
-/coach streak
-/coach history
+/coach             # Same thing, right inside Claude
+/coach handoff
+/coach recap
 ```
 
 ## How it works
@@ -63,6 +87,8 @@ coach history    # browse past insights
 3. **Delivers** one specific lesson + one actionable tip, with examples from your actual sessions
 4. **Learns** from your ratings to improve future insights
 
+AI-powered commands (`coach`, `handoff`, `focus`) use the Claude CLI under the hood — no separate API key needed.
+
 ## Data sources
 
 | Source | Location | What's collected |
@@ -70,10 +96,4 @@ coach history    # browse past insights
 | Claude Code | `~/.claude/` | Prompts, session transcripts, tool usage, tokens |
 | Claude App | `~/Library/Application Support/Claude/` | Cowork/agent mode audit logs |
 
-All data stays local. Only a summary is sent to the Claude API for analysis.
-
-## Requirements
-
-- Node.js 18+
-- An Anthropic API key
-- Claude Code and/or Claude Desktop App
+All data stays local. Only a summary is sent to Claude for analysis.

package/dist/bin/coach.js

@@ -3,9 +3,9 @@ import { createInterface } from "node:readline";
 import ora from "ora";
 import chalk from "chalk";
 import { collectToday } from "../src/collector.js";
-import { analyze } from "../src/analyzer.js";
-import { renderInsight, renderStreak, renderHistory, renderSetupSuccess, renderNoData, renderError, } from "../src/display.js";
-import { loadState, saveState, getApiKey, setApiKey, loadInsights, appendInsight, updateLastInsightRating, updateStreak, recordDimension, } from "../src/storage.js";
+import { analyze, runClaude, buildHandoffPrompt, buildFocusPrompt } from "../src/analyzer.js";
+import { renderInsight, renderStreak, renderHistory, renderNoData, renderError, renderHandoff, renderFocus, renderRecap, renderGoals, renderCompare, } from "../src/display.js";
+import { 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 });
     return new Promise((resolve) => {
@@ -15,28 +15,7 @@ function askQuestion(prompt) {
         });
     });
 }
-async function handleSetup() {
-    const existing = getApiKey();
-    if (existing) {
-        console.log(chalk.dim("API key already configured."));
-        const answer = await askQuestion("Replace it? [y/N] ");
-        if (answer !== "y")
-            return;
-    }
-    const key = await askQuestion("Enter your Anthropic API key: ");
-    if (!key) {
-        console.log(renderError("No key provided."));
-        return;
-    }
-    setApiKey(key);
-    console.log(renderSetupSuccess());
-}
 async function handleDefault() {
-    const apiKey = getApiKey();
-    if (!apiKey) {
-        console.log(renderError("No API key found. Run `coach setup` first, or set ANTHROPIC_API_KEY."));
-        return;
-    }
     const spinner = ora({ text: "Collecting today's sessions...", color: "cyan" }).start();
     // Collect data
     const data = collectToday();
@@ -49,15 +28,26 @@ async function handleDefault() {
     // Load state and past insights
     let state = loadState();
     const pastInsights = loadInsights();
+    // Record daily stat
+    const now = new Date();
+    const today = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+    recordDailyStat({
+        date: today,
+        sessions: data.sessions.length,
+        prompts: data.prompts.length,
+        tokens: data.totalTokens,
+        projects: data.projectsWorkedOn,
+        toolCalls: data.totalToolCalls,
+    });
     // Analyze
     let insight;
     try {
-        insight = await analyze(data, state.recentDimensions, pastInsights, apiKey);
+        insight = await analyze(data, state.recentDimensions, pastInsights);
     }
     catch (err) {
         spinner.stop();
-        if (err.status === 401) {
-            console.log(renderError("Invalid API key. Run `coach setup` to update it."));
+        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 ?? "Analysis failed."));
@@ -66,8 +56,6 @@ async function handleDefault() {
     }
     spinner.stop();
     // Update state
-    const now = new Date();
-    const today = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
     state = updateStreak(state, today);
     state = recordDimension(state, insight.dimension);
     // Display
@@ -130,13 +118,169 @@ function handleRate(value) {
         console.log(renderError("Usage: coach rate y|n"));
     }
 }
+async function handleHandoff() {
+    const spinner = ora({ text: "Collecting sessions for handoff...", color: "cyan" }).start();
+    const data = collectToday();
+    if (data.prompts.length === 0) {
+        spinner.stop();
+        console.log(renderNoData());
+        return;
+    }
+    spinner.text = "Generating handoff note...";
+    try {
+        const prompt = buildHandoffPrompt(data);
+        const text = await runClaude(prompt);
+        spinner.stop();
+        const cleaned = text.replace(/^```json?\s*/, "").replace(/\s*```$/, "").trim();
+        const handoff = JSON.parse(cleaned);
+        console.log("");
+        console.log(renderHandoff(handoff));
+        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 ?? "Handoff generation failed."));
+        }
+    }
+}
+async function handleFocus() {
+    const spinner = ora({ text: "Analyzing focus patterns...", color: "cyan" }).start();
+    const data = collectToday();
+    if (data.prompts.length === 0) {
+        spinner.stop();
+        console.log(renderNoData());
+        return;
+    }
+    spinner.text = "Building focus analysis...";
+    try {
+        const prompt = buildFocusPrompt(data);
+        const text = await runClaude(prompt);
+        spinner.stop();
+        const cleaned = text.replace(/^```json?\s*/, "").replace(/\s*```$/, "").trim();
+        const focus = JSON.parse(cleaned);
+        console.log("");
+        console.log(renderFocus(focus));
+        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 ?? "Focus analysis failed."));
+        }
+    }
+}
+function handleRecap() {
+    const data = collectToday();
+    if (data.prompts.length === 0) {
+        console.log(renderNoData());
+        return;
+    }
+    console.log("");
+    console.log(renderRecap(data));
+    console.log("");
+}
+function handleGoals(args) {
+    const sub = args[0];
+    if (!sub) {
+        // Show goals
+        const state = loadState();
+        console.log("");
+        console.log(renderGoals(state.goals));
+        console.log("");
+        return;
+    }
+    if (sub === "set") {
+        const text = args.slice(1).join(" ").replace(/^["']|["']$/g, "");
+        if (!text) {
+            console.log(renderError('Usage: coach goals set "your goal"'));
+            return;
+        }
+        const goal = addGoal(text);
+        console.log(chalk.green("✓") + ` Goal #${goal.id} added: ${goal.text}`);
+        return;
+    }
+    if (sub === "done") {
+        const id = parseInt(args[1], 10);
+        if (isNaN(id)) {
+            console.log(renderError("Usage: coach goals done <id>"));
+            return;
+        }
+        const ok = completeGoal(id);
+        if (ok) {
+            console.log(chalk.green("✓") + ` Goal #${id} marked complete.`);
+        }
+        else {
+            console.log(renderError(`Goal #${id} not found or already completed.`));
+        }
+        return;
+    }
+    if (sub === "clear") {
+        const count = clearCompletedGoals();
+        console.log(chalk.green("✓") + ` Cleared ${count} completed goal${count !== 1 ? "s" : ""}.`);
+        return;
+    }
+    console.log(renderError(`Unknown goals subcommand: ${sub}`));
+}
+function handleCompare() {
+    const data = collectToday();
+    if (data.prompts.length === 0) {
+        console.log(renderNoData());
+        return;
+    }
+    const state = loadState();
+    const now = new Date();
+    const today = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+    const todayStat = {
+        date: today,
+        sessions: data.sessions.length,
+        prompts: data.prompts.length,
+        tokens: data.totalTokens,
+        projects: data.projectsWorkedOn,
+        toolCalls: data.totalToolCalls,
+    };
+    // Compute 7-day average from stored stats (excluding today)
+    const pastStats = state.dailyStats.filter((s) => s.date !== today).slice(-7);
+    if (pastStats.length === 0) {
+        console.log("");
+        console.log(renderRecap(data));
+        console.log(chalk.dim("  No historical data yet for comparison. Run `coach` daily to build history."));
+        console.log("");
+        return;
+    }
+    const n = pastStats.length;
+    const avg = {
+        date: `${n}-day avg`,
+        sessions: pastStats.reduce((s, d) => s + d.sessions, 0) / n,
+        prompts: pastStats.reduce((s, d) => s + d.prompts, 0) / n,
+        tokens: pastStats.reduce((s, d) => s + d.tokens, 0) / n,
+        projects: Array(Math.round(pastStats.reduce((s, d) => s + d.projects.length, 0) / n)).fill(""),
+        toolCalls: pastStats.reduce((s, d) => s + d.toolCalls, 0) / n,
+    };
+    console.log("");
+    console.log(renderCompare(todayStat, avg));
+    console.log("");
+}
 function handleHelp() {
     console.log(`
 ${chalk.bold("coach")} — Daily AI Work Coach
 
 ${chalk.bold("Usage:")}
   coach            Today's lesson + tip (default)
-  coach setup      Set your Anthropic API key
+  coach handoff    Generate a handoff note for your current work
+  coach focus      Analyze context-switching and focus patterns
+  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"
+  coach goals done Mark complete: coach goals done 1
+  coach goals clear Clear completed goals
+  coach compare    Compare today vs recent averages
   coach history    Browse past insights
   coach streak     Show current streak + stats
   coach help       Show this help message
@@ -145,8 +289,20 @@ ${chalk.bold("Usage:")}
 // --- Main ---
 const command = process.argv[2];
 switch (command) {
-    case "setup":
-        handleSetup();
+    case "handoff":
+        handleHandoff();
+        break;
+    case "focus":
+        handleFocus();
+        break;
+    case "recap":
+        handleRecap();
+        break;
+    case "goals":
+        handleGoals(process.argv.slice(3));
+        break;
+    case "compare":
+        handleCompare();
         break;
     case "history":
         handleHistoryCmd();

package/dist/postinstall.js

@@ -5,28 +5,33 @@ const skillDir = join(homedir(), ".claude", "skills", "coach");
 const skillFile = join(skillDir, "SKILL.md");
 const SKILL_CONTENT = `---
 name: coach
-description: Daily AI work coach - analyzes your Claude Code and Claude App sessions to deliver one lesson and one tip
+description: Daily AI work coach — analyzes your Claude sessions to deliver insights, handoff notes, focus analysis, and more
 disable-model-invocation: true
 user-invocable: true
 ---
 
-Run the Coach CLI tool to analyze today's Claude usage and deliver a personalized insight.
+Run the Coach CLI tool and display the output exactly as-is to the user (it contains formatted terminal UI).
 
-Execute this command and display the output exactly as-is to the user (it contains formatted terminal UI):
+If the user passes an argument, route it as a subcommand:
+- \`/coach\` → \`coach\` (today's lesson + tip)
+- \`/coach handoff\` → \`coach handoff\` (generate handoff note)
+- \`/coach focus\` → \`coach focus\` (focus analysis)
+- \`/coach recap\` → \`coach recap\` (quick stats)
+- \`/coach goals\` → \`coach goals\` (show goals)
+- \`/coach goals set "text"\` → \`coach goals set "text"\`
+- \`/coach goals done 1\` → \`coach goals done 1\`
+- \`/coach compare\` → \`coach compare\` (today vs averages)
+- \`/coach streak\` → \`coach streak\`
+- \`/coach history\` → \`coach history\`
 
 \`\`\`bash
 coach
 \`\`\`
 
-After showing the output, ask the user: "Was this helpful? (y/n)" and based on their answer, run:
+After showing the output of the default command, ask the user: "Was this helpful? (y/n)" and based on their answer, run:
 
 - If yes: \`coach rate y\`
 - If no: \`coach rate n\`
-
-If the user passes an argument, route it as a subcommand:
-- \`/coach streak\` → \`coach streak\`
-- \`/coach history\` → \`coach history\`
-- \`/coach setup\` → \`coach setup\`
 `;
 try {
     if (!existsSync(join(homedir(), ".claude"))) {

package/dist/src/analyzer.d.ts

@@ -1,2 +1,5 @@
 import type { CollectedData, Dimension, Insight, StoredInsight } from "./types.js";
-export declare function analyze(data: CollectedData, recentDimensions: Dimension[], pastInsights: StoredInsight[], apiKey: string): Promise<Insight>;
+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 analyze(data: CollectedData, recentDimensions: Dimension[], pastInsights: StoredInsight[]): Promise<Insight>;

package/dist/src/analyzer.js

@@ -1,5 +1,38 @@
-import Anthropic from "@anthropic-ai/sdk";
+import { spawn } from "node:child_process";
 import { DIMENSIONS } from "./types.js";
+export function runClaude(prompt) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn("claude", ["-p", "--output-format", "text", "--max-tokens", "1024"], {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        proc.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        proc.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        proc.on("error", (err) => {
+            if (err.code === "ENOENT") {
+                reject(new Error("claude CLI not found. Install Claude Code first: https://docs.anthropic.com/en/docs/claude-code"));
+            }
+            else {
+                reject(err);
+            }
+        });
+        proc.on("close", (code) => {
+            if (code === 0) {
+                resolve(stdout.trim());
+            }
+            else {
+                reject(new Error(stderr.trim() || `claude exited with code ${code}`));
+            }
+        });
+        proc.stdin.write(prompt);
+        proc.stdin.end();
+    });
+}
 function pickDimension(recentDimensions, data) {
     // Filter out recently used dimensions
     const available = DIMENSIONS.filter((d) => !recentDimensions.includes(d));
@@ -120,16 +153,95 @@ Guidelines:
 
 Respond with ONLY the JSON object, no markdown fences or other text.`;
 }
-export async function analyze(data, recentDimensions, pastInsights, apiKey) {
+export function buildHandoffPrompt(data) {
+    const sessionSummaries = data.sessions.map((s) => ({
+        project: s.project,
+        branch: s.gitBranch,
+        messages: s.messageCount,
+        toolCalls: s.toolCallCount,
+        tools: s.toolNames,
+        duration: s.startTime && s.endTime
+            ? `${Math.round((new Date(s.endTime).getTime() - new Date(s.startTime).getTime()) / 60000)}min`
+            : "unknown",
+    }));
+    const samplePrompts = data.prompts.slice(0, 30).map((p) => ({
+        text: p.text.slice(0, 400),
+        project: p.project,
+    }));
+    return `You are a work session analyzer. Given the developer's Claude Code sessions from today, produce a structured handoff note for when they pause or stop working.
+
+## Today's Session Data
+
+Date: ${data.date}
+Projects: ${data.projectsWorkedOn.join(", ")}
+
+### Sessions
+${JSON.stringify(sessionSummaries, null, 2)}
+
+### User Prompts
+${JSON.stringify(samplePrompts, null, 2)}
+
+## Your Task
+
+Produce a handoff note as a JSON object with these fields:
+
+{
+  "workingOn": "Brief description of what was being worked on (projects, branches, features)",
+  "currentState": "What's done, what's in progress",
+  "keyDecisions": ["Decision 1", "Decision 2"],
+  "nextSteps": ["Next step 1", "Next step 2"],
+  "openQuestions": ["Question 1"] or []
+}
+
+Be specific — reference actual projects, branches, and prompt content.
+Respond with ONLY the JSON object, no markdown fences or other text.`;
+}
+export function buildFocusPrompt(data) {
+    const sessionTimeline = data.sessions.map((s) => ({
+        project: s.project,
+        start: s.startTime,
+        end: s.endTime,
+        prompts: s.userMessageCount,
+    }));
+    const projectSwitches = [];
+    for (let i = 1; i < data.prompts.length; i++) {
+        if (data.prompts[i].project !== data.prompts[i - 1].project) {
+            projectSwitches.push(`${data.prompts[i - 1].project} → ${data.prompts[i].project} at ${data.prompts[i].timestamp}`);
+        }
+    }
+    return `You are a focus and productivity analyst. Analyze this developer's context-switching patterns and suggest optimal focus blocks.
+
+## Today's Data
+
+Date: ${data.date}
+Total sessions: ${data.sessions.length}
+Projects: ${data.projectsWorkedOn.join(", ")}
+
+### Session Timeline
+${JSON.stringify(sessionTimeline, null, 2)}
+
+### Context Switches
+${projectSwitches.length > 0 ? projectSwitches.join("\n") : "No context switches detected"}
+
+## Your Task
+
+Analyze the patterns and return a JSON object:
+
+{
+  "contextSwitches": ${projectSwitches.length},
+  "longestFocusPeriod": "Description of longest uninterrupted focus period",
+  "shortestFocusPeriod": "Description of shortest period before switching",
+  "pattern": "Overall observation about their focus pattern today (2-3 sentences)",
+  "suggestions": ["Suggestion 1", "Suggestion 2", "Suggestion 3"]
+}
+
+Be specific and reference actual project names and times.
+Respond with ONLY the JSON object, no markdown fences or other text.`;
+}
+export async function analyze(data, recentDimensions, pastInsights) {
     const dimension = pickDimension(recentDimensions, data);
     const prompt = buildPrompt(data, dimension, pastInsights);
-    const client = new Anthropic({ apiKey });
-    const response = await client.messages.create({
-        model: "claude-sonnet-4-5-20250929",
-        max_tokens: 1024,
-        messages: [{ role: "user", content: prompt }],
-    });
-    const text = response.content[0].type === "text" ? response.content[0].text : "";
+    const text = await runClaude(prompt);
     // Parse JSON from response — handle possible markdown fences
     const cleaned = text.replace(/^```json?\s*/, "").replace(/\s*```$/, "").trim();
     const result = JSON.parse(cleaned);

package/dist/src/display.d.ts

@@ -1,7 +1,23 @@
-import type { Insight, CoachState, StoredInsight } from "./types.js";
+import type { Insight, CoachState, StoredInsight, Goal, CollectedData, DailyStat } 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;
-export declare function renderSetupSuccess(): string;
 export declare function renderNoData(): string;
 export declare function renderError(msg: string): string;
+export declare function renderHandoff(handoff: {
+    workingOn: string;
+    currentState: string;
+    keyDecisions: string[];
+    nextSteps: string[];
+    openQuestions: string[];
+}): string;
+export declare function renderFocus(focus: {
+    contextSwitches: number;
+    longestFocusPeriod: string;
+    shortestFocusPeriod: string;
+    pattern: string;
+    suggestions: string[];
+}): string;
+export declare function renderRecap(data: CollectedData): string;
+export declare function renderGoals(goals: Goal[]): string;
+export declare function renderCompare(today: DailyStat, avg: DailyStat): string;

package/dist/src/display.js

@@ -126,9 +126,6 @@ export function renderHistory(insights) {
     }
     return out.join("\n");
 }
-export function renderSetupSuccess() {
-    return chalk.green("✓") + " API key saved. Run " + chalk.bold("coach") + " to get your first insight!";
-}
 export function renderNoData() {
     return chalk.yellow("No Claude Code sessions found for today.") +
         "\n" +
@@ -137,3 +134,151 @@ export function renderNoData() {
 export function renderError(msg) {
     return chalk.red("Error: ") + msg;
 }
+// === Handoff ===
+export function renderHandoff(handoff) {
+    const out = [];
+    out.push(boxTop());
+    out.push(padLine(chalk.bold.white("  HANDOFF NOTE")));
+    out.push(boxMid());
+    out.push(...renderSection("  Working On", handoff.workingOn));
+    out.push(...renderSection("  Current State", handoff.currentState));
+    if (handoff.keyDecisions.length > 0) {
+        out.push(padLine(""));
+        out.push(padLine(chalk.bold("  Key Decisions")));
+        for (const d of handoff.keyDecisions) {
+            for (const line of wrapText(`- ${d}`, WIDTH - 6)) {
+                out.push(padLine("    " + line));
+            }
+        }
+    }
+    if (handoff.nextSteps.length > 0) {
+        out.push(padLine(""));
+        out.push(padLine(chalk.bold("  Next Steps")));
+        for (const s of handoff.nextSteps) {
+            for (const line of wrapText(`- ${s}`, WIDTH - 6)) {
+                out.push(padLine("    " + line));
+            }
+        }
+    }
+    if (handoff.openQuestions.length > 0) {
+        out.push(padLine(""));
+        out.push(padLine(chalk.bold("  Open Questions")));
+        for (const q of handoff.openQuestions) {
+            for (const line of wrapText(`? ${q}`, WIDTH - 6)) {
+                out.push(padLine("    " + line));
+            }
+        }
+    }
+    out.push(padLine(""));
+    out.push(boxBot());
+    return out.join("\n");
+}
+// === Focus ===
+export function renderFocus(focus) {
+    const out = [];
+    out.push(boxTop());
+    out.push(padLine(chalk.bold.white("  FOCUS ANALYSIS")));
+    out.push(boxMid());
+    out.push(padLine(""));
+    out.push(padLine(`  Context switches: ${chalk.bold.yellow(String(focus.contextSwitches))}`));
+    out.push(...renderSection("  Longest Focus", focus.longestFocusPeriod));
+    out.push(...renderSection("  Shortest Focus", focus.shortestFocusPeriod));
+    out.push(...renderSection("  Pattern", focus.pattern));
+    if (focus.suggestions.length > 0) {
+        out.push(padLine(""));
+        out.push(padLine(chalk.bold("  Suggestions")));
+        for (const s of focus.suggestions) {
+            for (const line of wrapText(`- ${s}`, WIDTH - 6)) {
+                out.push(padLine("    " + line));
+            }
+        }
+    }
+    out.push(padLine(""));
+    out.push(boxBot());
+    return out.join("\n");
+}
+// === Recap ===
+export function renderRecap(data) {
+    const out = [];
+    out.push(boxTop());
+    out.push(padLine(chalk.bold.white("  TODAY'S RECAP")));
+    out.push(boxMid());
+    out.push(padLine(""));
+    out.push(padLine(`  Date: ${chalk.bold(data.date)}`));
+    out.push(padLine(`  Projects: ${chalk.cyan(data.projectsWorkedOn.join(", ") || "none")}`));
+    out.push(padLine(`  Sessions: ${chalk.bold(String(data.sessions.length))}`));
+    out.push(padLine(`  Prompts: ${chalk.bold(String(data.prompts.length))}`));
+    out.push(padLine(`  Tokens: ${chalk.bold(data.totalTokens.toLocaleString())}`));
+    out.push(padLine(`  Tool calls: ${chalk.bold(String(data.totalToolCalls))}`));
+    // Time spent
+    let totalMinutes = 0;
+    for (const s of data.sessions) {
+        if (s.startTime && s.endTime) {
+            totalMinutes += Math.round((new Date(s.endTime).getTime() - new Date(s.startTime).getTime()) / 60000);
+        }
+    }
+    if (totalMinutes > 0) {
+        const hours = Math.floor(totalMinutes / 60);
+        const mins = totalMinutes % 60;
+        out.push(padLine(`  Time: ${chalk.bold(hours > 0 ? `${hours}h ${mins}m` : `${mins}m`)}`));
+    }
+    // Unique tools
+    const allTools = new Set();
+    for (const s of data.sessions) {
+        for (const t of s.toolNames)
+            allTools.add(t);
+    }
+    if (allTools.size > 0) {
+        out.push(padLine(`  Tools used: ${chalk.dim([...allTools].join(", "))}`));
+    }
+    out.push(padLine(""));
+    out.push(boxBot());
+    return out.join("\n");
+}
+// === Goals ===
+export function renderGoals(goals) {
+    const out = [];
+    out.push(boxTop());
+    out.push(padLine(chalk.bold.white("  GOALS")));
+    out.push(boxMid());
+    if (goals.length === 0) {
+        out.push(padLine(""));
+        out.push(padLine(chalk.dim("  No goals set. Use `coach goals set \"your goal\"` to add one.")));
+        out.push(padLine(""));
+    }
+    else {
+        out.push(padLine(""));
+        for (const g of goals) {
+            const status = g.completedDate
+                ? chalk.green("[done]")
+                : chalk.yellow("[    ]");
+            const text = g.completedDate ? chalk.strikethrough.dim(g.text) : g.text;
+            out.push(padLine(`  ${status} ${chalk.dim(`#${g.id}`)} ${text}`));
+        }
+        out.push(padLine(""));
+    }
+    out.push(boxBot());
+    return out.join("\n");
+}
+// === Compare ===
+export function renderCompare(today, avg) {
+    const out = [];
+    out.push(boxTop());
+    out.push(padLine(chalk.bold.white("  TODAY vs 7-DAY AVERAGE")));
+    out.push(boxMid());
+    function compareVal(label, todayVal, avgVal) {
+        const diff = todayVal - avgVal;
+        const arrow = diff > 0 ? chalk.green("^") : diff < 0 ? chalk.red("v") : chalk.dim("=");
+        const diffStr = diff !== 0 ? ` (${diff > 0 ? "+" : ""}${Math.round(diff)})` : "";
+        return `  ${label.padEnd(14)} ${chalk.bold(String(todayVal).padStart(6))}  ${chalk.dim("avg")} ${String(Math.round(avgVal)).padStart(6)}  ${arrow}${diffStr}`;
+    }
+    out.push(padLine(""));
+    out.push(padLine(compareVal("Sessions", today.sessions, avg.sessions)));
+    out.push(padLine(compareVal("Prompts", today.prompts, avg.prompts)));
+    out.push(padLine(compareVal("Tokens", today.tokens, avg.tokens)));
+    out.push(padLine(compareVal("Tool calls", today.toolCalls, avg.toolCalls)));
+    out.push(padLine(`  ${"Projects".padEnd(14)} ${chalk.bold(String(today.projects.length).padStart(6))}  ${chalk.dim("avg")} ${String(Math.round(avg.projects.length)).padStart(6)}`));
+    out.push(padLine(""));
+    out.push(boxBot());
+    return out.join("\n");
+}

package/dist/src/storage.d.ts

@@ -1,10 +1,12 @@
-import type { CoachState, StoredInsight } from "./types.js";
+import type { CoachState, StoredInsight, Goal, DailyStat } from "./types.js";
 export declare function loadState(): CoachState;
 export declare function saveState(state: CoachState): void;
-export declare function getApiKey(): string | undefined;
-export declare function setApiKey(key: string): void;
 export declare function updateStreak(state: CoachState, today: string): CoachState;
 export declare function recordDimension(state: CoachState, dimension: string): CoachState;
 export declare function appendInsight(insight: StoredInsight): void;
 export declare function loadInsights(): StoredInsight[];
 export declare function updateLastInsightRating(rating: "helpful" | "not_helpful"): void;
+export declare function addGoal(text: string): Goal;
+export declare function completeGoal(id: number): boolean;
+export declare function clearCompletedGoals(): number;
+export declare function recordDailyStat(stat: DailyStat): void;

package/dist/src/storage.js

@@ -16,6 +16,8 @@ const DEFAULT_STATE = {
     totalInsights: 0,
     helpfulCount: 0,
     notHelpfulCount: 0,
+    goals: [],
+    dailyStats: [],
 };
 export function loadState() {
     ensureDir();
@@ -23,21 +25,12 @@ export function loadState() {
         return { ...DEFAULT_STATE };
     }
     const raw = readFileSync(STATE_FILE, "utf-8");
-    return JSON.parse(raw);
+    return { ...DEFAULT_STATE, ...JSON.parse(raw) };
 }
 export function saveState(state) {
     ensureDir();
     writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
 }
-export function getApiKey() {
-    const state = loadState();
-    return state.apiKey ?? process.env.ANTHROPIC_API_KEY;
-}
-export function setApiKey(key) {
-    const state = loadState();
-    state.apiKey = key;
-    saveState(state);
-}
 export function updateStreak(state, today) {
     if (state.lastRunDate === today) {
         return state; // Already ran today
@@ -89,3 +82,48 @@ export function updateLastInsightRating(rating) {
     ensureDir();
     writeFileSync(INSIGHTS_FILE, insights.map((i) => JSON.stringify(i)).join("\n") + "\n");
 }
+// === Goal management ===
+export function addGoal(text) {
+    const state = loadState();
+    const id = (state.goals.length > 0 ? Math.max(...state.goals.map((g) => g.id)) : 0) + 1;
+    const now = new Date();
+    const today = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+    const goal = { id, text, createdDate: today, completedDate: null };
+    state.goals.push(goal);
+    saveState(state);
+    return goal;
+}
+export function completeGoal(id) {
+    const state = loadState();
+    const goal = state.goals.find((g) => g.id === id);
+    if (!goal || goal.completedDate)
+        return false;
+    const now = new Date();
+    goal.completedDate = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+    saveState(state);
+    return true;
+}
+export function clearCompletedGoals() {
+    const state = loadState();
+    const before = state.goals.length;
+    state.goals = state.goals.filter((g) => !g.completedDate);
+    saveState(state);
+    return before - state.goals.length;
+}
+// === Daily stat recording ===
+export function recordDailyStat(stat) {
+    const state = loadState();
+    // Replace if same date exists, otherwise append
+    const idx = state.dailyStats.findIndex((s) => s.date === stat.date);
+    if (idx >= 0) {
+        state.dailyStats[idx] = stat;
+    }
+    else {
+        state.dailyStats.push(stat);
+    }
+    // Keep last 30 days
+    if (state.dailyStats.length > 30) {
+        state.dailyStats = state.dailyStats.slice(-30);
+    }
+    saveState(state);
+}

package/dist/src/types.d.ts

@@ -46,6 +46,20 @@ export interface StoredInsight extends Insight {
     date: string;
     rating: "helpful" | "not_helpful" | null;
 }
+export interface Goal {
+    id: number;
+    text: string;
+    createdDate: string;
+    completedDate: string | null;
+}
+export interface DailyStat {
+    date: string;
+    sessions: number;
+    prompts: number;
+    tokens: number;
+    projects: string[];
+    toolCalls: number;
+}
 export interface CoachState {
     streak: number;
     lastRunDate: string | null;
@@ -53,7 +67,8 @@ export interface CoachState {
     totalInsights: number;
     helpfulCount: number;
     notHelpfulCount: number;
-    apiKey?: string;
+    goals: Goal[];
+    dailyStats: DailyStat[];
 }
 export interface HistoryEntry {
     display: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pkprosol/coach",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Daily AI work coach — analyzes your Claude Code & Claude App sessions to deliver one lesson + one tip daily",
   "type": "module",
   "bin": {
@@ -30,7 +30,6 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.39.0",
     "chalk": "^5.4.1",
     "ora": "^8.2.0"
   },