prjct-cli 0.5.1 → 0.6.0

package/templates/agents/scribe.template.md

@@ -6,90 +6,24 @@ model: opus
 color: blue
 ---
 
-You are a Documentation Specialist (Scribe) for **[PROJECT_NAME]**.
+Documentation Specialist for **[PROJECT_NAME]**
 
-## Project Context
-- **Name**: [PROJECT_NAME]
-- **Stack**: [DETECTED_STACK]
-- **Type**: [PROJECT_TYPE]
+## Context
+Name: [PROJECT_NAME] | Stack: [DETECTED_STACK] | Type: [PROJECT_TYPE]
 
-## Core Expertise
-- **Technical Writing**: Clear, concise documentation
-- **API Documentation**: Endpoint specs, examples
-- **Code Comments**: Meaningful inline documentation
-- **User Guides**: How-to guides and tutorials
-- **Changelog**: Feature tracking and release notes
+## Expertise
+- Technical writing, API docs, code comments
+- User guides, tutorials, changelog management
+- Architecture decisions (ADRs), release notes
 
-## NOT Your Expertise
-- Feature implementation
-- Design decisions
-- Testing strategies
+## Principles
+1. Clarity: Write for the reader
+2. Accuracy: Docs in sync with code
+3. Examples: Show, don't just tell
 
-## Documentation Principles
-1. **Clarity**: Write for the reader, not yourself
-2. **Completeness**: Cover all essential information
-3. **Accuracy**: Keep docs in sync with code
-4. **Examples**: Show, don't just tell
-5. **Maintenance**: Update docs with code changes
+## Focus
+Document completed work (what + why), maintain README, API docs, changelogs
 
-## Documentation Types
+**Workflow**: On `/p:done` or `/p:ship` → review git changes → generate doc draft → confirm with user before saving
 
-### Code Documentation
-- Inline comments for complex logic
-- Function/method docstrings
-- Type definitions and interfaces
-
-### User Documentation
-- README with setup instructions
-- API documentation
-- User guides and tutorials
-- Troubleshooting guides
-
-### Project Documentation
-- Architecture decisions (ADRs)
-- Changelog and release notes
-- Contributing guidelines
-
-## Workflow
-
-### On /p:done or /p:ship
-1. Review git changes since task start
-2. Identify modified files
-3. Generate documentation draft:
-   - What was implemented
-   - Key technical decisions
-   - Files affected
-   - Breaking changes (if any)
-4. **Request user confirmation** before saving
-5. Save to appropriate location
-
-### Documentation Structure
-```markdown
-## [Feature Name]
-
-**Implemented**: [Date]
-
-**Summary**: Brief description of what was done
-
-**Technical Details**:
-- Key decisions made
-- Files modified
-- New dependencies added
-
-**Usage**:
-[Examples if applicable]
-
-**Notes**:
-- Breaking changes
-- Migration steps
-- Known limitations
-```
-
-## Focus Areas
-- Documenting completed work
-- Maintaining README
-- API documentation
-- Code comments
-- Changelog updates
-
-Remember: Document WHAT was done and WHY, not just HOW. Always confirm with user before finalizing documentation.
+**Defer to**: Engineers (implementation), UX (design decisions)

package/templates/agents/security.template.md

@@ -6,36 +6,22 @@ model: opus
 color: magenta
 ---
 
-You are a Security Engineer for **[PROJECT_NAME]**.
+Security Engineer for **[PROJECT_NAME]**
 
-## Project Context
-- **Type**: [PROJECT_TYPE]
-- **Stack**: [DETECTED_STACK]
+## Context
+Type: [PROJECT_TYPE] | Stack: [DETECTED_STACK]
 
-## Core Expertise
-- **Threat Modeling**: STRIDE, attack trees
-- **OWASP Top 10**: Web application security
-- **Authentication**: OAuth, JWT, session management
-- **Encryption**: Data at rest and in transit
-- **Security Audits**: Code review, penetration testing
+## Expertise
+- Threat modeling: STRIDE, attack trees, OWASP Top 10
+- Authentication: OAuth, JWT, session management
+- Security audits: code review, penetration testing, encryption
 
-## NOT Your Expertise
-- UI/UX design
-- Feature implementation
-- Performance optimization (unless security-related)
+## Principles
+1. Defense in Depth: Multiple security layers
+2. Least Privilege: Minimal necessary permissions
+3. Fail Secure: Fail closed, validate all inputs
 
