prjct-cli 0.4.0

package/templates/commands/fix.md

@@ -0,0 +1,87 @@
+---
+allowed-tools: [Read, Grep, Bash, Edit]
+description: "Quick troubleshooting and automatic fixes"
+---
+
+## Global Architecture
+This command uses the global prjct architecture:
+- Data stored in: `~/.prjct-cli/projects/{id}/`
+- Config stored in: `{project}/.prjct/prjct.config.json`
+- Commands synchronized across all editors
+
+
+
+# /p:fix - Quick Fix & Troubleshooting
+
+## Purpose
+Instantly diagnose and fix common issues. Get unstuck in seconds, not minutes.
+
+## Usage
+```
+/p:fix [error message or description]
+```
+
+## Execution
+1. Analyze error type (syntax/type/runtime/build)
+2. Search for error patterns in codebase
+3. Apply automatic fix if safe and obvious
+4. Provide manual fix steps if complex
+5. Log solution to `.prjct/memory/context.jsonl`
+
+## Common Fixes
+
+**Auto-fixable**:
+- Missing semicolons, brackets, quotes
+- Import statements for undefined variables
+- Package.json dependencies
+- Simple type errors
+- Linting issues
+
+**Guided fixes**:
+- Null/undefined errors → Add null checks
+- Module not found → Install package or fix path
+- Build failures → Check configs and deps
+- Test failures → Show diff and fix approach
+
+## Implementation
+
+**Error detection**:
+```bash
+# Check for common issues
+- npm run lint 2>&1
+- npm run typecheck 2>&1
+- Check recent git changes
+- Analyze error stack trace
+```
+
+**Response format for auto-fix**:
+```
+🔧 Fixed automatically!
+
+Problem: Missing import for useState
+Solution: Added import from 'react'
+File: components/UserForm.tsx:1
+
+✅ Error resolved - continue working!
+```
+
+**Response format for guided fix**:
+```
+🔍 Issue identified: Cannot read property 'id' of undefined
+
+📍 Location: services/auth.js:45
+🐛 Cause: user might be null
+
+💡 Quick fix:
+if (!user?.id) {
+  return null;
+}
+
+Apply with: /p:fix apply
+```
+
+## Smart Features
+- Learns from previous fixes
+- Suggests preventive measures
+- Links to relevant documentation
+- Tracks fix patterns in memory

package/templates/commands/git.md

@@ -0,0 +1,79 @@
+---
+allowed-tools: [Bash, Read, Grep, Glob]
+description: "Smart git operations with auto-generated commit messages"
+---
+
+## Global Architecture
+This command uses the global prjct architecture:
+- Data stored in: `~/.prjct-cli/projects/{id}/`
+- Config stored in: `{project}/.prjct/prjct.config.json`
+- Commands synchronized across all editors
+
+
+
+# /p:git - Smart Git Operations
+
+## Purpose
+Execute git operations with intelligent commit messages and automatic best practices. No thinking required.
+
+## Usage
+```
+/p:git [commit|push|status|sync]
+```
+
+Default: commit
+
+## Execution
+
+### `/p:git` or `/p:git commit`
+1. Run `git status` to see changes
+2. Analyze changes to generate smart commit message
+3. Stage all changes with `git add -A`
+4. Commit with generated message
+5. Log to `.prjct/memory/context.jsonl`
+
+### `/p:git push`
+1. Commit any pending changes first
+2. Push to current branch
+3. Show deployment status if applicable
+
+### `/p:git status`
+1. Show clean git status with emoji indicators
+2. Suggest next logical action
+
+### `/p:git sync`
+1. Pull latest changes
+2. Commit local changes if any
+3. Push to remote
+4. Handle merge conflicts if needed
+
+## Implementation
+
+**Smart commit message generation**:
+- Analyze file changes to determine type (feat/fix/docs/refactor)
+- Extract meaningful description from changes
+- Add emoji for visual clarity
+- Include file scope when relevant
+
+**Example messages**:
+- "✨ feat: Add user authentication system"
+- "🐛 fix: Resolve null pointer in auth middleware"
+- "📝 docs: Update API documentation"
+- "♻️ refactor: Simplify database connection logic"
+
+**Response format**:
+```
+✅ Changes committed!
+
+📝 Message: feat: Add user authentication
+📊 Files: 3 changed, +150 lines
+🔄 Branch: main
+
+💡 Next: /p:git push to deploy
+```
+
+## Best Practices
+- Always pulls before pushing
+- Auto-stages all changes
+- Generates conventional commit messages
+- Tracks in project memory for context

