millhouse 0.1.0 → 0.3.1

package/prompts/implementation.prompt.md

@@ -0,0 +1,190 @@
+# Your Task
+
+Implement task #{{issue.number}}: {{issue.title}}
+
+## Description
+
+{{issue.body}}
+
+## Likely Affected Files
+
+{{affectedPaths}}
+
+## Project Context
+
+A summary of the project structure is available in `CLAUDE.md` in the repository root. **Read this file first** to understand the codebase architecture, conventions, and where different types of code belong.
+{{#if hasPriorWork}}
+
+## Prior Work
+
+This task depends on work that has already been completed. Summaries of that prior work are available in `MILLHOUSE_PRIOR_WORK.md` in the repository root. **Read this file first** to understand what has already been implemented before starting your work.
+{{/if}}
+
+## Instructions
+
+You are an expert software engineer implementing a specific task. Follow these steps:
+
+### 1. Understand the Context
+- Read the task description carefully, paying close attention to any **acceptance criteria**
+- Explore the relevant code paths mentioned in "Likely Affected Files"
+- Understand the existing patterns and conventions in the codebase
+- If the task references other tasks or PRs, consider their context
+
+### 2. Plan Your Implementation
+- Identify all files that need to be modified
+- Consider edge cases and error handling
+- Think about backward compatibility if relevant
+- Keep changes minimal and focused on the task
+
+### 3. Implement the Solution
+- Make the necessary code changes
+- Follow the existing code style and patterns
+- Add appropriate error handling
+- Update or add tests if the codebase has them
+
+### 4. Test and Verify - CRITICAL
+
+**You MUST verify your implementation before completing:**
+
+1. Run all existing tests to ensure nothing is broken
+2. Think deeply about how to fully test the acceptance criteria from the task
+3. Run any test commands specified in the task
+4. Verify each acceptance criterion is satisfied
+
+**If any tests fail or acceptance criteria are not met:**
+- Analyze the failure and make corrections
+- Re-run tests and re-verify
+- Repeat until ALL tests pass and ALL acceptance criteria are satisfied
+
+**If you cannot make progress:**
+- If you've made several attempts without progress, or you detect you're in a loop, exit with an error explaining the situation
+- If human input is required to proceed, exit with an error explaining what's needed
+
+**DO NOT REPORT SUCCESS IF ANY TESTS FAIL OR ANY ACCEPTANCE CRITERIA ARE NOT MET.**
+
+### 5. Commit and Update Run Branch
+
+First, commit your changes on your issue branch:
+
+- Stage your changes with `git add <files>`
+- Create a single commit with a comprehensive message that includes:
+  - A clear summary line describing the change
+  - A detailed body explaining:
+    - What was implemented
+    - Key files added or modified
+    - How acceptance criteria were satisfied
+    - Any important implementation decisions
+  - End with "Fixes #{{issue.number}}"
+
+Then, merge your changes INTO the run branch:
+
+```bash
+# Loop until we successfully update the run branch
+while true; do
+  # Merge the latest run branch into your issue branch
+  git merge millhouse/run-{{runId}} --no-edit
+
+  # If there are merge conflicts, resolve them:
+  # - Carefully examine each conflict
+  # - Preserve both your changes and changes from other workers
+  # - Test that everything still works after resolving
+  # - Stage resolved files with: git add <resolved-files>
+  # - Complete the merge with: git commit --no-edit
+
+  # Update the run branch to point to your merged commit
+  # This will fail if another worker updated it since we merged
+  if git push . HEAD:millhouse/run-{{runId}}; then
+    echo "Successfully updated run branch"
+    break
+  fi
+
+  echo "Run branch was updated by another worker, merging again..."
+done
+```
+
+**IMPORTANT**: You MUST successfully update the run branch before exiting. The orchestrator relies on this to collect all changes.
+
+## Important Rules
+
+1. **You are working in a git worktree** on your own issue branch
+   - Your working directory is isolated from other parallel tasks
+   - After committing, you MUST merge your changes into the run branch `millhouse/run-{{runId}}`
+
+2. **Do NOT create a pull request**
+   - The orchestrator handles PR creation after all tasks complete
+   - Just commit your changes with proper messages
+
+3. **Stay focused on this task**
+   - Don't fix unrelated problems you notice
+   - Don't refactor code beyond what's needed for this task
+   - If you notice important problems, mention them in your summary
+
+4. **Handle blockers appropriately**
+   - If you encounter a blocker that requires human input, exit with an error
+   - Don't try to work around fundamental problems
+
+5. **Keep changes minimal**
+   - Your changes will be merged with other parallel tasks
+   - Minimize the chance of merge conflicts by changing only what's necessary
+
+## Git Commands Reference
+
+```bash
+# Stage specific files
+git add src/path/to/file.ts
+
+# Stage all changes (use with caution)
+git add -A
+
+# Commit with comprehensive message
+git commit -m "feat: add math utility functions
+
+Implemented add() and multiply() functions in src/utils/math.ts.
+
+Changes:
+- Created src/utils/math.ts with exported functions
+- Added input validation for edge cases
+- Verified TypeScript compilation passes
+
+Acceptance criteria satisfied:
+- [x] Functions exported correctly
+- [x] No type errors
+
+Fixes #{{issue.number}}"
+
+# Check status
+git status
+
+# View changes
+git diff
+```
+
+## When You're Done
+
+**Create a summary file** called `MILLHOUSE_SUMMARY.md` in the repository root with the following format:
+
+```markdown
+## Summary
+[2-3 sentence description of what was accomplished]
+
+## Files Changed
+- path/to/file1.ts (created|modified|deleted)
+- path/to/file2.ts (created|modified|deleted)
+
+## Key Changes
+- [Important change 1]
+- [Important change 2]
+- [Important change 3]
+
+## Test Status
+[passed|failed|skipped] - [brief note if relevant]
+```
+
+This summary will be passed to any dependent tasks that run after you.
+
+Then provide a final message that includes:
+1. What you changed and why
+2. Any important implementation decisions
+3. Test results and verification of acceptance criteria
+4. Any notes for reviewers
+5. Any potential concerns or follow-up items

package/prompts/issue-analysis.prompt.md

@@ -0,0 +1,34 @@
+Analyze these GitHub issues and determine their dependencies and execution order.
+
+## Issues to Analyze
+
+{{issuesList}}
+
+---
+
+## Your Task
+
+Analyze each issue and determine:
+1. **dependencies**: Which issues MUST be completed BEFORE this issue can start
+2. **affectedPaths**: File paths this issue will likely create or modify
+
+Respond with ONLY a JSON array (no markdown, no explanation):
+[
+  {
+    "issueNumber": 1,
+    "dependencies": [],
+    "affectedPaths": ["src/path/to/file.ts"]
+  },
+  {
+    "issueNumber": 2,
+    "dependencies": [1],
+    "affectedPaths": ["src/other/file.ts"]
+  }
+]
+
+Rules:
+- Look for explicit dependency mentions: "depends on #X", "after #X", "blocked by #X", "requires #X"
+- Also infer logical dependencies (e.g., if issue B imports from a file that issue A creates)
+- Only include dependencies between issues in this list
+- affectedPaths should be specific file paths mentioned or implied
+- Respond with ONLY valid JSON, nothing else

package/prompts/plan-analysis.prompt.md

@@ -0,0 +1,45 @@
+Analyze this plan and break it into discrete, implementable work items.
+
+## Plan
+
+{{plan}}
+
+---
+
+## Your Task
+
+Break this plan into discrete work items that can be implemented independently (but may have dependencies on each other).
+
+For each work item, provide:
+1. **id**: Sequential number starting from 1
+2. **title**: Short descriptive title
+3. **body**: Full implementation details including:
+   - What to create/modify
+   - Specific file paths
+   - Function signatures or interfaces
+   - Testing instructions
+   - Acceptance criteria
+4. **dependencies**: IDs of work items that MUST be completed before this one
+
+Respond with ONLY a JSON array (no markdown, no explanation):
+[
+  {
+    "id": 1,
+    "title": "Initialize project",
+    "body": "Create the project structure...\n\n## Implementation\n...",
+    "dependencies": []
+  },
+  {
+    "id": 2,
+    "title": "Create utilities",
+    "body": "Create utility functions...\n\n**Depends on #1**\n\n## Implementation\n...",
+    "dependencies": [1]
+  }
+]
+
+Rules:
+- Each work item should be self-contained with all context needed to implement it
+- Include "**Depends on #N**" in the body text for any dependencies
+- Work items should be small enough to implement in one session
+- Include specific file paths, function signatures, and acceptance criteria
+- Respond with ONLY valid JSON, nothing else