prjct-cli 0.5.1 → 0.7.0

package/templates/commands/ship.md

@@ -1,181 +1,148 @@
 ---
-allowed-tools: [Read, Write, Edit, TodoWrite]
-description: "Ship a feature"
+allowed-tools: [Read, Write, Bash]
+description: 'Ship feature with complete automated workflow'
 ---
 
 # /p:ship
 
 ## Usage
+
 ```
-/p:ship <feature>
+/p:ship              # Current task
+/p:ship "<feature>"  # Named feature
 ```
 
-## Execution
-
-1. Add to `~/.prjct-cli/projects/{id}/progress/shipped.md`:
-   ```markdown
-   ## Week [W], [YEAR]
-   - ✅ [feature] ([timestamp])
-   ```
-
-2. **Trigger Scribe Agent** (Documentation):
-   - Get git changes for the feature: `git diff --name-only`
-   - Invoke Scribe agent to document the shipped feature
-   - Show documentation draft to user
-   - **Request confirmation** before saving
-   - Save to `analysis/feature-docs/[feature-id].md` if confirmed
-
-3. Update `progress/metrics.md` (count, velocity, streak)
-4. Update `core/context.md`
-5. Log to `memory/context.jsonl`:
-   ```json
-   {"action":"ship","feature":"[desc]","timestamp":"[ISO]","week":"[w]","layer":"progress","total":[n],"documented":true}
-   ```
+## Complete Workflow (Automated)
 
-6. Response:
-   ```
-   🚀 [feature name] shipped!
+1. ✅ **Lint checks** → Run project linters
+2. ✅ **Run tests** → Execute test suite (does NOT block if fail)
+3. ✅ **Update docs** → Update relevant documentation
+4. ✅ **Update version** → Bump version (patch/minor based on changes)
+5. ✅ **Update CHANGELOG** → Add entry with changes
+6. ✅ **Git commit** → Create commit with metadata
+7. ✅ **Git push** → Push to remote
+8. ✅ **Recommend compact** → Suggest conversation compacting
 
-   📈 This week: [count] | Total: [total]
-   Velocity: [X] features/day
+## Workflow Steps Detail
 
-   Keep the momentum!
-   • "start next task" → Keep building
-   • "see my progress" → View stats
-   • "plan ahead" → Strategic thinking
+### Step 1: Lint Checks
 
-   Or: /p:now | /p:recap | /p:roadmap
-   ```
-
-## Scribe Agent Workflow
-
-When a feature is shipped, the Scribe agent is automatically invoked to document changes:
+```bash
+npm run lint || yarn lint || pnpm lint
+# If fails: Show errors but continue
+```
 
-### Step 1: Detect Changes
-```javascript
-const gitIntegration = require('../core/git-integration')
+### Step 2: Run Tests
 
-// Get files changed for this feature
-const changes = await gitIntegration.getChangesSince(featureStartTime)
+```bash
+npm test || yarn test || pnpm test
+# If fails: Show results but DO NOT block (no infinite loop)
+# User decides if acceptable to ship
 ```
 
-### Step 2: Generate Documentation
-Invoke Scribe agent with prompt:
-```
-Document the following shipped feature:
+### Step 3: Update Docs
 
-Feature: "[feature description]"
-Shipped: [timestamp]
-Files changed:
-${changes.files.join('\n')}
+- Update README if needed
+- Update API docs if endpoints changed
+- Update component docs if UI changed
 
-Generate release documentation including:
-1. Feature overview and user impact
-2. Technical implementation summary
-3. Key files and components affected
-4. Breaking changes or migration notes (if any)
-5. Usage examples
+### Step 4: Update Version
 
-Keep it concise and user-focused (< 300 words).
+```json
+// package.json
+"version": "X.Y.Z" → "X.Y.(Z+1)"  // patch for fixes
+"version": "X.Y.Z" → "X.(Y+1).0"  // minor for features
 ```
 
-### Step 3: Show Draft & Request Confirmation
-```
-📝 Scribe Agent Feature Documentation
+### Step 5: Update CHANGELOG
 
-## Feature: [feature description]
+```markdown
+## [X.Y.Z] - YYYY-MM-DD
 
