prjct-cli 0.12.2 → 0.13.1

package/templates/commands/feature.md

@@ -2,15 +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'
+architecture: 'MD-first - MD files are source of truth'
 ---
 
 # /p:feature - Add Feature to Roadmap
 
-## Architecture: JSON-First
+## Architecture: MD-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)
+**Source of Truth**: `planning/roadmap.md`, `core/next.md`, `core/now.md`
+
+MD files are the source of truth. Write directly to MD files.
 
 ## Agent Delegation (REQUIRED)
 
@@ -52,10 +53,9 @@ Task(
 ## Context Variables
 - `{projectId}`: From `.prjct/prjct.config.json`
 - `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
-- `{dataPath}`: `{globalPath}/data`
-- `{roadmapPath}`: `{dataPath}/roadmap.json`
-- `{queuePath}`: `{dataPath}/queue.json`
-- `{statePath}`: `{dataPath}/state.json`
+- `{roadmapPath}`: `{globalPath}/planning/roadmap.md`
+- `{nextPath}`: `{globalPath}/core/next.md`
+- `{nowPath}`: `{globalPath}/core/now.md`
 - `{memoryPath}`: `{globalPath}/memory/context.jsonl`
 - `{feature}`: User-provided feature description
 
@@ -149,138 +149,137 @@ For feature "add user authentication":
 
 GENERATE: {tasks} = list of task descriptions
 
-## Step 5: Update Roadmap (JSON)
+## Step 5: Update Roadmap (MD)
 
 READ: `{roadmapPath}` (or create default if not exists)
 
 Default structure:
-```json
-{
-  "features": [],
-  "backlog": [],
-  "lastUpdated": ""
-}
+```markdown
+# Roadmap
+
+## Active
+
+_No active features_
+
+## Planned
+
+_No planned features_
+
+## Shipped
+
+_Nothing shipped yet_
 ```
 
 ### Generate Feature ID
 GENERATE: {featureId} = "feat_" + 8 random alphanumeric chars
 SET: {now} = GetTimestamp()
 
-### 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}"
-}
-```
+### Update roadmap.md
 
-### Update roadmap.json
-```json
-{
-  "features": [
-    {new feature entry},
-    ...existing features
-  ],
-  "backlog": [...existing],
-  "lastUpdated": "{now}"
-}
+Parse existing content and add new feature under "## Active" section:
+
+```markdown
+# Roadmap
+
+## Active
+
+### {feature}
+- **ID**: {featureId}
+- **Impact**: {impact}
+- **Effort**: {effort}
+- **Started**: {now}
+- **Tasks**:
+  - [ ] {task1}
+  - [ ] {task2}
+  - [ ] {task3}
+  ...
+
+{...existing active features}
+
+## Planned
+
+{...existing planned features}
+
+## Shipped
+
+{...existing shipped features}
 ```
 
 WRITE: `{roadmapPath}`
 
-## Step 6: Update Priority Queue (JSON)
+## Step 6: Update Priority Queue (MD)
 
-READ: `{queuePath}` (or create default if not exists)
+READ: `{nextPath}` (or create default if not exists)
 
 Default structure:
-```json
-{
-  "tasks": [],
-  "lastUpdated": ""
-}
+```markdown
+# Next
+
+## High Priority
+
+_No high priority tasks_
+
+## Normal Priority
+
+_No tasks in queue_
+
+## Low Priority
+
+_No low priority tasks_
 ```
 
 ### Add Tasks to Queue
-For each task in {tasks}:
-```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}"
-}
+For each task in {tasks}, add to appropriate priority section:
+
+```markdown
+# Next
+
+## High Priority
+
+{if high priority tasks}
+
+## Normal Priority
+
+- [ ] {task1} @{featureId}
+- [ ] {task2} @{featureId}
+...
+
+{...existing tasks}
+
+## Low Priority
+
+{...existing low priority tasks}
 ```
 
-WRITE: `{queuePath}`
+WRITE: `{nextPath}`
 
-## Step 7: Auto-Start First Task (JSON)
+## Step 7: Auto-Start First Task (MD)
 
-READ: `{statePath}` (or create default)
+READ: `{nowPath}`
 
-IF currentTask is null:
+IF file is empty OR contains "_No active task_":
   ### Start First Task
   {firstTask} = first item from {tasks}
   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}"
-  }
+  ### Update now.md
+  ```markdown
+  # NOW
+
+  **{firstTask}**
+
+  Started: {now}
+  Session: {sessionId}
+  Feature: {featureId}
   ```
 
