bueller-wheel 0.1.0

package/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright 2025 Andrew Fong
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,244 @@
+# Bueller Wheel
+
+A headless Claude Code issue processor that runs in a loop and resolves issues or tickets written in markdown
+
+## Quick Start
+
+```bash
+# Create an issue
+mkdir -p issues/open
+echo "@user: Please create a test file with 'Hello World'" > issues/open/p0-100-my-task.md
+
+# Run bueller-wheel to complete the task
+npx bueller-wheel
+```
+
+## Why?
+
+Claude Code agents work better when they focus on one thing at a time. Bueller Wheel helps defer context until it's needed through two mechanisms:
+
+**Issues as directory-based threads** - Each task becomes a reviewable conversation stored as markdown that gets moved along a file-based "kanban" board. This solves a few problems:
+- **Code review**: When Claude burns through multiple tasks, it's hard to know what happened. The issues structure creates discrete, reviewable units of work.
+- **Iteration without re-prompting**: Markdown files are structured as a back-and-forth between you and Claude, which lets you append follow-ups naturally without starting over.
+- **Human-editable prompts**: Storing issues as simple markdown (not JSON or a database) makes it easy to edit, append, or retroactively clean up conversations to improve prompting.
+
+**FAQ system** - Common mistakes get documented once, then referenced automatically. Instead of repeating corrections or watching Claude make the same errors over and over, capture solutions in FAQ files that the agent checks when stuck.
+
+**Note:** Bueller Wheel is not a full-fledged task management system. It has no concept of assignment or dependency apart from linear file ordering. The sweet spot for this tool is **solo developers working on a single branch**, but you can make [parallel branches and agents](#working-with-multiple-branches) work.
+
+## How It Works
+
+**The Processing Loop**
+
+1. Bueller Wheel finds the next issue in `issues/open/` (sorted alphabetically by filename)
+2. Claude Code reads the issue and works on the task
+3. Claude appends its work summary to the issue file
+4. Claude decides the outcome:
+   - **CONTINUE**: Keep working (stays in `open/`)
+   - **COMPLETE**: Done (moves to `review/`)
+   - **DECOMPOSE**: Split into sub-tasks (creates child issues, moves parent to `review/`)
+   - **STUCK**: Needs help (moves to `stuck/`)
+
+**Managing the "kanban" board:**
+
+- Create issue markdown in `open/` for each task you want Claude to work on. Name files alphabetically in the order you want them processed. By default, the prompt used tells our agent to name files with something like `p1-101-name-of-task.md` (`p1` is a priority between 0 to 2, and `101` is just an arbitrary number for ordering).
+- Move issues from `review/` or `stuck/` back to `open/` if more work is required
+- Delete issues from `review/` when done reviewing, or archive them however you want
+
+**Each iteration is a fresh Claude Code session** - no memory between iterations, which keeps context focused.
+
+**Inherits your project's Claude Code setup** - `bueller-wheel` uses the Anthropic API credential from whichever user you're logged in as. It inherits the same `.claude/settings.json` or `.claude/settings.local.json` as the Claude Code project it's used in. Whatever permissions apply to your regular `claude` CLI should also apply to `bueller-wheel`, with the exception that `bueller-wheel` starts in "accept edits" mode.
+
+## Issue Structure
+
+**Directory Layout**
+```
+issues/
+  open/      - Issues to be processed
+  review/    - Completed issues ready for human review
+  stuck/     - Issues blocked, requiring human intervention
+  prompt.md  - Custom prompt template (optional)
+```
+
+**Filename Format:** `p{priority}-{order}-{description}.md`
+
+Examples:
+- `p0-100-fix-critical-bug.md` (urgent work)
+- `p1-050-add-feature.md` (normal feature work)
+- `p2-020-refactor-code.md` (non-blocking follow-up)
+
+Files are processed alphabetically (p0 before p1, lower order numbers first).
+
+**Issue Content: A Conversation**
+
+Issues are markdown files with a simple conversation structure:
+
+```markdown
+@user: Please build the widget factory.
+
+---
+
+@claude: I have built the widget factory.
+
+Here is a summary of the work I have done:
+- Created WidgetFactory class
+- Added unit tests
+- Updated documentation
+
+---
+
+@user: Please add error handling.
+
+---
+
+@claude: I have added error handling.
+
+Here is a summary of the work I have done:
+- Added try-catch blocks
+- Added custom error types
+- Updated tests
+```
+
+Because it's just markdown, you can:
+- Append new instructions at any time
+- Edit previous messages to clarify intent
+- Delete irrelevant parts of the conversation
+- Copy successful patterns to new issues
+
+## FAQ System
+
+The `faq/` directory contains markdown files with solutions to common problems. When Claude encounters issues, it's instructed to check this directory for relevant guidance.
+
+**Why this helps:**
+- Document a fix once, reference it forever
+- Keep Claude on track with project-specific conventions
+- Reduce repeated mistakes without cluttering every issue prompt
+
+**Example FAQ structure:**
+```
+faq/
+  testing-guidelines.md
+  code-style.md
+  common-errors.md
+```
+
+Configure the location with `--faq-dir` (default: `./faq`)
+
+## Working with Multiple Branches
+
+The `open/` directory acts as an inbox for the agent on the current branch. The agent will attempt to burn through all issues in that directory (or until it hits `--max-iterations`).
+
+**If you want to divide work across multiple branches or run multiple agents in parallel:**
+
+1. **Track issues outside `open/`** - Use an external issue tracker or create an `issues/backlog/` directory. Bueller Wheel doesn't process anything except in the `open/` directory.
+
+2. **One branch per agent** - Create a separate branch (or checkout/worktree) for each agent working in parallel.
+
+3. **Move issues into `open/` as tasks for a single agent** - Only move issues from your backlog into `open/` that you want the current agent to work on. Think of it as dividing work into reviewable chunks that are easier to merge.
+
+## CLI Options
+
+```bash
+npx bueller-wheel --issues-dir ./my-issues --faq-dir ./my-faq --max-iterations 50 --git-commit --prompt ./my-prompt.md
+
+# Or if installed globally
+bueller-wheel --issues-dir ./my-issues --faq-dir ./my-faq --max-iterations 50 --git-commit --prompt ./my-prompt.md
+```
+
+- `--issues-dir <path>`: Issues directory (default: `./issues`)
+- `--faq-dir <path>`: FAQ directory (default: `./faq`)
+- `--max-iterations <number>`: Maximum iterations (default: `25`)
+- `--git-commit`: Enable automatic git commits after each iteration (default: disabled)
+- `--prompt <path>`: Path to custom prompt template file (default: `<issues-dir>/prompt.md`)
+- `--continue [prompt]`: Continue from previous session. Optional prompt defaults to "continue" if not provided
+
+### Custom Prompt Templates
+
+Bueller Wheel uses a customizable prompt template system that allows you to tailor the agent's behavior.
+
+#### How It Works
+
+1. **Default Template**: On first run, Bueller Wheel creates a default prompt template at `<issues-dir>/prompt.md`
+2. **Custom Template**: You can edit this file or specify a different template with `--prompt`
+3. **Template Variables**: The template uses bracketed variables that are replaced at runtime
+
+#### Template Variables
+
+The following variables are available in your prompt template:
+
+- `[ISSUES_DIR]` - The issues directory path (e.g., `./issues`)
+- `[FAQ_DIR]` - The FAQ directory path (e.g., `./faq`)
+- `[ISSUE_DIR_OPEN]` - The open subdirectory name (always `open`)
+- `[ISSUE_DIR_REVIEW]` - The review subdirectory name (always `review`)
+- `[ISSUE_DIR_STUCK]` - The stuck subdirectory name (always `stuck`)
+- `[ISSUE_FILE_PATH]` - Full path to the current issue file (e.g., `./issues/open/p0-100-task.md`)
+- `[ISSUE_FILE]` - Just the issue filename (e.g., `p0-100-task.md`)
+
+#### Example Usage
+
+```markdown
+Your task is to process: [ISSUE_FILE_PATH]
+
+When complete, move it to: [ISSUES_DIR]/[ISSUE_DIR_REVIEW]/[ISSUE_FILE]
+```
+
+This will be rendered as:
+
+```
+Your task is to process: ./issues/open/p0-100-task.md
+
+When complete, move it to: ./issues/review/p0-100-task.md
+```
+
+#### Creating a Custom Prompt
+
+1. Copy the default template from `issues/prompt.md`
+2. Modify the instructions while keeping the template variables
+3. Optionally save it to a different location and use `--prompt` to specify it
+
+### Continue Mode
+
+The `--continue` flag continues from the last Claude session with a custom prompt. You can use this to interrupt a live loop that's going sideways and nudge it back on track.
+
+```bash
+# Continue with default "continue" prompt
+npx bueller-wheel --continue
+
+# Continue with custom instructions
+npx bueller-wheel --continue "no use foo instead of bar"
+```
+
+Note that only the immediate prior iteration is continued. The next iteration will start with a fresh context and the original prompt.
+
+### Git Auto-Commit
+
+When `--git-commit` is enabled, Bueller Wheel will automatically create a git commit after each iteration where work was done on an issue.
+
+The commit message format includes the issue ID (the filename minus the `.md`) and status:
+```
+p0-002-git done
+p0-002-git in progress
+p0-002-git stuck
+p0-002-git unknown
+```
+## Development
+
+`pnpm run dev` will execute the current `src/index.ts` script file with whatever args you pass to it.
+
+## End-to-End Testing
+
+**These tests use your actual live instance of Claude Code!**
+
+```bash
+# Run all tests
+pnpm test
+
+# Run a specific test
+./tests/run-test.sh simple-task
+```
+
+Tests are located in `tests/fixtures/` and consist of:
+- Pre-configured issue directories with markdown files
+- Verification scripts to check outcomes
+
+See [tests/README.md](tests/README.md) for more details on creating new test cases.

package/dist/index.js

@@ -0,0 +1,462 @@
+#!/usr/bin/env node
+import { execSync } from 'node:child_process';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { query } from '@anthropic-ai/claude-agent-sdk';
+const ISSUE_DIR_OPEN = 'open';
+const ISSUE_DIR_REVIEW = 'review';
+const ISSUE_DIR_STUCK = 'stuck';
+function showHelp() {
+    console.log(`
+Bueller - Headless Claude Code Issue Processor
+
+USAGE:
+  bueller [OPTIONS]
+
+OPTIONS:
+  --help              Show this help message and exit
+  --issues-dir DIR    Directory containing issue queue (default: ./issues)
+  --faq-dir DIR       Directory containing FAQ/troubleshooting guides (default: ./faq)
+  --max-iterations N  Maximum number of iterations to run (default: 25)
+  --git, --git-commit Enable automatic git commits after each iteration
+  --prompt FILE       Custom prompt template file (default: ./issues/prompt.md)
+  --continue [PROMPT] Continue from previous session (default prompt: "continue")
+
+DIRECTORY STRUCTURE:
+  issues/
+    open/       Issues to be processed
+    review/     Completed issues
+    stuck/      Issues requiring human intervention
+    prompt.md   Custom prompt template (optional)
+  faq/          FAQ and troubleshooting guides
+
+ISSUE FILE FORMAT:
+  Issues are markdown files named: p{priority}-{order}-{description}.md
+
+  Priority levels:
+    p0: Urgent/unexpected work
+    p1: Normal feature work
+    p2: Non-blocking follow-up
+
+EXAMPLES:
+  bueller
+  bueller --issues-dir ./my-issues --faq-dir ./my-faq
+  bueller --max-iterations 50 --git-commit
+  bueller --prompt ./custom-prompt.md
+
+For more information, visit: https://github.com/anthropics/bueller
+`);
+}
+function parseArgs() {
+    const args = process.argv.slice(2);
+    // Check for help flag first
+    if (args.includes('--help') || args.includes('-h')) {
+        showHelp();
+        process.exit(0);
+    }
+    let issuesDir = './issues';
+    let faqDir = './faq';
+    let maxIterations = 25;
+    let gitCommit = false;
+    let promptFile = path.join('./issues', 'prompt.md');
+    let continueMode = false;
+    let continuePrompt = 'continue';
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--issues-dir' && i + 1 < args.length) {
+            issuesDir = args[++i];
+            // Update default prompt file location if issues-dir is changed
+            if (!args.includes('--prompt')) {
+                promptFile = path.join(issuesDir, 'prompt.md');
+            }
+        }
+        else if (args[i] === '--faq-dir' && i + 1 < args.length) {
+            faqDir = args[++i];
+        }
+        else if (args[i] === '--max-iterations' && i + 1 < args.length) {
+            maxIterations = parseInt(args[++i], 10);
+        }
+        else if (args[i] === '--git' || args[i] === '--git-commit') {
+            gitCommit = true;
+        }
+        else if (args[i] === '--prompt' && i + 1 < args.length) {
+            promptFile = args[++i];
+        }
+        else if (args[i] === '--continue') {
+            continueMode = true;
+            // Check if next arg exists and doesn't start with --
+            if (i + 1 < args.length && !args[i + 1].startsWith('--')) {
+                continuePrompt = args[++i];
+            }
+        }
+    }
+    return {
+        issuesDir,
+        faqDir,
+        maxIterations,
+        gitCommit,
+        promptFile,
+        continueMode,
+        continuePrompt,
+    };
+}
+async function ensureDirectories(issuesDir, faqDir) {
+    const dirs = [
+        issuesDir,
+        path.join(issuesDir, ISSUE_DIR_OPEN),
+        path.join(issuesDir, ISSUE_DIR_REVIEW),
+        path.join(issuesDir, ISSUE_DIR_STUCK),
+        faqDir,
+    ];
+    for (const dir of dirs) {
+        try {
+            await fs.access(dir);
+        }
+        catch {
+            await fs.mkdir(dir, { recursive: true });
+        }
+    }
+}
+async function getOpenIssues(issuesDir) {
+    const openDir = path.join(issuesDir, ISSUE_DIR_OPEN);
+    const files = await fs.readdir(openDir);
+    return files.filter((f) => f.endsWith('.md')).sort();
+}
+function extractIssueId(issueFile) {
+    // Extract ID from filename like "p0-002-git.md" -> "p0-002-git"
+    return issueFile.replace('.md', '');
+}
+function gitCommit(issueFile, status) {
+    const issueId = extractIssueId(issueFile);
+    try {
+        // Check if there are any changes to commit
+        try {
+            execSync('git diff --quiet && git diff --cached --quiet');
+            // Also check for untracked files
+            const untrackedFiles = execSync('git ls-files --others --exclude-standard', {
+                encoding: 'utf-8',
+            }).trim();
+            if (!untrackedFiles) {
+                console.log('No changes to commit');
+                return;
+            }
+        }
+        catch {
+            // There are changes, proceed with commit
+        }
+        // Stage all changes
+        execSync('git add -A', { stdio: 'inherit' });
+        // Create commit with issue ID and status
+        const commitMessage = `${issueId} ${status}`;
+        execSync(`git commit -m "${commitMessage.replace(/"/g, '\\"')}"`, {
+            stdio: 'inherit',
+        });
+        console.log(`\nGit commit created: ${commitMessage}`);
+    }
+    catch (error) {
+        console.error(`Failed to create git commit: ${String(error)}`);
+    }
+}
+function getDefaultPromptTemplate() {
+    return `You are a task automation agent processing issues from a queue.
+
+## Your Environment
+
+- [ISSUES_DIR]/[ISSUE_DIR_OPEN]/     - Issues to be processed
+- [ISSUES_DIR]/[ISSUE_DIR_REVIEW]/   - Completed issues
+- [ISSUES_DIR]/[ISSUE_DIR_STUCK]/    - Issues requiring human intervention
+- [FAQ_DIR]/                         - Troubleshooting
+
+## Issue File Format
+
+Issues are markdown files named: \`p{priority}-{order}-{description}.md\`
+
+Examples:
+- \`p0-100-fix-critical-bug.md\` (priority 0, order 100)
+- \`p1-050-add-feature.md\` (priority 1, order 50)
+
+Priority scheme:
+- p0: Urgent/unexpected work
+- p1: Normal feature work
+- p2: Non-blocking follow-up
+
+Issue files contain a conversation in this format:
+
+\`\`\`
+@user: Please build the widget factory.
+
+---
+
+@claude: I have built the widget factory.
+
+Here is a summary of the work I have done:
+- Item 1
+- Item 2
+
+---
+
+@user: Here is feedback on your work.
+
+---
+
+@claude: I have implemented your feedback.
+\`\`\`
+
+## Your Task for This Iteration
+
+Your issue file: [ISSUE_FILE_PATH]
+
+1. **Read the issue**: Parse the conversation history in [ISSUE_FILE_PATH] to understand the task
+2. **Work on the task**: Do what the issue requests. When encountering issues, always check for a relevant guide in [FAQ_DIR]/ first.
+3. **Append your response**: Add your summary to [ISSUE_FILE_PATH] using this format:
+   \`\`\`
+   ---
+
+   @claude: [Your summary here]
+
+   Here is a summary of the work I have done:
+   - Item 1
+   - Item 2
+   - Item 3
+   \`\`\`
+
+4. **Decide the outcome**: Choose ONE of the following actions:
+
+   a. **CONTINUE** - You made progress but the task isn't complete yet
+      - Leave the issue in \`[ISSUES_DIR]/[ISSUE_DIR_OPEN]/\` for the next iteration
+      - Use this when you need multiple iterations to complete a complex task
+
+   b. **COMPLETE** - The task is fully finished
+      - Move the issue to \`[ISSUES_DIR]/[ISSUE_DIR_REVIEW]/\` using: \`mv "[ISSUE_FILE_PATH]" "[ISSUES_DIR]/[ISSUE_DIR_REVIEW]/[ISSUE_FILE]"\`
+
+   c. **DECOMPOSE** - The task is too large and should be broken into smaller sub-tasks
+      - Create child issues in \`[ISSUES_DIR]/[ISSUE_DIR_OPEN]/\` with \`-001.md\`, \`-002.md\` suffixes
+      - Each child issue should start with: \`@user: [clear, actionable task description]\`
+      - Example: If parent is \`p1-050-add-auth.md\`, create:
+        - \`p1-050-add-auth-001.md\` for subtask 1
+        - \`p1-050-add-auth-002.md\` for subtask 2
+      - Move the parent issue to \`[ISSUES_DIR]/[ISSUE_DIR_REVIEW]/\`
+
+   d. **STUCK** - You cannot proceed without human intervention
+      - Explain clearly why you're stuck in your summary
+      - Move the issue to \`[ISSUES_DIR]/[ISSUE_DIR_STUCK]/\` using: \`mv "[ISSUE_FILE_PATH]" "[ISSUES_DIR]/[ISSUE_DIR_STUCK]/[ISSUE_FILE]"\`
+
+## Important Notes
+
+- Each invocation of this script is a separate session - you won't remember previous iterations
+- Always read the full conversation history in the issue file to understand context
+- Be thoughtful about when to CONTINUE vs COMPLETE - don't leave trivial tasks incomplete
+- When creating child issues, make each one focused and actionable
+- Use bash commands (mv, cat, echo) to manage files - you have full filesystem access
+
+**Critical:** ALWAYS check the FAQ directory ([FAQ_DIR]/) to see if there is a guide when you encounter a problem.
+
+Now, please process the issue at [ISSUE_FILE_PATH].`;
+}
+async function loadOrCreatePromptTemplate(promptFile) {
+    // If prompt file exists, load it
+    try {
+        await fs.access(promptFile);
+        console.log(`Loading prompt template from: ${promptFile}`);
+        return await fs.readFile(promptFile, 'utf-8');
+    }
+    catch {
+        // Otherwise, create the default prompt template
+        console.log(`Prompt file not found. Creating default template at: ${promptFile}`);
+        const defaultTemplate = getDefaultPromptTemplate();
+        // Ensure the directory exists
+        const promptDir = path.dirname(promptFile);
+        await fs.mkdir(promptDir, { recursive: true });
+        // Write the default template
+        await fs.writeFile(promptFile, defaultTemplate, 'utf-8');
+        return defaultTemplate;
+    }
+}
+function buildSystemPrompt(template, issuesDir, faqDir, issueFile) {
+    const issueFilePath = path.join(issuesDir, ISSUE_DIR_OPEN, issueFile);
+    // Convert all paths to absolute paths for clarity in the prompt
+    const absoluteIssuesDir = path.resolve(issuesDir);
+    const absoluteFaqDir = path.resolve(faqDir);
+    const absoluteIssueFilePath = path.resolve(issueFilePath);
+    // Replace template variables with actual values
+    return template
+        .replace(/\[ISSUES_DIR\]/g, absoluteIssuesDir)
+        .replace(/\[FAQ_DIR\]/g, absoluteFaqDir)
+        .replace(/\[ISSUE_DIR_OPEN\]/g, ISSUE_DIR_OPEN)
+        .replace(/\[ISSUE_DIR_REVIEW\]/g, ISSUE_DIR_REVIEW)
+        .replace(/\[ISSUE_DIR_STUCK\]/g, ISSUE_DIR_STUCK)
+        .replace(/\[ISSUE_FILE_PATH\]/g, absoluteIssueFilePath)
+        .replace(/\[ISSUE_FILE\]/g, issueFile);
+}
+function logToolUse(block) {
+    process.stdout.write('\n');
+    process.stdout.write(`[${block.name}] `);
+    switch (block.name.toLowerCase()) {
+        case 'read':
+        case 'write':
+        case 'edit':
+            process.stdout.write(`${block.input?.file_path}`);
+            break;
+        case 'bash':
+            process.stdout.write(`${block.input?.command}`);
+            break;
+        case 'glob':
+            process.stdout.write(`${block.input?.pattern}`);
+            break;
+        case 'todowrite': {
+            for (const todo of block.input?.todos ?? []) {
+                process.stdout.write('\n');
+                switch (todo.status) {
+                    case 'in_progress':
+                        process.stdout.write('⧖');
+                        break;
+                    case 'pending':
+                        process.stdout.write('☐');
+                        break;
+                    case 'completed':
+                        process.stdout.write('✓');
+                        break;
+                    default:
+                        process.stdout.write(todo.status);
+                        break;
+                }
+                process.stdout.write(' ');
+                process.stdout.write(String(todo.content));
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    process.stdout.write('\n');
+}
+function logSDKMessage(item) {
+    switch (item.type) {
+        case 'assistant':
+        case 'user':
+            for (const chunk of item.message.content) {
+                if (typeof chunk === 'string') {
+                    process.stdout.write('\n');
+                    process.stdout.write(chunk);
+                    process.stdout.write('\n');
+                    continue;
+                }
+                switch (chunk.type) {
+                    case 'text':
+                        process.stdout.write('\n');
+                        process.stdout.write(chunk.text);
+                        process.stdout.write('\n');
+                        break;
+                    case 'tool_use':
+                        logToolUse(chunk);
+                        break;
+                    default:
+                        break;
+                }
+            }
+            break;
+        default:
+            break;
+    }
+}
+async function runAgent(options) {
+    const { template, issuesDir, faqDir, issueFile, continueMode, continuePrompt } = options;
+    const systemPrompt = buildSystemPrompt(template, issuesDir, faqDir, issueFile);
+    console.log('\n--- Starting agent ---');
+    const stream = query({
+        prompt: continueMode ? continuePrompt : systemPrompt,
+        options: {
+            settingSources: ['local', 'project', 'user'],
+            permissionMode: 'acceptEdits',
+            continue: continueMode,
+        },
+    });
+    for await (const item of stream) {
+        logSDKMessage(item);
+    }
+    console.log('\n--- Agent finished ---');
+}
+async function main() {
+    const config = parseArgs();
+    console.log('Bueller? Bueller?');
+    console.log('-----------------');
+    console.log(`Issues directory: ${config.issuesDir}`);
+    console.log(`FAQ directory: ${config.faqDir}`);
+    console.log(`Max iterations: ${config.maxIterations}`);
+    console.log(`Git auto-commit: ${config.gitCommit ? 'enabled' : 'disabled'}`);
+    console.log(`Prompt file: ${config.promptFile}`);
+    if (config.continueMode) {
+        console.log(`Continue mode: enabled (prompt: "${config.continuePrompt}")`);
+    }
+    await ensureDirectories(config.issuesDir, config.faqDir);
+    // Load or create the prompt template
+    const promptTemplate = await loadOrCreatePromptTemplate(config.promptFile);
+    let iteration = 0;
+    while (iteration < config.maxIterations) {
+        iteration++;
+        console.log(`\n### Iteration ${iteration} ###\n`);
+        const openIssues = await getOpenIssues(config.issuesDir);
+        if (openIssues.length === 0) {
+            console.log('No more issues in open/. Exiting.');
+            break;
+        }
+        console.log(`Found ${openIssues.length} open issue(s)`);
+        console.log(`Next issue: ${openIssues[0]}`);
+        const currentIssue = openIssues[0];
+        await runAgent({
+            template: promptTemplate,
+            issuesDir: config.issuesDir,
+            faqDir: config.faqDir,
+            issueFile: currentIssue,
+            continueMode: config.continueMode,
+            continuePrompt: config.continuePrompt,
+        });
+        // Auto-commit if enabled and there's a current issue
+        if (config.gitCommit && currentIssue) {
+            // Determine the status based on where the issue ended up
+            let isNowInReview = false;
+            let isNowInStuck = false;
+            let isStillInOpen = false;
+            try {
+                await fs.access(path.join(config.issuesDir, ISSUE_DIR_REVIEW, currentIssue));
+                isNowInReview = true;
+            }
+            catch {
+                // File doesn't exist in review
+            }
+            try {
+                await fs.access(path.join(config.issuesDir, ISSUE_DIR_STUCK, currentIssue));
+                isNowInStuck = true;
+            }
+            catch {
+                // File doesn't exist in stuck
+            }
+            try {
+                await fs.access(path.join(config.issuesDir, ISSUE_DIR_OPEN, currentIssue));
+                isStillInOpen = true;
+            }
+            catch {
+                // File doesn't exist in open
+            }
+            let status = 'unknown';
+            if (isNowInReview) {
+                status = 'done';
+            }
+            else if (isNowInStuck) {
+                status = 'stuck';
+            }
+            else if (isStillInOpen) {
+                status = 'in progress';
+            }
+            gitCommit(currentIssue, status);
+        }
+    }
+    if (iteration >= config.maxIterations) {
+        console.log(`\nReached maximum iterations (${config.maxIterations}). Exiting.`);
+    }
+    console.log('\nDone!');
+}
+main().catch((error) => {
+    console.error('Error:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,69 @@
+{
+	"name": "bueller-wheel",
+	"version": "0.1.0",
+	"description": "Headless Claude Code issue processor - A wrapper that runs Claude Code in a loop to process issues from a directory queue",
+	"type": "module",
+	"main": "dist/index.js",
+	"bin": {
+		"bueller-wheel": "dist/index.js"
+	},
+	"scripts": {
+		"build": "rm -rf dist out && tsc && mkdir -p dist && cp out/src/index.js dist/index.js && echo '#!/usr/bin/env node' | cat - dist/index.js > dist/index.tmp && mv dist/index.tmp dist/index.js && chmod +x dist/index.js",
+		"dev": "tsx src/index.ts",
+		"start": "node dist/index.js",
+		"test": "tsx tests/test-runner.ts",
+		"typecheck": "tsc --noEmit",
+		"lint": "eslint .",
+		"lint:fix": "eslint . --fix",
+		"format": "prettier --write ."
+	},
+	"keywords": [
+		"claude",
+		"claude-code",
+		"automation",
+		"ai",
+		"issue-tracker",
+		"task-automation",
+		"agent"
+	],
+	"author": "Andrew Fong <id@andrewfong.com>",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/fongandrew/bueller-wheel.git"
+	},
+	"bugs": {
+		"url": "https://github.com/fongandrew/bueller-wheel/issues"
+	},
+	"homepage": "https://github.com/fongandrew/bueller-wheel#readme",
+	"files": [
+		"dist/index.js",
+		"README.md",
+		"LICENSE"
+	],
+	"engines": {
+		"node": ">=18.0.0"
+	},
+	"devDependencies": {
+		"@anthropic-ai/sdk": "^0.71.0",
+		"@eslint/js": "^9.30.1",
+		"@types/node": "^24.0.10",
+		"@typescript-eslint/parser": "^8.47.0",
+		"eslint": "^9.30.1",
+		"eslint-config-prettier": "^10.1.5",
+		"eslint-plugin-import": "^2.32.0",
+		"eslint-plugin-prettier": "^5.5.1",
+		"eslint-plugin-simple-import-sort": "^12.1.1",
+		"eslint-plugin-unused-imports": "^4.1.4",
+		"globals": "^16.3.0",
+		"install": "^0.13.0",
+		"npm": "^11.6.4",
+		"prettier": "^3.6.2",
+		"tsx": "^4.19.2",
+		"typescript": "^5.8.3",
+		"typescript-eslint": "^8.47.0"
+	},
+	"dependencies": {
+		"@anthropic-ai/claude-agent-sdk": "^0.1.55"
+	}
+}