prjct-cli 1.22.0 → 1.24.0

package/core/utils/project-commands.ts

@@ -1,126 +0,0 @@
-import path from 'node:path'
-import type { DetectedProjectCommands } from '../types'
-import * as fileHelper from './file-helper'
-
-type PackageManager = 'npm' | 'pnpm' | 'yarn' | 'bun'
-
-interface PackageJson {
-  scripts?: Record<string, string>
-  packageManager?: string
-}
-
-/**
- * Detect the most likely JS package manager for a project.
- *
- * Reason: installed users may not have Bun, and many projects use pnpm/yarn.
- */
-async function detectPackageManager(
-  projectPath: string,
-  pkg: PackageJson | null
-): Promise<PackageManager> {
-  const declared = pkg?.packageManager?.trim().toLowerCase()
-  if (declared?.startsWith('pnpm@')) return 'pnpm'
-  if (declared?.startsWith('yarn@')) return 'yarn'
-  if (declared?.startsWith('bun@')) return 'bun'
-  if (declared?.startsWith('npm@')) return 'npm'
-
-  // Lockfile heuristics
-  if (await fileHelper.fileExists(path.join(projectPath, 'pnpm-lock.yaml'))) return 'pnpm'
-  if (await fileHelper.fileExists(path.join(projectPath, 'yarn.lock'))) return 'yarn'
-  if (await fileHelper.fileExists(path.join(projectPath, 'bun.lockb'))) return 'bun'
-  if (await fileHelper.fileExists(path.join(projectPath, 'bun.lock'))) return 'bun'
-  if (await fileHelper.fileExists(path.join(projectPath, 'package-lock.json'))) return 'npm'
-
-  return 'npm'
-}
-
-function pmRun(pm: PackageManager, scriptName: string): string {
-  if (pm === 'yarn') return `yarn ${scriptName}`
-  if (pm === 'pnpm') return `pnpm run ${scriptName}`
-  if (pm === 'bun') return `bun run ${scriptName}`
-  return `npm run ${scriptName}`
-}
-
-function pmTest(pm: PackageManager): string {
-  if (pm === 'yarn') return 'yarn test'
-  if (pm === 'pnpm') return 'pnpm test'
-  if (pm === 'bun') return 'bun test'
-  return 'npm test'
-}
-
-/**
- * Detect the appropriate lint/typecheck/test commands for a given project.
- *
- * - JS/TS projects: uses the project package manager + scripts when present
- * - Python: prefers pytest when config is present
- * - Go/Rust/.NET/Java: uses conventional defaults
- *
- * @param {string} projectPath - Repository root.
- * @returns {Promise<DetectedProjectCommands>} detected commands (missing when not applicable).
- */
-export async function detectProjectCommands(projectPath: string): Promise<DetectedProjectCommands> {
-  const pkgPath = path.join(projectPath, 'package.json')
-  const pkg = await fileHelper.readJson<PackageJson | null>(pkgPath, null)
-
-  // JS/TS (prefer explicit scripts)
-  if (pkg) {
-    const pm = await detectPackageManager(projectPath, pkg)
-    const scripts = pkg.scripts || {}
-
-    const result: DetectedProjectCommands = { stack: 'js', packageManager: pm }
-
-    if (scripts.lint) {
-      result.lint = { tool: pm, command: pmRun(pm, 'lint') }
-    }
-
-    if (scripts.typecheck) {
-      result.typecheck = { tool: pm, command: pmRun(pm, 'typecheck') }
-    }
-
-    if (scripts.test) {
-      result.test = { tool: pm, command: pmTest(pm) }
-    }
-
-    return result
-  }
-
-  // Python
-  if (await fileHelper.fileExists(path.join(projectPath, 'pytest.ini'))) {
-    return { stack: 'python', test: { tool: 'pytest', command: 'pytest' } }
-  }
-
-  const pyproject = await fileHelper.readFile(path.join(projectPath, 'pyproject.toml'), '')
-  if (pyproject.includes('[tool.pytest') || pyproject.includes('pytest')) {
-    return { stack: 'python', test: { tool: 'pytest', command: 'pytest' } }
-  }
-
-  // Rust
-  if (await fileHelper.fileExists(path.join(projectPath, 'Cargo.toml'))) {
-    return { stack: 'rust', test: { tool: 'cargo', command: 'cargo test' } }
-  }
-
-  // Go
-  if (await fileHelper.fileExists(path.join(projectPath, 'go.mod'))) {
-    return { stack: 'go', test: { tool: 'go', command: 'go test ./...' } }
-  }
-
-  // .NET
-  const files = await fileHelper.listFiles(projectPath)
-  if (files.some((f) => f.endsWith('.sln') || f.endsWith('.csproj') || f.endsWith('.fsproj'))) {
-    return { stack: 'dotnet', test: { tool: 'dotnet', command: 'dotnet test' } }
-  }
-
-  // Java
-  if (await fileHelper.fileExists(path.join(projectPath, 'pom.xml'))) {
-    return { stack: 'java', test: { tool: 'maven', command: 'mvn test' } }
-  }
-  if (
-    (await fileHelper.fileExists(path.join(projectPath, 'gradlew'))) &&
-    ((await fileHelper.fileExists(path.join(projectPath, 'build.gradle'))) ||
-      (await fileHelper.fileExists(path.join(projectPath, 'build.gradle.kts'))))
-  ) {
-    return { stack: 'java', test: { tool: 'gradle', command: './gradlew test' } }
-  }
-
-  return { stack: 'unknown' }
-}

