prjct-cli 1.22.0 → 1.24.0

package/templates/commands/sync.md

@@ -1,104 +0,0 @@
----
-allowed-tools: [Bash, Read, Write, AskUserQuestion]
----
-
-# p. sync
-
-## Step 1: Run sync with JSON output
-
-```bash
-prjct sync --json
-```
-
-Parse the JSON output to determine next action.
-
-## Step 2: Handle response
-
-**If `action: "no_changes"`:**
-```
-Output: "✅ Context is up to date"
-```
-
-**If `action: "confirm_required"`:**
-
-Show the diff summary to the user:
-
-```
-📋 Changes to context files:
-
-+ Added: {list added sections}
-~ Modified: {list modified sections}
-- Removed: {list removed sections}
-
-Tokens: {tokensBefore} → {tokensAfter} ({tokenDelta})
-```
-
-Then ask for confirmation:
-
-```
-AskUserQuestion:
-  question: "Apply these context changes?"
-  header: "Sync"
-  options:
-    - label: "Yes, apply changes"
-      description: "Update context files with the changes shown above"
-    - label: "No, cancel"
-      description: "Keep existing context files unchanged"
-    - label: "Show full diff"
-      description: "See detailed before/after for each section"
-```
-
-## Step 3: Apply based on response
-
-**If "Yes, apply changes":**
-```bash
-prjct sync --yes
-```
-
-**If "No, cancel":**
-```
-Output: "✅ Sync cancelled"
-```
-
-**If "Show full diff":**
-- Run `prjct sync --preview --json` to get full diff details
-- Display the full diff to user
-- Ask again with Yes/No options only
-
-## First sync (no existing files)
-
-When there's no existing context, the CLI will apply changes directly:
-
-```bash
-prjct sync --json
-```
-
-This returns success without needing confirmation.
-
-## Linear Sync (when enabled)
-
-```
-READ: .prjct/prjct.config.json → get projectId
-READ: {globalPath}/project.json → check integrations.linear.enabled
-
-IF integrations.linear.enabled:
-  # Sync Linear issues to local cache
-  RUN: bun $PRJCT_CLI/core/cli/linear.ts --project {projectId} sync
-
-  # Result stored in {globalPath}/storage/issues.json
-  OUTPUT: "Linear: {fetched} issues synced"
-```
-
-## Output
-
-```
-✅ Synced: {projectName}
-
-Ecosystem: {ecosystem}
-Agents: {count} generated
-Linear: {issueCount} issues synced (or "not enabled")
-
-Next:
-- Start work → `p. task "description"`
-- See queue → `p. next`
-```

package/templates/commands/task.md

