prjct-cli 0.18.2 → 0.20.0

package/templates/commands/ship.md

@@ -1,277 +1,175 @@
 ---
-allowed-tools: [Read, Write, Bash]
+allowed-tools: [Read, Write, Bash, Glob, Grep]
 description: 'Ship feature with automated workflow'
-timestamp-rule: 'GetTimestamp() and GetDate() for ALL timestamps'
-architecture: 'Write-Through (JSON → MD → Events)'
-storage-layer: true
-source-of-truth: 'storage/shipped.json'
-claude-context: 'context/shipped.md'
-backend-sync: 'sync/pending.json'
 ---
 
-# /p:ship - Ship Feature Workflow
+# /p:ship - Ship Feature
 
-## Architecture: Write-Through Pattern
+Ship completed work with pre-flight checks, code review, and quality gates.
 
+## Usage
 ```
-User Action → Storage (JSON) → Context (MD) → Sync Events
+/p:ship [feature] [--blocking] [--skip-review]
 ```
+- `feature`: Name of the feature being shipped (required)
+- `--blocking`: Abort if any check fails
+- `--skip-review`: Skip code review (for trivial changes)
 
-**Source of Truth**: `storage/shipped.json`
-**Claude Context**: `context/shipped.md` (generated)
-**Backend Sync**: `sync/pending.json` (events)
+## Flow
 
