prjct-cli 0.44.1 → 0.45.3

package/core/integrations/jira/mcp-adapter.ts

@@ -19,15 +19,14 @@
  */
 
 import type {
-  IssueTrackerProvider,
-  Issue,
   CreateIssueInput,
-  UpdateIssueInput,
   FetchOptions,
-  JiraConfig,
-  IssueStatus,
+  Issue,
   IssuePriority,
+  IssueStatus,
+  IssueTrackerProvider,
   IssueType,
+  JiraConfig,
 } from '../issue-tracker/types'
 
 // =============================================================================
@@ -323,9 +322,7 @@ export class JiraMCPAdapter implements Partial<IssueTrackerProvider> {
     const statusCategory = mcpIssue.fields.status.statusCategory?.key || ''
 
     const status: IssueStatus =
-      JIRA_STATUS_NAME_MAP[statusName] ||
-      JIRA_STATUS_CATEGORY_MAP[statusCategory] ||
-      'backlog'
+      JIRA_STATUS_NAME_MAP[statusName] || JIRA_STATUS_CATEGORY_MAP[statusCategory] || 'backlog'
 
     const priorityName = mcpIssue.fields.priority?.name?.toLowerCase() || 'medium'
     const priority: IssuePriority = JIRA_PRIORITY_MAP[priorityName] || 'medium'
@@ -400,8 +397,6 @@ export class JiraMCPAdapter implements Partial<IssueTrackerProvider> {
         return 'Improvement'
       case 'epic':
         return 'Epic'
-      case 'chore':
-      case 'task':
       default:
         return 'Task'
     }

package/core/integrations/jira/service.ts

@@ -4,21 +4,21 @@
  * All operations are cached with 5-minute TTL.
  */
 
-import { jiraProvider } from './client'
-import {
-  issueCache,
-  assignedIssuesCache,
-  projectsCache,
-  clearJiraCache,
-  getJiraCacheStats,
-} from './cache'
 import type {
-  Issue,
   CreateIssueInput,
-  UpdateIssueInput,
   FetchOptions,
+  Issue,
   JiraConfig,
+  UpdateIssueInput,
 } from '../issue-tracker/types'
+import {
+  assignedIssuesCache,
+  clearJiraCache,
+  getJiraCacheStats,
+  issueCache,
+  projectsCache,
+} from './cache'
+import { jiraProvider } from './client'
 
 export class JiraService {
   private initialized = false

package/core/integrations/linear/client.ts

@@ -6,15 +6,15 @@
 import { LinearClient as LinearSDK } from '@linear/sdk'
 import { getCredential } from '../../utils/keychain'
 import type {
-  IssueTrackerProvider,
-  Issue,
   CreateIssueInput,
-  UpdateIssueInput,
   FetchOptions,
-  LinearConfig,
-  IssueStatus,
+  Issue,
   IssuePriority,
+  IssueStatus,
+  IssueTrackerProvider,
   IssueType,
+  LinearConfig,
+  UpdateIssueInput,
 } from '../issue-tracker/types'
 
 // =============================================================================
@@ -74,9 +74,7 @@ export class LinearProvider implements IssueTrackerProvider {
     // Try config first, then keychain (which falls back to env var)
     const apiKey = config.apiKey || (await getCredential('linear-api-key'))
     if (!apiKey) {
-      throw new Error(
-        'LINEAR_API_KEY not configured. Run `p. linear setup` to configure.'
-      )
+      throw new Error('LINEAR_API_KEY not configured. Run `p. linear setup` to configure.')
     }
 
     this.sdk = new LinearSDK({ apiKey })
@@ -118,9 +116,7 @@ export class LinearProvider implements IssueTrackerProvider {
       filter: Object.keys(filter).length > 0 ? filter : undefined,
     })
 
-    return Promise.all(
-      assignedIssues.nodes.map((issue) => this.mapIssue(issue))
-    )
+    return Promise.all(assignedIssues.nodes.map((issue) => this.mapIssue(issue)))
   }
 
   /**
@@ -356,7 +352,10 @@ export class LinearProvider implements IssueTrackerProvider {
       description: linearIssue.description || undefined,
       status: LINEAR_STATUS_MAP[state?.type || 'backlog'] || 'backlog',
       priority: LINEAR_PRIORITY_MAP[linearIssue.priority] || 'none',
-      type: this.inferType(linearIssue.title, labels.nodes.map((l) => l.name)),
+      type: this.inferType(
+        linearIssue.title,
+        labels.nodes.map((l) => l.name)
+      ),
       assignee: assignee
         ? {
             id: assignee.id,
@@ -395,13 +394,25 @@ export class LinearProvider implements IssueTrackerProvider {
     if (labelsLower.includes('bug') || titleLower.includes('fix') || titleLower.includes('bug')) {
       return 'bug'
     }
-    if (labelsLower.includes('feature') || titleLower.includes('add') || titleLower.includes('implement')) {
+    if (
+      labelsLower.includes('feature') ||
+      titleLower.includes('add') ||
+      titleLower.includes('implement')
+    ) {
       return 'feature'
     }
-    if (labelsLower.includes('improvement') || titleLower.includes('improve') || titleLower.includes('enhance')) {
+    if (
+      labelsLower.includes('improvement') ||
+      titleLower.includes('improve') ||
+      titleLower.includes('enhance')
+    ) {
       return 'improvement'
     }
-    if (labelsLower.includes('chore') || titleLower.includes('chore') || titleLower.includes('deps')) {
+    if (
+      labelsLower.includes('chore') ||
+      titleLower.includes('chore') ||
+      titleLower.includes('deps')
+    ) {
       return 'chore'
     }
 
@@ -417,9 +428,7 @@ export class LinearProvider implements IssueTrackerProvider {
     const team = await this.sdk.team(teamId)
     const labels = await team.labels()
 
-    return labels.nodes
-      .filter((label) => labelNames.includes(label.name))
-      .map((label) => label.id)
+    return labels.nodes.filter((label) => labelNames.includes(label.name)).map((label) => label.id)
   }
 }
 

package/core/integrations/linear/index.ts

@@ -3,21 +3,18 @@
  * Issue tracker provider for Linear using @linear/sdk
  */
 
-// Core provider
-export { LinearProvider, linearProvider } from './client'
-
-// Service layer with caching (preferred API)
-export { LinearService, linearService } from './service'
-
-// Sync layer for bidirectional sync with issues.json
-export { LinearSync, linearSync } from './sync'
-
 // Cache utilities
 export {
-  issueCache,
   assignedIssuesCache,
-  teamsCache,
-  projectsCache,
   clearLinearCache,
   getLinearCacheStats,
+  issueCache,
+  projectsCache,
+  teamsCache,
 } from './cache'
+// Core provider
+export { LinearProvider, linearProvider } from './client'
+// Service layer with caching (preferred API)
+export { LinearService, linearService } from './service'
+// Sync layer for bidirectional sync with issues.json
+export { LinearSync, linearSync } from './sync'

package/core/integrations/linear/service.ts

@@ -4,22 +4,22 @@
  * All operations are cached with 5-minute TTL.
  */
 
-import { linearProvider } from './client'
-import {
-  issueCache,
-  assignedIssuesCache,
-  teamsCache,
-  projectsCache,
-  clearLinearCache,
-  getLinearCacheStats,
-} from './cache'
 import type {
-  Issue,
   CreateIssueInput,
-  UpdateIssueInput,
   FetchOptions,
+  Issue,
   LinearConfig,
+  UpdateIssueInput,
 } from '../issue-tracker/types'
+import {
+  assignedIssuesCache,
+  clearLinearCache,
+  getLinearCacheStats,
+  issueCache,
+  projectsCache,
+  teamsCache,
+} from './cache'
+import { linearProvider } from './client'
 
 export class LinearService {
   private initialized = false

package/core/integrations/linear/sync.ts

@@ -14,19 +14,19 @@
  *   state.json.currentTask.linearId ← DIRECT LINK
  */
 
-import { readFile, writeFile, mkdir } from 'fs/promises'
-import { existsSync } from 'fs'
-import { join } from 'path'
-import { linearService } from './service'
-import { getProjectPath } from '../../schemas/schemas'
+import { existsSync } from 'node:fs'
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
 import {
-  type IssuesJson,
   type CachedIssue,
-  type SyncResult,
   createEmptyIssues,
+  type IssuesJson,
   parseIssues,
+  type SyncResult,
 } from '../../schemas/issues'
+import { getProjectPath } from '../../schemas/schemas'
 import type { Issue } from '../issue-tracker/types'
+import { linearService } from './service'
 
 // Default staleness threshold: 30 minutes
 const DEFAULT_STALE_AFTER = 30 * 60 * 1000
@@ -105,7 +105,7 @@ export class LinearSync {
     const issuesJson = await this.loadIssues(projectId)
 
     // Check local cache first
-    if (issuesJson && issuesJson.issues[identifier]) {
+    if (issuesJson?.issues[identifier]) {
       const cachedIssue = issuesJson.issues[identifier]
 
       // Check if cached issue is still fresh (within fetchedAt + some grace period)

package/core/outcomes/analyzer.ts

@@ -5,14 +5,8 @@
  * Powers the learning loop for better estimates and agent selection.
  */
 
+import type { AgentMetrics, DetectedPattern, Outcome, OutcomeSummary } from '../types'
 import outcomeRecorder from './recorder'
-import type {
-  Outcome,
-  OutcomeSummary,
-  QualityScore,
-  DetectedPattern,
-  AgentMetrics,
-} from '../types'
 
 /**
  * OutcomeAnalyzer - Extracts insights from outcomes.
@@ -36,8 +30,7 @@ export class OutcomeAnalyzer {
     }
 
     // Calculate average quality
-    const avgQuality =
-      outcomes.reduce((sum, o) => sum + o.qualityScore, 0) / outcomes.length
+    const avgQuality = outcomes.reduce((sum, o) => sum + o.qualityScore, 0) / outcomes.length
 
     // Calculate estimate accuracy
     const estimateAccuracy = await outcomeRecorder.getEstimateAccuracy(projectId)
@@ -98,8 +91,7 @@ export class OutcomeAnalyzer {
       const successful = agentOutcomes.filter((o) => o.completedAsPlanned)
       const successRate = Math.round((successful.length / tasksCompleted) * 100)
 
-      const avgQuality =
-        agentOutcomes.reduce((sum, o) => sum + o.qualityScore, 0) / tasksCompleted
+      const avgQuality = agentOutcomes.reduce((sum, o) => sum + o.qualityScore, 0) / tasksCompleted
 
       // Calculate estimate accuracy for this agent
       const accurateEstimates = agentOutcomes.filter((o) => {
@@ -109,9 +101,7 @@ export class OutcomeAnalyzer {
         if (estimated === 0) return false
         return Math.abs(variance) / estimated <= 0.2
       })
-      const estimateAccuracy = Math.round(
-        (accurateEstimates.length / tasksCompleted) * 100
-      )
+      const estimateAccuracy = Math.round((accurateEstimates.length / tasksCompleted) * 100)
 
       // Find best task types
       const taskTypes = new Map<string, number>()
@@ -214,10 +204,7 @@ export class OutcomeAnalyzer {
   /**
    * Suggest estimate for a task type based on history.
    */
-  async suggestEstimate(
-    projectId: string,
-    taskType: string
-  ): Promise<string | null> {
+  async suggestEstimate(projectId: string, taskType: string): Promise<string | null> {
     const outcomes = await outcomeRecorder.getAll(projectId)
 
     // Filter by task type (using tags)

package/core/outcomes/index.ts

@@ -29,6 +29,6 @@
  * ```
  */
 
-export { OutcomeRecorder, default as outcomeRecorder } from './recorder'
-export { OutcomeAnalyzer, default as outcomeAnalyzer } from './analyzer'
 export * from '../types'
+export { default as outcomeAnalyzer, OutcomeAnalyzer } from './analyzer'
+export { default as outcomeRecorder, OutcomeRecorder } from './recorder'

package/core/outcomes/recorder.ts

@@ -5,11 +5,11 @@
  * Appends to JSONL files for efficient streaming.
  */
 
-import path from 'path'
-import * as fileHelper from '../utils/file-helper'
+import path from 'node:path'
 import pathManager from '../infrastructure/path-manager'
 import { generateUUID } from '../schemas'
-import type { Outcome, OutcomeInput, OutcomeFilter } from '../types'
+import type { Outcome, OutcomeFilter, OutcomeInput } from '../types'
+import * as fileHelper from '../utils/file-helper'
 
 const OUTCOMES_DIR = 'outcomes'
 const OUTCOMES_FILE = 'outcomes.jsonl'

package/core/plugin/builtin/webhook.ts

@@ -17,10 +17,10 @@
  * }
  */
 
-import crypto from 'crypto'
+import crypto from 'node:crypto'
 import { EventTypes } from '../../bus'
+import type { WebhookConfig, WebhookPayload, WebhookPluginContext } from '../../types'
 import { HookPoints } from '../hooks'
-import type { WebhookConfig, WebhookPluginContext, WebhookPayload } from '../../types'
 
 const plugin = {
   name: 'webhook',
@@ -47,7 +47,7 @@ const plugin = {
     plugin.enabledEvents = config.events || [
       EventTypes.SESSION_COMPLETED,
       EventTypes.FEATURE_SHIPPED,
-      EventTypes.SNAPSHOT_CREATED
+      EventTypes.SNAPSHOT_CREATED,
     ]
   },
 
@@ -62,34 +62,38 @@ const plugin = {
    * Event handlers
    */
   events: {
-    [EventTypes.SESSION_COMPLETED]: async function(data: unknown): Promise<void> {
+    [EventTypes.SESSION_COMPLETED]: async (data: unknown): Promise<void> => {
       await plugin.sendWebhook('session.completed', data)
     },
 
-    [EventTypes.FEATURE_SHIPPED]: async function(data: unknown): Promise<void> {
+    [EventTypes.FEATURE_SHIPPED]: async (data: unknown): Promise<void> => {
       await plugin.sendWebhook('feature.shipped', data)
     },
 
-    [EventTypes.SNAPSHOT_CREATED]: async function(data: unknown): Promise<void> {
+    [EventTypes.SNAPSHOT_CREATED]: async (data: unknown): Promise<void> => {
       await plugin.sendWebhook('snapshot.created', data)
     },
 
-    [EventTypes.TASK_COMPLETED]: async function(data: unknown): Promise<void> {
+    [EventTypes.TASK_COMPLETED]: async (data: unknown): Promise<void> => {
       await plugin.sendWebhook('task.completed', data)
-    }
+    },
   },
 
   /**
    * Hook handlers
    */
   hooks: {
-    [HookPoints.AFTER_FEATURE_SHIP]: async function(data: { feature: string; version: string; timestamp: string }): Promise<void> {
+    [HookPoints.AFTER_FEATURE_SHIP]: async (data: {
+      feature: string
+      version: string
+      timestamp: string
+    }): Promise<void> => {
       await plugin.sendWebhook('feature.shipped', {
         feature: data.feature,
         version: data.version,
-        timestamp: data.timestamp
+        timestamp: data.timestamp,
       })
-    }
+    },
   },
 
   /**
@@ -107,13 +111,13 @@ const plugin = {
       event,
       timestamp: new Date().toISOString(),
       source: 'prjct-cli',
-      data
+      data,
     }
 
     try {
       const headers: Record<string, string> = {
         'Content-Type': 'application/json',
-        'User-Agent': 'prjct-cli/webhook'
+        'User-Agent': 'prjct-cli/webhook',
       }
 
       // Add signature if secret is configured
@@ -128,7 +132,7 @@ const plugin = {
       const response = await fetch(plugin.config.url, {
         method: 'POST',
         headers,
-        body: JSON.stringify(payload)
+        body: JSON.stringify(payload),
       })
 
       if (!response.ok) {
@@ -137,7 +141,7 @@ const plugin = {
     } catch (error) {
       console.error(`[webhook] Error sending webhook:`, (error as Error).message)
     }
-  }
+  },
 }
 
 export default plugin

package/core/plugin/hooks.ts

@@ -7,7 +7,7 @@
  * @version 1.0.0
  */
 
-import { eventBus, EventTypes } from '../bus'
+import { EventTypes, eventBus } from '../bus'
 
 /**
  * Hook Points - Where plugins can intercept
@@ -37,10 +37,10 @@ const HookPoints = {
   // Transform hooks (must return modified data)
   TRANSFORM_COMMIT_MESSAGE: 'transform:commit.message',
   TRANSFORM_TASK_DATA: 'transform:task.data',
-  TRANSFORM_METRICS: 'transform:metrics'
+  TRANSFORM_METRICS: 'transform:metrics',
 } as const
 
-type HookPoint = typeof HookPoints[keyof typeof HookPoints]
+type HookPoint = (typeof HookPoints)[keyof typeof HookPoints]
 type HookHandler = (data: unknown, context?: unknown) => unknown | Promise<unknown>
 
 interface HookEntry {
@@ -83,7 +83,7 @@ class HookSystem {
       handler,
       pluginName,
       priority,
-      id: `${pluginName}:${Date.now()}`
+      id: `${pluginName}:${Date.now()}`,
     }
 
     this.hooks.get(hookPoint)!.push(hookEntry)
@@ -107,7 +107,7 @@ class HookSystem {
   unregister(hookPoint: string, id: string): void {
     const hooks = this.hooks.get(hookPoint)
     if (hooks) {
-      const index = hooks.findIndex(h => h.id === id)
+      const index = hooks.findIndex((h) => h.id === id)
       if (index !== -1) {
         hooks.splice(index, 1)
       }
@@ -130,7 +130,10 @@ class HookSystem {
   /**
    * Execute a "before" hook (can modify data)
    */
-  async executeBefore(hookPoint: string, data: Record<string, unknown>): Promise<Record<string, unknown>> {
+  async executeBefore(
+    hookPoint: string,
+    data: Record<string, unknown>
+  ): Promise<Record<string, unknown>> {
     const hooks = this.hooks.get(hookPoint) || []
     let result = { ...data }
 
@@ -157,11 +160,14 @@ class HookSystem {
 
     // Execute all hooks in parallel for after hooks
     await Promise.allSettled(
-      hooks.map(async hook => {
+      hooks.map(async (hook) => {
         try {
           await hook.handler(data)
         } catch (error) {
-          console.error(`Hook error [${hook.pluginName}] at ${hookPoint}:`, (error as Error).message)
+          console.error(
+            `Hook error [${hook.pluginName}] at ${hookPoint}:`,
+            (error as Error).message
+          )
         }
       })
     )
@@ -176,7 +182,11 @@ class HookSystem {
   /**
    * Execute a "transform" hook (must return modified value)
    */
-  async executeTransform<T>(hookPoint: string, value: T, context: Record<string, unknown> = {}): Promise<T> {
+  async executeTransform<T>(
+    hookPoint: string,
+    value: T,
+    context: Record<string, unknown> = {}
+  ): Promise<T> {
     const hooks = this.hooks.get(hookPoint) || []
     let result = value
 
@@ -187,7 +197,10 @@ class HookSystem {
           result = transformed as T
         }
       } catch (error) {
-        console.error(`Transform hook error [${hook.pluginName}] at ${hookPoint}:`, (error as Error).message)
+        console.error(
+          `Transform hook error [${hook.pluginName}] at ${hookPoint}:`,
+          (error as Error).message
+        )
         // Keep previous value on error
       }
     }
@@ -210,7 +223,7 @@ class HookSystem {
       [HookPoints.AFTER_SNAPSHOT_RESTORE]: EventTypes.SNAPSHOT_RESTORED,
       [HookPoints.AFTER_COMMIT]: EventTypes.COMMIT_CREATED,
       [HookPoints.AFTER_PUSH]: EventTypes.PUSH_COMPLETED,
-      [HookPoints.AFTER_SYNC]: EventTypes.PROJECT_SYNCED
+      [HookPoints.AFTER_SYNC]: EventTypes.PROJECT_SYNCED,
     }
     return mapping[hookPoint] || null
   }
@@ -219,9 +232,9 @@ class HookSystem {
    * Get all registered hooks for a point
    */
   getHooks(hookPoint: string): Array<{ pluginName: string; priority: number }> {
-    return (this.hooks.get(hookPoint) || []).map(h => ({
+    return (this.hooks.get(hookPoint) || []).map((h) => ({
       pluginName: h.pluginName,
-      priority: h.priority
+      priority: h.priority,
     }))
   }
 
@@ -230,7 +243,7 @@ class HookSystem {
    */
   getPluginHooks(pluginName: string): string[] {
     const entries = this.pluginHooks.get(pluginName) || []
-    return entries.map(e => e.hookPoint)
+    return entries.map((e) => e.hookPoint)
   }
 
   /**
@@ -298,14 +311,9 @@ const hooks = {
    */
   runTransform: <T>(point: string, value: T, context?: Record<string, unknown>) => {
     return hookSystem.executeTransform(`transform:${point}`, value, context)
-  }
+  },
 }
 
-export {
-  HookSystem,
-  HookPoints,
-  hookSystem,
-  hooks
-}
+export { HookSystem, HookPoints, hookSystem, hooks }
 
 export default { HookSystem, HookPoints, hookSystem, hooks }

package/core/plugin/index.ts

@@ -6,14 +6,17 @@
  * @version 1.0.0
  */
 
-import { HookSystem, HookPoints, hookSystem, hooks } from './hooks'
+import { HookPoints, HookSystem, hookSystem, hooks } from './hooks'
 import { PluginLoader, pluginLoader } from './loader'
 import { PluginRegistry, pluginRegistry } from './registry'
 
 /**
  * Initialize the complete plugin system
  */
-async function initializePlugins(projectPath: string, config: Record<string, unknown> = {}): Promise<void> {
+async function initializePlugins(
+  projectPath: string,
+  config: Record<string, unknown> = {}
+): Promise<void> {
   await pluginRegistry.initialize()
   await pluginLoader.initialize(projectPath, config)
 }
@@ -35,18 +38,15 @@ export {
   HookPoints,
   hookSystem,
   hooks,
-
   // Plugin loader
   PluginLoader,
   pluginLoader,
-
   // Plugin registry
   PluginRegistry,
   pluginRegistry,
-
   // Convenience functions
   initializePlugins,
-  shutdownPlugins
+  shutdownPlugins,
 }
 
 export default {
@@ -59,5 +59,5 @@ export default {
   PluginRegistry,
   pluginRegistry,
   initializePlugins,
-  shutdownPlugins
+  shutdownPlugins,
 }