@stacksjs/ts-cloud-core 0.1.2 → 0.1.6

package/src/cli/suggestions.ts

@@ -1,327 +0,0 @@
-/**
- * Command suggestions and typo corrections
- * Helps users discover commands and fix typos
- */
-
-/**
- * Calculate Levenshtein distance between two strings
- */
-function levenshteinDistance(a: string, b: string): number {
-  const matrix: number[][] = []
-
-  for (let i = 0; i <= b.length; i++) {
-    matrix[i] = [i]
-  }
-
-  for (let j = 0; j <= a.length; j++) {
-    matrix[0][j] = j
-  }
-
-  for (let i = 1; i <= b.length; i++) {
-    for (let j = 1; j <= a.length; j++) {
-      if (b.charAt(i - 1) === a.charAt(j - 1)) {
-        matrix[i][j] = matrix[i - 1][j - 1]
-      }
-      else {
-        matrix[i][j] = Math.min(
-          matrix[i - 1][j - 1] + 1, // substitution
-          matrix[i][j - 1] + 1, // insertion
-          matrix[i - 1][j] + 1, // deletion
-        )
-      }
-    }
-  }
-
-  return matrix[b.length][a.length]
-}
-
-/**
- * Calculate similarity score between 0 and 1
- */
-function similarityScore(a: string, b: string): number {
-  const distance = levenshteinDistance(a.toLowerCase(), b.toLowerCase())
-  const maxLength = Math.max(a.length, b.length)
-
-  if (maxLength === 0) return 1
-
-  return 1 - distance / maxLength
-}
-
-/**
- * Suggest similar commands based on typo
- */
-export function suggestCommand(input: string, availableCommands: string[], threshold = 0.5): string[] {
-  const suggestions = availableCommands
-    .map(cmd => ({
-      command: cmd,
-      score: similarityScore(input, cmd),
-    }))
-    .filter(item => item.score >= threshold)
-    .sort((a, b) => b.score - a.score)
-    .map(item => item.command)
-
-  return suggestions.slice(0, 5) // Return top 5 suggestions
-}
-
-/**
- * Format suggestion message
- */
-export function formatSuggestion(input: string, suggestions: string[]): string {
-  if (suggestions.length === 0) {
-    return `Unknown command: '${input}'\n\nRun 'ts-cloud --help' to see available commands.`
-  }
-
-  if (suggestions.length === 1) {
-    return `Unknown command: '${input}'\n\nDid you mean: ${suggestions[0]}?`
-  }
-
-  return `Unknown command: '${input}'\n\nDid you mean one of these?\n${suggestions.map(s => `  • ${s}`).join('\n')}`
-}
-
-/**
- * Check if input is likely a typo of any available command
- */
-export function isLikelyTypo(input: string, availableCommands: string[]): boolean {
-  return suggestCommand(input, availableCommands, 0.7).length > 0
-}
-
-/**
- * Command categories for contextual help
- */
-export interface CommandCategory {
-  name: string
-  description: string
-  commands: CommandInfo[]
-}
-
-export interface CommandInfo {
-  name: string
-  description: string
-  aliases?: string[]
-  examples?: string[]
-}
-
-/**
- * Get contextual help based on current command
- */
-export function getContextualHelp(
-  currentCommand: string,
-  categories: CommandCategory[],
-): string {
-  // Find the category containing the current command
-  const category = categories.find(cat =>
-    cat.commands.some(cmd => cmd.name === currentCommand || cmd.aliases?.includes(currentCommand)),
-  )
-
-  if (!category) {
-    return 'No contextual help available.'
-  }
-
-  const lines: string[] = []
-
-  lines.push(`${category.name}`)
-  lines.push('─'.repeat(category.name.length))
-  lines.push(category.description)
-  lines.push('')
-
-  // Show related commands
-  lines.push('Related commands:')
-  for (const cmd of category.commands) {
-    lines.push(`  ${cmd.name.padEnd(20)} ${cmd.description}`)
-
-    if (cmd.aliases && cmd.aliases.length > 0) {
-      lines.push(`    Aliases: ${cmd.aliases.join(', ')}`)
-    }
-  }
-
-  // Show examples for current command
-  const currentCmd = category.commands.find(
-    cmd => cmd.name === currentCommand || cmd.aliases?.includes(currentCommand),
-  )
-
-  if (currentCmd?.examples && currentCmd.examples.length > 0) {
-    lines.push('')
-    lines.push('Examples:')
-    for (const example of currentCmd.examples) {
-      lines.push(`  ${example}`)
-    }
-  }
-
-  return lines.join('\n')
-}
-
-/**
- * Search commands by keyword
- */
-export function searchCommands(
-  query: string,
-  categories: CommandCategory[],
-): Array<{ command: CommandInfo; category: string }> {
-  const results: Array<{ command: CommandInfo; category: string }> = []
-  const queryLower = query.toLowerCase()
-
-  for (const category of categories) {
-    for (const command of category.commands) {
-      const nameMatch = command.name.toLowerCase().includes(queryLower)
-      const descMatch = command.description.toLowerCase().includes(queryLower)
-      const aliasMatch = command.aliases?.some(alias => alias.toLowerCase().includes(queryLower))
-
-      if (nameMatch || descMatch || aliasMatch) {
-        results.push({
-          command,
-          category: category.name,
-        })
-      }
-    }
-  }
-
-  return results
-}
-
-/**
- * Autocomplete suggestions for partial input
- */
-export function autocomplete(
-  partial: string,
-  availableCommands: string[],
-  maxResults = 10,
-): string[] {
-  const partialLower = partial.toLowerCase()
-
-  // First, exact prefix matches
-  const prefixMatches = availableCommands.filter(cmd =>
-    cmd.toLowerCase().startsWith(partialLower),
-  )
-
-  // Then, contains matches
-  const containsMatches = availableCommands.filter(
-    cmd =>
-      cmd.toLowerCase().includes(partialLower) && !cmd.toLowerCase().startsWith(partialLower),
-  )
-
-  return [...prefixMatches, ...containsMatches].slice(0, maxResults)
-}
-
-/**
- * Suggest flags based on partial input
- */
-export interface FlagInfo {
-  name: string
-  alias?: string
-  description: string
-  type: 'boolean' | 'string' | 'number'
-  required?: boolean
-}
-
-export function suggestFlags(partial: string, availableFlags: FlagInfo[]): FlagInfo[] {
-  const partialLower = partial.toLowerCase()
-
-  return availableFlags.filter((flag) => {
-    const nameMatch = flag.name.toLowerCase().includes(partialLower)
-    const aliasMatch = flag.alias?.toLowerCase().includes(partialLower)
-
-    return nameMatch || aliasMatch
-  })
-}
-
-/**
- * Format flag suggestions
- */
-export function formatFlagSuggestions(flags: FlagInfo[]): string {
-  if (flags.length === 0) {
-    return 'No matching flags found.'
-  }
-
-  const lines: string[] = []
-
-  for (const flag of flags) {
-    let line = `  --${flag.name}`
-
-    if (flag.alias) {
-      line += `, -${flag.alias}`
-    }
-
-    line = line.padEnd(30)
-    line += flag.description
-
-    if (flag.required) {
-      line += ' (required)'
-    }
-
-    lines.push(line)
-  }
-
-  return lines.join('\n')
-}
-
-/**
- * Get command usage example
- */
-export function getCommandUsage(command: CommandInfo): string {
-  const lines: string[] = []
-
-  lines.push(`Usage: ts-cloud ${command.name}`)
-  lines.push('')
-  lines.push(command.description)
-
-  if (command.aliases && command.aliases.length > 0) {
-    lines.push('')
-    lines.push(`Aliases: ${command.aliases.join(', ')}`)
-  }
-
-  if (command.examples && command.examples.length > 0) {
-    lines.push('')
-    lines.push('Examples:')
-    for (const example of command.examples) {
-      lines.push(`  ${example}`)
-    }
-  }
-
-  return lines.join('\n')
-}
-
-/**
- * Validate command and suggest fixes
- */
-export interface ValidationResult {
-  valid: boolean
-  errors: string[]
-  warnings: string[]
-  suggestions: string[]
-}
-
-export function validateCommand(
-  input: string,
-  availableCommands: string[],
-  requiredFlags: string[] = [],
-): ValidationResult {
-  const result: ValidationResult = {
-    valid: true,
-    errors: [],
-    warnings: [],
-    suggestions: [],
-  }
-
-  const [command, ...args] = input.split(' ')
-
-  // Check if command exists
-  if (!availableCommands.includes(command)) {
-    result.valid = false
-    result.errors.push(`Unknown command: ${command}`)
-
-    const suggestions = suggestCommand(command, availableCommands)
-    if (suggestions.length > 0) {
-      result.suggestions.push(...suggestions)
-    }
-  }
-
-  // Check for required flags
-  for (const flag of requiredFlags) {
-    if (!args.some(arg => arg === `--${flag}` || arg.startsWith(`--${flag}=`))) {
-      result.valid = false
-      result.errors.push(`Missing required flag: --${flag}`)
-    }
-  }
-
-  return result
-}

