prjct-cli 0.55.1 → 0.55.3

package/templates/commands/pause.md

@@ -4,36 +4,133 @@ allowed-tools: [Read, Write, Bash, AskUserQuestion]
 
 # p. pause "$ARGUMENTS"
 
+## Step 1: Resolve Project Paths
+
 ```bash
-prjct context pause
+# Get projectId from local config
+cat .prjct/prjct.config.json | grep -o '"projectId"[[:space:]]*:[[:space:]]*"[^"]*"' | cut -d'"' -f4
+```
+
+Set `globalPath = ~/.prjct-cli/projects/{projectId}`
+
+## Step 2: Read Current State
+
+READ `{globalPath}/storage/state.json`
+
 ```
+IF no currentTask OR currentTask is null:
+  OUTPUT: "No active task to pause."
+  STOP
 
-IF no `currentTask` → "No active task to pause"
-IF already paused → Show paused state, STOP
+IF currentTask.status == "paused":
+  OUTPUT:
+  """
+  ⏸️ Already paused: {currentTask.description}
 
-IF no reason provided, Ask: "Why pausing?"
-- Blocked (waiting on external)
-- Switching task
-- Taking a break
-- Researching
+  To resume: `p. resume`
+  """
+  STOP
+```
 
-IF blocked → Ask what's blocking
+## Step 3: Get Pause Reason
 
-Calculate duration since `startedAt`
+```
+IF $ARGUMENTS is empty:
+  AskUserQuestion:
+    question: "Why are you pausing?"
+    header: "Pause"
+    options:
+      - label: "Blocked (waiting on external)"
+        description: "Waiting for review, dependency, or other team"
+      - label: "Switching task"
+        description: "Need to work on something else"
+      - label: "Taking a break"
+        description: "Stepping away temporarily"
+      - label: "Researching"
+        description: "Need to investigate before continuing"
+
+  SET pauseReason = selected option
+
+  IF pauseReason == "Blocked":
+    ASK: "What's blocking you?"
+    SET blockingReason = response
+ELSE:
+  SET pauseReason = $ARGUMENTS
+```
+
+## Step 4: Calculate Duration
+
+```bash
+# Get current timestamp
+node -e "console.log(new Date().toISOString())"
+```
+
+Calculate time elapsed since `currentTask.startedAt` (or `resumedAt` if it exists).
+
+## Step 5: Update State
+
+READ current state, then update:
+
+```
+pausedTask = currentTask
+pausedTask.status = "paused"
+pausedTask.pausedAt = "{timestamp}"
+pausedTask.pauseReason = "{pauseReason}"
+pausedTask.blockingReason = "{blockingReason if set}"
+pausedTask.activeTime = "{duration worked so far}"
+
+state.pausedTasks = state.pausedTasks || []
+state.pausedTasks.unshift(pausedTask)  # Add to front
+state.currentTask = null
+```
+
+WRITE `{globalPath}/storage/state.json`:
+```json
+{
+  "currentTask": null,
+  "pausedTasks": [
+    {
+      "id": "{task.id}",
+      "description": "{task.description}",
+      "type": "{task.type}",
+      "status": "paused",
+      "startedAt": "{task.startedAt}",
+      "pausedAt": "{timestamp}",
+      "pauseReason": "{pauseReason}",
+      "blockingReason": "{blockingReason or null}",
+      "activeTime": "{duration}",
+      "subtasks": [...],
+      "currentSubtaskIndex": {task.currentSubtaskIndex},
+      "parentDescription": "{task.parentDescription}",
+      "branch": "{task.branch}",
+      "linearId": "{task.linearId or null}"
+    },
+    ...existing paused tasks
+  ],
+  "previousTask": {...}
+}
+```
+
+## Step 6: Log Event
+
+APPEND to `{globalPath}/memory/events.jsonl`:
+```json
+{"type":"task_paused","taskId":"{id}","description":"{description}","reason":"{pauseReason}","timestamp":"{timestamp}","activeTime":"{duration}"}
+```
+
+---
 
-UPDATE `{globalPath}/storage/state.json`:
-- `pausedTask` = currentTask with `status: "paused"`, `pausedAt`, `pauseReason`
-- `currentTask` = null
+## Output
 
