prjct-cli 1.22.0 → 1.23.0

package/core/utils/agent-stream.ts

@@ -1,140 +0,0 @@
-/**
- * Agent Activity Stream
- *
- * Shows real-time agent activity during task execution.
- * Provides visibility into which agents are working and what they're doing.
- */
-
-import chalk from 'chalk'
-
-/**
- * Domain icons for visual identification
- */
-const DOMAIN_ICONS: Record<string, string> = {
-  database: '💾',
-  backend: '🔧',
-  frontend: '📦',
-  testing: '🧪',
-  devops: '🚀',
-  uxui: '🎨',
-  security: '🔒',
-  docs: '📝',
-  api: '🌐',
-  default: '⚡',
-}
-
-/**
- * Get icon for a domain
- */
-function getIcon(domain: string): string {
-  return DOMAIN_ICONS[domain.toLowerCase()] || DOMAIN_ICONS.default
-}
-
-/**
- * Agent Stream - Visual activity tracker
- */
-class AgentStream {
-  private currentAgent: string | null = null
-  private startTime: number = 0
-  private quiet: boolean = false
-
-  /**
-   * Set quiet mode (no output)
-   */
-  setQuiet(quiet: boolean): void {
-    this.quiet = quiet
-  }
-
-  /**
-   * Show orchestration start
-   */
-  orchestrate(domains: string[]): void {
-    if (this.quiet) return
-    console.log(chalk.cyan(`\n🎯 Orchestrating: ${domains.join(', ')} domains detected\n`))
-  }
-
-  /**
-   * Start an agent activity block
-   */
-  startAgent(name: string, domain: string, description?: string): void {
-    if (this.quiet) return
-
-    this.currentAgent = name
-    this.startTime = Date.now()
-
-    const icon = getIcon(domain)
-    console.log(chalk.cyan(`┌─ ${icon} ${name} (${domain})`))
-
-    if (description) {
-      console.log(chalk.dim(`│  ${description}`))
-    }
-  }
-
-  /**
-   * Show progress within current agent
-   */
-  progress(message: string): void {
-    if (this.quiet || !this.currentAgent) return
-    console.log(chalk.dim(`│  └── ${message}`))
-  }
-
-  /**
-   * Show multiple progress items
-   */
-  progressList(items: string[]): void {
-    if (this.quiet || !this.currentAgent) return
-    for (const item of items) {
-      console.log(chalk.dim(`│  └── ${item}`))
-    }
-  }
-
-  /**
-   * End current agent block
-   */
-  endAgent(success: boolean = true): void {
-    if (this.quiet || !this.currentAgent) return
-
-    const duration = Date.now() - this.startTime
-    const durationStr = this.formatDuration(duration)
-
-    const icon = success ? chalk.green('✓') : chalk.red('✗')
-    const status = success ? 'Complete' : 'Failed'
-
-    console.log(`└─ ${icon} ${status} ${chalk.dim(`(${durationStr})`)}\n`)
-    this.currentAgent = null
-  }
-
-  /**
-   * Show a simple status line (no block)
-   */
-  status(icon: string, message: string): void {
-    if (this.quiet) return
-    console.log(`${icon} ${message}`)
-  }
-
-  /**
-   * Show task completion summary
-   */
-  complete(taskName: string, totalDuration?: number): void {
-    if (this.quiet) return
-
-    const durationStr = totalDuration
-      ? ` ${chalk.dim(`[${this.formatDuration(totalDuration)}]`)}`
-      : ''
-    console.log(chalk.green(`✅ ${taskName}${durationStr}`))
-  }
-
-  /**
-   * Format duration in human-readable form
-   */
-  private formatDuration(ms: number): string {
-    if (ms < 1000) return `${ms}ms`
-    const seconds = (ms / 1000).toFixed(1)
-    return `${seconds}s`
-  }
-}
-
-// Singleton instance
-export const agentStream = new AgentStream()
-
-export default agentStream

package/core/utils/animations.ts

