prjct-cli 0.13.3 → 0.15.0

package/templates/commands/feature.md

@@ -2,16 +2,24 @@
 allowed-tools: [Read, Write, Bash, Task, Glob]
 description: 'Value analysis + roadmap + task breakdown + auto-start'
 timestamp-rule: 'GetTimestamp() and GetDate() for ALL timestamps'
-architecture: 'MD-first - MD files are source of truth'
+architecture: 'Write-Through (JSON → MD → Events)'
+storage-layer: true
+source-of-truth: 'storage/queue.json'
+claude-context: 'context/next.md'
+backend-sync: 'sync/pending.json'
 ---
 
 # /p:feature - Add Feature to Roadmap
 
-## Architecture: MD-First
+## Architecture: Write-Through Pattern
 
-**Source of Truth**: `planning/roadmap.md`, `core/next.md`, `core/now.md`
+```
+User Action → Storage (JSON) → Context (MD) → Sync Events
+```
 
-MD files are the source of truth. Write directly to MD files.
+**Source of Truth**: `storage/queue.json` (tasks), `storage/roadmap.json` (features)
+**Claude Context**: `context/next.md`, `context/roadmap.md` (generated)
+**Backend Sync**: `sync/pending.json` (events)
 
 ## Agent Delegation (REQUIRED)
 
@@ -53,10 +61,11 @@ 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`
-- `{memoryPath}`: `{globalPath}/memory/context.jsonl`
+- `{queuePath}`: `{globalPath}/storage/queue.json`
+- `{statePath}`: `{globalPath}/storage/state.json`
+- `{nextContextPath}`: `{globalPath}/context/next.md`
+- `{syncPath}`: `{globalPath}/sync/pending.json`
+- `{memoryPath}`: `{globalPath}/memory/events.jsonl`
 - `{feature}`: User-provided feature description
 
 ## Step 1: Read Config
@@ -148,96 +157,54 @@ For feature "add user authentication":
 ```
 
 GENERATE: {tasks} = list of task descriptions
-
-## Step 5: Update Roadmap (MD)
-
-READ: `{roadmapPath}` (or create default if not exists)
-
-Default structure:
-```markdown
-# Roadmap
-
-## Active
-
-_No active features_
-
-## Planned
-
-_No planned features_
-
-## Shipped
-
-_Nothing shipped yet_
-```
-
-### Generate Feature ID
-GENERATE: {featureId} = "feat_" + 8 random alphanumeric chars
+GENERATE: {featureId} = UUID v4
 SET: {now} = GetTimestamp()
 
-### Update roadmap.md
-
-Parse existing content and add new feature under "## Active" section:
-
-```markdown
-# Roadmap
-
-## Active
+## Step 5: Update Storage (SOURCE OF TRUTH)
 
-### {feature}
-- **ID**: {featureId}
-- **Impact**: {impact}
-- **Effort**: {effort}
-- **Started**: {now}
-- **Tasks**:
-  - [ ] {task1}
-  - [ ] {task2}
-  - [ ] {task3}
-  ...
-
-{...existing active features}
-
-## Planned
-
-{...existing planned features}
-
-## Shipped
-
-{...existing shipped features}
-```
+### Update queue.json
 
-WRITE: `{roadmapPath}`
-
-## Step 6: Update Priority Queue (MD)
-
-READ: `{nextPath}` (or create default if not exists)
+READ: `{queuePath}` (or create default if not exists)
 
 Default structure:
-```markdown
-# Next
-
-## High Priority
-
-_No high priority tasks_
-
-## Normal Priority
+```json
+{
+  "tasks": [],
+  "lastUpdated": null
+}
+```
 
-_No tasks in queue_
+For each task in {tasks}, create task object:
+```json
+{
+  "id": "{taskId}",
+  "description": "{taskDescription}",
+  "type": "feature",
+  "priority": "normal",
+  "section": "active",
+  "featureId": "{featureId}",
+  "featureName": "{feature}",
+  "createdAt": "{now}"
+}
+```
 
-## Low Priority
+APPEND all tasks to `tasks` array
+SET: `lastUpdated` = {now}
+WRITE: `{queuePath}`
 
-_No low priority tasks_
-```
+## Step 6: Generate Context (FOR CLAUDE)
 
