prjct-cli 1.21.0 → 1.23.0

package/core/integrations/linear/sync.ts

@@ -1,314 +0,0 @@
-/**
- * Linear Sync Layer
- *
- * Bidirectional sync between Linear and local prjct storage.
- * Uses issues.json as local cache with 30-minute staleness.
- *
- * Architecture:
- *   Linear (source of truth)
- *          ↕
- *     Sync Layer (this file)
- *          ↕
- *   storage/issues.json ← FULL COPY of Linear issues
- *          ↕
- *   state.json.currentTask.linearId ← DIRECT LINK
- */
-
-import { mkdir, readFile, writeFile } from 'node:fs/promises'
-import { join } from 'node:path'
-import {
-  type CachedIssue,
-  createEmptyIssues,
-  type IssuesJson,
-  parseIssues,
-  type SyncResult,
-} from '../../schemas/issues'
-import { getProjectPath } from '../../schemas/schemas'
-import { getErrorMessage } from '../../types/fs'
-import { fileExists } from '../../utils/fs-helpers'
-import type { Issue } from '../issue-tracker/types'
-import { linearService } from './service'
-
-// Default staleness threshold: 30 minutes
-const DEFAULT_STALE_AFTER = 30 * 60 * 1000
-
-export class LinearSync {
-  /**
-   * Pull all assigned issues from Linear and store in issues.json
-   * This is the main sync operation - call on `p. sync`
-   */
-  async pullAll(projectId: string): Promise<SyncResult> {
-    const storagePath = join(getProjectPath(projectId), 'storage')
-    const issuesPath = join(storagePath, 'issues.json')
-
-    // Ensure storage directory exists
-    if (!(await fileExists(storagePath))) {
-      await mkdir(storagePath, { recursive: true })
-    }
-
-    const timestamp = new Date().toISOString()
-    const errors: Array<{ issueId: string; error: string }> = []
-
-    try {
-      // Fetch all assigned issues from Linear
-      const issues = await linearService.fetchAssignedIssues({ limit: 100 })
-
-      // Convert to cached format
-      const issuesMap: Record<string, CachedIssue> = {}
-      for (const issue of issues) {
-        try {
-          issuesMap[issue.externalId] = this.toCachedIssue(issue, timestamp)
-        } catch (err) {
-          errors.push({
-            issueId: issue.externalId || issue.id,
-            error: getErrorMessage(err),
-          })
-        }
-      }
-
-      // Write to issues.json
-      const issuesJson: IssuesJson = {
-        provider: 'linear',
-        lastSync: timestamp,
-        staleAfter: DEFAULT_STALE_AFTER,
-        issues: issuesMap,
-      }
-
-      await writeFile(issuesPath, JSON.stringify(issuesJson, null, 2))
-
-      return {
-        provider: 'linear',
-        fetched: issues.length,
-        updated: Object.keys(issuesMap).length,
-        errors,
-        timestamp,
-      }
-    } catch (err) {
-      errors.push({
-        issueId: 'all',
-        error: getErrorMessage(err),
-      })
-      return {
-        provider: 'linear',
-        fetched: 0,
-        updated: 0,
-        errors,
-        timestamp,
-      }
-    }
-  }
-
-  /**
-   * Get issue from local cache, fetch from API if not found or stale
-   * Local-first approach for performance
-   */
-  async getIssue(projectId: string, identifier: string): Promise<CachedIssue | null> {
-    const issuesJson = await this.loadIssues(projectId)
-
-    // Check local cache first
-    if (issuesJson?.issues[identifier]) {
-      const cachedIssue = issuesJson.issues[identifier]
-
-      // Check if cached issue is still fresh (within fetchedAt + some grace period)
-      const fetchedAt = new Date(cachedIssue.fetchedAt).getTime()
-      const now = Date.now()
-      const issueStaleness = 10 * 60 * 1000 // 10 minutes for individual issues
-
-      if (now - fetchedAt < issueStaleness) {
-        return cachedIssue
-      }
-    }
-
-    // Not in cache or stale - fetch from API and update cache
-    try {
-      const issue = await linearService.fetchIssue(identifier)
-      if (!issue) return null
-
-      const timestamp = new Date().toISOString()
-      const cachedIssue = this.toCachedIssue(issue, timestamp)
-
-      // Update cache with this single issue
-      await this.updateIssueInCache(projectId, identifier, cachedIssue)
-
-      return cachedIssue
-    } catch {
-      // API failed, return cached version if available (even if stale)
-      if (issuesJson?.issues[identifier]) {
-        return issuesJson.issues[identifier]
-      }
-      return null
-    }
-  }
-
-  /**
-   * Get issue from local cache ONLY (no API call)
-   * Use for fast lookups when you know the issue should be cached
-   */
-  async getIssueLocal(projectId: string, identifier: string): Promise<CachedIssue | null> {
-    const issuesJson = await this.loadIssues(projectId)
-    return issuesJson?.issues[identifier] || null
-  }
-
-  /**
-   * Push local status change to Linear
-   * Called when task status changes (in_progress, done)
-   */
-  async pushStatus(
-    projectId: string,
-    identifier: string,
-    status: 'in_progress' | 'done'
-  ): Promise<void> {
-    // Update Linear
-    if (status === 'in_progress') {
-      await linearService.markInProgress(identifier)
-    } else if (status === 'done') {
-      await linearService.markDone(identifier)
-    }
-
-    // Update local cache to reflect the change
-    const issuesJson = await this.loadIssues(projectId)
-    if (issuesJson?.issues[identifier]) {
-      const cachedStatus = status === 'done' ? 'done' : 'in_progress'
-      issuesJson.issues[identifier].status = cachedStatus
-      issuesJson.issues[identifier].fetchedAt = new Date().toISOString()
-
-      await this.saveIssues(projectId, issuesJson)
-    }
-  }
-
-  /**
-   * Check if the local issues cache is stale
-   * Staleness = lastSync is older than staleAfter threshold
-   */
-  async isStale(projectId: string): Promise<boolean> {
-    const issuesJson = await this.loadIssues(projectId)
-
-    if (!issuesJson || !issuesJson.lastSync) {
-      return true // No cache = stale
-    }
-
-    const lastSyncTime = new Date(issuesJson.lastSync).getTime()
-    const now = Date.now()
-    const staleAfter = issuesJson.staleAfter || DEFAULT_STALE_AFTER
-
-    return now - lastSyncTime > staleAfter
-  }
-
-  /**
-   * Get sync status for display
-   */
-  async getSyncStatus(projectId: string): Promise<{
-    hasCache: boolean
-    lastSync: string | null
-    issueCount: number
-    isStale: boolean
-  }> {
-    const issuesJson = await this.loadIssues(projectId)
-
-    if (!issuesJson) {
-      return {
-        hasCache: false,
-        lastSync: null,
-        issueCount: 0,
-        isStale: true,
-      }
-    }
-
-    return {
-      hasCache: true,
-      lastSync: issuesJson.lastSync || null,
-      issueCount: Object.keys(issuesJson.issues).length,
-      isStale: await this.isStale(projectId),
-    }
-  }
-
-  /**
-   * List all cached issues
-   */
-  async listCachedIssues(projectId: string): Promise<CachedIssue[]> {
-    const issuesJson = await this.loadIssues(projectId)
-    if (!issuesJson) return []
-
-    return Object.values(issuesJson.issues)
-  }
-
-  // =============================================================================
-  // Private Helpers
-  // =============================================================================
-
-  /**
-   * Load issues.json from disk
-   */
-  private async loadIssues(projectId: string): Promise<IssuesJson | null> {
-    const issuesPath = join(getProjectPath(projectId), 'storage', 'issues.json')
-
-    if (!(await fileExists(issuesPath))) {
-      return null
-    }
-
-    try {
-      const content = await readFile(issuesPath, 'utf-8')
-      return parseIssues(JSON.parse(content))
-    } catch {
-      return null
-    }
-  }
-
-  /**
-   * Save issues.json to disk
-   */
-  private async saveIssues(projectId: string, issuesJson: IssuesJson): Promise<void> {
-    const storagePath = join(getProjectPath(projectId), 'storage')
-    const issuesPath = join(storagePath, 'issues.json')
-
-    if (!(await fileExists(storagePath))) {
-      await mkdir(storagePath, { recursive: true })
-    }
-
-    await writeFile(issuesPath, JSON.stringify(issuesJson, null, 2))
-  }
-
-  /**
-   * Update a single issue in the cache
-   */
-  private async updateIssueInCache(
-    projectId: string,
-    identifier: string,
-    issue: CachedIssue
-  ): Promise<void> {
-    let issuesJson = await this.loadIssues(projectId)
-
-    if (!issuesJson) {
-      issuesJson = createEmptyIssues('linear')
-    }
-
-    issuesJson.issues[identifier] = issue
-    await this.saveIssues(projectId, issuesJson)
-  }
-
-  /**
-   * Convert API Issue to CachedIssue format
-   */
-  private toCachedIssue(issue: Issue, timestamp: string): CachedIssue {
-    return {
-      id: issue.id,
-      identifier: issue.externalId,
-      title: issue.title,
-      description: issue.description,
-      status: issue.status,
-      priority: issue.priority,
-      type: issue.type,
-      assignee: issue.assignee,
-      labels: issue.labels,
-      team: issue.team,
-      project: issue.project,
-      url: issue.url,
-      createdAt: issue.createdAt,
-      updatedAt: issue.updatedAt,
-      fetchedAt: timestamp,
-    }
-  }
-}
-
-// Singleton instance
-export const linearSync = new LinearSync()

