prjct-cli 0.10.14 → 0.11.1

package/templates/commands/redo.md

@@ -0,0 +1,142 @@
+---
+allowed-tools: [Read, Write, Bash]
+description: 'Redo previously undone changes'
+timestamp-rule: 'GetTimestamp() for ALL timestamps'
+---
+
+# /p:redo - Redo Previously Undone Snapshot
+
+## Overview
+Restores a previously undone snapshot. Only works if you have recently used /p:undo.
+
+## Context Variables
+- `{projectId}`: From `.prjct/prjct.config.json`
+- `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
+- `{snapshotDir}`: `{globalPath}/snapshots`
+- `{memoryPath}`: `{globalPath}/memory/context.jsonl`
+- `{redoStackPath}`: `{snapshotDir}/redo-stack.json`
+
+## 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: Check Redo Stack
+
+READ: `{redoStackPath}`
+
+IF file not found OR empty OR equals "[]":
+  OUTPUT: "⚠️ Nothing to redo. Use /p:undo first."
+  STOP
+
+PARSE as JSON array
+GET last item as {redoSnapshot}
+
+IF array is empty:
+  OUTPUT: "⚠️ Nothing to redo. Use /p:undo first."
+  STOP
+
+EXTRACT from {redoSnapshot}:
+- `{redoHash}`: hash
+- `{redoMessage}`: message
+- `{redoTimestamp}`: timestamp
+
+## Step 3: Get Current State
+
+BASH: `cd {snapshotDir} && git rev-parse HEAD`
+CAPTURE as {currentHash}
+
+BASH: `cd {snapshotDir} && git log -1 --pretty=format:'%s' {currentHash}`
+CAPTURE as {currentMessage}
+
+## Step 4: Get Files That Will Change
+
+BASH: `cd {snapshotDir} && git diff --name-only {currentHash} {redoHash}`
+CAPTURE as {affectedFiles}
+
+COUNT files as {fileCount}
+
+## Step 5: Restore Redo Snapshot
+
+### Checkout files from redo snapshot
+BASH: `cd {snapshotDir} && git checkout {redoHash} -- .`
+
+### Copy files back to project
+For each file in {affectedFiles}:
+  - Source: `{snapshotDir}/{file}`
+  - Destination: `{projectPath}/{file}`
+  - Copy content
+
+## Step 6: Remove from Redo Stack
+
+READ: `{redoStackPath}`
+PARSE as JSON array
+REMOVE last item
+WRITE: `{redoStackPath}`
+
+## Step 7: Log to Memory
+
+APPEND to: `{memoryPath}`
+
+Single line (JSONL):
+```json
+{"timestamp":"{GetTimestamp()}","action":"snapshot_redo","from":"{currentHash}","to":"{redoHash}","files":{fileCount}}
+```
+
+## Step 8: Log to Manifest
+
+APPEND to: `{snapshotDir}/manifest.jsonl`
+
+Single line (JSONL):
+```json
+{"type":"redo","from":"{currentHash}","to":"{redoHash}","timestamp":"{GetTimestamp()}","files":{fileCount}}
+```
+
+## Output
+
+SUCCESS:
+```
+⏩ Redone: {redoMessage}
+
+Restored from: {currentMessage}
+Files affected: {fileCount}
+
+/p:undo to undo again | /p:history to see all snapshots
+```
+
+## Error Handling
+
+| Error | Response | Action |
+|-------|----------|--------|
+| No redo stack | "Nothing to redo" | STOP |
+| Empty redo stack | "Nothing to redo" | STOP |
+| Git error | Show error message | STOP |
+| File copy fails | "Failed to restore {file}" | CONTINUE |
+
+## Examples
+
+### Example 1: Successful Redo
+```
+⏩ Redone: Ship authentication feature
+
+Restored from: Add login form
+Files affected: 5
+
+/p:undo to undo again | /p:history to see all snapshots
+```
+
+### Example 2: Nothing to Redo
+```
+⚠️ Nothing to redo. Use /p:undo first.
+```
+
+## Notes
+
+- Redo only works after /p:undo
+- Creating a new snapshot clears the redo stack
+- Multiple redos are possible if you undid multiple times
+- Redo stack is project-specific

package/templates/commands/resume.md

@@ -1,97 +1,201 @@
 ---
-allowed-tools: [Read, Write, GetTimestamp]
-description: 'Resume paused task'
-timestamp-rule: 'GetTimestamp() for resumed'
+allowed-tools: [Read, Write, Bash]
+description: 'Resume paused session'
+timestamp-rule: 'GetTimestamp() for all timestamps'
 ---
 
-# /p:resume
+# /p:resume - Resume Paused Session
+
+## Context Variables
+- `{projectId}`: From `.prjct/prjct.config.json`
+- `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
+- `{sessionPath}`: `{globalPath}/sessions/current.json`
+- `{nowPath}`: `{globalPath}/core/now.md`
+- `{memoryPath}`: `{globalPath}/memory/context.jsonl`
+
+## 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: Check Session State
+
+READ: `{sessionPath}`
+
+IF file not found OR empty:
+  OUTPUT:
+  ```
+  ⚠️ No paused session to resume.
+
+  Start a new task:
+  • /p:now <task>
+  ```
+  STOP
+
+PARSE as JSON → {session}
+
+IF {session.status} == "active":
+  CALCULATE: {elapsed} = time since last start/resume
+  OUTPUT:
+  ```
+  ▶️ Already active: {session.task}
+
+  Session: {session.id}
+  Working for: {elapsed}
+
+  /p:done to complete | /p:pause to pause
+  ```
+  STOP
+
+IF {session.status} == "completed":
+  OUTPUT:
+  ```
+  ⚠️ Session already completed.
+
+  Start a new task:
+  • /p:now <task>
+  ```
+  STOP
+
+IF {session.status} != "paused":
+  OUTPUT: "⚠️ No paused session to resume."
+  STOP
+
+## Step 3: Calculate Pause Duration
+
+SET: {now} = GetTimestamp()
+SET: {pauseDuration} = time since {session.pausedAt}
+SET: {pauseFormatted} = format as "Xh Ym" or "Xm"
+
+## Step 4: Update Session
+
+UPDATE {session}:
+```json
+{
+  "id": "{session.id}",
+  "projectId": "{session.projectId}",
+  "task": "{session.task}",
+  "status": "active",
+  "startedAt": "{session.startedAt}",
+  "pausedAt": null,
+  "completedAt": null,
+  "duration": {session.duration},
+  "metrics": {session.metrics},
+  "timeline": [
+    ...{session.timeline},
+    {"type": "resume", "at": "{now}"}
+  ]
+}
+```
 
