millhouse 0.1.0

package/LICENSE

@@ -0,0 +1,8 @@
+Copyright 2026 David Brophy
+
+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,248 @@
+# Millhouse
+
+Millhouse orchestrates parallel Claude Code instances to automatically implement work items. It supports two modes:
+
+- **GitHub Mode:** Point it at GitHub issues and it discovers related issues, analyzes dependencies, and creates a PR with all changes
+- **Plan Mode:** Give it any plan file (markdown, text) and it breaks it into work items automatically - no GitHub required
+
+In both modes, Millhouse executes work items in parallel where possible, respecting dependency order.
+
+## Quick Start
+
+### Plan Mode
+
+In Claude Code:
+```
+/millhouse plan             # Refine your plan for millhouse
+```
+... then exit Claude Code and run at the command line:
+```bash
+millhouse run               # Execute the most recent plan
+millhouse run plan.md       # Execute a specific plan file
+```
+
+### GitHub Issues Mode
+
+In Claude Code:
+```
+/millhouse plan             # Refine your plan for millhouse
+/millhouse issues           # Create GitHub issues from your plan
+```
+... then exit Claude Code and run at the command line:
+```bash
+millhouse run issues        # Run all open GitHub issues
+millhouse run issues 5      # Run issue #5 and linked issues
+millhouse run issues 1,2,3  # Run these issues and any linked issues
+```
+
+## Slash Commands
+
+### /millhouse plan
+
+Refines a rough plan into a millhouse-ready format. Use this before running `/millhouse issues` or `millhouse run`.
+
+```
+/millhouse plan                # Refine the current plan
+/millhouse plan plan.md        # Refine an existing plan file
+```
+
+This transforms your plan to have:
+- **Clearly separated work items** - each runs in a separate context
+- **Appropriately-sized tasks** - small enough to complete unattended
+- **Self-contained descriptions** - all context included, nothing assumed
+- **Acceptance criteria** - how to verify each task is complete
+- **Testing instructions** - specific commands and expected results
+- **Explicit dependencies** - what must complete before each task
+
+### /millhouse issues
+
+Creates GitHub issues from a plan. Use this for GitHub mode.
+
+```
+/millhouse issues              # Create issues from the current plan
+/millhouse issues plan.md      # Create issues from a plan file
+```
+
+## How It Works
+
+### Dependency Analysis
+
+When you run millhouse, it sends your work items to Claude to analyze dependencies. It understands:
+- Explicit markers: "Depends on #1", "Blocked by #2", "After #3"
+- Logical dependencies: If task B imports from a file that task A creates
+- Semantic relationships: Claude infers dependencies automatically
+
+### Parallel Execution
+
+Work items are organized into a dependency graph. The scheduler:
+- Starts all items with no dependencies in parallel (up to concurrency limit)
+- As each item completes, unblocks dependent items
+- Dynamically schedules newly-unblocked items
+
+### Git Worktrees
+
+Each work item runs in complete isolation:
+- Creates a branch: `millhouse/run-{runId}-issue-{N}`
+- Creates a git worktree in `.millhouse/worktrees/run-{runId}-issue-{N}`
+- Claude Code runs in that worktree with full autonomy
+- Changes are committed to the item's branch
+- On completion, branches are merged back to the run branch
+
+### GitHub Mode vs Plan Mode
+
+| | GitHub Mode                                | Plan Mode                     |
+|---|--------------------------------------------|---------------------------------|
+| Input | GitHub issues                              | Any text/markdown file        |
+| Setup | `/millhouse plan` then `/millhouse issues` | `/millhouse plan`             |
+| Run | `millhouse run issues [id]`                | `millhouse run [file.md]`     |
+| Output | Pull request                               | Changes on local branch       |
+| Labels | Auto-managed                               | N/A                           |
+
+## CLI Reference
+
+### Running
+
+```bash
+# Plan mode (default)
+millhouse run                    # Run most recent plan from ~/.claude/plans/
+millhouse run plan.md            # Run a specific plan file
+
+# GitHub issues mode (always discovers linked issues)
+millhouse run issues             # Run all open issues
+millhouse run issues 5           # Run issue #5 and linked issues
+millhouse run issues 1,2,3       # Run these issues and linked issues
+
+# Options (work with both modes)
+millhouse run --dry-run          # Preview without executing
+millhouse run -n 16              # Set parallel workers (default: 8)
+millhouse run -d detailed        # Start in detailed view (default: compact)
+millhouse run --dangerously-skip-permissions  # Unattended execution
+```
+
+### Other Commands
+
+```bash
+millhouse status              # Show all runs
+millhouse status --run-id X   # Show specific run
+millhouse resume <run-id>     # Resume interrupted run
+millhouse clean               # Clean up leftover state
+```
+
+## Writing Good Plans
+
+For best results, use `/millhouse plan` to refine your plan. Or write plans that include:
+
+**Clear task separation:**
+```markdown
+## 1. Create Math Utilities
+Create `src/math.ts` with add, subtract, multiply, divide functions.
+
+## 2. Create Calculator Class
+Create `src/calculator.ts` that uses the math utilities.
+**Depends on task 1.**
+```
+
+**Specific implementation details:**
+```markdown
+Create `src/math.ts` with:
+- `add(a: number, b: number): number`
+- `subtract(a: number, b: number): number`
+```
+
+**Testing instructions:**
+```markdown
+## Testing
+Run `npm test` - all tests should pass.
+Run `npm run build` - should compile without errors.
+```
+
+**Acceptance criteria:**
+```markdown
+## Acceptance Criteria
+- [ ] All four math functions exported
+- [ ] Tests cover edge cases (division by zero)
+- [ ] TypeScript compiles with strict mode
+```
+
+## Installation
+
+```bash
+npm install -g millhouse
+```
+
+Then install the `/millhouse` slash command for Claude Code:
+
+```bash
+millhouse setup --global
+```
+
+### Development Install
+
+If you want to contribute or modify millhouse:
+
+```bash
+git clone https://github.com/dave/millhouse.git
+cd millhouse
+npm install
+npm run build
+npm link
+```
+
+
+## Prerequisites
+
+- Node.js 20+
+- Claude Code installed and authenticated
+- GitHub CLI (`gh`) authenticated (GitHub mode only)
+
+## Configuration
+
+Create `.millhouserc.json` in your project root:
+
+```json
+{
+  "execution": {
+    "concurrency": 8,
+    "baseBranch": "main",
+    "continueOnError": true
+  },
+  "pullRequests": {
+    "createAsDraft": true,
+    "mergeStrategy": "squash"
+  }
+}
+```
+
+| Option | Description | Default |
+|---|---|---|
+| `concurrency` | Max parallel Claude instances | 8 |
+| `baseBranch` | Branch to base work on | main |
+| `continueOnError` | Keep going if one item fails | true |
+| `createAsDraft` | Create PR as draft | true |
+| `mergeStrategy` | PR merge strategy | squash |
+
+## GitHub Labels (GitHub Mode Only)
+
+Millhouse automatically manages labels to show progress:
+
+| Label | Meaning |
+|---|---|
+| `millhouse:queued` | Waiting in queue |
+| `millhouse:in-progress` | Claude is actively working |
+| `millhouse:blocked` | Waiting for dependency |
+| `millhouse:failed` | Execution failed |
+| `millhouse:done` | Completed successfully |
+
+## Troubleshooting
+
+**Worktree errors after interrupted run:**
+```bash
+millhouse clean
+```
+
+**To see what Claude is doing:**
+The CLI shows real-time activity for each work item. Use `-d detailed` to start in detailed view, or press `v` to toggle during execution.
+
+## License
+
+MIT

