wtf-p 0.1.0 → 0.2.0

package/commands/wtfp/contribute.md

@@ -0,0 +1,278 @@
+---
+name: wtfp:contribute
+description: Guide through contributing code to WTF-P via Pull Request
+allowed-tools:
+  - Bash
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+  - AskUserQuestion
+---
+
+<objective>
+Guide the user through the complete process of contributing code to WTF-P, from fork to Pull Request.
+</objective>
+
+<context>
+@~/.claude/write-the-f-paper/references/github-contrib.md
+@~/.claude/CONTRIBUTING.md
+</context>
+
+<process>
+
+## Step 1: Verify Prerequisites
+
+Check tools are available:
+```bash
+gh auth status 2>&1
+git --version
+node --version
+```
+
+If `gh` not authenticated:
+> Run `gh auth login` to authenticate with GitHub.
+
+## Step 2: Understand Contribution Type
+
+Use AskUserQuestion:
+
+**Question 1: What are you contributing?**
+- Header: "Type"
+- Options:
+  - "New command" - Add a /wtfp:* slash command
+  - "Bug fix" - Fix an existing issue
+  - "Workflow improvement" - Enhance a writing workflow
+  - "Documentation" - Improve docs or add examples
+  - "Other" - Something else
+
+**Question 2: Do you have an existing issue?**
+- Header: "Issue"
+- Options:
+  - "Yes, issue #___" - Link to existing issue
+  - "No, creating fresh" - New contribution without issue
+  - "I'll create one first" - Redirect to /wtfp:request-feature
+
+## Step 3: Setup Repository
+
+Check current state:
+```bash
+git remote -v
+```
+
+**If in wtf-p repo (maintainer):**
+```bash
+git checkout main
+git pull origin main
+git checkout -b [BRANCH_TYPE]/[SHORT_NAME]
+```
+
+**If not in wtf-p repo (external contributor):**
+```bash
+# Fork and clone
+gh repo fork akougkas/wtf-p --clone
+cd wtf-p
+
+# Create branch
+git checkout -b [BRANCH_TYPE]/[SHORT_NAME]
+```
+
+Branch naming:
+- `feat/add-citation-check` for features
+- `fix/install-path-spaces` for bugs
+- `docs/improve-readme` for documentation
+
+## Step 4: Guide Implementation
+
+Based on contribution type:
+
+### For New Command
+
+1. Show command template:
+```markdown
+---
+name: wtfp:command-name
+description: Brief description
+allowed-tools:
+  - Read
+  - Write
+  - AskUserQuestion
+---
+
+<objective>
+What this command accomplishes.
+</objective>
+
+<context>
+@~/.claude/write-the-f-paper/references/[relevant].md
+</context>
+
+<process>
+## Step 1: ...
+## Step 2: ...
+</process>
+```
+
+2. Create file in `commands/wtfp/[name].md`
+
+3. Follow naming conventions:
+   - `new-*` for creation
+   - `create-*` for generation
+   - `plan-*` for planning
+   - `write-*` for execution
+   - `review-*` for review
+   - `check-*` for validation
+   - `export-*` for output
+
+### For Bug Fix
+
+1. Identify the file(s) to modify
+2. Make minimal, focused changes
+3. Add test coverage if applicable
+
+### For Workflow Improvement
+
+1. Edit file in `write-the-f-paper/workflows/`
+2. If WCN version exists, update both `.md` and `.wcn.md`
+
+## Step 5: Test Changes
+
+```bash
+# Run existing tests
+npm test
+
+# Install locally for manual testing
+node bin/install.js --local --force
+
+# Test in Claude Code
+# /wtfp:your-new-command
+```
+
+Ask user to verify:
+- Does the feature work as expected?
+- Any edge cases to handle?
+- Error messages clear?
+
+## Step 6: Commit Changes
+
+Stage files:
+```bash
+git add [FILES]
+git status
+```
+
+Commit with conventional message:
+```bash
+git commit -m "[TYPE]([SCOPE]): [DESCRIPTION]
+
+[Optional body explaining why]
+
+[Closes #XX if applicable]"
+```
+
+Examples:
+- `feat(commands): add citation-check command`
+- `fix(cli): handle paths with spaces`
+- `docs(readme): clarify installation steps`
+
+## Step 7: Push and Create PR
+
+Push branch:
+```bash
+git push -u origin [BRANCH_NAME]
+```
+
+Create PR:
+```bash
+gh pr create \
+  --repo akougkas/wtf-p \
+  --title "[TYPE]([SCOPE]): [DESCRIPTION]" \
+  --body "$(cat <<'EOF'
+## Summary
+[What this PR does]
+
+## Changes
+- [Change 1]
+- [Change 2]
+
+## Testing
+- [ ] `npm test` passes
+- [ ] Manually tested in Claude Code
+- [ ] [Specific test scenario]
+
+## Related Issues
+[Closes #XX or References #XX]
+EOF
+)"
+```
+
+## Step 8: Post-PR Guidance
+
+After PR is created:
+
+1. **Show PR URL** to user
+2. **Explain review process:**
+   - Maintainer will review within a few days
+   - May request changes or ask questions
+   - Once approved, will be merged to main
+
+3. **Next steps:**
+   - Watch for review comments
+   - Respond to feedback
+   - Update PR if changes requested
+
+</process>
+
+<templates>
+
+## PR Title Format
+```
+<type>(<scope>): <description>
+```
+
+Types: feat, fix, docs, refactor, test, chore
+Scopes: commands, workflows, cli, templates
+
+## PR Body Template
+```markdown
+## Summary
+Brief description of what this PR accomplishes.
+
+## Changes
+- Added/Modified/Removed X
+- Updated Y to do Z
+
+## Testing
+How to verify this works:
+1. Install locally: `node bin/install.js --local`
+2. Run: `/wtfp:command`
+3. Expected: [outcome]
+
+## Screenshots (if UI changes)
+[Paste screenshots here]
+
+## Related Issues
+Closes #XX
+```
+
+</templates>
+
+<error-handling>
+
+**Fork already exists:** Use existing fork
+```bash
+gh repo sync [USERNAME]/wtf-p
+```
+
+**Branch already exists:**
+```bash
+git checkout [BRANCH]
+git pull origin main
+```
+
+**Push rejected:** Need to pull first or force push (with caution)
+
+**PR creation fails:** Check if branch was pushed, verify gh auth
+
+</error-handling>

