prjct-cli 0.42.0 → 0.44.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "0.42.0",
+  "version": "0.44.1",
   "description": "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
   "main": "core/index.ts",
   "bin": {

package/templates/_bases/tracker-base.md

@@ -9,6 +9,17 @@ description: 'Base template for issue tracker integrations'
 
 All issue tracker integrations (Linear, JIRA, GitHub Issues, Monday.com) inherit from this base.
 
+## CRITICAL - SDK vs MCP
+
+| Tracker | Method | Why |
+|---------|--------|-----|
+| **Linear** | **SDK ONLY** | Per-project credentials, 4x faster |
+| **JIRA** | **SDK ONLY** | Per-project credentials, 4x faster |
+| GitHub | MCP | Simple token auth |
+| Monday | MCP | OAuth only |
+
+**For Linear and JIRA**: NEVER use MCP tools (`mcp__linear__*`, `mcp__jira__*`). ALWAYS use the SDK CLI helper.
+
 ---
 
 ## Common Context Variables

package/templates/commands/done.md

@@ -26,20 +26,25 @@ WRITE `{globalPath}/storage/state.json`
 
 ## Sync Issue Tracker Status
 
-IF `currentTask.externalId` exists:
+IF `currentTask.linearId` exists:
 
 ```
-IF currentTask.externalProvider == "linear":
-  # Update Linear issue to Done
-  IMPORT: linearService from core/integrations/linear
-  CALL: linearService.markDone(currentTask.externalId)
-  OUTPUT: "Linear: {externalId} → Done"
-
-ELSE IF currentTask.externalProvider == "jira":
-  # Update JIRA issue to Done
-  IMPORT: jiraService from core/integrations/jira
-  CALL: jiraService.markDone(currentTask.externalId)
-  OUTPUT: "JIRA: {externalId} → Done"
+# Update Linear issue to Done using sync layer
+# This updates both Linear API and local issues.json cache
+
+IMPORT: linearSync from core/integrations/linear
+CALL: linearSync.pushStatus(projectId, currentTask.linearId, 'done')
+
+OUTPUT: "Linear: {linearId} → Done"
+```
+
+ELSE IF `currentTask.externalId` AND `currentTask.externalProvider == "jira"`:
+
+```
+# Update JIRA issue to Done
+IMPORT: jiraService from core/integrations/jira
+CALL: jiraService.markDone(currentTask.externalId)
+OUTPUT: "JIRA: {externalId} → Done"
 ```
 
 ---
@@ -49,7 +54,7 @@ ELSE IF currentTask.externalProvider == "jira":
 {task} ({duration})
 
 Files: {count} | Commits: {count}
-{externalId ? "{externalProvider}: {externalId} → Done" : ""}
+{linearId ? "Linear: {linearId} → Done" : ""}
 
 Next:
 - More work? → `p. task "description"`

package/templates/commands/git.md

@@ -1,5 +1,5 @@
 ---
-allowed-tools: [Bash, Read, Write]
+allowed-tools: [Bash, Read, Write, AskUserQuestion]
 description: 'Smart git operations with context'
 architecture: 'Write-Through (JSON → MD → Events)'
 storage-layer: true
@@ -8,11 +8,11 @@ source-of-truth: 'storage/state.json'
 
 # /p:git - Smart Git Operations
 
-## Architecture: Write-Through Pattern
+## ⛔ MANDATORY WORKFLOW - FOLLOW STEPS IN ORDER
 
-Reads from **Storage (JSON)** as source of truth.
+**All git operations through prjct MUST follow these rules.**
 
-**Source of Truth**: `storage/state.json`
+---
 
 ## Usage
 
@@ -23,6 +23,33 @@ Reads from **Storage (JSON)** as source of truth.
 /p:git undo         # Undo last commit
 ```
 
+## ⛔ GLOBAL BLOCKING RULES
+
+### Rule 1: Protected Branch Check (ALL OPERATIONS)
+
+```bash
+CURRENT_BRANCH=$(git branch --show-current)
+```
+
+**⛔ IF branch is `main` or `master`:**
+```
+For commit: STOP. "Cannot commit on main. Create a feature branch."
+For push: STOP. "Cannot push to main. Use p. ship to create PR."
+ABORT the operation entirely.
+```
+
+### Rule 2: Dirty Working Directory
+
+```bash
+git status --porcelain
+```
+
+**⛔ IF uncommitted changes AND operation is push/sync:**
+```
+STOP. "Uncommitted changes detected. Commit first with p. git commit."
+ABORT.
+```
+
 ## Context Variables
 - `{projectId}`: From `.prjct/prjct.config.json`
 - `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
@@ -31,65 +58,129 @@ Reads from **Storage (JSON)** as source of truth.
 
 ## Flow: commit
 
-### Step 1: Validate Branch
-READ: `.prjct/prjct.config.json` → extract `projectId`
-SET: `{globalPath}` = `~/.prjct-cli/projects/{projectId}`
+### Step 1: Pre-flight Checks (BLOCKING)
+
+```bash
+# Get current branch
+CURRENT_BRANCH=$(git branch --show-current)
+```
+
+**⛔ IF on main/master:**
+```
+STOP. DO NOT PROCEED.
+OUTPUT: "Cannot commit on protected branch: {currentBranch}"
+OUTPUT: "Create a feature branch first with: p. task 'description'"
+ABORT.
+```
+
+```bash
+# Check for changes
+git status --porcelain
+```
+
+**⛔ IF no changes:**
+```
+STOP. DO NOT PROCEED.
+OUTPUT: "Nothing to commit."
+ABORT.
+```
+
+### Step 2: Show Plan and Get Approval (BLOCKING)
+
+```bash
+git diff --stat
+```
+
+```
+OUTPUT:
+"""
+## Commit Plan
+
+Branch: {currentBranch}
+Changes:
+{git diff --stat output}
 
-READ: `{globalPath}/storage/state.json`
-IF currentTask AND currentTask.branch:
-  SET: {expectedBranch} = currentTask.branch.name
-ELSE:
-  SET: {expectedBranch} = null
+Will create commit with prjct footer.
+Proceed? (yes/no)
+"""
 
-BASH: `git branch --show-current`
-SET: {currentBranch} = result
+WAIT for explicit approval.
+DO NOT assume.
+```
 
-IF {currentBranch} == "main" OR {currentBranch} == "master":
-  OUTPUT:
-  ```
-  ⚠️ Cannot commit on protected branch: {currentBranch}
+### Step 3: Stage and Commit
 
-  Start a task first with /p:now "task name" to create a feature branch.
-  ```
-  STOP
+```bash
+git add .
+git commit -m "$(cat <<'EOF'
+{type}: {description}
 
-IF {expectedBranch} AND {currentBranch} != {expectedBranch}:
-  OUTPUT:
-  ```
-  ⚠️ Branch mismatch
+Generated with [p/](https://www.prjct.app/)
+EOF
+)"
+```
 
-  Current: {currentBranch}
-  Expected: {expectedBranch}
+**⛔ The prjct footer is MANDATORY. No exceptions.**
 
-  Switch to the correct branch: git checkout {expectedBranch}
-  ```
-  STOP
+### Step 4: Log to Memory
 
-### Step 2: Stage and Commit
-1. Git: `add .` → stage changes
-2. Create: commit message with prjct metadata
-3. Commit: with message
-4. Log: `memory/events.jsonl`
+APPEND to `{globalPath}/memory/events.jsonl`
 
 ## Flow: push
 
-### Step 1: Check Protected Branch
-BASH: `git branch --show-current`
-SET: {currentBranch} = result
+### Step 1: Pre-flight Checks (BLOCKING)
+
+```bash
+CURRENT_BRANCH=$(git branch --show-current)
+```
+
+**⛔ IF on main/master:**
+```
+STOP. DO NOT PROCEED.
+OUTPUT: "Cannot push directly to main/master."
+OUTPUT: "Use `p. ship` to create a Pull Request instead."
+ABORT.
+```
+
+```bash
+git status --porcelain
+```
+
+**⛔ IF uncommitted changes:**
+```
+STOP. DO NOT PROCEED.
+OUTPUT: "Uncommitted changes detected. Commit first."
+ABORT.
+```
+
+### Step 2: Show Plan and Get Approval (BLOCKING)
 
-IF {currentBranch} == "main" OR {currentBranch} == "master":
-  OUTPUT:
-  ```
-  ⚠️ Cannot push directly to protected branch: {currentBranch}
+```bash
+git log origin/{currentBranch}..HEAD --oneline 2>/dev/null || git log --oneline -3
+```
+
+```
+OUTPUT:
+"""
+## Push Plan
 
-  Use /p:ship to create a Pull Request instead.
-  ```
-  STOP
+Branch: {currentBranch}
+Commits to push:
+{commits}
+
+Proceed? (yes/no)
+"""
+
+WAIT for explicit approval.
+```
+
+### Step 3: Execute Push
+
+```bash
+git push -u origin {currentBranch}
+```
 
-### Step 2: Push
-1. Git: `status` → verify clean
-2. Git: `push -u origin {currentBranch}` with branch tracking
-3. Handle: errors (upstream, conflicts)
+**IF push fails:** Show error and STOP. Do not retry automatically.
 
 ## Flow: sync
 
@@ -106,20 +197,18 @@ IF {currentBranch} == "main" OR {currentBranch} == "master":
 
 {details if any}
 
-🤖 Generated with [p/](https://www.prjct.app/)
-Designed for [Claude](https://www.anthropic.com/claude)
+Generated with [p/](https://www.prjct.app/)
 
 ```
 
-**NON-NEGOTIABLE: The `🤖 Generated with [p/]` line MUST appear in ALL commits.**
+**NON-NEGOTIABLE: The `Generated with [p/]` line MUST appear in ALL commits.**
 
 Use HEREDOC for proper formatting:
 ```bash
 git commit -m "$(cat <<'EOF'
 {type}: {description}
 
-🤖 Generated with [p/](https://www.prjct.app/)
-Designed for [Claude](https://www.anthropic.com/claude)
+Generated with [p/](https://www.prjct.app/)
 
 EOF
 )"

package/templates/commands/merge.md

@@ -1,38 +1,146 @@
 ---
-allowed-tools: [Bash, Read, Write]
+allowed-tools: [Bash, Read, Write, AskUserQuestion]
 ---
 
 # p. merge
 
+## ⛔ MANDATORY WORKFLOW - DO NOT SKIP ANY STEP
+
+---
+
+### STEP 1: Pre-flight Checks (BLOCKING)
+
+```bash
+# 1a. Check if there's an active task with a PR
+```
+
+**⛔ IF no `currentTask`:**
+```
+STOP. DO NOT PROCEED.
+Tell user: "No active task. Use p. task first."
+ABORT.
+```
+
+**⛔ IF no PR number in task state:**
+```
+STOP. DO NOT PROCEED.
+Tell user: "No PR found. Run p. ship first to create a PR."
+ABORT.
+```
+
+---
+
+### STEP 2: Check PR Status (BLOCKING)
+
 ```bash
-prjct context merge
+gh pr view {prNumber} --json reviewDecision,mergeable,state,statusCheckRollup
+```
+
+**⛔ IF PR is not approved:**
+```
+STOP. DO NOT PROCEED.
+Tell user: "PR needs approval. Get reviews first."
+Show: gh pr view {prNumber} --web
+ABORT.
+```
+
+**⛔ IF PR has merge conflicts:**
+```
+STOP. DO NOT PROCEED.
+Tell user: "PR has conflicts. Resolve them first:
+  git checkout {branch}
+  git pull origin main
+  # fix conflicts
+  git push"
+ABORT.
+```
+
+**⛔ IF CI checks are failing:**
+```
+STOP. DO NOT PROCEED.
+Tell user: "CI checks are failing. Fix them first."
+Show failing checks.
+ABORT.
+```
+
+---
+
+### STEP 3: Show Plan and Get Approval (BLOCKING)
+
+Show the user:
+```
+## Merge Plan
+
+PR: #{prNumber} - {title}
+Branch: {branch} → main
+Strategy: squash
+
+Will do:
+1. Merge PR with squash
+2. Delete feature branch
+3. Update local main
+
+Proceed? (yes/no)
 ```
 
-IF no `currentTask` → "No active task"
-IF no PR → "Run p. review first"
+**⛔ WAIT for explicit approval. Do not assume.**
+
+---
+
+### STEP 4: Execute Merge
 
 ```bash
-gh pr view {prNumber} --json reviewDecision,mergeable,state
+gh pr merge {prNumber} --squash --delete-branch
 ```
 
-IF not approved → "Get approvals first"
-IF has conflicts → "Resolve conflicts first"
+---
+
+### STEP 5: Update Local
 
 ```bash
-gh pr merge {prNumber} --squash --auto
-git checkout main && git pull
+git checkout main
+git pull origin main
+```
+
+---
+
+### STEP 6: Update Task State
+
+- Set `currentTask.status = "merged"`
+- Set `currentTask.mergedAt = {now}`
+- Clear PR reference
+
+---
+
+### STEP 7: Update Linear (if applicable)
+
+IF `currentTask.linearId`:
 ```
+Update Linear issue status to "Done" or "Merged"
+Add comment: "PR #{prNumber} merged"
+```
+
+---
 
-Delete branch if created by prjct
+## Output Format
 
-**Output**:
 ```
-✅ PR Merged
+✅ Merged: {title}
 
 PR: #{prNumber}
 Strategy: squash
+Branch: {branch} (deleted)
 
 Next:
-- Release → `p. ship`
 - New task → `p. task "description"`
+- See backlog → `p. next`
 ```
+
+---
+
+## ⛔ VIOLATIONS
+
+- ❌ Merging without PR approval
+- ❌ Merging with failing CI
+- ❌ Merging with conflicts
+- ❌ Not waiting for user approval

package/templates/commands/review.md

@@ -151,7 +151,7 @@ ELSE:
 {mcpScore}/100
 
 ---
-🤖 Generated with [p/](https://www.prjct.app/)
+Generated with [p/](https://www.prjct.app/)
 """
   
   BASH: `gh pr create --title "{prTitle}" --base {baseBranch} --body "$(cat <<'PREOF'