-## Check
-- Requires paused tasks
-- Blocks if active exists
+WRITE: `{sessionPath}`
+Content: Updated session JSON
 
-## Flow
-1. Select: last/ID/# → Set status='active', resumed={GetTimestamp()}
-2. Update stack.jsonl + now.md → Log resume
+## Step 5: Update Legacy now.md
 
-## Response
-`▶️ {task} | Paused: {duration} | {agent} | Done: /p:done`
+WRITE: `{nowPath}`
+Content:
+```markdown
+# NOW
 
-## Examples
+**{session.task}**
 
-### Resume last paused
-```
-/p:resume
-→ Resumes most recently paused task
-→ Picks up exactly where you left off
+Started: {session.startedAt}
+Resumed: {now}
+Session: {session.id}
 ```
 
-### Resume specific task
-```
-/p:resume task-1234567890
-→ Resumes task by ID
-```
+## Step 6: Log to Memory
 
-### Resume by number
+APPEND to: `{memoryPath}`
+
+Single line (JSONL):
+```json
+{"timestamp":"{now}","action":"session_resumed","sessionId":"{session.id}","task":"{session.task}","pauseDuration":{pauseDurationSeconds}}
 ```
-/p:resume 2
-→ Resumes 2nd task from paused list
-→ Useful when shown list by /p:stack
+
+## Output
+
+SUCCESS:
 ```
