Token Burner

Token Burner

在 token 过期前自动执行有价值的项目改进任务，不浪费任何额度。

Overview

自动扫描项目，发现代码审查、测试生成、文档完善、依赖审计、重构等任务，按优先级排序后自主执行。使用 worktree 隔离每个任务，执行后自动验证，确保每次修改都是安全的。

When to Use

• User wants to use tokens productively before they expire
• User wants to run an autonomous code improvement session
• User says "burn tokens" / "token burner" / "用掉 token"
• User wants to auto-discover and fix issues across a project
• User inputs /token-burner
• User wants automated code review across the project
• User wants to find and fix code smells automatically
• User wants to improve test coverage without manual effort
• User wants to do a full project health check and cleanup

When NOT to Use:

• User wants to work on a specific, well-defined task (use normal workflow)
• User wants to chat or brainstorm (no token waste concern)
• User's project has no code to improve
• User wants to run automated tests only (use test runner directly)
• User wants to generate documentation only (use doc generation tools)
• User wants to refactor specific files (do it manually for better control)

Core Pattern

Step 1: 项目扫描

检测项目类型和结构，发现可执行任务：

# 检测项目类型
test -f package.json && echo "Node.js"
test -f go.mod && echo "Go"
test -f requirements.txt && echo "Python"
test -f Cargo.toml && echo "Rust"

# 检测 git 状态
git log --oneline -5          # 最近变更
git diff --stat HEAD~3        # 变更范围
git status --porcelain        # 未提交变更

任务发现引擎：（详见 templates/task-discovery.md）

生成任务列表，每个任务包含：type、file、description、impact（high/medium/low）、risk（high/medium/low）。

Step 2: 优先级排序

按 score = impact_score × (1 - risk_score) 排序：

安全策略：

• P0 任务（安全漏洞、缺陷）→ 立即执行
• P1 任务（测试）→ 可以执行，但每个任务在 worktree 中隔离
• P2 任务（文档、重构）→ 可以执行
• P3 任务（清理）→ 只在有剩余 token 时执行

前置依赖检查：

执行前先检查所需工具是否可用，缺失时跳过对应任务类型而非静默失败：

# 检查工具可用性
command -v jq >/dev/null 2>&1 || echo "⚠️ jq 未安装，安全审计任务将跳过"
command -v npm >/dev/null 2>&1 || echo "⚠️ npm 未安装，Node.js 审计将跳过"
command -v go >/dev/null 2>&1 || echo "⚠️ go 未安装，Go 审计将跳过"
command -v pip-audit >/dev/null 2>&1 || echo "⚠️ pip-audit 未安装，Python 审计将跳过"

过滤规则：

• 跳过 node_modules/、vendor/、.git/ 等目录
• 跳过已由其他 skill 覆盖的任务（如 git-hooks-setup 已配置的）
• 跳过超过 500 行变更的大任务（拆分为子任务）

Step 3: 自主执行

使用 Agent tool 逐个执行任务，每个任务在独立 worktree 中：

对每个 task in 队列:
  retries = 0
  max_retries = 3
  while retries < max_retries:
    1. Agent(task.prompt, {
         subagent_type: "general-purpose",
         isolation: "worktree",
         description: "token-burner:" + task.type
       })
    2. 在 worktree 中跑测试验证
    3. 如果测试通过 → 合并到主分支，break
    4. 如果测试失败 → retries++
       - 如果 retries < max_retries → 回滚 worktree，重试
       - 如果 retries >= max_retries → 记录失败原因，跳过此任务
    5. 更新任务状态

每种任务的执行策略：

执行限制：

• 每个任务最多 3 次重试
• 单个任务超时 5 分钟则跳过
• 总任务数默认最多 20 个（可通过 --max-tasks 调整）

Step 4: 记录和报告

每个任务完成后记录到 memory（任务类型、文件、状态、说明），执行结构见 templates/execution-report.md。

Step 5: 收尾

生成最终报告 templates/execution-report.md，包含：

• 执行统计（成功率、耗时、token 消耗估算）
• 每个任务的详细结果
• 未执行任务的原因
• 下次运行建议

Quick Reference

Note: Parameters below are natural language hints parsed by the AI. Without parameters, the AI will ask interactively.

/token-burner                          # Scan and execute all tasks
/token-burner 只跑测试和文档            # Only test and doc tasks
/token-burner 最多跑 10 个任务          # Limit to 10 tasks
/token-burner 只扫描不执行              # Scan only, don't execute
/token-burner 扫描 /path/to/repo       # Target specific project

Common Mistakes

🔥 Token Burner

Autonomously discover and execute valuable code improvements before tokens expire. Never waste a token again.

Installation

# npx skills (recommended)
npx skills add wu529778790/shenzjd-skills -s token-burner -y

# Manual (Claude Code)
git clone https://github.com/wu529778790/shenzjd-skills.git
cp -r shenzjd-skills/token-burner ~/.claude/skills/

# Manual (Cursor)
# Copy SKILL.md content to .cursorrules or .cursor/rules/

Usage

Note: Parameters are natural language hints parsed by the AI. Without parameters, the AI will ask interactively.

/token-burner                          # Scan and execute all tasks
/token-burner 只跑测试和文档            # Only test and doc tasks
/token-burner 最多跑 10 个任务          # Limit to 10 tasks
/token-burner 只扫描不执行              # Scan only, don't execute
/token-burner 扫描 /path/to/repo       # Target specific project

How It Works

