prjct-cli 0.10.9 → 0.10.11

package/templates/commands/ship.md

@@ -1,35 +1,256 @@
 ---
-allowed-tools: [Read, Write, Bash, GetTimestamp, GetDate]
-description: 'Ship feature workflow'
-timestamp-rule: 'GetTimestamp() and GetDate() for timestamps'
-think-triggers: [git_decision, report_complete]
+allowed-tools: [Read, Write, Bash]
+description: 'Ship feature with automated workflow'
+timestamp-rule: 'GetTimestamp() and GetDate() for ALL timestamps'
 ---
 
-# /p:ship
+# /p:ship - Ship Feature Workflow
 
-## Think First
-Before shipping, verify:
-1. Are there uncommitted changes to include?
-2. What version bump is needed (patch/minor/major)?
-3. Is the feature actually complete?
-4. Should tests run first?
+## Context Variables
+- `{projectId}`: From `.prjct/prjct.config.json`
+- `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
+- `{shippedPath}`: `{globalPath}/progress/shipped.md`
+- `{memoryPath}`: `{globalPath}/memory/context.jsonl`
+- `{feature}`: User-provided feature name
 
-## Workflow (non-blocking)
-1. Lint → Tests → Docs update
-2. Version bump → CHANGELOG
-3. Commit + push (prjct footer)
-4. Log: `progress/sessions/{YY-MM}/{DD}.jsonl`
-5. Update: `progress/shipped.md` (30 days)
-6. Recommend: compact
+## Step 1: Read Config
 
-## Data
-Session: `{"ts":"{GetTimestamp()}","type":"feature_ship","name":"{f}","agent":"{a}","version":"{v}"}`
+READ: `.prjct/prjct.config.json`
+EXTRACT: `projectId`
 
-Commit footer:
+IF file not found:
+  OUTPUT: "No prjct project. Run /p:init first."
+  STOP
+
+## Step 2: Validate Prerequisites
+
+BASH: `git status --porcelain`
+
+IF output empty (no changes):
+  OUTPUT: "⚠️ No changes to ship. Make some commits first."
+  STOP
+
+BASH: `git rev-parse --is-inside-work-tree`
+
+IF not a git repo:
+  OUTPUT: "⚠️ Not a git repository. Initialize git first."
+  STOP
+
+## Step 3: Quality Checks (Non-Blocking)
+
+### Lint Check
+BASH: `npm run lint 2>&1 || echo "LINT_SKIP"`
+
+CAPTURE output as {lintResult}
+
+IF contains "LINT_SKIP" OR contains "missing script":
+  {lintStatus} = "skipped"
+ELSE IF contains "error":
+  {lintStatus} = "warnings"
+ELSE:
+  {lintStatus} = "passed"
+
+### Test Check
+BASH: `npm test 2>&1 || echo "TEST_SKIP"`
+
+CAPTURE output as {testResult}
+
+IF contains "TEST_SKIP" OR contains "missing script":
+  {testStatus} = "skipped"
+ELSE IF contains "failed" OR contains "FAIL":
+  {testStatus} = "failed"
+ELSE:
+  {testStatus} = "passed"
+
+**Note**: These are NON-BLOCKING. Continue even if they fail.
+
+## Step 4: Version Bump
+
+READ: `package.json`
+EXTRACT: current version as {currentVersion}
+
+### Determine Bump Type
+
+BASH: `git log --oneline -10`
+
+ANALYZE commit messages:
+
+IF any commit contains "BREAKING" OR "major:":
+  {bumpType} = "major"
+  {newVersion} = increment X in X.Y.Z, set Y=0, Z=0
+
+ELSE IF any commit contains "feat:" OR "feature:":
+  {bumpType} = "minor"
+  {newVersion} = increment Y in X.Y.Z, set Z=0
+
+ELSE:
+  {bumpType} = "patch"
+  {newVersion} = increment Z in X.Y.Z
+
+### Update package.json
+
+READ: `package.json`
+REPLACE: `"version": "{currentVersion}"` with `"version": "{newVersion}"`
+WRITE: `package.json`
+
+## Step 5: Update CHANGELOG
+
+READ: `CHANGELOG.md` (create if not exists)
+
+### Format New Entry
+
+```markdown
+## [{newVersion}] - {GetDate()}
+
+### {feature}
+- Shipped by prjct-cli
+- Lint: {lintStatus}
+- Tests: {testStatus}
 ```
+
+INSERT at top of file (after # Changelog header)
+
+WRITE: `CHANGELOG.md`
+
+## Step 6: Git Commit
+
+### Stage Changes
+BASH: `git add .`
+
+### Create Commit
+BASH: `git commit -m "$(cat <<'EOF'
+feat: Ship {feature}
+
+- Version: {newVersion}
+- Lint: {lintStatus}
+- Tests: {testStatus}
+
 🤖 Generated with [p/](https://www.prjct.app/)
 Designed for [Claude](https://www.anthropic.com/claude)
+EOF
+)"`
+
+## Step 7: Git Push
+
+BASH: `git push 2>&1`
+
+CAPTURE output as {pushResult}
+
+IF contains "rejected" OR contains "failed":
+  OUTPUT: "⚠️ Push failed. Try: git pull --rebase && git push"
+  CONTINUE (don't stop)
+
+IF contains "no upstream":
+  BASH: `git push -u origin HEAD`
+
+## Step 8: Log to Session
+
+GET: {date} = GetDate()
+EXTRACT: {yearMonth} = YYYY-MM from {date}
+
+ENSURE directory exists:
+BASH: `mkdir -p {globalPath}/progress/sessions/{yearMonth}`
+
+APPEND to: `{globalPath}/progress/sessions/{yearMonth}/{date}.jsonl`
+
+Single line (JSONL):
+```json
+{"ts":"{GetTimestamp()}","type":"feature_ship","name":"{feature}","version":"{newVersion}","lint":"{lintStatus}","tests":"{testStatus}"}
+```
+
+## Step 9: Update Shipped Index
+
+READ: `{shippedPath}` (create if not exists)
+
+### Format New Entry
+
+```markdown
+## {GetDate()} - {feature}
+- Version: {newVersion}
+- Lint: {lintStatus} | Tests: {testStatus}
+```
+
+INSERT at top (after # Shipped header)
+
+### Archive Old Entries
+IF file has entries older than 30 days:
+  MOVE old entries to: `{globalPath}/progress/archive/shipped-{yearMonth}.md`
+
+WRITE: `{shippedPath}`
+
+## Step 10: Log to Memory
+
+APPEND to: `{memoryPath}`
+
+Single line (JSONL):
+```json
+{"timestamp":"{GetTimestamp()}","action":"feature_shipped","feature":"{feature}","version":"{newVersion}"}
+```
+
+## Output
+
+SUCCESS:
+```
+🚀 Shipped: {feature}
+
+Version: {currentVersion} → {newVersion}
+Lint: {lintStatus}
+Tests: {testStatus}
+Commit: {commitHash}
+
+Next:
+• /p:feature - Plan next feature
+• /p:recap - See progress
+• compact - Clean up conversation
+```
+
+## Error Handling
+
+| Error | Response | Action |
+|-------|----------|--------|
+| No git repo | "Not a git repository" | STOP |
+| No changes | "No changes to ship" | STOP |
+| Lint fails | Show warning | CONTINUE |
+| Tests fail | Show warning | CONTINUE |
+| Push fails | Show fix command | CONTINUE |
+| No package.json | Skip version bump | CONTINUE |
+
+## Examples
+
+### Example 1: Full Success
+```
+🚀 Shipped: user authentication
+
+Version: 1.2.0 → 1.3.0
+Lint: passed
+Tests: passed
+Commit: abc1234
+
+Next: /p:feature | /p:recap | compact
 ```
 
-## Response
-`🚀 {feature} | {agent} | {time} | v{version} | Next: compact`
+### Example 2: With Warnings
+```
+🚀 Shipped: bug fixes
+
+Version: 1.2.0 → 1.2.1
+Lint: warnings (non-blocking)
+Tests: skipped
+Commit: def5678
+
+⚠️ Consider fixing lint warnings
+
+Next: /p:feature | /p:recap | compact
+```
+
+### Example 3: No Tests/Lint
+```
+🚀 Shipped: documentation update
+
+Version: 1.2.0 → 1.2.1
+Lint: skipped (no script)
+Tests: skipped (no script)
+Commit: ghi9012
+
+Next: /p:feature | /p:recap | compact
+```

package/templates/commands/sync.md

@@ -1,71 +1,262 @@
 ---
-allowed-tools: [Read, Write, Bash, Glob, Grep, TodoWrite]
+allowed-tools: [Read, Write, Bash, Glob, Grep]
 description: 'Sync state + generate agents + detect patterns'
+timestamp-rule: 'GetTimestamp() for all timestamps'
 ---
 
-# /p:sync
+# /p:sync - Sync Project State
 
-## Flow
+## Context Variables
+- `{projectId}`: From `.prjct/prjct.config.json`
+- `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
+- `{analysisPath}`: `{globalPath}/analysis`
+- `{agentsPath}`: `{globalPath}/agents`
+- `{memoryPath}`: `{globalPath}/memory/context.jsonl`
 
-1. Execute `/p:analyze` → generates `analysis/repo-summary.md`
-2. Execute pattern analysis → generates `analysis/patterns.md`
-3. Read both analysis files
-4. Generate agents per technology → `agents/`
-5. Update `CLAUDE.md` with patterns summary
-6. Log to memory
+## Step 1: Read Config
 
-## Pattern Analysis (Step 2)
+READ: `.prjct/prjct.config.json`
+EXTRACT: `projectId`
 
-Read `templates/analysis/patterns.md` and execute:
+IF file not found:
+  OUTPUT: "No prjct project. Run /p:init first."
+  STOP
 
-1. **Sample 5-10 source files** across different directories
-2. **Detect design patterns**: SOLID, DRY, factories, etc.
-3. **Extract conventions**: naming, style, structure
-4. **Flag anti-patterns**: god classes, duplication, mixed concerns
-5. **Generate recommendations**: immediate fixes + best practices
+## Step 2: Analyze Repository
 
-### Key Files to Analyze
+### Detect Stack
+GLOB: `**/*.{js,ts,jsx,tsx,py,rb,go,rs,java}`
+GLOB: `**/package.json`, `**/Cargo.toml`, `**/go.mod`, `**/requirements.txt`
+
+EXTRACT:
+- {languages}: List of languages found
+- {frameworks}: Detected frameworks (React, Express, Django, etc.)
+- {packageManager}: npm, yarn, pnpm, pip, cargo, etc.
+
+### Analyze File Structure
+BASH: `find . -type f -name "*.{ext}" | head -50`
+
+DETERMINE:
+- {sourceDir}: Main source directory (src/, lib/, app/)
+- {testDir}: Test directory (test/, tests/, __tests__/)
+- {configFiles}: Config files found
+
+### Generate repo-summary.md
+
+WRITE: `{analysisPath}/repo-summary.md`
+
+```markdown
+# Repository Summary
+
+> Generated: {GetTimestamp()}
+
+## Stack
+- Languages: {languages}
+- Frameworks: {frameworks}
+- Package Manager: {packageManager}
+
+## Structure
+- Source: {sourceDir}
+- Tests: {testDir}
+- Entry: {entryPoint}
+
+## Files
+- Total: {fileCount}
+- Source: {sourceCount}
+- Tests: {testCount}
 ```
-- Main entry point (bin/, src/index, main)
-- Largest source files (potential god classes)
-- Utility/helper directories (DRY evidence)
-- Test files (testing patterns)
-- Config files (tooling conventions)
+
+## Step 3: Pattern Analysis
+
+### Sample Files
+READ 5-10 representative source files:
+- Main entry point
+- Largest files (potential complexity)
+- Utility/helper files
+- Test files
+- Config files
+
+### Detect Patterns
+
+Analyze for:
+1. **SOLID Principles**: Evidence of each
+2. **DRY**: Shared utilities, constants
+3. **Design Patterns**: Factory, singleton, observer, repository
+4. **Code Style**: Naming, formatting, imports
+
+### Detect Anti-Patterns
+
+Flag:
+- God classes (files > 300 lines)
+- Deep nesting (> 4 levels)
+- Code duplication
+- Magic numbers
+- Mixed concerns
+
+### Generate patterns.md
+
+WRITE: `{analysisPath}/patterns.md`
+
+```markdown
+# Code Patterns - {project}
+
+> Generated: {GetTimestamp()}
+
+## Patterns Detected
+- {pattern}: {where} - {example}
+
+## Conventions (MUST FOLLOW)
+- Functions: {convention}
+- Classes: {convention}
+- Files: {convention}
+- Async: {pattern}
+
+## Anti-Patterns ⚠️
+1. **{issue}**: {file:line} - Fix: {action}
+
+## Recommendations
+1. {action}
 ```
 
-### Output
-Save to `analysis/patterns.md` with:
-- Detected patterns (what to follow)
-- Conventions (MUST match in new code)
-- Anti-patterns found (with fixes)
-- Recommendations (for quality)
+## Step 4: Generate Agents
+
+Based on detected stack, generate specialized agents:
+
+### Agent Generation Rules
 
-## Agent Generation (Step 4)
+IF {languages} includes JavaScript/TypeScript:
+  IF React/Vue/Angular detected:
+    GENERATE: `agents/fe.md` (Frontend Specialist)
+  IF Express/Fastify/Nest detected:
+    GENERATE: `agents/be.md` (Backend Specialist)
 
-Use: `generateDynamicAgent(name, config)`
+IF {languages} includes Python:
+  GENERATE: `agents/py.md` (Python Specialist)
 
-## CLAUDE.md Update (Step 5)
+IF tests detected:
+  GENERATE: `agents/qa.md` (Quality Specialist)
+
+ALWAYS GENERATE:
+  - `agents/coordinator.md` (Orchestration)
+
+### Agent Template
+
+For each agent, WRITE to `{agentsPath}/{name}.md`:
 
-Add patterns summary section:
 ```markdown
-## Code Patterns
+# {Name} Agent
+
+## Role
+{Specialized role description}
 
-**Follow these patterns in ALL new code:**
-- {key conventions from patterns.md}
-- {design patterns to apply}
+## Skills
+- {skill1}
+- {skill2}
 
-**Avoid these anti-patterns:**
-- {detected anti-patterns}
+## Patterns to Follow
+{From patterns.md}
+
+## Files I Own
+{Directories/patterns this agent handles}
+```
+
+## Step 5: Update Project CLAUDE.md
+
+READ: `{globalPath}/CLAUDE.md`
+
+IF exists:
+  ### Add Patterns Summary
+
+  INSERT section:
+  ```markdown
+  ## Code Patterns
+
+  **Follow in ALL new code:**
+  - {key conventions}
+  - {design patterns}
+
+  **Avoid:**
+  - {anti-patterns}
+  ```
+
+  WRITE: `{globalPath}/CLAUDE.md`
+
+## Step 6: Log to Memory
+
+APPEND to: `{memoryPath}`
+
+Single line (JSONL):
+```json
+{"timestamp":"{GetTimestamp()}","action":"sync","stack":"{languages}","agents":{agentCount},"patterns":{patternCount}}
+```
+
+## Output
+
+SUCCESS:
+```
+🔄 Synced
+
+Stack:
+├── Languages: {languages}
+├── Frameworks: {frameworks}
+└── Package Manager: {packageManager}
+
+Generated:
+├── Agents: {agentCount}
+├── Patterns: {patternCount} detected
+└── Anti-patterns: {antiPatternCount} flagged
+
+Files:
+├── analysis/repo-summary.md
+├── analysis/patterns.md
+└── agents/*.md
+
+Next:
+• /p:feature - Start building
+• /p:context - See full context
+• /p:now - Set current task
+```
+
+## Error Handling
+
+| Error | Response | Action |
+|-------|----------|--------|
+| No config | "No prjct project" | STOP |
+| No source files | "Empty project" | WARN, continue |
+| Write fails | Log warning | CONTINUE |
+
+## Examples
+
+### Example 1: Node.js Project
 ```
+🔄 Synced
+
+Stack:
+├── Languages: JavaScript, TypeScript
+├── Frameworks: Express, React
+└── Package Manager: npm
 
-## Response
+Generated:
+├── Agents: 4 (coordinator, fe, be, qa)
+├── Patterns: 8 detected
+└── Anti-patterns: 2 flagged
 
+Next: /p:feature | /p:context
+```
+
+### Example 2: Python Project
 ```
 🔄 Synced
-├── Stack: {languages/frameworks}
-├── Agents: {count} generated
-├── Patterns: {count} detected
-└── Anti-patterns: {count} flagged
 
-Next: /p:context or /p:now
+Stack:
+├── Languages: Python
+├── Frameworks: Django
+└── Package Manager: pip
+
+Generated:
+├── Agents: 3 (coordinator, py, qa)
+├── Patterns: 5 detected
+└── Anti-patterns: 1 flagged
+
+Next: /p:feature | /p:context
 ```

package/templates/design/api.md

@@ -0,0 +1,95 @@
+---
+name: api-design
+description: Design API endpoints and contracts
+allowed-tools: [Read, Glob, Grep]
+---
+
+# API Design
+
+Design RESTful API endpoints for the given feature.
+
+## Input
+- Target: {{target}}
+- Requirements: {{requirements}}
+
+## Analysis Steps
+
+1. **Identify Resources**
+   - What entities are involved?
+   - What operations are needed?
+   - What relationships exist?
+
+2. **Review Existing APIs**
+   - Read existing route files
+   - Match naming conventions
+   - Use consistent patterns
+
+3. **Design Endpoints**
+   - RESTful resource naming
+   - Appropriate HTTP methods
+   - Request/response shapes
+
+4. **Define Validation**
+   - Input validation rules
+   - Error responses
+   - Edge cases
+
+## Output Format
+
+```markdown
+# API Design: {target}
+
+## Endpoints
+
+### GET /api/{resource}
+**Description**: List all resources
+
+**Query Parameters**:
+- `limit`: number (default: 20)
+- `offset`: number (default: 0)
+
+**Response** (200):
+```json
+{
+  "data": [...],
+  "total": 100,
+  "limit": 20,
+  "offset": 0
+}
+```
+
+### POST /api/{resource}
+**Description**: Create resource
+
+**Request Body**:
+```json
+{
+  "field": "value"
+}
+```
+
+**Response** (201):
+```json
+{
+  "id": "...",
+  "field": "value"
+}
+```
+
+**Errors**:
+- 400: Invalid input
+- 401: Unauthorized
+- 409: Conflict
+
+## Authentication
+- Method: Bearer token / API key
+- Required for: POST, PUT, DELETE
+
+## Rate Limiting
+- 100 requests/minute per user
+```
+
+## Guidelines
+- Follow REST conventions
+- Use consistent error format
+- Document all parameters