prjct-cli 1.22.0 → 1.23.0

package/core/utils/output.ts

@@ -1,403 +0,0 @@
-/**
- * Unified Output System for prjct-cli
- * Spinner while working → Single line result
- * With prjct branding
- *
- * Supports --quiet mode for CI/CD and scripting
- * Supports output tiers: silent, minimal, compact, verbose
- *
- * @see PRJ-105, PRJ-130
- */
-
-import chalk from 'chalk'
-import { OUTPUT_LIMITS } from '../constants'
-import type { ErrorCode, ErrorWithHint } from '../types/errors'
-import type { Output, OutputMetrics, OutputTier, TierConfig } from '../types/output'
-import branding from './branding'
-import { getError } from './error-messages'
-
-const _FRAMES = branding.spinner.frames
-const SPEED = branding.spinner.speed
-
-export type { Output, OutputMetrics, OutputTier, TierConfig } from '../types/output'
-
-export const OUTPUT_TIERS: Record<OutputTier, TierConfig> = {
-  silent: { maxLines: 0, maxCharsPerLine: 0, showMetrics: false },
-  minimal: { maxLines: 1, maxCharsPerLine: 65, showMetrics: false },
-  compact: { maxLines: 4, maxCharsPerLine: 80, showMetrics: true },
-  verbose: { maxLines: Infinity, maxCharsPerLine: Infinity, showMetrics: true },
-} as const
-
-// Current output tier (default: compact for human-readable output)
-let currentTier: OutputTier = 'compact'
-
-/**
- * Set the output tier
- */
-export function setOutputTier(tier: OutputTier): void {
-  currentTier = tier
-}
-
-/**
- * Get current output tier
- */
-export function getOutputTier(): OutputTier {
-  return currentTier
-}
-
-/**
- * Get current tier config
- */
-export function getTierConfig(): TierConfig {
-  return OUTPUT_TIERS[currentTier]
-}
-
-/**
- * Centralized icons for consistent output
- */
-export const ICONS = {
-  success: chalk.green('✓'),
-  fail: chalk.red('✗'),
-  warn: chalk.yellow('⚠'),
-  info: chalk.blue('ℹ'),
-  debug: chalk.dim('🔧'),
-  bullet: chalk.dim('•'),
-  arrow: chalk.dim('→'),
-  check: chalk.green('✓'),
-  cross: chalk.red('✗'),
-  spinner: chalk.cyan('◐'),
-} as const
-
-let interval: ReturnType<typeof setInterval> | null = null
-let frame = 0
-
-// Quiet mode - suppress all stdout except errors
-let quietMode = false
-
-/**
- * Enable quiet mode (no stdout, only stderr for errors)
- */
-export function setQuietMode(enabled: boolean): void {
-  quietMode = enabled
-}
-
-/**
- * Check if quiet mode is enabled
- */
-export function isQuietMode(): boolean {
-  return quietMode
-}
-
-/**
- * Truncate string to max chars (uses tier config if no max specified)
- */
-const truncate = (s: string | undefined | null, max?: number): string => {
-  const limit = max ?? (getTierConfig().maxCharsPerLine || OUTPUT_LIMITS.FALLBACK_TRUNCATE)
-  return s && s.length > limit ? `${s.slice(0, limit - 1)}…` : s || ''
-}
-
-/**
- * Limit output to maxLines (respects tier config)
- * Returns truncated content with "...N more lines" indicator
- */
-/**
- * Limit output to maxLines (respects tier config)
- * Returns truncated content with "...N more lines" indicator
- */
-export function limitLines(content: string, maxLines?: number): string {
-  const limit = maxLines ?? getTierConfig().maxLines
-  if (limit === Infinity || limit === 0) return content
-
-  const lines = content.split('\n')
-  if (lines.length <= limit) return content
-
-  const shown = lines.slice(0, limit)
-  const remaining = lines.length - limit
-  return `${shown.join('\n')}\n${chalk.dim(`...${remaining} more lines`)}`
-}
-
-/**
- * Format data for human-readable output (respects tier)
- * Use this instead of JSON.stringify for CLI output
- */
-export function formatForHuman(data: unknown): string {
-  const tier = getTierConfig()
-
-  if (currentTier === 'silent') return ''
-  if (currentTier === 'verbose') return JSON.stringify(data, null, 2)
-
-  // For minimal/compact: extract key info
-  if (typeof data !== 'object' || data === null) {
-    return truncate(String(data), tier.maxCharsPerLine)
-  }
-
-  const obj = data as Record<string, unknown>
-
-  // Linear issue format
-  if ('identifier' in obj && 'title' in obj) {
-    const lines: string[] = []
-    lines.push(`${obj.identifier}: ${truncate(String(obj.title), tier.maxCharsPerLine - 10)}`)
-    if (obj.status) lines.push(`Status: ${obj.status}`)
-    if (obj.priority && obj.priority !== 'none') lines.push(`Priority: ${obj.priority}`)
-    if (obj.url && currentTier === 'compact') lines.push(chalk.dim(String(obj.url)))
-    return limitLines(lines.join('\n'), tier.maxLines)
-  }
-
-  // Issue list format
-  if ('issues' in obj && Array.isArray(obj.issues)) {
-    const issues = obj.issues as Array<Record<string, unknown>>
-    const lines = issues.slice(0, tier.maxLines).map((i) => {
-      const priority = i.priority && i.priority !== 'none' ? ` [${i.priority}]` : ''
-      return `${i.identifier}  ${truncate(String(i.title), OUTPUT_LIMITS.ISSUE_TITLE)}${priority}`
-    })
-    if (issues.length > tier.maxLines) {
-      lines.push(chalk.dim(`...${issues.length - tier.maxLines} more`))
-    }
-    return lines.join('\n')
-  }
-
-  // Generic object: show key fields only
-  const keyFields = ['id', 'name', 'title', 'status', 'message', 'success', 'error']
-  const relevant = keyFields.filter((k) => k in obj)
-  if (relevant.length > 0) {
-    return limitLines(
-      relevant
-        .map((k) => `${k}: ${truncate(String(obj[k]), tier.maxCharsPerLine - k.length - 2)}`)
-        .join('\n'),
-      tier.maxLines
-    )
-  }
-
-  // Fallback: compact JSON
-  return limitLines(JSON.stringify(data, null, 2), tier.maxLines)
-}
-
-const clear = (): boolean =>
-  process.stdout.isTTY ? process.stdout.write(`\r${' '.repeat(OUTPUT_LIMITS.CLEAR_WIDTH)}\r`) : true
-
-const out: Output = {
-  // Branding: Show header at start
-  start() {
-    if (!quietMode) console.log(branding.cli.header())
-    return this
-  },
-
-  // Branding: Show footer at end
-  end() {
-    if (!quietMode) console.log(branding.cli.footer())
-    return this
-  },
-
-  // Branded spinner: prjct message...
-  // In non-TTY (CI, Claude Code), prints a static line instead of animating
-  spin(msg: string) {
-    if (quietMode) return this
-    this.stop()
-    if (!process.stdout.isTTY) {
-      process.stdout.write(`${branding.cli.spin(0, truncate(msg, OUTPUT_LIMITS.SPINNER_MSG))}\n`)
-      return this
-    }
-    interval = setInterval(() => {
-      process.stdout.write(
-        `\r${branding.cli.spin(frame++, truncate(msg, OUTPUT_LIMITS.SPINNER_MSG))}`
-      )
-    }, SPEED)
-    return this
-  },
-
-  done(msg: string, metrics?: OutputMetrics) {
-    this.stop()
-    if (!quietMode) {
-      // Build metrics suffix if provided: [2a | 97% | 45K]
-      let suffix = ''
-      if (metrics) {
-        const parts: string[] = []
-        if (metrics.agents !== undefined) parts.push(`${metrics.agents}a`)
-        if (metrics.reduction !== undefined) parts.push(`${metrics.reduction}%`)
-        if (metrics.tokens !== undefined) parts.push(`${Math.round(metrics.tokens)}K`)
-        if (parts.length > 0) {
-          suffix = chalk.dim(` [${parts.join(' | ')}]`)
-        }
-      }
-      console.log(`${ICONS.success} ${truncate(msg, OUTPUT_LIMITS.DONE_MSG)}${suffix}`)
-    }
-    return this
-  },
-
-  // Errors go to stderr even in quiet mode
-  fail(msg: string) {
-    this.stop()
-    console.error(`${ICONS.fail} ${truncate(msg, OUTPUT_LIMITS.FAIL_MSG)}`)
-    return this
-  },
-
-  // Rich error with context and recovery hint
-  failWithHint(error: ErrorWithHint | ErrorCode) {
-    this.stop()
-    const err = typeof error === 'string' ? getError(error as ErrorCode) : error
-    console.error()
-    console.error(`${ICONS.fail} ${err.message}`)
-    if (err.file) {
-      console.error(chalk.dim(`  File: ${err.file}`))
-    }
-    if (err.hint) {
-      console.error(chalk.yellow(`  💡 ${err.hint}`))
-    }
-    if (err.docs) {
-      console.error(chalk.dim(`  Docs: ${err.docs}`))
-    }
-    console.error()
-    return this
-  },
-
-  warn(msg: string) {
-    this.stop()
-    if (!quietMode) console.log(`${ICONS.warn} ${truncate(msg, OUTPUT_LIMITS.WARN_MSG)}`)
-    return this
-  },
-
-  // Informational message
-  info(msg: string) {
-    this.stop()
-    if (!quietMode) console.log(`${ICONS.info} ${msg}`)
-    return this
-  },
-
-  // Debug message (only if DEBUG=1 or DEBUG=true)
-  debug(msg: string) {
-    this.stop()
-    // DEBUG: Enable debug output (values: '1' or 'true')
-    const debugEnabled = process.env.DEBUG === '1' || process.env.DEBUG === 'true'
-    if (!quietMode && debugEnabled) {
-      console.log(`${ICONS.debug} ${chalk.dim(msg)}`)
-    }
-    return this
-  },
-
-  // Alias for done - explicit success indicator
-  success(msg: string, metrics?: OutputMetrics) {
-    return this.done(msg, metrics)
-  },
-
-  // Bulleted list
-  list(items: string[], options: { bullet?: string; indent?: number } = {}) {
-    this.stop()
-    if (quietMode) return this
-    const bullet = options.bullet || ICONS.bullet
-    const indent = ' '.repeat(options.indent || 0)
-    for (const item of items) {
-      console.log(`${indent}${bullet} ${item}`)
-    }
-    return this
-  },
-
-  // Simple table output
-  table(rows: Array<Record<string, string | number>>, options: { header?: boolean } = {}) {
-    this.stop()
-    if (quietMode || rows.length === 0) return this
-
-    const keys = Object.keys(rows[0])
-    const colWidths: Record<string, number> = {}
-
-    // Calculate column widths
-    for (const key of keys) {
-      colWidths[key] = key.length
-      for (const row of rows) {
-        const val = String(row[key] ?? '')
-        if (val.length > colWidths[key]) colWidths[key] = val.length
-      }
-    }
-
-    // Print header if requested
-    if (options.header !== false) {
-      const headerLine = keys.map((k) => k.padEnd(colWidths[k])).join('  ')
-      console.log(chalk.dim(headerLine))
-      console.log(chalk.dim('─'.repeat(headerLine.length)))
-    }
-
-    // Print rows
-    for (const row of rows) {
-      const line = keys.map((k) => String(row[k] ?? '').padEnd(colWidths[k])).join('  ')
-      console.log(line)
-    }
-    return this
-  },
-
-  // Boxed content
-  box(title: string, content: string) {
-    this.stop()
-    if (quietMode) return this
-    const lines = content.split('\n')
-    const maxLen = Math.max(title.length, ...lines.map((l) => l.length))
-    const border = '─'.repeat(maxLen + 2)
-
-    console.log(chalk.dim(`┌${border}┐`))
-    console.log(`${chalk.dim('│')} ${chalk.bold(title.padEnd(maxLen))} ${chalk.dim('│')}`)
-    console.log(chalk.dim(`├${border}┤`))
-    for (const line of lines) {
-      console.log(`${chalk.dim('│')} ${line.padEnd(maxLen)} ${chalk.dim('│')}`)
-    }
-    console.log(chalk.dim(`└${border}┘`))
-    return this
-  },
-
-  // Section header: bold title + underline
-  section(title: string) {
-    this.stop()
-    if (quietMode) return this
-    console.log(`\n${chalk.bold(title)}`)
-    console.log(chalk.dim('─'.repeat(title.length)))
-    return this
-  },
-
-  stop() {
-    if (interval) {
-      clearInterval(interval)
-      interval = null
-      clear()
-    }
-    return this
-  },
-
-  // Step counter: [3/7] Running tests...
-  step(current: number, total: number, msg: string) {
-    if (quietMode) return this
-    this.stop()
-    const counter = chalk.dim(`[${current}/${total}]`)
-    if (!process.stdout.isTTY) {
-      process.stdout.write(
-        `${branding.cli.spin(0, `${counter} ${truncate(msg, OUTPUT_LIMITS.STEP_MSG)}`)}\n`
-      )
-      return this
-    }
-    interval = setInterval(() => {
-      process.stdout.write(
-        `\r${branding.cli.spin(frame++, `${counter} ${truncate(msg, OUTPUT_LIMITS.STEP_MSG)}`)}`
-      )
-    }, SPEED)
-    return this
-  },
-
-  // Progress bar: [████░░░░] 50% Analyzing...
-  progress(current: number, total: number, msg?: string) {
-    if (quietMode) return this
-    this.stop()
-    const percent = Math.round((current / total) * 100)
-    const filled = Math.round(percent / 10)
-    const empty = 10 - filled
-    const bar = chalk.cyan('█'.repeat(filled)) + chalk.dim('░'.repeat(empty))
-    const text = msg ? ` ${truncate(msg, OUTPUT_LIMITS.PROGRESS_TEXT)}` : ''
-    if (!process.stdout.isTTY) {
-      process.stdout.write(`${branding.cli.spin(0, `[${bar}] ${percent}%${text}`)}\n`)
-      return this
-    }
-    interval = setInterval(() => {
-      process.stdout.write(`\r${branding.cli.spin(frame++, `[${bar}] ${percent}%${text}`)}`)
-    }, SPEED)
-    return this
-  },
-}
-
-export type { ErrorCode, ErrorWithHint } from './error-messages'
-export { createError, ERRORS, getError } from './error-messages'
-export default out

