prjct-cli 0.5.1 → 0.6.0

package/templates/commands/git.md

@@ -1,79 +1,52 @@
 ---
-allowed-tools: [Bash, Read, Grep, Glob]
-description: "Smart git operations with auto-generated commit messages"
+allowed-tools: [Bash, Read, Write]
+description: "Smart git operations with context"
 ---
 
-## 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.
+# /p:git
 
 ## Usage
 ```
-/p:git [commit|push|status|sync]
+/p:git commit       # Smart commit with metadata
+/p:git push         # Push with verification
+/p:git sync         # Pull, rebase, push
+/p:git undo         # Undo last commit
 ```
 
-Default: commit
-
-## Execution
+## Flow: commit
+1. Read: `core/now.md` → get task context
+2. Git: `add .` → stage changes
+3. Create: commit message with prjct metadata
+4. Commit: with message
+5. Log: `memory/context.jsonl`
 
-### `/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`
+## Flow: push
+1. Git: `status` → verify clean
+2. Git: `push` with branch tracking
+3. Handle: errors (upstream, conflicts)
 
-### `/p:git push`
-1. Commit any pending changes first
-2. Push to current branch
-3. Show deployment status if applicable
+## Flow: sync
+1. Git: `pull --rebase`
+2. Resolve: conflicts if any
+3. Git: `push`
 
-### `/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
+## Commit Message Format
+```
+{type}: {description}
 
-**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
+Agent: {agent}
+Dev: @{github_dev}
 
-**Example messages**:
-- "✨ feat: Add user authentication system"
-- "🐛 fix: Resolve null pointer in auth middleware"
-- "📝 docs: Update API documentation"
-- "♻️ refactor: Simplify database connection logic"
+Generated-by: prjct/cli
+Co-Authored-By: @{github_dev}
+```
 
-**Response format**:
+## Response
 ```
-✅ Changes committed!
+✅ Git {operation}
 
-📝 Message: feat: Add user authentication
-📊 Files: 3 changed, +150 lines
-🔄 Branch: main
+{operation_details}
 
-💡 Next: /p:git push to deploy
+/p:ship | /p:status
 ```
 
-## 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

@@ -1,72 +1,38 @@
 ---
-allowed-tools: [Read]
-description: "Interactive guide - talk naturally, no memorization needed"
+allowed-tools: []
+description: "Interactive guide"
 ---
 
 # /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"
+1. 🚀 Start working
+   Say: "I want to start {task}"
+   Or: /p:now "{task}"
 
-2. ✅ I finished a task
-   Say: "I'm done" or "finished"
+2. ✅ Finish task
+   Say: "I'm done"
    Or: /p:done
 
-3. 🎉 Ship a feature
-   Say: "ship [feature name]"
-   Or: /p:ship "feature"
+3. 🎉 Ship feature
+   Say: "ship {feature}"
+   Or: /p:ship "{feature}"
 
-4. 💡 Capture an idea
-   Say: "I have an idea about [thing]"
-   Or: /p:idea "idea text"
+4. 💡 Capture idea
+   Say: "idea about {thing}"
+   Or: /p:idea "{idea}"
 
-5. 📊 See my progress
-   Say: "show me my progress"
+5. 📊 See progress
+   Say: "show 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?
+💬 Talk naturally - I understand both!
 ```
 
-## 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

@@ -1,5 +1,5 @@
 ---
-allowed-tools: [Read, Write, Edit]
+allowed-tools: [Write]
 description: "Quick idea capture"
 ---
 
@@ -10,41 +10,16 @@ description: "Quick idea capture"
 /p:idea <text>
 ```
 
-## Execution
+## Flow
+1. Append: `planning/ideas.md` with timestamp
+2. If actionable → add to `core/next.md`
+3. Log: `memory/context.jsonl`
 
-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]
+## Response
+```
+💡 {idea}
+{✅ Added to queue | 📝 Saved to backlog}
 
-   What now?
-   • "add another idea" → Keep brainstorming
-   • "start working" → Pick a task
-   • "see my ideas" → View backlog
+/p:now "{idea}" | /p:next
+```
 
-   Or: /p:idea | /p:now | /p:next
-   ```

package/templates/commands/init.md

@@ -1,295 +1,48 @@
 ---
-allowed-tools: [Read, Write, Bash, Glob]
-description: "Initialize prjct project with global architecture"
+allowed-tools: [Read, Write, Bash]
+description: "Initialize prjct project"
 ---
 
-# /p:init - Initialize Project
+# /p:init
 
-## Purpose
-Initialize a new prjct project using global architecture with centralized data storage.
+## Flow
+1. Generate: project ID from path hash
+2. Create: `~/.prjct-cli/projects/{id}/` structure
+3. Write: `.prjct/prjct.config.json`
+4. Init: all markdown files with templates
+5. Log: `memory/context.jsonl`
 
-## 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)
+## Directory Structure
 ```
