@pkprosol/coach 1.0.0

package/README.md

@@ -0,0 +1,79 @@
+# 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.
+
+```
+┌──────────────────────────────────────────────────┐
+│  COACH                               Day 12 🔥   │
+├──────────────────────────────────────────────────┤
+│                                                  │
+│  TODAY'S LENS: Prompting Craft                   │
+│                                                  │
+│  📖 LESSON                                       │
+│  Your prompts today started broad and required   │
+│  3-4 clarification rounds...                     │
+│                                                  │
+│  💡 TIP                                          │
+│  Try the 'Context-Task-Format' frame...          │
+│                                                  │
+│  🌱 Your afternoon sessions showed much tighter  │
+│  prompting — you're already improving.           │
+│                                                  │
+├──────────────────────────────────────────────────┤
+│  Was this helpful?  [y] Yes  [n] No              │
+└──────────────────────────────────────────────────┘
+```
+
+## Install
+
+```bash
+npm install -g @pkprosol/coach
+```
+
+This installs the `coach` CLI and auto-registers `/coach` as a slash command in Claude Code.
+
+## Setup
+
+```bash
+coach setup   # paste your Anthropic API key
+```
+
+Or set `ANTHROPIC_API_KEY` in your environment.
+
+## Usage
+
+### Terminal
+```bash
+coach            # today's lesson + tip
+coach streak     # current streak + stats
+coach history    # browse past insights
+```
+
+### Claude Code
+```
+/coach           # same thing, right inside Claude
+/coach streak
+/coach history
+```
+
+## How it works
+
+1. **Collects** today's session data from `~/.claude/` (Claude Code) and `~/Library/Application Support/Claude/` (Claude App)
+2. **Analyzes** your prompts, workflow patterns, and tool usage through a rotating lens (8 dimensions: prompting craft, workflow efficiency, architecture thinking, etc.)
+3. **Delivers** one specific lesson + one actionable tip, with examples from your actual sessions
+4. **Learns** from your ratings to improve future insights
+
+## Data sources
+
+| Source | Location | What's collected |
+|--------|----------|-----------------|
+| 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

