prjct-cli 0.42.0 → 0.44.1

package/core/ai-tools/registry.ts

@@ -0,0 +1,195 @@
+/**
+ * AI Tools Registry
+ *
+ * Registry of AI coding tools (Claude Code, Cursor, Copilot, etc.)
+ * Each tool has its own context file format and token budget.
+ *
+ * Phase 1: Claude Code + Cursor
+ * Phase 2: + Copilot + Windsurf
+ * Phase 3: + Continue.dev + Auto-detection
+ */
+
+import { execSync } from 'child_process'
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+
+export interface AIToolConfig {
+  id: string
+  name: string
+  outputFile: string
+  outputPath: 'repo' | 'global'  // 'repo' = project root, 'global' = ~/.prjct-cli/projects/{id}/context/
+  maxTokens: number
+  format: 'detailed' | 'concise' | 'minimal' | 'json'
+  description: string
+}
+
+/**
+ * Supported AI tools registry
+ */
+export const AI_TOOLS: Record<string, AIToolConfig> = {
+  claude: {
+    id: 'claude',
+    name: 'Claude Code',
+    outputFile: 'CLAUDE.md',
+    outputPath: 'global',
+    maxTokens: 3000,
+    format: 'detailed',
+    description: 'Anthropic Claude Code CLI',
+  },
+  cursor: {
+    id: 'cursor',
+    name: 'Cursor',
+    outputFile: '.cursorrules',
+    outputPath: 'repo',
+    maxTokens: 2000,
+    format: 'concise',
+    description: 'Cursor AI Editor',
+  },
+  copilot: {
+    id: 'copilot',
+    name: 'GitHub Copilot',
+    outputFile: '.github/copilot-instructions.md',
+    outputPath: 'repo',
+    maxTokens: 1500,
+    format: 'minimal',
+    description: 'GitHub Copilot',
+  },
+  windsurf: {
+    id: 'windsurf',
+    name: 'Windsurf',
+    outputFile: '.windsurfrules',
+    outputPath: 'repo',
+    maxTokens: 2000,
+    format: 'concise',
+    description: 'Codeium Windsurf Editor',
+  },
+  continue: {
+    id: 'continue',
+    name: 'Continue.dev',
+    outputFile: '.continue/config.json',
+    outputPath: 'repo',
+    maxTokens: 1500,
+    format: 'json',
+    description: 'Continue.dev open-source AI assistant',
+  },
+}
+
+/**
+ * Default tools to generate (Phase 2: all major tools)
+ */
+export const DEFAULT_AI_TOOLS = ['claude', 'cursor', 'copilot', 'windsurf']
+
+/**
+ * All supported tool IDs
+ */
+export const SUPPORTED_AI_TOOLS = Object.keys(AI_TOOLS)
+
+/**
+ * Get tool config by ID
+ */
+export function getAIToolConfig(id: string): AIToolConfig | null {
+  return AI_TOOLS[id] || null
+}
+
+/**
+ * Parse --agents flag value
+ * Examples: "claude,cursor" or "all"
+ */
+export function parseAgentsFlag(value: string): string[] {
+  if (value === 'all') {
+    return SUPPORTED_AI_TOOLS
+  }
+
+  const requested = value.split(',').map(s => s.trim().toLowerCase())
+  return requested.filter(id => AI_TOOLS[id])
+}
+
+/**
+ * Validate tool IDs
+ */
+export function validateToolIds(ids: string[]): { valid: string[]; invalid: string[] } {
+  const valid: string[] = []
+  const invalid: string[] = []
+
+  for (const id of ids) {
+    if (AI_TOOLS[id]) {
+      valid.push(id)
+    } else {
+      invalid.push(id)
+    }
+  }
+
+  return { valid, invalid }
+}
+
+/**
+ * Check if a command exists in PATH
+ */
+function commandExists(cmd: string): boolean {
+  try {
+    execSync(`which ${cmd}`, { stdio: 'ignore' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Detect installed AI tools
+ * Returns list of tool IDs that are detected on the system
+ */
+export function detectInstalledTools(repoPath: string = process.cwd()): string[] {
+  const detected: string[] = []
+
+  // Claude Code: check for 'claude' command
+  if (commandExists('claude')) {
+    detected.push('claude')
+  }
+
+  // Cursor: check for command or .cursor/ directory in repo
+  if (commandExists('cursor') || fs.existsSync(path.join(repoPath, '.cursor'))) {
+    detected.push('cursor')
+  }
+
+  // Copilot: check for .github/ directory (likely has Copilot if using GitHub)
+  if (fs.existsSync(path.join(repoPath, '.github'))) {
+    detected.push('copilot')
+  }
+
+  // Windsurf: check for command or .windsurf/ directory
+  if (commandExists('windsurf') || fs.existsSync(path.join(repoPath, '.windsurf'))) {
+    detected.push('windsurf')
+  }
+
+  // Continue.dev: check for .continue/ directory
+  if (fs.existsSync(path.join(repoPath, '.continue')) || fs.existsSync(path.join(os.homedir(), '.continue'))) {
+    detected.push('continue')
+  }
+
+  return detected
+}
+
+/**
+ * Get tools to generate based on mode
+ * - 'auto': detect installed tools
+ * - 'all': all supported tools
+ * - specific: use provided list
+ */
+export function resolveToolIds(
+  mode: 'auto' | 'all' | string[],
+  repoPath: string = process.cwd()
+): string[] {
+  if (mode === 'auto') {
+    const detected = detectInstalledTools(repoPath)
+    // Always include claude if nothing detected (safe default)
+    return detected.length > 0 ? detected : ['claude']
+  }
+
+  if (mode === 'all') {
+    return SUPPORTED_AI_TOOLS
+  }
+
+  // Specific list provided
+  return mode.filter(id => AI_TOOLS[id])
+}

package/core/cli/linear.ts

@@ -9,6 +9,9 @@
  *   list                       - List my assigned issues
  *   list-team <teamId>         - List issues from a team
  *   get <id>                   - Get issue by ID or identifier (PRJ-123)
+ *   get-local <id>             - Get issue from local cache (no API call)
+ *   sync                       - Pull all assigned issues to local storage
+ *   sync-status                - Check local cache status
  *   create <json>              - Create issue from JSON input
  *   update <id> <json>         - Update issue
  *   start <id>                 - Mark issue as in progress
@@ -21,7 +24,7 @@
  * All output is JSON for easy parsing by Claude.
  */
 
-import { linearService } from '../integrations/linear'
+import { linearService, linearSync } from '../integrations/linear'
 import {
   getLinearApiKey,
   setLinearCredentials,
@@ -136,7 +139,16 @@ async function main(): Promise<void> {
       case 'list': {
         await initFromProject()
         const limit = commandArgs[0] ? parseInt(commandArgs[0], 10) : 20
-        const issues = await linearService.fetchAssignedIssues({ limit })
+
+        // Use team issues if teamId is configured, otherwise assigned issues
+        const creds = await getProjectCredentials(projectId!)
+        let issues
+        if (creds.linear?.teamId) {
+          issues = await linearService.fetchTeamIssues(creds.linear.teamId, { limit })
+        } else {
+          issues = await linearService.fetchAssignedIssues({ limit })
+        }
+
         output({
           count: issues.length,
           issues: issues.map((issue) => ({
@@ -192,6 +204,50 @@ async function main(): Promise<void> {
         break
       }
 
+      case 'get-local': {
+        if (!projectId) {
+          error('--project required for get-local')
+        }
+
+        const id = commandArgs[0]
+        if (!id) {
+          error('Issue ID required. Usage: get-local <id>')
+        }
+
+        const cachedIssue = await linearSync.getIssueLocal(projectId, id)
+        if (!cachedIssue) {
+          error(`Issue not in local cache: ${id}. Run 'sync' first.`)
+        }
+
+        output(cachedIssue)
+        break
+      }
+
+      case 'sync': {
+        if (!projectId) {
+          error('--project required for sync')
+        }
+
+        await initFromProject()
+        const result = await linearSync.pullAll(projectId)
+
+        output({
+          success: result.errors.length === 0,
+          ...result,
+        })
+        break
+      }
+
+      case 'sync-status': {
+        if (!projectId) {
+          error('--project required for sync-status')
+        }
+
+        const status = await linearSync.getSyncStatus(projectId)
+        output(status)
+        break
+      }
+
       case 'create': {
         await initFromProject()
         const inputJson = commandArgs[0]
@@ -357,6 +413,9 @@ async function main(): Promise<void> {
             list: 'list [limit] - List my assigned issues',
             'list-team': 'list-team <teamId> [limit] - List team issues',
             get: 'get <id> - Get issue by ID or identifier',
+            'get-local': 'get-local <id> - Get from local cache (no API)',
+            sync: 'sync - Pull all assigned issues to local storage',
+            'sync-status': 'sync-status - Check local cache status',
             create: 'create <json> - Create issue',
             update: 'update <id> <json> - Update issue',
             start: 'start <id> - Mark as in progress',

package/core/commands/analysis.ts

@@ -17,6 +17,7 @@ import analyzer from '../domain/analyzer'
 import { generateContext } from '../context/generator'
 import commandInstaller from '../infrastructure/command-installer'
 import { syncService } from '../services'
+import { showNextSteps } from '../utils/next-steps'
 
 export class AnalysisCommands extends PrjctCommandsBase {
   /**
@@ -205,15 +206,16 @@ export class AnalysisCommands extends PrjctCommandsBase {
    *
    * This eliminates the need for Claude to make 50+ individual tool calls.
    */
-  async sync(projectPath: string = process.cwd()): Promise<CommandResult> {
+  async sync(projectPath: string = process.cwd(), options: { aiTools?: string[] } = {}): Promise<CommandResult> {
     try {
       const initResult = await this.ensureProjectInit(projectPath)
       if (!initResult.success) return initResult
 
+      const startTime = Date.now()
       console.log('🔄 Syncing project...\n')
 
       // Use syncService to do EVERYTHING in one call
-      const result = await syncService.sync(projectPath)
+      const result = await syncService.sync(projectPath, { aiTools: options.aiTools })
 
       if (!result.success) {
         console.error('❌ Sync failed:', result.error)
@@ -246,6 +248,17 @@ export class AnalysisCommands extends PrjctCommandsBase {
       }
       console.log('')
 
+      // Show AI Tools generated (multi-agent output)
+      if (result.aiTools && result.aiTools.length > 0) {
+        const successTools = result.aiTools.filter(t => t.success)
+        console.log(`🤖 AI Tools Context (${successTools.length})`)
+        for (const tool of result.aiTools) {
+          const status = tool.success ? '✓' : '✗'
+          console.log(`├── ${status} ${tool.outputFile} (${tool.toolId})`)
+        }
+        console.log('')
+      }
+
       const workflowAgents = result.agents.filter(a => a.type === 'workflow').map(a => a.name)
       const domainAgents = result.agents.filter(a => a.type === 'domain').map(a => a.name)
 
@@ -267,9 +280,30 @@ export class AnalysisCommands extends PrjctCommandsBase {
         console.log('✨ Repository is clean!\n')
       }
 
+      showNextSteps('sync')
+
+      // Summary metrics
+      const elapsed = Date.now() - startTime
+      const contextFilesCount = result.contextFiles.length + (result.aiTools?.filter(t => t.success).length || 0)
+      const agentCount = result.agents.length
+
+      console.log('─'.repeat(45))
+      console.log(`📊 Sync Summary`)
+      console.log(`   Stack: ${result.stats.ecosystem} (${result.stats.frameworks.join(', ') || 'no frameworks'})`)
+      console.log(`   Files: ${result.stats.fileCount} analyzed → ${contextFilesCount} context files`)
+      console.log(`   Agents: ${agentCount} (${result.agents.filter(a => a.type === 'domain').length} domain)`)
+      console.log(`   Time: ${(elapsed / 1000).toFixed(1)}s`)
+      console.log('')
+
       return {
         success: true,
         data: result,
+        metrics: {
+          elapsed,
+          contextFilesCount,
+          agentCount,
+          fileCount: result.stats.fileCount,
+        },
       }
     } catch (error) {
       console.error('❌ Error:', (error as Error).message)

package/core/commands/commands.ts

@@ -154,8 +154,8 @@ class PrjctCommands {
     return this.analysis.analyze(options, projectPath)
   }
 
-  async sync(projectPath: string = process.cwd()): Promise<CommandResult> {
-    return this.analysis.sync(projectPath)
+  async sync(projectPath: string = process.cwd(), options: { aiTools?: string[] } = {}): Promise<CommandResult> {
+    return this.analysis.sync(projectPath, options)
   }
 
   // ========== Context Commands ==========

package/core/commands/planning.ts

@@ -21,6 +21,7 @@ import {
 import { queueStorage, ideasStorage } from '../storage'
 import authorDetector from '../infrastructure/author-detector'
 import commandInstaller from '../infrastructure/command-installer'
+import { showNextSteps } from '../utils/next-steps'
 
 // Lazy-loaded to avoid circular dependencies
 let _analysisCommands: import('./analysis').AnalysisCommands | null = null
@@ -47,7 +48,7 @@ export class PlanningCommands extends PrjctCommandsBase {
         return { success: false, message: 'Already initialized' }
       }
 
-      out.spin('initializing...')
+      out.step(1, 4, 'Detecting author...')
 
       const detectedAuthor = await authorDetector.detect()
       // Convert null to undefined for createConfig
@@ -59,7 +60,7 @@ export class PlanningCommands extends PrjctCommandsBase {
       const config = await configManager.createConfig(projectPath, author)
       const projectId = config.projectId
 
-      out.spin('creating structure...')
+      out.step(2, 4, 'Creating structure...')
 
       await pathManager.ensureProjectStructure(projectId)
       const globalPath = pathManager.getGlobalProjectPath(projectId)
@@ -91,12 +92,12 @@ export class PlanningCommands extends PrjctCommandsBase {
       const hasCode = await this._detectExistingCode(projectPath)
 
       if (hasCode || !isEmpty) {
-        out.spin('analyzing project...')
+        out.step(3, 4, 'Analyzing project...')
         const analysis = await getAnalysisCommands()
         const analysisResult = await analysis.analyze({}, projectPath)
 
         if (analysisResult.success) {
-          out.spin('generating agents...')
+          out.step(4, 4, 'Generating agents...')
           await analysis.sync(projectPath)
           out.done('initialized')
           return { success: true, mode: 'existing', projectId }
@@ -123,6 +124,7 @@ export class PlanningCommands extends PrjctCommandsBase {
       await commandInstaller.installGlobalConfig()
 
       out.done('initialized')
+      showNextSteps('init')
       return { success: true, projectId }
     } catch (error) {
       out.fail((error as Error).message)
@@ -250,6 +252,7 @@ export class PlanningCommands extends PrjctCommandsBase {
       })
 
       out.done(`bug [${severity}] → ${agent}`)
+      showNextSteps('bug')
 
       return { success: true, bug: description, severity, agent }
     } catch (error) {
@@ -416,6 +419,7 @@ Generated: ${new Date().toLocaleString()}
         })
 
         out.done(`idea captured: ${description.slice(0, 40)}`)
+        showNextSteps('idea')
 
         return { success: true, mode: 'capture', idea: description }
       }

package/core/commands/shipping.ts

@@ -18,6 +18,7 @@ import {
   out
 } from './base'
 import { stateStorage, shippedStorage } from '../storage'
+import { showNextSteps } from '../utils/next-steps'
 
 export class ShippingCommands extends PrjctCommandsBase {
   /**
@@ -70,22 +71,22 @@ export class ShippingCommands extends PrjctCommandsBase {
         featureName = currentTask?.description || 'current work'
       }
 
-      out.spin(`shipping ${featureName}...`)
-
+      // Ship steps with progress indicator
+      out.step(1, 5, `Linting ${featureName}...`)
       const lintResult = await this._runLint(projectPath)
 
-      out.spin('running tests...')
+      out.step(2, 5, 'Running tests...')
       const testResult = await this._runTests(projectPath)
 
-      out.spin('updating version...')
+      out.step(3, 5, 'Updating version...')
       const newVersion = await this._bumpVersion(projectPath)
       await this._updateChangelog(featureName, newVersion, projectPath)
 
-      out.spin('committing...')
+      out.step(4, 5, 'Committing...')
       const commitResult = await this._createShipCommit(featureName, projectPath)
 
       if (commitResult.success) {
-        out.spin('pushing...')
+        out.step(5, 5, 'Pushing...')
         await this._gitPush(projectPath)
       }
 
@@ -116,6 +117,7 @@ export class ShippingCommands extends PrjctCommandsBase {
       }
 
       out.done(`v${newVersion} shipped`)
+      showNextSteps('ship')
 
       return { success: true, feature: featureName, version: newVersion }
     } catch (error) {
@@ -215,7 +217,7 @@ export class ShippingCommands extends PrjctCommandsBase {
     try {
       await toolRegistry.get('Bash')!('git add .')
 
-      const commitMsg = `feat: ${feature}\n\n🤖 Generated with [p/](https://www.prjct.app/)\nDesigned for [Claude](https://www.anthropic.com/claude)`
+      const commitMsg = `feat: ${feature}\n\nGenerated with [p/](https://www.prjct.app/)`
 
       await toolRegistry.get('Bash')!(`git commit -m "${commitMsg.replace(/"/g, '\\"')}"`)
 

package/core/commands/workflow.ts

@@ -20,6 +20,10 @@ import {
 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 { linearService } from '../integrations/linear'
+import { getProjectCredentials, getLinearApiKey } from '../utils/project-credentials'
 
 export class WorkflowCommands extends PrjctCommandsBase {
   /**
@@ -45,24 +49,39 @@ export class WorkflowCommands extends PrjctCommandsBase {
           return { success: false, error: result.error }
         }
 
+        // Check if task is a Linear issue ID (e.g., PRJ-139)
+        let linearId: string | undefined
+        let taskDescription = task
+        const linearPattern = /^[A-Z]+-\d+$/
+        if (linearPattern.test(task)) {
+          try {
+            const creds = await getProjectCredentials(projectId)
+            const apiKey = await getLinearApiKey(projectId)
+            if (apiKey && creds.linear?.teamId) {
+              await linearService.initializeFromApiKey(
+                apiKey,
+                creds.linear.teamId
+              )
+              const issue = await linearService.fetchIssue(task)
+              if (issue) {
+                linearId = task
+                taskDescription = `${task}: ${issue.title}`
+                // Mark as in progress in Linear
+                await linearService.markInProgress(task)
+              }
+            }
+          } catch {
+            // Linear fetch failed - continue with task as-is
+          }
+        }
+
         // Write-through: JSON → MD → Event
         await stateStorage.startTask(projectId, {
           id: generateUUID(),
-          description: task,
-          sessionId: generateUUID()
-        })
-
-        // 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`)
-          }
-        }
+          description: taskDescription,
+          sessionId: generateUUID(),
+          linearId,
+        } as Parameters<typeof stateStorage.startTask>[1])
 
         // Get available agents for backward compatibility
         const availableAgents = await templateExecutor.getAvailableAgents(projectPath)
@@ -70,7 +89,9 @@ export class WorkflowCommands extends PrjctCommandsBase {
           ? availableAgents.join(', ')
           : 'none (run p. sync)'
 
-        out.done(`${task} [specialists: ${agentsList}]`)
+        out.done(`${task}`)
+        showStateInfo('working')
+        showNextSteps('task')
 
         await this.logToMemory(projectPath, 'task_started', {
           task,
@@ -139,7 +160,31 @@ export class WorkflowCommands extends PrjctCommandsBase {
       // Write-through: Complete task (JSON → MD → Event)
       await stateStorage.completeTask(projectId)
 
-      out.done(`${task}${duration ? ` (${duration})` : ''}`)
+      // Sync to Linear if task has linearId
+      const linearId = (currentTask as { linearId?: string }).linearId
+      if (linearId) {
+        try {
+          const creds = await getProjectCredentials(projectId)
+          const apiKey = await getLinearApiKey(projectId)
+          if (apiKey && creds.linear?.teamId) {
+            await linearService.initializeFromApiKey(
+              apiKey,
+              creds.linear.teamId
+            )
+            await linearService.markDone(linearId)
+            out.done(`${task}${duration ? ` (${duration})` : ''} → Linear ✓`)
+          } else {
+            out.done(`${task}${duration ? ` (${duration})` : ''}`)
+          }
+        } catch {
+          // Linear sync failed silently - don't block the workflow
+          out.done(`${task}${duration ? ` (${duration})` : ''}`)
+        }
+      } else {
+        out.done(`${task}${duration ? ` (${duration})` : ''}`)
+      }
+      showStateInfo('completed')
+      showNextSteps('done')
 
       await this.logToMemory(projectPath, 'task_completed', {
         task,
@@ -176,6 +221,7 @@ export class WorkflowCommands extends PrjctCommandsBase {
       }
 
       out.done(`${tasks.length} task${tasks.length !== 1 ? 's' : ''} queued`)
+      showNextSteps('next')
 
       return { success: true, tasks, count: tasks.length }
     } catch (error) {
@@ -210,6 +256,8 @@ export class WorkflowCommands extends PrjctCommandsBase {
 
       const taskDesc = currentTask.description.slice(0, 40)
       out.done(`paused: ${taskDesc}${reason ? ` (${reason})` : ''}`)
+      showStateInfo('paused')
+      showNextSteps('pause')
 
       await this.logToMemory(projectPath, 'task_paused', {
         task: currentTask.description,
@@ -254,6 +302,8 @@ export class WorkflowCommands extends PrjctCommandsBase {
       }
 
       out.done(`resumed: ${resumed.description.slice(0, 40)}`)
+      showStateInfo('working')
+      showNextSteps('resume')
 
       await this.logToMemory(projectPath, 'task_resumed', {
         task: resumed.description,

package/core/index.ts

@@ -118,7 +118,9 @@ async function main(): Promise<void> {
         redo: () => commands.redo(),
         history: () => commands.history(),
         // Setup
-        sync: () => commands.sync(),
+        sync: () => commands.sync(process.cwd(), {
+          aiTools: options.agents ? String(options.agents).split(',') : undefined,
+        }),
         start: () => commands.start(),
         // Context (for Claude templates)
         context: (p) => commands.context(p),