prjct-cli 0.35.3 → 0.35.4

package/templates/commands/idea.md

@@ -1,175 +1,33 @@
 ---
-allowed-tools: [Read, Write, Bash, GetTimestamp, GetDate]
-description: 'Quick idea capture'
-timestamp-rule: 'GetTimestamp() and GetDate() for timestamps'
-architecture: 'Write-Through (JSON → MD → Events)'
-storage-layer: true
-source-of-truth: 'storage/ideas.json'
-claude-context: 'context/ideas.md'
-backend-sync: 'sync/pending.json'
+allowed-tools: [Read, Write, Bash]
 ---
 
-# /p:idea - Quick Idea Capture
+# p. idea "$ARGUMENTS"
 
-## Architecture: Write-Through Pattern
-
-```
-User Action → Storage (JSON) → Context (MD) → Sync Events
+```bash
+prjct context idea
 ```
 
-**Source of Truth**: `storage/ideas.json`
-**Claude Context**: `context/ideas.md` (generated)
-**Backend Sync**: `sync/pending.json` (events)
-
-## Context Variables
-- `{projectId}`: From `.prjct/prjct.config.json`
-- `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
-- `{ideasStoragePath}`: `{globalPath}/storage/ideas.json`
-- `{ideasContextPath}`: `{globalPath}/context/ideas.md`
-- `{syncPath}`: `{globalPath}/sync/pending.json`
-- `{memoryPath}`: `{globalPath}/memory/events.jsonl`
-- `{text}`: User-provided idea text
-
-## 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: Analyze Idea
-
-Based on {text}, detect:
-
-### Priority Detection
-- If mentions "urgent", "critical", "asap" → priority = "high"
-- If mentions "later", "maybe", "nice to have" → priority = "low"
-- Default → priority = "medium"
-
-### Tag Detection
-- If mentions UI/design → add `#ui` tag
-- If mentions performance → add `#perf` tag
-- If mentions bug/fix → add `#bug` tag
-- If mentions API/backend → add `#api` tag
-- If mentions security → add `#security` tag
-- If mentions docs → add `#docs` tag
-
-## Step 3: Update Storage (SOURCE OF TRUTH)
+Detect priority from keywords:
+- urgent/critical/asap → high
+- later/maybe/nice-to-have → low
+- default → medium
 
-GENERATE: {ideaId} = UUID v4
-SET: {now} = GetTimestamp()
+Detect tags: #ui, #perf, #bug, #api, #security, #docs
 
-### Read existing ideas
-READ: `{ideasStoragePath}` or create default:
+ADD to `{globalPath}/storage/ideas.json`:
 ```json
-{
-  "ideas": [],
-  "lastUpdated": null
-}
+{"id":"{uuid}","text":"$ARGUMENTS","priority":"{priority}","tags":[...],"status":"pending","createdAt":"{now}"}
 ```
 
-### Create idea object
-```json
-{
-  "id": "{ideaId}",
-  "text": "{text}",
-  "priority": "{priority}",
-  "tags": ["{detected_tags}"],
-  "status": "pending",
-  "createdAt": "{now}"
-}
+**Output**:
 ```
+💡 $ARGUMENTS
 
-### Update ideas.json
-PREPEND new idea to ideas array
-SET: lastUpdated = {now}
-WRITE: `{ideasStoragePath}`
-
-## Step 4: Generate Context (FOR CLAUDE)
-
-WRITE: `{ideasContextPath}`
-
-```markdown
-# IDEAS
-
-## Pending
-
-{FOR EACH idea in ideas WHERE status == "pending":}
-- **{idea.text}** {idea.tags.join(' ')}
-  - Priority: {idea.priority}
-  - Added: {idea.createdAt}
-{END FOR}
+Priority: {priority}
+Tags: {tags}
 
-## Converted
-
-{FOR EACH idea in ideas WHERE status == "converted":}
-- ~~{idea.text}~~ → Feature: {idea.convertedTo}
-{END FOR}
-```
-
-## Step 5: Queue Sync Event (FOR BACKEND)
-
-READ: `{syncPath}` or create empty array
-APPEND event:
-```json
-{
-  "type": "idea.created",
-  "path": ["ideas"],
-  "data": {
-    "ideaId": "{ideaId}",
-    "text": "{text}",
-    "priority": "{priority}",
-    "tags": ["{detected_tags}"]
-  },
-  "timestamp": "{now}",
-  "projectId": "{projectId}"
-}
-```
-WRITE: `{syncPath}`
-
-## Step 6: Log to Memory (AUDIT TRAIL)
-
-APPEND to: `{memoryPath}`
-```json
-{"timestamp":"{now}","action":"idea_added","ideaId":"{ideaId}","text":"{text}","priority":"{priority}"}
-```
-
-## Response
-
-`💡 {text} | Saved | Start: /p:feature "{text}"`
-
-## Error Handling
-
-| Error | Response | Action |
-|-------|----------|--------|
-| No project | "No prjct project" | STOP |
-| No text | "What's your idea?" | ASK |
-| Write fails | Log warning | CONTINUE |
-
-## Examples
-
-### Example 1: Simple Idea
-**Input:** `/p:idea add dark mode support`
-
-**Output:**
-```
-💡 add dark mode support | Saved | Start: /p:feature "add dark mode support"
-```
-
-### Example 2: Idea with Priority
-**Input:** `/p:idea urgent fix login bug`
-
-**Output:**
-```
-💡 urgent fix login bug [high] | Saved | Start: /p:feature "fix login bug"
-```
-
-### Example 3: Idea with Tags
-**Input:** `/p:idea improve API performance`
-
-**Output:**
-```
-💡 improve API performance #api #perf | Saved
+Next:
+- Start work → `p. task "$ARGUMENTS"`
+- See ideas → `p. dash`
 ```

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/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`