-## Context Variables
-- `{projectId}`: From `.prjct/prjct.config.json`
-- `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
-- `{shippedStoragePath}`: `{globalPath}/storage/shipped.json`
-- `{shippedContextPath}`: `{globalPath}/context/shipped.md`
-- `{syncPath}`: `{globalPath}/sync/pending.json`
-- `{memoryPath}`: `{globalPath}/memory/events.jsonl`
-- `{snapshotDir}`: `{globalPath}/snapshots`
-- `{feature}`: User-provided feature name
-- `{outcome}`: User-provided outcome status (optional)
+### Step 1: Validate Project
+READ: `.prjct/prjct.config.json` → extract `projectId`
+IF missing: "No prjct project. Run /p:init first." → STOP
 
-## Outcome Categories
+SET: `{globalPath}` = `~/.prjct-cli/projects/{projectId}`
 
-Track what happened after shipping:
-
-| Outcome | Meaning | Use When |
-|---------|---------|----------|
-| `validated` | Confirmed working in production | Feature verified by users/tests |
-| `monitoring` | Deployed, needs observation | Just shipped, watching metrics |
-| `known-issues` | Working with caveats | Minor issues known, acceptable |
-
-If no outcome provided, default to `monitoring`.
-
-## Step 1: Read Config
-
-READ: `.prjct/prjct.config.json`
-EXTRACT: `projectId`
-
-IF file not found:
-  OUTPUT: "No prjct project. Run /p:init first."
-  STOP
-
-## Step 2: Validate Prerequisites
+### Step 2: Pre-flight Checks
 
+#### 2.1 Check for changes
 BASH: `git status --porcelain`
+IF empty: "No changes to ship." → STOP
+
+#### 2.2 Analyze change scope
+BASH: `git diff --stat HEAD`
+EXTRACT: {filesChanged}, {insertions}, {deletions}
+SET: {totalLines} = {insertions} + {deletions}
+
+#### 2.3 Detect trivial changes
+IF {totalLines} < 10 AND {filesChanged} <= 2:
+  SET: {changeType} = "trivial"
+  OUTPUT: "Trivial changes detected ({totalLines} lines in {filesChanged} files)"
+ELSE IF {totalLines} < 50:
+  SET: {changeType} = "small"
+ELSE IF {totalLines} < 200:
+  SET: {changeType} = "medium"
+ELSE:
+  SET: {changeType} = "large"
+  OUTPUT: "Large change detected ({totalLines} lines). Full review recommended."
 
-IF output empty (no changes):
-  OUTPUT: "⚠️ No changes to ship. Make some commits first."
-  STOP
-
-BASH: `git rev-parse --is-inside-work-tree`
+### Step 3: Quality Checks
+BASH: `npm run lint 2>&1 || echo "LINT_SKIP"`
+BASH: `npm test 2>&1 || echo "TEST_SKIP"`
 
-IF not a git repo:
-  OUTPUT: "⚠️ Not a git repository. Initialize git first."
+IF `--blocking` AND (lint failed OR tests failed):
+  OUTPUT: "Quality checks failed. Ship blocked."
   STOP
 
-## Step 3: Quality Checks (Non-Blocking)
+### Step 4: Code Review with Confidence Scoring
 
-### 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"
+IF `--skip-review` OR {changeType} == "trivial":
+  OUTPUT: "Skipping code review."
+  → Go to Step 5
 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"
+  OUTPUT: "Running code review..."
+
+#### 4.1 Get changed files
+BASH: `git diff --name-only HEAD`
+SET: {changedFiles} = result
+
+#### 4.2 Review each file for issues
+FOR each file in {changedFiles}:
+  BASH: `git diff HEAD -- {file}`
+
+  Analyze diff for:
+  - Missing error handling
+  - Security issues (hardcoded secrets, SQL injection, XSS)
+  - Logic errors
+  - Missing null checks
+  - Resource leaks
+
+  FOR each issue found:
+    ASSIGN confidence score (0-100):
+    - 90-100: Definite bug/security issue
+    - 70-89: Likely problem, should fix
+    - 50-69: Maybe a problem
+    - 0-49: Nitpick/style preference
+
+#### 4.3 Filter and report
+SET: {issues} = issues with confidence >= 70
+
+IF {issues}.length > 0:
+  OUTPUT: """
+  ## Code Review Results
+
+  Found {issues.length} issues (confidence >= 70%):
+
+  {FOR each issue:}
+  - [{confidence}%] {description}
+    File: {file}:{line}
+  {END FOR}
+  """
+
+  IF `--blocking`:
+    OUTPUT: "Fix issues before shipping."
+    STOP
+  ELSE:
+    PROMPT: "Continue with ship? (y/n)"
+    IF no: STOP
 ELSE:
-  {testStatus} = "passed"
-
-**Note**: These are NON-BLOCKING. Continue even if they fail.
-
-## Step 4: Version Bump (MANDATORY)
-
-### Read Current Version
-Detect project type and read version:
+  OUTPUT: "Code review passed. No high-confidence issues found."
 
-| File | Language | Version Location |
-|------|----------|------------------|
-| `package.json` | Node.js | `"version": "X.Y.Z"` |
-| `Cargo.toml` | Rust | `version = "X.Y.Z"` |
-| `pyproject.toml` | Python | `version = "X.Y.Z"` |
-| `VERSION` | Any | Plain text `X.Y.Z` |
+### Step 5: Version Bump
+READ: `package.json` (or Cargo.toml, pyproject.toml)
+EXTRACT: current version
 
-### Determine Bump Type
 BASH: `git log --oneline -10`
+Determine bump type:
+- "BREAKING" or "major:" → major
+- "feat:" or "feature:" → minor
+- else → patch
 
-IF any commit contains "BREAKING" OR "major:":
-  {bumpType} = "major"
-ELSE IF any commit contains "feat:" OR "feature:":
-  {bumpType} = "minor"
-ELSE:
-  {bumpType} = "patch"
-
-### Update Version File
-Update the version file with {newVersion}
-
-## Step 5: Update CHANGELOG (MANDATORY)
+UPDATE version file with new version
 
-### Get Recent Commits
+### Step 6: Update CHANGELOG
 BASH: `git log --oneline -20 --pretty=format:"- %s"`
-CAPTURE as {commitList}
-
-### Create/Update CHANGELOG.md
-INSERT new entry after header.
-
-## Step 6: Git Commit
+INSERT new entry in CHANGELOG.md
 
+### Step 7: Git Commit & Push
 BASH: `git add .`
-
-BASH: `git commit -m "$(cat <<'EOF'
-feat: Ship {feature} v{newVersion}
+BASH: `git commit -m "feat: Ship {feature} v{newVersion}
 
 🤖 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`
