prjct-cli 0.4.0

package/templates/workflows/init.md

@@ -0,0 +1,80 @@
+---
+title: prjct init
+invocable_name: p:init
+description: Initialize prjct in current project with global architecture
+---
+
+# Steps
+
+1. Check if project already initialized (`.prjct/prjct.config.json` exists)
+2. If exists, display current configuration and exit
+3. Generate unique project ID from path hash
+4. Detect author information:
+   - Try GitHub CLI: `gh api user` for username
+   - Fallback to git config: `git config user.name` and `git config user.email`
+5. Create global directory structure in `~/.prjct-cli/projects/{id}/`:
+   - `core/` - now.md, next.md, context.md
+   - `progress/` - shipped.md, metrics.md
+   - `planning/` - ideas.md, roadmap.md
+   - `analysis/` - repo-summary.md
+   - `memory/` - context.jsonl
+6. Create local config at `.prjct/prjct.config.json` with:
+   - version: "0.2.1"
+   - projectId
+   - dataPath
+   - author info
+   - timestamps
+7. Detect installed AI editors (Claude Code, Cursor, Codex, Windsurf)
+8. Install commands in all detected editors
+9. Display success message with next steps
+
+# Response Format
+
+```
+✅ prjct initialized successfully!
+
+🆔 Project ID: {hash-id}
+👤 Author: {name} ({github})
+💾 Data location: ~/.prjct-cli/projects/{id}/
+
+📦 Commands installed in:
+- ✓ Claude Code (~/.claude/commands/p/)
+- ✓ Cursor AI (~/.cursor/commands/p/)
+- ✓ OpenAI Codex (AGENTS.md)
+- ✓ Windsurf/Codeium (.windsurf/workflows/)
+
+🚀 Ready to start! Try:
+- /p:now {task} - Set your current focus
+- /p:idea {text} - Capture quick ideas
+- /p:recap - See project overview
+```
+
+# Global Architecture Created
+
+```
+~/.prjct-cli/projects/{id}/
+├── core/
+│   ├── now.md (empty)
+│   ├── next.md (template)
+│   └── context.md (project info)
+├── progress/
+│   ├── shipped.md (empty)
+│   └── metrics.md (initial stats)
+├── planning/
+│   ├── ideas.md (empty)
+│   └── roadmap.md (template)
+├── analysis/
+│   └── repo-summary.md (generated)
+└── memory/
+    └── context.jsonl (init log)
+
+.prjct/
+└── prjct.config.json (project config)
+```
+
+# Error Handling
+
+- If `.prjct/` exists but corrupted: Offer migration
+- If author detection fails: Prompt for manual input
+- If directory creation fails: Check permissions
+- If editor installation fails: Continue with warning

package/templates/workflows/natural-language-handler.md