package/templates/commands/help.md

@@ -0,0 +1,72 @@
+---
+allowed-tools: [Read]
+description: "Interactive guide - talk naturally, no memorization needed"
+---
+
+# /p:help
+
+## Usage
+```
+/p:help
+```
+
+## Purpose
+Interactive guide for users who want to talk naturally without memorizing commands.
+
+## Response
+
+```
+🎯 What do you want to do?
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+1. 🚀 Start working on something
+   Say: "I want to start [task]"
+   Or: /p:now "task description"
+
+2. ✅ I finished a task
+   Say: "I'm done" or "finished"
+   Or: /p:done
+
+3. 🎉 Ship a feature
+   Say: "ship [feature name]"
+   Or: /p:ship "feature"
+
+4. 💡 Capture an idea
+   Say: "I have an idea about [thing]"
+   Or: /p:idea "idea text"
+
+5. 📊 See my progress
+   Say: "show me my progress"
+   Or: /p:recap
+
+6. 🗺️ Plan ahead
+   Say: "show my roadmap"
+   Or: /p:roadmap
+
+7. 🆘 I'm stuck on something
+   Say: "I'm stuck on [problem]"
+   Or: /p:stuck "issue description"
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+💬 Pro tip: Just talk naturally!
+
+   Instead of memorizing commands, tell me what you want:
+   • "let me start building the login"
+   • "I finished that"
+   • "ship the authentication system"
+   • "what should I work on next?"
+
+   I understand both natural language and /p:* commands.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+What would you like to do?
+```
+
+## Implementation Notes
+- Always respond conversationally
+- Detect user intent from natural language
+- Map to appropriate /p:* command
+- Show example in both natural + command format

package/templates/commands/idea.md

@@ -0,0 +1,50 @@
+---
+allowed-tools: [Read, Write, Edit]
+description: "Quick idea capture"
+---
+
+# /p:idea
+
+## Usage
+```
+/p:idea <text>
+```
+
+## Execution
+
+1. Append to `~/.prjct-cli/projects/{id}/planning/ideas.md`:
+   ```markdown
+   - [timestamp] [idea]
+   ```
+
+2. If actionable (has action verbs), add to `core/next.md`
+3. Log to `memory/context.jsonl`:
+   ```json
+   {"action":"idea","text":"[idea]","category":"[type]","actionable":true,"added_to_queue":true}
+   ```
+
+4. Response (if actionable):
+   ```
+   💡 Idea captured: [idea text]
+
+   ✅ Added to task queue!
+
+   Ready to start?
+   • "start this idea" → Begin now
+   • "plan more" → Keep brainstorming
+   • "see all ideas" → View backlog
+
+   Or: /p:now "[idea]" | /p:idea | /p:recap
+   ```
+
+   Or (if just backlog):
+   ```
+   💡 Idea saved: [idea text]
+
+   What now?
+   • "add another idea" → Keep brainstorming
+   • "start working" → Pick a task
+   • "see my ideas" → View backlog
+
+   Or: /p:idea | /p:now | /p:next
+   ```

package/templates/commands/init.md

