prjct-cli 0.5.1 → 0.7.0

package/templates/commands/git.md

@@ -1,79 +1,57 @@
 ---
-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
+## Flow: commit
 
-## Execution
+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
 
-### `/p:git push`
-1. Commit any pending changes first
-2. Push to current branch
-3. Show deployment status if applicable
+1. Git: `status` → verify clean
+2. Git: `push` with branch tracking
+3. Handle: errors (upstream, conflicts)
 
-### `/p:git status`
-1. Show clean git status with emoji indicators
-2. Suggest next logical action
+## Flow: sync
 
-### `/p:git sync`
-1. Pull latest changes
-2. Commit local changes if any
-3. Push to remote
-4. Handle merge conflicts if needed
+1. Git: `pull --rebase`
+2. Resolve: conflicts if any
+3. Git: `push`
 
-## Implementation
+## Commit Message Format
 
-**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
+```
+{type}: {description}
 
-**Example messages**:
-- "✨ feat: Add user authentication system"
-- "🐛 fix: Resolve null pointer in auth middleware"
-- "📝 docs: Update API documentation"
-- "♻️ refactor: Simplify database connection logic"
+Agent: {agent}
+Dev: @{github_dev}
 
-**Response format**:
+Generated-by: prjct/cli
+Co-Authored-By: @{github_dev}
 ```
-✅ Changes committed!
 
-📝 Message: feat: Add user authentication
-📊 Files: 3 changed, +150 lines
-🔄 Branch: main
+## Response
 
-💡 Next: /p:git push to deploy
 ```
+✅ Git {operation}
 
-## Best Practices
-- Always pulls before pushing
-- Auto-stages all changes
-- Generates conventional commit messages
-- Tracks in project memory for context
+{operation_details}
+
+/p:ship | /p:status
+```

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,50 +1,34 @@
 ---
-allowed-tools: [Read, Write, Edit]
-description: "Quick idea capture"
+allowed-tools: [Write]
+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]
+## Flow
 
-   ✅ Added to task queue!
+1. **Append to session**: `planning/sessions/{YYYY-MM}/{YYYY-MM-DD}.jsonl`
+2. **Update index**: Append to `planning/ideas.md` (keep only last 30 days)
+3. If actionable → add to `core/next.md`
+4. **Archive old**: If ideas.md > 30 days, move to `planning/archive/ideas-{YYYY-MM}.md`
 
-   Ready to start?
-   • "start this idea" → Begin now
-   • "plan more" → Keep brainstorming
-   • "see all ideas" → View backlog
+## Session Log Format
 
-   Or: /p:now "[idea]" | /p:idea | /p:recap
-   ```
+```jsonl
+{"ts":"2025-10-04T16:00:00Z","type":"idea_add","idea":"{text}","actionable":{true/false},"priority":"{high/med/low}"}
+```
 
-   Or (if just backlog):
-   ```
-   💡 Idea saved: [idea text]
+## Response
 
-   What now?
-   • "add another idea" → Keep brainstorming
-   • "start working" → Pick a task
-   • "see my ideas" → View backlog
+```
+💡 {idea}
+{✅ Added to queue | 📝 Saved to backlog}
 
-   Or: /p:idea | /p:now | /p:next
-   ```
+/p:now "{idea}" | /p:next
+```

package/templates/commands/init.md

@@ -1,295 +1,103 @@
 ---
-allowed-tools: [Read, Write, Bash, Glob]
-description: "Initialize prjct project with global architecture"
+allowed-tools: [Read, Write, Bash]
+description: 'Initialize prjct project (with architect mode for blank projects)'
 ---
 
-# /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
+# /p:init
 
 ## 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}
+/p:init                    # Existing project
+/p:init "[idea]"          # New blank project (architect mode)
 ```
 
-### 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")
+## Flow: Existing Project
 
-# 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.
-```
+1. Generate: project ID from path hash
+2. Create: `~/.prjct-cli/projects/{id}/` structure (including `agents/`)
+3. Write: `.prjct/prjct.config.json`
+4. Run: `/p:analyze` to understand stack
+5. Generate: agents based on stack
+6. Log: `memory/context.jsonl`
 
-**~/.prjct-cli/projects/{id}/core/context.md**:
-```markdown
-# Project Context
+## Flow: Blank Project (Architect Mode)
 
-## Overview
-[Auto-generated from `/p:analyze`]
+1. Generate: project ID
+2. Activate: ARCHITECT role
+3. Analyze: idea/requirements
+4. Recommend: tech stack options (Next.js, React, Vue, etc.)
+5. User confirms: choice
+6. Create: directory structure + base files
+7. Generate: initial roadmap
+8. Generate: agents
+9. Ask: "¿Empezamos con la primera feature?"
 
-## Current Focus
-[Link to current task in now.md]
+## Directory Structure
 
-## 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]
+~/.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
+├── agents/        # AI agent definitions
+└── memory/        # context.jsonl
 ```
 
-### 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
+## Config Format
 
-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
+```json
+{
+  "version": "0.6.0",
+  "projectId": "{id}",
+  "dataPath": "~/.prjct-cli/projects/{id}",
+  "author": {
+    "name": "{from git}",
+    "email": "{from git}",
+    "github": "{from remote}"
+  }
+}
 ```
 
-### 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)
+## Response: Existing Project
 
-// Agents are created in ~/.claude/agents/
-// They are immediately available in Claude Code and Claude Desktop
 ```
+✅ prjct initialized!
 
-**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)
+📁 Data: ~/.prjct-cli/projects/{id}
+📝 Config: .prjct/prjct.config.json
+📊 Analysis: {stack_summary}
+🤖 Agents: {N} agents generated
 
-### 10. Log Initialization
+Listo para trabajar! ¿Qué feature agregamos?
 
-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"]}
+/p:feature | /p:analyze
 ```
 
-### 11. Success Message (Conversational Onboarding)
+## Response: Blank Project
 
 ```
-✅ 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!
+✅ prjct initialized!
 
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+📐 ARCHITECT MODE
 
-🎯 To start working:
+Your idea: "{idea}"
 
-   Say: "I want to start building the login page"
-   Or:  /p:now "build login page"
+Recommended stack:
+  Option 1: Next.js + TypeScript + Tailwind (⭐ Recommended)
+  Option 2: React + Vite + shadcn/ui
+  Option 3: Vue 3 + Nuxt
 
-   → I'll track your focus and time
+Which option? (or describe your preference)
 
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+[After user confirms:]
 
-✅ When you finish something:
+✅ Structure created!
+📋 Initial roadmap: {N} features
+🤖 Agents: generated
 
-   Say: "I'm done" or "finished that"
-   Or:  /p:done
+¿Empezamos con la primera feature?
 
-   → 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)
+/p:feature | /p:ship
 ```
-
-## 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)