prjct-cli 0.5.1 → 0.7.0

package/templates/analysis/analyze.md

@@ -0,0 +1,84 @@
+---
+allowed-tools: [Read, Bash]
+description: 'Analyze codebase and generate comprehensive summary'
+---
+
+# /p:analyze
+
+## Instructions for Claude
+
+You are analyzing a codebase to generate a comprehensive summary. **NO predetermined patterns** - analyze based on what you actually find.
+
+## Your Task
+
+1. **Read project files** using the analyzer helpers:
+   - package.json, Cargo.toml, go.mod, requirements.txt, etc.
+   - Directory structure
+   - Git history and stats
+   - Key source files
+
+2. **Understand the stack** - DON'T use predetermined lists:
+   - What language(s) are used?
+   - What frameworks are used?
+   - What tools and libraries are important?
+   - What's the architecture?
+
+3. **Identify features** - based on actual code, not assumptions:
+   - What has been built?
+   - What's the current state?
+   - What patterns do you see?
+
+4. **Generate agents** - create specialists for THIS project:
+   - Read the stack you identified
+   - Create agents for each major technology
+   - Use descriptive names (e.g., 'express-backend', 'react-frontend', 'postgres-db')
+   - Include specific versions and tools found
+
+## Guidelines
+
+- **No assumptions** - only report what you find
+- **No predefined maps** - don't assume express = "REST API server"
+- **Read and understand** - look at actual code structure
+- **Any stack works** - Elixir, Rust, Go, Python, Ruby, whatever exists
+- **Be specific** - include versions, specific tools, actual patterns
+
+## Output Format
+
+Generate `analysis/repo-summary.md` with:
+
+```markdown
+# Project Analysis
+
+## Stack
+
+[What you found - languages, frameworks, tools with versions]
+
+## Architecture
+
+[How it's organized - based on actual structure]
+
+## Features
+
+[What has been built - based on code and git history]
+
+## Statistics
+
+- Total files: [count]
+- Contributors: [count]
+- Age: [age]
+- Last activity: [date]
+
+## Recommendations
+
+[What agents to generate, what's next, etc.]
+```
+
+## After Analysis
+
+1. Save summary to `analysis/repo-summary.md`
+2. Generate agents using `generator.generateDynamicAgent()`
+3. Report what was found
+
+---
+
+**Remember**: You decide EVERYTHING based on analysis. No if/else, no predetermined patterns.

package/templates/commands/analyze.md

@@ -1,259 +1,63 @@
 ---
 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.
+## 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
 
-# /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]
+```markdown
+# Repository Analysis
 
-   ## Recommendations
-   - [Suggestions for improvements]
-   - [Best practices to consider]
+## Overview
 
-   **Generated**: [timestamp]
-   ```
+- Type: {type}
+- Language: {lang}
+- Framework: {framework}
 
-6. **Save analysis**:
-   Write the complete analysis to `.prjct/analysis/repo-summary.md`
+## Git Status
 
-7. **Provide summary**:
-   Display key findings and next suggested actions
+- Last commit: {hash} "{msg}" ({time_ago})
+- Status: {clean/has_changes}
 
-## Example Workflow
+## Stack
 
-```bash
-# Run analysis
-/p:analyze
+- Languages: {list}
+- Frameworks: {list}
+- Dependencies: {count}
 
-# Results saved to:
-# .prjct/analysis/repo-summary.md
+## Architecture
 
-# Example output:
-🔍 **Repository Analysis Complete**
+- Pattern: {pattern}
+- Entry points: {files}
 
-**Project**: prjct-cli (CLI Tool)
-**Language**: JavaScript (Node.js)
-**Structure**: 45 files across 8 directories
-**Dependencies**: 12 packages detected
+## Recommended Agents
 
-📄 **Full report**: `.prjct/analysis/repo-summary.md`
+Base (6): PM, UX, FE, BE, QA, Scribe
+Additional: {conditional_agents}
 
-**Next steps**:
-- `/p:roadmap` - Plan development roadmap
-- `/p:now "implement feature X"` - Set current focus
+Generated: {timestamp}
 ```
 
-## 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
+## Response
 
