prjct-cli 0.35.1 → 0.35.3

package/templates/commands/p.md

@@ -7,79 +7,214 @@ allowed-tools: [Read, Write, Edit, Bash, Glob, Grep, Task, AskUserQuestion, Todo
 
 **ARGUMENTS**: $ARGUMENTS
 
-## Instructions
-
-1. Parse ARGUMENTS: first word = `command`, rest = `commandArgs`
-2. Get npm global root:
-   ```bash
-   npm root -g
-   ```
-3. **Run Orchestrator** (for task-related commands):
-   - Read: `{npmRoot}/prjct-cli/templates/agentic/orchestrator.md`
-   - Execute orchestrator Steps 1-5 to load agents and skills
-4. Read command template:
-   ```
-   {npmRoot}/prjct-cli/templates/commands/{command}.md
-   ```
-5. Execute template with `commandArgs` + orchestrator context
-
-## Orchestrator Integration
-
-For these commands, run orchestrator FIRST:
-- `task`, `done`, `ship` - Core workflow
-- `bug`, `plan`, `prd`, `spec`, `design` - Planning
-- `review`, `merge` - Git operations
-
-Skip orchestrator for:
-- `init`, `sync`, `setup` - Project config (no task context)
-- `dash`, `next`, `history` - Read-only views
-- `linear`, `jira`, `github`, `monday` - Integrations (own logic)
-
-## Example
-
-ARGUMENTS = "task fix the login bug"
-
-1. command = "task"
-2. commandArgs = "fix the login bug"
-3. npm root -g → `/opt/homebrew/lib/node_modules`
-4. **Orchestrator**:
-   - Analyze: "login bug" → domains: [frontend, backend]
-   - Load agents: frontend.md, backend.md
-   - Invoke skills: ui-design, api-design
-5. Read: `/opt/homebrew/lib/node_modules/prjct-cli/templates/commands/task.md`
-6. Execute with: "fix the login bug" + orchestrator context
+## Quick Routing
 
-## Available Commands
+Parse ARGUMENTS and route to the correct command template.
+
+```
+PARSE: $ARGUMENTS
+SET: command = first word (lowercase)
+SET: commandArgs = rest of arguments
+```
+
+---
+
+## Command Aliases (Redirects)
+
+These commands redirect to unified commands:
+
+| Input | Redirects To |
+|-------|--------------|
+| `p. undo` | `p. history undo` |
+| `p. redo` | `p. history redo` |
+
+If command is `undo` or `redo`:
+  PREPEND "history" to arguments
+  SET: command = "history"
+  SET: commandArgs = "{original_command} {commandArgs}"
+
+---
+
+## Command Categories
+
+### Core Workflow (use orchestrator)
+- `task` - Start any task with PM Expert enrichment
+- `done` - Complete current subtask
+- `ship` - Ship feature with version bump
+
+### Planning (use orchestrator for task context)
+- `plan` - Quarter-based roadmap planning
+- `prd` - Create PRD with Chief Architect
+- `spec` - Spec-driven development
+- `design` - Design workflow
+- `enrich` - Ticket enrichment
+
+### Project Management (no orchestrator)
+- `init` - Initialize project
+- `sync` - Deep project analysis
+- `setup` - Configure prjct
+- `dash` - View dashboard
+
+### Queue & Ideas (no orchestrator)
+- `next` - Show priority queue
+- `idea` - Quick idea capture
+- `bug` - Report bug with auto-priority
+
+### Issue Trackers (own logic)
+- `linear` - Linear integration
+- `jira` - JIRA integration
+- `github` - GitHub Issues integration
+- `monday` - Monday.com integration
+
+### Git Operations (use orchestrator)
+- `git` - Smart git operations
+- `merge` - Merge PR
+- `review` - Code review
+
+### Analysis (no orchestrator)
+- `analyze` - Analyze project
+- `history` - View/undo/redo snapshots
+- `impact` - Track outcomes
+
+### Utilities (no orchestrator)
+- `cleanup` - Code cleanup
+- `update` - Force update prjct
+- `verify` - Verify completion
+- `test` - Run tests
+- `serve` - Start web server
+- `auth` - Manage authentication
+- `skill` - Skill management
+- `pause` - Pause current task
+- `resume` - Resume paused task
+
+---
+
+## Execution Flow
+
+### Step 1: Get npm global root
+
+```bash
+npm root -g
+```
+
+SET: npmRoot = result
+
+### Step 2: Load State (always)
+
+```
+READ: .prjct/prjct.config.json
+EXTRACT: projectId
+
+IF file exists:
+  SET: globalPath = ~/.prjct-cli/projects/{projectId}
+  READ: {globalPath}/storage/state.json (if exists)
+  SET: hasActiveTask = state.currentTask != null
+```
+
+### Step 3: Load Agent (if project has one)
+
+```
+IF {globalPath}/agents/ has files:
+  # Load the main project agent (generated by sync)
+  GLOB: {globalPath}/agents/*.md
+  READ: first agent file (project-specific patterns)
+  SET: agentContext = agent content
+```
+
+### Step 4: Check if orchestrator needed
 
-**Core**: `task` `done` `ship` `pause` `resume`
-**Project**: `init` `sync` `setup` `dash`
-**Planning**: `plan` `prd` `spec` `design` `enrich`
-**Queue**: `next` `idea` `bug`
-**Integrations**: `linear` `jira` `github` `monday`
-**Git**: `git` `merge` `review`
-**Analysis**: `analyze` `history` `impact`
-**Utils**: `cleanup` `update` `verify` `test` `undo` `redo` `serve` `auth` `skill`
+Commands that benefit from orchestrator (task context + agent loading):
+- `task`, `done`, `ship`
+- `bug`, `plan`, `prd`, `spec`, `design`
+- `review`, `merge`
 
-## Orchestrator Output
+For these commands:
+```
+READ: {npmRoot}/prjct-cli/templates/agentic/orchestrator.md
+EXECUTE: orchestrator Steps 1-5 to build execution context
+```
+
+### Step 5: Load and execute command template
+
+```
+READ: {npmRoot}/prjct-cli/templates/commands/{command}.md
+EXECUTE: template with:
+  - commandArgs as $ARGUMENTS
+  - orchestrator context (if loaded)
+  - agent context (if loaded)
+  - state context (if available)
+```
+
+---
+
+## State Context Injection
+
+When executing any command, include:
+
+```
+## Current State
+
+Project: {projectId}
+{IF hasActiveTask:}
+Active Task: {state.currentTask.description}
+Branch: {state.currentTask.branch.name}
+Subtask: {state.currentTask.currentSubtaskIndex + 1}/{state.currentTask.subtasks.length}
+{ELSE:}
+No active task.
+{ENDIF}
+```
+
+---
 
-When orchestrator runs, output:
+## Output Format
+
+For orchestrator-enabled commands, output context header:
 
 ```
 🎯 Task: {commandArgs}
 
 📦 Context:
-├── Agents: {loadedAgents}
-├── Skills: {activeSkills}
-└── Domain: {primaryDomain}
+├── Agent: {loadedAgent || 'none'}
+├── State: {hasActiveTask ? 'active task' : 'no task'}
+└── Domain: {detectedDomain || 'general'}
+
+{Continue with command execution...}
 ```
 
-Then proceed with command execution.
+For utility commands, execute directly without context header.
+
+---
+
+## Error Handling
+
+| Error | Action |
+|-------|--------|
+| Unknown command | "Unknown command: {command}. Run `p. help` for available commands." |
+| No project | "No prjct project. Run `p. init` first." (for commands that need project) |
+| Template not found | "Template not found: {command}.md" |
+
+---
+
+## Available Commands
+
+```
+Core:     task  done  ship  pause  resume
+Project:  init  sync  setup  dash
+Planning: plan  prd  spec  design  enrich
+Queue:    next  idea  bug
+Trackers: linear  jira  github  monday
+Git:      git  merge  review
+Analysis: analyze  history  impact
+Utils:    cleanup  update  verify  test  serve  auth  skill
+```
+
+---
 
-## Action
+## NOW: Execute
 
-NOW:
-1. Run `npm root -g`
-2. Check if command needs orchestrator
-3. If yes: Read and execute orchestrator.md
-4. Read the command template
-5. Execute with full context
+1. Parse command from $ARGUMENTS
+2. Handle aliases (undo → history undo, redo → history redo)
+3. Run `npm root -g` to get template path
+4. Load state and agent context
+5. Check if orchestrator needed
+6. Load and execute command template

package/templates/commands/resume.md

@@ -1,6 +1,6 @@
 ---
-allowed-tools: [Read, Write, Bash, AskUserQuestion]
-description: 'Resume paused or interrupted session'
+allowed-tools: [Read, Write, Bash, Glob, AskUserQuestion]
+description: 'Resume paused or interrupted session with full context'
 timestamp-rule: 'GetTimestamp() for all timestamps'
 architecture: 'Write-Through (JSON → MD → Events)'
 storage-layer: true
@@ -9,7 +9,19 @@ claude-context: 'context/now.md'
 backend-sync: 'sync/pending.json'
 ---
 
-# /p:resume - Resume Paused Session
+# p. resume - Resume Session with Full Context
+
+**Purpose**: Resume work on a project by loading full context from the last session.
+
+## IMPORTANT: Multi-Session Continuity
+
+When starting a NEW Claude Code session (not just resuming a paused task), `p. resume` provides:
+- Full project state including active task
+- Enterprise domain progress
+- Stack and patterns from project agent
+- Session context (last action, next steps, blockers)
+
+This is the recommended way to start any session on an existing project.
 
 ## Architecture: Write-Through Pattern
 
@@ -155,7 +167,36 @@ SET: state.{clearField} = null  # Clear pausedTask or interruptedTask based on w
 SET: state.lastUpdated = {now}
 WRITE: `{statePath}`
 
-## Step 5: Generate Context (FOR CLAUDE)
+## Step 5: Load Enterprise Context (NEW)
+
+### 5.1 Load Project Agent
+
+```
+GLOB: {globalPath}/agents/*.md
+IF files found:
+  READ: first agent file
+  SET: agentContent = file content
+  SET: agentName = filename
+```
+
+### 5.2 Extract Enterprise State
+
+```
+IF state.domains exists:
+  SET: hasDomains = true
+  SET: domains = state.domains
+
+IF state.stack exists:
+  SET: hasStack = true
+  SET: stack = state.stack
+
+IF state.context exists:
+  SET: lastAction = state.context.lastAction
+  SET: nextAction = state.context.nextAction
+  SET: blockers = state.context.blockers
+```
+
+## Step 6: Generate Context (FOR CLAUDE)
 
 WRITE: `{nowContextPath}`
 
@@ -169,6 +210,29 @@ Resumed: {now}
 Session: {taskToResume.sessionId}
 {IF taskToResume.estimate: Estimate: {taskToResume.estimate}}
 {IF taskToResume.subtasks: Subtask: {currentSubtask.description}}
+
+{IF hasStack:}
+## Stack
+- Language: {stack.language}
+- Framework: {stack.framework}
+- State: {stack.stateManagement}
+{ENDIF}
+
+{IF hasDomains:}
+## Domain Progress
+{FOR EACH [name, info] in domains:}
+- {name}: {info.progress}% ({info.status})
+{END FOR}
+{ENDIF}
+
+{IF lastAction:}
+## Session Context
+- Last Action: {lastAction}
+- Next: {nextAction}
+{IF blockers:}
+- Blockers: {blockers.join(', ')}
+{ENDIF}
+{ENDIF}
 ```
 
 ## Step 6: Queue Sync Event (FOR BACKEND)

package/templates/commands/sync.md

@@ -372,6 +372,109 @@ WRITE: `{globalPath}/analysis/repo-analysis.json`
 
 ---
 
+## Step 3.5.7: Update Enterprise State (CRITICAL for Multi-Session)
+
+**CRITICAL**: This step updates state.json with enterprise fields for multi-session continuity.
+
+### 3.5.7.1 Read Existing State
+
+```
+READ: {globalPath}/storage/state.json
+
+IF file not found:
+  CREATE default state:
+  {
+    "projectId": "{projectId}",
+    "currentTask": null,
+    "queue": [],
+    "shipped": []
+  }
+```
+
+### 3.5.7.2 Update Stack Info
+
+```
+SET: state.stack = {
+  "language": "{detected language - e.g., TypeScript, Python, Go}",
+  "runtime": "{runtime - e.g., Node.js, Python 3.11, Go 1.21}",
+  "framework": "{primary framework - e.g., React, Django, Gin}",
+  "stateManagement": "{if detected - e.g., Zustand, Redux, None}",
+  "database": "{if detected - e.g., PostgreSQL, MongoDB}",
+  "styling": "{if detected - e.g., Tailwind, CSS Modules}",
+  "testRunner": "{test framework - e.g., Vitest, Pytest, go test}"
+}
+```
+
+### 3.5.7.3 Determine Project Type
+
+```
+# Count domains detected
+SET: domainCount = count of detected domains (frontend, backend, database, etc.)
+
+# Determine project type
+IF fileCount > 300 OR domainCount >= 4:
+  SET: state.projectType = "enterprise"
+ELSE IF domainCount >= 2 OR fileCount > 50:
+  SET: state.projectType = "complex"
+ELSE:
+  SET: state.projectType = "simple"
+```
+
+### 3.5.7.4 Initialize Domains (Enterprise Projects)
+
+IF state.projectType == "enterprise" OR state.projectType == "complex":
+
+```
+# Detect and initialize domain progress
+SET: state.domains = {}
+
+FOR EACH domain in {detectedDomains}:
+  # Count files in domain area
+  COUNT files matching domain patterns
+
+  SET: state.domains[domain] = {
+    "status": "pending",
+    "progress": 0,
+    "tests": "none",
+    "keyFiles": ["{detected key files for domain}"],
+    "dependencies": []
+  }
+```
+
+### 3.5.7.5 Update Metrics
+
+```
+SET: state.metrics = {
+  "totalFiles": {fileCount},
+  "totalLOC": {locCount if available},
+  "testCoverage": null,
+  "lastBuild": "unknown"
+}
+```
+
+### 3.5.7.6 Update Session Context
+
+```
+SET: state.lastSync = {timestamp}
+SET: state.lastUpdated = {timestamp}
+
+IF state.context does not exist:
+  SET: state.context = {}
+
+SET: state.context.lastSession = {timestamp}
+SET: state.context.lastAction = "Synced project"
+SET: state.context.nextAction = "Run `p. task \"description\"` to start working"
+```
+
+### 3.5.7.7 Write Updated State
+
+```
+WRITE: {globalPath}/storage/state.json
+OUTPUT: "📊 Updated state.json with enterprise fields"
+```
+
+---
+
 ## Step 3.6: Generate/Update Roadmap (For Existing Projects)
 
 **CRITICAL**: This step populates the roadmap from git history for existing projects.

package/packages/shared/node_modules/@types/bun/LICENSE

@@ -1,21 +0,0 @@
-    MIT License
-
-    Copyright (c) Microsoft Corporation.
-
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to deal
-    in the Software without restriction, including without limitation the rights
-    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-    copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in all
-    copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-    SOFTWARE

package/packages/shared/node_modules/@types/bun/README.md

@@ -1,20 +0,0 @@
-# Installation
-> `npm install --save @types/bun`
-
-# Summary
-This package contains type definitions for bun (https://bun.com).
-
-# Details
-Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/bun.
-## [index.d.ts](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/bun/index.d.ts)
-````ts
-/// <reference types="bun-types" />
-
-````
-
-### Additional Details
- * Last updated: Thu, 18 Dec 2025 18:43:14 GMT
- * Dependencies: [bun-types](https://npmjs.com/package/bun-types)
-
-# Credits
-These definitions were written by [Jarred Sumner](https://github.com/Jarred-Sumner), [Robobun](https://github.com/robobun), [Dylan Conway](https://github.com/dylan-conway), [Meghan Denny](https://github.com/nektro), [Michael H](https://github.com/RiskyMH), and [Alistair Smith](https://github.com/alii).

package/packages/shared/node_modules/@types/bun/index.d.ts

@@ -1 +0,0 @@
-/// <reference types="bun-types" />

package/packages/shared/node_modules/@types/bun/node_modules/bun-types/CLAUDE.md

@@ -1,105 +0,0 @@
-Default to using Bun instead of Node.js.
-
-- Use `bun <file>` instead of `node <file>` or `ts-node <file>`
-- Use `bun test` instead of `jest` or `vitest`
-- Use `bun build <file.html|file.ts|file.css>` instead of `webpack` or `esbuild`
-- Use `bun install` instead of `npm install` or `yarn install` or `pnpm install`
-- Use `bun run <script>` instead of `npm run <script>` or `yarn run <script>` or `pnpm run <script>`
-- Use `bunx <package> <command>` instead of `npx <package> <command>`
-- Bun automatically loads .env, so don't use dotenv.
-
-## APIs
-
-- `Bun.serve()` supports WebSockets, HTTPS, and routes. Don't use `express`.
-- `bun:sqlite` for SQLite. Don't use `better-sqlite3`.
-- `Bun.redis` for Redis. Don't use `ioredis`.
-- `Bun.sql` for Postgres. Don't use `pg` or `postgres.js`.
-- `WebSocket` is built-in. Don't use `ws`.
-- Prefer `Bun.file` over `node:fs`'s readFile/writeFile
-- Bun.$`ls` instead of execa.
-
-## Testing
-
-Use `bun test` to run tests.
-
-```ts#index.test.ts
-import { test, expect } from "bun:test";
-
-test("hello world", () => {
-  expect(1).toBe(1);
-});
-```
-
-## Frontend
-
-Use HTML imports with `Bun.serve()`. Don't use `vite`. HTML imports fully support React, CSS, Tailwind.
-
-Server:
-
-```ts#index.ts
-import index from "./index.html"
-
-Bun.serve({
-  routes: {
-    "/": index,
-    "/api/users/:id": {
-      GET: (req) => {
-        return new Response(JSON.stringify({ id: req.params.id }));
-      },
-    },
-  },
-  // optional websocket support
-  websocket: {
-    open: (ws) => {
-      ws.send("Hello, world!");
-    },
-    message: (ws, message) => {
-      ws.send(message);
-    },
-    close: (ws) => {
-      // handle close
-    }
-  },
-  development: {
-    hmr: true,
-    console: true,
-  }
-})
-```
-
-HTML files can import .tsx, .jsx or .js files directly and Bun's bundler will transpile & bundle automatically. `<link>` tags can point to stylesheets and Bun's CSS bundler will bundle.
-
-```html#index.html
-<html>
-  <body>
-    <h1>Hello, world!</h1>
-    <script type="module" src="./frontend.tsx"></script>
-  </body>
-</html>
-```
-
-With the following `frontend.tsx`:
-
-```tsx#frontend.tsx
-import React from "react";
-import { createRoot } from "react-dom/client";
-
-// import .css files directly and it works
-import './index.css';
-
-const root = createRoot(document.body);
-
-export default function Frontend() {
-  return <h1>Hello, world!</h1>;
-}
-
-root.render(<Frontend />);
-```
-
-Then, run index.ts
-
-```sh
-bun --hot ./index.ts
-```
-
-For more information, read the Bun API docs in `docs/**.mdx`.

package/packages/shared/node_modules/@types/bun/node_modules/bun-types/README.md

@@ -1,33 +0,0 @@
-# TypeScript types for Bun
-
-<p align="center">
-  <a href="https://bun.com"><img src="https://bun.com/logo@2x.png" alt="Logo"></a>
-</p>
-
-These are the type definitions for Bun's JavaScript runtime APIs.
-
-# Installation
-
-Install the `@types/bun` npm package:
-
-```bash
-# yarn/npm/pnpm work too
-# @types/bun is an ordinary npm package
-bun add -D @types/bun
-```
-
-That's it! VS Code and TypeScript automatically load `@types/*` packages into your project, so the `Bun` global and all `bun:*` modules should be available immediately.
-
-# Contributing
-
-The `@types/bun` package is a shim that loads `bun-types`. The `bun-types` package lives in the Bun repo under `packages/bun-types`.
-
-To add a new file, add it under `packages/bun-types`. Then add a [triple-slash directive](https://www.typescriptlang.org/docs/handbook/triple-slash-directives.html) pointing to it inside [./index.d.ts](./index.d.ts).
-
-```diff
-+ /// <reference path="./newfile.d.ts" />
-```
-
-```bash
-bun build
-```