prjct-cli 1.22.0 → 1.23.0

package/core/utils/runtime.ts

@@ -1,108 +0,0 @@
-/**
- * Runtime Detection Utility
- *
- * Detects available JavaScript runtimes and provides utilities
- * for runtime-agnostic code execution.
- *
- * @version 1.0.0
- */
-
-import type { Runtime } from '../types'
-
-/**
- * Detect the current JavaScript runtime
- */
-export function detectRuntime(): Runtime {
-  // Check for Bun-specific global
-  if (typeof globalThis !== 'undefined' && 'Bun' in globalThis) {
-    return 'bun'
-  }
-
-  return 'node'
-}
-
-/**
- * Check if Bun is available on the system
- */
-export function isBunAvailable(): boolean {
-  // If we're already running in Bun, it's available
-  if (detectRuntime() === 'bun') {
-    return true
-  }
-
-  // Check if bun command exists in PATH
-  try {
-    const { execSync } = require('node:child_process')
-    execSync('bun --version', { stdio: 'ignore' })
-    return true
-  } catch (_error) {
-    return false
-  }
-}
-
-/**
- * Check if Node is available on the system
- */
-export function isNodeAvailable(): boolean {
-  // If we're running, Node is available (either native or via Bun's node compat)
-  return true
-}
-
-/**
- * Get runtime version
- */
-export function getRuntimeVersion(): string {
-  const runtime = detectRuntime()
-
-  if (runtime === 'bun') {
-    return `bun ${Bun.version || 'unknown'}`
-  }
-
-  return `node ${process.version}`
-}
-
-/**
- * Check if we're running in a Bun environment
- */
-export function isBun(): boolean {
-  return detectRuntime() === 'bun'
-}
-
-/**
- * Check if we're running in a Node environment
- */
-export function isNode(): boolean {
-  return detectRuntime() === 'node'
-}
-
-/**
- * Get the preferred runtime for execution
- * Returns 'bun' if available, otherwise 'node'
- */
-export function getPreferredRuntime(): Runtime {
-  if (isBunAvailable()) {
-    return 'bun'
-  }
-  return 'node'
-}
-
-/**
- * Get command to run a script with the appropriate runtime
- */
-export function getRunCommand(scriptPath: string, args: string[] = []): string {
-  const runtime = getPreferredRuntime()
-  const argsStr = args.length > 0 ? ` ${args.join(' ')}` : ''
-
-  if (runtime === 'bun') {
-    return `bun ${scriptPath}${argsStr}`
-  }
-
-  // For Node, check if it's a .ts file
-  if (scriptPath.endsWith('.ts')) {
-    // Use compiled version
-    const jsPath = scriptPath.replace(/\.ts$/, '.js').replace('/bin/', '/dist/bin/')
-    return `node ${jsPath}${argsStr}`
-  }
-
-  return `node ${scriptPath}${argsStr}`
-}

package/core/utils/session-helper.ts