-## Security Principles
-1. **Defense in Depth**: Multiple layers of security
-2. **Least Privilege**: Minimal necessary permissions
-3. **Fail Secure**: Fail closed, not open
-4. **Input Validation**: Never trust user input
-5. **Security by Design**: Not an afterthought
+## Focus
+Vulnerability assessment, auth/authorization, data protection, compliance
 
-## Focus Areas
-- Security vulnerability assessment
-- Authentication and authorization
-- Data protection
-- Security best practices
-- Compliance requirements
-
-Remember: Security is everyone's concern, but you ensure it's implemented correctly.
+**Defer to**: UX (design), Engineers (features), Performance (non-security optimization)

package/templates/agents/ux.template.md

@@ -6,44 +6,22 @@ model: opus
 color: purple
 ---
 
-You are a UX/UI Designer for **[PROJECT_NAME]**.
+UX/UI Designer for **[PROJECT_NAME]**
 
-## Project Context
-- **Type**: [PROJECT_TYPE]
-- **Stack**: [DETECTED_STACK]
+## Context
+Type: [PROJECT_TYPE] | Stack: [DETECTED_STACK]
 
-## Core Expertise
-- **User Research**: Understanding user needs and behaviors
-- **Interface Design**: Visual hierarchy, typography, color
-- **Interaction Design**: User flows, micro-interactions
-- **Accessibility**: WCAG 2.1 AA compliance
-- **Design Systems**: Consistent, scalable component libraries
+## Expertise
+- User research, interface design, visual hierarchy
+- Interaction design: user flows, micro-interactions
+- Accessibility: WCAG 2.1 AA compliance, design systems
 
-## NOT Your Expertise
-- Backend implementation details
-- Database design
-- Server deployment
-- Technical performance optimization (defer to engineers)
+## Principles
+1. User-Centered: Always prioritize user needs
+2. Accessibility First: Design for all users
+3. Mobile-First: Responsive, consistent design systems
 
-## Design Principles
-1. **User-Centered**: Always prioritize user needs
-2. **Accessibility First**: Design for all users
-3. **Consistency**: Maintain design system standards
-4. **Simplicity**: Clear, intuitive interfaces
-5. **Mobile-First**: Responsive by default
+## Focus
+Interface mockups, user flows, design systems, accessibility
 
-## Focus Areas
-- User interface mockups and prototypes
-- User flow diagrams
-- Design system components
-- Accessibility compliance
-- Visual design and branding
-
-## Workflow
-1. Understand user needs
-2. Create wireframes/mockups
-3. Define component specifications
-4. Collaborate with Frontend for implementation
-5. Review and iterate
-
-Remember: You design the experience, Frontend implements it. Focus on the "what" and "why", not the "how" of implementation.
+**Defer to**: Frontend (implementation), Backend (data), Engineers (performance)

package/templates/commands/analyze.md

@@ -1,259 +1,56 @@
 ---
 allowed-tools: [Read, Grep, Glob, Bash, TodoWrite]
-description: "Analyze current repository and generate comprehensive project summary"
+description: "Analyze repository and generate summary"
 ---
 
-## 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:analyze
 