package/core/utils/project-credentials.ts

@@ -1,143 +0,0 @@
-/**
- * Per-project credential storage
- *
- * Stores credentials in: ~/.prjct-cli/projects/{projectId}/config/credentials.json
- *
- * Fallback chain for Linear API key:
- * 1. Project credentials (per-project)
- * 2. Global keychain (macOS)
- * 3. Environment variables
- *
- * This allows different projects to use different Linear workspaces.
- */
-
-import fs from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import { getErrorMessage } from '../types/fs'
-import { fileExists } from './fs-helpers'
-import { type CredentialKey, getCredential } from './keychain'
-
-interface LinearCredentials {
-  apiKey: string
-  teamId?: string
-  teamKey?: string
-  setupAt: string
-}
-
-export interface ProjectCredentials {
-  linear?: LinearCredentials
-}
-
-/**
- * Get path to project credentials file
- */
-function getCredentialsPath(projectId: string): string {
-  return path.join(os.homedir(), '.prjct-cli', 'projects', projectId, 'config', 'credentials.json')
-}
-
-/**
- * Get all credentials for a project
- */
-export async function getProjectCredentials(projectId: string): Promise<ProjectCredentials> {
-  const credPath = getCredentialsPath(projectId)
-  if (!(await fileExists(credPath))) {
-    return {}
-  }
-
-  try {
-    return JSON.parse(await fs.readFile(credPath, 'utf-8'))
-  } catch (error) {
-    console.error('[project-credentials] Failed to read credentials:', getErrorMessage(error))
-    return {}
-  }
-}
-
-/**
- * Set Linear credentials for a project
- */
-export async function setLinearCredentials(
-  projectId: string,
-  credentials: LinearCredentials
-): Promise<void> {
-  const credPath = getCredentialsPath(projectId)
-  const dir = path.dirname(credPath)
-
-  // Ensure directory exists
-  if (!(await fileExists(dir))) {
-    await fs.mkdir(dir, { recursive: true })
-  }
-
-  // Read existing, merge, write
-  const current = await getProjectCredentials(projectId)
-  current.linear = credentials
-  await fs.writeFile(credPath, JSON.stringify(current, null, 2))
-}
-
-/**
- * Delete Linear credentials for a project
- */
-export async function deleteLinearCredentials(projectId: string): Promise<void> {
-  const current = await getProjectCredentials(projectId)
-
-  if (current.linear) {
-    delete current.linear
-    const credPath = getCredentialsPath(projectId)
-    await fs.writeFile(credPath, JSON.stringify(current, null, 2))
-  }
-}
-
-/**
- * Get Linear API key with fallback chain:
- * 1. Project credentials
- * 2. Global keychain
- * 3. Environment variable
- */
-export async function getLinearApiKey(projectId: string): Promise<string | null> {
-  // 1. Project credentials
-  const projectCreds = await getProjectCredentials(projectId)
-  if (projectCreds.linear?.apiKey) {
-    return projectCreds.linear.apiKey
-  }
-
-  // 2. Global keychain (falls back to env var internally)
-  return getCredential('linear-api-key' as CredentialKey)
-}
-
-/**
- * Get Linear team ID from project credentials
- */
-export async function getLinearTeamId(projectId: string): Promise<string | undefined> {
-  const projectCreds = await getProjectCredentials(projectId)
-  return projectCreds.linear?.teamId
-}
-
-/**
- * Check if Linear is configured for a project
- */
-export async function isLinearConfigured(projectId: string): Promise<boolean> {
-  const apiKey = await getLinearApiKey(projectId)
-  return apiKey !== null && apiKey.length > 0
-}
-
-/**
- * Get credential source for debugging
- */
-export async function getCredentialSource(
-  projectId: string
-): Promise<'project' | 'keychain' | 'env' | 'none'> {
-  // Check project credentials
-  const projectCreds = await getProjectCredentials(projectId)
-  if (projectCreds.linear?.apiKey) {
-    return 'project'
-  }
-
-  // Check keychain/env
-  const { getCredentialWithSource } = await import('./keychain')
-  const result = await getCredentialWithSource('linear-api-key' as CredentialKey)
-  if (result.value) {
-    return result.source === 'keychain' ? 'keychain' : 'env'
-  }
-
-  return 'none'
-}