@@ -1,251 +0,0 @@
-/**
- * Simple animations with basic colors for better compatibility
- * Fallback when terminal doesn't support RGB colors
- */
-
-import chalk from 'chalk'
-
-type ChalkFunction = typeof chalk.green
-
-interface Colors {
-  success: ChalkFunction
-  error: ChalkFunction
-  warning: ChalkFunction
-  info: ChalkFunction
-  ship: ChalkFunction
-  celebrate: ChalkFunction
-  focus: ChalkFunction
-  idea: ChalkFunction
-  progress: ChalkFunction
-  task: ChalkFunction
-  primary: ChalkFunction
-  secondary: ChalkFunction
-  text: ChalkFunction
-  subtext: ChalkFunction
-  dim: ChalkFunction
-}
-
-interface Frames {
-  rocket: string[]
-  sparkles: string[]
-  loading: string[]
-  progress: string[]
-  celebration: string[]
-}
-
-interface Banners {
-  ship: string
-  success: string
-  error: string
-  welcome: string
-  cleanup: string
-  focus: string
-}
-
-interface RecapData {
-  currentTask?: string | null
-  shippedCount: number
-  queuedCount: number
-  ideasCount: number
-}
-
-export const colors: Colors = {
-  success: chalk.green,
-  error: chalk.red,
-  warning: chalk.yellow,
-  info: chalk.blue,
-  ship: chalk.cyan,
-  celebrate: chalk.magenta,
-  focus: chalk.green.bold,
-  idea: chalk.yellow,
-  progress: chalk.blue,
-  task: chalk.cyan,
-  primary: chalk.magenta,
-  secondary: chalk.cyan,
-  text: chalk.white,
-  subtext: chalk.gray,
-  dim: chalk.gray,
-}
-
-export const frames: Frames = {
-  rocket: [
-    '     🚀     ',
-    '    🚀      ',
-    '   🚀       ',
-    '  🚀        ',
-    ' 🚀         ',
-    '🚀          ',
-  ],
-  sparkles: [
-    '✨ ･ ｡ﾟ☆: *.☽ .* :☆ﾟ. ✨',
-    '･ ｡ﾟ☆: *.☽ .* :☆ﾟ. ✨ ･',
-    '｡ﾟ☆: *.☽ .* :☆ﾟ. ✨ ･ ｡ﾟ',
-    '☆: *.☽ .* :☆ﾟ. ✨ ･ ｡ﾟ☆:',
-  ],
-  loading: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'],
-  progress: [
-    '[          ]',
-    '[▓         ]',
-    '[▓▓        ]',
-    '[▓▓▓       ]',
-    '[▓▓▓▓      ]',
-    '[▓▓▓▓▓     ]',
-    '[▓▓▓▓▓▓    ]',
-    '[▓▓▓▓▓▓▓   ]',
-    '[▓▓▓▓▓▓▓▓  ]',
-    '[▓▓▓▓▓▓▓▓▓ ]',
-    '[▓▓▓▓▓▓▓▓▓▓]',
-  ],
-  celebration: ['🎉', '🎊', '✨', '🌟', '⭐', '💫', '🎆', '🎇'],
-}
-
-export const banners: Banners = {
-  ship: `
-╔════════════════════════════════════════════╗
-║  🚀 ${colors.ship.bold('S H I P P E D !')}  🚀            ║
-╚════════════════════════════════════════════╝`,
-
-  success: `
-✨ ${colors.success.bold('Success!')} ✨`,
-
-  error: `
-❌ ${colors.error.bold('Error')} ❌`,
-
-  welcome: `
-${colors.primary('╔══════════════════════════════════════════════════╗')}
-${colors.primary('║')}  ${colors.text.bold('🚀 prjct')}${colors.primary('/')}${colors.secondary.bold('cli')}                              ${colors.primary('║')}
-${colors.primary('║')}  ${colors.dim('Ship faster with zero friction')}              ${colors.primary('║')}
-${colors.primary('╚══════════════════════════════════════════════════╝')}`,
-
-  cleanup: `
-${colors.focus('🧹 ✨ Cleanup Magic ✨ 🧹')}`,
-
-  focus: `
-${colors.focus('━━━━━━━━━━━━━━━━━━━━━━━')}
-${colors.focus.bold('   🎯 FOCUS MODE 🎯   ')}
-${colors.focus('━━━━━━━━━━━━━━━━━━━━━━━')}`,
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
-export async function animate(frameList: string[], duration = 100): Promise<void> {
-  for (const frame of frameList) {
-    process.stdout.write(`\r${frame}`)
-    await sleep(duration)
-  }
-  process.stdout.write(`\r${' '.repeat(30)}\r`)
-}
-
-export async function typeWriter(text: string, delay = 30): Promise<void> {
-  for (let i = 0; i <= text.length; i++) {
-    process.stdout.write(`\r${text.slice(0, i)}${i < text.length ? '▋' : ''}`)
-    await sleep(delay)
-  }
-  process.stdout.write('\n')
-}
-
-export async function progressBar(duration = 1000, label = 'Processing'): Promise<void> {
-  const steps = 20
-  const stepDuration = duration / steps
-
-  for (let i = 0; i <= steps; i++) {
-    const percent = Math.round((i / steps) * 100)
-    const filled = '▓'.repeat(i)
-    const empty = '░'.repeat(steps - i)
-    const bar = `${colors.dim(label)} [${colors.primary(filled)}${colors.dim(empty)}] ${colors.text(`${percent}%`)}`
-    process.stdout.write(`\r${bar}`)
-    await sleep(stepDuration)
-  }
-  process.stdout.write('\n')
-}
-
-export async function sparkle(message: string): Promise<void> {
-  const sparkles = ['✨', '⭐', '💫', '🌟']
-  let output = ''
-
-  for (let i = 0; i < 3; i++) {
-    const spark = sparkles[Math.floor(Math.random() * sparkles.length)]
-    output = `${spark} ${message} ${spark}`
-    process.stdout.write(`\r${output}`)
-    await sleep(200)
-    process.stdout.write(`\r${' '.repeat(output.length)}`)
-    await sleep(100)
-  }
-
-  console.log(output)
-}
-
-export function formatShip(feature: string, count: number): string {
-  const banner = banners.ship
-  const stats = `
-${colors.text('Feature:')} ${colors.ship.bold(feature)}
-${colors.text('Total shipped:')} ${colors.success.bold(String(count))}
-${colors.text('Velocity:')} ${colors.celebrate('🔥 On fire!')}
-  `
-
-  return banner + stats
-}
-
-export function formatFocus(task: string, timestamp: string): string {
-  const banner = banners.focus
-  const info = `
-${colors.text('Current task:')} ${colors.focus.bold(task)}
-${colors.dim('Started:')} ${colors.subtext(timestamp)}
-  `
-
-  return banner + info
-}
-
-export function formatSuccess(message: string): string {
-  return `${colors.success('✅')} ${colors.text(message)}`
-}
-
-export function formatError(message: string): string {
-  return `${colors.error('❌')} ${colors.text(message)}`
-}
-
-export function formatIdea(idea: string): string {
-  return `
-${colors.idea('💡 Idea captured!')}
-${colors.text('―'.repeat(30))}
-${colors.subtext(idea)}
-${colors.text('―'.repeat(30))}
-${colors.dim('Added to your ideas backlog')}
-  `
-}
-
-export function formatCleanup(
-  filesRemoved: number,
-  tasksArchived: number,
-  spaceFeed: number
-): string {
-  return `
-${banners.cleanup}
-
-${colors.text('🗑️  Files removed:')} ${colors.success.bold(String(filesRemoved))}
-${colors.text('📦 Tasks archived:')} ${colors.success.bold(String(tasksArchived))}
-${colors.text('💾 Space freed:')} ${colors.success.bold(`${spaceFeed} MB`)}
-
-${colors.celebrate('✨ Your project is clean and lean!')}
-  `
-}
-
-export function formatRecap(data: RecapData): string {
-  const divider = colors.primary('━'.repeat(40))
-
-  return `
-${divider}
-${colors.primary.bold('📊 PROJECT RECAP')}
-${divider}
-
-${colors.text('🎯 Current focus:')} ${data.currentTask || colors.dim('No active task')}
-${colors.text('🚀 Shipped this week:')} ${colors.success.bold(String(data.shippedCount))}
-${colors.text('📝 Queued tasks:')} ${colors.info.bold(String(data.queuedCount))}
-${colors.text('💡 Ideas captured:')} ${colors.idea.bold(String(data.ideasCount))}
-
-${divider}
-${colors.dim('Keep shipping! 🚀')}
-  `
-}

package/core/utils/branding.ts

@@ -1,88 +0,0 @@
-/**
- * Branding Configuration for prjct-cli
- * Single source of truth for all branding across CLI and AI agents
- *
- * Supports multiple AI providers (Claude Code, Gemini CLI)
- */
-
-import chalk from 'chalk'
-import { getProviderBranding } from '../infrastructure/ai-provider'
-import type { AIProviderName } from '../types/provider'
-
-const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
-const SPINNER_SPEED = 80
-
-interface Branding {
-  name: string
-  icon: string
-  signature: string
-  spinner: {
-    frames: string[]
-    speed: number
-  }
-  cli: {
-    header: () => string
-    footer: () => string
-    spin: (frame: number, msg?: string) => string
-  }
-  template: {
-    header: string
-    footer: string
-  }
-  commitFooter: string
-  urls: {
-    website: string
-    docs: string
-  }
-  // Provider-aware methods
-  getCommitFooter: (provider?: AIProviderName) => string
-  getSignature: (provider?: AIProviderName) => string
-}
-
-const branding: Branding = {
-  // Core identity
-  name: 'prjct',
-  icon: '⚡',
-  signature: '⚡ prjct',
-
-  // Spinner config
-  spinner: {
-    frames: SPINNER_FRAMES,
-    speed: SPINNER_SPEED,
-  },
-
-  // CLI output (with chalk colors)
-  cli: {
-    header: () => `${chalk.cyan.bold('⚡')} ${chalk.cyan('prjct')}`,
-    footer: () => chalk.dim('⚡ prjct'),
-    spin: (frame: number, msg?: string) =>
-      `${chalk.cyan('⚡')} ${chalk.cyan('prjct')} ${chalk.cyan(SPINNER_FRAMES[frame % 10])} ${chalk.dim(msg || '')}`,
-  },
-
-  // Template (plain text)
-  template: {
-    header: '⚡ prjct',
-    footer: '⚡ prjct',
-  },
-
-  // Default Git commit footer (generic)
-  commitFooter: `Generated with [p/](https://www.prjct.app/)`,
-
-  // URLs
-  urls: {
-    website: 'https://prjct.app',
-    docs: 'https://prjct.app/docs',
-  },
-
-  // Provider-aware commit footer
-  getCommitFooter: (provider: AIProviderName = 'claude') => {
-    return getProviderBranding(provider).commitFooter
-  },
-
-  // Provider-aware signature
-  getSignature: (provider: AIProviderName = 'claude') => {
-    return getProviderBranding(provider).signature
-  },
-}
-
-export default branding

package/core/utils/cache.ts

@@ -1,187 +0,0 @@
-/**
- * Cache Utilities - Shared caching primitives for storage layers
- *
- * Provides two cache implementations:
- * - TTLCache: Time-based cache with LRU eviction (for StorageManager)
- * - LazyCache: Single-project lazy loading cache (for memory system)
- */
-
-import type { CacheEntry, CacheOptions, CacheStats } from '../types'
-
-/**
- * TTL Cache with LRU eviction
- *
- * Used by StorageManager for project-keyed caching.
- * Automatically evicts expired entries and oldest entries when over capacity.
- */
-export class TTLCache<T> {
-  private cache = new Map<string, CacheEntry<T>>()
-  private readonly ttl: number
-  private readonly maxSize: number
-
-  constructor(options: CacheOptions = {}) {
-    this.ttl = options.ttl ?? 5000
-    this.maxSize = options.maxSize ?? 50
-  }
-
-  /**
-   * Check if entry exists and is not expired
-   */
-  isValid(key: string): boolean {
-    const entry = this.cache.get(key)
-    if (!entry) return false
-    return Date.now() - entry.timestamp < this.ttl
-  }
-
-  /**
-   * Get entry if valid, otherwise null
-   */
-  get(key: string): T | null {
-    const entry = this.cache.get(key)
-
-    if (!entry) return null
-
-    if (!this.isValid(key)) {
-      this.cache.delete(key)
-      return null
-    }
-
-    return entry.data
-  }
-
-  /**
-   * Set entry with current timestamp
-   */
-  set(key: string, data: T): void {
-    this.cache.set(key, { data, timestamp: Date.now() })
-    this.evictOldEntries()
-  }
-
-  /**
-   * Delete entry
-   */
-  delete(key: string): void {
-    this.cache.delete(key)
-  }
-
-  /**
-   * Clear all entries
-   */
-  clear(): void {
-    this.cache.clear()
-  }
-
-  /**
-   * Check if key exists (may be expired)
-   */
-  has(key: string): boolean {
-    return this.cache.has(key)
-  }
-
-  /**
-   * Get number of entries (including expired)
-   */
-  get size(): number {
-    return this.cache.size
-  }
-
-  /**
-   * Evict oldest entries if over max size
-   */
-  private evictOldEntries(): void {
-    if (this.cache.size <= this.maxSize) return
-
-    const entries = Array.from(this.cache.entries()).sort((a, b) => a[1].timestamp - b[1].timestamp)
-
-    const toRemove = entries.slice(0, this.cache.size - this.maxSize)
-    for (const [key] of toRemove) {
-      this.cache.delete(key)
-    }
-  }
-
-  /**
-   * Get cache statistics
-   */
-  stats(): CacheStats {
-    return {
-      size: this.cache.size,
-      maxSize: this.maxSize,
-      ttl: this.ttl,
-    }
-  }
-
-  /**
-   * Remove all expired entries
-   */
-  prune(): number {
-    let removed = 0
-    for (const key of this.cache.keys()) {
-      if (!this.isValid(key)) {
-        this.cache.delete(key)
-        removed++
-      }
-    }
-    return removed
-  }
-}
-
-/**
- * Single-project lazy cache
- *
- * Used by CachedStore for memory system (one project at a time).
- * Simpler than TTLCache - just tracks if data is loaded for current project.
- */
-export class LazyCache<T> {
-  private data: T | null = null
-  private loaded = false
-  private projectId: string | null = null
-
-  /**
-   * Check if loaded for a specific project
-   */
-  isLoaded(projectId?: string): boolean {
-    if (projectId) {
-      return this.loaded && this.projectId === projectId
-    }
-    return this.loaded
-  }
-
-  /**
-   * Get cached data (may be null if not loaded)
-   */
-  get(): T | null {
-    return this.data
-  }
-
-  /**
-   * Set data for a project
-   */
-  set(projectId: string, data: T): void {
-    this.data = data
-    this.loaded = true
-    this.projectId = projectId
-  }
-
-  /**
-   * Reset cache
-   */
-  reset(): void {
-    this.data = null
-    this.loaded = false
-    this.projectId = null
-  }
-
-  /**
-   * Get current project ID
-   */
-  getProjectId(): string | null {
-    return this.projectId
-  }
-
-  /**
-   * Check if cache is empty
-   */
-  isEmpty(): boolean {
-    return !this.loaded || this.data === null
-  }
-}

package/core/utils/citations.ts

@@ -1,39 +0,0 @@
-/**
- * Citation utilities for context source tracking
- *
- * Generates HTML comments indicating where each section's data came from.
- * Source types: detected (from files), user-defined (from config), inferred (from heuristics)
- *
- * @see PRJ-113
- */
-
-import type { ContextSources, SourceInfo } from '../types/citations'
-
-export type { ContextSources, SourceInfo, SourceType } from '../types/citations'
-
-/**
- * Generate an HTML citation comment
- *
- * @example cite({ file: 'package.json', type: 'detected' })
- * // => '<!-- source: package.json, detected -->'
- */
-export function cite(source: SourceInfo): string {
-  return `<!-- source: ${source.file}, ${source.type} -->`
-}
-
-/**
- * Create default sources (all unknown) - used as fallback
- */
-export function defaultSources(): ContextSources {
-  const unknown: SourceInfo = { file: 'unknown', type: 'detected' }
-  return {
-    name: { ...unknown },
-    version: { ...unknown },
-    ecosystem: { ...unknown },
-    languages: { ...unknown },
-    frameworks: { ...unknown },
-    commands: { ...unknown },
-    projectType: { ...unknown },
-    git: { file: 'git', type: 'detected' },
-  }
-}