-**Output**:
 ```
-⏸️ Paused: {task}
+⏸️ Paused: {task description}
 
-Duration: {time}
-Reason: {reason}
+Duration: {time worked}
+Reason: {pauseReason}
+{IF blockingReason: "Blocked by: {blockingReason}"}
 
 Next:
 - Resume → `p. resume`
 - New task → `p. task "description"`
-- Complete without resuming → `p. done`
+- Fix bug → `p. bug "description"`
 ```

package/templates/commands/resume.md

@@ -4,31 +4,168 @@ allowed-tools: [Read, Write, Bash, Glob, AskUserQuestion]
 
 # p. resume
 
+## Step 1: Resolve Project Paths
+
+```bash
+# Get projectId from local config
+cat .prjct/prjct.config.json | grep -o '"projectId"[[:space:]]*:[[:space:]]*"[^"]*"' | cut -d'"' -f4
+```
+
+Set `globalPath = ~/.prjct-cli/projects/{projectId}`
+
+## Step 2: Read Current State
+
+READ `{globalPath}/storage/state.json`
+
+```
+IF currentTask exists AND currentTask.status == "active":
+  OUTPUT:
+  """
+  Already active: {currentTask.description}
+
+  To pause: `p. pause`
+  To complete: `p. done`
+  """
+  STOP
+
+IF (no pausedTasks OR pausedTasks is empty):
+  OUTPUT: "Nothing to resume. Use `p. task` to start a new task."
+  STOP
+```
+
+## Step 3: Select Task to Resume
+
+```
+IF pausedTasks.length == 1:
+  taskToResume = pausedTasks[0]
+ELSE:
+  # Multiple paused tasks - let user choose
+  Show list:
+  """
+  Multiple paused tasks:
+
+  1. {pausedTasks[0].description} (paused {time ago})
+     Reason: {pauseReason}
+  2. {pausedTasks[1].description} (paused {time ago})
+     Reason: {pauseReason}
+  ...
+  """
+
+  AskUserQuestion:
+    question: "Which task do you want to resume?"
+    header: "Resume"
+    options:
+      - label: "{pausedTasks[0].description}"
+        description: "Paused {time ago} - {pauseReason}"
+      - label: "{pausedTasks[1].description}"
+        description: "Paused {time ago} - {pauseReason}"
+      ... (up to 4 options)
+
+  taskToResume = selected task
+```
+
+## Step 4: Calculate Away Duration
+
+```bash
+# Get current timestamp
+node -e "console.log(new Date().toISOString())"
+```
+
+Calculate time since `taskToResume.pausedAt`.
+
+## Step 5: Switch to Task Branch (if needed)
+
 ```bash
-prjct context resume
+git branch --show-current
+```
+
+```
+IF taskToResume.branch exists AND currentBranch != taskToResume.branch:
+  # Check for uncommitted changes first
+  git status --porcelain
+
+  IF uncommitted changes:
+    AskUserQuestion:
+      question: "You have uncommitted changes. What should we do?"
+      header: "Git"
+      options:
+        - label: "Stash changes"
+          description: "Save changes and switch branches"
+        - label: "Commit changes"
+          description: "Commit before switching"
+        - label: "Cancel resume"
+          description: "Stay on current branch"
+
+    Handle response appropriately
+
+  git checkout {taskToResume.branch}
+```
+
+## Step 6: Update State
+
+```
+resumedTask = taskToResume
+resumedTask.status = "active"
+resumedTask.resumedAt = "{timestamp}"
+resumedTask.pausedDuration = "{away duration}"
+
+# Remove from pausedTasks
+state.pausedTasks = state.pausedTasks.filter(t => t.id != resumedTask.id)
+state.currentTask = resumedTask
 ```
 
-IF `currentTask` active → "Already active: {task}", STOP
-IF no `pausedTask` AND no `interruptedTask` → "Nothing to resume", STOP
+WRITE `{globalPath}/storage/state.json`:
+```json
+{
+  "currentTask": {
+    "id": "{task.id}",
+    "description": "{task.description}",
+    "type": "{task.type}",
+    "status": "active",
+    "startedAt": "{task.startedAt}",
+    "resumedAt": "{timestamp}",
+    "pausedDuration": "{away duration}",
+    "subtasks": [...],
+    "currentSubtaskIndex": {task.currentSubtaskIndex},
+    "parentDescription": "{task.parentDescription}",
+    "branch": "{task.branch}",
+    "linearId": "{task.linearId or null}"
+  },
+  "pausedTasks": [...remaining paused tasks],
+  "previousTask": {...}
+}
+```
 