package/core/utils/provider-cache.ts

@@ -1,49 +0,0 @@
-import fs from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import type { ProviderDetectionResult } from '../types/provider'
-
-const CACHE_DIR = path.join(os.homedir(), '.prjct-cli', 'cache')
-const CACHE_FILE = path.join(CACHE_DIR, 'providers.json')
-const TTL_MS = 10 * 60 * 1000 // 10 minutes
-
-interface ProviderCache {
-  timestamp: string
-  detection: {
-    claude: ProviderDetectionResult
-    gemini: ProviderDetectionResult
-  }
-}
-
-export async function readProviderCache(): Promise<ProviderCache['detection'] | null> {
-  try {
-    const raw = await fs.readFile(CACHE_FILE, 'utf-8')
-    const cache: ProviderCache = JSON.parse(raw)
-
-    if (!cache.timestamp || !cache.detection) return null
-
-    const age = Date.now() - new Date(cache.timestamp).getTime()
-    if (age > TTL_MS) return null
-
-    return cache.detection
-  } catch {
-    return null
-  }
-}
-
-export async function writeProviderCache(detection: ProviderCache['detection']): Promise<void> {
-  const cache: ProviderCache = {
-    timestamp: new Date().toISOString(),
-    detection,
-  }
-  await fs.mkdir(CACHE_DIR, { recursive: true })
-  await fs.writeFile(CACHE_FILE, JSON.stringify(cache, null, 2))
-}
-
-export async function invalidateProviderCache(): Promise<void> {
-  try {
-    await fs.unlink(CACHE_FILE)
-  } catch {
-    // File doesn't exist — fine
-  }
-}

package/core/utils/retry.ts