@@ -1,278 +0,0 @@
-import path from 'node:path'
-import { getErrorMessage } from '../types/fs'
-import * as dateHelper from './date-helper'
-import * as fileHelper from './file-helper'
-import * as jsonlHelper from './jsonl-helper'
-
-/**
- * Session Helper - High-level session operations
- *
- * Simplifies common session workflows by combining:
- * - date-helper (date formatting)
- * - jsonl-helper (JSONL parsing)
- * - file-helper (file operations)
- * - path-manager (path construction)
- */
-
-interface SessionEntry {
-  ts?: string
-  timestamp?: string
-  type?: string
-  [key: string]: unknown
-}
-
-interface SessionStats {
-  totalEntries: number
-  byType: Record<string, number>
-  byDate: Record<string, number>
-  activeDays: number
-  averagePerDay: number
-}
-
-interface ArchiveResult {
-  archived: number
-  files: string[]
-  errors: Array<{ filename: string; error: string }>
-}
-
-/**
- * Build session file path for today
- */
-export function getTodaySessionFilePath(
-  projectGlobalPath: string,
-  layer: string,
-  filename: string | null = null
-): string {
-  const today = dateHelper.getTodayKey()
-  const yearMonth = dateHelper.formatMonth(new Date())
-  const [year, month] = yearMonth.split('-')
-
-  const sessionDir = path.join(projectGlobalPath, layer, 'sessions', year, month)
-
-  if (filename) {
-    return path.join(sessionDir, filename)
-  }
-
-  return path.join(sessionDir, `${today}.jsonl`)
-}
-
-/**
- * Ensure today's session directory exists
- */
-export async function ensureTodaySessionDir(
-  projectGlobalPath: string,
-  layer: string
-): Promise<string> {
-  const yearMonth = dateHelper.formatMonth(new Date())
-  const [year, month] = yearMonth.split('-')
-
-  const sessionDir = path.join(projectGlobalPath, layer, 'sessions', year, month)
-  await fileHelper.ensureDir(sessionDir)
-
-  return sessionDir
-}
-
-/**
- * Write log entry to today's session
- */
-export async function writeToSession(
-  projectGlobalPath: string,
-  layer: string,
-  entry: SessionEntry,
-  filename: string | null = null
-): Promise<void> {
-  await ensureTodaySessionDir(projectGlobalPath, layer)
-
-  const filePath = getTodaySessionFilePath(projectGlobalPath, layer, filename)
-
-  // Add timestamp if not present
-  if (!entry.ts && !entry.timestamp) {
-    entry.ts = dateHelper.getTimestamp()
-  }
-
-  await jsonlHelper.appendJsonLine(filePath, entry)
-}
-
-/**
- * Read today's session logs
- */
-export async function readTodaySession<T = SessionEntry>(
-  projectGlobalPath: string,
-  layer: string,
-  filename: string | null = null
-): Promise<T[]> {
-  const filePath = getTodaySessionFilePath(projectGlobalPath, layer, filename)
-  return await jsonlHelper.readJsonLines<T>(filePath)
-}
-
-/**
- * Read session logs for a date range
- */
-export async function readRecentSessions<T = SessionEntry>(
-  projectGlobalPath: string,
-  layer: string,
-  daysBack = 7
-): Promise<T[]> {
-  const fromDate = dateHelper.getDaysAgo(daysBack)
-  const toDate = new Date()
-
-  const dates = dateHelper.getDateRange(fromDate, toDate)
-  const allEntries: T[] = []
-
-  for (const date of dates) {
-    const yearMonth = dateHelper.formatMonth(date)
-    const dateKey = dateHelper.getDateKey(date)
-    const [year, month] = yearMonth.split('-')
-
-    const filePath = path.join(
-      projectGlobalPath,
-      layer,
-      'sessions',
-      year,
-      month,
-      `${dateKey}.jsonl`
-    )
-
-    const entries = await jsonlHelper.readJsonLines<T>(filePath)
-    allEntries.push(...entries)
-  }
-
-  return allEntries
-}
-
-/**
- * Get session statistics for a layer
- */
-export async function getSessionStats(
-  projectGlobalPath: string,
-  layer: string,
-  daysBack = 30
-): Promise<SessionStats> {
-  const entries = await readRecentSessions<SessionEntry>(projectGlobalPath, layer, daysBack)
-
-  // Group by type
-  const byType: Record<string, number> = {}
-  for (const entry of entries) {
-    const type = entry.type || 'unknown'
-    byType[type] = (byType[type] || 0) + 1
-  }
-
-  // Group by date
-  const byDate: Record<string, number> = {}
-  for (const entry of entries) {
-    const timestamp = entry.ts || entry.timestamp
-    if (timestamp) {
-      const date = dateHelper.getDateKey(new Date(timestamp))
-      byDate[date] = (byDate[date] || 0) + 1
-    }
-  }
-
-  return {
-    totalEntries: entries.length,
-    byType,
-    byDate,
-    activeDays: Object.keys(byDate).length,
-    averagePerDay: entries.length / Math.max(daysBack, 1),
-  }
-}
-
-/**
- * Archive old session data (move sessions older than N days)
- */
-export async function archiveOldSessions(
-  projectGlobalPath: string,
-  layer: string,
-  daysToKeep = 30
-): Promise<ArchiveResult> {
-  const cutoffDate = dateHelper.getDaysAgo(daysToKeep)
-  const archiveDir = path.join(projectGlobalPath, layer, 'archive')
-  await fileHelper.ensureDir(archiveDir)
-
-  const sessionsDir = path.join(projectGlobalPath, layer, 'sessions')
-
-  // Find all session files older than cutoff
-  const archived: string[] = []
-  const errors: Array<{ filename: string; error: string }> = []
-
-  try {
-    const years = await fileHelper.listFiles(sessionsDir, { dirsOnly: true })
-
-    for (const year of years) {
-      const yearPath = path.join(sessionsDir, year)
-      const months = await fileHelper.listFiles(yearPath, { dirsOnly: true })
-
-      for (const month of months) {
-        const monthPath = path.join(yearPath, month)
-        const sessionFiles = await fileHelper.listFiles(monthPath, { filesOnly: true })
-
-        for (const filename of sessionFiles) {
-          // Parse date from filename (YYYY-MM-DD.jsonl)
-          const dateMatch = filename.match(/(\d{4}-\d{2}-\d{2})/)
-          if (!dateMatch) continue
-
-          const sessionDate = new Date(dateMatch[1])
-          if (sessionDate < cutoffDate) {
-            const sourcePath = path.join(monthPath, filename)
-            const destPath = path.join(archiveDir, filename)
-
-            try {
-              await fileHelper.moveFile(sourcePath, destPath)
-              archived.push(filename)
-            } catch (error) {
-              errors.push({ filename, error: getErrorMessage(error) })
-            }
-          }
-        }
-      }
-    }
-  } catch (_error) {
-    // Sessions directory might not exist yet - expected
-  }
-
-  return {
-    archived: archived.length,
-    files: archived,
-    errors,
-  }
-}
-
-/**
- * Clean empty session directories
- */
-export async function cleanEmptySessionDirs(
-  projectGlobalPath: string,
-  layer: string
-): Promise<number> {
-  const sessionsDir = path.join(projectGlobalPath, layer, 'sessions')
-  let cleaned = 0
-
-  try {
-    const years = await fileHelper.listFiles(sessionsDir, { dirsOnly: true })
-
-    for (const year of years) {
-      const yearPath = path.join(sessionsDir, year)
-      const months = await fileHelper.listFiles(yearPath, { dirsOnly: true })
-
-      for (const month of months) {
-        const monthPath = path.join(yearPath, month)
-        const files = await fileHelper.listFiles(monthPath)
-
-        if (files.length === 0) {
-          await fileHelper.deleteDir(monthPath)
-          cleaned++
-        }
-      }
-
-      // Check if year directory is now empty
-      const remainingMonths = await fileHelper.listFiles(yearPath, { dirsOnly: true })
-      if (remainingMonths.length === 0) {
-        await fileHelper.deleteDir(yearPath)
-        cleaned++
-      }
-    }
-  } catch (_error) {
-    // Sessions directory might not exist - expected
-  }
-
-  return cleaned
-}

