prjct-cli 0.10.13 → 0.11.0

package/CHANGELOG.md

@@ -1,5 +1,63 @@
 # Changelog
 
+## [0.11.0] - 2025-12-08
+
+### Added - Web Application & Server Components
+
+Major release introducing the prjct web application with Next.js.
+
+- **Web Application** - Full Next.js web interface for prjct
+  - Project stats API implementation
+  - Enhanced UI components
+  - Terminal functionality in browser
+
+- **Server Components** - New server infrastructure
+  - Project management endpoints
+  - Stats API for metrics and analytics
+
+- **UI Enhancements**
+  - Improved project management interface
+  - Enhanced terminal integration
+
+## [0.10.14] - 2025-11-29
+
+### Refactored - 100% Agentic Subagent Delegation via Task Tool
+
+Claude now delegates to specialist agents using the Task tool with efficient reference passing.
+
+- **`command-executor.js`** - Eliminated all if/else agent assignment logic
+  - Removed: `MandatoryAgentRouter`, `ContextFilter`, `ContextEstimator`
+  - Removed: `isTaskCommand()`, `shouldUseAgent()` methods
+  - JS only loads templates and context, Claude decides everything
+  - Added: `agentsPath` and `agentRoutingPath` to context for Claude
+
+- **Templates updated with Agent Delegation section**:
+  - `feature.md` - Added Task + Glob tools, agent delegation instructions
+  - `bug.md` - Added Task + Glob tools, agent delegation instructions
+  - `task.md` - Added Task + Glob tools, agent delegation instructions
+
+- **`agent-routing.md`** - Added efficient Task tool invocation
+  - Pass file PATH (~200 bytes), not content (3-5KB)
+  - Subagent reads agent file itself
+  - Reduced context bloat by 95%
+
+### Architecture
+
+```
+Usuario: "p. feature mejorar UX"
+    ↓
+Claude lee agent-routing.md → decide: "ux-ui"
+    ↓
+Claude: Task(prompt='Read: path/agents/ux-ui.md + Task: mejorar UX')
+    ↓
+Subagente: Lee archivo → aplica expertise → ejecuta
+```
+
+**Benefits:**
+- 95% reduction in prompt size for delegation
+- Lower hallucination risk
+- True 100% agentic - JS is pure orchestration
+
 ## [0.10.12] - 2025-11-29
 
 ### Refactored - Mandatory Agent Assignment (100% Agentic)

package/CLAUDE.md

@@ -55,8 +55,14 @@ p. ship       → Lint/test/commit/push
 
 When message starts with `p.`:
 1. Check `.prjct/prjct.config.json` exists
-2. If exists → Detect intent → Execute `/p:*` command
-3. If not exists → "No prjct project. Run /p:init first."
+2. Detect intent from message
+3. **USE SlashCommand tool** to execute the command
+
+⚠️ **CRITICAL** - Always use SlashCommand, never work directly:
+- ✅ `SlashCommand("/p:feature add dark mode")`
+- ❌ Directly creating files without the command
+
+If no project: "No prjct project. Run /p:init first."
 
 ### Intent Map
 
@@ -201,3 +207,42 @@ Use: `generator.generateDynamicAgent(name, config)`
 4. **Confirm before executing** - Always show plan first
 5. **Log actions** - Append to memory/context.jsonl
 6. **Suggest next actions** - Maintain user momentum
+
+## Output Philosophy
+
+**Task completion responses MUST be concise (< 4 lines):**
+
+Format:
+```
+✅ [What was done]
+
+Files: [count] | Modified: [key file]
+Next: [action]
+```
+
+**NEVER include in task summaries:**
+- Tables listing files
+- "Created Files" / "Modified Files" sections
+- "How It Works" explanations
+- Code snippets or implementation details
+- Detailed breakdowns of what was done
+
+**Example (GOOD):**
+```
+✅ Agentic checklists integrated
+
+Files: 11 created | Modified: prompt-builder.js
+Next: /p:ship or test with /p:now
+```
+
+**Example (BAD):**
+```
+Created Files:
+| File | Purpose |
+|------|---------|
+| x.md | Does X  |
+...
+
+How It Works:
+Claude reads → decides → applies...
+```