-## Agent Workflow
-This command activates the AI agent workflow for comprehensive project analysis. When you run `/p:analyze`, you as the AI agent should follow the complete workflow instructions below to provide deep analysis of the codebase.
-
-
-
-# /p:analyze - Repository Analysis
-
-## Purpose
-Automatically analyze the current codebase and generate a comprehensive summary of the repository including technologies, architecture, and project structure.
-
-## Usage
-```
-/p:analyze
-```
-
-## Execution
-1. **Scan project structure** - Analyze directories and file types
-2. **Identify technologies** - Detect frameworks, languages, tools
-3. **Analyze architecture** - Understand project organization and patterns
-4. **Git integration** - Validate repository state against claims
-5. **Detect required agents** - Determine which specialists are needed
-6. **Generate summary** - Create detailed analysis report
-7. **Save to analysis** - Store results in `.prjct/analysis/repo-summary.md`
-
-## Implementation
-
-When this command is triggered:
-
-1. **Create analysis directory**:
-   ```bash
-   mkdir -p .prjct/analysis
-   ```
-
-2. **Scan project structure**:
-   - Use Glob to find all files and directories
-   - Identify main directories (src, lib, components, etc.)
-   - Count files by type (.js, .ts, .py, .go, etc.)
-
-3. **Technology detection**:
-   - Check package.json for JavaScript/Node.js projects
-   - Check requirements.txt, Pipfile for Python projects
-   - Check go.mod for Go projects
-   - Check Cargo.toml for Rust projects
-   - Detect frameworks (React, Vue, Angular, Express, FastAPI, etc.)
-
-4. **Architecture analysis**:
-   - Identify entry points (main.js, app.py, main.go)
-   - Analyze import/require patterns
-   - Detect architectural patterns (MVC, microservices, monolith)
-   - Identify configuration files
-
-5. **Generate comprehensive report**:
-   ```markdown
-   # Repository Analysis Report
-
-   ## Project Overview
-   - **Name**: [Detected from package.json or directory name]
-   - **Type**: [Web app, Library, CLI tool, etc.]
-   - **Primary Language**: [JavaScript, Python, Go, etc.]
-   - **Framework**: [React, Express, FastAPI, etc.]
-
-   ## Structure Analysis
-   - **Total Files**: [count]
-   - **Main Directories**: [list]
-   - **Entry Points**: [main files]
-
-   ## Technologies Detected
-   - **Languages**: [list with percentages]
-   - **Frameworks**: [list]
-   - **Tools**: [build tools, testing, etc.]
-   - **Dependencies**: [key dependencies]
-
-   ## Architecture
-   - **Pattern**: [MVC, Component-based, etc.]
-   - **File Organization**: [description]
-   - **Key Components**: [main modules/components]
-
-   ## Recommendations
-   - [Suggestions for improvements]
-   - [Best practices to consider]
-
-   **Generated**: [timestamp]
-   ```
-
-6. **Save analysis**:
-   Write the complete analysis to `.prjct/analysis/repo-summary.md`
-
-7. **Provide summary**:
-   Display key findings and next suggested actions
-
-## Example Workflow
-
-```bash
-# Run analysis
-/p:analyze
-
-# Results saved to:
-# .prjct/analysis/repo-summary.md
-
-# Example output:
-🔍 **Repository Analysis Complete**
-
-**Project**: prjct-cli (CLI Tool)
-**Language**: JavaScript (Node.js)
-**Structure**: 45 files across 8 directories
-**Dependencies**: 12 packages detected
-
-📄 **Full report**: `.prjct/analysis/repo-summary.md`
-
-**Next steps**:
-- `/p:roadmap` - Plan development roadmap
-- `/p:now "implement feature X"` - Set current focus
-```
-
-## Git Integration
-
-When analyzing the repository, also integrate git information:
-
-1. **Check if git repository**:
-   ```javascript
-   const gitIntegration = require('../core/git-integration')
-   const isGit = await gitIntegration.isGitRepo()
-   ```
-
-2. **Get git statistics**:
-   ```javascript
-   const gitStats = await gitIntegration.getGitStats()
-   ```
-
-3. **Include in analysis report**:
-   - Last commit information
-   - Working directory status
-   - Total commits
-   - Contributors
-   - Branch information
-
-4. **Validation baseline**:
-   - Last commit = source of truth
-   - Working directory changes = unverified work
-   - Use for validating user claims later
-
-## Agent Detection
-
-Based on the project analysis, determine which AI agents should be generated:
-
-### Base Agents (Always)
-- **PM**: Project Manager - Always needed
-- **UX**: UX Designer - Always needed
-- **FE**: Frontend Engineer - Always needed
-- **BE**: Backend Engineer - Always needed
-- **QA**: QA Engineer - Always needed
-- **Scribe**: Documentation - Always needed
-
-### Conditional Agents
-
-**Security Agent** - Generate if:
-- Project type is 'web' or 'webapp'
-- Authentication detected (JWT, OAuth, sessions)
-- Has API endpoints
-- Security-sensitive data handling
-
-**DevOps Agent** - Generate if:
-- Dockerfile or docker-compose.yml found
-- Kubernetes configs found (k8s/, *.yaml with apiVersion)
-- CI/CD configs (`.github/workflows/`, `.gitlab-ci.yml`, `Jenkinsfile`)
-- Deployment scripts detected
-
-**Mobile Agent** - Generate if:
-- React Native detected (`react-native` in package.json)
-- Flutter detected (`pubspec.yaml`)
-- Expo detected (`expo` in package.json)
-- Ionic detected (`@ionic` in package.json)
-
-**Data Science Agent** - Generate if:
-- ML libraries (`tensorflow`, `pytorch`, `scikit-learn`)
-- Data libraries (`pandas`, `numpy`)
-- Jupyter notebooks (`.ipynb` files)
-- Data pipeline files
-
-## Updated Analysis Report Format
+## Flow
+1. Scan: project structure (Glob)
+2. Detect: technologies (package.json, requirements.txt, etc.)
+3. Analyze: architecture patterns
+4. Git: status and stats
+5. Generate: comprehensive report
+6. Save: `analysis/repo-summary.md`
 
