prjct-cli 0.35.1 → 0.35.3

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.35.2] - 2026-01-17
+
+### Fix: CLI Workflow Now Uses CommandExecutor
+
+The `workflow.ts` was calling `templateExecutor` directly, bypassing the orchestrator.
+Now properly routes through `commandExecutor.execute()` which triggers:
+- Domain detection
+- Agent loading
+- Skill loading
+- Task fragmentation
+
+**Files Changed:**
+- `core/commands/workflow.ts` - Uses `commandExecutor.execute()` instead of `templateExecutor`
+
 ## [0.35.1] - 2026-01-17
 
 ### Fix: Orchestrator Now Actually Executes
@@ -34,6 +48,7 @@ ALL COMPLETE (100%)
 - `core/agentic/command-executor.ts` - Calls orchestrator
 - `core/agentic/prompt-builder.ts` - Injects orchestrator context
 - `core/types/agentic.ts` - Added orchestrator types
+- `core/commands/workflow.ts` - **Connects CLI to CommandExecutor** (was bypassing orchestrator)
 
 ## [0.34.0] - 2026-01-15
 

package/core/commands/workflow.ts

@@ -19,6 +19,7 @@ import {
 } from './base'
 import { stateStorage, queueStorage } from '../storage'
 import { templateExecutor } from '../agentic/template-executor'
