prjct-cli 1.22.0 → 1.24.0

package/core/utils/keychain.ts

@@ -1,127 +0,0 @@
-/**
- * Keychain Helper - Secure credential storage
- *
- * Uses macOS Keychain for secure storage of API keys and tokens.
- * Falls back to environment variables if keychain is not available.
- */
-
-import { exec } from 'node:child_process'
-import { promisify } from 'node:util'
-import { getErrorMessage } from '../types/fs'
-
-const execAsync = promisify(exec)
-
-const SERVICE_NAME = 'prjct-cli'
-
-export type CredentialKey = 'linear-api-key' | 'jira-api-token'
-
-/**
- * Store a credential in the keychain
- */
-export async function setCredential(key: CredentialKey, value: string): Promise<boolean> {
-  if (process.platform !== 'darwin') {
-    console.warn('[keychain] macOS Keychain only available on macOS')
-    return false
-  }
-
-  try {
-    // Delete existing entry first (ignore errors if it doesn't exist)
-    await execAsync(
-      `security delete-generic-password -s "${SERVICE_NAME}" -a "${key}" 2>/dev/null || true`
-    )
-
-    // Add new entry
-    await execAsync(`security add-generic-password -s "${SERVICE_NAME}" -a "${key}" -w "${value}"`)
-
-    return true
-  } catch (error) {
-    console.error('[keychain] Failed to store credential:', getErrorMessage(error))
-    return false
-  }
-}
-
-/**
- * Get a credential from the keychain
- */
-export async function getCredential(key: CredentialKey): Promise<string | null> {
-  if (process.platform !== 'darwin') {
-    // Fallback to environment variables on non-macOS
-    return getEnvFallback(key)
-  }
-
-  try {
-    const { stdout } = await execAsync(
-      `security find-generic-password -s "${SERVICE_NAME}" -a "${key}" -w 2>/dev/null`
-    )
-    return stdout.trim() || null
-  } catch (_error) {
-    // Not found in keychain - expected, try environment variable
-    return getEnvFallback(key)
-  }
-}
-
-/**
- * Delete a credential from the keychain
- */
-export async function deleteCredential(key: CredentialKey): Promise<boolean> {
-  if (process.platform !== 'darwin') {
-    return false
-  }
-
-  try {
-    await execAsync(`security delete-generic-password -s "${SERVICE_NAME}" -a "${key}" 2>/dev/null`)
-    return true
-  } catch (_error) {
-    // Not found in keychain - expected
-    return false
-  }
-}
-
-/**
- * Check if a credential exists
- */
-export async function hasCredential(key: CredentialKey): Promise<boolean> {
-  const value = await getCredential(key)
-  return value !== null && value.length > 0
-}
-
-/**
- * Get environment variable fallback for a credential key
- */
-function getEnvFallback(key: CredentialKey): string | null {
-  const envMap: Record<CredentialKey, string> = {
-    'linear-api-key': 'LINEAR_API_KEY',
-    'jira-api-token': 'JIRA_API_TOKEN',
-  }
-
-  const envVar = envMap[key]
-  return process.env[envVar] || null
-}
-
-/**
- * Get credential with source information
- */
-export async function getCredentialWithSource(
-  key: CredentialKey
-): Promise<{ value: string | null; source: 'keychain' | 'env' | 'none' }> {
-  if (process.platform === 'darwin') {
-    try {
-      const { stdout } = await execAsync(
-        `security find-generic-password -s "${SERVICE_NAME}" -a "${key}" -w 2>/dev/null`
-      )
-      const value = stdout.trim()
-      if (value) {
-        return { value, source: 'keychain' }
-      }
-    } catch (_error) {
-      // Not in keychain - expected, check env
-    }
-  }
-
-  const envValue = getEnvFallback(key)
-  if (envValue) {
-    return { value: envValue, source: 'env' }
-  }
-
-  return { value: null, source: 'none' }
-}

package/core/utils/logger.ts