+▶️ Resumed: {session.task}
 
-## Stack Display Format
+Session: {session.id}
+Was paused: {pauseFormatted}
+Total active: {session.duration} (before this stretch)
 
-When multiple paused tasks exist:
+/p:done when finished | /p:pause for another break
 ```
-⏸️  Paused tasks (3):
 
-1. Fix login validation bug
-   Paused 10m ago | Active time: 45m
+## Error Handling
 
-2. Implement dark mode toggle
-   Paused 2h ago | Active time: 1h 20m
+| Error | Response | Action |
+|-------|----------|--------|
+| No project | "No prjct project" | STOP |
+| No session | "No paused session" | STOP |
+| Already active | Show active state | STOP |
+| Already completed | Suggest /p:now | STOP |
+| Write fails | Log warning | CONTINUE |
 
-3. Update documentation
-   Paused yesterday | Active time: 30m
+## Examples
 
-Resume: /p:resume {1-3}
+### Example 1: Resume Paused Session
+**Session:**
+```json
+{
+  "id": "sess_abc12345",
+  "task": "implement auth",
+  "status": "paused",
+  "pausedAt": "2025-12-07T12:30:00.000Z",
+  "duration": 9000,
+  "timeline": [
+    {"type": "start", "at": "2025-12-07T10:00:00.000Z"},
+    {"type": "pause", "at": "2025-12-07T12:30:00.000Z"}
+  ]
+}
 ```
 
-## Natural Language Support
+**Current time:** 2:00 PM (paused 1.5h ago)
 
-Detect intent for resume:
-- "p. resume" → Resume last paused
-- "p. continue" → Resume last paused
-- "p. back to {task}" → Resume matching task
-- "p. resume 2" → Resume task #2
+**Output:**
+```
+▶️ Resumed: implement auth
 
-## Error Handling
+Session: sess_abc12345
+Was paused: 1h 30m
+Total active: 2h 30m (before this stretch)
 
-### No paused tasks
+/p:done when finished | /p:pause for another break
 ```
-❌ No paused tasks to resume
-
-See what's in queue:
-→ /p:next
 
-Start new task:
-→ /p:work "{task}"
+### Example 2: Already Active
+**Output:**
 ```
+▶️ Already active: implement auth
 
-### Active task exists
+Session: sess_abc12345
+Working for: 45m
+
+/p:done to complete | /p:pause to pause
 ```
-❌ Already working on: {current_task}
 
-Options:
-→ /p:done (complete current)
-→ /p:pause (pause current)
-→ /p:switch {task_id} (atomic switch)
+### Example 3: No Paused Session
+**Output:**
 ```
+⚠️ No paused session to resume.
 
-### Invalid task ID
+Start a new task:
+• /p:now <task>
 ```
-❌ Task {id} not found or not paused
 
-See paused tasks:
-→ /p:stack
-```
+## Natural Language Support
+
+Detect intent for resume:
+- "p. resume" → Resume paused session
+- "p. continue" → Resume paused session
+- "p. back to work" → Resume paused session
+- "p. unpause" → Resume paused session

package/templates/commands/serve.md