@@ -0,0 +1,183 @@
+---
+description: "Semantic intent detection for natural language commands"
+allowed-tools: [Read]
+---
+
+# Natural Language Handler
+
+## Core Concept
+
+**You're an LLM, not a regex parser!**
+
+Use your semantic understanding to map user intent to commands. Don't rely on pattern matching or hardcoded phrases.
+
+## How It Works
+
+### Step 1: Check for Direct Command
+```javascript
+if (message.startsWith('/p:')) {
+  return executeCommand(message)
+}
+```
+
+### Step 2: Understand User Intent
+
+Ask yourself: **"What is the user trying to accomplish?"**
+
+Use your natural language understanding to determine the intent:
+
+| User Intent | Command |
+|-------------|---------|
+| Wants to start/focus on a task | `/p:now` |
+| Finished current work | `/p:done` |
+| Ready to ship/deploy something | `/p:ship` |
+| Has an idea to capture | `/p:idea` |
+| Wants to see progress/status | `/p:recap` |
+| Stuck on a problem | `/p:stuck` |
+| Wants to know what's next | `/p:next` |
+| Needs general help | `/p:help` |
+
+### Step 3: Extract Relevant Information
+
+Pull the important details from the message:
+- For `/p:now`: What task are they starting?
+- For `/p:ship`: What feature are they shipping?
+- For `/p:idea`: What's their idea?
+- For `/p:stuck`: What problem are they facing?
+
+### Step 4: Show Transparency
+
+Always communicate what you understood:
+
+```
+💬 I understood: "[your interpretation of their intent]"
+⚡ Executing: /p:[command] [parameters]
+```
+
+### Step 5: Provide Conversational Response
+
+Guide them toward next actions naturally.
+
+## Examples (Infinite Variations Possible)
+
+### Starting a Task
+
+**All of these mean `/p:now`:**
+- "I want to start building the login page"
+- "Let me work on authentication"
+- "Starting the API now"
+- "Voy a hacer el dashboard"
+- "Gonna work on that bug fix"
+- "I shall commence development of the user profile"
+
+**Your response pattern:**
+```
+💬 I understood: "start working on [extracted task]"
+⚡ Executing: /p:now "[extracted task]"
+
+✅ Starting task: [extracted task]
+
+What's next?
+• Say "I'm done" when finished
+• Or: /p:done
+```
+
+### Completing Work
+
+**All of these mean `/p:done`:**
+- "I'm done" | "finished" | "completed"
+- "terminé" | "listo" | "ya acabé"
+- "all done with this"
+- "that's finished"
+
+### Shipping a Feature
+
+**All of these mean `/p:ship`:**
+- "ship the authentication system"
+- "deploy this feature"
+- "it's ready to launch"
+- "let's ship it"
+
+### Capturing Ideas
+
+**All of these mean `/p:idea`:**
+- "I have an idea about dark mode"
+- "what if we added user profiles"
+- "tengo una idea sobre notificaciones"
+- "idea: add export functionality"
+
+## Implementation Philosophy
+
+```javascript
+// ❌ DON'T DO THIS (pattern matching)
+if (message.includes("I want to start") ||
+    message.includes("let me start") ||
+    message.includes("quiero empezar")) {
+  // This is too rigid!
+}
+
+// ✅ DO THIS (semantic understanding)
+const intent = understandUserIntent(message)
+// Use your LLM capabilities to understand what they want
+
+if (userWantsToStartTask(intent)) {
+  const task = extractTaskDescription(message)
+  return executeCommand('/p:now', task)
+}
+```
+
+## Works in Any Language
+
+If you understand the user's intent in **any language**, execute the command:
+
+- **English**: "I want to start the API"
+- **Spanish**: "Quiero empezar con la autenticación"
+- **Casual**: "gonna work on that login thing"
+- **Formal**: "I shall commence development of the authentication module"
+- **Mixed**: "voy a hacer the user dashboard"
+
+All map to: `/p:now`
+
+## Edge Cases
+
+### Ambiguous Intent
+If you're not sure what they want:
+```
+💬 I need clarification:
+
+Did you mean:
+1. 📖 Interactive guide → Use /p:help
+2. 🆘 I'm stuck on something → Say "I'm stuck on [problem]"
+
+Which one?
+```
+
+### Multiple Commands
+Handle sequentially:
+```
+User: "I'm done, now start the API work"
+
+Step 1: Execute /p:done
+Step 2: Execute /p:now "API work"
+```
+
+### Unknown Intent
+If you truly don't understand:
+```
+💬 I'm not sure what you'd like to do.
+
+Common actions:
+• "start [task]" → Begin working
+• "I'm done" → Complete current task
+• "show my progress" → See status
+
+Or type /p:help for the full guide
+```
+
+## Key Principles
+
+1. **Trust your understanding** - You're an LLM with semantic comprehension
+2. **Any phrasing works** - Users can express intent however they want
+3. **Any language works** - If you understand it, execute it
+4. **Always be transparent** - Show what you understood
+5. **Guide naturally** - Suggest next steps conversationally

package/templates/workflows/next.md