Project Scan → Task Discovery → Priority Queue → Autonomous Execution → Report
     │              │                │                    │                │
     │              │                │                    │                │
  Detect        Find issues     Sort by impact      Agent executes    Generate
  project       & opportunities  × (1 - risk)       in worktrees      summary
  type                                                        with tests

Task Types

Safety

• Each task runs in an isolated git worktree
• Tests run after every change
• Failed tasks auto-rollback
• Checkpoint commits every 5 tasks
• Progress persisted across sessions

Prerequisites

• Git repository with history
• Project-specific tools (npm, go, pip, cargo) installed
• jq installed (for JSON processing)

Token Burner 执行报告

运行概览

任务详情

{{#each tasks}} | {{@index}} | {{type_icon}} {{type}} | {{priority}} | {{file}} | {{status_icon}} {{status}} | {{description}} | {{duration}} | {{/each}}

失败任务分析

{{#if failed_tasks}} {{#each failed_tasks}}

{{type}}: {{file}}

• 错误信息： {{error}}
• 重试次数： {{retries}}
• 失败原因： {{reason}}
• 建议： {{suggestion}}

{{/each}} {{else}} 无失败任务。 {{/if}}

未执行任务

{{#if skipped_tasks}}

{{#each skipped_tasks}} | {{@index}} | {{type}} | {{file}} | {{reason}} | {{/each}} {{else}} 所有任务均已执行。 {{/if}}

改动统计

下次运行建议

{{#each suggestions}}

• {{this}}

{{/each}}

任务发现指南

本文档定义了 token-burner 如何在任意项目中自动发现可执行任务。

项目类型检测

# Node.js / TypeScript
test -f package.json && echo "node"

# Go
test -f go.mod && echo "go"

# Python
test -f requirements.txt -o -f pyproject.toml -o -f setup.py && echo "python"

# Rust
test -f Cargo.toml && echo "rust"

# Java
test -f pom.xml -o -f build.gradle && echo "java"

任务发现规则

P0 - 安全和缺陷（立即执行）

依赖安全扫描：

# Node.js（需要 jq 和 package-lock.json）
if command -v jq >/dev/null 2>&1 && test -f package-lock.json; then
  # npm audit 发现漏洞时退出码非 0，故不依赖退出码，直接解析 JSON
  vuln_count=$(npm audit --json 2>/dev/null | jq '.metadata.vulnerabilities.total // (.vulnerabilities | length) // 0' 2>/dev/null)
  if [ -n "$vuln_count" ] && [ "$vuln_count" != "null" ]; then
    echo "npm vulnerabilities: $vuln_count"
  else
    echo "audit parse failed"
  fi
elif ! test -f package-lock.json; then
  echo "⚠️ 缺少 package-lock.json，跳过 npm audit"
fi

# Go（需要 govulncheck）
if command -v go >/dev/null 2>&1; then
  $(go env GOPATH)/bin/govulncheck ./... 2>/dev/null || echo "⚠️ govulncheck 未安装或执行失败"
fi

# Python（需要 pip-audit）
if command -v pip-audit >/dev/null 2>&1; then
  pip-audit 2>/dev/null || echo "⚠️ pip-audit 执行失败"
else
  echo "⚠️ pip-audit 未安装，运行: pip install pip-audit"
fi

代码缺陷检测：

• 检查 git diff 中的常见错误模式
• 搜索 TODO: fix、FIXME、HACK 标记
• 检查是否有未处理的错误（空 catch、忽略返回值）

P1 - 测试覆盖（高优先级）

无测试文件检测：

# Node.js - 找没有对应测试的源文件（需要 shopt -s globstar 递归匹配）
shopt -s globstar
for f in src/**/*.ts; do
  test_file="${f%.ts}.test.ts"
  test -f "$test_file" || echo "Missing test: $f"
done

# Go - 检查测试覆盖率
go test -coverprofile=coverage.out ./... 2>/dev/null
go tool cover -func=coverage.out | grep "total:"

低覆盖率检测：

• 覆盖率 < 50% 的文件 → 生成测试任务
• 覆盖率 50-80% 的文件 → 补充边界测试

P2 - 文档和重构（中优先级）

文档缺失检测：

# 检查 README 是否存在
test -f README.md || echo "Missing README.md"

# 检查函数注释（Go）
grep -r "^func " --include="*.go" | head -20

# 检查 API 文档
test -d docs/api || echo "Missing API docs"

代码重复检测：

# 简单的重复行检测
sort file.ts | uniq -d | head -10

# 复杂度检测（需要工具）
# npx complexity-report src/ --maxcomplexity 10

P3 - Git 清理（低优先级）

过时分支检测：

git branch --merged main | grep -v "main\|master"

大文件检测：

git ls-files | xargs ls -lS 2>/dev/null | sort -rn | head -10

Conflict markers 检测：

grep -r "<<<<<<" --include="*.ts" --include="*.js" --include="*.go" .

任务评分公式

score = impact_score × (1 - risk_score)

impact_score:
  security_vulnerability = 3
  bug_fix = 3
  test_coverage = 2
  documentation = 2
  refactoring = 2
  cleanup = 1

risk_score:
  change_business_logic = 0.8
  add_tests = 0.4
  add_docs = 0.4
  read_only_analysis = 0.1

任务输出格式

每个发现的任务输出为：

{
  "id": "task-001",
  "type": "security|bug|test|docs|refactor|clean",
  "priority": "P0|P1|P2|P3",
  "file": "path/to/file",
  "description": "简短描述",
  "impact": "high|medium|low",
  "risk": "high|medium|low",
  "score": 2.4,
  "prompt": "执行此任务的具体指令"
}