-
-IF contains "rejected" OR contains "failed":
-  OUTPUT: "⚠️ Push failed. Try: git pull --rebase && git push"
-  CONTINUE
-
-## Step 8: Update Storage (SOURCE OF TRUTH)
+"`
+BASH: `git push`
 
-SET: {now} = GetTimestamp()
-GENERATE: {shipId} = UUID v4
+### Step 8: Update Storage
+GET timestamp: `bun -e "console.log(new Date().toISOString())" 2>/dev/null || node -e "console.log(new Date().toISOString())"`
+GET uuid: `bun -e "console.log(crypto.randomUUID())" 2>/dev/null || node -e "console.log(require('crypto').randomUUID())"`
 
-### Read existing shipped
-READ: `{shippedStoragePath}` or create default:
+READ: `{globalPath}/storage/shipped.json` (or create default)
+PREPEND new ship object:
 ```json
 {
-  "shipped": [],
-  "lastUpdated": null
-}
-```
-
-### Create ship object
-```json
-{
-  "id": "{shipId}",
+  "id": "{uuid}",
   "name": "{feature}",
   "version": "{newVersion}",
-  "outcome": "{outcome}",
-  "shippedAt": "{now}",
+  "shippedAt": "{timestamp}",
   "lint": "{lintStatus}",
-  "tests": "{testStatus}",
-  "commits": {commits}
+  "tests": "{testStatus}"
 }
 ```
+WRITE: `{globalPath}/storage/shipped.json`
 
-### Update shipped.json
-PREPEND new ship to shipped array
-SET: lastUpdated = {now}
-WRITE: `{shippedStoragePath}`
+Generate context:
+WRITE: `{globalPath}/context/shipped.md`
 
-## Step 9: Generate Context (FOR CLAUDE)
+Queue sync event:
+APPEND to `{globalPath}/sync/pending.json`
 
-WRITE: `{shippedContextPath}`
+Log to memory:
+APPEND to `{globalPath}/memory/events.jsonl`
 
-```markdown
-# SHIPPED 🚀
-
-## {Month Year}
-
-{FOR EACH ship in shipped WHERE month matches:}
-- **{ship.name}** v{ship.version} - {ship.shippedAt}
-{END FOR}
-
----
-
-**Total shipped:** {shipped.length}
-```
-
-## Step 10: Queue Sync Event (FOR BACKEND)
-
-READ: `{syncPath}` or create empty array
-APPEND event:
-```json
-{
-  "type": "feature.shipped",
-  "path": ["shipped"],
-  "data": {
-    "shipId": "{shipId}",
-    "name": "{feature}",
-    "version": "{newVersion}",
-    "outcome": "{outcome}",
-    "shippedAt": "{now}"
-  },
-  "timestamp": "{now}",
-  "projectId": "{projectId}"
-}
-```
-WRITE: `{syncPath}`
-
-## Step 11: Log to Daily Session
-
-GET: {date} = YYYY-MM-DD from {now}
-GET: {yearMonth} = YYYY-MM from {now}
-SET: {dailySessionPath} = `{globalPath}/progress/sessions/{yearMonth}/{date}.jsonl`
-
-BASH: `mkdir -p {globalPath}/progress/sessions/{yearMonth}`
-
-APPEND to: `{dailySessionPath}`
-```json
-{"ts":"{now}","type":"feature_ship","name":"{feature}","version":"{newVersion}"}
-```
-
-## Step 12: Log to Memory (AUDIT TRAIL)
-
-APPEND to: `{memoryPath}`
-```json
-{"timestamp":"{now}","action":"feature_shipped","shipId":"{shipId}","feature":"{feature}","version":"{newVersion}","outcome":"{outcome}"}
-```
-
-## Step 13: Update project.json
-
-SET: {projectJsonPath} = `{globalPath}/project.json`
-
-READ: `{projectJsonPath}`
-UPDATE:
-- `"version"`: Set to `{newVersion}`
-- `"hasUncommittedChanges"`: Set to `false`
-- `"lastSync"`: Set to `{now}`
-WRITE: `{projectJsonPath}`
-
-## Step 14: Run Deep Sync
-
-Execute `/p:sync` logic to update all context files.
-
-## Output
-
-SUCCESS:
+### Step 9: Output
 ```
 🚀 Shipped: {feature}
 
-Version: {currentVersion} → {newVersion}
-Outcome: {outcome}
-Lint: {lintStatus}
-Tests: {testStatus}
-Commit: {commitHash}
-
-🔄 Synced project data
+Version: {oldVersion} → {newVersion}
+Changes: {changeType} ({totalLines} lines in {filesChanged} files)
+Quality: Lint {lintStatus} | Tests {testStatus}
+Review: {reviewStatus}
 
-Next:
-• /p:undo - Revert this ship if needed
-• /p:feature - Plan next feature
-• /p:recap - See progress
+Next: /p:feature | /p:recap
 ```
 
 ## Error Handling