package/commands/millhouse.md

@@ -0,0 +1,223 @@
+# Millhouse
+
+Orchestrate parallel Claude Code instances to implement work items.
+
+## Usage
+
+Parse $ARGUMENTS to determine the subcommand:
+
+- `/millhouse plan [plan-file]` - Refine a plan for millhouse execution
+- `/millhouse issues [plan-file]` - Create GitHub issues from a plan
+
+---
+
+## /millhouse plan
+
+Refine and improve a plan to make it suitable for millhouse execution. This should be fast and unattended - don't ask clarifying questions, just improve the plan.
+
+### Context
+
+Millhouse executes work items in **parallel using separate Claude Code instances**, each running **unattended in its own context window**. This means:
+
+- Each work item is a fresh start with no memory of previous work
+- Work items must be completely self-contained
+- Nothing can be assumed or left implicit
+
+### Instructions
+
+1. Read the plan from the file path argument. If no file given, look for plan.md or ask for the filename only.
+2. Analyze the plan and rewrite it following the guidelines below
+3. Save the improved plan to the same file (overwrite), or `plan.md` if it was a new plan
+4. **Do not ask questions about features, scope, or implementation details** - work with what's given
+5. **Do not suggest additions** - only restructure and clarify what's already in the plan
+
+### Plan Improvement Guidelines
+
+Transform the plan to be millhouse-ready:
+
+**1. Separate work items clearly**
+- Each work item should be a distinct section
+- Work items will run in separate contexts, stage by stage
+- Make boundaries between items obvious
+
+**2. Split into appropriately-sized tasks**
+- Break large tasks into smaller sub-tasks where necessary
+- Each task should be small enough to complete in one go, unattended
+- A task that's "create an entire application" is too big
+- A task that's "create a function that adds two numbers" might be too small (unless it's a dependency)
+
+**3. Make each task self-contained**
+- Include ALL context needed to implement the task
+- Specify exact file paths to create or modify
+- Include function signatures, types, interfaces
+- Don't assume knowledge from other tasks
+
+**4. Add thorough acceptance criteria**
+- How do we know this task is done?
+- What commands verify it works? (e.g., `npm test`, `go build`)
+- What should the output look like?
+- What edge cases should be handled?
+
+**5. Add testing instructions**
+- Specific test commands to run
+- Expected results
+- How to verify integration with other components
+
+**6. Make dependencies explicit**
+- Which tasks must complete before this one can start?
+- What does this task need from its dependencies? (files, exports, etc.)
+- Use clear language like "This requires the math utilities from task 1"
+
+### Important: Be Non-Interactive
+
+- **Don't ask** if the user wants to add features, tests, or documentation
+- **Don't suggest** expanding scope or adding "nice to haves"
+- **Just restructure** the existing plan into millhouse-ready format
+- If something is ambiguous, make a reasonable assumption and note it in the task
+
+### Example Transformation
+
+**Before (too vague):**
+```markdown
+# My App
+- Build a calculator
+- Add tests
+```
+
+**After (millhouse-ready):**
+```markdown
+# Calculator App
+
+## 1. Initialize TypeScript Project
+Create the project structure with TypeScript configuration.
+
+### Implementation
+- Create `package.json` with name "calculator", typescript and vitest as dev dependencies
+- Create `tsconfig.json` with strict mode, ES2020 target, NodeNext module resolution
+- Create `src/` directory
+
+### Testing
+Run `npm install` and `npx tsc --noEmit` - should complete without errors.
+
+### Acceptance Criteria
+- [ ] `package.json` exists with correct dependencies
+- [ ] `tsconfig.json` exists with strict mode enabled
+- [ ] `src/` directory exists
+- [ ] `npm install && npx tsc --noEmit` succeeds
+
+## 2. Create Math Utilities
+Create basic arithmetic functions used by the calculator.
+
+**Depends on task 1** - needs the TypeScript project structure.
+
+### Implementation
+Create `src/math.ts` with:
+- `add(a: number, b: number): number` - returns sum
+- `subtract(a: number, b: number): number` - returns difference
+- `multiply(a: number, b: number): number` - returns product
+- `divide(a: number, b: number): number` - returns quotient, throws on division by zero
+
+### Testing
+Create `src/math.test.ts` with vitest tests for all functions including edge cases.
+Run `npx vitest run` - all tests should pass.
+
+### Acceptance Criteria
+- [ ] `src/math.ts` exports all four functions
+- [ ] `src/math.test.ts` has tests for each function
+- [ ] Tests cover division by zero error case
+- [ ] `npx vitest run` passes all tests
+```
+
+---
+
+## /millhouse issues
+
+Convert a plan into GitHub issues formatted for Millhouse.
+
+### Critical Context
+
+These issues will be implemented by Claude Code instances running **unattended in separate context windows**. Each issue is a fresh start with no memory of previous conversations. This means:
+
+- Every issue must be completely self-contained
+- All relevant context, requirements, and constraints must be explicitly stated
+- Nothing can be assumed or left implicit
+
+### Instructions
+
+1. Read the plan from the file path argument, or ask the user to describe it
+2. Break it into discrete, implementable issues
+3. For each issue, identify dependencies on other issues
+4. Create issues in order using `gh issue create`, starting with issues that have no dependencies
+5. Use the actual issue numbers returned by GitHub for dependency references
+6. After creating all issues, create an **index issue** that lists them all (see below)
+
+### Issue Content Requirements
+
+Each issue MUST include:
+
+**Implementation Details**
+- Specific file paths to create or modify
+- Function signatures, types, or interfaces expected
+- Any specific libraries or patterns to use
+
+**Testing & Verification**
+- How to verify the implementation works
+- Specific test commands to run (e.g., `npm test`, `npm run build`)
+- Expected output or behavior
+
+**Acceptance Criteria**
+- Clear, checkable criteria for when the issue is "done"
+- Edge cases to handle
+- Error conditions to consider
+
+**Dependencies**
+- `**Depends on #N**` if it depends on another issue
+- What specifically it needs from that dependency (files, exports, etc.)
+
+### Example Issue Body
+
+```markdown
+Create `src/utils/math.ts` with basic arithmetic functions.
+
+## Implementation
+- Export functions: `add(a: number, b: number): number` and `multiply(a: number, b: number): number`
+- Use ES module syntax (export, not module.exports)
+- No external dependencies
+
+## Testing
+Run `npx tsc --noEmit` to verify no type errors.
+
+## Acceptance Criteria
+- [ ] File exists at `src/utils/math.ts`
+- [ ] Both functions are exported
+- [ ] TypeScript compiles without errors
+```
+
+### Index Issue
+
+After creating all implementation issues, create a final **index issue** that serves as an overview. Title it something like "Implement [feature name]" and include:
+
+- A one-line summary of the overall goal
+- A list of all created issues with their numbers and a brief description
+- The command to run: `millhouse run issues <index-number>`
+
+Example:
+
+```markdown
+Implement a calculator library with math utilities.
+
+## Issues
+
+- #1 Create math utilities (`src/utils/math.ts`)
+- #2 Create string helpers (`src/utils/string.ts`)
+- #3 Create calculator class (`src/calculator.ts`)
+- #4 Create main entry point (`src/index.ts`)
+
+## Run
+
+\`\`\`bash
+millhouse run issues <this-issue-number>
+\`\`\`
+```
+
+The index issue should **not** include detailed dependency information—Millhouse will discover dependencies from the individual issues.