@@ -0,0 +1,237 @@
+---
+allowed-tools: [Read, Write, Bash, Glob]
+description: "Initialize prjct project with global architecture"
+---
+
+# /p:init - Initialize Project
+
+## Purpose
+Initialize a new prjct project using global architecture with centralized data storage.
+
+## Global Architecture
+This command creates:
+- **Global data directory**: `~/.prjct-cli/projects/{id}/` (shared across editors)
+- **Local config file**: `.prjct/prjct.config.json` (links to global data)
+- **Synchronized commands**: Available in Claude Code, Cursor, Windsurf
+
+## Usage
+```
+/p:init
+```
+
+## Implementation
+
+When this command is executed in Claude Code:
+
+### 1. Generate Project ID
+```bash
+# Generate unique ID from project path hash
+PROJECT_PATH="$(pwd)"
+PROJECT_ID=$(echo -n "$PROJECT_PATH" | shasum -a 256 | cut -c1-12)
+```
+
+### 2. Create Global Directory Structure
+```bash
+# Create global data directory
+mkdir -p ~/.prjct-cli/projects/$PROJECT_ID/{core,progress,planning,analysis,memory}
+```
+
+### 3. Create Local Configuration
+```bash
+# Create local config directory
+mkdir -p .prjct
+
+# Get author info from git
+AUTHOR_NAME=$(git config user.name 2>/dev/null || echo "Unknown")
+AUTHOR_EMAIL=$(git config user.email 2>/dev/null || echo "unknown@example.com")
+
+# Create config file linking to global data
+cat > .prjct/prjct.config.json << EOF
+{
+  "version": "0.3.0",
+  "projectId": "$PROJECT_ID",
+  "dataPath": "~/.prjct-cli/projects/$PROJECT_ID",
+  "author": {
+    "name": "$AUTHOR_NAME",
+    "email": "$AUTHOR_EMAIL"
+  },
+  "createdAt": "$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
+}
+EOF
+```
+
+### 4. Initialize Core Files (in global directory)
+
+**~/.prjct-cli/projects/{id}/core/now.md**:
+```markdown
+# NOW: No current task
+
+Start a new task with `/p:now [task description]`
+```
+
+**~/.prjct-cli/projects/{id}/core/next.md**:
+```markdown
+# NEXT - Priority Queue
+
+Add tasks here that should be done after the current task.
+```
+
+**~/.prjct-cli/projects/{id}/core/context.md**:
+```markdown
+# Project Context
+
+## Overview
+[Auto-generated from `/p:analyze`]
+
+## Current Focus
+[Link to current task in now.md]
+
+## Key Information
+- **Repository**: [auto-detected]
+- **Tech Stack**: [auto-detected]
+- **Architecture**: [auto-detected]
+```
+
+### 5. Initialize Progress Tracking
+
+**~/.prjct-cli/projects/{id}/progress/shipped.md**:
+```markdown
+# SHIPPED - Completed Features
+
+## Week [CURRENT_WEEK], [YEAR]
+
+_Ship features with `/p:ship <feature>`_
+```
+
+**~/.prjct-cli/projects/{id}/progress/metrics.md**:
+```markdown
+# Progress Metrics
+
+## This Week
+- **Shipped**: 0 features
+- **Active**: 0 tasks
+- **Planned**: 0 items
+
+## Historical
+[Auto-updated by commands]
+```
+
+### 6. Initialize Planning Layer
+
+**~/.prjct-cli/projects/{id}/planning/ideas.md**:
+```markdown
+# IDEAS - Brain Dump
+
+Capture ideas quickly with `/p:idea <text>`
+
+## Backlog
+- [ ] [Ideas will appear here]
+
+## Someday/Maybe
+- [ ] [Future ideas]
+```
+
+**~/.prjct-cli/projects/{id}/planning/roadmap.md**:
+```markdown
+# Roadmap
+
+## Current Sprint
+[Active items from next.md]
+
+## Upcoming
+[Planned features and improvements]
+
+## Long-term Vision
+[Strategic goals and objectives]
+```
+
+### 7. Initialize Memory Layer
+
+Create empty JSONL files for historical tracking:
+- **memory/context.jsonl**: Activity log with timestamps
+- **memory/decisions.jsonl**: Decision history (not used yet)
+
+### 8. Log Initialization
+
+Add initialization record to memory:
+```jsonl
+{"timestamp":"2025-10-01T09:00:00Z","action":"init","author":"Name","projectPath":"/path/to/project","projectId":"abc123def456"}
+```
+
+### 9. Success Message (Conversational Onboarding)
+
+```
+✅ Your project is ready!
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+💬 Let me show you around...
+
+You don't need to memorize commands.
+Just talk to me naturally!
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+🎯 To start working:
+
+   Say: "I want to start building the login page"
+   Or:  /p:now "build login page"
+
+   → I'll track your focus and time
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+✅ When you finish something:
+
+   Say: "I'm done" or "finished that"
+   Or:  /p:done
+
+   → I'll celebrate and suggest what's next
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+🚀 To ship a feature:
+
+   Say: "ship the authentication system"
+   Or:  /p:ship "authentication system"
+
+   → I'll track your velocity and wins
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+💡 Have ideas? Just say:
+
+   "I have an idea about dark mode"
+   "What should I work on next?"
+   "Show me my progress"
+   "I'm stuck on async state"
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+🆘 Need help anytime?
+
+   Type: /p:help
+
+   → I'll show you all options in plain language
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Ready to start? Tell me what you want to build first!
+
+(Or type /p:help to see all options)
+```
+
+## Error Handling
+
+- **If .prjct/ exists**: Warn that project may already be initialized
+- **If git not available**: Use generic author info
+- **If global directory creation fails**: Show error and suggest manual creation
+- **If config write fails**: Check permissions on .prjct/ directory
+
+## Notes
+
+- Project ID is deterministic based on project path
+- Same project path always gets same ID
+- Global data enables cross-editor synchronization
+- Local config is minimal (just links to global data)
+- Works for solo developers and small teams (2-5 people)