-### Add Tasks to Queue
+### Generate context/next.md
 
-For each task in {tasks}, add to appropriate priority section:
+READ: `{queuePath}`
+TRANSFORM to markdown:
 
 ```markdown
 # Next
 
 ## High Priority
 
-{if high priority tasks}
+{high priority tasks from queue}
 
 ## Normal Priority
 
@@ -245,58 +212,113 @@ For each task in {tasks}, add to appropriate priority section:
 - [ ] {task2} @{featureId}
 ...
 
-{...existing tasks}
-
 ## Low Priority
 
-{...existing low priority tasks}
+{low priority tasks}
 ```
 
-WRITE: `{nextPath}`
+WRITE: `{nextContextPath}`
 
-## Step 7: Auto-Start First Task (MD)
+## Step 7: Auto-Start First Task
 
-READ: `{nowPath}`
+READ: `{statePath}`
 
-IF file is empty OR contains "_No active task_":
+IF no currentTask:
   ### Start First Task
   {firstTask} = first item from {tasks}
-  GENERATE: {sessionId} = "sess_" + 8 random alphanumeric chars
+  GENERATE: {sessionId} = UUID v4
+
+  ### Update state.json
+  ```json
+  {
+    "currentTask": {
+      "id": "{firstTask.id}",
+      "description": "{firstTask.description}",
+      "sessionId": "{sessionId}",
+      "featureId": "{featureId}",
+      "startedAt": "{now}",
+      "status": "active"
+    },
+    "pausedTask": null,
+    "lastUpdated": "{now}"
+  }
+  ```
+  WRITE: `{statePath}`
 
-  ### Update now.md
+  ### Generate context/now.md
   ```markdown
   # NOW
 
-  **{firstTask}**
+  **{firstTask.description}**
 
   Started: {now}
   Session: {sessionId}
   Feature: {featureId}
   ```
+  WRITE: `{globalPath}/context/now.md`
 
-  WRITE: `{nowPath}`
   {autoStarted} = true
 ELSE:
   {autoStarted} = false
 
-## Step 8: Log to Memory
+## Step 8: Queue Sync Events
 
-GET: {date} = GetDate()
-EXTRACT: {yearMonth} = YYYY-MM from {date}
+READ: `{syncPath}` or create empty array
 
-ENSURE directory:
-BASH: `mkdir -p {globalPath}/memory/sessions/{yearMonth}`
+### Feature created event
+APPEND:
+```json
+{
+  "type": "feature.created",
+  "path": ["queue"],
+  "data": {
+    "featureId": "{featureId}",
+    "name": "{feature}",
+    "impact": "{impact}",
+    "effort": "{effort}",
+    "taskCount": {taskCount}
+  },
+  "timestamp": "{now}",
+  "projectId": "{projectId}"
+}
+```
 
-APPEND to: `{globalPath}/memory/sessions/{yearMonth}/{date}.jsonl`
+### Tasks added events (one per task)
+For each task:
+```json
+{
+  "type": "queue.task_added",
+  "path": ["queue"],
+  "data": {
+    "taskId": "{taskId}",
+    "description": "{taskDescription}",
+    "featureId": "{featureId}"
+  },
+  "timestamp": "{now}",
+  "projectId": "{projectId}"
+}
+```
 
-Single line (JSONL):
+IF {autoStarted}:
 ```json
-{"ts":"{now}","type":"feature_add","featureId":"{featureId}","name":"{feature}","tasks":{taskCount},"impact":"{impact}","effort":"{effort}"}
+{
+  "type": "task.started",
+  "path": ["state"],
+  "data": {
+    "taskId": "{firstTask.id}",
+    "sessionId": "{sessionId}",
+    "featureId": "{featureId}"
+  },
+  "timestamp": "{now}",
+  "projectId": "{projectId}"
+}
 ```
 
