prjct-cli 0.4.8 → 0.5.0

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

@@ -1,183 +0,0 @@
----
-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

@@ -1,44 +0,0 @@
----
-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

@@ -1,19 +0,0 @@
----
-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

@@ -1,113 +0,0 @@
----
-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

@@ -1,66 +0,0 @@
----
-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

@@ -1,95 +0,0 @@
----
-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

@@ -1,18 +0,0 @@
----
-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

@@ -1,25 +0,0 @@
----
-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}"
-   ```

package/templates/workflows/task.md

@@ -1,109 +0,0 @@
----
-title: prjct task
-invocable_name: p:task
-description: Break down and execute complex tasks systematically using global prjct architecture
----
-
-# Steps
-
-1. Read project config from `.prjct/prjct.config.json`
-2. Extract `projectId` and `author` from config
-3. Parse task description from arguments
-4. Analyze task complexity and requirements
-5. Break down into subtasks with dependencies
-6. Create task breakdown in `~/.prjct-cli/projects/{projectId}/planning/tasks/{task-id}.md`
-7. Add subtasks to `~/.prjct-cli/projects/{projectId}/core/next.md` with priority
-8. Set first subtask to `~/.prjct-cli/projects/{projectId}/core/now.md`
-9. Log task creation to memory
-10. Display execution plan
-
-# Response Format
-
-```
-📋 Task Breakdown: {task description}
-
-🔍 Analysis:
-- Complexity: {High/Medium/Low}
-- Estimated Time: {timeframe}
-- Dependencies: {list or "None"}
-
-📦 Subtasks Created:
-
-1. 🎯 {subtask 1} (Starting now)
-   - Why: {reason}
-   - Deliverable: {outcome}
-   - Estimate: {time}
-
-2. ⏳ {subtask 2}
-   - Why: {reason}
-   - Deliverable: {outcome}
-   - Estimate: {time}
-   - Depends on: #1
-
-3. ⏳ {subtask 3}
-   - Why: {reason}
-   - Deliverable: {outcome}
-   - Estimate: {time}
-   - Depends on: #2
-
-Total Estimate: {total time}
-
-✅ Actions Taken:
-- Created task breakdown file
-- Added subtasks to priority queue
-- Set first subtask as current focus
-
-🎯 Let's start! Current task:
-{subtask 1 description}
-
-Use /p:done when complete to move to next subtask.
-```
-
-# Task Breakdown Strategy
-
-1. **Understand Requirements**: Analyze what needs to be done
-2. **Identify Dependencies**: What must happen first?
-3. **Define Milestones**: Key deliverables within the task
-4. **Chunk into Subtasks**: Each subtask should be ~1-4 hours
-5. **Sequence Execution**: Order by dependencies and logic
-6. **Estimate Effort**: Realistic time estimates per subtask
-
-# Subtask Characteristics
-
-Good subtasks are:
-- **Atomic**: Can be completed in one session
-- **Testable**: Clear success criteria
-- **Valuable**: Produces tangible progress
-- **Independent**: Minimal blocking dependencies
-- **Sized Right**: 1-4 hours of focused work
-
-# Task Tracking
-
-Task breakdown file created at:
-`~/.prjct-cli/projects/{id}/planning/tasks/{task-id}.md`
-
-Contains:
-- Original task description
-- Analysis and breakdown
-- Subtask list with status
-- Dependencies map
-- Progress tracking
-- Completion notes
-
-# Progress Workflow
-
-1. `/p:task "Complex feature"` - Break down
-2. `/p:now` shows first subtask (auto-set)
-3. `/p:done` when complete → auto-advances to next subtask
-4. Repeat until all subtasks complete
-5. Final `/p:done` marks entire task complete
-6. `/p:ship` to celebrate the feature
-
-# Global Architecture Notes
-
-- **Task Files**: `~/.prjct-cli/projects/{id}/planning/tasks/*.md`
-- **Queue Integration**: `~/.prjct-cli/projects/{id}/core/next.md`
-- **Current Task**: `~/.prjct-cli/projects/{id}/core/now.md`
-- **Memory Logging**: `~/.prjct-cli/projects/{id}/memory/context.jsonl`
-- **Config Location**: `{project}/.prjct/prjct.config.json`
-- **Use Case**: Complex features, refactoring, large implementations