package/core/outcomes/analyzer.ts

@@ -1,286 +0,0 @@
-/**
- * Outcome Analyzer
- *
- * Analyzes outcomes to extract patterns and insights.
- * Powers the learning loop for better estimates and agent selection.
- */
-
-import type { AgentMetrics, DetectedPattern, Outcome, OutcomeSummary } from '../types'
-import outcomeRecorder from './recorder'
-
-/**
- * OutcomeAnalyzer - Extracts insights from outcomes.
- */
-export class OutcomeAnalyzer {
-  /**
-   * Generate summary of all outcomes.
-   */
-  async summarize(projectId: string): Promise<OutcomeSummary> {
-    const outcomes = await outcomeRecorder.getAll(projectId)
-
-    if (outcomes.length === 0) {
-      return {
-        totalOutcomes: 0,
-        avgQualityScore: 0,
-        estimateAccuracy: 0,
-        topBlockers: [],
-        topAgents: [],
-        patternsDetected: [],
-      }
-    }
-
-    // Calculate average quality
-    const avgQuality = outcomes.reduce((sum, o) => sum + o.qualityScore, 0) / outcomes.length
-
-    // Calculate estimate accuracy
-    const estimateAccuracy = await outcomeRecorder.getEstimateAccuracy(projectId)
-
-    // Find top blockers
-    const blockerCounts = new Map<string, number>()
-    for (const outcome of outcomes) {
-      for (const blocker of outcome.blockers || []) {
-        blockerCounts.set(blocker, (blockerCounts.get(blocker) || 0) + 1)
-      }
-    }
-    const topBlockers = [...blockerCounts.entries()]
-      .sort((a, b) => b[1] - a[1])
-      .slice(0, 5)
-      .map(([blocker]) => blocker)
-
-    // Find top agents
-    const agentMetrics = await this.getAgentMetrics(projectId)
-    const topAgents = agentMetrics
-      .sort((a, b) => b.successRate - a.successRate)
-      .slice(0, 3)
-      .map((m) => m.agent)
-
-    // Detect patterns
-    const patterns = await this.detectPatterns(projectId)
-    const patternsDetected = patterns.map((p) => p.description)
-
-    return {
-      totalOutcomes: outcomes.length,
-      avgQualityScore: Math.round(avgQuality * 10) / 10,
-      estimateAccuracy,
-      topBlockers,
-      topAgents,
-      patternsDetected,
-    }
-  }
-
-  /**
-   * Get metrics for each agent.
-   */
-  async getAgentMetrics(projectId: string): Promise<AgentMetrics[]> {
-    const outcomes = await outcomeRecorder.getAll(projectId)
-
-    // Group by agent
-    const byAgent = new Map<string, Outcome[]>()
-    for (const outcome of outcomes) {
-      const agent = outcome.agentUsed || 'unknown'
-      if (!byAgent.has(agent)) {
-        byAgent.set(agent, [])
-      }
-      byAgent.get(agent)!.push(outcome)
-    }
-
-    const metrics: AgentMetrics[] = []
-
-    for (const [agent, agentOutcomes] of byAgent) {
-      const tasksCompleted = agentOutcomes.length
-      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
-
-      // Calculate estimate accuracy for this agent
-      const accurateEstimates = agentOutcomes.filter((o) => {
-        if (!o.variance) return false
-        const variance = this.parseVariance(o.variance)
-        const estimated = this.parseDuration(o.estimatedDuration)
-        if (estimated === 0) return false
-        return Math.abs(variance) / estimated <= 0.2
-      })
-      const estimateAccuracy = Math.round((accurateEstimates.length / tasksCompleted) * 100)
-
-      // Find best task types
-      const taskTypes = new Map<string, number>()
-      for (const o of agentOutcomes.filter((o) => o.completedAsPlanned)) {
-        for (const tag of o.tags || []) {
-          taskTypes.set(tag, (taskTypes.get(tag) || 0) + 1)
-        }
-      }
-      const bestFor = [...taskTypes.entries()]
-        .sort((a, b) => b[1] - a[1])
-        .slice(0, 3)
-        .map(([type]) => type)
-
-      metrics.push({
-        agent,
-        tasksCompleted,
-        successRate,
-        avgQualityScore: Math.round(avgQuality * 10) / 10,
-        estimateAccuracy,
-        bestFor,
-      })
-    }
-
-    return metrics
-  }
-
-  /**
-   * Detect patterns from outcomes.
-   */
-  async detectPatterns(projectId: string): Promise<DetectedPattern[]> {
-    const outcomes = await outcomeRecorder.getAll(projectId)
-    const patterns: DetectedPattern[] = []
-
-    if (outcomes.length < 3) {
-      return patterns // Need at least 3 outcomes to detect patterns
-    }
-
-    // Pattern: Consistent underestimation
-    const underestimated = outcomes.filter((o) => {
-      const variance = this.parseVariance(o.variance)
-      return variance > 0
-    })
-    if (underestimated.length / outcomes.length > 0.6) {
-      patterns.push({
-        description: 'Tasks consistently take longer than estimated',
-        confidence: underestimated.length / outcomes.length,
-        occurrences: underestimated.length,
-        suggestedAction: 'Add 30% buffer to estimates',
-      })
-    }
-
-    // Pattern: Consistent overestimation
-    const overestimated = outcomes.filter((o) => {
-      const variance = this.parseVariance(o.variance)
-      return variance < 0
-    })
-    if (overestimated.length / outcomes.length > 0.6) {
-      patterns.push({
-        description: 'Tasks consistently finish faster than estimated',
-        confidence: overestimated.length / outcomes.length,
-        occurrences: overestimated.length,
-        suggestedAction: 'Reduce estimates by 20%',
-      })
-    }
-
-    // Pattern: Common blockers
-    const blockerCounts = new Map<string, number>()
-    for (const outcome of outcomes) {
-      for (const blocker of outcome.blockers || []) {
-        blockerCounts.set(blocker, (blockerCounts.get(blocker) || 0) + 1)
-      }
-    }
-    for (const [blocker, count] of blockerCounts) {
-      if (count >= 3) {
-        patterns.push({
-          description: `Recurring blocker: ${blocker}`,
-          confidence: count / outcomes.length,
-          occurrences: count,
-          suggestedAction: `Address root cause of "${blocker}"`,
-        })
-      }
-    }
-
-    // Pattern: Agent performance
-    const agentMetrics = await this.getAgentMetrics(projectId)
-    for (const metrics of agentMetrics) {
-      if (metrics.tasksCompleted >= 5 && metrics.successRate > 90) {
-        patterns.push({
-          description: `${metrics.agent} has high success rate (${metrics.successRate}%)`,
-          confidence: 0.9,
-          occurrences: metrics.tasksCompleted,
-          suggestedAction: `Prefer ${metrics.agent} for similar tasks`,
-        })
-      }
-    }
-
-    return patterns.sort((a, b) => b.confidence - a.confidence)
-  }
-
-  /**
-   * Suggest estimate for a task type based on history.
-   */
-  async suggestEstimate(projectId: string, taskType: string): Promise<string | null> {
-    const outcomes = await outcomeRecorder.getAll(projectId)
-
-    // Filter by task type (using tags)
-    const relevant = outcomes.filter((o) => o.tags?.includes(taskType))
-
-    if (relevant.length < 2) {
-      return null // Not enough data
-    }
-
-    // Calculate average actual duration
-    const totalMinutes = relevant.reduce((sum, o) => {
-      return sum + this.parseDuration(o.actualDuration)
-    }, 0)
-
-    const avgMinutes = Math.round(totalMinutes / relevant.length)
-
-    // Format as duration string
-    if (avgMinutes >= 60) {
-      const hours = Math.floor(avgMinutes / 60)
-      const mins = avgMinutes % 60
-      return mins > 0 ? `${hours}h ${mins}m` : `${hours}h`
-    }
-    return `${avgMinutes}m`
-  }
-
-  /**
-   * Suggest best agent for a task type.
-   */
-  async suggestAgent(projectId: string, taskType: string): Promise<string | null> {
-    const agentMetrics = await this.getAgentMetrics(projectId)
-
-    // Find agents good at this task type
-    const suitable = agentMetrics.filter((m) => m.bestFor.includes(taskType))
-
-    if (suitable.length === 0) {
-      return null
-    }
-
-    // Return the one with highest success rate
-    return suitable.sort((a, b) => b.successRate - a.successRate)[0].agent
-  }
-
-  /**
-   * Parse variance string to minutes.
-   */
-  private parseVariance(variance: string): number {
-    const match = variance.match(/^([+-])(\d+)([mh])$/)
-    if (!match) return 0
-
-    const sign = match[1] === '-' ? -1 : 1
-    const value = parseInt(match[2], 10)
-    const unit = match[3]
-
-    return sign * (unit === 'h' ? value * 60 : value)
-  }
-
-  /**
-   * Parse duration string to minutes.
-   */
-  private parseDuration(duration: string): number {
-    let minutes = 0
-
-    const hourMatch = duration.match(/(\d+)h/)
-    if (hourMatch) {
-      minutes += parseInt(hourMatch[1], 10) * 60
-    }
-
-    const minMatch = duration.match(/(\d+)m/)
-    if (minMatch) {
-      minutes += parseInt(minMatch[1], 10)
-    }
-
-    return minutes
-  }
-}
-
-// Singleton instance
-const outcomeAnalyzer = new OutcomeAnalyzer()
-export default outcomeAnalyzer

package/core/outcomes/index.ts

@@ -1,34 +0,0 @@
-/**
- * Outcomes Module
- *
- * Records and analyzes execution outcomes for learning.
- *
- * @example
- * ```typescript
- * import { outcomeRecorder, outcomeAnalyzer } from './outcomes'
- *
- * // Record an outcome
- * await outcomeRecorder.record(projectId, {
- *   sessionId: 'session_123',
- *   command: '/p:now',
- *   task: 'implement auth',
- *   startedAt: '2025-12-09T14:00:00Z',
- *   completedAt: '2025-12-09T16:30:00Z',
- *   estimatedDuration: '2h',
- *   actualDuration: '2h 30m',
- *   variance: '+30m',
- *   completedAsPlanned: true,
- *   qualityScore: 4,
- *   agentUsed: 'backend-specialist',
- *   tags: ['auth', 'backend']
- * })
- *
- * // Analyze outcomes
- * const summary = await outcomeAnalyzer.summarize(projectId)
- * const patterns = await outcomeAnalyzer.detectPatterns(projectId)
- * ```
- */
-
-export * from '../types'
-export { default as outcomeAnalyzer, OutcomeAnalyzer } from './analyzer'
-export { default as outcomeRecorder, OutcomeRecorder } from './recorder'