-APPEND to: `{memoryPath}`
+WRITE: `{syncPath}`
+
+## Step 9: Log to Memory
 
-Single line (JSONL):
+APPEND to: `{memoryPath}`
 ```json
 {"timestamp":"{now}","action":"feature_added","featureId":"{featureId}","feature":"{feature}","tasks":{taskCount}}
 ```
@@ -310,7 +332,7 @@ SUCCESS (with auto-start):
 Impact: {impact} | Effort: {effort}
 Tasks: {taskCount}
 
-🎯 Started: {firstTask}
+🎯 Started: {firstTask.description}
 
 Next:
 • Work on the task

package/templates/commands/git.md

@@ -1,9 +1,18 @@
 ---
 allowed-tools: [Bash, Read, Write]
 description: 'Smart git operations with context'
+architecture: 'Write-Through (JSON → MD → Events)'
+storage-layer: true
+source-of-truth: 'storage/state.json'
 ---
 
-# /p:git
+# /p:git - Smart Git Operations
+
+## Architecture: Write-Through Pattern
+
+Reads from **Storage (JSON)** as source of truth.
+
+**Source of Truth**: `storage/state.json`
 
 ## Usage
 
@@ -14,13 +23,19 @@ description: 'Smart git operations with context'
 /p:git undo         # Undo last commit
 ```
 
+## Context Variables
+- `{projectId}`: From `.prjct/prjct.config.json`
+- `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
+- `{statePath}`: `{globalPath}/storage/state.json`
+- `{memoryPath}`: `{globalPath}/memory/events.jsonl`
+
 ## Flow: commit
 
-1. Read: `core/now.md` → get task context
+1. Read: `storage/state.json` → get task context
 2. Git: `add .` → stage changes
 3. Create: commit message with prjct metadata
 4. Commit: with message
-5. Log: `memory/context.jsonl`
+5. Log: `memory/events.jsonl`
 
 ## Flow: push
 

package/templates/commands/idea.md

@@ -2,22 +2,32 @@
 allowed-tools: [Read, Write, Bash, GetTimestamp, GetDate]
 description: 'Quick idea capture'
 timestamp-rule: 'GetTimestamp() and GetDate() for timestamps'
-architecture: 'MD-first - MD files are source of truth'
+architecture: 'Write-Through (JSON → MD → Events)'
+storage-layer: true
+source-of-truth: 'storage/ideas.json'
+claude-context: 'context/ideas.md'
+backend-sync: 'sync/pending.json'
 ---
 
 # /p:idea - Quick Idea Capture
 
-## Architecture: MD-First
+## Architecture: Write-Through Pattern
 
-**Source of Truth**: `planning/ideas.md`
+```
+User Action → Storage (JSON) → Context (MD) → Sync Events
+```
 
-MD files are the source of truth. Write directly to MD files.
+**Source of Truth**: `storage/ideas.json`
+**Claude Context**: `context/ideas.md` (generated)
+**Backend Sync**: `sync/pending.json` (events)
 
 ## Context Variables
 - `{projectId}`: From `.prjct/prjct.config.json`
 - `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
-- `{ideasPath}`: `{globalPath}/planning/ideas.md`
-- `{memoryPath}`: `{globalPath}/memory/context.jsonl`
+- `{ideasStoragePath}`: `{globalPath}/storage/ideas.json`
+- `{ideasContextPath}`: `{globalPath}/context/ideas.md`
+- `{syncPath}`: `{globalPath}/sync/pending.json`
+- `{memoryPath}`: `{globalPath}/memory/events.jsonl`
 - `{text}`: User-provided idea text
 
 ## Step 1: Read Config
@@ -29,64 +39,137 @@ IF file not found:
   OUTPUT: "No prjct project. Run /p:init first."
   STOP
 
-## Step 2: Read Current Ideas
+## Step 2: Analyze Idea
 
-READ: `{ideasPath}` (or create default if not exists)
+Based on {text}, detect:
 
-Default structure:
-```markdown
-# Ideas
+### Priority Detection
+- If mentions "urgent", "critical", "asap" → priority = "high"
+- If mentions "later", "maybe", "nice to have" → priority = "low"
+- Default → priority = "medium"
 