@@ -1,77 +0,0 @@
-/**
- * Logger - Centralized logging with levels
- *
- * Silent by default. Enable with:
- *   PRJCT_DEBUG=1       (all logs)
- *   PRJCT_DEBUG=error   (errors only)
- *   PRJCT_DEBUG=warn    (errors + warnings)
- *   PRJCT_DEBUG=info    (errors + warnings + info)
- *   PRJCT_DEBUG=debug   (everything)
- *
- * Usage:
- *   import log from './utils/logger'
- *   log.debug('Processing files...')
- *   log.info('Task started')
- *   log.warn('Cache miss')
- *   log.error('Failed to load', error.message)
- */
-
-import type { LogFunction, Logger, LogLevel } from '../types/logger'
-
-const LEVELS: Record<LogLevel, number> = { error: 0, warn: 1, info: 2, debug: 3 }
-const TRUTHY_VALUES = new Set(['1', 'true', '*'])
-
-/**
- * Determine log level from environment variables
- * Returns -1 (disabled) or a level from LEVELS
- */
-function getLogLevel(): { level: number; name: LogLevel | 'disabled' } {
-  // PRJCT_DEBUG (primary) or DEBUG (fallback): Enable debug logging
-  // Values: '1', 'true', a log level name, or 'prjct' to match
-  const debugEnv = process.env.PRJCT_DEBUG || process.env.DEBUG || ''
-
-  // Disabled if empty
-  if (!debugEnv) return { level: -1, name: 'disabled' }
-
-  // Enable all logs for common truthy values or prjct-related patterns
-  if (TRUTHY_VALUES.has(debugEnv) || debugEnv.includes('prjct')) {
-    return { level: LEVELS.debug, name: 'debug' }
-  }
-
-  // Check for specific level name (error, warn, info, debug)
-  const levelValue = LEVELS[debugEnv as LogLevel] ?? -1
-  const levelName = levelValue >= 0 ? (debugEnv as LogLevel) : 'disabled'
-  return { level: levelValue, name: levelName }
-}
-
-const { level: currentLevel, name: currentLevelName } = getLogLevel()
-
-// No-op function for disabled logs
-const noop: LogFunction = () => {}
-
-// Factory for creating log methods
-function createLogMethod(
-  levelThreshold: number,
-  prefix: string,
-  method: 'log' | 'warn' | 'error'
-): LogFunction {
-  return currentLevel >= levelThreshold
-    ? (...args: unknown[]) => console[method](prefix, ...args)
-    : noop
-}
-
-// Create logger methods
-const logger: Logger = {
-  error: createLogMethod(LEVELS.error, '[prjct:error]', 'error'),
-  warn: createLogMethod(LEVELS.warn, '[prjct:warn]', 'warn'),
-  info: createLogMethod(LEVELS.info, '[prjct:info]', 'log'),
-  debug: createLogMethod(LEVELS.debug, '[prjct:debug]', 'log'),
-
-  // Check if logging is enabled (useful for expensive log prep)
-  isEnabled: () => currentLevel >= 0,
-
-  // Get current level name (pre-computed, no runtime lookup)
-  level: () => currentLevelName,
-}
-
-export default logger

package/core/utils/markdown-builder.ts