@@ -1,312 +0,0 @@
----
-allowed-tools: [Read, Write, Bash, Task, Glob, Grep, AskUserQuestion]
----
-
-# p. task "$ARGUMENTS"
-
-## ⛔ MANDATORY PRE-FLIGHT CHECKS
-
-**Execute these checks BEFORE any task creation:**
-
-### Check 1: Validate Arguments
-
-```
-IF $ARGUMENTS is empty:
-  ASK: "What task do you want to start?"
-  WAIT for response
-  DO NOT proceed with empty 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
-
-IF currentTask exists AND currentTask.status == "active":
-  OUTPUT:
-  """
-  ⚠️ Active task detected: {currentTask.description}
-
-  Options:
-  1. Complete current task first → `p. done`
-  2. Pause current task → `p. pause`
-  3. Switch anyway (current task will be paused)
-  """
-
-  ASK: "What would you like to do?"
-  WAIT for explicit choice
-  DO NOT automatically switch tasks
-```
-
-### Check 4: Validate Git State
-
-```bash
-git status --porcelain
-```
-
-```
-IF uncommitted changes exist:
-  OUTPUT:
-  """
-  ⚠️ You have uncommitted changes:
-  {list of files}
-
-  Commit or stash them before starting a new task.
-  """
-
-  ASK: "Would you like to commit these changes first?"
-  WAIT for response
-```
-
----
-
-## Step 0: Detect Issue Tracker Reference
-
-IF `$ARGUMENTS` matches pattern `/^[A-Z]+-\d+$/` (e.g., PRJ-123, PROJ-456):
-
-**⛔ CRITICAL: READ LOCAL, WRITE REMOTE (Token Efficiency)**
-
-```
-READ: {globalPath}/project.json
-CHECK: integrations.linear OR integrations.jira
-
-IF integrations.linear.enabled:
-  # ═══════════════════════════════════════════════════════════════
-  # READ FROM LOCAL CACHE - NEVER call API for issue details
-  # This saves 1000s of tokens by not re-reading descriptions/AC
-  # ═══════════════════════════════════════════════════════════════
-
-  READ: {globalPath}/storage/issues.json
-  FIND: issue where identifier == "$ARGUMENTS"
-
-  IF issue NOT found in local cache:
-    # Only sync if issue not cached (rare case)
-    OUTPUT: "Issue not in cache. Syncing..."
-    RUN: prjct linear sync
-    READ: {globalPath}/storage/issues.json  # Re-read after sync
-
-  IF issue found:
-    # Use cached data - DO NOT re-fetch from API
-    SET: task.linearId = issue.identifier     # "PRJ-123"
-    SET: task.linearUuid = issue.id           # Linear internal UUID
-    SET: task.description = issue.title       # From cache, not API
-    SET: $ARGUMENTS = issue.title
-
-    # ═══════════════════════════════════════════════════════════════
-    # WRITE TO REMOTE - Only status updates go to API
-    # USE prjct CLI DIRECTLY - NOT $PRJCT_CLI (may be unset)
-    # ═══════════════════════════════════════════════════════════════
-    RUN: prjct linear start "{task.linearId}"
-
-    OUTPUT: "Linked to Linear: {issue.identifier} - {issue.title}"
-    OUTPUT: "Linear: → In Progress ✓"
-
-ELSE IF integrations.jira.enabled:
-  # ═══════════════════════════════════════════════════════════════
-  # READ FROM LOCAL CACHE - Same pattern as Linear
-  # ═══════════════════════════════════════════════════════════════
-
-  READ: {globalPath}/storage/issues.json
-  FIND: issue where externalId == "$ARGUMENTS"
-
-  IF issue NOT found in local cache:
-    OUTPUT: "Issue not in cache. Syncing..."
-    RUN: prjct jira sync
-    READ: {globalPath}/storage/issues.json
-
-  IF issue found:
-    SET: task.externalId = issue.externalId
-    SET: task.externalProvider = "jira"
-    SET: task.description = issue.title
-    SET: $ARGUMENTS = issue.title
-
-    # WRITE TO REMOTE - Only status update
-    # USE prjct CLI DIRECTLY
-    RUN: prjct jira transition "$ARGUMENTS" "In Progress"
-
-    OUTPUT: "Linked to JIRA: {issue.externalId} - {issue.title}"
-    OUTPUT: "JIRA: In Progress"
-
-ELSE:
-  OUTPUT: "Issue tracker not configured. Run `p. linear setup` or `p. jira setup`"
-```
-
----
-
-## Main Flow
-
-### 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 C.5: Define Expected Value
-
-**Before showing the plan, identify expected outcomes:**
-
-Based on exploration and task analysis, determine:
-- **Expected value type**: feature | bugfix | performance | dx | refactor | infrastructure
-- **Expected impact**: high | medium | low
-- **Success criteria**: What makes this task "done well" (1-2 bullet points)
-
-This will be stored in state.json and compared against actual outcomes in `p. done`.
-
-### Step D: Show Plan and Get Approval (BLOCKING)
-
-**⛔ DO NOT create branches or modify state without user approval.**
-
-Show the user:
-```
-## Task Plan
-
-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. Begin work on first subtask
-{If Linear: 4. Update issue status to In Progress}
-```
-
-Then ask for confirmation:
-
-```
-AskUserQuestion:
-  question: "Start this task?"
-  header: "Task"
-  options:
-    - label: "Yes, start task (Recommended)"
-      description: "Create branch and begin tracking"
-    - label: "No, cancel"
-      description: "Don't create task"
-    - label: "Modify plan"
-      description: "Change type, branch name, or subtasks"
-```
-
-**Handle responses:**
-
-**If "Modify plan":**
-- Ask: "What would you like to change?"
-- Update plan accordingly
-- Ask again with Yes/No options only
-
-**If "No, cancel":**
-```
-OUTPUT: "✅ Task creation cancelled"
-STOP - Do not continue
-```
-
-**If "Yes, start task":**
-CONTINUE to Step E
-
-### Step E: Create Branch (if needed)
-
-```bash
-git branch --show-current
-```
-
-```
-IF current branch == "main" OR "master":
-  OUTPUT: "Creating feature branch: {type}/{slug}"
-
-  git checkout -b {type}/{slug}
-
-  IF git command fails:
-    OUTPUT: "Failed to create branch. Check git status."
-    STOP
-```
-
-### Step F: Write State
-
-Generate UUID and timestamp:
-```bash
-# UUID
-node -e "console.log(require('crypto').randomUUID())"
-
-# Timestamp
-node -e "console.log(new Date().toISOString())"
-```
-
-WRITE `{globalPath}/storage/state.json`:
-```json
-{
-  "currentTask": {
-    "id": "{uuid}",
-    "description": "{first subtask description}",
-    "type": "{type}",
-    "status": "active",
-    "startedAt": "{timestamp}",
-    "subtasks": [
-      {"description": "{subtask 1}", "status": "active"},
-      {"description": "{subtask 2}", "status": "pending"},
-      {"description": "{subtask 3}", "status": "pending"}
-    ],
-    "currentSubtaskIndex": 0,
-    "parentDescription": "$ARGUMENTS",
-    "branch": "{type}/{slug}",
-    "linearId": "{identifier or null}",
-    "linearUuid": "{uuid or null}",
-    "expectedValue": {
-      "type": "{feature|bugfix|performance|dx|refactor|infrastructure}",
-      "impact": "{high|medium|low}",
-      "successCriteria": ["criterion 1", "criterion 2"]
-    }
-  },
-  "pausedTasks": []
-}
-```
-
-### 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
-
-Branch: {branch} | Subtasks: {count}
-{linearId ? "Linear: {linearId} → In Progress" : ""}
-
-Current: {first subtask}
-
-Next: Work on subtask, then `p. done`
-```

package/templates/commands/test.md

@@ -1,93 +0,0 @@
----
-allowed-tools: [Bash, Read, Write]
----
-
-# p. test
-
-## Step 1: Detect Test Runner
-
-Check project files to determine the test runner:
-
-```bash
-# 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
-```
-
-| 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
-
-```bash
-{runnerCmd} 2>&1
-```
-
-Parse results to count passed/failed tests.
-
-## Step 3: Handle Results
-
-**IF all tests pass:**
-
-```
-✅ Tests passing
-
-Passed: {count}
-Coverage: {%} (if available)
-
-Next:
-- Code review → `p. review`
-- Ship → `p. ship`
-```
-
-**IF tests fail:**
-
-```
-❌ {failed} tests failing
-
-{test output - last 50 lines}
-
-Next:
-- 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.