@@ -0,0 +1,121 @@
+---
+allowed-tools: [Bash]
+description: 'Start prjct web server'
+---
+
+# /p:serve - Start Web Server
+
+## Overview
+Starts the prjct web interface with Claude Code CLI integration.
+
+**CRITICAL**: Uses your Claude subscription via PTY - NO API costs!
+
+## Usage
+
+```bash
+# Start with defaults (port 3333)
+prjct-serve
+
+# Custom port
+prjct-serve --port=8080
+```
+
+## What It Does
+
+1. **Starts API Server** (Hono)
+   - REST endpoints for projects, sessions, tasks
+   - WebSocket for Claude Code CLI interaction
+   - SSE for real-time updates
+
+2. **Starts Web App** (React + Vite)
+   - Dashboard with metrics
+   - Terminal with xterm.js
+   - Session history
+
+3. **PTY Manager**
+   - Spawns Claude Code CLI in pseudo-terminal
+   - Streams I/O via WebSocket
+   - Uses YOUR subscription - $0 API costs
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  Browser (localhost:3000)                               │
+│  ┌─────────────────────────────────────────────────┐   │
+│  │  React App                                       │   │
+│  │  ├── Dashboard (metrics, projects)              │   │
+│  │  ├── Terminal (xterm.js)                        │   │
+│  │  └── Sessions (history)                         │   │
+│  └─────────────────────────────────────────────────┘   │
+│                         │                               │
+│                    WebSocket                            │
+│                         │                               │
+│  ┌─────────────────────────────────────────────────┐   │
+│  │  Hono Server (localhost:3333)                   │   │
+│  │  ├── /api/projects                              │   │
+│  │  ├── /api/sessions                              │   │
+│  │  ├── /api/claude/sessions                       │   │
+│  │  └── /ws/claude/:sessionId                      │   │
+│  └─────────────────────────────────────────────────┘   │
+│                         │                               │
+│                   PTY (node-pty)                        │
+│                         │                               │
+│  ┌─────────────────────────────────────────────────┐   │
+│  │  Claude Code CLI                                │   │
+│  │  (your subscription, no API costs)              │   │
+│  └─────────────────────────────────────────────────┘   │
+└─────────────────────────────────────────────────────────┘
+```
+
+## Endpoints
+
+### REST API
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/api/projects` | GET | List all projects |
+| `/api/projects/:id` | GET | Get project details |
+| `/api/projects/:id/status` | GET | Get project status |
+| `/api/sessions` | GET | List sessions |
+| `/api/sessions/current` | GET | Get current session |
+| `/api/sessions` | POST | Create session |
+| `/api/sessions/:id/pause` | POST | Pause session |
+| `/api/sessions/:id/resume` | POST | Resume session |
+| `/api/sessions/:id/complete` | POST | Complete session |
+| `/api/claude/status` | GET | Check Claude CLI availability |
+| `/api/claude/sessions` | GET | List PTY sessions |
+| `/api/claude/sessions` | POST | Create PTY session |
+
+### WebSocket
+
+| Endpoint | Description |
+|----------|-------------|
+| `/ws/claude/:sessionId` | Real-time Claude CLI interaction |
+
+**Messages:**
+- `{ type: 'input', data: string }` - Send input to CLI
+- `{ type: 'resize', cols: number, rows: number }` - Resize terminal
+- `{ type: 'output', data: string }` - Receive CLI output
+
+## Requirements
+
+- Node.js 18+
+- Claude Code CLI installed (`claude` command available)
+- Active Claude subscription (Max or similar)
+
+## Output
+
+```
+╔═══════════════════════════════════════════════════════════╗
+║                                                           ║
+║   ⚡ prjct - Developer Momentum                          ║
+║                                                           ║
+║   API:     http://localhost:3333                          ║
+║   Web:     http://localhost:3000                          ║
+║   Claude:  ws://localhost:3333/ws/claude                  ║
+║                                                           ║
+║   Using your Claude subscription - $0 API costs           ║
+║                                                           ║
+╚═══════════════════════════════════════════════════════════╝
+```

package/templates/commands/ship.md

@@ -11,6 +11,7 @@ timestamp-rule: 'GetTimestamp() and GetDate() for ALL timestamps'
 - `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
 - `{shippedPath}`: `{globalPath}/progress/shipped.md`
 - `{memoryPath}`: `{globalPath}/memory/context.jsonl`
+- `{snapshotDir}`: `{globalPath}/snapshots`
 - `{feature}`: User-provided feature name
 
 ## Step 1: Read Config
@@ -187,6 +188,48 @@ Single line (JSONL):
 {"timestamp":"{GetTimestamp()}","action":"feature_shipped","feature":"{feature}","version":"{newVersion}"}
 ```
 