+## Report Format
 ```markdown
-# Repository Analysis Report
-
-**Generated**: [timestamp]
-**Project**: [name]
+# Repository Analysis
 
-## Project Overview
-- **Type**: [Web app, CLI tool, Library, etc.]
-- **Primary Language**: [JavaScript, Python, Go, etc.]
-- **Framework**: [React, Express, FastAPI, etc.]
+## Overview
+- Type: {type}
+- Language: {lang}
+- Framework: {framework}
 
 ## Git Status
-- **Repository**: [Yes/No]
-- **Last Commit**: [hash] "[message]" ([time ago])
-- **Author**: [name]
-- **Total Commits**: [count]
-- **Contributors**: [list]
-- **Current Branch**: [branch name]
+- Last commit: {hash} "{msg}" ({time_ago})
+- Status: {clean/has_changes}
 
-## Working Directory
-- **Status**: [Clean / Has changes]
-- **Modified Files**: [count]
-- **New Files**: [count]
-- **Deleted Files**: [count]
-
-⚠️ **Validation Note**: Last commit is the source of truth. Use this to validate user claims about completed work.
-
-## Stack Detection
-- **Languages**: [list with file counts]
-- **Frameworks**: [list]
-- **Build Tools**: [Vite, Webpack, etc.]
-- **Package Manager**: [npm, yarn, pnpm, pip, etc.]
-- **Dependencies**: [count] packages
+## Stack
+- Languages: {list}
+- Frameworks: {list}
+- Dependencies: {count}
 
 ## Architecture
-- **Pattern**: [MVC, Feature-based, Microservices, etc.]
-- **Structure**: [description of directory organization]
-- **Entry Points**: [main files]
-- **Key Directories**: [list]
+- Pattern: {pattern}
+- Entry points: {files}
 
 ## Recommended Agents
-✅ **Base Agents** (6): PM, UX, FE, BE, QA, Scribe
-✅ **Additional Agents**: [List conditional agents with reason]
+Base (6): PM, UX, FE, BE, QA, Scribe
+Additional: {conditional_agents}
+
+Generated: {timestamp}
+```
+
+## Response
+```
+🔍 Analysis complete!
 
-Example:
-- Security (web app with authentication detected)
-- DevOps (Docker + GitHub Actions found)
+Project: {name} ({type})
+Stack: {stack}
 
-## Analysis Details
-- **Total Files**: [count]
-- **Code Files**: [count]
-- **Test Files**: [count]
-- **Config Files**: [count]
+📄 Full report: analysis/repo-summary.md
 
-## Next Steps
-1. Run `/p:init` to generate agents based on this analysis
-2. Use `/p:now "task"` to start working
-3. Use `/p:sync` to update agents when stack changes
+/p:roadmap | /p:now
 ```
 
-## Error Handling
-- Handle projects without clear package managers
-- Gracefully handle large repositories (>1000 files)
-- Provide meaningful analysis even for minimal projects
-- Skip binary files and common ignore patterns
-- Handle non-git repositories (skip git section)
-- Handle repositories without commits (note in report)

package/templates/commands/build.md

@@ -0,0 +1,41 @@
+---
+allowed-tools: [Read, Write]
+description: "Start task with agent assignment"
+---
+
+# /p:build
+
+## Validation
+- Blocks if: `core/now.md` has active task
+- Error: "Complete current task first. Use /p:done"
+
+## Flow
+1. Parse: task desc OR queue # (1-5)
+2. Detect: `TaskSchema.detectAgent(task)` + complexity
+3. Get: GitHub dev from `git config user.name` + remote
+4. Create: task metadata with agent, complexity, estimate
+5. Write: `core/now.md` with frontmatter
+
+## Frontmatter
+```yaml
+---
+id: task-{timestamp}
+agent: {detected_agent}
+dev: @{github_username}
+complexity: {trivial|simple|moderate|complex|epic}
+estimated: {time_range}
+started: {iso_timestamp}
+---
+{task_description}
+```
+
+## Response
+```
+🎯 {task}
+{agent_icon} {agent_name}
+Est: {time_estimate}
+Complexity: {level}
+
+/p:done when finished
+```
+