-  WRITE: `{statePath}`
+  WRITE: `{nowPath}`
   {autoStarted} = true
 ELSE:
   {autoStarted} = false
 
-## 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
+## Step 8: Log to Memory
 
 GET: {date} = GetDate()
 EXTRACT: {yearMonth} = YYYY-MM from {date}

package/templates/commands/idea.md

@@ -2,21 +2,21 @@
 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'
+architecture: 'MD-first - MD files are source of truth'
 ---
 
 # /p:idea - Quick Idea Capture
 
-## Architecture: JSON-First
+## Architecture: MD-First
 
-**Source of Truth**: `data/ideas.json`
-**Generated View**: `views/ideas.md` (auto-generated)
+**Source of Truth**: `planning/ideas.md`
+
+MD files are the source of truth. Write directly to MD files.
 
 ## Context Variables
 - `{projectId}`: From `.prjct/prjct.config.json`
 - `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
-- `{dataPath}`: `{globalPath}/data`
-- `{ideasPath}`: `{dataPath}/ideas.json`
+- `{ideasPath}`: `{globalPath}/planning/ideas.md`
 - `{memoryPath}`: `{globalPath}/memory/context.jsonl`
 - `{text}`: User-provided idea text
 
@@ -34,50 +34,53 @@ IF file not found:
 READ: `{ideasPath}` (or create default if not exists)
 
 Default structure:
-```json
-{
-  "ideas": [],
-  "lastUpdated": ""
-}
+```markdown
+# Ideas
+
+## Pending
+
+_No ideas yet_
+
+## Implemented
+
+_Nothing implemented yet_
 ```
 
-## Step 3: Add New Idea (JSON)
+## Step 3: Add New Idea (MD)
 
 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
+- 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}"
-}
-```
+### Update ideas.md
 
-WRITE: `{ideasPath}`
+Parse existing content and add new idea under "## Pending" section:
+
+```markdown
+# Ideas
+
+## Pending
+
+- **{text}** #{detected_tags}
+  - ID: {ideaId}
+  - Added: {now}
 
-## Step 4: Generate Views
+{...existing pending ideas}
 
-BASH: `cd {projectRoot} && npx prjct-generate-views --project={projectId}`
+## Implemented
+
+{...existing implemented ideas}
+```
+
+WRITE: `{ideasPath}`
 
-## Step 5: Log to Memory
+## Step 4: Log to Memory
 
 APPEND to: `{memoryPath}`
 ```json
@@ -86,4 +89,4 @@ APPEND to: `{memoryPath}`
 
 ## Response
 
-`💡 {text} | Saved | Start: /p:feature "{text}"`
+`💡 {text} | Saved | Start: /p:feature "{text}"`

package/templates/commands/now.md

@@ -2,26 +2,38 @@
 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'
+architecture: 'MD-first - MD files are source of truth'
 ---
 
 # /p:now - Current Task with Session Tracking
 
-## Architecture: JSON-First
+## Architecture: MD-First
 
-**Source of Truth**: `data/state.json`
-**Generated View**: `views/now.md` (auto-generated, do not edit directly)
+**Source of Truth**: `core/now.md`
 