+## Step 11: Create Snapshot (Undo/Redo Support)
+
+This creates a snapshot for the undo/redo system.
+
+### Initialize Snapshot Directory
+BASH: `mkdir -p {snapshotDir}`
+
+### Check if Git Repo Exists
+BASH: `ls {snapshotDir}/.git 2>/dev/null || echo "INIT_NEEDED"`
+
+IF output contains "INIT_NEEDED":
+  BASH: `cd {snapshotDir} && git init && git config user.email "prjct@local" && git config user.name "prjct-snapshots" && git commit --allow-empty -m "init: snapshot system"`
+
+### Copy Changed Files to Snapshot
+BASH: `git diff --name-only HEAD~1 2>/dev/null || git diff --name-only`
+CAPTURE as {changedFiles}
+
+For each file in {changedFiles}:
+  - Source: `{projectPath}/{file}`
+  - Destination: `{snapshotDir}/{file}`
+  - Create parent directories if needed
+  - Copy file content
+
+### Commit Snapshot
+BASH: `cd {snapshotDir} && git add -A && git commit -m "Ship: {feature} (v{newVersion})" 2>/dev/null || echo "NO_CHANGES"`
+
+### Get Snapshot Hash
+BASH: `cd {snapshotDir} && git rev-parse --short HEAD`
+CAPTURE as {snapshotHash}
+
+### Clear Redo Stack (new snapshot invalidates redo)
+WRITE: `{snapshotDir}/redo-stack.json`
+Content: `[]`
+
+### Log Snapshot
+APPEND to: `{snapshotDir}/manifest.jsonl`
+
+Single line (JSONL):
+```json
+{"type":"snapshot","hash":"{snapshotHash}","message":"Ship: {feature}","version":"{newVersion}","timestamp":"{GetTimestamp()}"}
+```
+
 ## Output
 
 SUCCESS:
@@ -197,11 +240,12 @@ Version: {currentVersion} → {newVersion}
 Lint: {lintStatus}
 Tests: {testStatus}
 Commit: {commitHash}
+Snapshot: {snapshotHash}
 
 Next:
+• /p:undo - Revert this ship if needed
 • /p:feature - Plan next feature
 • /p:recap - See progress
-• compact - Clean up conversation
 ```
 
 ## Error Handling

package/templates/commands/sync.md

@@ -181,7 +181,40 @@ IF exists:
 
   WRITE: `{globalPath}/CLAUDE.md`
 
-## Step 6: Log to Memory
+## Step 6: Update project.json
+
+This file is the source of truth for the web dashboard. It maps projectId → repoPath.
+
+### Determine Project Name
+- Try package.json → `name` field
+- Try Cargo.toml → `[package] name`
+- Try pyproject.toml → `[project] name`
+- Fallback to directory name (last segment of current path)
+
+WRITE: `{globalPath}/project.json`
+
+```json
+{
+  "projectId": "{projectId}",
+  "repoPath": "{cwd}",
+  "name": "{projectName}",
+  "techStack": ["{primaryLanguage}", "{primaryFramework}", ...],
+  "createdAt": "{existingCreatedAt || GetTimestamp()}",
+  "lastSync": "{GetTimestamp()}"
+}
+```
+
+### techStack Array Rules
+- Max 4 items for display in dashboard cards
+- Order by relevance: primary language → framework → tools
+- Examples:
+  - Node.js + React: `["TypeScript", "React", "Node.js", "Vitest"]`
+  - Python Django: `["Python", "Django", "PostgreSQL"]`
+  - CLI tool: `["Node.js", "CLI", "CommonJS"]`
+
+NOTE: If project.json already exists, preserve `createdAt` field. Always update `lastSync` and `techStack`.
+
+## Step 7: Log to Memory
 
 APPEND to: `{memoryPath}`