-**Shipped**: [date]
-**Impact**: [user-facing impact]
+### Added / Changed / Fixed
 
-**Overview**:
-[AI-generated feature summary]
+- {feature_description}
+- Agent: {agent}
+- Time: {actual_time}
+```
 
-**Technical Details**:
-- [Implementation highlights]
-- [Key components]
+### Step 6-7: Git Commit + Push
 
-**Usage**:
-[Examples if applicable]
+Auto-commit with metadata and push
 
-**Breaking Changes**: [None / List]
+### Step 8: Log to Session
 
-─────────────────────────────────────
+Append to `progress/sessions/{YYYY-MM}/{YYYY-MM-DD}.jsonl`:
 
-Save this documentation? (y/n): _
+```jsonl
+{"ts":"2025-10-04T18:00:00Z","type":"feature_ship","name":"{feature}","tasks_done":{N},"duration":"{Xh}","agent":"{agent}","version":"{X.Y.Z}"}
 ```
 
-### Step 4: Save if Confirmed
-```javascript
-if (userConfirms) {
-  const docPath = `~/.prjct-cli/projects/{id}/analysis/feature-docs/${featureId}.md`
-  await saveDocumentation(docPath, documentation)
-  console.log('✅ Feature documentation saved!')
-} else {
-  console.log('ℹ️  Documentation discarded')
-}
-```
+### Step 9: Update Index
 
-## Example with Scribe
+Prepend to `progress/shipped.md` (keep only last 30 days):
 
+```markdown
+## 2025-10-04
+- ✅ {feature_name} ({Xh}, {N} tasks, v{X.Y.Z})
 ```
-/p:ship "authentication system"
 
-🚀 authentication system shipped!
+If shipped.md has entries > 30 days old, archive to `progress/archive/shipped-{YYYY-MM}.md`
 
-📝 Scribe Agent is documenting your feature...
+### Step 10: Update Roadmap
 
-─────────────────────────────────────────────
+Mark feature as complete in `planning/roadmap.md`:
 
-## Feature: authentication system
+```markdown
+## Completed
+- [x] {feature_name} - Shipped 2025-10-04
+```
 
-**Shipped**: 2025-10-02
-**Impact**: Users can now securely log in and manage sessions
+### Step 11: Recommend Compact
 
-**Overview**:
-Implemented JWT-based authentication with login, registration, and password reset. Added middleware for protected routes and session management with automatic token refresh.
+Suggest compacting conversation after ship
 
-**Technical Details**:
-- JWT authentication with bcrypt password hashing
-- Login/register/reset endpoints in auth.controller.ts
-- JWT middleware for route protection
-- Redis-based session management with 7-day expiry
-- Email verification workflow
+## Commit Message Format
 
-**Files Modified**:
-- src/features/auth/auth.service.ts (new)
-- src/features/auth/auth.controller.ts (new)
-- src/middleware/jwt.middleware.ts (new)
-- src/config/redis.config.ts (modified)
+```
+feat: {feature_name}
 
-**Breaking Changes**: None
+Agent: {agent}
+Dev: @{github_dev}
+Complexity: {complexity}
+Time: {actual_time}
 
-**Usage**:
-```javascript
-// Protected route example
-app.get('/api/profile', jwtMiddleware, profileController.get)
+🤖 Generated with [p/](https://www.prjct.app/)
+Designed for [Claude](https://www.anthropic.com/claude)
 ```
 
-─────────────────────────────────────────────
+**IMPORTANT**: This footer format MUST be used in ALL commits made by prjct.
+
+## Response
 
-Save this documentation? (y/n): y
+```
+🚀 {feature} shipped!
 
-✅ Feature documentation saved to analysis/feature-docs/!
+Workflow completed:
+  ✅ Lint checks: {pass/fail_continued}
+  ✅ Tests: {pass/fail_continued}
+  ✅ Docs: updated
+  ✅ Version: {old} → {new}
+  ✅ CHANGELOG: updated
+  ✅ Git: committed + pushed
 
-📈 This week: 3 | Total: 15
-Velocity: 2.1 features/day
+{agent_icon} {agent} • {actual_time}
 
-Keep the momentum!
-• "start next task" → Keep building
-• "see my progress" → View stats
+💡 Recommendation: Compact conversation now
+   (Keeps context clean for next feature)
 
-Or: /p:now | /p:recap
+/p:feature | /p:done
 ```
 