package/dist/analysis/graph-builder.d.ts

@@ -0,0 +1,42 @@
+import type { AnalyzedIssue } from '../types.js';
+export interface DependencyGraph {
+    /**
+     * Get all issue numbers that this issue depends on.
+     */
+    getDependencies(issueNumber: number): number[];
+    /**
+     * Get all issue numbers that depend on this issue.
+     */
+    getDependents(issueNumber: number): number[];
+    /**
+     * Get issues that are ready to start (all dependencies completed).
+     */
+    getReady(completed: number[]): number[];
+    /**
+     * Get issues that are blocked (have uncompleted dependencies).
+     */
+    getBlocked(completed: number[]): number[];
+    /**
+     * Get topological order of issues.
+     */
+    getTopologicalOrder(): number[];
+    /**
+     * Check if the graph is a valid DAG (no cycles).
+     */
+    isAcyclic(): boolean;
+    /**
+     * Get cycles if any exist.
+     */
+    getCycles(): number[][];
+    /**
+     * Get all issue numbers in the graph.
+     */
+    getAllIssues(): number[];
+}
+export declare class GraphBuilder {
+    /**
+     * Build a dependency graph from analyzed issues.
+     */
+    build(issues: AnalyzedIssue[]): DependencyGraph;
+}
+//# sourceMappingURL=graph-builder.d.ts.map