@@ -1,280 +0,0 @@
-/**
- * MarkdownBuilder - Fluent API for constructing markdown documents
- *
- * Eliminates duplicated markdown generation across:
- * - state-storage.ts (~35 lines)
- * - queue-storage.ts (~45 lines)
- * - ideas-storage.ts (~40 lines)
- * - shipped-storage.ts (~25 lines)
- *
- * Usage:
- * ```typescript
- * const content = md()
- *   .h1('Title')
- *   .p('Description')
- *   .when(hasItems, m => m.list(items))
- *   .build()
- * ```
- */
-
-export class MarkdownBuilder {
-  private lines: string[] = []
-
-  /**
-   * Add H1 heading
-   */
-  h1(text: string): this {
-    this.lines.push(`# ${text}`, '')
-    return this
-  }
-
-  /**
-   * Add H2 heading
-   */
-  h2(text: string): this {
-    this.lines.push(`## ${text}`, '')
-    return this
-  }
-
-  /**
-   * Add H3 heading
-   */
-  h3(text: string): this {
-    this.lines.push(`### ${text}`)
-    return this
-  }
-
-  /**
-   * Add H4 heading
-   */
-  h4(text: string): this {
-    this.lines.push(`#### ${text}`)
-    return this
-  }
-
-  /**
-   * Add paragraph
-   */
-  p(text: string): this {
-    this.lines.push(text, '')
-    return this
-  }
-
-  /**
-   * Add bold text on its own line
-   */
-  bold(text: string): this {
-    this.lines.push(`**${text}**`)
-    return this
-  }
-
-  /**
-   * Add italic text on its own line
-   */
-  italic(text: string): this {
-    this.lines.push(`*${text}*`)
-    return this
-  }
-
-  /**
-   * Add inline code
-   */
-  code(text: string): this {
-    this.lines.push(`\`${text}\``)
-    return this
-  }
-
-  /**
-   * Add code block
-   */
-  codeBlock(code: string, lang = ''): this {
-    this.lines.push(`\`\`\`${lang}`, code, '```', '')
-    return this
-  }
-
-  /**
-   * Add list item with optional checkbox
-   */
-  li(text: string, options?: { checked?: boolean; indent?: number }): this {
-    const indent = '  '.repeat(options?.indent ?? 0)
-    if (options?.checked !== undefined) {
-      this.lines.push(`${indent}- [${options.checked ? 'x' : ' '}] ${text}`)
-    } else {
-      this.lines.push(`${indent}- ${text}`)
-    }
-    return this
-  }
-
-  /**
-   * Add numbered list item
-   */
-  oli(text: string, number: number): this {
-    this.lines.push(`${number}. ${text}`)
-    return this
-  }
-
-  /**
-   * Add multiple list items
-   */
-  list(items: string[], options?: { checked?: boolean }): this {
-    for (const item of items) {
-      this.li(item, options)
-    }
-    return this
-  }
-
-  /**
-   * Add multiple numbered list items
-   */
-  orderedList(items: string[]): this {
-    for (let i = 0; i < items.length; i++) {
-      this.oli(items[i], i + 1)
-    }
-    return this
-  }
-
-  /**
-   * Add horizontal rule
-   */
-  hr(): this {
-    this.lines.push('', '---', '')
-    return this
-  }
-
-  /**
-   * Add blank line
-   */
-  blank(): this {
-    this.lines.push('')
-    return this
-  }
-
-  /**
-   * Add raw line(s)
-   */
-  raw(text: string): this {
-    this.lines.push(text)
-    return this
-  }
-
-  /**
-   * Add multiple raw lines
-   */
-  rawLines(lines: string[]): this {
-    this.lines.push(...lines)
-    return this
-  }
-
-  /**
-   * Add blockquote
-   */
-  quote(text: string): this {
-    this.lines.push(`> ${text}`)
-    return this
-  }
-
-  /**
-   * Add link
-   */
-  link(text: string, url: string): this {
-    this.lines.push(`[${text}](${url})`)
-    return this
-  }
-
-  /**
-   * Add key-value pair (bold key)
-   */
-  kv(key: string, value: string): this {
-    this.lines.push(`**${key}:** ${value}`)
-    return this
-  }
-
-  /**
-   * Add table from data
-   */
-  table(headers: string[], rows: string[][]): this {
-    // Header row
-    this.lines.push(`| ${headers.join(' | ')} |`)
-    // Separator
-    this.lines.push(`| ${headers.map(() => '---').join(' | ')} |`)
-    // Data rows
-    rows.forEach((row) => {
-      this.lines.push(`| ${row.join(' | ')} |`)
-    })
-    this.blank()
-    return this
-  }
-
-  /**
-   * Conditional block - only adds content if condition is true
-   */
-  when(condition: boolean, builder: (md: MarkdownBuilder) => void): this {
-    if (condition) {
-      builder(this)
-    }
-    return this
-  }
-
-  /**
-   * Optional block - only adds content if value exists
-   */
-  maybe<T>(value: T | null | undefined, builder: (md: MarkdownBuilder, val: T) => void): this {
-    if (value != null) {
-      builder(this, value)
-    }
-    return this
-  }
-
-  /**
-   * Iterate and build for each item
-   */
-  each<T>(items: T[], builder: (md: MarkdownBuilder, item: T, index: number) => void): this {
-    for (let i = 0; i < items.length; i++) {
-      builder(this, items[i], i)
-    }
-    return this
-  }
-
-  /**
-   * Add section with heading and content
-   */
-  section(heading: string, level: 1 | 2 | 3 | 4, builder: (md: MarkdownBuilder) => void): this {
-    switch (level) {
-      case 1:
-        this.h1(heading)
-        break
-      case 2:
-        this.h2(heading)
-        break
-      case 3:
-        this.h3(heading)
-        break
-      case 4:
-        this.h4(heading)
-        break
-    }
-    builder(this)
-    return this
-  }
-
-  /**
-   * Build final markdown string
-   */
-  build(): string {
-    return this.lines.join('\n')
-  }
-
-  /**
-   * Get current line count
-   */
-  get length(): number {
-    return this.lines.length
-  }
-}
-
-/**
- * Factory function for fluent API
- */
-export function md(): MarkdownBuilder {
-  return new MarkdownBuilder()
-}