package/bin/dev.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+
+/**
+ * prjct dev - Start prjct web development environment
+ *
+ * Launches Next.js fullstack app on port 9472
+ * - Frontend + API routes + WebSocket for PTY
+ *
+ * Usage: prjct dev [--no-open]
+ */
+
+const { spawn, exec } = require('child_process')
+const path = require('path')
+const os = require('os')
+
+// Configuration
+const PORT = process.env.PRJCT_PORT || 9472
+const WEB_URL = `http://localhost:${PORT}`
+
+// Colors for terminal output
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  magenta: '\x1b[35m'
+}
+
+// Find prjct-cli root (where packages/ lives)
+function findPrjctRoot() {
+  const locations = [
+    path.join(__dirname, '..'),
+    path.join(os.homedir(), 'Apps', 'prjct', 'prjct-cli'),
+    path.join(os.homedir(), '.prjct-cli', 'source'),
+  ]
+
+  for (const loc of locations) {
+    const pkgPath = path.join(loc, 'packages')
+    try {
+      require('fs').accessSync(pkgPath)
+      return loc
+    } catch {}
+  }
+
+  return locations[0]
+}
+
+const PRJCT_ROOT = findPrjctRoot()
+const WEB_PATH = path.join(PRJCT_ROOT, 'packages', 'web')
+
+// Print banner
+function printBanner() {
+  console.log(`
+${colors.cyan}${colors.bright}╔═══════════════════════════════════════════════╗
+║                                               ║
+║   ⚡ prjct dev                                 ║
+║                                               ║
+║   App:     ${colors.green}http://localhost:${PORT}${colors.cyan}            ║
+║                                               ║
+║   ${colors.dim}Press Ctrl+C to stop${colors.cyan}${colors.bright}                        ║
+║                                               ║
+╚═══════════════════════════════════════════════╝${colors.reset}
+`)
+}
+
+// Open browser based on OS
+function openBrowser(url) {
+  const platform = os.platform()
+  let command
+
+  switch (platform) {
+    case 'darwin':
+      command = `open "${url}"`
+      break
+    case 'win32':
+      command = `start "" "${url}"`
+      break
+    default:
+      command = `xdg-open "${url}"`
+  }
+
+  exec(command, (err) => {
+    if (err) {
+      console.log(`${colors.yellow}Could not open browser automatically. Visit: ${url}${colors.reset}`)
+    }
+  })
+}
+
+// Check if port is available
+function checkPort(port) {
+  return new Promise((resolve) => {
+    const net = require('net')
+    const server = net.createServer()
+
+    server.once('error', () => resolve(false))
+    server.once('listening', () => {
+      server.close()
+      resolve(true)
+    })
+
+    server.listen(port)
+  })
+}
+
+// Wait for server to be ready
+function waitForServer(port, maxAttempts = 60) {
+  return new Promise((resolve, reject) => {
+    let attempts = 0
+
+    const check = () => {
+      const http = require('http')
+      const req = http.get(`http://localhost:${port}`, (res) => {
+        resolve(true)
+      })
+
+      req.on('error', () => {
+        attempts++
+        if (attempts >= maxAttempts) {
+          reject(new Error(`Server on port ${port} did not start`))
+        } else {
+          setTimeout(check, 500)
+        }
+      })
+
+      req.end()
+    }
+
+    check()
+  })
+}
+
+// Main function
+async function main() {
+  const args = process.argv.slice(2)
+  const noOpen = args.includes('--no-open')
+
+  // Check port
+  const portAvailable = await checkPort(PORT)
+
+  if (!portAvailable) {
+    console.log(`${colors.red}Port ${PORT} is already in use. Stop other services or set PRJCT_PORT.${colors.reset}`)
+    process.exit(1)
+  }
+
+  printBanner()
+
+  // Start Next.js with custom server
+  console.log(`${colors.cyan}Starting prjct...${colors.reset}`)
+  const webProc = spawn('npm', ['run', 'dev'], {
+    cwd: WEB_PATH,
+    env: { ...process.env, PORT: PORT.toString() },
+    stdio: ['ignore', 'pipe', 'pipe'],
+    shell: true
+  })
+
+  webProc.stdout.on('data', (data) => {
+    const lines = data.toString().split('\n').filter(Boolean)
+    lines.forEach(line => {
+      // Show relevant output
+      if (line.includes('ready') || line.includes('Ready') || line.includes('[WS]')) {
+        console.log(`${colors.green}${line}${colors.reset}`)
+      } else if (!line.includes('╔') && !line.includes('║') && !line.includes('╚')) {
+        console.log(`${colors.dim}${line}${colors.reset}`)
+      }
+    })
+  })
+
+  webProc.stderr.on('data', (data) => {
+    const msg = data.toString().trim()
+    // Filter out common non-error messages
+    if (!msg.includes('ExperimentalWarning') && !msg.includes('punycode')) {
+      console.log(`${colors.red}${msg}${colors.reset}`)
+    }
+  })
+
+  // Wait for server and open browser
+  try {
+    console.log(`${colors.dim}Waiting for server to start...${colors.reset}`)
+    await waitForServer(PORT)
+
+    console.log(`${colors.green}${colors.bright}Ready!${colors.reset}\n`)
+
+    if (!noOpen) {
+      setTimeout(() => openBrowser(WEB_URL), 500)
+    }
+  } catch (err) {
+    console.log(`${colors.red}${err.message}${colors.reset}`)
+  }
+
+  // Handle shutdown
+  const cleanup = () => {
+    console.log(`\n${colors.yellow}Shutting down...${colors.reset}`)
+    webProc.kill()
+    process.exit(0)
+  }
+
+  process.on('SIGINT', cleanup)
+  process.on('SIGTERM', cleanup)
+
+  webProc.on('error', (err) => {
+    console.log(`${colors.red}Error: ${err.message}${colors.reset}`)
+  })
+
+  webProc.on('exit', (code) => {
+    if (code !== 0 && code !== null) {
+      console.log(`${colors.red}Exited with code ${code}${colors.reset}`)
+    }
+  })
+}
+
+main().catch((err) => {
+  console.error(`${colors.red}Error: ${err.message}${colors.reset}`)
+  process.exit(1)
+})