@@ -0,0 +1,44 @@
+---
+title: prjct next
+invocable_name: p:next
+description: Show priority queue of upcoming tasks using global prjct architecture
+---
+
+# Steps
+
+1. Read project config from `.prjct/prjct.config.json`
+2. Extract `projectId` from config
+3. Read priority queue from `~/.prjct-cli/projects/{projectId}/core/next.md`
+4. Parse task list with priorities
+5. Format and display tasks with priority indicators
+6. Show count of queued tasks
+7. Suggest using `/p:now {task}` to start working
+
+# Response Format
+
+```
+📋 Priority Queue:
+
+1. 🔥 {high-priority task}
+2. ⚡ {medium-priority task}
+3. 📌 {normal-priority task}
+...
+
+Total queued: X tasks
+
+Ready to start? Use /p:now {task number or description}
+```
+
+# Priority Indicators
+
+- 🔥 High priority / urgent
+- ⚡ Medium priority / important
+- 📌 Normal priority / routine
+- 💡 Nice to have / experimental
+
+# Global Architecture Notes
+
+- **Data Location**: `~/.prjct-cli/projects/{id}/core/next.md`
+- **Config Location**: `{project}/.prjct/prjct.config.json`
+- **File Format**: Markdown list with optional priority markers
+- **Integration**: Tasks can be promoted to `now.md` with `/p:now`

package/templates/workflows/now.md

@@ -0,0 +1,19 @@
+---
+title: prjct now
+invocable_name: p:now
+description: Set/show current focus
+---
+
+# Steps
+
+**Show**: Read config → get projectId → read `~/.prjct-cli/projects/{id}/core/now.md`
+
+**Set**:
+1. Get projectId + author from `.prjct/prjct.config.json`
+2. Write task + timestamp to `~/.prjct-cli/projects/{id}/core/now.md`
+3. Log to `memory/context.jsonl` with author
+4. Response:
+   ```
+   🎯 {task}
+   → /p:done when complete
+   ```

package/templates/workflows/progress.md

@@ -0,0 +1,113 @@
+---
+title: prjct progress
+invocable_name: p:progress
+description: Show progress metrics for specified period using global prjct architecture
+---
+
+# Steps
+
+1. Read project config from `.prjct/prjct.config.json`
+2. Extract `projectId` from config
+3. Parse period argument (default: week):
+   - `day` or `today` - Today's progress
+   - `week` - This week (Mon-Sun)
+   - `month` - This month
+   - `all` or `total` - All-time
+4. Read all shipped features from `~/.prjct-cli/projects/{projectId}/progress/shipped.md`
+5. Filter entries by timestamp for specified period
+6. Calculate metrics:
+   - Total features shipped
+   - Average velocity
+   - Completion rate
+   - Momentum indicators
+7. Read metrics file for additional stats
+8. Format and display progress report
+
+# Response Format
+
+## Daily Progress
+```
+📊 Progress Report - Today
+
+🚀 Features Shipped: X features
+⏱️  Active Time: Y hours
+✅ Tasks Completed: Z tasks
+
+📈 Momentum: {High/Medium/Low}
+
+Keep it up! 💪
+```
+
+## Weekly Progress
+```
+📊 Progress Report - This Week
+
+🚀 Features Shipped: X features
+📅 Days Active: Y of 7 days
+⚡ Velocity: A features/day
+✅ Tasks Completed: Z tasks
+
+📈 Week Trend: {Up/Steady/Down}
+💡 Ideas Captured: B ideas
+
+{comparison to last week}
+
+🎯 Next Week Goal: {suggestion}
+```
+
+## Monthly Progress
+```
+📊 Progress Report - This Month
+
+🚀 Features Shipped: X features
+📅 Active Days: Y of 30 days
+⚡ Monthly Velocity: A features/week
+✅ Total Tasks: Z tasks
+💡 Ideas Generated: B ideas
+
+📈 Month Highlights:
+- Best week: {date} with {n} features
+- Most productive day: {day} with {n} tasks
+- Momentum: {analysis}
+
+🎯 Month-End Goal: {progress toward goal}
+```
+
+## All-Time Progress
+```
+📊 Progress Report - All Time
+
+🚀 Total Features Shipped: X features
+📅 Project Duration: Y days
+⚡ Average Velocity: A features/week
+✅ Total Tasks Completed: Z tasks
+💡 Total Ideas: B ideas
+
+📈 Milestones:
+- {milestone 1}
+- {milestone 2}
+- {milestone 3}
+
+🏆 Achievements:
+- Most productive week: {date}
+- Longest streak: {n} days
+- Best month: {month}
+
+Keep building! 🚀
+```
+
+# Calculations
+
+- **Velocity**: Features / Time Period
+- **Momentum**: Based on recent trend (last 3 data points)
+- **Active Days**: Days with at least 1 logged action
+- **Streak**: Consecutive days with activity
+
+# Global Architecture Notes
+
+- **Data Source**: `~/.prjct-cli/projects/{id}/progress/`
+  - `shipped.md` - All completed features with timestamps
+  - `metrics.md` - Aggregated statistics
+- **Memory Source**: `~/.prjct-cli/projects/{id}/memory/context.jsonl` for activity
+- **Config Location**: `{project}/.prjct/prjct.config.json`
+- **Use Case**: Standups, retrospectives, velocity tracking