-IF both exist → Ask which to resume
+## Step 7: Load Context
 
-Calculate away duration
+Load agents for context:
+```
+GLOB: {globalPath}/agents/*.md
 
-UPDATE `{globalPath}/storage/state.json`:
-- `currentTask` = resumed task with `status: "active"`, `resumedAt`
-- Clear `pausedTask` or `interruptedTask`
+FOR each agent file:
+  READ agent content for domain patterns
+```
+
+## Step 8: Log Event
+
+APPEND to `{globalPath}/memory/events.jsonl`:
+```json
+{"type":"task_resumed","taskId":"{id}","description":"{description}","timestamp":"{timestamp}","pausedDuration":"{away duration}"}
+```
+
+---
 
-Load agents from `{globalPath}/agents/` for context
+## Output
 
-**Output**:
 ```
-▶️ Resumed: {task}
+▶️ Resumed: {task.parentDescription}
 
-Was paused: {duration}
-{IF workflow: Phase: {phase}}
+Was paused: {pausedDuration}
+{IF task.subtasks: "Current subtask: {current subtask}"}
+Branch: {task.branch}
 
 Next:
-- Finish work → `p. done`
+- Continue work → make changes
+- Finish subtask → `p. done`
 - Pause again → `p. pause`
 ```

package/templates/commands/sync.md

@@ -89,15 +89,6 @@ IF integrations.linear.enabled:
   OUTPUT: "Linear: {fetched} issues synced"
 ```
 
-## Cursor Router Regeneration
-
-If `.cursor/` exists but `.cursor/rules/prjct.mdc` is missing:
-1. Get npm root: `npm root -g`
-2. Create `.cursor/rules/` directory if needed
-3. Copy router: `{npmRoot}/prjct-cli/templates/cursor/router.mdc` → `.cursor/rules/prjct.mdc`
-4. Copy commands: `{npmRoot}/prjct-cli/templates/cursor/p.md` → `.cursor/commands/p.md`
-5. Report: "Cursor routers regenerated"
-
 ## Output
 
 ```
@@ -106,7 +97,6 @@ If `.cursor/` exists but `.cursor/rules/prjct.mdc` is missing:
 Ecosystem: {ecosystem}
 Agents: {count} generated
 Linear: {issueCount} issues synced (or "not enabled")
-Cursor: {regenerated/ready/not detected}
 
 Next:
 - Start work → `p. task "description"`

package/templates/commands/task.md

@@ -17,7 +17,16 @@ IF $ARGUMENTS is empty:
   DO NOT proceed with empty task
 ```
 
-### Check 2: Check for Active Task
+### Check 2: Resolve Project Paths
+
+```bash
+# Get projectId from local config
+cat .prjct/prjct.config.json | grep -o '"projectId"[[:space:]]*:[[:space:]]*"[^"]*"' | cut -d'"' -f4
+```
+
+Set `globalPath = ~/.prjct-cli/projects/{projectId}`
+
+### Check 3: Check for Active Task
 
 ```
 READ: {globalPath}/storage/state.json
@@ -38,7 +47,7 @@ IF currentTask exists AND currentTask.status == "active":
   DO NOT automatically switch tasks
 ```
 
-### Check 3: Validate Git State
+### Check 4: Validate Git State
 
 ```bash
 git status --porcelain
@@ -77,9 +86,9 @@ IF integrations.linear.enabled:
   IF issue found in local cache:
     USE cached issue data (no API call needed)
   ELSE:
-    # Fallback to API
-    IMPORT: linearSync from core/integrations/linear
-    CALL: linearSync.getIssue(projectId, "$ARGUMENTS")  # Fetches + caches
+    # Fallback to API - sync and retry
+    RUN: bun $PRJCT_CLI/core/cli/linear.ts --project {projectId} sync
+    RUN: bun $PRJCT_CLI/core/cli/linear.ts --project {projectId} get-local "$ARGUMENTS"
 
   IF issue found:
     SET: task.linearId = issue.identifier     # "PRJ-123"
@@ -87,17 +96,15 @@ IF integrations.linear.enabled:
     SET: task.description = issue.title
     SET: $ARGUMENTS = issue.title  # Use title for task
 