package/src/cli/table.test.ts

@@ -1,319 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import {
-  formatTable,
-  formatTree,
-  formatProgressBar,
-  formatBytes,
-  formatDuration,
-  formatList,
-  formatKeyValue,
-} from './table'
-
-describe('Table Formatting', () => {
-  describe('formatTable', () => {
-    it('should format basic table', () => {
-      const result = formatTable({
-        columns: [
-          { key: 'name', label: 'Name' },
-          { key: 'age', label: 'Age' },
-        ],
-        data: [
-          { name: 'Alice', age: 25 },
-          { name: 'Bob', age: 30 },
-        ],
-      })
-
-      expect(result).toContain('Name')
-      expect(result).toContain('Age')
-      expect(result).toContain('Alice')
-      expect(result).toContain('Bob')
-      expect(result).toContain('25')
-      expect(result).toContain('30')
-    })
-
-    it('should handle empty data', () => {
-      const result = formatTable({
-        columns: [
-          { key: 'name', label: 'Name' },
-        ],
-        data: [],
-      })
-
-      expect(result).toBe('No data to display')
-    })
-
-    it('should apply formatters', () => {
-      const result = formatTable({
-        columns: [
-          { key: 'name', label: 'Name' },
-          {
-            key: 'amount',
-            label: 'Amount',
-            formatter: (val) => `$${val}`,
-          },
-        ],
-        data: [
-          { name: 'Item', amount: 100 },
-        ],
-      })
-
-      expect(result).toContain('$100')
-    })
-
-    it('should align columns', () => {
-      const result = formatTable({
-        columns: [
-          { key: 'name', label: 'Name', align: 'left' },
-          { key: 'age', label: 'Age', align: 'right' },
-        ],
-        data: [
-          { name: 'Alice', age: 25 },
-        ],
-      })
-
-      expect(result).toContain('Alice')
-      expect(result).toContain('25')
-    })
-
-    it('should handle missing values', () => {
-      const result = formatTable({
-        columns: [
-          { key: 'name', label: 'Name' },
-          { key: 'age', label: 'Age' },
-        ],
-        data: [
-          { name: 'Alice' }, // Missing age
-        ],
-      })
-
-      expect(result).toContain('Alice')
-    })
-  })
-
-  describe('formatTree', () => {
-    it('should format tree structure', () => {
-      const result = formatTree([
-        {
-          label: 'Root',
-          children: [
-            { label: 'Child 1' },
-            { label: 'Child 2' },
-          ],
-        },
-      ])
-
-      expect(result).toContain('Root')
-      expect(result).toContain('Child 1')
-      expect(result).toContain('Child 2')
-      expect(result).toContain('├─')
-      expect(result).toContain('└─')
-    })
-
-    it('should show metadata when enabled', () => {
-      const result = formatTree(
-        [
-          {
-            label: 'Node',
-            metadata: { status: 'active', count: 5 },
-          },
-        ],
-        { showMetadata: true },
-      )
-
-      expect(result).toContain('Node')
-      expect(result).toContain('status')
-      expect(result).toContain('active')
-      expect(result).toContain('count')
-      expect(result).toContain('5')
-    })
-
-    it('should handle nested children', () => {
-      const result = formatTree([
-        {
-          label: 'Level 1',
-          children: [
-            {
-              label: 'Level 2',
-              children: [
-                { label: 'Level 3' },
-              ],
-            },
-          ],
-        },
-      ])
-
-      expect(result).toContain('Level 1')
-      expect(result).toContain('Level 2')
-      expect(result).toContain('Level 3')
-    })
-  })
-
-  describe('formatProgressBar', () => {
-    it('should format progress bar at 0%', () => {
-      const result = formatProgressBar({
-        total: 100,
-        current: 0,
-      })
-
-      expect(result).toContain('0%')
-      expect(result).toContain('0/100')
-    })
-
-    it('should format progress bar at 50%', () => {
-      const result = formatProgressBar({
-        total: 100,
-        current: 50,
-      })
-
-      expect(result).toContain('50%')
-      expect(result).toContain('50/100')
-    })
-
-    it('should format progress bar at 100%', () => {
-      const result = formatProgressBar({
-        total: 100,
-        current: 100,
-      })
-
-      expect(result).toContain('100%')
-      expect(result).toContain('100/100')
-    })
-
-    it('should use custom format', () => {
-      const result = formatProgressBar({
-        total: 100,
-        current: 50,
-        format: ':percent complete',
-      })
-
-      expect(result).toContain('50% complete')
-    })
-
-    it('should handle partial progress', () => {
-      const result = formatProgressBar({
-        total: 10,
-        current: 3,
-      })
-
-      expect(result).toContain('30%')
-    })
-  })
-
-  describe('formatBytes', () => {
-    it('should format bytes', () => {
-      expect(formatBytes(0)).toBe('0 Bytes')
-      expect(formatBytes(100)).toBe('100 Bytes')
-      expect(formatBytes(1024)).toBe('1 KB')
-      expect(formatBytes(1024 * 1024)).toBe('1 MB')
-      expect(formatBytes(1024 * 1024 * 1024)).toBe('1 GB')
-    })
-
-    it('should handle decimals', () => {
-      const result = formatBytes(1536, 2) // 1.5 KB
-      expect(result).toContain('1.5')
-      expect(result).toContain('KB')
-    })
-
-    it('should format large values', () => {
-      const result = formatBytes(1024 * 1024 * 1024 * 1024) // 1 TB
-      expect(result).toContain('1')
-      expect(result).toContain('TB')
-    })
-  })
-
-  describe('formatDuration', () => {
-    it('should format milliseconds', () => {
-      expect(formatDuration(500)).toBe('500ms')
-    })
-
-    it('should format seconds', () => {
-      expect(formatDuration(5000)).toBe('5s')
-      expect(formatDuration(45000)).toBe('45s')
-    })
-
-    it('should format minutes', () => {
-      expect(formatDuration(60000)).toBe('1m')
-      expect(formatDuration(90000)).toBe('1m 30s')
-      expect(formatDuration(120000)).toBe('2m')
-    })
-
-    it('should format hours', () => {
-      expect(formatDuration(3600000)).toBe('1h')
-      expect(formatDuration(5400000)).toBe('1h 30m')
-      expect(formatDuration(7200000)).toBe('2h')
-    })
-
-    it('should format days', () => {
-      expect(formatDuration(86400000)).toBe('1d')
-      expect(formatDuration(90000000)).toBe('1d 1h')
-    })
-  })
-
-  describe('formatList', () => {
-    it('should format simple list', () => {
-      const result = formatList(['Item 1', 'Item 2', 'Item 3'])
-
-      expect(result).toContain('• Item 1')
-      expect(result).toContain('• Item 2')
-      expect(result).toContain('• Item 3')
-    })
-
-    it('should use custom bullet', () => {
-      const result = formatList(['Item 1', 'Item 2'], '-')
-
-      expect(result).toContain('- Item 1')
-      expect(result).toContain('- Item 2')
-    })
-
-    it('should handle empty list', () => {
-      const result = formatList([])
-      expect(result).toBe('')
-    })
-  })
-
-  describe('formatKeyValue', () => {
-    it('should format key-value pairs', () => {
-      const result = formatKeyValue({
-        name: 'Alice',
-        age: 25,
-        city: 'NYC',
-      })
-
-      expect(result).toContain('name')
-      expect(result).toContain('Alice')
-      expect(result).toContain('age')
-      expect(result).toContain('25')
-      expect(result).toContain('city')
-      expect(result).toContain('NYC')
-    })
-
-    it('should align keys', () => {
-      const result = formatKeyValue({
-        a: '1',
-        abc: '2',
-        abcdef: '3',
-      })
-
-      // Keys should be padded to same length
-      expect(result).toContain(':')
-    })
-
-    it('should use custom separator', () => {
-      const result = formatKeyValue(
-        { name: 'Alice' },
-        { separator: ' = ' },
-      )
-
-      expect(result).toContain('name = Alice')
-    })
-
-    it('should indent output', () => {
-      const result = formatKeyValue(
-        { name: 'Alice' },
-        { indent: '  ' },
-      )
-
-      expect(result).toMatch(/^\s+name/)
-    })
-  })
-})