package/templates/workflows/recap.md

@@ -0,0 +1,66 @@
+---
+title: prjct recap
+invocable_name: p:recap
+description: Show comprehensive project overview using global prjct architecture
+---
+
+# Steps
+
+1. Read project config from `.prjct/prjct.config.json`
+2. Extract `projectId` and `author` from config
+3. Read current focus from `~/.prjct-cli/projects/{projectId}/core/now.md`
+4. Read recent shipped features from `~/.prjct-cli/projects/{projectId}/progress/shipped.md` (last 5)
+5. Read priority queue from `~/.prjct-cli/projects/{projectId}/core/next.md` (top 3)
+6. Read recent ideas from `~/.prjct-cli/projects/{projectId}/planning/ideas.md` (count)
+7. Calculate metrics from `~/.prjct-cli/projects/{projectId}/progress/metrics.md`
+8. Read recent context from `~/.prjct-cli/projects/{projectId}/memory/context.jsonl` (last 3 actions)
+9. Format and display comprehensive overview
+
+# Response Format
+
+```
+📊 Project Recap for {project-name}
+
+🎯 Current Focus:
+{current task or "No task set - use /p:now to set focus"}
+
+🚀 Recently Shipped (Last 5):
+- {feature 1} - {timestamp}
+- {feature 2} - {timestamp}
+- {feature 3} - {timestamp}
+- {feature 4} - {timestamp}
+- {feature 5} - {timestamp}
+
+📋 Coming Up Next (Top 3):
+1. {priority 1}
+2. {priority 2}
+3. {priority 3}
+
+💡 Ideas Backlog: X ideas captured
+📝 Total queued tasks: Y tasks
+
+📈 Progress Metrics:
+- This week: X features shipped
+- This month: Y features shipped
+- Total: Z features shipped
+- Average velocity: A features/week
+
+🕒 Recent Activity:
+- {timestamp}: {action 1}
+- {timestamp}: {action 2}
+- {timestamp}: {action 3}
+
+👤 Author: {name} ({github})
+```
+
+# Global Architecture Notes
+
+- **Data Sources**: Multiple layers in `~/.prjct-cli/projects/{id}/`
+  - `core/now.md` - Current task
+  - `core/next.md` - Priority queue
+  - `progress/shipped.md` - Completed features
+  - `progress/metrics.md` - Statistics
+  - `planning/ideas.md` - Ideas backlog
+  - `memory/context.jsonl` - Action history
+- **Config Location**: `{project}/.prjct/prjct.config.json`
+- **Use Case**: Daily standup, status updates, context restoration

package/templates/workflows/roadmap.md