package/core/utils/subtask-table.ts

@@ -1,227 +0,0 @@
-/**
- * Subtask Progress Display
- *
- * Clean, minimal visual display of subtask progress.
- * No tables - just a clean list with animated status.
- *
- * @see PRJ-138
- * @module utils/subtask-table
- */
-
-import chalk from 'chalk'
-
-// Color palette for domains (cycle through these)
-const DOMAIN_COLOR_PALETTE = [
-  chalk.cyan,
-  chalk.magenta,
-  chalk.yellow,
-  chalk.blue,
-  chalk.green,
-  chalk.redBright,
-  chalk.magentaBright,
-  chalk.cyanBright,
-]
-
-/**
- * Get consistent color for a domain name using hash
- * Same domain name always returns same color
- */
-function getDomainColor(domain: string): (text: string) => string {
-  let hash = 0
-  for (const char of domain) {
-    hash = (hash << 5) - hash + char.charCodeAt(0)
-    hash = hash & hash
-  }
-  const index = Math.abs(hash) % DOMAIN_COLOR_PALETTE.length
-  return DOMAIN_COLOR_PALETTE[index]
-}
-
-// Terminal control sequences (not colors - chalk doesn't handle these)
-const HIDE_CURSOR = '\x1b[?25l'
-const SHOW_CURSOR = '\x1b[?25h'
-
-// Spinner frames (dots animation)
-const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
-
-export type SubtaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'blocked'
-
-export interface SubtaskDisplay {
-  id: string
-  domain: string
-  description: string
-  status: SubtaskStatus
-}
-
-/**
- * Format a single subtask line
- */
-function formatSubtaskLine(
-  index: number,
-  subtask: SubtaskDisplay,
-  spinnerFrame: string = '▶'
-): string {
-  const num = chalk.dim(String(index + 1).padStart(2))
-  const domainColorFn = getDomainColor(subtask.domain)
-  const domain = domainColorFn(subtask.domain.padEnd(10))
-  const desc =
-    subtask.description.length > 32
-      ? `${subtask.description.slice(0, 29)}...`
-      : subtask.description.padEnd(32)
-
-  let status: string
-  switch (subtask.status) {
-    case 'completed':
-      status = chalk.green('✓ Complete')
-      break
-    case 'in_progress':
-      status = chalk.yellow(`${spinnerFrame} Working...`)
-      break
-    case 'pending':
-      status = chalk.gray('○ Pending')
-      break
-    case 'failed':
-      status = chalk.red('✗ Failed')
-      break
-    case 'blocked':
-      status = chalk.gray('⊘ Blocked')
-      break
-    default:
-      status = chalk.gray(`○ ${subtask.status}`)
-  }
-
-  return `  ${num}   ${domain} ${desc}  ${status}`
-}
-
-/**
- * Render static subtask progress (no animation)
- */
-export function renderSubtaskProgress(subtasks: SubtaskDisplay[]): string {
-  if (subtasks.length === 0) return ''
-
-  const lines: string[] = []
-
-  lines.push('')
-  lines.push(`  ${chalk.bold.white('SUBTASK PROGRESS')}`)
-  lines.push(`  ${chalk.dim('─'.repeat(58))}`)
-
-  for (let i = 0; i < subtasks.length; i++) {
-    lines.push(formatSubtaskLine(i, subtasks[i]))
-  }
-
-  lines.push('')
-
-  return lines.join('\n')
-}
-
-/**
- * Print static subtask progress
- */
-export function printSubtaskProgress(subtasks: SubtaskDisplay[]): void {
-  console.log(renderSubtaskProgress(subtasks))
-}
-
-/**
- * Animated subtask progress with spinner
- * Returns a controller to update/stop the animation
- */
-export function createSubtaskAnimation(subtasks: SubtaskDisplay[]) {
-  let frameIndex = 0
-  let intervalId: ReturnType<typeof setInterval> | null = null
-  let lastOutput = ''
-
-  const render = () => {
-    const spinnerFrame = SPINNER_FRAMES[frameIndex % SPINNER_FRAMES.length]
-    const lines: string[] = []
-
-    lines.push('')
-    lines.push(`  ${chalk.bold.white('SUBTASK PROGRESS')}`)
-    lines.push(`  ${chalk.dim('─'.repeat(58))}`)
-
-    for (let i = 0; i < subtasks.length; i++) {
-      lines.push(formatSubtaskLine(i, subtasks[i], spinnerFrame))
-    }
-
-    lines.push('')
-
-    return lines.join('\n')
-  }
-
-  const clear = () => {
-    if (lastOutput) {
-      const lineCount = lastOutput.split('\n').length
-      // Move up and clear each line
-      process.stdout.write(`\x1b[${lineCount}A`)
-      for (let i = 0; i < lineCount; i++) {
-        process.stdout.write('\x1b[2K\n')
-      }
-      process.stdout.write(`\x1b[${lineCount}A`)
-    }
-  }
-
-  const draw = () => {
-    clear()
-    lastOutput = render()
-    process.stdout.write(lastOutput)
-    frameIndex++
-  }
-
-  return {
-    /**
-     * Start the animation
-     */
-    start: () => {
-      process.stdout.write(HIDE_CURSOR)
-      lastOutput = render()
-      process.stdout.write(lastOutput)
-      intervalId = setInterval(draw, 80)
-    },
-
-    /**
-     * Update subtask status
-     */
-    update: (index: number, status: SubtaskStatus) => {
-      if (index >= 0 && index < subtasks.length) {
-        subtasks[index].status = status
-      }
-    },
-
-    /**
-     * Stop animation and show final state
-     */
-    stop: () => {
-      if (intervalId) {
-        clearInterval(intervalId)
-        intervalId = null
-      }
-      clear()
-      // Print final state with static icons
-      const finalLines: string[] = []
-      finalLines.push('')
-      finalLines.push(`  ${chalk.bold.white('SUBTASK PROGRESS')}`)
-      finalLines.push(`  ${chalk.dim('─'.repeat(58))}`)
-      for (let i = 0; i < subtasks.length; i++) {
-        finalLines.push(formatSubtaskLine(i, subtasks[i], '▶'))
-      }
-      finalLines.push('')
-      process.stdout.write(finalLines.join('\n'))
-      process.stdout.write(SHOW_CURSOR)
-    },
-
-    /**
-     * Get current subtasks state
-     */
-    getSubtasks: () => [...subtasks],
-  }
-}
-
-/**
- * Simple progress line
- * Output: "Progress: 2/4 subtasks complete"
- */
-export function renderProgressLine(completed: number, total: number): string {
-  return `  ${chalk.dim('Progress:')} ${completed}/${total} subtasks complete`
-}
-
-// Legacy exports for backwards compatibility
-export const renderSubtaskTable = renderSubtaskProgress
-export const printSubtaskTable = printSubtaskProgress