@@ -280,37 +178,60 @@ Next:
 |-------|----------|--------|
 | 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 |
-| Version bump fails | "Failed to update version" | STOP |
+| Lint/test fails (blocking) | "Quality checks failed" | STOP |
+| Lint/test fails (non-blocking) | Show warning | CONTINUE |
+| Code review finds issues (blocking) | "Fix issues before shipping" | STOP |
+| Code review finds issues (non-blocking) | Prompt to continue | ASK |
+| Push fails | "Push failed. Try: git pull --rebase" | CONTINUE |
 
 ## Examples
 
-### Example 1: Full Success
+### Example 1: Trivial Change (auto-skip review)
 ```
-🚀 Shipped: user authentication
+/p:ship "fix typo"
 
-Version: 1.2.0 → 1.3.0
-Outcome: validated
-Lint: passed
-Tests: passed
-Commit: abc1234
+Pre-flight: Trivial changes (3 lines in 1 file)
+Quality: Lint ✅ | Tests ✅
+Review: Skipped (trivial)
 
-Next: /p:feature | /p:recap
+🚀 Shipped: fix typo
+Version: 1.2.0 → 1.2.1
 ```
 
-### Example 2: With Warnings
+### Example 2: Medium Change (with review)
 ```
-🚀 Shipped: bug fixes
+/p:ship "add auth"
 
-Version: 1.2.0 → 1.2.1
-Outcome: monitoring
-Lint: warnings (non-blocking)
-Tests: skipped
-Commit: def5678
+Pre-flight: Medium changes (87 lines in 5 files)
+Quality: Lint ✅ | Tests ✅
+Review: Running...
 
-⚠️ Consider fixing lint warnings
+## Code Review Results
+Found 2 issues (confidence >= 70%):
+- [85%] Missing error handling in OAuth callback
+  File: src/auth/oauth.ts:67
+- [72%] Token not validated before use
+  File: src/auth/validate.ts:23
 
-Next: /p:feature | /p:recap
+Continue with ship? (y/n)
 ```
+
+### Example 3: Blocking Mode
+```
+/p:ship "deploy script" --blocking
+
+Pre-flight: Small changes (28 lines in 2 files)
+Quality: Lint ✅ | Tests ✅
+Review: Running...
+
+## Code Review Results
+Found 1 issue (confidence >= 70%):
+- [95%] Hardcoded credentials detected
+  File: scripts/deploy.sh:12
+
+Fix issues before shipping.
+```
+
+## References
+- Architecture details: `~/.prjct-cli/docs/architecture.md`
+- Validation patterns: `~/.prjct-cli/docs/validation.md`

package/templates/commands/sync.md

@@ -167,6 +167,42 @@ GLOB for config files and analyze:
 
 EXTRACT: `{languages}`, `{frameworks}`, `{techStack}`
 