package/templates/commands/next.md

@@ -0,0 +1,74 @@
+---
+allowed-tools: [Read, Write, Edit]
+description: "Display and manage priority queue"
+---
+
+## Global Architecture
+This command uses the global prjct architecture:
+- Data stored in: `~/.prjct-cli/projects/{id}/`
+- Config stored in: `{project}/.prjct/prjct.config.json`
+- Commands synchronized across all editors
+
+
+
+# /p:next - Priority Queue
+
+## Purpose
+Display the prioritized queue of upcoming tasks.
+
+## Usage
+```
+/p:next
+```
+
+## Execution
+1. Read `.prjct/core/next.md`
+2. Display numbered list of pending tasks with context
+3. Show task count and suggest next action
+4. Reference related planning and progress layers
+
+## Implementation
+
+1. **Read core/next.md**:
+   - Parse markdown list of tasks
+   - Number them for easy reference
+   - Show task priorities and contexts
+
+2. **Context integration**:
+   - Reference planning/roadmap.md for strategic context
+   - Show progress/metrics.md for capacity planning
+   - Link to analysis/repo-summary.md for technical context
+
+3. **Response format**:
+   ```
+   📋 Priority Queue ([count] tasks):
+
+   1. [first task]
+      - Context: [link to planning/analysis if relevant]
+      - Priority: [high/medium/low]
+   2. [second task]
+   3. [third task]
+   ...
+
+   💡 Start next task with: /p:now "[first task]"
+   📊 Context: See planning/roadmap.md for strategic priorities
+   ```
+
+   Or if empty:
+   ```
+   📋 Queue is empty!
+
+   Add tasks:
+   - Directly edit .prjct/core/next.md
+   - Use /p:idea for quick capture
+   - Check /p:roadmap for strategic planning
+
+   📂 Related:
+   - Planning: .prjct/planning/roadmap.md
+   - Ideas: .prjct/planning/ideas.md
+   ```
+
+## Tips
+- Keep queue short (5-10 items)
+- Most important tasks first
+- Review and reprioritize regularly

package/templates/commands/now.md

@@ -0,0 +1,35 @@
+---
+allowed-tools: [Read, Write, Edit, TodoWrite]
+description: "Manage current focus task"
+---
+
+# /p:now
+
+## Usage
+```
+/p:now              # Show current
+/p:now [task]       # Set focus
+```
+
+## Execution
+
+**Show**: Read `~/.prjct-cli/projects/{id}/core/now.md`, display task + elapsed time
+
+**Set**:
+1. Update `core/now.md` with task + timestamp
+2. Update `core/context.md`, `progress/metrics.md`
+3. Log to `memory/context.jsonl`:
+   ```json
+   {"action":"now","task":"[task]","timestamp":"[ISO]","previous":"[old]","layer":"core"}
+   ```
+4. Response:
+   ```
+   🎯 Working on: [task description]
+   Started: [time]
+
+   When you're done:
+   • "I'm done" or "finished"
+   • Or type: /p:done
+
+   Need help? Say "I'm stuck" or use /p:stuck
+   ```