-All writes go to JSON. After writing, run `prjct generate-views --project={projectId}` to regenerate MD views.
+MD files are the source of truth. Write directly to MD files.
 
 ## Context Variables
 - `{projectId}`: From `.prjct/prjct.config.json`
 - `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
-- `{dataPath}`: `{globalPath}/data`
-- `{statePath}`: `{dataPath}/state.json`
+- `{nowPath}`: `{globalPath}/core/now.md`
 - `{sessionPath}`: `{globalPath}/sessions/current.json`
 - `{memoryPath}`: `{globalPath}/memory/context.jsonl`
 - `{task}`: User-provided task (optional)
+- `{estimate}`: User-provided time estimate (optional, e.g., "2h", "30m", "1d")
+
+## Estimate Format
+
+Estimates use simple duration format:
+- `30m` - 30 minutes
+- `2h` - 2 hours
+- `1d` - 1 day (8 hours)
+- `2h30m` - 2 hours 30 minutes
+
+If no estimate provided, gently remind:
+```
+💡 Tip: Add estimate next time with /p:now "task" 2h
+```
 
 ## Step 1: Read Config
 
@@ -34,14 +46,17 @@ IF file not found:
 
 ## Step 2: Check Current State
 
-### Read state.json (source of truth)
-READ: `{statePath}`
+### Read now.md (source of truth)
+READ: `{nowPath}`
 
-IF file exists:
-  PARSE as JSON
-  EXTRACT: {currentTask} from state.currentTask
+IF file exists AND has content:
+  PARSE MD format:
+  - Look for `**Task description**` (bold text = current task)
+  - Look for `Started: {timestamp}`
+  - Look for `Session: {sessionId}`
+  EXTRACT: {currentTask}, {startedAt}, {sessionId}
 
-### Check for active session (legacy support)
+### Check for active session (for detailed tracking)
 READ: `{sessionPath}`
 
 IF file exists:
@@ -104,23 +119,30 @@ IF {task} is provided:
   GENERATE: {sessionId} = "sess_" + 8 random alphanumeric chars
   SET: {startedAt} = GetTimestamp()
 
-  ### Write state.json (SOURCE OF TRUTH)
-  READ: `{statePath}` (or create default if not exists)
+  ### Write now.md (SOURCE OF TRUTH)
 
-  UPDATE state.json:
-  ```json
-  {
-    "currentTask": {
-      "id": "task_{8_random_chars}",
-      "description": "{task}",
-      "startedAt": "{startedAt}",
-      "sessionId": "{sessionId}"
-    },
-    "lastUpdated": "{startedAt}"
-  }
+  WRITE: `{nowPath}`
+
+  IF {estimate} provided:
+  ```markdown
+  # NOW
+
+  **{task}**
+
+  Started: {startedAt}
+  Session: {sessionId}
+  Estimate: {estimate}
   ```
 
-  WRITE: `{statePath}`
+  ELSE (no estimate):
+  ```markdown
+  # NOW
+
+  **{task}**
+
+  Started: {startedAt}
+  Session: {sessionId}
+  ```
 
   ### Create session JSON (for detailed tracking)
   WRITE: `{sessionPath}`
@@ -135,6 +157,8 @@ IF {task} is provided:
     "pausedAt": null,
     "completedAt": null,
     "duration": 0,
+    "estimate": "{estimate OR null}",
+    "estimateSeconds": {estimateInSeconds OR null},
     "metrics": {
       "filesChanged": 0,
       "linesAdded": 0,
@@ -148,26 +172,48 @@ IF {task} is provided:
   }
   ```
 
-  ### Generate views (auto-regenerate MD from JSON)
-  BASH: `cd {projectRoot} && npx prjct-generate-views --project={projectId}`
-
-  Note: This regenerates views/now.md from data/state.json automatically.
+  ### Convert estimate to seconds
+  IF {estimate} provided:
+    - "30m" → 1800 seconds
+    - "2h" → 7200 seconds
+    - "1d" → 28800 seconds (8 hours)
+    - "2h30m" → 9000 seconds
 
   ### Log to memory
   APPEND to: `{memoryPath}`
   Single line (JSONL):
+
+  IF {estimate} provided:
+  ```json
+  {"timestamp":"{startedAt}","action":"session_started","sessionId":"{sessionId}","task":"{task}","estimate":"{estimate}","estimateSeconds":{estimateInSeconds}}
+  ```
+
+  ELSE:
   ```json
   {"timestamp":"{startedAt}","action":"session_started","sessionId":"{sessionId}","task":"{task}"}
   ```
 
 ## Output
 
-SUCCESS (new task):
+SUCCESS (new task with estimate):
 ```
 🎯 {task}
 
 Session: {sessionId}
 Started: now
+Estimate: {estimate}
+
+/p:done when finished | /p:pause to take a break
+```
+
+SUCCESS (new task without estimate):
+```
+🎯 {task}
+
+Session: {sessionId}
+Started: now
+
+💡 Tip: Add estimate next time with /p:now "task" 2h
 
 /p:done when finished | /p:pause to take a break
 ```
@@ -195,7 +241,7 @@ Status: active
 /p:done to complete | /p:pause to pause
 ```
 
-### Example 2: Start New Task
+### Example 2: Start New Task (without estimate)
 ```
 User: /p:now "Add login form"
 Output:
@@ -204,6 +250,21 @@ Output:
 Session: sess_xyz98765
 Started: now
 
+💡 Tip: Add estimate next time with /p:now "task" 2h
+
+/p:done when finished | /p:pause to take a break
+```
+
+### Example 2b: Start New Task (with estimate)
+```
+User: /p:now "Add login form" 2h
+Output:
+🎯 Add login form
+
+Session: sess_xyz98765
+Started: now
+Estimate: 2h
+
 /p:done when finished | /p:pause to take a break
 ```