-## Pending
+### Tag Detection
+- 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
+- If mentions security → add `#security` tag
+- If mentions docs → add `#docs` tag
 
-_No ideas yet_
+## Step 3: Update Storage (SOURCE OF TRUTH)
 
-## Implemented
+GENERATE: {ideaId} = UUID v4
+SET: {now} = GetTimestamp()
 
-_Nothing implemented yet_
+### Read existing ideas
+READ: `{ideasStoragePath}` or create default:
+```json
+{
+  "ideas": [],
+  "lastUpdated": null
+}
 ```
 
-## Step 3: Add New Idea (MD)
+### Create idea object
+```json
+{
+  "id": "{ideaId}",
+  "text": "{text}",
+  "priority": "{priority}",
+  "tags": ["{detected_tags}"],
+  "status": "pending",
+  "createdAt": "{now}"
+}
+```
 
-GENERATE: {ideaId} = "idea_" + 8 random alphanumeric chars
-SET: {now} = GetTimestamp()
+### Update ideas.json
+PREPEND new idea to ideas array
+SET: lastUpdated = {now}
+WRITE: `{ideasStoragePath}`
 
-### 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
+## Step 4: Generate Context (FOR CLAUDE)
 
-### Update ideas.md
-
-Parse existing content and add new idea under "## Pending" section:
+WRITE: `{ideasContextPath}`
 
 ```markdown
-# Ideas
+# IDEAS
 
 ## Pending
 
-- **{text}** #{detected_tags}
-  - ID: {ideaId}
-  - Added: {now}
-
-{...existing pending ideas}
+{FOR EACH idea in ideas WHERE status == "pending":}
+- **{idea.text}** {idea.tags.join(' ')}
+  - Priority: {idea.priority}
+  - Added: {idea.createdAt}
+{END FOR}
 
-## Implemented
+## Converted
 
-{...existing implemented ideas}
+{FOR EACH idea in ideas WHERE status == "converted":}
+- ~~{idea.text}~~ → Feature: {idea.convertedTo}
+{END FOR}
 ```
 
-WRITE: `{ideasPath}`
+## Step 5: Queue Sync Event (FOR BACKEND)
 
-## Step 4: Log to Memory
+READ: `{syncPath}` or create empty array
+APPEND event:
+```json
+{
+  "type": "idea.created",
+  "path": ["ideas"],
+  "data": {
+    "ideaId": "{ideaId}",
+    "text": "{text}",
+    "priority": "{priority}",
+    "tags": ["{detected_tags}"]
+  },
+  "timestamp": "{now}",
+  "projectId": "{projectId}"
+}
+```
+WRITE: `{syncPath}`
+
+## Step 6: Log to Memory (AUDIT TRAIL)
 
 APPEND to: `{memoryPath}`
 ```json
-{"timestamp":"{now}","action":"idea_added","ideaId":"{ideaId}","text":"{text}"}
+{"timestamp":"{now}","action":"idea_added","ideaId":"{ideaId}","text":"{text}","priority":"{priority}"}
 ```
 
 ## Response
 
 `💡 {text} | Saved | Start: /p:feature "{text}"`
+
+## Error Handling
+
+| Error | Response | Action |
+|-------|----------|--------|
+| No project | "No prjct project" | STOP |
+| No text | "What's your idea?" | ASK |
+| Write fails | Log warning | CONTINUE |
+
+## Examples
+
+### Example 1: Simple Idea
+**Input:** `/p:idea add dark mode support`
+
+**Output:**
+```
+💡 add dark mode support | Saved | Start: /p:feature "add dark mode support"
+```
+
+### Example 2: Idea with Priority
+**Input:** `/p:idea urgent fix login bug`
+
+**Output:**
+```
+💡 urgent fix login bug [high] | Saved | Start: /p:feature "fix login bug"
+```
+
+### Example 3: Idea with Tags
+**Input:** `/p:idea improve API performance`
+
+**Output:**
+```
+💡 improve API performance #api #perf | Saved
+```