prjct-cli 0.35.2 → 0.35.4

package/templates/commands/init.md

@@ -1,227 +1,38 @@
 ---
-allowed-tools: [Read, Write, Bash]
-description: 'Initialize prjct'
-timestamp-rule: 'GetTimestamp() for all timestamps'
-architecture: 'Write-Through (JSON → MD → Events)'
-storage-layer: true
+allowed-tools: [Read, Write, Bash, AskUserQuestion]
 ---
 
-# /p:init - Initialize Project
+# p. init
 
-## Architecture: Write-Through Pattern
+Check if already initialized (`.prjct/prjct.config.json` exists)
 
-Creates the full storage structure for a new project.
+Generate UUID: `crypto.randomUUID()`
 
-## Context Variables
-- `{projectId}`: Generated UUID (standard format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)
-- `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
-- `{cwd}`: Current working directory (repository path)
+Create directories in `~/.prjct-cli/projects/{projectId}/`:
+- storage/ (state.json, queue.json, ideas.json, shipped.json)
+- context/
+- sync/
+- agents/
+- memory/
 
-## Project ID Format
-
-**CRITICAL**: Project IDs MUST be standard UUIDs for PostgreSQL consistency.
-
-```
-Format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
-Example: 550e8400-e29b-41d4-a716-446655440000
-```
-
-Generate using: `crypto.randomUUID()`
-
-## Flow
-
-1. **Check existing**: Read `.prjct/prjct.config.json`
-2. **Generate UUID**: Use `crypto.randomUUID()`
-3. **Create directories**: storage/, context/, sync/, agents/, memory/
-4. **Create config files**: local + global
-5. **Analyze project**: Detect stack, dependencies
-6. **Generate agents**: Based on detected stack
-
-## Directory Structure
-
-```
-~/.prjct-cli/projects/{projectId}/
-├── storage/                  # Source of Truth (JSON)
-│   ├── state.json           # Current + paused task
-│   ├── queue.json           # Task queue
-│   ├── ideas.json           # Ideas list
-│   └── shipped.json         # Shipped features
-├── context/                  # For Claude (MD)
-│   ├── CLAUDE.md            # Full context
-│   ├── now.md               # Current task
-│   ├── next.md              # Queue
-│   ├── ideas.md             # Ideas
-│   └── shipped.md           # Shipped
-├── sync/                     # Backend Sync
-│   └── pending.json         # Events queue
-├── agents/                   # Specialists
-├── memory/                   # Audit Trail
-│   └── events.jsonl
-├── progress/                 # Historical Data
-│   └── sessions/{YYYY-MM}/
-└── project.json             # Metadata
-```
-
-## Step: Create Storage Files
-
-### storage/state.json
-```json
-{
-  "currentTask": null,
-  "pausedTask": null,
-  "previousTask": null,
-  "lastUpdated": null
-}
-```
-
-### storage/queue.json
+Create `.prjct/prjct.config.json`:
 ```json