-## Notes
+## Important Notes
 
-- Scribe agent uses git history to understand feature scope
-- Documentation is saved per-feature for release notes
-- User confirmation prevents unwanted documentation
-- Can skip documentation by saying "no"
-- Feature docs help with changelog generation and onboarding
+- **Tests/Lint failures DO NOT block shipping**
+- User sees results and decides
+- Prevents infinite loop of "fix → test → fail → fix"
+- ALWAYS updates version and CHANGELOG
+- ALWAYS commits and pushes if workflow completes

package/templates/commands/status.md

@@ -0,0 +1,42 @@
+---
+allowed-tools: [Read]
+description: 'KPI dashboard with ASCII graphics'
+---
+
+# /p:status
+
+## Flow
+
+1. Read: all core files + progress files
+2. Calculate: metrics (sprint %, tasks complete, days since ship, etc.)
+3. Render: `ASCIIGraphics.createDashboard(data)`
+
+## Data Structure
+
+```js
+{
+  sprintProgress: (complete / total) * 100,
+  tasksComplete: count,
+  tasksTotal: count,
+  ideasCount: count,
+  daysSinceShip: days,
+  currentTask: string,
+  taskTime: 'Xh Ym ago'
+}
+```
+
+## Output (Catppuccin Mocha)
+
+```
+┌─ Project Status ────────────────┐
+│ Sprint Progress  [████░] 80%    │
+│ Tasks Complete   12/15          │
+│ Ideas Backlog    8              │
+│ Days Since Ship  3              │
+├─ Current Focus ─────────────────┤
+│ → {current_task}                │
+│   Started: {time_ago}           │
+└─────────────────────────────────┘
+```
+
+**Colors**: Mauve borders, Teal progress, Sapphire highlights, Green/Yellow/Red for status

package/templates/commands/sync.md

@@ -1,220 +1,34 @@
 ---
-allowed-tools: [Read, Write, Bash, Glob, Grep, TodoWrite]
-description: "Sync project state and update AI agents based on latest analysis"
+allowed-tools: [Read, Write, Bash, TodoWrite]
+description: 'Sync project state and generate dynamic agents'
 ---
 
-# /p:sync - Sync Project State
+# /p:sync
 
-## Purpose
-Re-analyze the project and update all AI agents with current project state, stack changes, and new requirements.
+## Flow
 
-## Global Architecture
-This command uses the global prjct architecture:
-- Data stored in: `~/.prjct-cli/projects/{id}/`
-- Config stored in: `{project}/.prjct/prjct.config.json`
-- Agents updated in: `~/.claude/agents/`
+1. Run: `/p:analyze` → get current state
+2. **Read**: `analysis/repo-summary.md`
+3. **Generate**: Dynamic agents for each technology
+4. Log: changes to `memory/context.jsonl`
 