+### Detect Frontend/UI Stack (for UX/UI Agent)
+
+**CRITICAL**: If ANY frontend technology is detected, generate the UX/UI agent.
+
+#### Web Frontend Detection
+```bash
+# Check package.json for web frameworks
+grep -E '"(react|react-dom|next|vue|nuxt|svelte|@sveltejs/kit|@angular/core)"' package.json 2>/dev/null
+```
+
+SET: `{hasWebFrontend}` = true if any match
+
+#### Mobile Frontend Detection
+```bash
+# React Native / Expo
+grep -E '"(react-native|expo)"' package.json 2>/dev/null
+
+# Flutter
+test -f pubspec.yaml && echo "flutter"
+
+# SwiftUI (iOS)
+find . -name "*.swift" -exec grep -l "import SwiftUI" {} \; 2>/dev/null | head -1
+
+# Jetpack Compose (Android)
+find . -name "*.kt" -exec grep -l "androidx.compose" {} \; 2>/dev/null | head -1
+```
+
+SET: `{hasMobileFrontend}` = true if any match
+
+#### Combined Frontend Flag
+```
+{hasFrontendUI} = {hasWebFrontend} OR {hasMobileFrontend}
+```
+
+EXTRACT: `{frontendType}` = "web" | "mobile" | "both" | null
+
 ---
 
 ## Step 4: Regenerate ALL Context Files
@@ -421,13 +457,32 @@ Analyze `{techStack}` from Step 3 and generate ONLY relevant domain agents:
 | PostgreSQL, MySQL, MongoDB, Prisma | `database.md` | `templates/subagents/domain/database.md` |
 | Docker, Kubernetes, GitHub Actions | `devops.md` | `templates/subagents/domain/devops.md` |
 | Jest, Pytest, Vitest, testing | `testing.md` | `templates/subagents/domain/testing.md` |
+| **{hasFrontendUI} = true** | `uxui.md` | `templates/agentic/agents/uxui.md` |
 
 For EACH detected stack:
 1. READ template from `templates/subagents/domain/{name}.md`
 2. ADAPT description with detected frameworks (e.g., "React specialist" not just "frontend")
 3. WRITE to `{globalPath}/agents/{name}.md`
 
-### 7.5 Report Generated Agents
+### 7.5 Generate UX/UI Agent (CRITICAL for Frontend Projects)
+
+**Priority: UX > UI** - User experience is more important than visuals.
+
+IF `{hasFrontendUI}` == true:
+
+1. READ template: `templates/agentic/agents/uxui.md`
+2. WRITE to: `{globalPath}/agents/uxui.md`
+3. ADD to `{domainAgents}`: "uxui"
+
+OUTPUT: "🎨 Generated UX/UI agent for {frontendType} ({frameworks detected})"
+
+The UX/UI agent ensures:
+- **UX First**: Clarity, feedback, reduced friction, error handling, accessibility
+- **Modern UI**: Distinctive typography, bold colors, purposeful animation
+- **Anti-patterns avoided**: No "AI slop" (Inter font, purple gradients, generic layouts)
+- **Checklists**: UX and UI quality gates before shipping
+
+### 7.6 Report Generated Agents
 
 Track which agents were generated for output:
 - `{workflowAgents}`: Always 3 (prjct-workflow, prjct-planner, prjct-shipper)
@@ -516,7 +571,10 @@ IF cloudSync AND no syncError:
 
 🤖 Claude Code Sub-Agents ({workflowAgents.length + domainAgents.length})
 ├── Workflow: prjct-workflow, prjct-planner, prjct-shipper
-└── Domain: {domainAgents.join(', ') || 'none'}
+├── Domain: {domainAgents.join(', ') || 'none'}
+{IF hasFrontendUI}
+└── 🎨 UX/UI: uxui.md (Priority: UX > UI)
+{ENDIF}
 
 {IF cloudSync}
 ☁️ Cloud Sync
@@ -581,5 +639,6 @@ Next: /p:now to start a new task
 ├── backend.md               # (if Node/Go/Python API detected)
 ├── database.md              # (if DB detected)
 ├── devops.md                # (if Docker/K8s detected)
-└── testing.md               # (if test framework detected)
+├── testing.md               # (if test framework detected)
+└── uxui.md                  # (if ANY frontend UI detected - web or mobile)
 ```