package/commands/wtfp/help.md

@@ -333,10 +333,35 @@ Claude adapts its role per section:
 /wtfp:respond-reviews  # Generate response doc
 ```
 
+## Contributing to WTF-P
+
+Found a bug or want a new feature? Use these commands:
+
+**`/wtfp:report-bug`**
+Report a bug via GitHub issue.
+- Guides you through describing the problem
+- Collects environment info automatically
+- Creates well-formatted issue with `gh` CLI
+
+**`/wtfp:request-feature`**
+Request a new feature via GitHub issue.
+- Helps articulate what you need and why
+- Checks for duplicate requests
+- Can lead into implementation if desired
+
+**`/wtfp:contribute`**
+Guide through contributing code via Pull Request.
+- Fork → Branch → Implement → Test → PR workflow
+- Works for new commands, bug fixes, docs
+- Follows project conventions automatically
+
 ## Getting Help
 
 - Read `.planning/PROJECT.md` for paper vision
 - Read `.planning/STATE.md` for current context
 - Check `.planning/ROADMAP.md` for section status
 - Run `/wtfp:progress` to check where you're at
+- Report bugs: `/wtfp:report-bug`
+- Request features: `/wtfp:request-feature`
+- GitHub: https://github.com/akougkas/wtf-p
 </reference>

package/commands/wtfp/report-bug.md

@@ -0,0 +1,131 @@
+---
+name: wtfp:report-bug
+description: Report a bug in WTF-P via GitHub issue
+allowed-tools:
+  - Bash
+  - Read
+  - AskUserQuestion
+---
+
+<objective>
+Help the user report a bug in WTF-P by creating a well-formatted GitHub issue.
+</objective>
+
+<context>
+@~/.claude/write-the-f-paper/references/github-contrib.md
+</context>
+
+<process>
+
+## Step 1: Verify GitHub CLI
+
+Check if `gh` is authenticated:
+
+```bash
+gh auth status 2>&1
+```
+
+If not authenticated, inform the user:
+> To create GitHub issues, you need to authenticate the GitHub CLI.
+> Run: `gh auth login`
+> Then try this command again.
+
+## Step 2: Gather Bug Information
+
+Use AskUserQuestion to collect bug details:
+
+**Question 1: Bug Category**
+- Header: "Bug Type"
+- Options:
+  - "Command fails" - A /wtfp:* command doesn't work as expected
+  - "Installation issue" - Problems with npx wtf-p install/uninstall
+  - "Workflow error" - Writing workflow produces wrong output
+  - "Documentation gap" - Docs are missing or incorrect
+
+**Question 2: Bug Description**
+- Header: "Description"
+- Options:
+  - "Let me describe it" - User provides description
+  - "Help me articulate" - Claude helps user describe the bug
+
+If user needs help articulating, ask follow-up questions:
+- What were you trying to do?
+- What happened instead?
+- What did you expect to happen?
+
+## Step 3: Gather Environment Info
+
+Automatically collect:
+```bash
+npx wtf-p --version 2>/dev/null || echo "Not installed via npx"
+node --version
+uname -s 2>/dev/null || echo "Unknown OS"
+```
+
+## Step 4: Collect Reproduction Steps
+
+Ask user:
+- What command or action triggered the bug?
+- Can you reproduce it consistently?
+- Any error messages? (ask to paste them)
+
+## Step 5: Draft the Issue
+
+Create a draft and show it to the user:
+
+```markdown
+## Bug Description
+[From user input]
+
+## Steps to Reproduce
+1. [Step 1]
+2. [Step 2]
+3. [What happened vs expected]
+
+## Environment
+- WTF-P version: [collected]
+- Node.js version: [collected]
+- OS: [collected]
+
+## Additional Context
+[Error messages, logs, screenshots mentioned]
+```
+
+## Step 6: Confirm and Create
+
+Ask user to confirm:
+- "Create this issue?" with options: Yes / Edit first / Cancel
+
+If confirmed, create the issue:
+
+```bash
+gh issue create \
+  --repo akougkas/wtf-p \
+  --title "bug: [SHORT_TITLE]" \
+  --body "$(cat <<'EOF'
+[FULL_BODY_HERE]
+EOF
+)" \
+  --label "bug"
+```
+
+## Step 7: Report Success
+
+Show the user:
+- Issue URL (from gh output)
+- Issue number
+- What happens next (maintainer will review)
+
+</process>
+
+<error-handling>
+
+**gh not installed**: Direct user to https://cli.github.com/
+
+**gh not authenticated**: Guide through `gh auth login`
+
+**Network error**: Save draft locally, retry later
+
+**Permission denied**: User may need to fork first for external contributors
+
+</error-handling>

package/commands/wtfp/request-feature.md

@@ -0,0 +1,160 @@
+---
+name: wtfp:request-feature
+description: Request a new feature for WTF-P via GitHub issue
+allowed-tools:
+  - Bash
+  - Read
+  - AskUserQuestion
+---
+
+<objective>
+Help the user request a new feature for WTF-P by creating a well-formatted GitHub issue.
+</objective>
+
+<context>
+@~/.claude/write-the-f-paper/references/github-contrib.md
+</context>
+
+<process>
+
+## Step 1: Verify GitHub CLI
+
+Check if `gh` is authenticated:
+
+```bash
+gh auth status 2>&1
+```
+
+If not authenticated, inform the user:
+> To create GitHub issues, you need to authenticate the GitHub CLI.
+> Run: `gh auth login`
+> Then try this command again.
+
+## Step 2: Understand the Feature Request
+
+Use AskUserQuestion to understand what the user wants:
+
+**Question 1: Feature Category**
+- Header: "Category"
+- Options:
+  - "New command" - A new /wtfp:* slash command
+  - "Workflow enhancement" - Improve existing writing workflow
+  - "Installation/CLI" - Improve npx wtf-p experience
+  - "Template/Format" - New venue template or output format
+  - "Integration" - Connect with other tools (Zotero, Overleaf, etc.)
+
+**Question 2: Complexity**
+- Header: "Scope"
+- Options:
+  - "Small tweak" - Minor change to existing behavior
+  - "New capability" - Add something that doesn't exist
+  - "Major feature" - Significant new functionality
+
+## Step 3: Gather Feature Details
+
+Based on category, ask targeted questions:
+
+**For new command:**
+- What should `/wtfp:new-command` do?
+- When would you use it in your writing workflow?
+- What inputs does it need? What outputs?
+
+**For workflow enhancement:**
+- Which workflow needs improvement?
+- What's missing or frustrating?
+- How should it work differently?
+
+**For templates/formats:**
+- Which venue or format?
+- Do you have example requirements?
+
+## Step 4: Explore Use Case
+
+Ask user:
+- What problem does this solve for you?
+- How often would you use this?
+- Have you tried any workarounds?
+
+## Step 5: Check for Duplicates
+
+Search existing issues:
+```bash
+gh issue list --repo akougkas/wtf-p --search "[KEYWORDS]" --limit 5
+```
+
+If similar issues exist, show them to the user and ask:
+- "These similar issues exist. Should we add to one of these, or create a new issue?"
+
+## Step 6: Draft the Feature Request
+
+Create a draft:
+
+```markdown
+## Feature Description
+[Clear description of the feature]
+
+## Use Case
+[Why this is needed, what problem it solves]
+
+## Proposed Solution
+[How it should work, with examples]
+
+### Example Usage
+```
+/wtfp:new-command
+> [Expected interaction]
+```
+
+## Alternatives Considered
+[Other approaches, if discussed]
+
+## Additional Context
+[Related features, prior art, mockups]
+```
+
+## Step 7: Offer Implementation Path
+
+Ask user:
+- Header: "Next Step"
+- Options:
+  - "Create issue only" - Submit as feature request for maintainers
+  - "I'll implement it" - Create issue + guide through PR process
+  - "Help me implement" - Claude assists with implementation
+
+If user wants to implement, transition to `/wtfp:contribute` workflow.
+
+## Step 8: Create the Issue
+
+If confirmed:
+
+```bash
+gh issue create \
+  --repo akougkas/wtf-p \
+  --title "feat: [SHORT_TITLE]" \
+  --body "$(cat <<'EOF'
+[FULL_BODY_HERE]
+EOF
+)" \
+  --label "enhancement"
+```
+
+## Step 9: Report Success
+
+Show the user:
+- Issue URL
+- Issue number
+- Encourage voting/commenting to show interest
+- If they want to implement: next steps
+
+</process>
+
+<tips>
+
+**Good feature requests include:**
+- Specific use case (not just "it would be nice")
+- Example of how it would work
+- Explanation of why existing features don't solve this
+
+**Signal boost:** Encourage users to share the issue link with others who might want the feature. More reactions = higher priority.
+
+</tips>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wtf-p",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "The G.O.A.T. meta-prompting system for 10x researchers who need to submit papers and projects and proposals YESTERDAY.",
   "bin": {
     "wtfp": "bin/install.js",
@@ -8,7 +8,9 @@
     "wtf-p-uninstall": "bin/uninstall.js"
   },
   "scripts": {
-    "test": "node test/sanity.js",
+    "test": "node test/sanity.js && node test/paths.js",
+    "test:integration": "node test/integration.js",
+    "test:all": "npm test && npm run test:integration",
     "preflight": "node scripts/preflight.js",
     "release": "node scripts/release.js"
   },