+import commandExecutor from '../agentic/command-executor'
 
 export class WorkflowCommands extends PrjctCommandsBase {
   /**
@@ -36,12 +37,13 @@ export class WorkflowCommands extends PrjctCommandsBase {
       }
 
       if (task) {
-        // AGENTIC: Build execution context for Claude to decide
-        const execContext = await templateExecutor.buildContext('task', task, projectPath)
-        const agenticInfo = templateExecutor.buildAgenticPrompt(execContext)
+        // AGENTIC: Use CommandExecutor for full orchestration support
+        const result = await commandExecutor.execute('task', { task }, projectPath)
 
-        // Get available agents for context
-        const availableAgents = await templateExecutor.getAvailableAgents(projectPath)
+        if (!result.success) {
+          out.fail(result.error || 'Failed to execute task')
+          return { success: false, error: result.error }
+        }
 
         // Write-through: JSON → MD → Event
         await stateStorage.startTask(projectId, {
@@ -50,28 +52,42 @@ export class WorkflowCommands extends PrjctCommandsBase {
           sessionId: generateUUID()
         })
 
-        // AGENTIC: Log that Claude will decide via templates
+        // Log orchestrator results if available
+        if (result.orchestratorContext) {
+          const oc = result.orchestratorContext
+          const agentsList = oc.agents.map((a: { name: string }) => a.name).join(', ') || 'none'
+          const domainsList = oc.detectedDomains.join(', ')
+          console.log(`🎯 Orchestrator: ${domainsList} → [${agentsList}]`)
+
+          if (oc.requiresFragmentation && oc.subtasks) {
+            console.log(`   → ${oc.subtasks.length} subtasks created`)
+          }
+        }
+
+        // Get available agents for backward compatibility
+        const availableAgents = await templateExecutor.getAvailableAgents(projectPath)
         const agentsList = availableAgents.length > 0
           ? availableAgents.join(', ')
           : 'none (run p. sync)'
 
-        console.log(`🤖 Agentic mode: Claude will read templates and decide`)
         out.done(`${task} [specialists: ${agentsList}]`)
 
         await this.logToMemory(projectPath, 'task_started', {
           task,
           agenticMode: true,
           availableAgents,
+          orchestratorContext: result.orchestratorContext,
           timestamp: dateHelper.getTimestamp(),
         })
 
         return {
+          // Include full CommandExecutor result first (orchestratorContext, prompt, etc.)
+          ...result,
+          // Then override with our specific values
           success: true,
           task,
           agenticMode: true,
           availableAgents,
-          execContext,
-          agenticPrompt: agenticInfo.prompt,
         }
       } else {
         // Read from storage (JSON is source of truth)

package/dist/bin/prjct.mjs

@@ -11471,6 +11471,7 @@ var init_workflow = __esm({
     init_base();
     init_storage2();
     init_template_executor();
+    init_command_executor();
     WorkflowCommands = class extends PrjctCommandsBase {
       static {
         __name(this, "WorkflowCommands");
@@ -11488,30 +11489,43 @@ var init_workflow = __esm({
             return { success: false, error: "No project ID found" };
           }
           if (task) {
-            const execContext = await templateExecutor.buildContext("task", task, projectPath);
-            const agenticInfo = templateExecutor.buildAgenticPrompt(execContext);
-            const availableAgents = await templateExecutor.getAvailableAgents(projectPath);
+            const result = await command_executor_default.execute("task", { task }, projectPath);
+            if (!result.success) {
+              output_default.fail(result.error || "Failed to execute task");
+              return { success: false, error: result.error };
+            }
             await stateStorage.startTask(projectId, {
               id: generateUUID(),
               description: task,
               sessionId: generateUUID()
             });
+            if (result.orchestratorContext) {
+              const oc = result.orchestratorContext;
+              const agentsList2 = oc.agents.map((a) => a.name).join(", ") || "none";
+              const domainsList = oc.detectedDomains.join(", ");
+              console.log(`\u{1F3AF} Orchestrator: ${domainsList} \u2192 [${agentsList2}]`);
+              if (oc.requiresFragmentation && oc.subtasks) {
+                console.log(`   \u2192 ${oc.subtasks.length} subtasks created`);
+              }
+            }
+            const availableAgents = await templateExecutor.getAvailableAgents(projectPath);
             const agentsList = availableAgents.length > 0 ? availableAgents.join(", ") : "none (run p. sync)";
-            console.log(`\u{1F916} Agentic mode: Claude will read templates and decide`);
             output_default.done(`${task} [specialists: ${agentsList}]`);
             await this.logToMemory(projectPath, "task_started", {
               task,
               agenticMode: true,
               availableAgents,
+              orchestratorContext: result.orchestratorContext,
               timestamp: date_helper_default.getTimestamp()
             });
             return {
+              // Include full CommandExecutor result first (orchestratorContext, prompt, etc.)
+              ...result,
+              // Then override with our specific values
               success: true,
               task,
               agenticMode: true,
-              availableAgents,
-              execContext,
-              agenticPrompt: agenticInfo.prompt
+              availableAgents
             };
           } else {
             const currentTask = await stateStorage.getCurrentTask(projectId);
@@ -13846,7 +13860,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "0.35.0",
+      version: "0.35.2",
       description: "Built for Claude - Ship fast, track progress, stay focused. Developer momentum tool for indie hackers.",
       main: "core/index.ts",
       bin: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "0.35.1",
+  "version": "0.35.3",
   "description": "Built for Claude - Ship fast, track progress, stay focused. Developer momentum tool for indie hackers.",
   "main": "core/index.ts",
   "bin": {

package/templates/_bases/tracker-base.md

@@ -0,0 +1,309 @@
+---
+allowed-tools: [Read, Write, Bash, AskUserQuestion]
+description: 'Base template for issue tracker integrations'
+---
+
+# Issue Tracker Base Template
+
+**This is a BASE TEMPLATE. Do not execute directly.**
+
+All issue tracker integrations (Linear, JIRA, GitHub Issues, Monday.com) inherit from this base.
+
+---
+
+## Common Context Variables
+
+- `{projectId}`: From `.prjct/prjct.config.json`
+- `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
+- `{args}`: User-provided arguments (subcommand)
+- `{tracker}`: The tracker name (linear, jira, github, monday)
+- `{mcpPrefix}`: MCP tool prefix (e.g., `mcp__linear__`, `mcp__atlassian__jira_`)
+
+---
+
+## Standard Subcommands
+
+All trackers MUST support these subcommands:
+
+| Command | Description |
+|---------|-------------|
+| `p. {tracker}` | Show status + your assigned issues |
+| `p. {tracker} setup` | Configure integration (REQUIRED FIRST) |
+| `p. {tracker} start <ID>` | Start working on issue |
+| `p. {tracker} comment <ID> <text>` | Add comment to issue |
+
+---
+
+## Step 1: Validate Project (COMMON)
+
+```
+READ: .prjct/prjct.config.json
+EXTRACT: projectId
+SET: globalPath = ~/.prjct-cli/projects/{projectId}
+
+IF file not found:
+  OUTPUT: "No prjct project. Run `p. init` first."
+  STOP
+```
+
+---
+
+## Step 2: Check Authentication (TRACKER-SPECIFIC)
+
+**Override this section per tracker.**
+
+Common patterns:
+- **MCP OAuth** (Linear, JIRA): First use opens browser
+- **API Token** (GitHub): Requires env var
+- **Both supported** (JIRA): OAuth preferred, token fallback
+
+```
+# Check for existing config
+READ: {globalPath}/project.json → integrations.{tracker}
+
+IF config exists AND config.enabled:
+  # Use existing credentials
+  SET: authMode = config.authMode
+ELSE:
+  # Need setup
+  OUTPUT: "{TRACKER} not configured. Run `p. {tracker} setup` first."
+  STOP
+```
+
+---
+
+## Step 3: Install MCP Server (COMMON)
+
+```
+READ: ~/.claude/settings.json (create {} if not exists)
+CHECK: Does mcpServers.{mcpServerName} exist?
+
+IF not exists:
+  MERGE MCP config:
+  {
+    "mcpServers": {
+      "{mcpServerName}": {mcpConfig}
+    }
+  }
+
+  WRITE: ~/.claude/settings.json
+
+  OUTPUT: "✅ Installed {TRACKER} MCP server"
+  OUTPUT: ""
+  OUTPUT: "⚠️ Restart Claude Code to activate the MCP server."
+  OUTPUT: "Then run `p. {tracker} setup` again to complete configuration."
+  STOP
+```
+
+---
+
+## Step 4: Check MCP Tools Available (COMMON)
+
+```
+CHECK: Are {mcpPrefix}* tools available?
+
+IF not available:
+  OUTPUT: "{TRACKER} MCP is installed but not yet active."
+  OUTPUT: "Restart Claude Code, then run `p. {tracker} setup` again."
+  STOP
+```
+
+---
+
+## Subcommand: setup (COMMON FLOW)
+
+### Flow
+
+1. **Install MCP + Verify tools available**
+   - Execute Step 3 (auto-install if needed)
+   - Execute Step 4 (verify tools active)
+   - IF not available: Prompt restart and STOP
+
+2. **Test connection (TRACKER-SPECIFIC)**
+   - Call list/get endpoint to verify auth
+   - MCP OAuth may open browser on first call
+
+3. **Get user info (TRACKER-SPECIFIC)**
+   - Get current user
+   - List available projects/teams
+
+4. **Ask user to select project/team**
+   ```
+   ASK: "Select your default {project|team|board}"
+   OPTIONS: List from step 3
+   ```
+
+5. **Save config to project.json**
+   ```json
+   {
+     "integrations": {
+       "{tracker}": {
+         "enabled": true,
+         "authMode": "{mcp|token}",
+         "{projectKey}": "{selected}",
+         "setupAt": "{timestamp}"
+       }
+     }
+   }
+   ```
+
+### Output
+
+```
+✅ {TRACKER} configured
+
+{Connected as: {user} (if available)}
+{Project|Team}: {name}
+Auth: {authMode}
+
+Next: `p. {tracker}` to see your issues
+```
+
+---
+
+## Subcommand: status (default, no args) - COMMON FLOW
+
+```
+1. Validate auth (Step 2)
+2. Call list issues API with assignee filter
+3. Format and display
+
+OUTPUT:
+{TRACKER}: Connected ✓
+{Project|Team}: {name}
+
+Your issues ({count}):
+• {ID-1} {title} ({status})
+• {ID-2} {title} ({status})
+...
+
+Next: `p. {tracker} start {ID}` to begin work
+```
+
+---
+
+## Subcommand: start <ID> - COMMON FLOW
+
+```
+1. Get issue by ID
+   USE: {mcpPrefix}get_issue or equivalent
+
+2. Update status to "In Progress"
+   USE: {mcpPrefix}update_issue or transition
+
+3. Create prjct task from issue
+   - Extract title, description
+   - Create task with linked issueId
+
+4. Create git branch
+   SET: branchName = {type}/{ID}-{slug}
+   BASH: git checkout -b {branchName}
+
+OUTPUT:
+Started: {ID} - {title}
+
+Branch: {branchName}
+{TRACKER}: In Progress ✓
+
+Next: Work on the task, then `p. done`
+```
+
+---
+
+## Subcommand: comment <ID> <text> - COMMON FLOW
+
+```
+1. Get issue ID (may need to lookup)
+2. Add comment via MCP
+
+OUTPUT:
+Comment added to {ID}
+```
+
+---
+
+## Config Storage (COMMON)
+
+| What | Where |
+|------|-------|
+| Auth | Varies: Env var, MCP OAuth, or keychain |
+| Config | `{globalPath}/project.json` → `integrations.{tracker}` |
+| Issue cache | `{globalPath}/storage/issues.json` (optional) |
+
+---
+
+## Error Handling (COMMON)
+
+| Error | Action |
+|-------|--------|
+| No project | "Run `p. init` first" |
+| Auth not configured | "Run `p. {tracker} setup` first" |
+| MCP tools not found | "Restart Claude Code after setup" |
+| Auth failed | Re-authenticate message |
+| Issue not found | "Issue {ID} not found in {TRACKER}" |
+| Rate limited | "Rate limited. Try again later" |
+
+---
+
+## Output Format (COMMON)
+
+```
+{action}: {result}
+
+{details}
+
+Next: {suggested action}
+```
+
+---
+
+## MCP Tool Mapping
+
+| Operation | Pattern |
+|-----------|---------|
+| List issues | `{mcpPrefix}list_issues` |
+| Get issue | `{mcpPrefix}get_issue` |
+| Update issue | `{mcpPrefix}update_issue` |
+| Create issue | `{mcpPrefix}create_issue` |
+| Add comment | `{mcpPrefix}create_comment` |
+
+---
+
+## Tracker-Specific Overrides
+
+When implementing a tracker:
+
+1. **INHERIT** all common flows from this base
+2. **OVERRIDE** authentication check with tracker-specific logic
+3. **IMPLEMENT** MCP tool calls with correct tool names
+4. **ADD** tracker-specific subcommands if needed
+
+---
+
+## Example Implementation Pattern
+
+```markdown
+# p. {tracker} - {Tracker Name} Integration
+
+**EXTENDS**: `_bases/tracker-base.md`
+
+## Tracker-Specific Config
+
+- `{mcpServerName}`: "{mcp server identifier}"
+- `{mcpPrefix}`: "{tool prefix}"
+- `{projectKey}`: "{what they call it - team, project, repo}"
+
+## Authentication Override
+
+{Tracker-specific auth flow}
+
+## MCP Tool Reference
+
+| Operation | MCP Tool |
+|-----------|----------|
+{Tracker-specific tool mappings}
+
+## Additional Subcommands (if any)
+
+{Tracker-specific commands}
+```