-
-### 2. Create Global Directory Structure
-```bash
-# Create global data directory
-mkdir -p ~/.prjct-cli/projects/$PROJECT_ID/{core,progress,planning,analysis,memory}
+~/.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
 ```
 
-### 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
+## Config Format
+```json
 {
-  "version": "0.3.0",
-  "projectId": "$PROJECT_ID",
-  "dataPath": "~/.prjct-cli/projects/$PROJECT_ID",
+  "version": "0.6.0",
+  "projectId": "{id}",
+  "dataPath": "~/.prjct-cli/projects/{id}",
   "author": {
-    "name": "$AUTHOR_NAME",
-    "email": "$AUTHOR_EMAIL"
-  },
-  "createdAt": "$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
+    "name": "{from git}",
+    "email": "{from git}",
+    "github": "{from remote}"
+  }
 }
-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. Run Project Analysis
-
-Execute `/p:analyze` to understand the project:
-
-```javascript
-// This should execute the analyze command internally
-// The AI will:
-// 1. Scan project structure
-// 2. Detect stack and frameworks
-// 3. Check git status
-// 4. Determine which agents are needed
-// 5. Save analysis to .prjct/analysis/repo-summary.md
-```
-
-### 9. Generate AI Agents
-
-Based on the analysis, generate specialized AI agents:
-
-```javascript
-const agentGenerator = require('../core/agent-generator')
-const analysis = await readAnalysisFile('.prjct/analysis/repo-summary.md')
-
-// Generate all required agents
-const generatedAgents = await agentGenerator.generateAll(analysis)
-
-// Agents are created in ~/.claude/agents/
-// They are immediately available in Claude Code and Claude Desktop
 ```
 
-**Generated Agents**:
-- **Base** (always): PM, UX, FE, BE, QA, Scribe (6 agents)
-- **Conditional** (based on project):
-  - Security (if web app or has auth)
-  - DevOps (if Docker/CI/CD detected)
-  - Mobile (if React Native/Flutter detected)
-  - Data (if ML/data science detected)
-
-### 10. Log Initialization
-
-Add initialization record to memory:
-```jsonl
-{"timestamp":"2025-10-01T09:00:00Z","action":"init","author":"Name","projectPath":"/path/to/project","projectId":"abc123def456","agents":["pm","ux","fe","be","qa","scribe","security"]}
+## Response
 ```
+✅ prjct initialized!
 
-### 11. Success Message (Conversational Onboarding)
+📁 Data: ~/.prjct-cli/projects/{id}
+📝 Config: .prjct/prjct.config.json
 
+/p:now | /p:idea | /p:status
 ```
-✅ Your project is ready!
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-📦 Project Analysis Complete
-
-Project: [PROJECT_NAME]
-Type: [PROJECT_TYPE]
-Stack: [DETECTED_STACK]
-
-🤖 AI Agents Generated ([COUNT] specialists)
-
-✅ PM - Project coordination
-✅ UX - Design & user experience
-✅ FE - Frontend development
-✅ BE - Backend development
-✅ QA - Testing & quality
-✅ Scribe - Documentation
-[+ conditional agents if detected]
-
-These agents are now available in Claude and will provide
-specialized expertise for your project tasks.
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-💬 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

@@ -1,74 +1,32 @@
 ---
-allowed-tools: [Read, Write, Edit]
-description: "Display and manage priority queue"
+allowed-tools: [Read]
+description: "Show priority queue (top 5 non-blocking)"
 ---
 
-## 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
 
+## Flow
+1. Check: `core/now.md` → if active task, show warning
+2. Read: `core/next.md` → filter blocked tasks
+3. Return: top 5 actionable
 
-
-# /p:next - Priority Queue
-
-## Purpose
-Display the prioritized queue of upcoming tasks.
-
-## Usage
+## Response (active task)
 ```
-/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
+⚠️  Active: {current_task}
+Started: {time_ago}
 
-1. **Read core/next.md**:
-   - Parse markdown list of tasks
-   - Number them for easy reference
-   - Show task priorities and contexts
+Complete first: /p:done
 
-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
-   ```
+📋 Queue preview:
+{top_5_numbered}
+```
 
-   Or if empty:
-   ```
-   📋 Queue is empty!
+## Response (no active)
+```
+📋 Priority Queue
 
-   Add tasks:
-   - Directly edit .prjct/core/next.md
-   - Use /p:idea for quick capture
-   - Check /p:roadmap for strategic planning
+{numbered_tasks_1_to_5}
 
-   📂 Related:
-   - Planning: .prjct/planning/roadmap.md
-   - Ideas: .prjct/planning/ideas.md
-   ```
+/p:build {1-5} | /p:build "{task}"
+```
 
-## Tips
-- Keep queue short (5-10 items)
-- Most important tasks first
-- Review and reprioritize regularly