@@ -0,0 +1,95 @@
+---
+title: prjct roadmap
+invocable_name: p:roadmap
+description: Show or update strategic roadmap using global prjct architecture
+---
+
+# Steps
+
+1. Read project config from `.prjct/prjct.config.json`
+2. Extract `projectId` from config
+3. Read roadmap from `~/.prjct-cli/projects/{projectId}/planning/roadmap.md`
+4. Parse roadmap structure (phases, milestones, features)
+5. Read shipped features from `~/.prjct-cli/projects/{projectId}/progress/shipped.md`
+6. Calculate completion progress for each phase
+7. Identify current phase and next milestones
+8. Format and display roadmap with progress
+
+# Response Format
+
+```
+🗺️  Project Roadmap
+
+📍 Current Phase: {phase name}
+Progress: {X}% complete
+
+## Phases Overview
+
+### ✅ Phase 1: {name} (Completed)
+- {feature 1} ✓
+- {feature 2} ✓
+- {feature 3} ✓
+
+### 🔄 Phase 2: {name} (In Progress - {X}%)
+- {feature 1} ✓
+- {feature 2} 🔄 Current
+- {feature 3} ⏳
+- {feature 4} ⏳
+
+### ⏳ Phase 3: {name} (Planned)
+- {feature 1}
+- {feature 2}
+- {feature 3}
+
+### 💡 Phase 4: {name} (Future)
+- {feature 1}
+- {feature 2}
+
+## Upcoming Milestones
+
+🎯 Next Milestone: {milestone name}
+  - Target: {date/timeframe}
+  - Features remaining: X
+  - Estimated: Y weeks
+
+🔮 Future Milestones:
+  - {milestone 2}: {timeframe}
+  - {milestone 3}: {timeframe}
+
+💡 Want to update roadmap? Edit ~/.prjct-cli/projects/{id}/planning/roadmap.md
+```
+
+# Roadmap Structure
+
+The roadmap.md file should follow this structure:
+
+```markdown
+# Project Roadmap
+
+## Phase 1: Foundation
+Target: Q1 2025
+- [ ] Feature A
+- [ ] Feature B
+- [ ] Feature C
+
+## Phase 2: Core Features
+Target: Q2 2025
+- [ ] Feature D
+- [ ] Feature E
+
+...
+```
+
+# Progress Calculation
+
+- Match shipped features against roadmap items
+- Calculate percentage completion per phase
+- Identify current phase (first with incomplete items)
+- Estimate completion based on velocity
+
+# Global Architecture Notes
+
+- **Data Location**: `~/.prjct-cli/projects/{id}/planning/roadmap.md`
+- **Progress Source**: `~/.prjct-cli/projects/{id}/progress/shipped.md`
+- **Config Location**: `{project}/.prjct/prjct.config.json`
+- **Use Case**: Strategic planning, stakeholder updates, long-term vision

package/templates/workflows/ship.md

@@ -0,0 +1,18 @@
+---
+title: prjct ship
+invocable_name: p:ship
+description: Ship feature
+---
+
+# Steps
+
+1. Get projectId + author from `.prjct/prjct.config.json`
+2. Append to `~/.prjct-cli/projects/{id}/progress/shipped.md` + timestamp
+3. Update `progress/metrics.md` (count, velocity)
+4. Log to `memory/context.jsonl` with author
+5. Response:
+   ```
+   🚀 {feature}
+   Week: {n} | Total: {total}
+   → /p:now
+   ```

package/templates/workflows/stuck.md

@@ -0,0 +1,25 @@
+---
+title: prjct stuck
+invocable_name: p:stuck
+description: Get unstuck
+---
+
+# Steps
+
+1. Get projectId from `.prjct/prjct.config.json`
+2. Detect type: bug/design/perf/feature
+3. Read context from:
+   - `~/.prjct-cli/projects/{id}/analysis/repo-summary.md`
+   - `~/.prjct-cli/projects/{id}/memory/context.jsonl`
+4. Log to `memory/context.jsonl`
+5. Response by type:
+   - **Bug**: `🔍 1. Check logs 2. Isolate 3. Search error`
+   - **Design**: `🎨 1. Define clearly 2. Start simple 3. Ship MVP`
+   - **Perf**: `⚡ 1. Profile 2. Fix slowest 3. Cache`
+   - **Default**: `💡 1. Break down 2. Start smallest 3. Ship`
+6. Suggest breakdown:
+   ```
+   🧩 Break down:
+   1. {task} (15m)
+   → /p:now "{first}"
+   ```