package/bin/prjct

@@ -9,6 +9,14 @@
 const { VERSION } = require('../core/utils/version')
 const editorsConfig = require('../core/infrastructure/editors-config')
 
+// Check for special subcommands that bypass normal CLI
+const args = process.argv.slice(2)
+if (args[0] === 'dev') {
+  // Launch prjct dev environment
+  require('./dev.js')
+  process.exitCode = 0
+} else {
+
 // Ensure setup has run for this version
 ;(async function ensureSetup() {
   try {
@@ -32,3 +40,5 @@ const editorsConfig = require('../core/infrastructure/editors-config')
   // Continue to main CLI logic
   require('../core/index')
 })()
+
+} // end else

package/bin/serve.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+/**
+ * prjct serve - Start the web server
+ *
+ * Launches the prjct web interface with Claude Code CLI integration.
+ * Uses your existing Claude subscription via PTY - no API costs!
+ */
+
+const { spawn } = require('child_process')
+const path = require('path')
+const fs = require('fs')
+
+const serverDir = path.join(__dirname, '..', 'packages', 'server')
+const webDir = path.join(__dirname, '..', 'packages', 'web')
+
+// Parse arguments
+const args = process.argv.slice(2)
+const portArg = args.find(a => a.startsWith('--port='))
+const port = portArg ? portArg.split('=')[1] : '3333'
+const webPort = '3000'
+
+// Check if packages exist
+if (!fs.existsSync(serverDir) || !fs.existsSync(webDir)) {
+  console.error('❌ Web packages not found. Run from prjct-cli directory.')
+  process.exit(1)
+}
+
+console.log(`
+╔═══════════════════════════════════════════════════════════╗
+║                                                           ║
+║   ⚡ prjct - Developer Momentum                          ║
+║                                                           ║
+║   Starting web server...                                  ║
+║                                                           ║
+║   API:     http://localhost:${port}                          ║
+║   Web:     http://localhost:${webPort}                          ║
+║   Claude:  ws://localhost:${port}/ws/claude                  ║
+║                                                           ║
+║   Using your Claude subscription - $0 API costs           ║
+║                                                           ║
+╚═══════════════════════════════════════════════════════════╝
+`)
+
+// Start server
+const server = spawn('npm', ['run', 'dev'], {
+  cwd: serverDir,
+  stdio: 'inherit',
+  shell: true,
+  env: { ...process.env, PORT: port }
+})
+
+// Start web dev server
+const web = spawn('npm', ['run', 'dev'], {
+  cwd: webDir,
+  stdio: 'inherit',
+  shell: true
+})
+
+// Handle shutdown
+const cleanup = () => {
+  console.log('\n👋 Shutting down prjct server...')
+  server.kill()
+  web.kill()
+  process.exit(0)
+}
+
+process.on('SIGINT', cleanup)
+process.on('SIGTERM', cleanup)
+
+// Handle errors
+server.on('error', (err) => {
+  console.error('Server error:', err.message)
+})
+
+web.on('error', (err) => {
+  console.error('Web error:', err.message)
+})

package/core/agentic/command-executor.js

@@ -1,16 +1,19 @@
 /**
  * Command Executor
- * WITH MANDATORY AGENT ASSIGNMENT
- * Every task MUST use a specialized agent
+ * 100% AGENTIC - Claude decides agent assignment via Task tool
  *
- * OPTIMIZATION (P0.2): Explicit Validation
- * - Pre-flight checks before execution
- * - Specific error messages, never generic failures
- * - Actionable suggestions in every error
+ * NO if/else logic for agent selection here.
+ * Claude reads templates/agentic/agent-routing.md and delegates via Task tool.
  *
- * P3.4: Plan Mode + Approval Flow
- * - Separates planning from execution
- * - Requires approval for destructive commands
+ * JS only:
+ * - Loads templates
+ * - Builds context
+ * - Returns prompt for Claude
+ *
+ * Claude:
+ * - Reads agent-routing.md
+ * - Decides best agent for task
+ * - Delegates via Task(subagent_type='general-purpose', prompt='Read: path/to/agent.md...')
  *
  * Source: Claude Code, Devin, Augment Code patterns
  */
@@ -22,9 +25,8 @@ const templateLoader = require('./template-loader')
 const contextBuilder = require('./context-builder')
 const promptBuilder = require('./prompt-builder')
 const toolRegistry = require('./tool-registry')
-const MandatoryAgentRouter = require('./agent-router')
-const ContextFilter = require('./context-filter')
-const ContextEstimator = require('../domain/context-estimator')
+// REMOVED: MandatoryAgentRouter, ContextFilter, ContextEstimator
+// Agent assignment is 100% agentic - Claude decides via templates
 const { validate, formatError } = require('./validation-rules')
 const loopDetector = require('./loop-detector')
 const chainOfThought = require('./chain-of-thought')
@@ -45,9 +47,8 @@ const RUNNING_FILE = path.join(os.homedir(), '.prjct-cli', '.running')
 
 class CommandExecutor {
   constructor() {
-    this.agentRouter = new MandatoryAgentRouter()
-    this.contextFilter = new ContextFilter()
-    this.contextEstimator = null
+    // 100% AGENTIC: No agent router here
+    // Claude decides agent assignment via templates and Task tool
   }
 
   /**
@@ -173,72 +174,18 @@ class CommandExecutor {
         }
       }
 
-      // 3. CRITICAL: Force agent assignment for ALL task-related commands
-      const requiresAgent = template.metadata?.['required-agent'] !== false &&
-                           (template.metadata?.['required-agent'] === true ||
-                            this.isTaskCommand(commandName) ||
-                            this.shouldUseAgent(commandName))
-
+      // 3. AGENTIC: Claude decides agent assignment via templates
+      // NO if/else logic here - templates instruct Claude to use Task tool
+      // See templates/agentic/agent-routing.md for routing rules
       let context = metadataContext
-      let assignedAgent = null
-
-      // MANDATORY: Assign specialized agent for task commands
-      if (requiresAgent) {
-        // 4. Create task object for analysis
-        const task = {
-          description: params.task || params.description || commandName,
-          type: commandName
-        }
-
-        // 5. LAZY CONTEXT: Analyze task FIRST, then estimate files needed
-        // This avoids reading all files before knowing what we need
-        const agentAssignment = await this.agentRouter.executeTask(
-          task,
-          metadataContext, // Only metadata, no files yet
-          projectPath
-        )
-
-        assignedAgent = agentAssignment.agent
-        const taskAnalysis = agentAssignment.taskAnalysis
-
-        // Validate agent was assigned
-        if (!assignedAgent || !assignedAgent.name) {
-          throw new Error(
-            `CRITICAL: Failed to assign agent for command "${commandName}". ` +
-            `System requires ALL task commands to use specialized agents.`
-          )
-        }
-
-        // 6. PRE-FILTER: Estimate which files are needed BEFORE reading
-        if (!this.contextEstimator) {
-          this.contextEstimator = new ContextEstimator()
-        }
-
-        const estimatedFiles = await this.contextEstimator.estimateFiles(
-          taskAnalysis,
-          projectPath
-        )
 
-        // 7. Build context ONLY with estimated files (lazy loading)
-        const filtered = await this.contextFilter.filterForAgent(
-          assignedAgent,
-          task,
-          projectPath,
-          {
-            ...metadataContext,
-            estimatedFiles, // Pre-filtered file list
-            fileCount: estimatedFiles.length
-          }
-        )
-
-        context = {
-          ...filtered,
-          agent: assignedAgent,
-          originalSize: estimatedFiles.length, // Estimated, not actual full size
-          filteredSize: filtered.files?.length || 0,
-          reduction: filtered.metrics?.reductionPercent || 0,
-          lazyLoaded: true // Flag indicating lazy loading was used
-        }
+      // Provide agent info to context so Claude can delegate
+      context = {
+        ...context,
+        agentsPath: path.join(os.homedir(), '.prjct-cli', 'projects', metadataContext.projectId || '', 'agents'),
+        agentRoutingPath: path.join(__dirname, '..', '..', 'templates', 'agentic', 'agent-routing.md'),
+        // Flag: Claude must delegate to subagent via Task tool
+        agenticDelegation: true
       }
 
       // 6. Load state with filtered context
@@ -285,7 +232,7 @@ class CommandExecutor {
         )
       }
 
-      // 9. Build prompt with agent assignment, learned patterns, think blocks, memories, AND plan mode
+      // 9. Build prompt - NO agent assignment here, Claude decides via templates
       const planInfo = {
         isPlanning: requiresPlanning || isInPlanningMode,
         requiresApproval: isDestructive && !params.approved,
@@ -295,13 +242,11 @@ class CommandExecutor {
           template.frontmatter['allowed-tools'] || []
         )
       }
-      const prompt = promptBuilder.build(template, context, state, assignedAgent, learnedPatterns, thinkBlock, relevantMemories, planInfo)
+      // Agent is null - Claude assigns via Task tool using agent-routing.md
+      const prompt = promptBuilder.build(template, context, state, null, learnedPatterns, thinkBlock, relevantMemories, planInfo)
 
-      // 8. Log agent usage
-      if (assignedAgent) {
-        console.log(`🤖 Task assigned to: ${assignedAgent.name}`)
-        console.log(`📉 Context reduced by: ${context.reduction}%`)
-      }
+      // Log agentic mode
+      console.log(`🤖 Agentic delegation enabled - Claude will assign agent via Task tool`)
 
       // Record successful attempt
       loopDetector.recordSuccess(commandName, loopContext)
@@ -315,8 +260,10 @@ class CommandExecutor {
         context,
         state,
         prompt,
-        assignedAgent,
-        contextReduction: context.reduction,
+        // AGENTIC: No pre-assigned agent - Claude delegates via Task tool
+        agenticDelegation: true,
+        agentsPath: context.agentsPath,
+        agentRoutingPath: context.agentRoutingPath,
         reasoning, // Chain of thought results
         thinkBlock, // Think blocks (P3.1)
         groundTruth: groundTruthResult, // Ground truth verification (P1.3)
@@ -406,30 +353,9 @@ class CommandExecutor {
     }
   }
 
-  /**
-   * Check if command is task-related
-   */
-  isTaskCommand(commandName) {
-    const taskCommands = [
-      'work', 'now', 'build', 'feature', 'bug', 'done',
-      'task', 'design', 'cleanup', 'fix', 'test'
-    ]
-    return taskCommands.includes(commandName)
-  }
-
-  /**
-   * Determine if command should use an agent
-   * Expanded list of commands that benefit from agent specialization
-   */
-  shouldUseAgent(commandName) {
-    // Commands that should ALWAYS use agents
-    const agentCommands = [
-      'work', 'now', 'build', 'feature', 'bug', 'done',
-      'task', 'design', 'cleanup', 'fix', 'test',
-      'sync', 'analyze' // These analyze/modify code, need specialization
-    ]
-    return agentCommands.includes(commandName)
-  }
+  // REMOVED: isTaskCommand() and shouldUseAgent()
+  // Agent assignment is now 100% agentic - Claude decides via templates
+  // See templates/agentic/agent-routing.md
 
   /**
    * Execute tool with permission check