vibe-academy-cli 1.0.0

package/templates/.claude/scripts/hook-post-file.ts

@@ -0,0 +1,162 @@
+#!/usr/bin/env bun
+// @ts-nocheck
+
+interface HookInput {
+  session_id: string;
+  transcript_path: string;
+  cwd: string;
+  hook_event_name: string;
+  tool_name: string;
+  tool_input: {
+    file_path: string;
+    content: string;
+  };
+  tool_response: {
+    filePath: string;
+    success: boolean;
+  };
+}
+
+interface HookOutput {
+  hookSpecificOutput: {
+    hookEventName: string;
+    additionalContext: string;
+  };
+}
+
+// Check for debug mode
+const DEBUG = process.argv.includes("--debug");
+
+function log(message: string, ...args: unknown[]) {
+  if (DEBUG) {
+    console.log(message, ...args);
+  }
+}
+
+async function runCommand(
+  command: string[],
+): Promise<{ stdout: string; stderr: string; success: boolean }> {
+  try {
+    const proc = Bun.spawn(command, {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const success = (await proc.exited) === 0;
+
+    return { stdout, stderr, success };
+  } catch (error) {
+    return { stdout: "", stderr: String(error), success: false };
+  }
+}
+
+async function main() {
+  log("Hook started for file processing");
+
+  // Lire l'input JSON depuis stdin
+  const input = await Bun.stdin.text();
+  log("Input received, length:", input.length);
+
+  let hookData: HookInput;
+  try {
+    hookData = JSON.parse(input);
+  } catch (error) {
+    log("Error parsing JSON input:", error);
+    process.exit(0);
+  }
+
+  const filePath = hookData.tool_input?.file_path;
+  if (!filePath) {
+    log("Unable to extract file path from input");
+    process.exit(0);
+  }
+
+  // Vérifier que c'est un fichier .ts ou .tsx uniquement
+  if (!filePath.endsWith(".ts") && !filePath.endsWith(".tsx")) {
+    log(`Skipping ${filePath}: not a TypeScript file`);
+    process.exit(0);
+  }
+
+  log("Processing file:", filePath);
+
+  // Vérifier que le fichier existe
+  const file = Bun.file(filePath);
+  if (!(await file.exists())) {
+    log("File not found:", filePath);
+    process.exit(1);
+  }
+
+  // 1. Exécuter Prettier
+  log("Running Prettier formatting");
+  const prettierResult = await runCommand([
+    "bun",
+    "x",
+    "prettier",
+    "--write",
+    filePath,
+  ]);
+  if (!prettierResult.success) {
+    log("Prettier failed:", prettierResult.stderr);
+  }
+
+  // 2. ESLint --fix
+  log("Running ESLint --fix");
+  await runCommand(["bun", "x", "eslint", "--fix", filePath]);
+
+  // 3. Run ESLint check and TypeScript check in parallel
+  log("Running ESLint and TypeScript checks in parallel");
+  const [eslintCheckResult, tscResult] = await Promise.all([
+    runCommand(["bun", "x", "eslint", filePath]),
+    runCommand(["bun", "x", "tsc", "--noEmit", "--pretty", "false"]),
+  ]);
+
+  const eslintErrors = (
+    eslintCheckResult.stdout + eslintCheckResult.stderr
+  ).trim();
+
+  const tsErrors = tscResult.stderr
+    .split("\n")
+    .filter((line) => line.includes(filePath))
+    .join("\n");
+
+  // Construire le message d'erreurs
+  let errorMessage = "";
+
+  if (tsErrors || eslintErrors) {
+    errorMessage = `Fix NOW the following errors AND warning detected in ${filePath
+      .split("/")
+      .pop()}:\\n`;
+
+    if (tsErrors) {
+      errorMessage += `\\n TypeScript errors:\\n${tsErrors}\\n`;
+    }
+
+    if (eslintErrors) {
+      errorMessage += `\\n ESLint errors:\\n${eslintErrors}\\n`;
+    }
+  }
+
+  log("Error message", errorMessage);
+
+  // Sortir le résultat
+  if (errorMessage) {
+    const output: HookOutput = {
+      hookSpecificOutput: {
+        hookEventName: "PostToolUse",
+        additionalContext: errorMessage,
+      },
+    };
+
+    log("Output", JSON.stringify(output, null, 2));
+    console.log(JSON.stringify(output, null, 2));
+  } else {
+    console.error(`No errors detected in ${filePath.split("/").pop()}`);
+  }
+}
+
+main().catch((error) => {
+  log("Error in hook:", error);
+  process.exit(1);
+});

package/templates/.claude/scripts/statusline/CLAUDE.md

@@ -0,0 +1,178 @@
+# Claude Code Statusline - Project Memory
+
+## Overview
+
+Clean, type-safe statusline implementation for Claude Code using Bun + TypeScript. Displays real-time session information, git status, context usage, and Claude API rate limits.
+
+## Project Setup & Configuration
+
+### Dependencies
+- **Bun**: Runtime (uses `$` for shell commands)
+- **@biomejs/biome**: Linting & formatting
+- **TypeScript**: Type safety
+
+No external npm packages required - pure Bun APIs.
+
+### Configuration in Claude Code
+
+Add to `~/.claude/settings.json`:
+
+```json
+{
+  "statusLine": {
+    "type": "command",
+    "command": "bun /Users/melvynx/.claude/scripts/statusline/src/index.ts",
+    "padding": 0
+  }
+}
+```
+
+### Authentication
+
+OAuth token stored in macOS Keychain:
+- **Service**: `Claude Code-credentials`
+- **Format**: JSON with `claudeAiOauth.accessToken`
+- **Token type**: `sk-ant-oat01-...` (OAuth token, not API key)
+- **Access**: `security find-generic-password -s "Claude Code-credentials" -w`
+
+## Architecture
+
+### Modular Design
+
+The project follows a clean architecture with separated concerns:
+
+```
+src/
+├── index.ts              # Main entry - orchestrates all components
+└── lib/
+    ├── types.ts          # TypeScript interfaces (HookInput)
+    ├── git.ts            # Git operations (branch, changes)
+    ├── context.ts        # Transcript parsing & context calculation
+    ├── usage-limits.ts   # Claude OAuth API integration
+    └── formatters.ts     # Display utilities & colors
+```
+
+### Data Flow
+
+```
+Claude Code Hook → stdin JSON → index.ts
+                                    ↓
+                    ┌───────────────┴───────────────┐
+                    ↓                               ↓
+            [Get Git Status]            [Get Context Data]
+                    ↓                               ↓
+            [Format Branch]             [Get Usage Limits]
+                    ↓                               ↓
+                    └───────────────┬───────────────┘
+                                    ↓
+                            [Build Output Lines]
+                                    ↓
+                            stdout (2 lines)
+```
+
+## Component Specifications
+
+### Context Calculation (`lib/context.ts`)
+- **Purpose**: Calculate token usage from Claude Code transcript files
+- **Algorithm**: Parses `.jsonl` transcript, finds most recent main-chain entry
+- **Tokens counted**: `input_tokens + cache_read_input_tokens + cache_creation_input_tokens`
+- **Excludes**: Sidechain entries (agent calls), API error messages
+- **Output**: `{ tokens: number, percentage: number }` (0-100% of 200k context)
+
+### Usage Limits (`lib/usage-limits.ts`)
+- **Purpose**: Fetch Claude API rate limits from OAuth endpoint
+- **Auth**: Retrieves OAuth token from macOS Keychain (`Claude Code-credentials`)
+- **API**: `https://api.anthropic.com/api/oauth/usage`
+- **Data**: Five-hour window utilization + reset time
+- **Error handling**: Fails silently, returns null on errors
+
+### Git Status (`lib/git.ts`)
+- **Purpose**: Show current branch and uncommitted changes
+- **Detection**: Checks both staged and unstaged changes
+- **Output**: Branch name + line additions/deletions
+- **Display**: `main* (+123 -45)` with color coding
+
+### Formatters (`lib/formatters.ts`)
+- **Colors**: ANSI color codes for terminal output
+- **Token display**: `62.5K`, `1.2M` format
+- **Time formatting**: `3h21m`, `45m` for countdowns
+- **Reset time**: Calculates difference between API reset time and now
+
+## Output Specification
+
+### Line 1: Session Info
+```
+main* (+123 -45) | ~/.claude | Sonnet 4.5
+```
+
+### Line 2: Metrics
+```
+$0.17 (6m) | 62.5K tokens | 31% | 15% (3h27m)
+```
+
+**Components:**
+- `$0.17` - Session cost (USD)
+- `(6m)` - Session duration
+- `62.5K tokens` - Context tokens used (from transcript)
+- `31%` - Context percentage (tokens / 200k)
+- `15%` - Five-hour usage (from Claude API)
+- `(3h27m)` - Time until rate limit resets
+
+## Development
+
+### Testing
+
+```bash
+# Run test with fixture
+bun run test
+
+# Use custom fixture
+bun run test fixtures/custom.json
+
+# Manual test
+echo '{ ... }' | bun run start
+```
+
+### Code Conventions
+
+- **ALWAYS** use camelCase for variables and functions
+- Use TypeScript strict mode
+- Follow Biome formatting rules
+
+### Error Handling & Performance
+
+**Error Handling** - All components fail silently:
+- Missing transcript → 0 tokens, 0%
+- API failure → No usage limits shown
+- Git errors → "no-git" branch
+- Keychain access denied → No usage limits
+
+This ensures statusline never crashes Claude Code.
+
+**Performance Benchmarks:**
+- Context calculation: ~10-50ms (depends on transcript size)
+- API call: ~100-300ms (cached by Claude API)
+- Git operations: ~20-50ms
+- Total: < 500ms typical
+
+## Maintenance Guide
+
+### Adding New Metrics
+
+1. Add interface to `lib/types.ts`
+2. Create fetcher in `lib/*.ts`
+3. Import in `index.ts`
+4. Add to `buildSecondLine()`
+
+### Modifying Display
+
+- Colors: Edit `lib/formatters.ts` colors constant
+- Layout: Modify `buildFirstLine()` / `buildSecondLine()`
+- Formatting: Add functions to `lib/formatters.ts`
+
+## Known Limitations
+
+- macOS only (uses Keychain)
+- Requires `git` CLI for git status
+- Requires Claude Code OAuth (not API key)
+- Transcript must be accessible (permissions)

package/templates/.claude/scripts/statusline/README.md

@@ -0,0 +1,138 @@
+# Claude Code Status Line
+
+nouvelle version de la status line qui combine les features de l'ancienne et de la nouvelle version avec synchronisation Claude Code.
+
+## features
+
+### ligne 1 : informations contextuelles
+- 🌿 **branche git** avec changements (vert pour ajouts, rouge pour suppressions)
+- 💄 **output style** (le style de réponse claude configuré)
+- 📁 **dossier actuel** (chemin avec ~ pour home)
+- 🤖 **modèle utilisé** (sonnet 4.5, opus, etc.)
+
+### ligne 2 : métriques et limites
+- 📅 **coût journalier** (via ccusage)
+- 🧩 **tokens utilisés** avec pourcentage du contexte (200k max)
+- ⏱️ **temps restant** avant reset de session (3pm heure locale)
+
+## prérequis **obligatoires**
+
+### ccusage (impératif)
+
+**installation** :
+```bash
+npm install -g @erinreily/ccusage
+```
+
+**pourquoi ccusage est obligatoire** :
+- calcul du coût journalier
+- tracking du temps restant avant reset
+- sans ccusage, la status line affichera $0.00 et pas de temps restant
+
+**vérification** :
+```bash
+ccusage --version  # doit afficher 17.0.2 ou plus
+```
+
+### git (optionnel)
+
+pour afficher la branche et les changements. si git n'est pas disponible, affichera "no-git".
+
+## activation
+
+la status line v2 est déjà active si tu as suivi la configuration précédente.
+
+pour vérifier dans `~/.claude/settings.json` :
+
+```json
+{
+  "statusLine": {
+    "type": "command",
+    "command": "bun /Users/matthieucousin/.claude/scripts/statusline/src/index.ts",
+    "padding": 0
+  }
+}
+```
+
+## format de sortie
+
+```
+🌿 main • 💄 senior-dev • 📁 ~/Documents/project • 🤖 Claude Sonnet 4.5
+📅 $12.76 • 🧩 124.4K tokens (62%) • ⏱️ (2h22m left)
+```
+
+## sources de données
+
+- **git** : commandes git locales (branche + changements)
+- **output style** : `input.output_style.name` depuis Claude Code
+- **modèle** : `input.model.display_name` depuis Claude Code
+- **dossier** : `input.workspace.current_dir` depuis Claude Code
+- **tokens** : transcript Claude Code (input + cache + cache_read, précis)
+- **coût jour** : ccusage daily (nécessite ccusage)
+- **temps restant** : calculé jusqu'à 3pm heure locale (reset de session Claude Code)
+
+## synchronisation avec claude code
+
+le temps restant affiché dans la status bar est **synchronisé avec l'interface Claude Code** :
+- claude code : "resets 3pm (America/Guadeloupe)"
+- status bar : calcule le temps jusqu'à 3pm heure locale
+- toujours cohérent avec `/usage` dans claude code
+
+## différences avec l'ancienne version
+
+**l'ancienne version bash** (`statusline-ccusage.sh`, supprimée) avait :
+- ✅ branche git (conservé)
+- ✅ output style (conservé)
+- ✅ modèle (conservé)
+- ✅ coût journalier (conservé)
+- ❌ bloc actif ccusage (enlevé, utilisait projection incorrecte)
+- ❌ coût de session (enlevé, redondant avec journalier)
+
+**la version v2 ajoute** :
+- synchronisation précise avec claude code (3pm reset)
+- pourcentage du contexte utilisé
+- tokens depuis transcript (plus précis que ccusage)
+- architecture modulaire typescript (git.ts, usage-limits.ts, etc.)
+
+## architecture
+
+```
+src/
+├── index.ts              # entry point principal
+└── lib/
+    ├── types.ts             # interfaces typescript
+    ├── context.ts           # calcul tokens depuis transcript
+    ├── git.ts               # statut git
+    ├── usage-limits.ts      # temps restant + coût bloc
+    └── formatters.ts        # formatage affichage
+```
+
+## troubleshooting
+
+### temps restant incorrect
+
+si le temps affiché ne correspond pas à `/usage` dans claude code :
+1. vérifie ta timezone système : `date`
+2. vérifie que claude code affiche "resets 3pm"
+3. redémarre claude code
+
+### coût à $0.00
+
+si le coût journalier est toujours $0.00 :
+1. vérifie ccusage : `ccusage --version`
+2. vérifie les données : `ccusage daily --json`
+3. réinstalle si besoin : `npm install -g @erinreily/ccusage`
+
+### pas de temps restant affiché
+
+si ⏱️ n'apparaît pas :
+1. ccusage n'est pas installé ou ne fonctionne pas
+2. pas de bloc actif : `ccusage blocks --active --json`
+
+## notes techniques
+
+- écrit en typescript avec bun runtime
+- réutilise les types et helpers de la nouvelle status line
+- gère les erreurs gracieusement (fallback sur valeurs par défaut)
+- compatible avec toutes les timezones (utilise timezone système)
+- ne dépend **pas** de l'API OAuth anthropic (qui ne fonctionne pas avec credentials claude code)

package/templates/.claude/scripts/statusline/biome.json

@@ -0,0 +1,34 @@
+{
+	"$schema": "https://biomejs.dev/schemas/2.3.2/schema.json",
+	"vcs": {
+		"enabled": true,
+		"clientKind": "git",
+		"useIgnoreFile": true
+	},
+	"files": {
+		"ignoreUnknown": false
+	},
+	"formatter": {
+		"enabled": true,
+		"indentStyle": "tab"
+	},
+	"linter": {
+		"enabled": true,
+		"rules": {
+			"recommended": true
+		}
+	},
+	"javascript": {
+		"formatter": {
+			"quoteStyle": "double"
+		}
+	},
+	"assist": {
+		"enabled": true,
+		"actions": {
+			"source": {
+				"organizeImports": "on"
+			}
+		}
+	}
+}

package/templates/.claude/scripts/statusline/fixtures/test-input.json

@@ -0,0 +1,25 @@
+{
+	"session_id": "06a7b019-03f8-4083-a9db-410d95cb01e6",
+	"transcript_path": "/Users/melvynx/.claude/projects/-Users-melvynx--claude/06a7b019-03f8-4083-a9db-410d95cb01e6.jsonl",
+	"cwd": "/Users/melvynx/.claude",
+	"model": {
+		"id": "claude-sonnet-4-5-20250929",
+		"display_name": "Sonnet 4.5"
+	},
+	"workspace": {
+		"current_dir": "/Users/melvynx/.claude",
+		"project_dir": "/Users/melvynx/.claude"
+	},
+	"version": "2.0.31",
+	"output_style": {
+		"name": "default"
+	},
+	"cost": {
+		"total_cost_usd": 0.17468000000000003,
+		"total_duration_ms": 385160,
+		"total_api_duration_ms": 252694,
+		"total_lines_added": 185,
+		"total_lines_removed": 75
+	},
+	"exceeds_200k_tokens": false
+}

package/templates/.claude/scripts/statusline/package.json

@@ -0,0 +1,19 @@
+{
+	"name": "statusline",
+	"version": "2.0.0",
+	"module": "src/index.ts",
+	"type": "module",
+	"scripts": {
+		"start": "bun run src/index.ts",
+		"test": "bun run test.ts",
+		"lint": "biome check --write .",
+		"format": "biome format --write ."
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^2.3.2",
+		"@types/bun": "latest"
+	},
+	"peerDependencies": {
+		"typescript": "^5.0.0"
+	}
+}

package/templates/.claude/scripts/statusline/src/index.ts

@@ -0,0 +1,111 @@
+#!/usr/bin/env bun
+
+import { defaultConfig } from "../statusline.config";
+import { getContextData } from "./lib/context";
+import { colors, formatPath } from "./lib/formatters";
+import { getGitInfo } from "./lib/git";
+import type { HookInput } from "./lib/types";
+import { getUsageLimits } from "./lib/usage-limits";
+
+// Helper functions for formatting
+function formatCost(cost: number): string {
+  return cost.toFixed(2);
+}
+
+function formatTokens(tokens: number): string {
+  if (tokens >= 1000000) {
+    const value = (tokens / 1000000).toFixed(1);
+    return `${value}M`;
+  }
+  if (tokens >= 1000) {
+    const value = (tokens / 1000).toFixed(1);
+    return `${value}K`;
+  }
+  return tokens.toString();
+}
+
+async function getDailyCost(): Promise<number> {
+  try {
+    const today = new Date().toISOString().split("T")[0].replace(/-/g, "");
+    const dailyProc = Bun.spawn([
+      "ccusage",
+      "daily",
+      "--json",
+      "--since",
+      today,
+    ]);
+    const dailyText = await new Response(dailyProc.stdout).text();
+    const dailyData = JSON.parse(dailyText);
+
+    if (dailyData && dailyData.totals && dailyData.totals.totalCost) {
+      return dailyData.totals.totalCost;
+    }
+    return 0;
+  } catch {
+    return 0;
+  }
+}
+
+async function main() {
+  try {
+    const input: HookInput = await Bun.stdin.json();
+
+    // Get basic info from Claude Code
+    const dirPath = formatPath(
+      input.workspace.current_dir,
+      defaultConfig.pathDisplayMode,
+    );
+    const modelName = input.model.display_name || "unknown";
+    const outputStyle = input.output_style.name || "unknown";
+
+    // Get context data (tokens from transcript - most accurate)
+    const contextData = await getContextData({
+      transcriptPath: input.transcript_path,
+      maxContextTokens: defaultConfig.context.maxContextTokens,
+    });
+
+    // Get git info
+    const gitBranch = await getGitInfo();
+
+    // Get daily cost from ccusage (optional)
+    const dailyCost = await getDailyCost();
+
+    // Get usage limits (five-hour window)
+    const usageLimits = await getUsageLimits();
+
+    // Format tokens
+    const formattedTokens = formatTokens(contextData.tokens);
+
+    // Build output
+    const sep = ` ${colors.GRAY}${defaultConfig.separator}${colors.LIGHT_GRAY} `;
+
+    // First line: branch / style / folder / model
+    const firstLine = `${colors.LIGHT_GRAY}🌿 ${gitBranch}${sep}💄 ${outputStyle}${sep}📁 ${dirPath}${sep}🤖 ${modelName}${colors.RESET}`;
+
+    // Second line: daily cost / tokens (percentage) / usage limits
+    let secondLineParts = [
+      `📅 $${formatCost(dailyCost)}`,
+      `🧩 ${formattedTokens} ${colors.GRAY}tokens (${contextData.percentage}%)${colors.LIGHT_GRAY}`,
+    ];
+
+    // Add usage limits if available (from Anthropic API)
+    if (usageLimits) {
+      secondLineParts.push(
+        `⏱️ ${colors.GRAY}(${usageLimits.utilization}%)${colors.LIGHT_GRAY}`,
+        `⏳ ${colors.GRAY}(${usageLimits.remainingTime} left)${colors.LIGHT_GRAY}`,
+      );
+    }
+
+    const secondLine = `${colors.LIGHT_GRAY}${secondLineParts.join(sep)}${colors.RESET}`;
+
+    console.log(firstLine);
+    console.log(secondLine);
+    console.log("");
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.log(`${colors.LIGHT_GRAY}Error: ${errorMessage}${colors.RESET}`);
+    console.log("");
+  }
+}
+
+main();