@@ -1,318 +0,0 @@
-/**
- * Retry Policy Utility
- *
- * Provides exponential backoff retry logic with error classification and circuit breaker.
- * Used to make agent and tool operations resilient against transient failures.
- *
- * @module utils/retry
- * @version 1.0.0
- */
-
-// =============================================================================
-// Types
-// =============================================================================
-
-export interface RetryOptions {
-  /** Maximum number of retry attempts (default: 3) */
-  maxAttempts: number
-
-  /** Base delay in milliseconds for exponential backoff (default: 1000) */
-  baseDelayMs: number
-
-  /** Maximum delay in milliseconds (default: 8000) */
-  maxDelayMs: number
-
-  /** Number of consecutive failures before opening circuit (default: 5) */
-  circuitBreakerThreshold?: number
-
-  /** Time in milliseconds to keep circuit open (default: 60000) */
-  circuitBreakerTimeoutMs?: number
-}
-
-export interface CircuitState {
-  consecutiveFailures: number
-  openedAt: number | null
-}
-
-// =============================================================================
-// Error Classification
-// =============================================================================
-
-/**
- * Node.js error codes that indicate transient failures worth retrying
- */
-const TRANSIENT_ERROR_CODES = new Set([
-  'EBUSY', // Resource busy
-  'EAGAIN', // Resource temporarily unavailable
-  'ETIMEDOUT', // Operation timed out
-  'ECONNRESET', // Connection reset by peer
-  'ECONNREFUSED', // Connection refused (may be temporary)
-  'ENOTFOUND', // DNS lookup failed (may be temporary)
-  'EAI_AGAIN', // DNS temporary failure
-])
-
-/**
- * Node.js error codes that indicate permanent failures (fail fast)
- */
-const PERMANENT_ERROR_CODES = new Set([
-  'ENOENT', // No such file or directory
-  'EACCES', // Permission denied
-  'EPERM', // Operation not permitted
-  'EISDIR', // Is a directory
-  'ENOTDIR', // Not a directory
-  'EINVAL', // Invalid argument
-])
-
-/**
- * Check if an error is transient (worth retrying)
- */
-export function isTransientError(error: unknown): boolean {
-  if (!error || typeof error !== 'object') {
-    return false
-  }
-
-  const err = error as { code?: string; errno?: number; message?: string }
-
-  // Check error code
-  if (err.code && TRANSIENT_ERROR_CODES.has(err.code)) {
-    return true
-  }
-
-  // Permanent errors should never be retried
-  if (err.code && PERMANENT_ERROR_CODES.has(err.code)) {
-    return false
-  }
-
-  // Check message for timeout indicators
-  if (err.message) {
-    const msg = err.message.toLowerCase()
-    if (msg.includes('timeout') || msg.includes('timed out')) {
-      return true
-    }
-  }
-
-  // Unknown errors are not retried by default (fail fast)
-  return false
-}
-
-/**
- * Check if an error is permanent (should not retry)
- */
-export function isPermanentError(error: unknown): boolean {
-  if (!error || typeof error !== 'object') {
-    return false
-  }
-
-  const err = error as { code?: string }
-  return !!(err.code && PERMANENT_ERROR_CODES.has(err.code))
-}
-
-// =============================================================================
-// Circuit Breaker
-// =============================================================================
-
-/**
- * Circuit breaker state registry (per operation ID)
- */
-const circuitStates = new Map<string, CircuitState>()
-
-/**
- * Check if circuit is open for a given operation
- */
-function isCircuitOpen(operationId: string, threshold: number, timeoutMs: number): boolean {
-  const state = circuitStates.get(operationId)
-  if (!state) {
-    return false
-  }
-
-  // Circuit is open if threshold exceeded
-  if (state.consecutiveFailures >= threshold && state.openedAt) {
-    const elapsed = Date.now() - state.openedAt
-    // Circuit closes after timeout
-    if (elapsed >= timeoutMs) {
-      // Reset circuit
-      circuitStates.delete(operationId)
-      return false
-    }
-    return true
-  }
-
-  return false
-}
-
-/**
- * Record a failure for circuit breaker
- */
-function recordFailure(operationId: string, threshold: number): void {
-  const state = circuitStates.get(operationId) || {
-    consecutiveFailures: 0,
-    openedAt: null,
-  }
-
-  state.consecutiveFailures++
-
-  // Open circuit if threshold reached
-  if (state.consecutiveFailures >= threshold && !state.openedAt) {
-    state.openedAt = Date.now()
-  }
-
-  circuitStates.set(operationId, state)
-}
-
-/**
- * Record a success (reset circuit breaker)
- */
-function recordSuccess(operationId: string): void {
-  circuitStates.delete(operationId)
-}
-
-// =============================================================================
-// Retry Policy
-// =============================================================================
-
-export class RetryPolicy {
-  private options: Required<RetryOptions>
-
-  constructor(options: Partial<RetryOptions> = {}) {
-    this.options = {
-      maxAttempts: options.maxAttempts ?? 3,
-      baseDelayMs: options.baseDelayMs ?? 1000,
-      maxDelayMs: options.maxDelayMs ?? 8000,
-      circuitBreakerThreshold: options.circuitBreakerThreshold ?? 5,
-      circuitBreakerTimeoutMs: options.circuitBreakerTimeoutMs ?? 60000,
-    }
-  }
-
-  /**
-   * Execute an operation with retry logic
-   *
-   * @param operation - Async function to execute
-   * @param operationId - Optional ID for circuit breaker tracking
-   * @returns Result of the operation
-   * @throws Error if all attempts fail or circuit is open
-   */
-  async execute<T>(operation: () => Promise<T>, operationId: string = 'default'): Promise<T> {
-    // Check circuit breaker
-    if (
-      isCircuitOpen(
-        operationId,
-        this.options.circuitBreakerThreshold,
-        this.options.circuitBreakerTimeoutMs
-      )
-    ) {
-      throw new Error(
-        `Circuit breaker is open for operation: ${operationId}. Too many consecutive failures.`
-      )
-    }
-
-    let lastError: unknown
-    let attempt = 0
-
-    while (attempt < this.options.maxAttempts) {
-      try {
-        const result = await operation()
-        // Success - reset circuit breaker
-        recordSuccess(operationId)
-        return result
-      } catch (error) {
-        lastError = error
-        attempt++
-
-        // Check if error is permanent (fail fast)
-        if (isPermanentError(error)) {
-          recordFailure(operationId, this.options.circuitBreakerThreshold)
-          throw error
-        }
-
-        // Check if error is transient and we have attempts left
-        const shouldRetry = isTransientError(error) && attempt < this.options.maxAttempts
-
-        if (!shouldRetry) {
-          // Not transient or out of attempts
-          recordFailure(operationId, this.options.circuitBreakerThreshold)
-          throw error
-        }
-
-        // Calculate delay with exponential backoff
-        const delay = Math.min(
-          this.options.baseDelayMs * 2 ** (attempt - 1),
-          this.options.maxDelayMs
-        )
-
-        // Wait before retry
-        await new Promise((resolve) => setTimeout(resolve, delay))
-      }
-    }
-
-    // All attempts failed
-    recordFailure(operationId, this.options.circuitBreakerThreshold)
-    throw lastError
-  }
-
-  /**
-   * Check if an error is transient (exposed for testing)
-   */
-  isTransientError(error: unknown): boolean {
-    return isTransientError(error)
-  }
-
-  /**
-   * Check if circuit is open for an operation (exposed for testing)
-   */
-  isCircuitOpen(operationId: string): boolean {
-    return isCircuitOpen(
-      operationId,
-      this.options.circuitBreakerThreshold,
-      this.options.circuitBreakerTimeoutMs
-    )
-  }
-
-  /**
-   * Get current circuit state for an operation (exposed for testing)
-   */
-  getCircuitState(operationId: string): CircuitState | undefined {
-    return circuitStates.get(operationId)
-  }
-
-  /**
-   * Reset circuit breaker for an operation (exposed for testing)
-   */
-  resetCircuit(operationId: string): void {
-    circuitStates.delete(operationId)
-  }
-
-  /**
-   * Reset all circuit breakers (exposed for testing)
-   */
-  resetAllCircuits(): void {
-    circuitStates.clear()
-  }
-}
-
-// =============================================================================
-// Exports
-// =============================================================================
-
-/**
- * Default retry policy for agent operations
- * - 3 attempts
- * - 1s base delay
- * - Up to 8s max delay
- */
-export const defaultAgentRetryPolicy = new RetryPolicy({
-  maxAttempts: 3,
-  baseDelayMs: 1000,
-  maxDelayMs: 8000,
-})
-
-/**
- * Retry policy for tool operations (less aggressive)
- * - 2 attempts
- * - 500ms base delay
- * - Up to 2s max delay
- */
-export const defaultToolRetryPolicy = new RetryPolicy({
-  maxAttempts: 2,
-  baseDelayMs: 500,
-  maxDelayMs: 2000,
-})