-    # Mark issue as In Progress in Linear (pushes status change)
-    IMPORT: linearSync from core/integrations/linear
-    CALL: linearSync.pushStatus(projectId, issue.identifier, 'in_progress')
+    # Mark issue as In Progress in Linear
+    RUN: bun $PRJCT_CLI/core/cli/linear.ts --project {projectId} status "$ARGUMENTS" "in_progress"
 
     OUTPUT: "Linked to Linear: {issue.identifier} - {issue.title}"
     OUTPUT: "Linear: In Progress"
 
 ELSE IF integrations.jira.enabled:
   # JIRA issue detected
-  IMPORT: jiraService from core/integrations/jira
-  CALL: jiraService.fetchIssue("$ARGUMENTS")
+  RUN: bun $PRJCT_CLI/core/cli/jira.ts --project {projectId} get "$ARGUMENTS"
 
   IF issue found:
     SET: task.externalId = issue.externalId
@@ -106,7 +113,7 @@ ELSE IF integrations.jira.enabled:
     SET: $ARGUMENTS = issue.title  # Use title for task
 
     # Mark issue as In Progress in JIRA
-    CALL: jiraService.markInProgress(issue.externalId)
+    RUN: bun $PRJCT_CLI/core/cli/jira.ts --project {projectId} status "$ARGUMENTS" "in_progress"
 
     OUTPUT: "Linked to JIRA: {issue.externalId} - {issue.title}"
     OUTPUT: "JIRA: In Progress"
@@ -119,7 +126,29 @@ ELSE:
 
 ## Main Flow
 
-### Step A: Show Plan and Get Approval (BLOCKING)
+### Step A: Explore Codebase (for context)
+
+```
+USE Task(Explore) → find similar code, affected files
+READ {globalPath}/agents/*.md → get domain patterns (if they exist)
+```
+
+### Step B: Classify Task
+
+Determine type based on keywords:
+- `add`, `create`, `implement`, `new` → **feature**
+- `fix`, `repair`, `broken`, `error` → **bug**
+- `improve`, `enhance`, `optimize` → **improvement**
+- `refactor`, `clean`, `reorganize` → **refactor**
+- `update`, `upgrade`, `migrate` → **chore**
+
+Default: **feature**
+
+### Step C: Break Down into Subtasks
+
+Create 2-5 actionable subtasks based on the task description.
+
+### Step D: Show Plan and Get Approval (BLOCKING)
 
 **⛔ DO NOT create branches or modify state without user approval.**
 
@@ -131,11 +160,16 @@ Description: $ARGUMENTS
 Type: {classified type}
 Branch: {type}/{slug}
 
+Subtasks:
+1. {subtask 1}
+2. {subtask 2}
+...
+
 Will do:
 1. Create feature branch from current branch
 2. Initialize task tracking in state.json
-3. Break down into subtasks
-4. {If Linear: Update issue status to In Progress}
+3. Begin work on first subtask
+{If Linear: 4. Update issue status to In Progress}
 ```
 
 Then ask for confirmation:
@@ -167,27 +201,16 @@ STOP - Do not continue
 ```
 
 **If "Yes, start task":**
-CONTINUE to Step B
+CONTINUE to Step E
 
-### Step B: Explore Codebase
-
-```
-USE Task(Explore) → find similar code, affected files
-READ agents/*.md → get domain patterns
-```
-
-### Step C: Classify Task
-
-Determine type: feature | bug | improvement | refactor | chore
-
-### Step D: Create Branch (if needed)
+### Step E: Create Branch (if needed)
 
 ```bash
-CURRENT_BRANCH=$(git branch --show-current)
+git branch --show-current
 ```
 
 ```
-IF CURRENT_BRANCH == "main" OR CURRENT_BRANCH == "master":
+IF current branch == "main" OR "master":
   OUTPUT: "Creating feature branch: {type}/{slug}"
 
   git checkout -b {type}/{slug}
@@ -197,8 +220,15 @@ IF CURRENT_BRANCH == "main" OR CURRENT_BRANCH == "master":
     STOP
 ```
 
+### Step F: Write State
+
+Generate UUID and timestamp:
 ```bash
-prjct work "$ARGUMENTS"
+# UUID
+node -e "console.log(require('crypto').randomUUID())"
+
+# Timestamp
+node -e "console.log(new Date().toISOString())"
 ```
 
 WRITE `{globalPath}/storage/state.json`:
@@ -206,25 +236,43 @@ WRITE `{globalPath}/storage/state.json`:
 {
   "currentTask": {
     "id": "{uuid}",
-    "description": "{subtask}",
+    "description": "{first subtask description}",
     "type": "{type}",
     "status": "active",
-    "startedAt": "{now}",
-    "subtasks": [...],
+    "startedAt": "{timestamp}",
+    "subtasks": [
+      {"description": "{subtask 1}", "status": "active"},
+      {"description": "{subtask 2}", "status": "pending"},
+      {"description": "{subtask 3}", "status": "pending"}
+    ],
     "currentSubtaskIndex": 0,
     "parentDescription": "$ARGUMENTS",
-    "linearId": "{identifier or null}",      // "PRJ-123" - Linear identifier
-    "linearUuid": "{uuid or null}"           // Linear internal UUID
-  }
+    "branch": "{type}/{slug}",
+    "linearId": "{identifier or null}",
+    "linearUuid": "{uuid or null}"
+  },
+  "pausedTasks": []
 }
 ```
 
-**Output**:
+### Step G: Log Event
+
+APPEND to `{globalPath}/memory/events.jsonl`:
+```json
+{"type":"task_started","taskId":"{uuid}","description":"$ARGUMENTS","timestamp":"{timestamp}","branch":"{branch}"}
+```
+
+---
+
+## Output
+
 ```
-{type}: $ARGUMENTS
+✅ {type}: $ARGUMENTS
 
 Branch: {branch} | Subtasks: {count}
 {linearId ? "Linear: {linearId} → In Progress" : ""}
 
+Current: {first subtask}
+
 Next: Work on subtask, then `p. done`
 ```

package/templates/commands/test.md

@@ -4,47 +4,90 @@ allowed-tools: [Bash, Read, Write]
 
 # p. test
 
+## Step 1: Detect Test Runner
+
+Check project files to determine the test runner:
+
 ```bash
-prjct context test
+# Check for package.json with test script
+if [ -f package.json ]; then
+  cat package.json | grep -o '"test"[[:space:]]*:' && echo "node"
+fi
+
+# Check for pytest
+if [ -f pytest.ini ] || [ -f pyproject.toml ]; then
+  echo "pytest"
+fi
+
+# Check for Cargo (Rust)
+if [ -f Cargo.toml ]; then
+  echo "cargo"
+fi
+
+# Check for Go
+if [ -f go.mod ]; then
+  echo "go"
+fi
+
+# Check for .NET
+if ls *.sln *.csproj 2>/dev/null | head -1; then
+  echo "dotnet"
+fi
 ```
 
-Detect test runner from project files:
-- package.json with scripts.test → npm/pnpm/yarn/bun test
-- pytest.ini/pyproject.toml → pytest
-- Cargo.toml → cargo test
-- go.mod → go test ./...
-- *.sln/*.csproj → dotnet test
+| Detected | Runner Command |
+|----------|----------------|
+| package.json with scripts.test | `npm test` or `bun test` or `pnpm test` |
+| pytest.ini / pyproject.toml | `pytest` |
+| Cargo.toml | `cargo test` |
+| go.mod | `go test ./...` |
+| *.sln / *.csproj | `dotnet test` |
+
+## Step 2: Run Tests
 
-Run tests:
 ```bash
 {runnerCmd} 2>&1
 ```
 
-Parse results: passed/failed count
+Parse results to count passed/failed tests.
 
-IF failed AND mode == "fix":
-  Try `{runnerCmd} -- -u` (update snapshots)
-  Re-run tests
+## Step 3: Handle Results
+
+**IF all tests pass:**
 
-**Output (pass)**:
 ```
 ✅ Tests passing
 
 Passed: {count}
-Coverage: {%}
+Coverage: {%} (if available)
 
 Next:
 - Code review → `p. review`
 - Ship → `p. ship`
 ```
 
-**Output (fail)**:
+**IF tests fail:**
+
 ```
 ❌ {failed} tests failing
 
-{test output}
+{test output - last 50 lines}
 
 Next:
-- Auto-fix → `p. test fix`
+- Auto-fix snapshots → `p. test fix`
 - Fix manually and re-run
 ```
+
+---
+
+## Fix Mode (`p. test fix`)
+
+IF mode == "fix":
+  Try updating snapshots:
+  ```bash
+  {runnerCmd} -- -u
+  # or for jest: npm test -- -u
+  # or for vitest: npx vitest --update
+  ```
+
+  Re-run tests to verify fix.