prjct-cli 0.11.5 → 0.12.0

package/packages/web/server.ts

@@ -12,7 +12,9 @@ import type { IPty } from 'node-pty'
 
 const dev = process.env.NODE_ENV !== 'production'
 const hostname = 'localhost'
-const port = parseInt(process.env.PORT || '9472', 10)
+// Dev: 9471, Prod: 9472 (allows running both simultaneously for testing)
+const defaultPort = dev ? 9471 : 9472
+const port = parseInt(process.env.PORT || String(defaultPort), 10)
 
 // PTY Sessions stored in server memory
 interface Session {
@@ -33,8 +35,14 @@ function createSession(sessionId: string, projectDir: string): { pty: IPty; isNe
     return { pty: existing.pty, isNew: false }
   }
 
-  const shell = process.platform === 'win32' ? 'cmd.exe' : 'bash'
-  const args = process.platform === 'win32' ? [] : ['-l']
+  // Use user's default shell (zsh, bash, etc.) - respects $SHELL env var
+  const shell = process.platform === 'win32'
+    ? 'cmd.exe'
+    : process.env.SHELL || '/bin/zsh'
+
+  // -l for login shell (loads .zshrc, .bashrc, etc.)
+  // -i for interactive shell (enables job control, aliases)
+  const args = process.platform === 'win32' ? [] : ['-l', '-i']
 
   const ptyProcess = pty.spawn(shell, args, {
     name: 'xterm-256color',
@@ -44,7 +52,9 @@ function createSession(sessionId: string, projectDir: string): { pty: IPty; isNe
     env: {
       ...process.env,
       TERM: 'xterm-256color',
-      COLORTERM: 'truecolor'
+      COLORTERM: 'truecolor',
+      // Ensure shell knows it's interactive
+      SHELL: shell
     }
   })
 
@@ -204,10 +214,25 @@ app.prepare().then(() => {
 
     const ptyProcess = session.pty
 
+    // Output buffering for smooth terminal rendering
+    // Batches PTY output and flushes every 16ms (one animation frame)
+    const outputBuffer: string[] = []
+    let flushTimer: NodeJS.Timeout | null = null
+    const BATCH_MS = 16
+
+    const flushBuffer = () => {
+      if (outputBuffer.length > 0 && ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: 'output', data: outputBuffer.join('') }))
+        outputBuffer.length = 0
+      }
+      flushTimer = null
+    }
+
     // Register data handler FIRST before sending any commands
     const dataHandler = ptyProcess.onData((data: string) => {
-      if (ws.readyState === WebSocket.OPEN) {
-        ws.send(JSON.stringify({ type: 'output', data }))
+      outputBuffer.push(data)
+      if (!flushTimer) {
+        flushTimer = setTimeout(flushBuffer, BATCH_MS)
       }
     })
 
@@ -247,6 +272,11 @@ app.prepare().then(() => {
 
     ws.on('close', () => {
       console.log(`[WS] PTY connection closed: ${sessionId}`)
+      // Clear buffer flush timer
+      if (flushTimer) {
+        clearTimeout(flushTimer)
+        flushTimer = null
+      }
       dataHandler.dispose()
       exitHandler.dispose()
     })

package/templates/commands/done.md

@@ -2,18 +2,28 @@
 allowed-tools: [Read, Write, Bash]
 description: 'Complete current task with session metrics'
 timestamp-rule: 'GetTimestamp() for all timestamps'
+architecture: 'JSON-first - Write to data/*.json, views are generated'
 ---
 
 # /p:done - Complete Current Task with Session Metrics
 
+## Architecture: JSON-First
+
+**Source of Truth**: `data/state.json`, `data/queue.json`, `data/metrics.json`
+**Generated Views**: `views/now.md`, `views/next.md` (auto-generated)
+
+All writes go to JSON. After writing, views are auto-regenerated.
+
 ## Context Variables
 - `{projectId}`: From `.prjct/prjct.config.json`
 - `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
-- `{nowPath}`: `{globalPath}/core/now.md`
+- `{dataPath}`: `{globalPath}/data`
+- `{statePath}`: `{dataPath}/state.json`
+- `{queuePath}`: `{dataPath}/queue.json`
+- `{metricsJsonPath}`: `{dataPath}/metrics.json`
 - `{sessionPath}`: `{globalPath}/sessions/current.json`
 - `{archiveDir}`: `{globalPath}/sessions/archive`
 - `{memoryPath}`: `{globalPath}/memory/context.jsonl`
-- `{metricsPath}`: `{globalPath}/progress/metrics.md`
 
 ## Step 1: Read Config
 
@@ -26,18 +36,23 @@ IF file not found:
 
 ## Step 2: Check Session State
 
-### Try structured session first
+### Read state.json (source of truth)
+READ: `{statePath}`
+
+IF file exists AND has currentTask:
+  EXTRACT: {task} = state.currentTask
+  GOTO Step 3 (Session Completion)
+
+### Try structured session (for detailed metrics)
 READ: `{sessionPath}`
 
 IF file exists:
   PARSE as JSON
   EXTRACT: {session} object
-  GOTO Step 3 (Session Completion)
-
-### Fallback to legacy now.md
-READ: `{nowPath}`
+ELSE:
+  CREATE session from state.currentTask data
 
-IF empty OR contains "No current task":
+IF no currentTask in state.json:
   OUTPUT: "⚠️ No active task to complete. Use /p:now to start one."
   STOP
 
@@ -100,48 +115,77 @@ BASH: `mkdir -p {archiveDir}/{yearMonth}`
 WRITE: `{archiveDir}/{yearMonth}/{session.id}.json`
 Content: Updated session object from Step 3
 
-## Step 5: Clear Current Session
+## Step 5: Clear Current State (JSON)
 
-DELETE: `{sessionPath}`
+### Clear state.json (SOURCE OF TRUTH)
+READ: `{statePath}`
 
-OR WRITE empty state:
+UPDATE state.json:
+```json
+{
+  "currentTask": null,
+  "lastUpdated": "{now}"
+}
+```
+
+WRITE: `{statePath}`
+
+### Clear session.json
 WRITE: `{sessionPath}`
 Content:
 ```json
 {}
 ```
 
-## Step 6: Update Legacy now.md
+## Step 6: Update Metrics (JSON)
 
-WRITE: `{nowPath}`
-Content:
-```markdown
-# NOW
+READ: `{metricsJsonPath}` (or create default if not exists)
 
-No current task. Use `/p:now` to set focus.
+### Update metrics.json
+```json
+{
+  "velocity": {
+    "tasksPerDay": {calculated},
+    "avgTaskDuration": {calculated}
+  },
+  "allTime": {
+    "totalTasks": {increment by 1},
+    "totalTime": {add duration},
+    "daysActive": {recalculate}
+  },
+  "recentTasks": [
+    {
+      "task": "{session.task}",
+      "duration": {duration},
+      "completedAt": "{now}",
+      "metrics": {
+        "filesChanged": {filesChanged},
+        "linesAdded": {linesAdded},
+        "linesRemoved": {linesRemoved},
+        "commits": {commits}
+      }
+    },
+    ...existing recent tasks (keep last 10)
+  ],
+  "lastUpdated": "{now}"
+}
 ```
 
-## Step 7: Log to Memory
+WRITE: `{metricsJsonPath}`
 
-APPEND to: `{memoryPath}`
+## Step 7: Generate Views
 
-Single line (JSONL format):
-```json
-{"timestamp":"{now}","action":"session_completed","sessionId":"{session.id}","task":"{session.task}","duration":{duration},"metrics":{"files":{filesChanged},"added":{linesAdded},"removed":{linesRemoved},"commits":{commits}}}
-```
+BASH: `cd {projectRoot} && npx prjct-generate-views --project={projectId}`
 
-## Step 8: Update Metrics Summary
+Note: This regenerates views/now.md, views/next.md from JSON automatically.
 
-READ: `{metricsPath}` (create if not exists)
+## Step 8: Log to Memory
 
-### Append Daily Entry
-GET: {date} = YYYY-MM-DD from {now}
+APPEND to: `{memoryPath}`
 
-INSERT or UPDATE entry for {date}:
-```markdown
-### {date}
-- **{session.task}** ({durationFormatted})
-  - Files: {filesChanged} | +{linesAdded}/-{linesRemoved} | Commits: {commits}
+Single line (JSONL format):
+```json
+{"timestamp":"{now}","action":"session_completed","sessionId":"{session.id}","task":"{session.task}","duration":{duration},"metrics":{"files":{filesChanged},"added":{linesAdded},"removed":{linesRemoved},"commits":{commits}}}
 ```
 
 ## Output

package/templates/commands/feature.md

@@ -2,10 +2,16 @@
 allowed-tools: [Read, Write, Bash, Task, Glob]
 description: 'Value analysis + roadmap + task breakdown + auto-start'
 timestamp-rule: 'GetTimestamp() and GetDate() for ALL timestamps'
+architecture: 'JSON-first - Write to data/*.json, views are generated'
 ---
 
 # /p:feature - Add Feature to Roadmap
 
+## Architecture: JSON-First
+
+**Source of Truth**: `data/roadmap.json`, `data/queue.json`, `data/state.json`
+**Generated Views**: `views/roadmap.md`, `views/next.md`, `views/now.md` (auto-generated)
+
 ## Agent Delegation (REQUIRED)
 
 Before executing any code-related task, delegate to a specialist agent:
@@ -46,9 +52,10 @@ Task(
 ## Context Variables
 - `{projectId}`: From `.prjct/prjct.config.json`
 - `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
-- `{roadmapPath}`: `{globalPath}/planning/roadmap.md`
-- `{nextPath}`: `{globalPath}/core/next.md`
-- `{nowPath}`: `{globalPath}/core/now.md`
+- `{dataPath}`: `{globalPath}/data`
+- `{roadmapPath}`: `{dataPath}/roadmap.json`
+- `{queuePath}`: `{dataPath}/queue.json`
+- `{statePath}`: `{dataPath}/state.json`
 - `{memoryPath}`: `{globalPath}/memory/context.jsonl`
 - `{feature}`: User-provided feature description
 
@@ -142,90 +149,157 @@ For feature "add user authentication":
 
 GENERATE: {tasks} = list of task descriptions
 
-## Step 5: Update Roadmap
+## Step 5: Update Roadmap (JSON)
 
-READ: `{roadmapPath}` (create if not exists)
+READ: `{roadmapPath}` (or create default if not exists)
 
-### Format New Entry
+Default structure:
+```json
+{
+  "features": [],
+  "backlog": [],
+  "lastUpdated": ""
+}
+```
 
-```markdown
-## {GetDate()} - {feature}
-- Impact: {impact} | Effort: {effort}
-- Tasks: {taskCount}
-- Status: active
+### Generate Feature ID
+GENERATE: {featureId} = "feat_" + 8 random alphanumeric chars
+SET: {now} = GetTimestamp()
 
-### Tasks
-1. [ ] {task1}
-2. [ ] {task2}
-...
+### Create Feature Entry
+```json
+{
+  "id": "{featureId}",
+  "name": "{feature}",
+  "impact": "{impact}",
+  "effort": "{effort}",
+  "status": "active",
+  "progress": 0,
+  "tasks": [
+    {
+      "id": "task_{8_random}",
+      "description": "{task1}",
+      "completed": false,
+      "createdAt": "{now}"
+    },
+    {
+      "id": "task_{8_random}",
+      "description": "{task2}",
+      "completed": false,
+      "createdAt": "{now}"
+    }
+    ...
+  ],
+  "createdAt": "{now}"
+}
 ```
 
-INSERT at top (after # Roadmap header)
-
-### Archive Old Entries
-IF entries older than 30 days exist:
-  MOVE to: `{globalPath}/planning/archive/roadmap-{yearMonth}.md`
+### Update roadmap.json
+```json
+{
+  "features": [
+    {new feature entry},
+    ...existing features
+  ],
+  "backlog": [...existing],
+  "lastUpdated": "{now}"
+}
+```
 
 WRITE: `{roadmapPath}`
 
-## Step 6: Update Priority Queue
+## Step 6: Update Priority Queue (JSON)
 
-READ: `{nextPath}` (create if not exists)
+READ: `{queuePath}` (or create default if not exists)
 
-### Add Tasks to Queue
+Default structure:
+```json
+{
+  "tasks": [],
+  "lastUpdated": ""
+}
+```
 
+### Add Tasks to Queue
 For each task in {tasks}:
-  APPEND to next.md:
-  ```markdown
-  - [ ] {task} (from: {feature})
-  ```
+```json
+{
+  "id": "task_{8_random}",
+  "description": "{task}",
+  "priority": "medium",
+  "featureId": "{featureId}",
+  "completed": false,
+  "createdAt": "{now}"
+}
+```
+
+### Update queue.json
+```json
+{
+  "tasks": [
+    ...new tasks,
+    ...existing tasks
+  ],
+  "lastUpdated": "{now}"
+}
+```
 
-WRITE: `{nextPath}`
+WRITE: `{queuePath}`
 
-## Step 7: Auto-Start First Task
+## Step 7: Auto-Start First Task (JSON)
 
-READ: `{nowPath}`
+READ: `{statePath}` (or create default)
 
-IF empty OR contains "No current task":
+IF currentTask is null:
   ### Start First Task
   {firstTask} = first item from {tasks}
-
-  WRITE: `{nowPath}`
-  ```markdown
-  # NOW
-
-  **{firstTask}**
-
-  Feature: {feature}
-  Started: {GetTimestamp()}
+  GENERATE: {sessionId} = "sess_" + 8 random alphanumeric chars
+
+  ### Update state.json
+  ```json
+  {
+    "currentTask": {
+      "id": "task_{8_random}",
+      "description": "{firstTask}",
+      "startedAt": "{now}",
+      "sessionId": "{sessionId}",
+      "featureId": "{featureId}"
+    },
+    "lastUpdated": "{now}"
+  }
   ```
 
+  WRITE: `{statePath}`
   {autoStarted} = true
 ELSE:
   {autoStarted} = false
 
-## Step 8: Log to Session
+## Step 8: Generate Views
+
+BASH: `cd {projectRoot} && npx prjct-generate-views --project={projectId}`
+
+Note: This regenerates views/roadmap.md, views/next.md, views/now.md from JSON automatically.
+
+## Step 9: Log to Memory
 
 GET: {date} = GetDate()
 EXTRACT: {yearMonth} = YYYY-MM from {date}
 
 ENSURE directory:
-BASH: `mkdir -p {globalPath}/planning/sessions/{yearMonth}`
+BASH: `mkdir -p {globalPath}/memory/sessions/{yearMonth}`
 
-APPEND to: `{globalPath}/planning/sessions/{yearMonth}/{date}.jsonl`
+APPEND to: `{globalPath}/memory/sessions/{yearMonth}/{date}.jsonl`
 
 Single line (JSONL):
 ```json
-{"ts":"{GetTimestamp()}","type":"feature_add","name":"{feature}","tasks":{taskCount},"impact":"{impact}","effort":"{effort}"}
+{"ts":"{now}","type":"feature_add","featureId":"{featureId}","name":"{feature}","tasks":{taskCount},"impact":"{impact}","effort":"{effort}"}
 ```
 
-## Step 9: Log to Memory
-
 APPEND to: `{memoryPath}`
 
 Single line (JSONL):
 ```json
-{"timestamp":"{GetTimestamp()}","action":"feature_added","feature":"{feature}","tasks":{taskCount}}
+{"timestamp":"{now}","action":"feature_added","featureId":"{featureId}","feature":"{feature}","tasks":{taskCount}}
 ```
 
 ## Output

package/templates/commands/idea.md

@@ -1,16 +1,89 @@
 ---
-allowed-tools: [Read, Write, GetTimestamp, GetDate]
+allowed-tools: [Read, Write, Bash, GetTimestamp, GetDate]
 description: 'Quick idea capture'
 timestamp-rule: 'GetTimestamp() and GetDate() for timestamps'
+architecture: 'JSON-first - Write to data/ideas.json, views are generated'
 ---
 
-# /p:idea
+# /p:idea - Quick Idea Capture
 
-## Flow
-1. Log: `planning/sessions/{YY-MM}/{DD}.jsonl`
-   `{"ts":"{GetTimestamp()}","type":"idea_add","idea":"{text}"}`
-2. Update: `planning/ideas.md` with {GetDate()}
-3. If actionable → `core/next.md`
+## Architecture: JSON-First
+
+**Source of Truth**: `data/ideas.json`
+**Generated View**: `views/ideas.md` (auto-generated)
+
+## Context Variables
+- `{projectId}`: From `.prjct/prjct.config.json`
+- `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
+- `{dataPath}`: `{globalPath}/data`
+- `{ideasPath}`: `{dataPath}/ideas.json`
+- `{memoryPath}`: `{globalPath}/memory/context.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: Read Current Ideas
+
+READ: `{ideasPath}` (or create default if not exists)
+
+Default structure:
+```json
+{
+  "ideas": [],
+  "lastUpdated": ""
+}
+```
+
+## Step 3: Add New Idea (JSON)
+
+GENERATE: {ideaId} = "idea_" + 8 random alphanumeric chars
+SET: {now} = GetTimestamp()
+
+### Analyze idea for tags
+Based on {text}, detect tags:
+- 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
+
+### Update ideas.json
+```json
+{
+  "ideas": [
+    {
+      "id": "{ideaId}",
+      "text": "{text}",
+      "priority": "medium",
+      "status": "pending",
+      "tags": [{detected_tags}],
+      "createdAt": "{now}"
+    },
+    ...existing ideas
+  ],
+  "lastUpdated": "{now}"
+}
+```
+
+WRITE: `{ideasPath}`
+
+## Step 4: Generate Views
+
+BASH: `cd {projectRoot} && npx prjct-generate-views --project={projectId}`
+
+## Step 5: Log to Memory
+
+APPEND to: `{memoryPath}`
+```json
+{"timestamp":"{now}","action":"idea_added","ideaId":"{ideaId}","text":"{text}"}
+```
 
 ## Response
-`💡 {idea} | Saved | Start: /p:feature "{idea}"`
+
+`💡 {text} | Saved | Start: /p:feature "{text}"`

package/templates/commands/now.md

@@ -2,14 +2,23 @@
 allowed-tools: [Read, Write, Bash]
 description: 'Set or show current task with session tracking'
 timestamp-rule: 'GetTimestamp() for ALL timestamps'
+architecture: 'JSON-first - Write to data/*.json, views are generated'
 ---
 
 # /p:now - Current Task with Session Tracking
 
+## Architecture: JSON-First
+
+**Source of Truth**: `data/state.json`
+**Generated View**: `views/now.md` (auto-generated, do not edit directly)
+
+All writes go to JSON. After writing, run `prjct generate-views --project={projectId}` to regenerate MD views.
+
 ## Context Variables
 - `{projectId}`: From `.prjct/prjct.config.json`
 - `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
-- `{nowPath}`: `{globalPath}/core/now.md`
+- `{dataPath}`: `{globalPath}/data`
+- `{statePath}`: `{dataPath}/state.json`
 - `{sessionPath}`: `{globalPath}/sessions/current.json`
 - `{memoryPath}`: `{globalPath}/memory/context.jsonl`
 - `{task}`: User-provided task (optional)
@@ -25,15 +34,19 @@ IF file not found:
 
 ## Step 2: Check Current State
 
-### Check for active session
-READ: `{sessionPath}`
+### Read state.json (source of truth)
+READ: `{statePath}`
 
 IF file exists:
   PARSE as JSON
-  EXTRACT: {currentTask}, {status}, {startedAt}, {duration}
+  EXTRACT: {currentTask} from state.currentTask
+
+### Check for active session (legacy support)
+READ: `{sessionPath}`
 
-### Check now.md
-READ: `{nowPath}`
+IF file exists:
+  PARSE as JSON
+  EXTRACT: {session.task}, {session.status}, {session.startedAt}, {session.duration}
 
 ## Step 3: Handle Cases
 
@@ -91,7 +104,25 @@ IF {task} is provided:
   GENERATE: {sessionId} = "sess_" + 8 random alphanumeric chars
   SET: {startedAt} = GetTimestamp()
 
-  ### Create session JSON
+  ### Write state.json (SOURCE OF TRUTH)
+  READ: `{statePath}` (or create default if not exists)
+
+  UPDATE state.json:
+  ```json
+  {
+    "currentTask": {
+      "id": "task_{8_random_chars}",
+      "description": "{task}",
+      "startedAt": "{startedAt}",
+      "sessionId": "{sessionId}"
+    },
+    "lastUpdated": "{startedAt}"
+  }
+  ```
+
+  WRITE: `{statePath}`
+
+  ### Create session JSON (for detailed tracking)
   WRITE: `{sessionPath}`
   Content:
   ```json
@@ -117,17 +148,10 @@ IF {task} is provided:
   }
   ```
 
-  ### Update now.md (legacy support)
-  WRITE: `{nowPath}`
-  Content:
-  ```markdown
-  # NOW
-
-  **{task}**
+  ### Generate views (auto-regenerate MD from JSON)
+  BASH: `cd {projectRoot} && npx prjct-generate-views --project={projectId}`
 
-  Started: {startedAt}
-  Session: {sessionId}
-  ```
+  Note: This regenerates views/now.md from data/state.json automatically.
 
   ### Log to memory
   APPEND to: `{memoryPath}`