-## Usage
-```
-/p:sync
-```
-
-## When to Run
-- After major dependency changes
-- When adding new frameworks or tools
-- After significant architecture changes
-- When project type changes (e.g., adding mobile support)
-- Periodically to keep agents up-to-date
-
-## Execution Flow
-
-### 1. Re-run Project Analysis
-
-Execute `/p:analyze` to get current project state:
-```javascript
-// This will:
-// 1. Scan all files and directories
-// 2. Detect current stack and frameworks
-// 3. Check git status
-// 4. Compare with previous analysis
-// 5. Identify what changed
-```
-
-### 2. Detect Changes
-
-Compare new analysis with previous:
-```javascript
-const previousAnalysis = await readFile('.prjct/analysis/repo-summary.md')
-const currentAnalysis = await runAnalyze()
-
-const changes = {
-  newDependencies: [],
-  removedDependencies: [],
-  newFrameworks: [],
-  stackChanges: [],
-  structureChanges: []
-}
-
-// Detect what changed
-if (currentAnalysis.frameworks !== previousAnalysis.frameworks) {
-  changes.newFrameworks = difference(current, previous)
-}
-```
-
-### 3. Update Existing Agents
-
-Regenerate all current agents with new context:
-```javascript
-const agentGenerator = require('../core/agent-generator')
+## Agent Generation
 
-// Update all existing agents
-const updated = await agentGenerator.updateExistingAgents(currentAnalysis)
+**See `templates/agents/AGENTS.md` for complete reference** with examples and guidelines.
 
-console.log(`↻ Updated ${updated.length} agents with new context`)
-```
-
-### 4. Add New Agents
-
-Generate any newly required agents:
-```javascript
-// Detect newly required agents
-const existingAgents = await listAgentFiles()
-const requiredAgents = detectRequiredAgents(currentAnalysis)
-const newAgents = requiredAgents.filter(a => !existingAgents.includes(a))
-
-if (newAgents.length > 0) {
-  for (const agentType of newAgents) {
-    await agentGenerator.generateAgent(agentType, currentAnalysis)
-    console.log(`✅ Added ${agentType} agent`)
-  }
-}
-```
-
-### 5. Remove Obsolete Agents (Optional)
-
-Ask user if agents should be removed:
-```javascript
-const obsoleteAgents = existingAgents.filter(a => !requiredAgents.includes(a))
+Use `generator.generateDynamicAgent(name, config)` for each specialist.
 
-if (obsoleteAgents.length > 0) {
-  console.log(`\n⚠️  The following agents may no longer be needed:`)
-  obsoleteAgents.forEach(a => console.log(`   - ${a}`))
+## Response
 
-  const shouldRemove = await confirmWithUser('\nRemove these agents? (y/n): ')
-
-  if (shouldRemove) {
-    await agentGenerator.cleanupObsoleteAgents(requiredAgents)
-  }
-}
 ```
+🔄 Sync complete!
 
-### 6. Update Analysis File
-
-Save new analysis:
-```bash
-# Backup previous analysis
-cp .prjct/analysis/repo-summary.md .prjct/analysis/repo-summary.backup.md
-
-# Save new analysis
-# (already saved by /p:analyze)
-```
-
-### 7. Update Memory Log
-
-Log sync action:
-```jsonl
-{"timestamp":"2025-10-02T14:30:00Z","action":"sync","author":"Name","changes":{"addedAgents":["mobile"],"updatedAgents":["fe","be"],"removedAgents":[],"stackChanges":["added react-native"]}}
-```
+🤖 Agents Generated:
+• {agent_name_1} - {role}
+• {agent_name_2} - {role}
 
-## Output Examples
+📋 Based on: analysis/repo-summary.md
+💡 See templates/agents/AGENTS.md for generation reference
 
