prjct-cli 0.28.4 → 0.29.0

package/core/agentic/prompt-builder.ts

@@ -283,7 +283,7 @@ class PromptBuilder {
 
     // Agent assignment (CONDITIONAL - only for code-modifying commands)
     const commandName = template.frontmatter?.name?.replace('p:', '') || ''
-    const agentCommands = ['task', 'design', 'fix', 'bug', 'test', 'cleanup', 'spec']
+    const agentCommands = ['now', 'build', 'feature', 'design', 'fix', 'bug', 'test', 'work', 'cleanup', 'spec']
     const needsAgent = agentCommands.includes(commandName)
 
     if (agent && needsAgent) {
@@ -332,7 +332,7 @@ class PromptBuilder {
     }
 
     // OPTIMIZED: Only include patterns for code-modifying commands
-    const codeCommands = ['task', 'design', 'cleanup', 'fix', 'bug', 'test', 'init', 'spec']
+    const codeCommands = ['now', 'build', 'feature', 'design', 'cleanup', 'fix', 'bug', 'test', 'init', 'spec', 'work']
     const needsPatterns = codeCommands.includes(commandName)
 
     // Include code patterns analysis for code-modifying commands
@@ -498,87 +498,6 @@ class PromptBuilder {
     return result || null
   }
 
-  /**
-   * Claude Code subagents that can be invoked via @ notation
-   */
-  private readonly CLAUDE_SUBAGENTS = ['explore', 'general', 'plan']
-
-  /**
-   * Parse @ agent mentions from input
-   * Separates prjct agents from Claude Code subagents
-   * @example "@frontend @explore add dark mode" -> { prjctAgents: ["frontend"], claudeSubagents: ["explore"], cleanInput: "add dark mode" }
-   */
-  parseAgentMentions(input: string): {
-    prjctAgents: string[]
-    claudeSubagents: string[]
-    cleanInput: string
-  } {
-    if (!input) return { prjctAgents: [], claudeSubagents: [], cleanInput: '' }
-
-    const mentionPattern = /@(\w+)/g
-    const prjctAgents: string[] = []
-    const claudeSubagents: string[] = []
-    let match
-
-    while ((match = mentionPattern.exec(input)) !== null) {
-      const name = match[1].toLowerCase()
-      if (this.CLAUDE_SUBAGENTS.includes(name)) {
-        claudeSubagents.push(name)
-      } else {
-        prjctAgents.push(name)
-      }
-    }
-
-    const cleanInput = input.replace(mentionPattern, '').trim()
-    return { prjctAgents, claudeSubagents, cleanInput }
-  }
-
-  /**
-   * Build Claude subagent instructions for the prompt
-   */
-  buildSubagentInstructions(claudeSubagents: string[]): string {
-    if (!claudeSubagents.length) return ''
-
-    const instructions = claudeSubagents.map((sub) => {
-      switch (sub) {
-        case 'explore':
-          return '- USE Task tool with subagent_type=Explore for fast codebase exploration'
-        case 'general':
-          return '- USE Task tool with subagent_type=general-purpose for complex multi-step research'
-        case 'plan':
-          return '- USE Task tool with subagent_type=Plan for architecture design'
-        default:
-          return null
-      }
-    }).filter(Boolean)
-
-    if (!instructions.length) return ''
-
-    return `
-## CLAUDE SUBAGENT INSTRUCTIONS
-${instructions.join('\n')}
-`
-  }
-
-  /**
-   * Build tool permissions section from template frontmatter
-   */
-  buildToolPermissions(toolPermissions: Record<string, { allow?: string[]; ask?: string[]; deny?: string[] }> | null): string {
-    if (!toolPermissions) return ''
-
-    const parts: string[] = ['\n## TOOL PERMISSIONS\n', 'Check these BEFORE executing:\n']
-
-    for (const [tool, rules] of Object.entries(toolPermissions)) {
-      parts.push(`\n**${tool}:**`)
-      if (rules.allow?.length) parts.push(`- ALLOW: ${rules.allow.join(', ')}`)
-      if (rules.ask?.length) parts.push(`- ASK USER: ${rules.ask.join(', ')}`)
-      if (rules.deny?.length) parts.push(`- NEVER: ${rules.deny.join(', ')}`)
-    }
-
-    parts.push('\n⚠️ DENY = Never execute. ASK = Confirm with user first.\n')
-    return parts.join('\n')
-  }
-
   /**
    * Build critical anti-hallucination rules section
    */

package/core/agentic/smart-context.ts

@@ -13,6 +13,7 @@ import { outcomeAnalyzer } from '../outcomes'
 import type { TaskType } from '../types'
 import type {
   ContextDomain,
+  SmartContextProjectState,
   FullContext,
   FilteredContext,
   StackInfo,
@@ -31,22 +32,8 @@ export type {
   FilterMetrics,
 } from '../types'
 
-/**
- * PERFORMANCE: Pre-built keyword → domain map for O(1) lookup
- * Instead of iterating 5 arrays of keywords, we do a single pass
- */
-const KEYWORD_DOMAIN_MAP: Map<string, ContextDomain> = new Map([
-  // Frontend
-  ...['ui', 'component', 'react', 'vue', 'angular', 'css', 'style', 'button', 'form', 'modal', 'layout', 'responsive', 'animation', 'dom', 'html', 'frontend', 'fe', 'client', 'browser', 'jsx', 'tsx'].map(k => [k, 'frontend' as ContextDomain] as const),
-  // Backend
-  ...['api', 'server', 'database', 'db', 'endpoint', 'route', 'handler', 'controller', 'service', 'repository', 'model', 'query', 'backend', 'be', 'rest', 'graphql', 'prisma', 'sql', 'redis', 'auth'].map(k => [k, 'backend' as ContextDomain] as const),
-  // DevOps
-  ...['deploy', 'docker', 'kubernetes', 'k8s', 'ci', 'cd', 'pipeline', 'terraform', 'ansible', 'aws', 'gcp', 'azure', 'nginx', 'devops', 'infrastructure', 'monitoring', 'logging'].map(k => [k, 'devops' as ContextDomain] as const),
-  // Docs
-  ...['document', 'docs', 'readme', 'changelog', 'comment', 'jsdoc', 'tutorial', 'guide', 'explain', 'describe', 'markdown'].map(k => [k, 'docs' as ContextDomain] as const),
-  // Testing
-  ...['test', 'spec', 'jest', 'mocha', 'cypress', 'playwright', 'pytest', 'unittest', 'e2e', 'unit', 'integration', 'coverage', 'mock', 'fixture'].map(k => [k, 'testing' as ContextDomain] as const),
-])
+// Local type alias for backward compatibility
+type ProjectState = SmartContextProjectState
 
 /**
  * SmartContext - Intelligent context filtering.
@@ -54,20 +41,63 @@ const KEYWORD_DOMAIN_MAP: Map<string, ContextDomain> = new Map([
 class SmartContext {
   /**
    * Detect the domain of a task from its description.
-   * OPTIMIZED: Single-pass O(n) where n = words in description
    */
   detectDomain(taskDescription: string): DomainAnalysis {
-    const words = taskDescription.toLowerCase().split(/\s+/)
-    const scores: Record<ContextDomain, number> = {
-      frontend: 0, backend: 0, devops: 0, docs: 0, testing: 0, general: 0
-    }
+    const lower = taskDescription.toLowerCase()
 
-    // Single pass: check each word against the map
-    for (const word of words) {
-      const domain = KEYWORD_DOMAIN_MAP.get(word)
-      if (domain) {
-        scores[domain]++
-      }
+    // Frontend indicators
+    const frontendKeywords = [
+      'ui', 'component', 'react', 'vue', 'angular', 'css', 'style',
+      'button', 'form', 'modal', 'layout', 'responsive', 'animation',
+      'dom', 'html', 'frontend', 'fe', 'client', 'browser', 'jsx', 'tsx'
+    ]
+
+    // Backend indicators
+    const backendKeywords = [
+      'api', 'server', 'database', 'db', 'endpoint', 'route', 'handler',
+      'controller', 'service', 'repository', 'model', 'query', 'backend',
+      'be', 'rest', 'graphql', 'prisma', 'sql', 'redis', 'auth'
+    ]
+
+    // DevOps indicators
+    const devopsKeywords = [
+      'deploy', 'docker', 'kubernetes', 'k8s', 'ci', 'cd', 'pipeline',
+      'terraform', 'ansible', 'aws', 'gcp', 'azure', 'config', 'nginx',
+      'devops', 'infrastructure', 'monitoring', 'logging', 'build'
+    ]
+
+    // Docs indicators
+    const docsKeywords = [
+      'document', 'docs', 'readme', 'changelog', 'comment', 'jsdoc',
+      'tutorial', 'guide', 'explain', 'describe', 'markdown'
+    ]
+
+    // Testing indicators
+    const testingKeywords = [
+      'test', 'spec',
+      // JS/TS
+      'bun', 'bun test', 'jest', 'mocha', 'cypress', 'playwright',
+      // Python
+      'pytest', 'unittest',
+      // Go
+      'go test',
+      // Rust
+      'cargo test',
+      // .NET
+      'dotnet test',
+      // Java
+      'mvn test', 'gradle test', 'gradlew test',
+      'e2e', 'unit', 'integration', 'coverage', 'mock', 'fixture'
+    ]
+
+    // Count matches
+    const scores: Record<ContextDomain, number> = {
+      frontend: frontendKeywords.filter(k => lower.includes(k)).length,
+      backend: backendKeywords.filter(k => lower.includes(k)).length,
+      devops: devopsKeywords.filter(k => lower.includes(k)).length,
+      docs: docsKeywords.filter(k => lower.includes(k)).length,
+      testing: testingKeywords.filter(k => lower.includes(k)).length,
+      general: 0,
     }
 
     // Find primary and secondary domains
@@ -109,16 +139,14 @@ class SmartContext {
       agent => relevantDomains.includes(agent.domain)
     )
 
-    // OPTIMIZED: Enrich with performance data in parallel
-    const perfPromises = filteredAgents.map(agent =>
-      agentPerformanceTracker.getAgentPerformance(projectId, agent.name)
-    )
-    const perfResults = await Promise.all(perfPromises)
-
-    for (let i = 0; i < filteredAgents.length; i++) {
-      const perf = perfResults[i]
+    // Enrich with performance data
+    for (const agent of filteredAgents) {
+      const perf = await agentPerformanceTracker.getAgentPerformance(
+        projectId,
+        agent.name
+      )
       if (perf) {
-        filteredAgents[i].successRate = perf.successRate
+        agent.successRate = perf.successRate
       }
     }
 

package/core/agentic/template-loader.ts

@@ -15,92 +15,26 @@ import type { Frontmatter, ParsedTemplate } from '../types'
 const TEMPLATES_DIR = path.join(__dirname, '..', '..', 'templates', 'commands')
 const MAX_CACHE_SIZE = 50
 
-// Use single Map for O(1) LRU operations (ES6 Maps maintain insertion order)
 const cache = new Map<string, ParsedTemplate>()
+const cacheOrder: string[] = []
 
 // ============ Cache Helpers ============
 
-function setWithLru(key: string, value: ParsedTemplate): void {
-  // Delete first to move to end when re-adding (most recently used)
-  cache.delete(key)
-  cache.set(key, value)
-
-  // Evict oldest (first item) if over limit
-  if (cache.size > MAX_CACHE_SIZE) {
-    const oldest = cache.keys().next().value
-    if (oldest) cache.delete(oldest)
-  }
+function updateLruOrder(key: string): void {
+  const index = cacheOrder.indexOf(key)
+  if (index > -1) cacheOrder.splice(index, 1)
+  cacheOrder.push(key)
 }
 
-function getWithLru(key: string): ParsedTemplate | undefined {
-  const value = cache.get(key)
-  if (value !== undefined) {
-    // Move to end (most recently used)
-    cache.delete(key)
-    cache.set(key, value)
+function evictLru(): void {
+  while (cache.size >= MAX_CACHE_SIZE && cacheOrder.length > 0) {
+    const oldest = cacheOrder.shift()
+    if (oldest) cache.delete(oldest)
   }
-  return value
 }
 
 // ============ Parsing Functions ============
 
-/**
- * Parse tool-permissions YAML block
- * Handles nested structure like:
- * tool-permissions:
- *   bash:
- *     allow: ["git *"]
- *     deny: ["rm -rf"]
- */
-function parseToolPermissions(lines: string[], startIndex: number): {
-  permissions: Record<string, { allow?: string[]; ask?: string[]; deny?: string[] }>
-  endIndex: number
-} {
-  const permissions: Record<string, { allow?: string[]; ask?: string[]; deny?: string[] }> = {}
-  let i = startIndex
-  let currentTool: string | null = null
-
-  while (i < lines.length) {
-    const line = lines[i]
-    const trimmed = line.trim()
-
-    // End if we hit a new top-level key (no leading spaces)
-    if (line.length > 0 && !line.startsWith(' ') && !line.startsWith('\t')) {
-      break
-    }
-
-    // Tool name (2 spaces indent)
-    const toolMatch = line.match(/^ {2}(\w+):$/)
-    if (toolMatch) {
-      currentTool = toolMatch[1]
-      permissions[currentTool] = {}
-      i++
-      continue
-    }
-
-    // Permission array (4 spaces indent)
-    const permMatch = line.match(/^ {4}(allow|ask|deny):\s*\[(.+)\]/)
-    if (permMatch && currentTool) {
-      const [, permType, arrayContent] = permMatch
-      permissions[currentTool][permType as 'allow' | 'ask' | 'deny'] = arrayContent
-        .split(',')
-        .map((v) => v.trim().replace(/^["']|["']$/g, ''))
-      i++
-      continue
-    }
-
-    // Skip empty lines within block
-    if (trimmed === '') {
-      i++
-      continue
-    }
-
-    i++
-  }
-
-  return { permissions, endIndex: i }
-}
-
 export function parseFrontmatter(content: string): ParsedTemplate {
   const frontmatterRegex = /^---\n([\s\S]+?)\n---\n([\s\S]*)$/
   const match = content.match(frontmatterRegex)
@@ -111,35 +45,21 @@ export function parseFrontmatter(content: string): ParsedTemplate {
 
   const [, frontmatterText, mainContent] = match
   const frontmatter: Frontmatter = {}
-  const lines = frontmatterText.split('\n')
 
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i]
+  frontmatterText.split('\n').forEach((line) => {
     const [key, ...valueParts] = line.split(':')
-
-    if (!key || line.startsWith(' ') || line.startsWith('\t')) {
-      continue
+    if (key && valueParts.length > 0) {
+      const value = valueParts.join(':').trim()
+
+      // Parse arrays
+      if (value.startsWith('[') && value.endsWith(']')) {
+        frontmatter[key.trim()] = value.slice(1, -1).split(',').map((v) => v.trim())
+      } else {
+        // Remove quotes if present
+        frontmatter[key.trim()] = value.replace(/^["']|["']$/g, '')
+      }
     }
-
-    const keyTrimmed = key.trim()
-    const value = valueParts.join(':').trim()
-
-    // Handle tool-permissions nested block
-    if (keyTrimmed === 'tool-permissions' && value === '') {
-      const { permissions, endIndex } = parseToolPermissions(lines, i + 1)
-      frontmatter['tool-permissions'] = permissions
-      i = endIndex - 1
-      continue
-    }
-
-    // Parse arrays
-    if (value.startsWith('[') && value.endsWith(']')) {
-      frontmatter[keyTrimmed] = value.slice(1, -1).split(',').map((v) => v.trim())
-    } else if (value) {
-      // Remove quotes if present
-      frontmatter[keyTrimmed] = value.replace(/^["']|["']$/g, '')
-    }
-  }
+  })
 
   return { frontmatter, content: mainContent.trim() }
 }
@@ -147,10 +67,10 @@ export function parseFrontmatter(content: string): ParsedTemplate {
 // ============ Main Functions ============
 
 export async function load(commandName: string): Promise<ParsedTemplate> {
-  // Check cache first with LRU update
-  const cached = getWithLru(commandName)
-  if (cached) {
-    return cached
+  // Check cache first
+  if (cache.has(commandName)) {
+    updateLruOrder(commandName)
+    return cache.get(commandName)!
   }
 
   const templatePath = path.join(TEMPLATES_DIR, `${commandName}.md`)
@@ -159,8 +79,12 @@ export async function load(commandName: string): Promise<ParsedTemplate> {
     const rawContent = await fs.readFile(templatePath, 'utf-8')
     const parsed = parseFrontmatter(rawContent)
 
-    // Cache with LRU management
-    setWithLru(commandName, parsed)
+    // Evict LRU if needed before adding
+    evictLru()
+
+    // Cache result
+    cache.set(commandName, parsed)
+    cacheOrder.push(commandName)
 
     return parsed
   } catch {
@@ -175,6 +99,7 @@ export async function getAllowedTools(commandName: string): Promise<string[]> {
 
 export function clearCache(): void {
   cache.clear()
+  cacheOrder.length = 0
 }
 
 // ============ Default Export (backwards compat) ============

package/core/commands/command-data.ts

@@ -62,6 +62,17 @@ export const COMMANDS: CommandMeta[] = [
     requiresProject: true,
     features: ['Agentic type classification', '7-phase workflow', 'Git branch management', 'Task breakdown'],
   },
+  {
+    name: 'feature',
+    group: 'core',
+    description: 'DEPRECATED - Use /p:task instead',
+    usage: { claude: '/p:task "<description>"', terminal: 'prjct task "<description>"' },
+    params: '<description>',
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+    deprecated: true,
+  },
   {
     name: 'spec',
     group: 'core',
@@ -72,6 +83,28 @@ export const COMMANDS: CommandMeta[] = [
     hasTemplate: true,
     requiresProject: true,
   },
+  {
+    name: 'now',
+    group: 'core',
+    description: 'DEPRECATED - Use /p:task instead',
+    usage: { claude: '/p:task "<description>"', terminal: 'prjct task "<description>"' },
+    params: '[task]',
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+    deprecated: true,
+  },
+  {
+    name: 'work',
+    group: 'core',
+    description: 'DEPRECATED - Use /p:task instead',
+    usage: { claude: '/p:task "<description>"', terminal: 'prjct task "<description>"' },
+    params: '[task]',
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+    deprecated: true,
+  },
   {
     name: 'pause',
     group: 'core',

package/core/commands/commands.ts

@@ -3,12 +3,12 @@
  *
  * MD-First Architecture - All state in Markdown files.
  *
- * COMMANDS (20 total):
- * - Workflow (4): done, next, pause, resume
- * - Planning (4): init, bug, idea, spec
+ * COMMANDS (22 total):
+ * - Workflow (5): work, done, next, pause, resume
+ * - Planning (5): init, feature, bug, idea, spec
  * - Shipping (1): ship
  * - Analytics (2): dash, help
- * - Maintenance (6): cleanup, design, recover, undo, redo, history
+ * - Maintenance (5): cleanup, design, recover, undo, redo, history
  * - Analysis (2): analyze, sync
  * - Setup (3): start, setup, migrateAll
  */
@@ -69,6 +69,10 @@ class PrjctCommands {
 
   // ========== Workflow Commands ==========
 
+  async work(task: string | null = null, projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.workflow.now(task, projectPath)
+  }
+
   async done(projectPath: string = process.cwd()): Promise<CommandResult> {
     return this.workflow.done(projectPath)
   }
@@ -91,6 +95,10 @@ class PrjctCommands {
     return this.planning.init(idea, projectPath)
   }
 
+  async feature(description: string, projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.planning.feature(description, projectPath)
+  }
+
   async bug(description: string, projectPath: string = process.cwd()): Promise<CommandResult> {
     return this.planning.bug(description, projectPath)
   }

package/core/commands/registry.ts

@@ -388,6 +388,43 @@ export class CommandRegistry {
     }
   }
 
+  /**
+   * Execute without requiring project (for init, setup commands)
+   * @deprecated Use execute() - it auto-detects based on command metadata
+   */
+  async executeWithoutProject<TParams = void>(
+    name: string,
+    params: TParams,
+    projectPath: string = process.cwd()
+  ): Promise<CommandResult> {
+    const handler = this.handlers.get(name)
+    if (handler) {
+      const context: ExecutionContext = {
+        projectId: '',
+        projectPath,
+        globalPath: '',
+        timestamp: getTimestamp(),
+      }
+      return handler.execute(params, context)
+    }
+
+    const handlerFn = this.handlerFns.get(name)
+    if (handlerFn) {
+      const context: ExecutionContext = {
+        projectId: '',
+        projectPath,
+        globalPath: '',
+        timestamp: getTimestamp(),
+      }
+      return handlerFn(params, context)
+    }
+
+    return {
+      success: false,
+      error: `Command not found: ${name}`,
+    }
+  }
+
   /**
    * Clear all registrations (useful for testing)
    */

package/core/domain/agent-loader.ts

@@ -70,21 +70,23 @@ class AgentLoader {
   }
 
   /**
-   * Load all agents for the project (parallel loading for performance)
+   * Load all agents for the project
    */
   async loadAllAgents(): Promise<Agent[]> {
     try {
       const files = await fs.readdir(this.agentsDir)
       const agentFiles = files.filter((f) => f.endsWith('.md') && !f.startsWith('.'))
 
-      // Load all agents in parallel for better performance
-      const agentPromises = agentFiles.map((file) => {
+      const agents: Agent[] = []
+      for (const file of agentFiles) {
         const agentName = file.replace('.md', '')
-        return this.loadAgent(agentName)
-      })
+        const agent = await this.loadAgent(agentName)
+        if (agent) {
+          agents.push(agent)
+        }
+      }
 
-      const results = await Promise.all(agentPromises)
-      return results.filter((agent): agent is Agent => agent !== null)
+      return agents
     } catch (error) {
       if (isNotFoundError(error)) {
         return [] // Agents directory doesn't exist yet

package/core/domain/context-estimator.ts

@@ -137,21 +137,21 @@ class ContextEstimator {
         globPatterns.push(`*${ext}`)
       }
 
-      // Execute glob searches in parallel for better performance
-      const ignorePatterns = patterns.exclude.map((ex) => `**/${ex}/**`)
-      const globPromises = globPatterns.map((pattern) =>
-        glob(pattern, {
-          cwd: projectPath,
-          ignore: ignorePatterns,
-          nodir: true,
-          follow: false,
-        }).catch(() => [] as string[]) // Return empty array on error
-      )
-
-      const results = await Promise.all(globPromises)
-      for (const matches of results) {
-        if (Array.isArray(matches)) {
-          files.push(...matches)
+      // Execute glob searches
+      for (const pattern of globPatterns) {
+        try {
+          const matches = await glob(pattern, {
+            cwd: projectPath,
+            ignore: patterns.exclude.map((ex) => `**/${ex}/**`),
+            nodir: true,
+            follow: false,
+          })
+
+          if (Array.isArray(matches)) {
+            files.push(...matches)
+          }
+        } catch {
+          // Skip invalid patterns
         }
       }
 

package/core/index.ts

@@ -97,12 +97,14 @@ async function main(): Promise<void> {
       const param = parsedArgs.join(' ') || null
       const standardCommands: Record<string, (p: string | null) => Promise<CommandResult>> = {
         // Core workflow
+        work: (p) => commands.work(p),
         done: () => commands.done(),
         next: () => commands.next(),
         pause: (p) => commands.pause(p || ''),
         resume: (p) => commands.resume(p),
         // Planning
         init: (p) => commands.init(p),
+        feature: (p) => commands.feature(p || ''),
         bug: (p) => commands.bug(p || ''),
         idea: (p) => commands.idea(p || ''),
         spec: (p) => commands.spec(p),