cc-fail 1.0.0

package/README.md

@@ -0,0 +1,48 @@
+# cc-fail
+
+See which tools fail most in your Claude Code sessions.
+
+```
+npx cc-fail
+```
+
+## What it shows
+
+- **Overall failure rate** — what % of tool calls return errors
+- **Per-tool failure rates** — Bash, WebFetch, Read, Edit, Write...
+- **Error categories** — bash-exit, token-limit, permission, timeout, network
+- **Per-project failure rates** — which project has the most errors
+- **Worst session** — the single session with the highest failure rate
+
+## Example output
+
+```
+cc-fail — Tool Failure Analysis
+════════════════════════════════════════
+
+▸ Overview
+  Total tool calls:  144,851
+  Failed:               7,060 (4.9%)
+  Succeeded:          137,791 (95.1%)
+
+▸ Failure rate by tool
+  WebFetch              24.7%  376/1521
+  Bash                   6.2%  3377/54178
+  Read                   2.1%  84/4001
+
+▸ Error types
+  bash-exit            ████████████████  2499
+  parallel-error       ██████░░░░░░░░░░  1005
+  token-limit          ██░░░░░░░░░░░░░░   429
+  permission           █░░░░░░░░░░░░░░░   198
+```
+
+## JSON output
+
+```bash
+npx cc-fail --json
+```
+
+## Part of cc-toolkit
+
+60 free tools for Claude Code users. → [yurukusa.github.io/cc-toolkit](https://yurukusa.github.io/cc-toolkit/)

package/cli.mjs

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+
+// cc-fail — See which tools fail most in your Claude Code sessions.
+// Zero dependencies. Reads ~/.claude/projects/ session transcripts.
+
+import { readdir, stat, open } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { createInterface } from 'node:readline';
+import { createReadStream } from 'node:fs';
+
+const CONCURRENCY = 8;
+
+const C = {
+  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+  red: '\x1b[31m', green: '\x1b[32m', yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+};
+
+function bar(pct, width = 20) {
+  const filled = Math.round(pct * width);
+  return '█'.repeat(filled) + '░'.repeat(width - filled);
+}
+
+function projectName(dir) {
+  const stripped = dir.replace(/^-home-[^-]+/, '').replace(/^-/, '');
+  return stripped || '~/ (home)';
+}
+
+// Classify error message into category
+function classifyError(msg) {
+  if (!msg) return 'unknown';
+  const m = String(msg).toLowerCase();
+  if (m.includes('exit code') || m.includes('exit status')) return 'bash-exit';
+  if (m.includes('file not found') || m.includes('no such file')) return 'file-not-found';
+  if (m.includes('permission denied')) return 'permission-denied';
+  if (m.includes('timeout') || m.includes('timed out')) return 'timeout';
+  if (m.includes('token') && m.includes('exceed')) return 'token-limit';
+  if (m.includes('sibling tool') || m.includes('parallel')) return 'parallel-error';
+  if (m.includes('parse') || m.includes('invalid json') || m.includes('syntax')) return 'parse-error';
+  if (m.includes('rate limit') || m.includes('429')) return 'rate-limit';
+  if (m.includes('network') || m.includes('connection') || m.includes('econnrefused')) return 'network';
+  if (m.includes('not allowed') || m.includes('denied') || m.includes('blocked')) return 'permission';
+  return 'other';
+}
+
+async function analyzeFile(filePath) {
+  const result = {
+    totalCalls: 0,
+    errors: 0,
+    byTool: {},     // toolName -> { calls, errors }
+    byCategory: {}, // errorCategory -> count
+    topErrors: {},  // first 80 chars of error -> count
+  };
+
+  const rl = createInterface({
+    input: createReadStream(filePath),
+    crlfDelay: Infinity,
+  });
+
+  // Map tool_use_id -> tool_name (populated from assistant tool_use events)
+  const toolNames = {};
+
+  for await (const line of rl) {
+    if (!line) continue;
+
+    // Only parse lines that mention tool_use or tool_result
+    const hasToolUse = line.includes('"tool_use"');
+    const hasToolResult = line.includes('"tool_result"');
+    if (!hasToolUse && !hasToolResult) continue;
+
+    let data;
+    try { data = JSON.parse(line); } catch { continue; }
+
+    const msg = data.message || data;
+    if (!msg || !Array.isArray(msg.content)) continue;
+
+    for (const item of msg.content) {
+      if (!item || typeof item !== 'object') continue;
+
+      // assistant: tool_use event — record tool name by id
+      if (item.type === 'tool_use' && item.id && item.name) {
+        toolNames[item.id] = item.name;
+      }
+
+      // user: tool_result event — count success/failure
+      if (item.type === 'tool_result' && item.tool_use_id) {
+        const toolName = toolNames[item.tool_use_id] || 'unknown';
+        const isError = item.is_error === true;
+
+        result.totalCalls++;
+        if (!result.byTool[toolName]) result.byTool[toolName] = { calls: 0, errors: 0 };
+        result.byTool[toolName].calls++;
+
+        if (isError) {
+          result.errors++;
+          result.byTool[toolName].errors++;
+
+          // Error category
+          const errContent = Array.isArray(item.content)
+            ? item.content.map(c => (typeof c === 'string' ? c : c.text || '')).join(' ')
+            : String(item.content || '');
+          const cat = classifyError(errContent);
+          result.byCategory[cat] = (result.byCategory[cat] || 0) + 1;
+
+          // Top error snippets
+          const snippet = errContent.slice(0, 80).replace(/\n/g, ' ').trim();
+          if (snippet) result.topErrors[snippet] = (result.topErrors[snippet] || 0) + 1;
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+async function scan() {
+  const projectsDir = join(homedir(), '.claude', 'projects');
+  let projectDirs;
+  try { projectDirs = await readdir(projectsDir); } catch { return []; }
+
+  // Collect all session files
+  const tasks = [];
+  for (const pd of projectDirs) {
+    const pp = join(projectsDir, pd);
+    const ps = await stat(pp).catch(() => null);
+    if (!ps?.isDirectory()) continue;
+    const files = await readdir(pp).catch(() => []);
+    for (const f of files) {
+      if (f.endsWith('.jsonl')) {
+        tasks.push({ path: join(pp, f), project: projectName(pd) });
+      }
+    }
+    // Subagent files
+    for (const f of files) {
+      const sp = join(pp, f, 'subagents');
+      const ss = await stat(sp).catch(() => null);
+      if (!ss?.isDirectory()) continue;
+      const sfs = await readdir(sp).catch(() => []);
+      for (const sf of sfs) {
+        if (sf.endsWith('.jsonl')) {
+          tasks.push({ path: join(sp, sf), project: projectName(pd) });
+        }
+      }
+    }
+  }
+
+  // Aggregate results by project
+  const byProject = {}; // project -> { totalCalls, errors }
+  let globalCalls = 0, globalErrors = 0;
+  const globalByTool = {};
+  const globalByCategory = {};
+  const globalTopErrors = {};
+  let worstSession = { path: '', rate: 0, errors: 0, calls: 0 };
+
+  // Process in batches
+  for (let i = 0; i < tasks.length; i += CONCURRENCY) {
+    const batch = tasks.slice(i, i + CONCURRENCY);
+    const results = await Promise.all(batch.map(async t => {
+      const st = await stat(t.path).catch(() => null);
+      if (!st || st.size < 100) return null;
+      const r = await analyzeFile(t.path).catch(() => null);
+      return r ? { ...r, project: t.project, path: t.path } : null;
+    }));
+
+    for (const r of results) {
+      if (!r || r.totalCalls === 0) continue;
+      globalCalls += r.totalCalls;
+      globalErrors += r.errors;
+
+      if (!byProject[r.project]) byProject[r.project] = { calls: 0, errors: 0 };
+      byProject[r.project].calls += r.totalCalls;
+      byProject[r.project].errors += r.errors;
+
+      for (const [t, v] of Object.entries(r.byTool)) {
+        if (!globalByTool[t]) globalByTool[t] = { calls: 0, errors: 0 };
+        globalByTool[t].calls += v.calls;
+        globalByTool[t].errors += v.errors;
+      }
+      for (const [c, n] of Object.entries(r.byCategory)) {
+        globalByCategory[c] = (globalByCategory[c] || 0) + n;
+      }
+      for (const [e, n] of Object.entries(r.topErrors)) {
+        globalTopErrors[e] = (globalTopErrors[e] || 0) + n;
+      }
+
+      const rate = r.totalCalls > 0 ? r.errors / r.totalCalls : 0;
+      if (r.errors > 5 && rate > worstSession.rate) {
+        worstSession = { path: r.path, rate, errors: r.errors, calls: r.totalCalls };
+      }
+    }
+  }
+
+  return { globalCalls, globalErrors, byProject, globalByTool, globalByCategory, globalTopErrors, worstSession };
+}
+
+const jsonMode = process.argv.includes('--json');
+if (!jsonMode) process.stdout.write(`  ${C.dim}Analyzing tool calls...${C.reset}\r`);
+
+const data = await scan();
+const { globalCalls, globalErrors, byProject, globalByTool, globalByCategory, globalTopErrors, worstSession } = data;
+
+const globalRate = globalCalls > 0 ? globalErrors / globalCalls : 0;
+
+if (jsonMode) {
+  const byToolSorted = Object.entries(globalByTool)
+    .filter(([, v]) => v.calls >= 5)
+    .sort((a, b) => b[1].errors - a[1].errors)
+    .map(([name, v]) => ({ name, calls: v.calls, errors: v.errors, rate: v.calls > 0 ? +(v.errors / v.calls).toFixed(3) : 0 }));
+  const byProjectSorted = Object.entries(byProject)
+    .filter(([, v]) => v.calls >= 5)
+    .sort((a, b) => (b[1].errors / b[1].calls) - (a[1].errors / a[1].calls))
+    .map(([name, v]) => ({ name, calls: v.calls, errors: v.errors, rate: +(v.errors / v.calls).toFixed(3) }));
+  console.log(JSON.stringify({
+    version: '1.0.0',
+    totalCalls: globalCalls,
+    totalErrors: globalErrors,
+    errorRate: +globalRate.toFixed(3),
+    byTool: byToolSorted,
+    byProject: byProjectSorted,
+    byCategory: globalByCategory,
+  }, null, 2));
+  process.exit(0);
+}
+
+// ── Display ──────────────────────────────────────────────────────
+
+const pct = (n, d) => d > 0 ? (n / d * 100).toFixed(1) + '%' : '0%';
+
+console.log(`\n  ${C.bold}${C.cyan}cc-fail — Tool Failure Analysis${C.reset}`);
+console.log(`  ${'═'.repeat(40)}`);
+
+console.log(`\n  ${C.bold}▸ Overview${C.reset}`);
+console.log(`    Total tool calls:  ${C.bold}${globalCalls.toLocaleString()}${C.reset}`);
+console.log(`    Failed:            ${C.bold}${C.red}${globalErrors.toLocaleString()}${C.reset} ${C.dim}(${pct(globalErrors, globalCalls)})${C.reset}`);
+console.log(`    Succeeded:         ${C.bold}${C.green}${(globalCalls - globalErrors).toLocaleString()}${C.reset} ${C.dim}(${pct(globalCalls - globalErrors, globalCalls)})${C.reset}`);
+
+// Per-tool breakdown
+const tools = Object.entries(globalByTool)
+  .filter(([, v]) => v.calls >= 5)
+  .sort((a, b) => (b[1].errors / b[1].calls) - (a[1].errors / a[1].calls))
+  .slice(0, 10);
+
+if (tools.length > 0) {
+  console.log(`\n  ${C.bold}▸ Failure rate by tool${C.reset}`);
+  const maxCalls = Math.max(...tools.map(([, v]) => v.calls));
+  for (const [name, v] of tools) {
+    const rate = v.calls > 0 ? v.errors / v.calls : 0;
+    const color = rate > 0.2 ? C.red : rate > 0.1 ? C.yellow : C.green;
+    const nameP = name.padEnd(20);
+    console.log(`    ${C.dim}${nameP}${C.reset} ${color}${pct(v.errors, v.calls).padStart(6)}${C.reset}  ${C.dim}${v.errors}/${v.calls}${C.reset}`);
+  }
+}
+
+// Error categories
+const cats = Object.entries(globalByCategory).sort((a, b) => b[1] - a[1]).slice(0, 6);
+if (cats.length > 0) {
+  console.log(`\n  ${C.bold}▸ Error types${C.reset}`);
+  const maxCat = cats[0][1];
+  for (const [cat, n] of cats) {
+    const b = bar(n / maxCat, 16);
+    console.log(`    ${cat.padEnd(20)} ${C.red}${b}${C.reset}  ${n}`);
+  }
+}
+
+// Per-project
+const projects = Object.entries(byProject)
+  .filter(([, v]) => v.calls >= 10)
+  .sort((a, b) => (b[1].errors / b[1].calls) - (a[1].errors / a[1].calls))
+  .slice(0, 6);
+
+if (projects.length > 0) {
+  console.log(`\n  ${C.bold}▸ Failure rate by project${C.reset}`);
+  for (const [name, v] of projects) {
+    const rate = v.calls > 0 ? v.errors / v.calls : 0;
+    const color = rate > 0.15 ? C.red : rate > 0.08 ? C.yellow : C.dim;
+    console.log(`    ${color}${name.slice(0, 28).padEnd(28)}${C.reset}  ${pct(v.errors, v.calls).padStart(6)}  ${C.dim}${v.errors}/${v.calls}${C.reset}`);
+  }
+}
+
+// Worst session
+if (worstSession.calls > 0) {
+  const sessionName = worstSession.path.split('/').slice(-3).join('/');
+  console.log(`\n  ${C.bold}▸ Worst session${C.reset}`);
+  console.log(`    ${C.red}${pct(worstSession.errors, worstSession.calls)}${C.reset} failure rate`);
+  console.log(`    ${C.dim}${sessionName.slice(0, 60)}${C.reset}`);
+}
+
+console.log();
+console.log(`  ${C.dim}─── Share ───${C.reset}`);
+console.log(`  ${C.dim}My tool failure rate: ${pct(globalErrors, globalCalls)} (${globalErrors.toLocaleString()} failures / ${globalCalls.toLocaleString()} calls)`);
+console.log(`  #ClaudeCode${C.reset}`);
+console.log();

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "cc-fail",
+  "version": "1.0.0",
+  "description": "See which tools fail most in your Claude Code sessions. Bash exit rates, WebFetch errors, permission denials and more.",
+  "bin": {
+    "cc-fail": "cli.mjs"
+  },
+  "type": "module",
+  "keywords": [
+    "claude-code",
+    "claude",
+    "ai",
+    "debugging",
+    "error-analysis",
+    "tool-failure",
+    "bash",
+    "productivity"
+  ],
+  "author": "yurukusa",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yurukusa/cc-fail.git"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "cli.mjs",
+    "README.md",
+    "LICENSE"
+  ]
+}