-{
-  "tasks": [],
-  "lastUpdated": null
-}
+{"projectId": "{uuid}", "dataPath": "~/.prjct-cli/projects/{uuid}"}
 ```
 
-### storage/ideas.json
-```json
-{
-  "ideas": [],
-  "lastUpdated": null
-}
-```
+Create `{globalPath}/project.json` with project name from package.json
 
-### storage/shipped.json
-```json
-{
-  "shipped": [],
-  "lastUpdated": null
-}
-```
-
-### sync/pending.json
-```json
-[]
-```
-
-## Step: Create project.json (REQUIRED)
-
-This file is the source of truth for the web dashboard.
-
-### Determine Project Name
-- Try package.json → `name` field
-- Try Cargo.toml → `[package] name`
-- Try pyproject.toml → `[project] name`
-- Fallback to directory name
-
-WRITE: `{globalPath}/project.json`
-
-```json
-{
-  "projectId": "{projectId}",
-  "repoPath": "{cwd}",
-  "name": "{projectName}",
-  "createdAt": "{GetTimestamp()}",
-  "lastSync": "{GetTimestamp()}"
-}
-```
-
-## Step: Create Local Config
-
-WRITE: `.prjct/prjct.config.json`
-
-```json
-{
-  "projectId": "{projectId}",
-  "dataPath": "~/.prjct-cli/projects/{projectId}"
-}
-```
-
-## Step: Install MCP Servers
-
-Install required MCP servers by merging `templates/mcp-config.json` into `~/.claude/settings.json`.
-
-```
-READ: templates/mcp-config.json
-READ: ~/.claude/settings.json (if exists)
-MERGE: mcpServers (don't overwrite existing)
-WRITE: ~/.claude/settings.json
-
-Servers installed:
-- context7: Library documentation lookup
-- Atlassian: JIRA/Confluence (OAuth, SSO compatible)
-```
-
-## Step: Optional Integrations
-
-After core setup, offer optional integrations.
-
-### JIRA Integration (Optional)
-
-Ask: "Would you like to connect with JIRA for issue tracking?"
-
-If yes:
-1. MCP server already installed (Atlassian)
-2. Ask user to authenticate:
-   - "Run `p. jira setup` after init completes"
-   - First use will open browser for OAuth (SSO compatible)
-3. Store config in `project.json`:
-
-```json
-{
-  "integrations": {
-    "jira": {
-      "enabled": true,
-      "provider": "jira",
-      "authMode": "mcp"
-    }
-  }
-}
-```
-
-If no: Skip (integration can be added later with `p. jira setup`).
-
-### Linear Integration (Optional)
-
-Ask: "Would you like to connect with Linear for issue tracking?"
-
-If yes:
-1. Ask for LINEAR_API_KEY (from https://linear.app/settings/api)
-2. Run `p. linear setup` to complete configuration
-
-## Response
+Optional: Ask about JIRA/Linear integration
 
+**Output**:
 ```
 ✅ Initialized prjct
 
-Project ID: {projectId}
-Data Path: ~/.prjct-cli/projects/{projectId}/
-
-Structure:
-├── storage/    # JSON (source of truth)
-├── context/    # MD (for Claude)
-├── sync/       # Backend events
-└── agents/     # Specialists
-
-MCP Servers:
-• context7: Library docs ✓
-• Atlassian: JIRA/Confluence ✓
-
-Integrations:
-• JIRA: {enabled|disabled}
-• Linear: {enabled|disabled}
+Project ID: {uuid}
+Data: ~/.prjct-cli/projects/{uuid}/
 
 Next:
-• p. sync - Analyze project and generate agents
-• p. jira setup - Configure JIRA project (if enabled)
-• p. linear setup - Configure Linear (if enabled)
-• p. task "{first_task}" - Start first task
-• p. help - See all commands
+- Analyze project → `p. sync`
+- Start first task → `p. task "description"`
+- See help → `p. help`
 ```
-
-## Error Handling
-
-| Error | Response |
-|-------|----------|
-| Already initialized | Show existing projectId |
-| Permission denied | Suggest chmod |
-| Write fails | Show error |

package/templates/commands/jira.md

@@ -1,14 +1,23 @@
 ---
 allowed-tools: [Read, Write, Bash, Task, Glob, Grep, AskUserQuestion]
 description: 'JIRA issue tracker integration'
+extends: '_bases/tracker-base.md'
 ---
 
 # p. jira - JIRA Integration
 
+**EXTENDS**: `_bases/tracker-base.md` - See base template for common flows.
+
 **ARGUMENTS**: $ARGUMENTS
 
 Manage JIRA issues directly from prjct.
 
+## Tracker-Specific Config
+
+- `{mcpServerName}`: "Atlassian"
+- `{mcpPrefix}`: "mcp__atlassian__jira_"
+- `{projectKey}`: "projectKey"
+
 ## Context Variables
 
 - `{projectId}`: From `.prjct/prjct.config.json`

package/templates/commands/linear.md

@@ -1,14 +1,23 @@
 ---
 allowed-tools: [Read, Write, Bash, AskUserQuestion]
 description: 'Linear issue tracker integration via MCP'
+extends: '_bases/tracker-base.md'
 ---
 
 # p. linear - Linear Integration
 
+**EXTENDS**: `_bases/tracker-base.md` - See base template for common flows.
+
 **ARGUMENTS**: $ARGUMENTS
 
 Manage Linear issues directly from prjct using MCP (no SDK needed).
 
+## Tracker-Specific Config
+
+- `{mcpServerName}`: "linear"
+- `{mcpPrefix}`: "mcp__linear__"
+- `{projectKey}`: "teamId"
+
 ## Context Variables
 
 - `{projectId}`: From `.prjct/prjct.config.json`

package/templates/commands/merge.md

@@ -1,202 +1,38 @@
 ---
-allowed-tools: [Bash, Read, Write, AskUserQuestion]
-description: 'Merge PR to main branch'
-timestamp-rule: 'GetTimestamp() for ALL timestamps'
-architecture: 'Write-Through (JSON -> MD -> Events)'
-storage-layer: true
-source-of-truth: 'storage/state.json'
+allowed-tools: [Bash, Read, Write]
 ---
 
-# /p:merge
+# p. merge
 
-Merge approved PR to main branch.
-
-## Usage
-
-```
-/p:merge [--squash|--rebase|--merge]    # Merge strategy (default: squash)
-         [--delete-branch]               # Delete branch after merge
+```bash
+prjct context merge
 ```
 
-## Context Variables
-- `{projectId}`: From `.prjct/prjct.config.json`
-- `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
-- `{statePath}`: `{globalPath}/storage/state.json`
-- `{memoryPath}`: `{globalPath}/memory/events.jsonl`
-- `{syncPath}`: `{globalPath}/sync/pending.json`
-
-## Step 1: Validate Project
-
-READ: `.prjct/prjct.config.json`
-EXTRACT: `projectId`
-
-IF file not found:
-  OUTPUT: "No prjct project. Run /p:init first."
-  STOP
-
-## Step 2: Validate Workflow Phase
-
-READ: `{globalPath}/storage/state.json`
-
-IF currentTask is null:
-  OUTPUT: "No active task. Use p. task to start one."
-  STOP
-
-IF currentTask.workflow exists:
-  IF currentTask.workflow.phase != "review":
-    OUTPUT:
-    ```
-    Cannot merge. Current phase: {currentTask.workflow.phase}
-
-    Required phase: review
-
-    Workflow: analyze → branch → implement → test → review → merge → ship → verify
-    
-    Complete code review first with p. review
-    ```
-    STOP
-
-## Step 3: Verify PR Status
-
-SET: {prNumber} = currentTask.branch.prNumber
-
-IF {prNumber} is null:
-  OUTPUT: "No PR found. Run p. review first to create PR."
-  STOP
-
-### Check PR is approved
-BASH: `gh pr view {prNumber} --json reviewDecision,mergeable,state`
-SET: {decision} = result.reviewDecision
-SET: {mergeable} = result.mergeable
-SET: {state} = result.state
-
-IF {state} == "MERGED":
-  OUTPUT: "PR already merged."
-  -> Skip to Step 5 (update workflow)
-
-IF {decision} != "APPROVED":
-  OUTPUT:
-  ```
-  ⚠️ PR not approved yet
-
-  Current status: {decision}
-  
-  Get approvals and run p. merge again.
-  ```
-  STOP
-
-IF {mergeable} != "MERGEABLE":
-  OUTPUT:
-  ```
-  ⚠️ PR has conflicts or is not mergeable
-
-  Status: {mergeable}
-  
-  Resolve conflicts and run p. merge again.
-  ```
-  STOP
-
-## Step 4: Merge PR
+IF no `currentTask` → "No active task"
+IF no PR → "Run p. review first"
 
-### Parse merge strategy
-SET: {strategy} = "squash"  # default
-IF --rebase: {strategy} = "rebase"
-IF --merge: {strategy} = "merge"
-
-OUTPUT: "Merging PR #{prNumber} with {strategy} strategy..."
-
-BASH: `gh pr merge {prNumber} --{strategy} --auto 2>&1`
-
-IF command fails:
-  OUTPUT: "Merge failed. Check PR status on GitHub."
-  STOP
-
-### Delete branch if requested
-IF --delete-branch OR currentTask.branch.createdByPrjct:
-  BASH: `git branch -d {currentTask.branch.name} 2>/dev/null`
-  BASH: `git push origin --delete {currentTask.branch.name} 2>/dev/null`
-  OUTPUT: "Deleted branch: {currentTask.branch.name}"
-
-### Switch to base branch
-BASH: `git checkout {currentTask.branch.baseBranch}`
-BASH: `git pull origin {currentTask.branch.baseBranch}`
-
-## Step 5: Update Workflow Phase
-
-SET: {now} = GetTimestamp()
-
-### Get merge commit
-BASH: `git rev-parse HEAD`
-SET: {mergeCommit} = result
-
-SET: currentTask.workflow.phase = "merge"
-SET: currentTask.workflow.checkpoints.merge = {
-  "completedAt": "{now}",
-  "data": {
-    "mergeCommit": "{mergeCommit}",
-    "prNumber": {prNumber},
-    "strategy": "{strategy}"
-  }
-}
-SET: currentTask.workflow.lastCheckpoint = "merge"
-
-WRITE: `{statePath}`
-
-## Step 6: Log Events
-
-APPEND to `{memoryPath}`:
-```json
-{"timestamp":"{now}","action":"phase_advanced","taskId":"{currentTask.id}","from":"review","to":"merge"}
-{"timestamp":"{now}","action":"checkpoint_completed","taskId":"{currentTask.id}","checkpoint":"merge","data":{"mergeCommit":"{mergeCommit}"}}
+```bash
+gh pr view {prNumber} --json reviewDecision,mergeable,state
 ```
 
-APPEND to `{syncPath}`:
-```json
-{"type":"workflow.phase_advanced","data":{"taskId":"{currentTask.id}","from":"review","to":"merge","mergeCommit":"{mergeCommit}"},"timestamp":"{now}"}
+IF not approved → "Get approvals first"
+IF has conflicts → "Resolve conflicts first"
+
+```bash
+gh pr merge {prNumber} --squash --auto
+git checkout main && git pull
 ```
 
-## Output
+Delete branch if created by prjct
 
+**Output**:
 ```
-✓ PR Merged
+✅ PR Merged
 
-Task: {currentTask.description}
 PR: #{prNumber}
-Merge commit: {mergeCommit}
-Strategy: {strategy}
-
-Phase: merge (6/11 checkpoints)
+Strategy: squash
 
-Workflow:
-1. analyze ✓
-2. branch ✓
-3. implement ✓
-4. test ✓
-5. review ✓
-6. merge ✓
-7-10. ship ← next
-
-Next: p. ship to release
+Next:
+- Release → `p. ship`
+- New task → `p. task "description"`
 ```
-
-## Error Handling
-
-| Error | Response | Action |
-|-------|----------|--------|
-| No project | "No prjct project" | STOP |
-| No active task | "No active task" | STOP |
-| Wrong phase | Show required phase | STOP |
-| No PR | "Run p. review first" | STOP |
-| Not approved | "Get approvals first" | STOP |
-| Conflicts | "Resolve conflicts" | STOP |
-| Merge fails | Show error | STOP |
-
-## Natural Language Triggers
-
-- `p. merge` -> /p:merge
-- `p. merge pr` -> /p:merge
-
-## References
-
-- Architecture: `~/.prjct-cli/docs/architecture.md`
-- Workflow: `~/.prjct-cli/docs/workflow.md`

package/templates/commands/monday.md

@@ -1,14 +1,23 @@
 ---
 allowed-tools: [Read, Write, Bash, AskUserQuestion]
 description: 'Monday.com issue tracker integration via MCP'
+extends: '_bases/tracker-base.md'
 ---
 
 # p. monday - Monday.com Integration
 
+**EXTENDS**: `_bases/tracker-base.md` - See base template for common flows.
+
 **ARGUMENTS**: $ARGUMENTS
 
 Manage Monday.com boards directly from prjct using MCP.
 
+## Tracker-Specific Config
+
+- `{mcpServerName}`: "monday"
+- `{mcpPrefix}`: "mcp__monday__"
+- `{projectKey}`: "boardId"
+
 ## Context Variables
 
 - `{projectId}`: From `.prjct/prjct.config.json`

package/templates/commands/next.md

@@ -1,124 +1,42 @@
 ---
 allowed-tools: [Read]
-description: 'Show priority queue'
-architecture: 'Write-Through (JSON → MD → Events)'
-storage-layer: true
-source-of-truth: 'storage/queue.json'
-claude-context: 'context/next.md'
 ---
 
-# /p:next - Show Priority Queue
+# p. next
 
-## Architecture: Write-Through Pattern
-
-Reads from **Storage (JSON)** as source of truth.
-
-**Source of Truth**: `storage/queue.json`
-**Also reads**: `storage/state.json` for current task status
-
-## Context Variables
-- `{projectId}`: From `.prjct/prjct.config.json`
-- `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
-- `{queuePath}`: `{globalPath}/storage/queue.json`
-- `{statePath}`: `{globalPath}/storage/state.json`
-
-## Flow
+```bash
+prjct context next
+```
 
-1. Read `storage/state.json` → Check if active task
-2. Read `storage/queue.json` → Get queue tasks
-3. Display top 5 non-blocked tasks
+READ `{globalPath}/storage/queue.json`
+READ `{globalPath}/storage/state.json`
 
-## Response
+IF `currentTask` active → Show warning first
 
-**If active task**:
+**Output (queue view)**:
 ```
-⚠️ Active: {currentTask.description}
-
-Complete with /p:done first, or:
-
 📋 Queue ({count})
-1. {task_1}
+
+1. {task_1} [{priority}]
 2. {task_2}
 3. {task_3}
 ...
 
-Start: /p:work {N}
+Next:
+- Start task → `p. task "{task_1}"`
+- Add task → `p. task "description"`
+- Report bug → `p. bug "description"`
 ```
 
-**If no active task**:
-```
-📋 Queue ({count})
-
-1. {task_1} {priority}
-2. {task_2} {priority}
-3. {task_3} {priority}
-4. {task_4}
-5. {task_5}
-
-{IF count > 5: ... and {count - 5} more}
-
-Start: /p:work 1 or /p:now "{task}"
-```
-
-**If empty queue**:
+**Output (empty)**:
 ```
 📋 Queue is empty
 
-Add tasks:
-• /p:feature "description"
-• /p:bug "description"
-• /p:idea "quick note"
+Next:
+- Add task → `p. task "description"`
+- Report bug → `p. bug "description"`
+- Capture idea → `p. idea "note"`
 ```
 
-## Data Source
-
-| Data | Storage File | Field |
-|------|--------------|-------|
-| Current Task | `storage/state.json` | `currentTask` |
-| Queue Tasks | `storage/queue.json` | `tasks[]` |
-| Shipped | `storage/shipped.json` | `shipped[]` |
-
-## Usage Variants
-
-```
-/p:next                    # Priority queue (default)
-/p:next roadmap            # Feature-grouped view
-/p:next --roadmap          # Same as above
-```
-
-## Roadmap View
-
-When called with `roadmap` parameter, show feature-grouped view:
-
-```
-📍 PRODUCT ROADMAP
-
-🚀 Current Sprint
-├── ✅ {completed_feature} - shipped {date}
-├── 🔄 {active_feature} ({X}% complete)
-│   └── 🎯 {current_task}
-└── ⏳ {pending_feature} ({N} tasks)
-
-📅 Next Up ({N} features)
-├── {feature_1} - {effort}
-└── {feature_2} - {effort}
-
-📊 Velocity: {X.X} features/week
-
-/p:now "{next}" | /p:done
-```
-
-### Roadmap Data Aggregation
-
-1. Group queue tasks by `featureId`
-2. Calculate completion % per feature
-3. Sort by priority/dependency
-4. Show current task within active feature
-
-## Natural Language Support
-
-- "p. next" → Priority queue
-- "p. queue" → Priority queue
-- "p. what's next" → Priority queue
-- "p. roadmap" → Roadmap view
-- "p. features" → Roadmap view
+**Roadmap view** (`p. next roadmap`):
+Group by feature, show completion %