package/templates/commands/update.md

@@ -1,63 +0,0 @@
----
-allowed-tools: [Bash, Read, Write, Glob]
-description: 'Force update prjct-cli - sync all templates from npm package'
----
-
-# p. update - Force Update prjct-cli
-
-Manually sync all templates from npm package to local installation.
-
-## Step 1: Find npm package location
-
-```bash
-npm root -g
-```
-
-Save this path as `NPM_ROOT`.
-
-## Step 2: Copy p.md router
-
-Read: `{NPM_ROOT}/prjct-cli/templates/commands/p.md`
-Write to: `~/.claude/commands/p.md`
-
-## Step 3: Copy ALL command templates
-
-For each `.md` file in `{NPM_ROOT}/prjct-cli/templates/commands/`:
-- Read the file
-- Write to `~/.claude/commands/p/{filename}`
-
-## Step 4: Update CLAUDE.md
-
-Read: `{NPM_ROOT}/prjct-cli/templates/global/CLAUDE.md`
-
-Check if `~/.claude/CLAUDE.md` exists:
-- If NOT exists: Write the template content directly
-- If exists: Find markers `<!-- prjct:start -->` and `<!-- prjct:end -->`, replace content between them
-
-## Step 5: Copy statusline
-
-Copy from `{NPM_ROOT}/prjct-cli/assets/statusline/` to `~/.prjct-cli/statusline/`:
-- `statusline.sh`
-- `lib/*.sh`
-- `components/*.sh`
-- `themes/*.json`
-
-## Step 6: Get version and confirm
-
-```bash
-cat "$(npm root -g)/prjct-cli/package.json" | grep '"version"'
-```
-
-## Output
-
-```
-✅ prjct-cli updated
-
-Commands: synced to ~/.claude/commands/p/
-Config: ~/.claude/CLAUDE.md updated
-Statusline: ~/.prjct-cli/statusline/ updated
-```
-
-## Action
-
-NOW execute steps 1-6 in order. Use Bash to find npm root, then Read/Write to copy files.