-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
-
-```markdown
-# Repository Analysis Report
-
-**Generated**: [timestamp]
-**Project**: [name]
-
-## Project Overview
-- **Type**: [Web app, CLI tool, Library, etc.]
-- **Primary Language**: [JavaScript, Python, Go, etc.]
-- **Framework**: [React, Express, FastAPI, etc.]
-
-## Git Status
-- **Repository**: [Yes/No]
-- **Last Commit**: [hash] "[message]" ([time ago])
-- **Author**: [name]
-- **Total Commits**: [count]
-- **Contributors**: [list]
-- **Current Branch**: [branch name]
-
-## 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
-
-## Architecture
-- **Pattern**: [MVC, Feature-based, Microservices, etc.]
-- **Structure**: [description of directory organization]
-- **Entry Points**: [main files]
-- **Key Directories**: [list]
-
-## Recommended Agents
-✅ **Base Agents** (6): PM, UX, FE, BE, QA, Scribe
-✅ **Additional Agents**: [List conditional agents with reason]
+```
+🔍 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/bug.md

@@ -0,0 +1,79 @@
+---
+allowed-tools: [Read, Write]
+description: 'Report and track bugs with auto-prioritization'
+---
+
+# /p:bug
+
+## Usage
+
+```
+/p:bug "<description>"
+```
+
+## What It Does
+
+1. **Severity detection**: Analyzes bug description for severity indicators
+2. **Priority placement**: Adds to `core/next.md` based on severity
+3. **Memory tracking**: Logs bug report to `memory/context.jsonl`
+4. **Quick resolution**: Suggests immediate actions
+
+## Severity Detection
+
+Auto-detects severity from keywords:
+
+- **Critical**: crash, down, broken, not working, production, urgent
+- **High**: error, fail, issue, problem, major
+- **Medium**: bug, incorrect, wrong, should
+- **Low**: minor, small, cosmetic, typo
+
+## Flow
+
+1. Detect severity from description
+2. Read `core/next.md`
+3. Format bug entry: `🐛 [SEVERITY] description`
+4. Insert at top if critical/high, bottom if medium/low
+5. Write to `core/next.md`
+6. Log to `memory/context.jsonl`
+
+## Response Format
+
+```
+🐛 Bug reported: {severity}
+
+{description}
+
+Priority: {critical/high/medium/low}
+Added to: core/next.md (position {top/bottom})
+
+Quick actions:
+• "start fixing" → /p:now "{description}"
+• "show queue" → /p:next
+
+/p:now | /p:next
+```
+
+## Example
+
+```
+User: p. bug "login button crashes on mobile"
+
+Claude detects:
+- Keywords: "crashes" → CRITICAL severity
+- Action: Add to top of next.md
+- Format: 🐛 [CRITICAL] login button crashes on mobile
+
+Response:
+🐛 Bug reported: CRITICAL
+
+login button crashes on mobile
+
+Priority: critical
+Added to: core/next.md (top priority)
+
+Quick actions:
+• "start fixing" → /p:now "login button crashes on mobile"
+• "show queue" → /p:next
+
+/p:now | /p:next
+```

package/templates/commands/build.md

@@ -0,0 +1,44 @@
+---
+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,42 @@
 ---
-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
-
-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
-
-```
-🧹 ✨ Cleanup Complete! ✨ 🧹
-
-📊 Cleanup Results:
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-🗑️ Dead Code Removed:
-• Console.logs: {count} statements
-• Commented code: {count} blocks
-• Unused functions: {count}
-
-📦 Imports Optimized:
-• Unused imports: {count} removed
-• Files organized: {count}
-
-📁 Files Cleaned:
-• Temp files: {count} removed
-• Empty files: {count} removed
-• Space freed: {size} MB
+## Flow
 
-📚 Dependencies:
-• Unused packages: {count} removed
-• Size reduced: {size} MB
+1. Parse: type + mode
+2. Backup: create if needed
+3. Execute: cleanup by type
+4. Validate: syntax check
+5. Log: `memory/cleanup-log.jsonl`
 
-📦 Archived:
-• Memory entries: {count} (older than 30 days)
+## Types
 
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-✨ Your project is clean and optimized!
+- **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
 
-💡 Tip: Run with --dry-run first to preview changes
-```
-
-## 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
+## Response
 
-## Examples
-
-Basic cleanup:
-```
-/p:cleanup
 ```
+🧹 Cleanup complete!
 
-Cleanup specific type:
-```
-/p:cleanup --type code
-/p:cleanup --type imports
-/p:cleanup --type deps
-```
+📊 Results:
+• Console.logs: {N} removed
+• Dead code: {N} blocks
+• Unused imports: {N}
+• Space freed: {X} MB
 
-Preview changes:
-```
-/p:cleanup --dry-run
-```
-
-Aggressive cleanup with backup:
-```
-/p:cleanup --aggressive --type all
+/p:test | /p:ship
 ```