package/core/utils/next-steps.ts

@@ -1,95 +0,0 @@
-/**
- * Next Steps - Show explicit guidance after each command
- *
- * Uses the workflow state machine to show valid commands
- * for the current state.
- */
-
-import chalk from 'chalk'
-import { type WorkflowState, workflowStateMachine } from '../workflow/state-machine'
-
-interface NextStep {
-  cmd: string
-  desc: string
-}
-
-/**
- * Command descriptions for display
- */
-const CMD_DESCRIPTIONS: Record<string, string> = {
-  task: 'Start new task',
-  done: 'Complete current task',
-  pause: 'Pause and switch context',
-  resume: 'Continue paused task',
-  ship: 'Ship the feature',
-  reopen: 'Reopen for rework',
-  next: 'View task queue',
-  sync: 'Analyze project',
-  bug: 'Report a bug',
-  idea: 'Capture an idea',
-}
-
-/**
- * Map command to resulting workflow state
- */
-const COMMAND_TO_STATE: Record<string, WorkflowState> = {
-  task: 'working',
-  done: 'completed',
-  'done-subtask': 'working', // Still working on subtasks
-  pause: 'paused',
-  resume: 'working',
-  ship: 'shipped',
-  reopen: 'working',
-  next: 'idle',
-  sync: 'idle',
-  init: 'idle',
-  bug: 'working',
-  idea: 'idle',
-}
-
-/**
- * Show next steps after a command
- */
-export function showNextSteps(command: string, options: { quiet?: boolean } = {}): void {
-  if (options.quiet) return
-
-  // Get the state after this command
-  const resultingState = COMMAND_TO_STATE[command] || 'idle'
-
-  // Get valid commands for that state
-  const validCommands = workflowStateMachine.getValidCommands(resultingState)
-
-  if (validCommands.length === 0) return
-
-  const steps: NextStep[] = validCommands.map((cmd) => ({
-    cmd: `p. ${cmd}`,
-    desc: CMD_DESCRIPTIONS[cmd] || cmd,
-  }))
-
-  console.log(chalk.dim('\nNext:'))
-  for (const step of steps) {
-    const cmd = chalk.cyan(step.cmd.padEnd(12))
-    console.log(chalk.dim(`  ${cmd} → ${step.desc}`))
-  }
-}
-
-/**
- * Get next steps for a command (for programmatic use)
- */
-export function getNextSteps(command: string): NextStep[] {
-  const resultingState = COMMAND_TO_STATE[command] || 'idle'
-  const validCommands = workflowStateMachine.getValidCommands(resultingState)
-
-  return validCommands.map((cmd) => ({
-    cmd: `p. ${cmd}`,
-    desc: CMD_DESCRIPTIONS[cmd] || cmd,
-  }))
-}
-
-/**
- * Show current state info
- */
-export function showStateInfo(state: WorkflowState): void {
-  const info = workflowStateMachine.getStateInfo(state)
-  console.log(chalk.dim(`📍 State: ${chalk.white(state.toUpperCase())} - ${info.description}`))
-}