prjct-cli 0.45.0 → 0.45.3

package/core/commands/workflow.ts

@@ -8,28 +8,24 @@
  * TypeScript provides infrastructure; Claude decides via templates.
  */
 
-import type { CommandResult, ProjectContext } from '../types'
-import { generateUUID } from '../schemas'
-import {
-  PrjctCommandsBase,
-  contextBuilder,
-  configManager,
-  dateHelper,
-  out
-} from './base'
-import { stateStorage, queueStorage } from '../storage'
-import { templateExecutor } from '../agentic/template-executor'
 import commandExecutor from '../agentic/command-executor'
-import { showNextSteps, showStateInfo } from '../utils/next-steps'
-import { workflowStateMachine } from '../workflow/state-machine'
+import { templateExecutor } from '../agentic/template-executor'
 import { linearService } from '../integrations/linear'
-import { getProjectCredentials, getLinearApiKey } from '../utils/project-credentials'
+import { generateUUID } from '../schemas'
+import { queueStorage, stateStorage } from '../storage'
+import type { CommandResult } from '../types'
+import { showNextSteps, showStateInfo } from '../utils/next-steps'
+import { getLinearApiKey, getProjectCredentials } from '../utils/project-credentials'
+import { configManager, dateHelper, out, PrjctCommandsBase } from './base'
 
 export class WorkflowCommands extends PrjctCommandsBase {
   /**
    * /p:now - Set or show current task
    */
-  async now(task: string | null = null, projectPath: string = process.cwd()): Promise<CommandResult> {
+  async now(
+    task: string | null = null,
+    projectPath: string = process.cwd()
+  ): Promise<CommandResult> {
     try {
       const initResult = await this.ensureProjectInit(projectPath)
       if (!initResult.success) return initResult
@@ -58,10 +54,7 @@ export class WorkflowCommands extends PrjctCommandsBase {
             const creds = await getProjectCredentials(projectId)
             const apiKey = await getLinearApiKey(projectId)
             if (apiKey && creds.linear?.teamId) {
-              await linearService.initializeFromApiKey(
-                apiKey,
-                creds.linear.teamId
-              )
+              await linearService.initializeFromApiKey(apiKey, creds.linear.teamId)
               const issue = await linearService.fetchIssue(task)
               if (issue) {
                 linearId = task
@@ -85,11 +78,14 @@ export class WorkflowCommands extends PrjctCommandsBase {
 
         // Get available agents for backward compatibility
         const availableAgents = await templateExecutor.getAvailableAgents(projectPath)
-        const agentsList = availableAgents.length > 0
-          ? availableAgents.join(', ')
-          : 'none (run p. sync)'
+        const _agentsList =
+          availableAgents.length > 0 ? availableAgents.join(', ') : 'none (run p. sync)'
 
-        out.done(`${task}`)
+        // Build metrics from orchestrator context
+        const agentCount = result.orchestratorContext?.agents?.length || availableAgents.length
+        out.done(`${task}`, {
+          agents: agentCount > 0 ? agentCount : undefined,
+        })
         showStateInfo('working')
         showNextSteps('task')
 
@@ -167,10 +163,7 @@ export class WorkflowCommands extends PrjctCommandsBase {
           const creds = await getProjectCredentials(projectId)
           const apiKey = await getLinearApiKey(projectId)
           if (apiKey && creds.linear?.teamId) {
-            await linearService.initializeFromApiKey(
-              apiKey,
-              creds.linear.teamId
-            )
+            await linearService.initializeFromApiKey(apiKey, creds.linear.teamId)
             await linearService.markDone(linearId)
             out.done(`${task}${duration ? ` (${duration})` : ''} → Linear ✓`)
           } else {
@@ -275,7 +268,10 @@ export class WorkflowCommands extends PrjctCommandsBase {
   /**
    * /p:resume - Resume most recently paused task
    */
-  async resume(taskId: string | null = null, projectPath: string = process.cwd()): Promise<CommandResult> {
+  async resume(
+    _taskId: string | null = null,
+    projectPath: string = process.cwd()
+  ): Promise<CommandResult> {
     try {
       const initResult = await this.ensureProjectInit(projectPath)
       if (!initResult.success) return initResult

package/core/constants/index.ts

@@ -19,17 +19,13 @@ export const NOW = {
 
   /** Generate NOW file content */
   content: (task: string, startedAt: string, agent?: string, confidence?: number): string => {
-    const lines = [
-      '# NOW',
-      '',
-      `**${task}**`,
-      '',
-      `Started: ${startedAt}`,
-    ]
+    const lines = ['# NOW', '', `**${task}**`, '', `Started: ${startedAt}`]
     if (agent) {
-      lines.push(`Agent: ${agent}${confidence ? ` (${Math.round(confidence * 100)}% confidence)` : ''}`)
+      lines.push(
+        `Agent: ${agent}${confidence ? ` (${Math.round(confidence * 100)}% confidence)` : ''}`
+      )
     }
-    return lines.join('\n') + '\n'
+    return `${lines.join('\n')}\n`
   },
 
   /** Extract task from NOW content */
@@ -48,15 +44,11 @@ export const SHIPPED = {
 
   /** Generate ship entry */
   entry: (feature: string, date: string, duration?: string): string => {
-    const lines = [
-      `## ${feature}`,
-      '',
-      `Shipped: ${date}`,
-    ]
+    const lines = [`## ${feature}`, '', `Shipped: ${date}`]
     if (duration) {
       lines.push(`Duration: ${duration}`)
     }
-    return lines.join('\n') + '\n\n'
+    return `${lines.join('\n')}\n\n`
   },
 } as const
 
@@ -113,16 +105,12 @@ export const ROADMAP = {
 
   /** Generate feature entry */
   entry: (feature: string, status: RoadmapStatusKey, tasks?: string[]): string => {
-    const lines = [
-      `## ${feature}`,
-      '',
-      `Status: ${ROADMAP_STATUS[status]}`,
-    ]
+    const lines = [`## ${feature}`, '', `Status: ${ROADMAP_STATUS[status]}`]
     if (tasks && tasks.length > 0) {
       lines.push('', '### Tasks', '')
-      tasks.forEach(task => lines.push(`- [ ] ${task}`))
+      tasks.forEach((task) => lines.push(`- [ ] ${task}`))
     }
-    return lines.join('\n') + '\n\n'
+    return `${lines.join('\n')}\n\n`
   },
 } as const
 

package/core/context/generator.ts

@@ -11,12 +11,12 @@
  * └── summary.md   - Project summary
  */
 
-import fs from 'fs/promises'
-import path from 'path'
-import { exec } from 'child_process'
-import { promisify } from 'util'
-import { getStorage } from '../storage'
+import { exec } from 'node:child_process'
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { promisify } from 'node:util'
 import pathManager from '../infrastructure/path-manager'
+import { getStorage } from '../storage'
 
 const execAsync = promisify(exec)
 
@@ -59,7 +59,7 @@ interface Agent {
  * Generate all context MD files from JSON data
  */
 export async function generateContext(projectId: string, repoPath: string): Promise<void> {
-  const globalPath = pathManager.getGlobalProjectPath(projectId)
+  const _globalPath = pathManager.getGlobalProjectPath(projectId)
   const contextPath = pathManager.getContextPath(projectId)
   const storage = getStorage(projectId)
 
@@ -67,7 +67,7 @@ export async function generateContext(projectId: string, repoPath: string): Prom
   await fs.mkdir(contextPath, { recursive: true })
 
   // Read all data
-  const project = await storage.read<ProjectData>(['project']) || {}
+  const project = (await storage.read<ProjectData>(['project'])) || {}
   const taskPaths = await storage.list(['task'])
   const featurePaths = await storage.list(['feature'])
   const ideaPaths = await storage.list(['idea'])
@@ -104,7 +104,18 @@ export async function generateContext(projectId: string, repoPath: string): Prom
   const pkgData = await getPackageData(repoPath)
 
   // Generate each context file
-  await generateClaudeMd(contextPath, projectId, project, tasks, features, ideas, agents, gitData, pkgData, repoPath)
+  await generateClaudeMd(
+    contextPath,
+    projectId,
+    project,
+    tasks,
+    features,
+    ideas,
+    agents,
+    gitData,
+    pkgData,
+    repoPath
+  )
   await generateNowMd(contextPath, tasks)
   await generateQueueMd(contextPath, tasks)
   await generateSummaryMd(contextPath, project, gitData, pkgData)
@@ -116,7 +127,7 @@ async function getGitData(repoPath: string) {
     commits: 0,
     contributors: 0,
     hasChanges: false,
-    recentCommits: [] as { hash: string; message: string; date: string }[]
+    recentCommits: [] as { hash: string; message: string; date: string }[],
   }
 
   try {
@@ -124,19 +135,27 @@ async function getGitData(repoPath: string) {
     data.branch = branch.trim() || 'main'
 
     const { stdout: commits } = await execAsync('git rev-list --count HEAD', { cwd: repoPath })
-    data.commits = parseInt(commits.trim()) || 0
+    data.commits = parseInt(commits.trim(), 10) || 0
 
-    const { stdout: contributors } = await execAsync('git shortlog -sn --all | wc -l', { cwd: repoPath })
-    data.contributors = parseInt(contributors.trim()) || 0
+    const { stdout: contributors } = await execAsync('git shortlog -sn --all | wc -l', {
+      cwd: repoPath,
+    })
+    data.contributors = parseInt(contributors.trim(), 10) || 0
 
     const { stdout: status } = await execAsync('git status --porcelain', { cwd: repoPath })
     data.hasChanges = status.trim().length > 0
 
-    const { stdout: log } = await execAsync('git log --oneline -10 --pretty=format:"%h|%s|%ad" --date=short', { cwd: repoPath })
-    data.recentCommits = log.split('\n').filter(Boolean).map(line => {
-      const [hash, message, date] = line.split('|')
-      return { hash, message, date }
-    })
+    const { stdout: log } = await execAsync(
+      'git log --oneline -10 --pretty=format:"%h|%s|%ad" --date=short',
+      { cwd: repoPath }
+    )
+    data.recentCommits = log
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => {
+        const [hash, message, date] = line.split('|')
+        return { hash, message, date }
+      })
   } catch (_error) {
     // Not a git repo - expected
   }
@@ -148,7 +167,7 @@ async function getPackageData(repoPath: string) {
   const data = {
     dependencies: {} as Record<string, string>,
     devDependencies: {} as Record<string, string>,
-    scripts: {} as Record<string, string>
+    scripts: {} as Record<string, string>,
   }
 
   try {
@@ -177,9 +196,9 @@ async function generateClaudeMd(
   repoPath: string
 ) {
   const projectName = project.name || path.basename(repoPath)
-  const currentTask = tasks.find(t => t.status === 'in_progress')
-  const pendingTasks = tasks.filter(t => t.status === 'pending')
-  const activeFeatures = features.filter(f => f.status === 'in_progress' || f.status === 'active')
+  const currentTask = tasks.find((t) => t.status === 'in_progress')
+  const pendingTasks = tasks.filter((t) => t.status === 'pending')
+  const activeFeatures = features.filter((f) => f.status === 'in_progress' || f.status === 'active')
 
   const deps = Object.keys(pkgData.dependencies)
   const devDeps = Object.keys(pkgData.devDependencies)
@@ -193,14 +212,20 @@ async function generateClaudeMd(
 ### Dependencies (${deps.length + devDeps.length})
 
 **Production** (${deps.length}):
-${deps.length > 0 ? deps.map(d => `- ${d}: ${pkgData.dependencies[d]}`).join('\n') : '_None_'}
+${deps.length > 0 ? deps.map((d) => `- ${d}: ${pkgData.dependencies[d]}`).join('\n') : '_None_'}
 
 **Dev** (${devDeps.length}):
-${devDeps.length > 0 ? devDeps.map(d => `- ${d}: ${pkgData.devDependencies[d]}`).join('\n') : '_None_'}
+${devDeps.length > 0 ? devDeps.map((d) => `- ${d}: ${pkgData.devDependencies[d]}`).join('\n') : '_None_'}
 
 ### Scripts
 
-${Object.keys(pkgData.scripts).length > 0 ? Object.entries(pkgData.scripts).map(([k, v]) => `- \`${k}\`: ${v}`).join('\n') : '_None_'}
+${
+  Object.keys(pkgData.scripts).length > 0
+    ? Object.entries(pkgData.scripts)
+        .map(([k, v]) => `- \`${k}\`: ${v}`)
+        .join('\n')
+    : '_None_'
+}
 
 ### Git
 
@@ -210,7 +235,14 @@ ${Object.keys(pkgData.scripts).length > 0 ? Object.entries(pkgData.scripts).map(
 - Uncommitted: ${gitData.hasChanges ? 'Yes' : 'No'}
 
 **Recent:**
-${gitData.recentCommits.length > 0 ? gitData.recentCommits.slice(0, 5).map(c => `- \`${c.hash}\` ${c.message}`).join('\n') : '_None_'}
+${
+  gitData.recentCommits.length > 0
+    ? gitData.recentCommits
+        .slice(0, 5)
+        .map((c) => `- \`${c.hash}\` ${c.message}`)
+        .join('\n')
+    : '_None_'
+}
 
 ---
 
@@ -219,19 +251,33 @@ ${gitData.recentCommits.length > 0 ? gitData.recentCommits.slice(0, 5).map(c =>
 **Now:** ${currentTask ? currentTask.description : '_No active task_'}
 
 **Queue (${pendingTasks.length}):**
-${pendingTasks.length > 0 ? pendingTasks.slice(0, 10).map((t, i) => `${i + 1}. ${t.description}`).join('\n') : '_Empty_'}
+${
+  pendingTasks.length > 0
+    ? pendingTasks
+        .slice(0, 10)
+        .map((t, i) => `${i + 1}. ${t.description}`)
+        .join('\n')
+    : '_Empty_'
+}
 
 **Active Features (${activeFeatures.length}):**
-${activeFeatures.length > 0 ? activeFeatures.map(f => `- ${f.name}`).join('\n') : '_None_'}
+${activeFeatures.length > 0 ? activeFeatures.map((f) => `- ${f.name}`).join('\n') : '_None_'}
 
 **Ideas (${ideas.length}):**
-${ideas.length > 0 ? ideas.slice(0, 5).map(i => `- ${i.title}`).join('\n') : '_None_'}
+${
+  ideas.length > 0
+    ? ideas
+        .slice(0, 5)
+        .map((i) => `- ${i.title}`)
+        .join('\n')
+    : '_None_'
+}
 
 ---
 
 ## AGENTS
 
-${agents.length > 0 ? agents.map(a => `- **${a.name}**: ${a.role || 'Specialist'}`).join('\n') : '_None_'}
+${agents.length > 0 ? agents.map((a) => `- **${a.name}**: ${a.role || 'Specialist'}`).join('\n') : '_None_'}
 
 ---
 
@@ -258,7 +304,7 @@ ${agents.length > 0 ? agents.map(a => `- **${a.name}**: ${a.role || 'Specialist'
 }
 
 async function generateNowMd(contextPath: string, tasks: Task[]) {
-  const currentTask = tasks.find(t => t.status === 'in_progress')
+  const currentTask = tasks.find((t) => t.status === 'in_progress')
 
   const content = currentTask
     ? `# NOW
@@ -278,12 +324,15 @@ _No active task. Use /p:now to start._
 }
 
 async function generateQueueMd(contextPath: string, tasks: Task[]) {
-  const pendingTasks = tasks.filter(t => t.status === 'pending')
+  const pendingTasks = tasks.filter((t) => t.status === 'pending')
 
   const content = `# QUEUE
 
-${pendingTasks.length > 0
-    ? pendingTasks.map((t, i) => `${i + 1}. ${t.description}${t.priority ? ` [${t.priority}]` : ''}`).join('\n')
+${
+  pendingTasks.length > 0
+    ? pendingTasks
+        .map((t, i) => `${i + 1}. ${t.description}${t.priority ? ` [${t.priority}]` : ''}`)
+        .join('\n')
     : '_Empty queue. Use /p:next to add tasks._'
 }
 `

package/core/context-tools/files-tool.ts

@@ -11,12 +11,12 @@
  * @version 1.0.0
  */
 
-import fs from 'fs/promises'
-import path from 'path'
-import { exec as execCallback } from 'child_process'
-import { promisify } from 'util'
-import type { FilesToolOutput, ScoredFile, ScoreReason } from './types'
+import { exec as execCallback } from 'node:child_process'
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { promisify } from 'node:util'
 import { isNotFoundError } from '../types/fs'
+import type { FilesToolOutput, ScoredFile, ScoreReason } from './types'
 
 const exec = promisify(execCallback)
 
@@ -270,7 +270,10 @@ export async function findRelevantFiles(
  */
 function extractKeywords(description: string): string[] {
   // Convert to lowercase and split by non-word characters
-  const words = description.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean)
+  const words = description
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter(Boolean)
 
   // Remove common stop words
   const stopWords = new Set([
@@ -430,14 +433,14 @@ async function getGitRecency(
     for (const line of lines) {
       const match = line.match(/^(\d+)\s+(\d+)\s+(.+)$/)
       if (match) {
-        const commits = parseInt(match[1])
-        const timestamp = parseInt(match[2])
+        const commits = parseInt(match[1], 10)
+        const timestamp = parseInt(match[2], 10)
         const file = match[3]
         const daysAgo = Math.floor((now - timestamp) / 86400)
         recency.set(file, { commits, daysAgo })
       }
     }
-  } catch (error) {
+  } catch (_error) {
     // Git not available or not a git repo
   }
 
@@ -459,7 +462,10 @@ function scoreFile(
   let importScore = 0
 
   const pathLower = filePath.toLowerCase()
-  const pathParts = pathLower.split('/').join(' ').split(/[^a-z0-9]+/)
+  const pathParts = pathLower
+    .split('/')
+    .join(' ')
+    .split(/[^a-z0-9]+/)
 
   // Keyword matching (60% weight)
   for (const keyword of keywords) {
@@ -483,10 +489,7 @@ function scoreFile(
       if (pathLower.includes(domainKw)) {
         // Check if any task keyword relates to this domain
         const taskRelatesToDomain = keywords.some(
-          (k) =>
-            domainKeywords.includes(k) ||
-            k.includes(domain) ||
-            domain.includes(k)
+          (k) => domainKeywords.includes(k) || k.includes(domain) || domain.includes(k)
         )
         if (taskRelatesToDomain) {
           domainScore += 0.4
@@ -547,11 +550,7 @@ function scoreFile(
   }
 
   // Calculate weighted score
-  const score =
-    keywordScore * 0.6 +
-    domainScore * 0.2 +
-    recencyScore * 0.15 +
-    importScore * 0.05
+  const score = keywordScore * 0.6 + domainScore * 0.2 + recencyScore * 0.15 + importScore * 0.05
 
   return {
     path: filePath,

package/core/context-tools/imports-tool.ts

@@ -10,17 +10,12 @@
  * @version 1.0.0
  */
 
-import fs from 'fs/promises'
-import path from 'path'
-import { exec as execCallback } from 'child_process'
-import { promisify } from 'util'
-import type {
-  ImportsToolOutput,
-  ImportRelation,
-  ImportedBy,
-  DependencyNode,
-} from './types'
+import { exec as execCallback } from 'node:child_process'
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { promisify } from 'node:util'
 import { isNotFoundError } from '../types/fs'
+import type { DependencyNode, ImportedBy, ImportRelation, ImportsToolOutput } from './types'
 
 const exec = promisify(execCallback)
 
@@ -154,9 +149,7 @@ export async function analyzeImports(
     depth?: number // Dependency tree depth (0 = no tree)
   } = {}
 ): Promise<ImportsToolOutput> {
-  const absolutePath = path.isAbsolute(filePath)
-    ? filePath
-    : path.join(projectPath, filePath)
+  const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(projectPath, filePath)
 
   // Read file content
   let content: string
@@ -196,11 +189,7 @@ export async function analyzeImports(
   // Build dependency tree if requested
   let dependencyTree: DependencyNode | undefined
   if (options.depth && options.depth > 0) {
-    dependencyTree = await buildDependencyTree(
-      filePath,
-      projectPath,
-      options.depth
-    )
+    dependencyTree = await buildDependencyTree(filePath, projectPath, options.depth)
   }
 
   // Calculate metrics
@@ -285,11 +274,7 @@ function extractImports(
 /**
  * Resolve a relative import to an absolute path
  */
-function resolveImport(
-  source: string,
-  fromFile: string,
-  projectPath: string
-): string | null {
+function resolveImport(source: string, fromFile: string, projectPath: string): string | null {
   const fileDir = path.dirname(fromFile)
 
   // Handle path alias like @/
@@ -313,13 +298,11 @@ function tryResolve(basePath: string, projectPath: string): string | null {
     const fullPath = basePath + ext
     try {
       // Check synchronously (we're in a hot path)
-      const fs = require('fs')
+      const fs = require('node:fs')
       if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
         return path.relative(projectPath, fullPath)
       }
-    } catch {
-      continue
-    }
+    } catch {}
   }
 
   return null
@@ -328,15 +311,12 @@ function tryResolve(basePath: string, projectPath: string): string | null {
 /**
  * Find all files that import the target file
  */
-async function findImportedBy(
-  filePath: string,
-  projectPath: string
-): Promise<ImportedBy[]> {
+async function findImportedBy(filePath: string, projectPath: string): Promise<ImportedBy[]> {
   const importedBy: ImportedBy[] = []
 
   // Get the base name without extension for matching
   const baseName = path.basename(filePath, path.extname(filePath))
-  const dirName = path.dirname(filePath)
+  const _dirName = path.dirname(filePath)
 
   try {
     // Use ripgrep if available, otherwise grep
@@ -364,7 +344,7 @@ async function findImportedBy(
     for (const file of files) {
       importedBy.push({ file })
     }
-  } catch (error) {
+  } catch (_error) {
     // grep not available or error - return empty
   }