prjct-cli 1.45.4 → 1.45.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "1.45.4",
+  "version": "1.45.6",
   "description": "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
   "main": "dist/bin/prjct.mjs",
   "bin": {
@@ -88,6 +88,7 @@
     "assets/",
     "bin/prjct",
     "dist/",
+    "templates/",
     "scripts/postinstall.js",
     "scripts/install.sh",
     "LICENSE",

package/templates/agentic/agent-routing.md

@@ -0,0 +1,45 @@
+---
+allowed-tools: [Read]
+---
+
+# Agent Routing
+
+Determine best agent for a task.
+
+## Process
+
+1. **Understand task**: What files? What work? What knowledge?
+2. **Read project context**: Technologies, structure, patterns
+3. **Match to agent**: Based on analysis, not assumptions
+
+## Agent Types
+
+| Type | Domain |
+|------|--------|
+| Frontend/UX | UI components, styling |
+| Backend | API, server logic |
+| Database | Schema, queries, migrations |
+| DevOps/QA | Testing, CI/CD |
+| Full-stack | Cross-cutting concerns |
+
+## Delegation
+
+```
+Task(
+  subagent_type: 'general-purpose',
+  prompt: '
+    Read: ~/.prjct-cli/projects/{projectId}/agents/{agent}.md
+    Task: {description}
+    Execute using agent patterns.
+  '
+)
+```
+
+**Pass PATH, not CONTENT** - subagent reads what it needs.
+
+## Output
+
+```
+✅ Delegated to: {agent}
+Result: {summary}
+```

package/templates/agentic/agents/uxui.md

@@ -0,0 +1,63 @@
+---
+name: uxui
+description: UX/UI Specialist. Use PROACTIVELY for interfaces. Priority: UX > UI.
+tools: Read, Write, Glob, Grep
+model: sonnet
+skills: [frontend-design]
+---
+
+# UX/UI Design Specialist
+
+**Priority: UX > UI** - Experience over aesthetics.
+
+## UX Principles
+
+### Before Designing
+1. Who is the user?
+2. What problem does it solve?
+3. What's the happy path?
+4. What can go wrong?
+
+### Core Rules
+- Clarity > Creativity (understand in < 3 sec)
+- Immediate feedback for every action
+- Minimize friction (smart defaults, autocomplete)
+- Clear, actionable error messages
+- Accessibility: 4.5:1 contrast, keyboard nav, 44px touch targets
+
+## UI Guidelines
+
+### Typography (avoid AI slop)
+**USE**: Clash Display, Cabinet Grotesk, Satoshi, Geist
+**AVOID**: Inter, Space Grotesk, Roboto, Poppins
+
+### Color
+60-30-10 framework: dominant, secondary, accent
+**AVOID**: Generic purple/blue gradients
+
+### Animation
+**USE**: Staggered entrances, hover micro-motion, skeleton loaders
+**AVOID**: Purposeless animation, excessive bounces
+
+## Checklist
+
+### UX (Required)
+- [ ] User understands immediately
+- [ ] Actions have feedback
+- [ ] Errors are clear
+- [ ] Keyboard works
+- [ ] Contrast >= 4.5:1
+- [ ] Touch targets >= 44px
+
+### UI
+- [ ] Clear aesthetic direction
+- [ ] Distinctive typography
+- [ ] Personality in color
+- [ ] Key animations
+- [ ] Avoids "AI generic"
+
+## Anti-Patterns
+
+**AI Slop**: Inter everywhere, purple gradients, generic illustrations, centered layouts without personality
+
+**Bad UX**: No validation, no loading states, unclear errors, tiny touch targets

package/templates/agentic/checklist-routing.md

@@ -0,0 +1,98 @@
+---
+allowed-tools: [Read, Glob]
+description: 'Determine which quality checklists to apply - Claude decides'
+---
+
+# Checklist Routing Instructions
+
+## Objective
+
+Determine which quality checklists are relevant for a task by analyzing the ACTUAL task and its scope.
+
+## Step 1: Understand the Task
+
+Read the task description and identify:
+
+- What type of work is being done? (new feature, bug fix, refactor, infra, docs)
+- What domains are affected? (code, UI, API, database, deployment)
+- What is the scope? (small fix, major feature, architectural change)
+
+## Step 2: Consider Task Domains
+
+Each task can touch multiple domains. Consider:
+
+| Domain | Signals |
+|--------|---------|
+| Code Quality | Writing/modifying any code |
+| Architecture | New components, services, or major refactors |
+| UX/UI | User-facing changes, CLI output, visual elements |
+| Infrastructure | Deployment, containers, CI/CD, cloud resources |
+| Security | Auth, user data, external inputs, secrets |
+| Testing | New functionality, bug fixes, critical paths |
+| Documentation | Public APIs, complex features, breaking changes |
+| Performance | Data processing, loops, network calls, rendering |
+| Accessibility | User interfaces (web, mobile, CLI) |
+| Data | Database operations, caching, data transformations |
+
+## Step 3: Match Task to Checklists
+
+Based on your analysis, select relevant checklists:
+
+**DO NOT assume:**
+- Every task needs all checklists
+- "Frontend" = only UX checklist
+- "Backend" = only Code Quality checklist
+
+**DO analyze:**
+- What the task actually touches
+- What quality dimensions matter for this specific work
+- What could go wrong if not checked
+
+## Available Checklists
+
+Located in `templates/checklists/`:
+
+| Checklist | When to Apply |
+|-----------|---------------|
+| `code-quality.md` | Any code changes (any language) |
+| `architecture.md` | New modules, services, significant structural changes |
+| `ux-ui.md` | User-facing interfaces (web, mobile, CLI, API DX) |
+| `infrastructure.md` | Deployment, containers, CI/CD, cloud resources |
+| `security.md` | ALWAYS for: auth, user input, external APIs, secrets |
+| `testing.md` | New features, bug fixes, refactors |
+| `documentation.md` | Public APIs, complex features, configuration changes |
+| `performance.md` | Data-intensive operations, critical paths |
+| `accessibility.md` | Any user interface work |
+| `data.md` | Database, caching, data transformations |
+
+## Decision Process
+
+1. Read task description
+2. Identify primary work domain
+3. List secondary domains affected
+4. Select 2-4 most relevant checklists
+5. Consider Security (almost always relevant)
+
+## Output
+
+Return selected checklists with reasoning:
+
+```json
+{
+  "checklists": ["code-quality", "security", "testing"],
+  "reasoning": "Task involves new API endpoint (code), handles user input (security), and adds business logic (testing)",
+  "priority_items": ["Input validation", "Error handling", "Happy path tests"],
+  "skipped": {
+    "accessibility": "No user interface changes",
+    "infrastructure": "No deployment changes"
+  }
+}
+```
+
+## Rules
+
+- **Task-driven** - Focus on what the specific task needs
+- **Less is more** - 2-4 focused checklists beat 10 unfocused
+- **Security is special** - Default to including unless clearly irrelevant
+- **Explain your reasoning** - Don't just pick, justify selections AND skips
+- **Context matters** - Small typo fix ≠ major refactor in checklist needs

package/templates/agentic/orchestrator.md

@@ -0,0 +1,68 @@
+# Orchestrator
+
+Load project context for task execution.
+
+## Flow
+
+```
+p. {command} → Load Config → Load State → Load Agents → Execute
+```
+
+## Step 1: Load Config
+
+```
+READ: .prjct/prjct.config.json → {projectId}
+SET: {globalPath} = ~/.prjct-cli/projects/{projectId}
+```
+
+## Step 2: Load State
+
+```bash
+prjct dash compact
+# Parse output to determine: {hasActiveTask}
+```
+
+## Step 3: Load Agents
+
+```
+GLOB: {globalPath}/agents/*.md
+FOR EACH agent: READ and store content
+```
+
+## Step 4: Detect Domains
+
+Analyze task → identify domains:
+- frontend: UI, forms, components
+- backend: API, server logic
+- database: Schema, queries
+- testing: Tests, mocks
+- devops: CI/CD, deployment
+
+IF task spans 3+ domains → fragment into subtasks
+
+## Step 5: Build Context
+
+Combine: state + agents + detected domains → execute
+
+## Output Format
+
+```
+🎯 Task: {description}
+📦 Context: Agent: {name} | State: {status} | Domains: {list}
+```
+
+## Error Handling
+
+| Situation | Action |
+|-----------|--------|
+| No config | "Run `p. init` first" |
+| No state | Create default |
+| No agents | Warn, continue |
+
+## Disable
+
+```yaml
+---
+orchestrator: false
+---
+```

package/templates/agentic/task-fragmentation.md

@@ -0,0 +1,89 @@
+# Task Fragmentation
+
+Break complex multi-domain tasks into subtasks.
+
+## When to Fragment
+
+- Spans 3+ domains (frontend + backend + database)
+- Has natural dependency order
+- Too large for single execution
+
+## When NOT to Fragment
+
+- Single domain only
+- Small, focused change
+- Already atomic
+
+## Dependency Order
+
+1. **Database** (models first)
+2. **Backend** (API using models)
+3. **Frontend** (UI using API)
+4. **Testing** (tests for all)
+5. **DevOps** (deploy)
+
+## Subtask Format
+
+```json
+{
+  "subtasks": [{
+    "id": "subtask-1",
+    "description": "Create users table",
+    "domain": "database",
+    "agent": "database.md",
+    "dependsOn": []
+  }]
+}
+```
+
+## Output
+
+```
+🎯 Task: {task}
+
+📋 Subtasks:
+├─ 1. [database] Create schema
+├─ 2. [backend] Create API
+└─ 3. [frontend] Create form
+```
+
+## Delegation
+
+```
+Task(
+  subagent_type: 'general-purpose',
+  prompt: '
+    Read: {agentsPath}/{domain}.md
+    Subtask: {description}
+    Previous: {previousSummary}
+    Focus ONLY on this subtask.
+  '
+)
+```
+
+## Progress
+
+```
+📊 Progress: 2/4 (50%)
+✅ 1. [database] Done
+✅ 2. [backend] Done
+▶️ 3. [frontend] ← CURRENT
+⏳ 4. [testing]
+```
+
+## Error Handling
+
+```
+❌ Subtask 2/4 failed
+
+Options:
+1. Retry
+2. Skip and continue
+3. Abort
+```
+
+## Anti-Patterns
+
+- Over-fragmentation: 10 subtasks for "add button"
+- Under-fragmentation: 1 subtask for "add auth system"
+- Wrong order: Frontend before backend

package/templates/agents/AGENTS.md

@@ -0,0 +1,67 @@
+# AGENTS.md
+
+AI assistant guidance for **prjct-cli** - context layer for AI coding agents. Works with Claude Code, Gemini CLI, and more.
+
+## What This Is
+
+**NOT** project management. NO sprints, story points, ceremonies, or meetings.
+
+**IS** a context layer that gives AI agents the project knowledge they need to work effectively.
+
+---
+
+## Dynamic Agent Generation
+
+Generate agents during `p. sync` based on analysis:
+
+```javascript
+await generator.generateDynamicAgent('agent-name', {
+  role: 'Role Description',
+  expertise: 'Technologies, versions, tools',
+  responsibilities: 'What they handle'
+})
+```
+
+### Guidelines
+1. Read `analysis/repo-summary.md` first
+2. Create specialists for each major technology
+3. Name descriptively: `go-backend` not `be`
+4. Include versions and frameworks found
+5. Follow project-specific patterns
+
+## Architecture
+
+**Global**: `~/.prjct-cli/projects/{id}/`
+```
+prjct.db   # SQLite database (all state)
+context/   # now.md, next.md
+agents/    # domain specialists
+```
+
+**Local**: `.prjct/prjct.config.json` (read-only)
+
+## Commands
+
+| Command | Action |
+|---------|--------|
+| `p. init` | Initialize |
+| `p. sync` | Analyze + generate agents |
+| `p. task X` | Start task |
+| `p. done` | Complete subtask |
+| `p. ship` | Ship feature |
+| `p. next` | Show queue |
+
+## Intent Detection
+
+| Intent | Command |
+|--------|---------|
+| Start task | `p. task` |
+| Finish | `p. done` |
+| Ship | `p. ship` |
+| What's next | `p. next` |
+
+## Implementation
+
+- Atomic operations via `prjct` CLI
+- CLI handles all state persistence (SQLite)
+- Handle missing config gracefully

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/analysis/patterns.md

@@ -0,0 +1,60 @@
+---
+allowed-tools: [Read, Glob, Grep]
+description: 'Analyze code patterns and conventions'
+---
+
+# Code Pattern Analysis
+
+## Detection Steps
+
+1. **Structure** (5-10 files): File org, exports, modules
+2. **Patterns**: SOLID, DRY, factory/singleton/observer
+3. **Conventions**: Naming, style, error handling, async
+4. **Anti-patterns**: God class, spaghetti, copy-paste, magic numbers
+5. **Performance**: Memoization, N+1 queries, leaks
+
+## Output: analysis/patterns.md
+
+```markdown
+# Code Patterns - {Project}
+
+> Generated: {GetTimestamp()}
+
+## Patterns Detected
+- **{Pattern}**: {Where} - {Example}
+
+## SOLID Compliance
+| Principle | Status | Evidence |
+|-----------|--------|----------|
+| Single Responsibility | ✅/⚠️/❌ | {evidence} |
+| Open/Closed | ✅/⚠️/❌ | {evidence} |
+| Liskov Substitution | ✅/⚠️/❌ | {evidence} |
+| Interface Segregation | ✅/⚠️/❌ | {evidence} |
+| Dependency Inversion | ✅/⚠️/❌ | {evidence} |
+
+## Conventions (MUST FOLLOW)
+- Functions: {camelCase/snake_case}
+- Classes: {PascalCase}
+- Files: {kebab-case/camelCase}
+- Quotes: {single/double}
+- Async: {async-await/promises}
+
+## Anti-Patterns ⚠️
+
+### High Priority
+1. **{Issue}**: {file:line} - Fix: {action}
+
+### Medium Priority
+1. **{Issue}**: {file:line} - Fix: {action}
+
+## Recommendations
+1. {Immediate action}
+2. {Best practice}
+```
+
+## Rules
+
+1. Check patterns.md FIRST before writing code
+2. Match conventions exactly
+3. NEVER introduce anti-patterns
+4. Warn if asked to violate patterns

package/templates/antigravity/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: prjct
+description: Project context layer for AI coding agents. Use when user says "p. sync", "p. task", "p. done", "p. ship", or asks about project context, tasks, shipping features, or project state management.
+---
+
+# prjct - Context Layer for AI Agents
+
+You are using **prjct**, a context layer for AI coding agents.
+
+## Load Full Instructions
+
+1. Run: `npm root -g` to get the npm global root
+2. Read: `{npmRoot}/prjct-cli/templates/global/ANTIGRAVITY.md`
+3. Follow those instructions for ALL `p. <command>` requests
+
+## Quick Reference
+
+| Command | Action |
+|---------|--------|
+| `p. sync` | Analyze project, generate agents |
+| `p. task "..."` | Start a task |
+| `p. done` | Complete subtask |
+| `p. ship` | Ship with PR + version |
+| `p. pause` | Pause current task |
+| `p. resume` | Resume paused task |
+
+## Critical Rule
+
+**PLAN BEFORE ACTION**: For ANY prjct command, you MUST:
+1. Create a plan showing what will be done
+2. Wait for user approval
+3. Only then execute
+
+Never skip the plan step. This is non-negotiable.
+
+## Note
+
+This skill auto-regenerates with `p. sync` if deleted.
+Full instructions are in the npm package (always up-to-date).

package/templates/architect/discovery.md

@@ -0,0 +1,67 @@
+---
+name: architect-discovery
+description: Discovery phase for architecture generation
+allowed-tools: [Read, AskUserQuestion]
+---
+
+# Discovery Phase
+
+Conduct discovery for the given idea to understand requirements and constraints.
+
+## Input
+- Idea: {{idea}}
+- Context: {{context}}
+
+## Discovery Steps
+
+1. **Understand the Problem**
+   - What problem does this solve?
+   - Who experiences this problem?
+   - How critical is it?
+
+2. **Identify Target Users**
+   - Who are the primary users?
+   - What are their goals?
+   - What's their technical level?
+
+3. **Define Constraints**
+   - Budget limitations?
+   - Timeline requirements?
+   - Team size?
+   - Regulatory needs?
+
+4. **Set Success Metrics**
+   - How will we measure success?
+   - What's the MVP threshold?
+   - Key performance indicators?
+
+## Output Format
+
+Return structured discovery:
+```json
+{
+  "problem": {
+    "statement": "...",
+    "painPoints": ["..."],
+    "impact": "high|medium|low"
+  },
+  "users": {
+    "primary": { "persona": "...", "goals": ["..."] },
+    "secondary": [...]
+  },
+  "constraints": {
+    "budget": "...",
+    "timeline": "...",
+    "teamSize": 1
+  },
+  "successMetrics": {
+    "primary": "...",
+    "mvpThreshold": "..."
+  }
+}
+```
+
+## Guidelines
+- Ask clarifying questions if needed
+- Be realistic about constraints
+- Focus on MVP scope