package/core/utils/preserve-sections.ts

@@ -1,218 +0,0 @@
-/**
- * Preserve Sections Utility
- *
- * Extracts and preserves user-customized sections during file regeneration.
- * Users can mark sections with preserve markers to survive sync.
- *
- * Usage in CLAUDE.md or other context files:
- * ```markdown
- * <!-- prjct:preserve -->
- * # My Custom Rules
- * - Always use tabs
- * - Prefer functional patterns
- * <!-- /prjct:preserve -->
- * ```
- *
- * @see PRJ-115
- * @module utils/preserve-sections
- */
-
-export interface PreservedSection {
-  id: string
-  content: string
-  startIndex: number
-  endIndex: number
-}
-
-// Markers for preserved sections
-const PRESERVE_START = '<!-- prjct:preserve -->'
-const PRESERVE_END = '<!-- /prjct:preserve -->'
-const PRESERVE_END_PATTERN = '<!-- /prjct:preserve -->'
-
-// Named section markers (optional identifier) - create fresh regex each time
-// Uses [\w-]+ to allow hyphens in section names (e.g., "custom-rules")
-function createPreserveStartRegex(): RegExp {
-  return /<!-- prjct:preserve(?::([\w-]+))? -->/g
-}
-
-/**
- * Extract all preserved sections from content
- */
-export function extractPreservedSections(content: string): PreservedSection[] {
-  const sections: PreservedSection[] = []
-  const regex = createPreserveStartRegex()
-
-  let match: RegExpExecArray | null
-  let sectionIndex = 0
-
-  while ((match = regex.exec(content)) !== null) {
-    const startIndex = match.index
-    const startTag = match[0]
-    const sectionId = match[1] || `section-${sectionIndex++}`
-
-    // Find the closing tag
-    const endTagStart = content.indexOf(PRESERVE_END_PATTERN, startIndex + startTag.length)
-
-    if (endTagStart === -1) {
-      // No closing tag found - skip this section
-      continue
-    }
-
-    const endIndex = endTagStart + PRESERVE_END_PATTERN.length
-
-    // Extract the content between markers (including markers)
-    const fullContent = content.substring(startIndex, endIndex)
-
-    sections.push({
-      id: sectionId,
-      content: fullContent,
-      startIndex,
-      endIndex,
-    })
-  }
-
-  return sections
-}
-
-/**
- * Extract the inner content of preserved sections (without markers)
- */
-export function extractPreservedContent(content: string): string[] {
-  const sections = extractPreservedSections(content)
-
-  return sections.map((section) => {
-    // Remove the markers to get just the inner content
-    let inner = section.content
-    inner = inner.replace(createPreserveStartRegex(), '').replace(PRESERVE_END_PATTERN, '')
-    return inner.trim()
-  })
-}
-
-/**
- * Check if content has any preserved sections
- */
-export function hasPreservedSections(content: string): boolean {
-  return content.includes(PRESERVE_START) || createPreserveStartRegex().test(content)
-}
-
-/**
- * Merge preserved sections from old content into new content
- *
- * Strategy:
- * 1. Extract preserved sections from old content
- * 2. Append them to the end of new content
- * 3. Ensure proper spacing
- *
- * @param newContent - Freshly generated content
- * @param oldContent - Previous content with user customizations
- * @returns Merged content with preserved sections
- */
-export function mergePreservedSections(newContent: string, oldContent: string): string {
-  const preservedSections = extractPreservedSections(oldContent)
-
-  if (preservedSections.length === 0) {
-    return newContent
-  }
-
-  // Build the merged content
-  let merged = newContent.trimEnd()
-
-  // Add separator before preserved sections
-  merged += '\n\n---\n\n'
-  merged += '## Your Customizations\n\n'
-  merged += '_The sections below are preserved during sync. Edit freely._\n\n'
-
-  // Append each preserved section
-  for (const section of preservedSections) {
-    merged += section.content
-    merged += '\n\n'
-  }
-
-  return `${merged.trimEnd()}\n`
-}
-
-/**
- * Create an empty preserve block for users to customize
- */
-export function createEmptyPreserveBlock(title?: string): string {
-  const header = title ? `\n# ${title}\n` : '\n'
-  return `${PRESERVE_START}${header}<!-- Add your custom instructions here -->\n${PRESERVE_END}`
-}
-
-/**
- * Wrap content in preserve markers
- */
-export function wrapInPreserveMarkers(content: string, id?: string): string {
-  const startTag = id ? `<!-- prjct:preserve:${id} -->` : PRESERVE_START
-  return `${startTag}\n${content}\n${PRESERVE_END}`
-}
-
-/**
- * Remove all preserved sections from content
- * (Useful for getting the auto-generated portion only)
- */
-export function stripPreservedSections(content: string): string {
-  const sections = extractPreservedSections(content)
-
-  if (sections.length === 0) {
-    return content
-  }
-
-  // Remove sections in reverse order to preserve indices
-  let result = content
-  for (let i = sections.length - 1; i >= 0; i--) {
-    const section = sections[i]
-    result = result.substring(0, section.startIndex) + result.substring(section.endIndex)
-  }
-
-  // Clean up any resulting double newlines
-  result = result.replace(/\n{3,}/g, '\n\n')
-
-  return result.trim()
-}
-
-/**
- * Validate that all preserve blocks are properly closed
- */
-export function validatePreserveBlocks(content: string): {
-  valid: boolean
-  errors: string[]
-} {
-  const errors: string[] = []
-
-  const startMatches = content.match(/<!-- prjct:preserve(?::\w+)? -->/g) || []
-  const endMatches = content.match(/<!-- \/prjct:preserve -->/g) || []
-
-  if (startMatches.length !== endMatches.length) {
-    errors.push(
-      `Mismatched preserve markers: ${startMatches.length} opening, ${endMatches.length} closing`
-    )
-  }
-
-  // Check for nested blocks (not supported)
-  let depth = 0
-  let maxDepth = 0
-  const lines = content.split('\n')
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i]
-    if (/<!-- prjct:preserve(?::\w+)? -->/.test(line)) {
-      depth++
-      maxDepth = Math.max(maxDepth, depth)
-    }
-    if (line.includes(PRESERVE_END_PATTERN)) {
-      depth--
-    }
-    if (depth > 1) {
-      errors.push(`Nested preserve blocks detected at line ${i + 1} (not supported)`)
-    }
-    if (depth < 0) {
-      errors.push(`Unexpected closing marker at line ${i + 1}`)
-    }
-  }
-
-  return {
-    valid: errors.length === 0,
-    errors,
-  }
-}