-### No Changes
+/p:context
 ```
-🔄 Syncing project state...
-
-📊 Analysis Complete
-   No significant changes detected
-
-🤖 Agents Status
-   ✓ All 7 agents are up-to-date
-
-✅ Sync complete! Everything is current.
-```
-
-### With Changes
-```
-🔄 Syncing project state...
-
-📊 Changes Detected
-   ✅ New dependency: @tanstack/react-query
-   ✅ New framework: Expo (React Native)
-   ℹ️  Architecture: Still feature-based
-
-🤖 Agent Updates
-   ↻ FE agent - Added React Query patterns
-   ↻ BE agent - Updated API integration context
-   ✅ Mobile agent - ADDED (React Native detected)
-   ✓ Other agents - No changes needed
-
-⚠️  Obsolete Agents
-   - devops (Docker removed from project)
-
-   Remove obsolete agents? (y/n): _
-
-✅ Sync complete!
-   - 2 agents updated
-   - 1 agent added
-   - 1 agent removed
-```
-
-### Stack Migration
-```
-🔄 Syncing project state...
-
-📊 Major Changes Detected
-   ⚠️  Framework changed: Vue → React
-   ⚠️  Build tool changed: Webpack → Vite
-   ✅ New: TypeScript added
-
-🤖 Full Agent Regeneration
-   ↻ PM - Updated with React patterns
-   ↻ UX - Updated component guidelines
-   ↻ FE - COMPLETELY REGENERATED for React + TS
-   ↻ BE - Updated API patterns
-   ↻ QA - Updated test framework context
-   ↻ Scribe - Updated documentation style
-
-✅ Sync complete! All agents updated for new stack.
-
-💡 Tip: Review agent descriptions to see new capabilities.
-```
-
-## Error Handling
-
-- **No .prjct/**: Error - Project not initialized, run `/p:init` first
-- **No analysis file**: Warning - Running first-time analysis
-- **Agent generation fails**: Warn but continue with others
-- **Permission issues**: Suggest checking `~/.claude/agents/` permissions
-
-## Notes
-
-- Sync is safe to run anytime
-- Existing agents are updated, not deleted (unless confirmed)
-- Git status is refreshed during sync
-- Analysis diff helps track project evolution
-- Agents get project-specific context from analysis
-
-## Related Commands
-
-- `/p:analyze` - Just analyze without updating agents
-- `/p:init` - Initialize project (first-time setup)
-- `/p:context` - View current project context
-
-## Implementation Notes
-
-The sync command should:
-1. Be idempotent (safe to run multiple times)
-2. Preserve manual agent customizations (warn if detected)
-3. Create backups before major changes
-4. Provide clear diff of what changed
-5. Allow granular control (which agents to update)

package/templates/commands/task.md

@@ -1,97 +1,37 @@
 ---
-allowed-tools: [Read, Write, Edit, TodoWrite, Bash, Glob]
-description: "Break down and execute complex tasks systematically"
+allowed-tools: [Read, Write, TodoWrite]
+description: 'Break down complex tasks'
 ---
 
-## 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:task - Complex Task Execution
-
-## Purpose
-Handle complex features by breaking them down, executing systematically, and tracking progress. No overwhelm.
+# /p:task
 
 ## Usage
+
 ```
 /p:task <description>
 ```
 
-## Execution
-1. Analyze task complexity
-2. Break into 3-7 subtasks automatically
-3. Create execution plan in `.prjct/planning/tasks/`
-4. Execute each subtask with validation
-5. Track progress and update metrics
+## Flow
 
-## Implementation
+1. Analyze: task complexity
+2. Break down: into 3-7 subtasks
+3. Create: execution plan
+4. Execute: each subtask with validation
+5. Track: progress in `planning/tasks/`
 
-**Task breakdown**:
-- Identify main components needed
-- Order by dependencies
-- Estimate time for each
-- Create actionable subtasks
+## Response
 
-**Example breakdown**:
 ```
-/p:task "implement user authentication"
-
-📋 Task Plan Created:
-
-1. Database schema (15 min)
-   - User table with email/password
-   - Sessions table
-
-2. Auth middleware (30 min)
-   - JWT token generation
-   - Route protection
-
-3. API endpoints (45 min)
-   - POST /auth/signup
-   - POST /auth/login
-   - POST /auth/logout
+📋 Task Plan: {description}
 
-4. Frontend forms (30 min)
-   - Login component
-   - Signup component
+Breakdown:
+1. {subtask} (~{time})
+2. {subtask} (~{time})
+3. {subtask} (~{time})
 
-5. Testing (20 min)
-   - Auth flow tests
-   - Security tests
+Est total: {total_time}
 
 🚀 Starting execution...
-[1/5] Creating database schema... ✅
-[2/5] Building auth middleware... 🔄
+[1/{N}] {subtask}... ✅
+[2/{N}] {subtask}... 🔄
 ```
-
-**Progress tracking**:
-- Real-time status updates
-- Save progress between sessions
-- Resume interrupted tasks
-- Log to `.prjct/memory/context.jsonl`
-
-**Response format**:
-```
-✅ Task completed: User authentication
-
-📊 Execution Summary:
-• Time: 2h 15min (estimated 2h 20min)
-• Subtasks: 5/5 completed
-• Tests: All passing
-• Files: 12 created/modified
-
-📝 Logged to: .prjct/planning/tasks/auth_system.md
-
-💡 Next: /p:ship "user authentication"
-```
-
-## Features
-- Automatic task decomposition
-- Progress persistence
-- Time tracking
-- Dependency management
-- Smart validation gates