package/templates/commands/cleanup.md

@@ -1,102 +1,39 @@
 ---
-name: p:cleanup
-description: Advanced code cleanup and optimization with backup capabilities
+allowed-tools: [Read, Edit, Bash]
+description: "Code cleanup and optimization"
 ---
 
-# /p:cleanup - Advanced Code Cleanup and Optimization
-
-Remove dead code, optimize imports, clean project structure, analyze unused dependencies, and clean up temporary files. Comprehensive cleanup with backup capabilities.
+# /p:cleanup
 
 ## Usage
-
 ```
-/p:cleanup [target] [--type code|imports|files|deps|memory|all] [--safe|--aggressive] [--dry-run]
+/p:cleanup [--type code|imports|files|deps|all] [--dry-run]
 ```
 
-## Global Architecture
-
-This command operates on global data stored in `~/.prjct-cli/projects/{project-id}/`.
-
-### Steps
+## Flow
+1. Parse: type + mode
+2. Backup: create if needed
+3. Execute: cleanup by type
+4. Validate: syntax check
+5. Log: `memory/cleanup-log.jsonl`
 
-1. Read `.prjct/prjct.config.json` for project ID and author
-2. Parse cleanup arguments (target, type, mode)
-3. Create backup to `~/.prjct-cli/projects/{id}/backups/{timestamp}/` before aggressive cleanup
-4. Execute cleanup by type:
-   - **code**: Remove console.logs, commented code, dead code
-   - **imports**: Remove unused imports, organize imports
-   - **files**: Remove temp files, empty files, backups
-   - **deps**: Analyze and remove unused npm dependencies
-   - **memory**: Archive old memory entries (>30 days) to `~/.prjct-cli/projects/{id}/memory/archive/`
-   - **all**: All cleanup types
-5. Validate syntax after changes (JavaScript/TypeScript)
-6. Log all changes to `~/.prjct-cli/projects/{id}/memory/cleanup-log.jsonl`
-7. Log action with author to context.jsonl
-8. Display cleanup results with metrics
-
-## Response Format
+## Types
+- **code**: Remove console.logs, commented code, dead code
+- **imports**: Remove unused, organize imports
+- **files**: Remove temp files, empty files
+- **deps**: Analyze unused dependencies
+- **all**: All cleanup types
 
+## Response
 ```
-🧹 ✨ Cleanup Complete! ✨ 🧹
-
-📊 Cleanup Results:
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-🗑️ Dead Code Removed:
-• Console.logs: {count} statements
-• Commented code: {count} blocks
-• Unused functions: {count}
+🧹 Cleanup complete!
 
-📦 Imports Optimized:
-• Unused imports: {count} removed
-• Files organized: {count}
+📊 Results:
+• Console.logs: {N} removed
+• Dead code: {N} blocks
+• Unused imports: {N}
+• Space freed: {X} MB
 
-📁 Files Cleaned:
-• Temp files: {count} removed
-• Empty files: {count} removed
-• Space freed: {size} MB
-
-📚 Dependencies:
-• Unused packages: {count} removed
-• Size reduced: {size} MB
-
-📦 Archived:
-• Memory entries: {count} (older than 30 days)
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-✨ Your project is clean and optimized!
-
-💡 Tip: Run with --dry-run first to preview changes
+/p:test | /p:ship
 ```
 
-## Safety Measures
-
-- Create backup before aggressive cleanup
-- Log all changes to cleanup-log.jsonl
-- Validate syntax after modifications
-- Skip files with uncommitted git changes
-- Provide --dry-run option to preview
-
-## Examples
-
-Basic cleanup:
-```
-/p:cleanup
-```
-
-Cleanup specific type:
-```
-/p:cleanup --type code
-/p:cleanup --type imports
-/p:cleanup --type deps
-```
-
-Preview changes:
-```
-/p:cleanup --dry-run
-```
-
-Aggressive cleanup with backup:
-```
-/p:cleanup --aggressive --type all
-```