package/dist/bin/coach.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/coach.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+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";
+function askQuestion(prompt) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            rl.close();
+            resolve(answer.trim().toLowerCase());
+        });
+    });
+}
+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();
+    if (data.prompts.length === 0) {
+        spinner.stop();
+        console.log(renderNoData());
+        return;
+    }
+    spinner.text = `Found ${data.prompts.length} prompts across ${data.sessions.length} sessions. Analyzing...`;
+    // Load state and past insights
+    let state = loadState();
+    const pastInsights = loadInsights();
+    // Analyze
+    let insight;
+    try {
+        insight = await analyze(data, state.recentDimensions, pastInsights, apiKey);
+    }
+    catch (err) {
+        spinner.stop();
+        if (err.status === 401) {
+            console.log(renderError("Invalid API key. Run `coach setup` to update it."));
+        }
+        else {
+            console.log(renderError(err.message ?? "Analysis failed."));
+        }
+        return;
+    }
+    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
+    console.log("");
+    console.log(renderInsight(insight, state));
+    console.log("");
+    // Save insight (without rating yet)
+    const storedInsight = {
+        ...insight,
+        date: today,
+        rating: null,
+    };
+    appendInsight(storedInsight);
+    // Ask for rating (only in interactive terminal)
+    if (process.stdin.isTTY) {
+        const answer = await askQuestion("  ");
+        if (answer === "y" || answer === "yes") {
+            state.helpfulCount++;
+            updateLastInsightRating("helpful");
+            console.log(chalk.green("\n  Thanks! Noted for tomorrow. 🙌\n"));
+        }
+        else if (answer === "n" || answer === "no") {
+            state.notHelpfulCount++;
+            updateLastInsightRating("not_helpful");
+            console.log(chalk.dim("\n  Got it — will adjust. Thanks for the feedback.\n"));
+        }
+        else {
+            console.log(chalk.dim("\n  Skipped. See you tomorrow!\n"));
+        }
+    }
+    saveState(state);
+}
+function handleStreakCmd() {
+    const state = loadState();
+    console.log("");
+    console.log(renderStreak(state));
+    console.log("");
+}
+function handleHistoryCmd() {
+    const insights = loadInsights();
+    console.log("");
+    console.log(renderHistory(insights));
+    console.log("");
+}
+function handleRate(value) {
+    const state = loadState();
+    if (value === "y" || value === "yes") {
+        state.helpfulCount++;
+        updateLastInsightRating("helpful");
+        saveState(state);
+        console.log(chalk.green("  Thanks! Noted for tomorrow. 🙌"));
+    }
+    else if (value === "n" || value === "no") {
+        state.notHelpfulCount++;
+        updateLastInsightRating("not_helpful");
+        saveState(state);
+        console.log(chalk.dim("  Got it — will adjust. Thanks for the feedback."));
+    }
+    else {
+        console.log(renderError("Usage: coach rate y|n"));
+    }
+}
+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 history    Browse past insights
+  coach streak     Show current streak + stats
+  coach help       Show this help message
+`);
+}
+// --- Main ---
+const command = process.argv[2];
+switch (command) {
+    case "setup":
+        handleSetup();
+        break;
+    case "history":
+        handleHistoryCmd();
+        break;
+    case "streak":
+        handleStreakCmd();
+        break;
+    case "rate":
+        handleRate(process.argv[3] ?? "");
+        break;
+    case "help":
+    case "--help":
+    case "-h":
+        handleHelp();
+        break;
+    default:
+        handleDefault();
+        break;
+}

package/dist/postinstall.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/postinstall.js

@@ -0,0 +1,43 @@
+import { mkdirSync, writeFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+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
+disable-model-invocation: true
+user-invocable: true
+---
+
+Run the Coach CLI tool to analyze today's Claude usage and deliver a personalized insight.
+
+Execute this command and display the output exactly as-is to the user (it contains formatted terminal UI):
+
+\`\`\`bash
+coach
+\`\`\`
+
+After showing the output, 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"))) {
+        // Claude Code not installed — skip skill setup silently
+        process.exit(0);
+    }
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(skillFile, SKILL_CONTENT);
+    console.log("✓ Installed /coach command for Claude Code");
+}
+catch {
+    // Non-fatal — coach CLI still works without the skill
+    console.log("Note: Could not install /coach skill (coach CLI still works via `coach` command)");
+}

package/dist/src/analyzer.d.ts

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

package/dist/src/analyzer.js

@@ -0,0 +1,137 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { DIMENSIONS } from "./types.js";
+function pickDimension(recentDimensions, data) {
+    // Filter out recently used dimensions
+    const available = DIMENSIONS.filter((d) => !recentDimensions.includes(d));
+    const pool = available.length > 0 ? available : [...DIMENSIONS];
+    // Heuristic: pick the most relevant dimension for today's data
+    // Weight based on data signals
+    const scores = new Map();
+    for (const d of pool) {
+        scores.set(d, Math.random()); // Base randomness
+    }
+    const avgPromptsPerSession = data.sessions.length > 0
+        ? data.prompts.length / data.sessions.length
+        : data.prompts.length;
+    // Boost relevant dimensions based on data patterns
+    if (avgPromptsPerSession > 8) {
+        scores.set("Prompting Craft", (scores.get("Prompting Craft") ?? 0) + 2);
+        scores.set("Workflow Efficiency", (scores.get("Workflow Efficiency") ?? 0) + 1);
+    }
+    if (data.projectsWorkedOn.length > 2) {
+        scores.set("Focus & Deep Work", (scores.get("Focus & Deep Work") ?? 0) + 2);
+    }
+    if (data.totalToolCalls > 20) {
+        scores.set("Tool Leverage", (scores.get("Tool Leverage") ?? 0) + 1.5);
+    }
+    if (data.sessions.length === 1 && data.prompts.length > 5) {
+        scores.set("Problem Decomposition", (scores.get("Problem Decomposition") ?? 0) + 1.5);
+    }
+    // Pick highest scoring available dimension
+    let best = pool[0];
+    let bestScore = -1;
+    for (const [dim, score] of scores) {
+        if (pool.includes(dim) && score > bestScore) {
+            best = dim;
+            bestScore = score;
+        }
+    }
+    return best;
+}
+function buildPrompt(data, dimension, pastInsights) {
+    // Truncate prompts to avoid overwhelming context
+    const samplePrompts = data.prompts.slice(0, 40).map((p) => ({
+        text: p.text.slice(0, 500),
+        project: p.project,
+        sessionId: p.sessionId.slice(0, 8),
+    }));
+    const sessionSummaries = data.sessions.map((s) => ({
+        project: s.project,
+        messages: s.messageCount,
+        userMessages: s.userMessageCount,
+        toolCalls: s.toolCallCount,
+        tools: s.toolNames,
+        tokens: s.inputTokens + s.outputTokens,
+        duration: s.startTime && s.endTime
+            ? `${Math.round((new Date(s.endTime).getTime() - new Date(s.startTime).getTime()) / 60000)}min`
+            : "unknown",
+        branch: s.gitBranch,
+    }));
+    // Include recent past insights for context
+    const recentRated = pastInsights
+        .filter((i) => i.rating !== null)
+        .slice(-5)
+        .map((i) => ({
+        dimension: i.dimension,
+        rating: i.rating,
+        date: i.date,
+    }));
+    return `You are Coach, a personal AI work coach that analyzes a developer's Claude Code usage patterns to deliver one actionable lesson and one practical tip.
+
+## Today's Analysis Dimension: ${dimension}
+
+Dimension descriptions:
+- Prompting Craft: clarity, specificity, effectiveness of the user's prompts
+- Workflow Efficiency: circular patterns, redundant requests, wasted effort
+- Architecture Thinking: over/under-engineering signals in what the user asks for
+- Learning Patterns: building knowledge vs re-learning the same things
+- Focus & Deep Work: context switching vs sustained depth
+- 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
+
+## Today's Session Data
+
+Date: ${data.date}
+Projects worked on: ${data.projectsWorkedOn.join(", ")}
+Total sessions: ${data.sessions.length}
+Total messages: ${data.totalMessages}
+Total tool calls: ${data.totalToolCalls}
+Total tokens: ${data.totalTokens.toLocaleString()}
+
+### User Prompts (chronological)
+${JSON.stringify(samplePrompts, null, 2)}
+
+### Session Summaries
+${JSON.stringify(sessionSummaries, null, 2)}
+
+${recentRated.length > 0 ? `### Past Insight Ratings (for context on what the user finds helpful)
+${JSON.stringify(recentRated, null, 2)}` : ""}
+
+## Your Task
+
+Analyze the data through the lens of "${dimension}" and return a JSON object with exactly these fields:
+
+{
+  "dimension": "${dimension}",
+  "lesson": "A specific, data-backed observation about today's work (2-3 sentences). Reference actual prompts or patterns you see.",
+  "tip": "One concrete, actionable technique they can try tomorrow (2-3 sentences). Be specific with a method or framework.",
+  "specificExample": { "before": "An actual prompt from today (or close paraphrase)", "after": "A rewritten version applying your tip" } or null if not applicable,
+  "encouragement": "One sentence noting something they did well today. Be genuine — find something real."
+}
+
+Guidelines:
+- Be specific. Reference actual data from the session — prompt text, project names, patterns.
+- The lesson should feel like a personal discovery, not generic advice.
+- The tip should be immediately actionable tomorrow.
+- If the specificExample doesn't make sense for this dimension, set it to null.
+- Keep the encouragement genuine and grounded in their actual work.
+- Total response should feel insightful but concise.
+
+Respond with ONLY the JSON object, no markdown fences or other text.`;
+}
+export async function analyze(data, recentDimensions, pastInsights, apiKey) {
+    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 : "";
+    // Parse JSON from response — handle possible markdown fences
+    const cleaned = text.replace(/^```json?\s*/, "").replace(/\s*```$/, "").trim();
+    const result = JSON.parse(cleaned);
+    return result;
+}

package/dist/src/collector.d.ts

@@ -0,0 +1,2 @@
+import type { CollectedData } from "./types.js";
+export declare function collectToday(dateOverride?: string): CollectedData;

package/dist/src/collector.js

@@ -0,0 +1,315 @@
+import { readFileSync, readdirSync, existsSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, basename } from "node:path";
+const CLAUDE_DIR = join(homedir(), ".claude");
+const HISTORY_FILE = join(CLAUDE_DIR, "history.jsonl");
+const PROJECTS_DIR = join(CLAUDE_DIR, "projects");
+const DESKTOP_SESSIONS_DIR = join(homedir(), "Library", "Application Support", "Claude", "local-agent-mode-sessions");
+function readJsonl(path) {
+    if (!existsSync(path))
+        return [];
+    const raw = readFileSync(path, "utf-8").trim();
+    if (!raw)
+        return [];
+    const items = [];
+    for (const line of raw.split("\n")) {
+        try {
+            items.push(JSON.parse(line));
+        }
+        catch {
+            // Skip malformed lines
+        }
+    }
+    return items;
+}
+function toLocalDateStr(date) {
+    return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+}
+function localToday() {
+    return toLocalDateStr(new Date());
+}
+function isSameDay(timestamp, targetDate) {
+    const date = new Date(timestamp);
+    return toLocalDateStr(date) === targetDate;
+}
+function extractProjectName(projectPath) {
+    return basename(projectPath);
+}
+// =============================================
+// Claude Code collection
+// =============================================
+function collectCodePrompts(today) {
+    const entries = readJsonl(HISTORY_FILE);
+    const prompts = [];
+    for (const entry of entries) {
+        if (isSameDay(entry.timestamp, today)) {
+            prompts.push({
+                text: entry.display,
+                timestamp: new Date(entry.timestamp).toISOString(),
+                sessionId: entry.sessionId,
+                project: extractProjectName(entry.project),
+            });
+        }
+    }
+    return prompts;
+}
+function findCodeSessionFiles(_today, sessionIds) {
+    const files = [];
+    if (!existsSync(PROJECTS_DIR))
+        return files;
+    for (const projectDir of readdirSync(PROJECTS_DIR)) {
+        const projectPath = join(PROJECTS_DIR, projectDir);
+        let entries;
+        try {
+            entries = readdirSync(projectPath);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.endsWith(".jsonl"))
+                continue;
+            const sessionId = entry.replace(".jsonl", "");
+            if (sessionIds.has(sessionId)) {
+                files.push(join(projectPath, entry));
+            }
+        }
+    }
+    return files;
+}
+function parseCodeSessionFile(filePath, today) {
+    const messages = readJsonl(filePath);
+    if (messages.length === 0)
+        return null;
+    let userCount = 0;
+    let assistantCount = 0;
+    let toolCallCount = 0;
+    const toolNames = new Set();
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let startTime = "";
+    let endTime = "";
+    let sessionId = "";
+    let project = "";
+    let gitBranch;
+    for (const msg of messages) {
+        if (msg.type === "file-history-snapshot")
+            continue;
+        if (!msg.timestamp || !isSameDay(msg.timestamp, today))
+            continue;
+        if (!startTime || msg.timestamp < startTime)
+            startTime = msg.timestamp;
+        if (!endTime || msg.timestamp > endTime)
+            endTime = msg.timestamp;
+        if (msg.sessionId)
+            sessionId = msg.sessionId;
+        if (msg.gitBranch)
+            gitBranch = msg.gitBranch;
+        if (msg.cwd)
+            project = extractProjectName(msg.cwd);
+        if (msg.type === "user") {
+            userCount++;
+        }
+        else if (msg.type === "assistant") {
+            assistantCount++;
+            if (msg.message?.usage) {
+                inputTokens += msg.message.usage.input_tokens || 0;
+                outputTokens += msg.message.usage.output_tokens || 0;
+            }
+            if (Array.isArray(msg.message?.content)) {
+                for (const block of msg.message.content) {
+                    if (block.type === "tool_use" && block.name) {
+                        toolCallCount++;
+                        toolNames.add(block.name);
+                    }
+                }
+            }
+        }
+    }
+    if (userCount === 0 && assistantCount === 0)
+        return null;
+    return {
+        sessionId,
+        project,
+        source: "claude-code",
+        messageCount: userCount + assistantCount,
+        userMessageCount: userCount,
+        assistantMessageCount: assistantCount,
+        toolCallCount,
+        toolNames: [...toolNames],
+        inputTokens,
+        outputTokens,
+        startTime,
+        endTime,
+        gitBranch,
+    };
+}
+function collectCodeSessions(today) {
+    const prompts = collectCodePrompts(today);
+    const sessionIds = new Set(prompts.map((p) => p.sessionId));
+    const sessionFiles = findCodeSessionFiles(today, sessionIds);
+    const sessions = [];
+    for (const file of sessionFiles) {
+        const summary = parseCodeSessionFile(file, today);
+        if (summary)
+            sessions.push(summary);
+    }
+    return { prompts, sessions };
+}
+// =============================================
+// Claude Desktop App collection
+// =============================================
+function findDesktopAuditFiles() {
+    const results = [];
+    if (!existsSync(DESKTOP_SESSIONS_DIR))
+        return results;
+    try {
+        // Traverse: workspace-id / user-id / local_session-id/audit.jsonl
+        for (const workspace of readdirSync(DESKTOP_SESSIONS_DIR)) {
+            const wsPath = join(DESKTOP_SESSIONS_DIR, workspace);
+            if (!statSync(wsPath).isDirectory())
+                continue;
+            for (const userId of readdirSync(wsPath)) {
+                const userPath = join(wsPath, userId);
+                if (!statSync(userPath).isDirectory())
+                    continue;
+                for (const entry of readdirSync(userPath)) {
+                    // Session directories are named like local_<uuid>
+                    const sessionDir = join(userPath, entry);
+                    if (!entry.startsWith("local_") || !statSync(sessionDir).isDirectory())
+                        continue;
+                    const auditPath = join(sessionDir, "audit.jsonl");
+                    const metaPath = join(userPath, entry + ".json");
+                    if (existsSync(auditPath)) {
+                        results.push({ auditPath, metaPath });
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Gracefully handle permission errors etc.
+    }
+    return results;
+}
+function parseDesktopSession(auditPath, metaPath, today) {
+    const entries = readJsonl(auditPath);
+    const prompts = [];
+    // Read session metadata for title
+    let title = "Claude App";
+    let sessionId = "";
+    if (existsSync(metaPath)) {
+        try {
+            const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
+            title = meta.title || "Claude App";
+            sessionId = meta.sessionId || "";
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    let userCount = 0;
+    let assistantCount = 0;
+    let toolCallCount = 0;
+    const toolNames = new Set();
+    let startTime = "";
+    let endTime = "";
+    let hasTodayMessages = false;
+    for (const entry of entries) {
+        if (!entry._audit_timestamp || !isSameDay(entry._audit_timestamp, today))
+            continue;
+        hasTodayMessages = true;
+        if (!startTime || entry._audit_timestamp < startTime)
+            startTime = entry._audit_timestamp;
+        if (!endTime || entry._audit_timestamp > endTime)
+            endTime = entry._audit_timestamp;
+        if (!sessionId && entry.session_id)
+            sessionId = entry.session_id;
+        if (entry.type === "user") {
+            userCount++;
+            const text = typeof entry.message?.content === "string"
+                ? entry.message.content
+                : Array.isArray(entry.message?.content)
+                    ? entry.message.content
+                        .filter((b) => b.type === "text" && b.text)
+                        .map((b) => b.text)
+                        .join(" ")
+                    : "";
+            if (text) {
+                prompts.push({
+                    text,
+                    timestamp: entry._audit_timestamp,
+                    sessionId: sessionId || entry.session_id,
+                    project: `[App] ${title}`,
+                });
+            }
+        }
+        else if (entry.type === "assistant") {
+            assistantCount++;
+            // Count tool_use blocks in assistant messages
+            if (Array.isArray(entry.message?.content)) {
+                for (const block of entry.message.content) {
+                    if (block.type === "tool_use" && block.name) {
+                        toolCallCount++;
+                        toolNames.add(block.name);
+                    }
+                }
+            }
+        }
+    }
+    if (!hasTodayMessages) {
+        return { prompts: [], session: null };
+    }
+    const session = {
+        sessionId,
+        project: `[App] ${title}`,
+        source: "claude-app",
+        messageCount: userCount + assistantCount,
+        userMessageCount: userCount,
+        assistantMessageCount: assistantCount,
+        toolCallCount,
+        toolNames: [...toolNames],
+        inputTokens: 0, // Not available in audit logs
+        outputTokens: 0,
+        startTime,
+        endTime,
+    };
+    return { prompts, session };
+}
+function collectDesktopSessions(today) {
+    const auditFiles = findDesktopAuditFiles();
+    const prompts = [];
+    const sessions = [];
+    for (const { auditPath, metaPath } of auditFiles) {
+        const result = parseDesktopSession(auditPath, metaPath, today);
+        prompts.push(...result.prompts);
+        if (result.session && result.session.messageCount > 0) {
+            sessions.push(result.session);
+        }
+    }
+    return { prompts, sessions };
+}
+// =============================================
+// Combined collector
+// =============================================
+export function collectToday(dateOverride) {
+    const today = dateOverride ?? localToday();
+    // Collect from both sources
+    const code = collectCodeSessions(today);
+    const desktop = collectDesktopSessions(today);
+    const prompts = [...code.prompts, ...desktop.prompts].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    const sessions = [...code.sessions, ...desktop.sessions];
+    const totalTokens = sessions.reduce((s, sess) => s + sess.inputTokens + sess.outputTokens, 0);
+    const totalMessages = sessions.reduce((s, sess) => s + sess.messageCount, 0);
+    const totalToolCalls = sessions.reduce((s, sess) => s + sess.toolCallCount, 0);
+    const projectsWorkedOn = [...new Set(prompts.map((p) => p.project))];
+    return {
+        date: today,
+        prompts,
+        sessions,
+        totalTokens,
+        totalMessages,
+        totalToolCalls,
+        projectsWorkedOn,
+    };
+}

package/dist/src/display.d.ts

@@ -0,0 +1,7 @@
+import type { Insight, CoachState, StoredInsight } 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;

package/dist/src/display.js

@@ -0,0 +1,139 @@
+import chalk from "chalk";
+const WIDTH = 50;
+function hr() {
+    return chalk.dim("─".repeat(WIDTH));
+}
+function boxTop() {
+    return chalk.dim("┌" + "─".repeat(WIDTH) + "┐");
+}
+function boxBot() {
+    return chalk.dim("└" + "─".repeat(WIDTH) + "┘");
+}
+function boxMid() {
+    return chalk.dim("├" + "─".repeat(WIDTH) + "┤");
+}
+function padLine(text) {
+    return chalk.dim("│") + " " + text;
+}
+function wrapText(text, maxWidth) {
+    const words = text.split(" ");
+    const lines = [];
+    let current = "";
+    for (const word of words) {
+        if (current.length + word.length + 1 > maxWidth) {
+            lines.push(current);
+            current = word;
+        }
+        else {
+            current = current ? current + " " + word : word;
+        }
+    }
+    if (current)
+        lines.push(current);
+    return lines;
+}
+function renderSection(label, body) {
+    const lines = [];
+    lines.push(padLine(""));
+    lines.push(padLine(chalk.bold(label)));
+    for (const line of wrapText(body, WIDTH - 4)) {
+        lines.push(padLine("  " + line));
+    }
+    return lines;
+}
+export function renderInsight(insight, state) {
+    const out = [];
+    // Header
+    out.push(boxTop());
+    const streakStr = state.streak > 0 ? `Day ${state.streak} ${state.streak >= 3 ? "🔥" : ""}` : "Day 1";
+    const header = `  COACH`;
+    const headerRight = streakStr;
+    const padding = WIDTH - header.length - headerRight.length - 1;
+    out.push(padLine(chalk.bold.white(header) + " ".repeat(Math.max(1, padding)) + chalk.yellow(headerRight)));
+    out.push(boxMid());
+    // Dimension
+    out.push(padLine(""));
+    out.push(padLine(chalk.cyan.bold(`  TODAY'S LENS: ${insight.dimension}`)));
+    // Lesson
+    out.push(...renderSection("  📖 LESSON", insight.lesson));
+    // Tip
+    out.push(...renderSection("  💡 TIP", insight.tip));
+    // Specific example
+    if (insight.specificExample) {
+        out.push(padLine(""));
+        out.push(padLine(chalk.bold("  ✦ BEFORE (your prompt):")));
+        for (const line of wrapText(insight.specificExample.before, WIDTH - 6)) {
+            out.push(padLine(chalk.dim("    " + line)));
+        }
+        out.push(padLine(""));
+        out.push(padLine(chalk.bold("  ✦ AFTER (try this):")));
+        for (const line of wrapText(insight.specificExample.after, WIDTH - 6)) {
+            out.push(padLine(chalk.green("    " + line)));
+        }
+    }
+    // Encouragement
+    out.push(padLine(""));
+    out.push(padLine("  🌱 " + chalk.italic(insight.encouragement)));
+    // Footer
+    out.push(padLine(""));
+    out.push(boxMid());
+    out.push(padLine(chalk.dim("  Was this helpful?  ") + chalk.bold("[y]") + " Yes  " + chalk.bold("[n]") + " No"));
+    out.push(boxBot());
+    return out.join("\n");
+}
+export function renderStreak(state) {
+    const out = [];
+    out.push(boxTop());
+    out.push(padLine(chalk.bold.white("  COACH STATS")));
+    out.push(boxMid());
+    out.push(padLine(""));
+    out.push(padLine(`  🔥 Current streak: ${chalk.bold.yellow(String(state.streak))} days`));
+    out.push(padLine(`  📊 Total insights: ${chalk.bold(String(state.totalInsights))}`));
+    if (state.totalInsights > 0) {
+        const helpfulPct = Math.round((state.helpfulCount / state.totalInsights) * 100);
+        out.push(padLine(`  👍 Helpful rate: ${chalk.bold.green(helpfulPct + "%")} (${state.helpfulCount}/${state.totalInsights})`));
+    }
+    out.push(padLine(`  📅 Last run: ${state.lastRunDate ?? "never"}`));
+    out.push(padLine(""));
+    out.push(boxBot());
+    return out.join("\n");
+}
+export function renderHistory(insights) {
+    if (insights.length === 0) {
+        return chalk.dim("No insights yet. Run `coach` to get your first one!");
+    }
+    const out = [];
+    out.push(boxTop());
+    out.push(padLine(chalk.bold.white("  PAST INSIGHTS")));
+    out.push(boxMid());
+    // Show last 10
+    const recent = insights.slice(-10).reverse();
+    for (const insight of recent) {
+        const ratingIcon = insight.rating === "helpful"
+            ? chalk.green("👍")
+            : insight.rating === "not_helpful"
+                ? chalk.red("👎")
+                : chalk.dim("--");
+        out.push(padLine(""));
+        out.push(padLine(`  ${chalk.dim(insight.date)}  ${chalk.cyan(insight.dimension)}  ${ratingIcon}`));
+        const preview = insight.lesson.slice(0, WIDTH - 8);
+        out.push(padLine(chalk.dim(`    ${preview}...`)));
+    }
+    out.push(padLine(""));
+    out.push(boxBot());
+    if (insights.length > 10) {
+        out.push(chalk.dim(`  Showing last 10 of ${insights.length} 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" +
+        chalk.dim("Use Claude Code throughout the day, then run `coach` in the evening for your daily insight.");
+}
+export function renderError(msg) {
+    return chalk.red("Error: ") + msg;
+}

package/dist/src/storage.d.ts

@@ -0,0 +1,10 @@
+import type { CoachState, StoredInsight } 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;

package/dist/src/storage.js

@@ -0,0 +1,91 @@
+import { mkdirSync, readFileSync, writeFileSync, existsSync, appendFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const COACH_DIR = join(homedir(), ".coach");
+const STATE_FILE = join(COACH_DIR, "state.json");
+const INSIGHTS_FILE = join(COACH_DIR, "insights.jsonl");
+function ensureDir() {
+    if (!existsSync(COACH_DIR)) {
+        mkdirSync(COACH_DIR, { recursive: true });
+    }
+}
+const DEFAULT_STATE = {
+    streak: 0,
+    lastRunDate: null,
+    recentDimensions: [],
+    totalInsights: 0,
+    helpfulCount: 0,
+    notHelpfulCount: 0,
+};
+export function loadState() {
+    ensureDir();
+    if (!existsSync(STATE_FILE)) {
+        return { ...DEFAULT_STATE };
+    }
+    const raw = readFileSync(STATE_FILE, "utf-8");
+    return 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
+    }
+    const yesterday = new Date(today);
+    yesterday.setDate(yesterday.getDate() - 1);
+    const yesterdayStr = yesterday.toISOString().slice(0, 10);
+    if (state.lastRunDate === yesterdayStr) {
+        state.streak += 1;
+    }
+    else if (state.lastRunDate === null) {
+        state.streak = 1;
+    }
+    else {
+        state.streak = 1; // Streak broken, restart
+    }
+    state.lastRunDate = today;
+    return state;
+}
+export function recordDimension(state, dimension) {
+    state.recentDimensions.push(dimension);
+    // Keep only last 4 to ensure rotation
+    if (state.recentDimensions.length > 4) {
+        state.recentDimensions = state.recentDimensions.slice(-4);
+    }
+    state.totalInsights += 1;
+    return state;
+}
+export function appendInsight(insight) {
+    ensureDir();
+    appendFileSync(INSIGHTS_FILE, JSON.stringify(insight) + "\n");
+}
+export function loadInsights() {
+    ensureDir();
+    if (!existsSync(INSIGHTS_FILE)) {
+        return [];
+    }
+    const raw = readFileSync(INSIGHTS_FILE, "utf-8").trim();
+    if (!raw)
+        return [];
+    return raw.split("\n").map((line) => JSON.parse(line));
+}
+export function updateLastInsightRating(rating) {
+    const insights = loadInsights();
+    if (insights.length === 0)
+        return;
+    insights[insights.length - 1].rating = rating;
+    // Rewrite entire file
+    ensureDir();
+    writeFileSync(INSIGHTS_FILE, insights.map((i) => JSON.stringify(i)).join("\n") + "\n");
+}

package/dist/src/types.d.ts

@@ -0,0 +1,109 @@
+export declare const DIMENSIONS: readonly ["Prompting Craft", "Workflow Efficiency", "Architecture Thinking", "Learning Patterns", "Focus & Deep Work", "Communication Style", "Tool Leverage", "Problem Decomposition"];
+export type Dimension = (typeof DIMENSIONS)[number];
+export interface UserPrompt {
+    text: string;
+    timestamp: string;
+    sessionId: string;
+    project: string;
+}
+export type SessionSource = "claude-code" | "claude-app";
+export interface SessionSummary {
+    sessionId: string;
+    project: string;
+    source: SessionSource;
+    messageCount: number;
+    userMessageCount: number;
+    assistantMessageCount: number;
+    toolCallCount: number;
+    toolNames: string[];
+    inputTokens: number;
+    outputTokens: number;
+    startTime: string;
+    endTime: string;
+    gitBranch?: string;
+}
+export interface CollectedData {
+    date: string;
+    prompts: UserPrompt[];
+    sessions: SessionSummary[];
+    totalTokens: number;
+    totalMessages: number;
+    totalToolCalls: number;
+    projectsWorkedOn: string[];
+}
+export interface SpecificExample {
+    before: string;
+    after: string;
+}
+export interface Insight {
+    dimension: Dimension;
+    lesson: string;
+    tip: string;
+    specificExample: SpecificExample | null;
+    encouragement: string;
+}
+export interface StoredInsight extends Insight {
+    date: string;
+    rating: "helpful" | "not_helpful" | null;
+}
+export interface CoachState {
+    streak: number;
+    lastRunDate: string | null;
+    recentDimensions: Dimension[];
+    totalInsights: number;
+    helpfulCount: number;
+    notHelpfulCount: number;
+    apiKey?: string;
+}
+export interface HistoryEntry {
+    display: string;
+    pastedContents: Record<string, unknown>;
+    timestamp: number;
+    project: string;
+    sessionId: string;
+}
+export interface ConversationMessage {
+    type: "user" | "assistant" | "file-history-snapshot";
+    sessionId?: string;
+    timestamp?: string;
+    cwd?: string;
+    gitBranch?: string;
+    message?: {
+        role: string;
+        content: string | ContentBlock[];
+        usage?: TokenUsage;
+    };
+}
+export interface ContentBlock {
+    type: string;
+    text?: string;
+    thinking?: string;
+    name?: string;
+    input?: unknown;
+}
+export interface TokenUsage {
+    input_tokens: number;
+    output_tokens: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
+}
+export interface DesktopSessionMeta {
+    sessionId: string;
+    title: string;
+    model: string;
+    initialMessage: string;
+    createdAt: number;
+    lastActivityAt: number;
+    cwd?: string;
+}
+export interface AuditEntry {
+    type: "user" | "assistant" | "tool" | "tool_result";
+    uuid: string;
+    session_id: string;
+    parent_tool_use_id: string | null;
+    message: {
+        role: string;
+        content: string | ContentBlock[];
+    };
+    _audit_timestamp: string;
+}

package/dist/src/types.js

@@ -0,0 +1,11 @@
+// === Analysis Dimensions ===
+export const DIMENSIONS = [
+    "Prompting Craft",
+    "Workflow Efficiency",
+    "Architecture Thinking",
+    "Learning Patterns",
+    "Focus & Deep Work",
+    "Communication Style",
+    "Tool Leverage",
+    "Problem Decomposition",
+];

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@pkprosol/coach",
+  "version": "1.0.0",
+  "description": "Daily AI work coach — analyzes your Claude Code & Claude App sessions to deliver one lesson + one tip daily",
+  "type": "module",
+  "bin": {
+    "coach": "./dist/bin/coach.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "postinstall": "node dist/postinstall.js || true"
+  },
+  "files": [
+    "dist",
+    "skill"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "coach",
+    "productivity",
+    "developer-tools",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pkprosol/coach"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.39.0",
+    "chalk": "^5.4.1",
+    "ora": "^8.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  }
+}