package/dist/analysis/graph-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-builder.d.ts","sourceRoot":"","sources":["../../src/analysis/graph-builder.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAIjD,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAE/C;;OAEG;IACH,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAE7C;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;IAExC;;OAEG;IACH,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;IAE1C;;OAEG;IACH,mBAAmB,IAAI,MAAM,EAAE,CAAC;IAEhC;;OAEG;IACH,SAAS,IAAI,OAAO,CAAC;IAErB;;OAEG;IACH,SAAS,IAAI,MAAM,EAAE,EAAE,CAAC;IAExB;;OAEG;IACH,YAAY,IAAI,MAAM,EAAE,CAAC;CAC1B;AAED,qBAAa,YAAY;IACvB;;OAEG;IACH,KAAK,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,eAAe;CAoBhD"}

package/dist/analysis/graph-builder.js

@@ -0,0 +1,98 @@
+import graphlib from 'graphlib';
+const { Graph, alg } = graphlib;
+export class GraphBuilder {
+    /**
+     * Build a dependency graph from analyzed issues.
+     */
+    build(issues) {
+        const graph = new Graph({ directed: true });
+        // Add all nodes
+        for (const issue of issues) {
+            graph.setNode(String(issue.number), issue);
+        }
+        // Add edges (dependency -> dependent)
+        for (const issue of issues) {
+            for (const dep of issue.dependencies) {
+                if (graph.hasNode(String(dep))) {
+                    // Edge from dependency to dependent (dep must complete before issue)
+                    graph.setEdge(String(dep), String(issue.number));
+                }
+            }
+        }
+        return new DependencyGraphImpl(graph);
+    }
+}
+class DependencyGraphImpl {
+    graph;
+    constructor(graph) {
+        this.graph = graph;
+    }
+    getDependencies(issueNumber) {
+        const predecessors = this.graph.predecessors(String(issueNumber));
+        if (!predecessors)
+            return [];
+        return predecessors.map((n) => parseInt(n, 10));
+    }
+    getDependents(issueNumber) {
+        const successors = this.graph.successors(String(issueNumber));
+        if (!successors)
+            return [];
+        return successors.map((n) => parseInt(n, 10));
+    }
+    getReady(completed) {
+        const completedSet = new Set(completed.map(String));
+        const ready = [];
+        for (const node of this.graph.nodes()) {
+            // Skip if already completed
+            if (completedSet.has(node))
+                continue;
+            // Check if all dependencies are completed
+            const deps = this.graph.predecessors(node) || [];
+            const allDepsCompleted = deps.every((d) => completedSet.has(d));
+            if (allDepsCompleted) {
+                ready.push(parseInt(node, 10));
+            }
+        }
+        return ready;
+    }
+    getBlocked(completed) {
+        const completedSet = new Set(completed.map(String));
+        const blocked = [];
+        for (const node of this.graph.nodes()) {
+            // Skip if already completed
+            if (completedSet.has(node))
+                continue;
+            // Check if any dependency is not completed
+            const deps = this.graph.predecessors(node) || [];
+            const hasPendingDeps = deps.some((d) => !completedSet.has(d));
+            if (hasPendingDeps) {
+                blocked.push(parseInt(node, 10));
+            }
+        }
+        return blocked;
+    }
+    getTopologicalOrder() {
+        try {
+            const sorted = alg.topsort(this.graph);
+            return sorted.map((n) => parseInt(n, 10));
+        }
+        catch {
+            // Graph has cycles, return empty
+            return [];
+        }
+    }
+    isAcyclic() {
+        return alg.isAcyclic(this.graph);
+    }
+    getCycles() {
+        const tarjan = alg.tarjan(this.graph);
+        // tarjan returns SCCs; cycles are SCCs with more than 1 node
+        return tarjan
+            .filter((scc) => scc.length > 1)
+            .map((scc) => scc.map((n) => parseInt(n, 10)));
+    }
+    getAllIssues() {
+        return this.graph.nodes().map((n) => parseInt(n, 10));
+    }
+}
+//# sourceMappingURL=graph-builder.js.map

package/dist/analysis/graph-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-builder.js","sourceRoot":"","sources":["../../src/analysis/graph-builder.ts"],"names":[],"mappings":"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"}

package/dist/analysis/issue-analyzer.d.ts

@@ -0,0 +1,20 @@
+import type { GitHubIssue, AnalyzedIssue } from '../types.js';
+export declare class IssueAnalyzer {
+    /**
+     * Analyze all issues in a single Claude call to determine dependencies.
+     */
+    analyzeIssues(issues: GitHubIssue[]): Promise<AnalyzedIssue[]>;
+    /**
+     * Fallback to pattern matching if Claude analysis fails.
+     */
+    private fallbackAnalysis;
+    /**
+     * Extract dependencies using pattern matching.
+     */
+    private extractDependencies;
+    /**
+     * Extract affected file paths from issue body.
+     */
+    private extractAffectedPaths;
+}
+//# sourceMappingURL=issue-analyzer.d.ts.map

package/dist/analysis/issue-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issue-analyzer.d.ts","sourceRoot":"","sources":["../../src/analysis/issue-analyzer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAqC9D,qBAAa,aAAa;IACxB;;OAEG;IACG,aAAa,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IAuFpE;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAmBxB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA8B3B;;OAEG;IACH,OAAO,CAAC,oBAAoB;CAa7B"}