@ecmaos/coreutils 0.3.1 → 0.4.2

package/src/commands/expand.ts

@@ -0,0 +1,207 @@
+import path from 'path'
+import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
+import { TerminalEvents } from '@ecmaos/types'
+import { TerminalCommand } from '../shared/terminal-command.js'
+import { writelnStderr } from '../shared/helpers.js'
+
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: expand [OPTION]... [FILE]...
+Convert tabs to spaces in each FILE.
+
+  -t, --tabs=NUMBER     have tabs NUMBER characters apart, not 8
+  -t, --tabs=LIST       use comma separated list of tab positions
+  --help               display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+function parseTabStops(tabStr: string): number[] {
+  if (tabStr.includes(',')) {
+    const stops = tabStr.split(',').map(s => parseInt(s.trim(), 10)).filter(n => !isNaN(n) && n > 0)
+    return stops.length > 0 ? stops : [8]
+  }
+  const single = parseInt(tabStr, 10)
+  return !isNaN(single) && single > 0 ? [single] : [8]
+}
+
+function expandTabs(line: string, tabStops: number[]): string {
+  let result = ''
+  let column = 0
+  
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i]
+    
+    if (char === '\t') {
+      let nextStop = tabStops[0] ?? 8
+      for (const stop of tabStops) {
+        if (stop > column) {
+          nextStop = stop
+          break
+        }
+      }
+      
+      if (nextStop <= column) {
+        const lastStop = tabStops[tabStops.length - 1] ?? 8
+        nextStop = lastStop
+        while (nextStop <= column) {
+          nextStop += lastStop
+        }
+      }
+      
+      const spaces = nextStop - column
+      result += ' '.repeat(spaces)
+      column = nextStop
+    } else {
+      result += char
+      if (char === '\n' || char === '\r') {
+        column = 0
+      } else {
+        column++
+      }
+    }
+  }
+  
+  return result
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'expand',
+    description: 'Convert tabs to spaces',
+    kernel,
+    shell,
+    terminal,
+    run: async (pid: number, argv: string[]) => {
+      const process = kernel.processes.get(pid) as Process | undefined
+
+      if (!process) return 1
+
+      if (argv.length > 0 && (argv[0] === '--help' || argv[0] === '-h')) {
+        printUsage(process, terminal)
+        return 0
+      }
+
+      let tabStops: number[] = [8]
+      const files: string[] = []
+
+      for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i]
+        if (!arg) continue
+
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (arg === '-t' || arg === '--tabs') {
+          if (i + 1 < argv.length) {
+            const tabStr = argv[++i]
+            if (tabStr !== undefined) {
+              tabStops = parseTabStops(tabStr)
+            }
+          }
+        } else if (arg.startsWith('--tabs=')) {
+          const tabStr = arg.slice(7)
+          tabStops = parseTabStops(tabStr)
+        } else if (arg.startsWith('-t')) {
+          const tabStr = arg.slice(2)
+          if (tabStr) {
+            tabStops = parseTabStops(tabStr)
+          }
+        } else if (!arg.startsWith('-')) {
+          files.push(arg)
+        } else {
+          await writelnStderr(process, terminal, `expand: invalid option -- '${arg.slice(1)}'`)
+          await writelnStderr(process, terminal, "Try 'expand --help' for more information.")
+          return 1
+        }
+      }
+
+      const writer = process.stdout.getWriter()
+
+      try {
+        let lines: string[] = []
+
+        if (files.length === 0) {
+          if (!process.stdin) {
+            return 0
+          }
+
+          const reader = process.stdin.getReader()
+          const decoder = new TextDecoder()
+          let buffer = ''
+
+          try {
+            while (true) {
+              const { done, value } = await reader.read()
+              if (done) break
+              if (value) {
+                buffer += decoder.decode(value, { stream: true })
+                const newLines = buffer.split('\n')
+                buffer = newLines.pop() || ''
+                lines.push(...newLines)
+              }
+            }
+            if (buffer) {
+              lines.push(buffer)
+            }
+          } finally {
+            reader.releaseLock()
+          }
+        } else {
+          for (const file of files) {
+            const fullPath = path.resolve(shell.cwd, file)
+
+            let interrupted = false
+            const interruptHandler = () => { interrupted = true }
+            kernel.terminal.events.on(TerminalEvents.INTERRUPT, interruptHandler)
+
+            try {
+              if (fullPath.startsWith('/dev')) {
+                await writelnStderr(process, terminal, `expand: ${file}: cannot process device files`)
+                continue
+              }
+
+              const handle = await shell.context.fs.promises.open(fullPath, 'r')
+              const stat = await shell.context.fs.promises.stat(fullPath)
+
+              const decoder = new TextDecoder()
+              let content = ''
+              let bytesRead = 0
+              const chunkSize = 1024
+
+              while (bytesRead < stat.size) {
+                if (interrupted) break
+                const data = new Uint8Array(chunkSize)
+                const readSize = Math.min(chunkSize, stat.size - bytesRead)
+                await handle.read(data, 0, readSize, bytesRead)
+                const chunk = data.subarray(0, readSize)
+                content += decoder.decode(chunk, { stream: true })
+                bytesRead += readSize
+              }
+
+              const fileLines = content.split('\n')
+              if (fileLines[fileLines.length - 1] === '') {
+                fileLines.pop()
+              }
+              lines.push(...fileLines)
+            } catch (error) {
+              await writelnStderr(process, terminal, `expand: ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+            } finally {
+              kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+            }
+          }
+        }
+
+        for (const line of lines) {
+          const expanded = expandTabs(line, tabStops)
+          await writer.write(new TextEncoder().encode(expanded + '\n'))
+        }
+
+        return 0
+      } catch (error) {
+        await writelnStderr(process, terminal, `expand: ${error instanceof Error ? error.message : 'Unknown error'}`)
+        return 1
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}

package/src/commands/factor.ts

@@ -0,0 +1,151 @@
+import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
+import { TerminalCommand } from '../shared/terminal-command.js'
+import { writelnStderr, writelnStdout } from '../shared/helpers.js'
+
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: factor [NUMBER]...
+Print prime factors of each NUMBER.
+
+  --help  display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+function factorize(n: number): number[] {
+  if (n < 2) {
+    return [n]
+  }
+
+  const factors: number[] = []
+  let num = n
+
+  while (num % 2 === 0) {
+    factors.push(2)
+    num /= 2
+  }
+
+  for (let i = 3; i * i <= num; i += 2) {
+    while (num % i === 0) {
+      factors.push(i)
+      num /= i
+    }
+  }
+
+  if (num > 2) {
+    factors.push(num)
+  }
+
+  return factors
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'factor',
+    description: 'Print prime factors of numbers',
+    kernel,
+    shell,
+    terminal,
+    run: async (pid: number, argv: string[]) => {
+      const process = kernel.processes.get(pid) as Process | undefined
+
+      if (!process) return 1
+
+      if (argv.length > 0 && (argv[0] === '--help' || argv[0] === '-h')) {
+        printUsage(process, terminal)
+        return 0
+      }
+
+      const numbers: string[] = []
+
+      for (const arg of argv) {
+        if (!arg) continue
+
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (!arg.startsWith('-')) {
+          numbers.push(arg)
+        } else {
+          await writelnStderr(process, terminal, `factor: invalid option -- '${arg.slice(1)}'`)
+          await writelnStderr(process, terminal, "Try 'factor --help' for more information.")
+          return 1
+        }
+      }
+
+      if (numbers.length === 0) {
+        if (!process.stdin) {
+          await writelnStderr(process, terminal, 'factor: missing operand')
+          await writelnStderr(process, terminal, "Try 'factor --help' for more information.")
+          return 1
+        }
+
+        if (process.stdinIsTTY) {
+          try {
+            while (true) {
+              const line = await terminal.readline('', false, true)
+              if (!line) break
+              const trimmed = line.trim()
+              if (trimmed) {
+                numbers.push(...trimmed.split(/\s+/))
+              } else {
+                break
+              }
+            }
+          } catch {
+          } finally {
+            terminal.listen()
+          }
+        } else {
+          const reader = process.stdin.getReader()
+          const decoder = new TextDecoder()
+          let buffer = ''
+
+          try {
+            while (true) {
+              const { done, value } = await reader.read()
+              if (done) break
+              if (value) {
+                buffer += decoder.decode(value, { stream: true })
+                const lines = buffer.split('\n')
+                buffer = lines.pop() || ''
+                for (const line of lines) {
+                  const trimmed = line.trim()
+                  if (trimmed) {
+                    numbers.push(...trimmed.split(/\s+/))
+                  }
+                }
+              }
+            }
+            if (buffer.trim()) {
+              numbers.push(...buffer.trim().split(/\s+/))
+            }
+          } finally {
+            reader.releaseLock()
+          }
+        }
+      }
+
+      if (numbers.length === 0) {
+        await writelnStderr(process, terminal, 'factor: missing operand')
+        await writelnStderr(process, terminal, "Try 'factor --help' for more information.")
+        return 1
+      }
+
+      let hasError = false
+
+      for (const numStr of numbers) {
+        const num = parseInt(numStr, 10)
+        if (isNaN(num) || num < 0) {
+          await writelnStderr(process, terminal, `factor: '${numStr}' is not a valid positive integer`)
+          hasError = true
+          continue
+        }
+
+        const factors = factorize(num)
+        const output = `${num}: ${factors.join(' ')}`
+        await writelnStdout(process, terminal, output)
+      }
+
+      return hasError ? 1 : 0
+    }
+  })
+}

package/src/commands/fmt.ts

@@ -0,0 +1,293 @@
+import path from 'path'
+import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
+import { TerminalEvents } from '@ecmaos/types'
+import { TerminalCommand } from '../shared/terminal-command.js'
+import { writelnStderr } from '../shared/helpers.js'
+
+function printUsage(process: Process | undefined, terminal: Terminal): void {
+  const usage = `Usage: fmt [OPTION]... [FILE]...
+Reformat paragraph text.
+
+  -w, --width=WIDTH      maximum line width (default: 75)
+  -s, --split-only       split long lines, but do not join short lines
+  -u, --uniform-spacing use uniform spacing (one space between words)
+  --help                display this help and exit`
+  writelnStderr(process, terminal, usage)
+}
+
+function normalizeWhitespace(text: string): string {
+  return text.replace(/\s+/g, ' ').trim()
+}
+
+function formatText(lines: string[], width: number, splitOnly: boolean, uniformSpacing: boolean): string[] {
+  const result: string[] = []
+  let currentParagraph: string[] = []
+  
+  for (const line of lines) {
+    const trimmed = line.trim()
+    
+    if (trimmed === '') {
+      if (currentParagraph.length > 0) {
+        const formatted = formatParagraph(currentParagraph, width, splitOnly, uniformSpacing)
+        result.push(...formatted)
+        currentParagraph = []
+      }
+      result.push('')
+    } else {
+      currentParagraph.push(trimmed)
+    }
+  }
+  
+  if (currentParagraph.length > 0) {
+    const formatted = formatParagraph(currentParagraph, width, splitOnly, uniformSpacing)
+    result.push(...formatted)
+  }
+  
+  return result
+}
+
+function formatParagraph(paragraph: string[], width: number, splitOnly: boolean, uniformSpacing: boolean): string[] {
+  if (paragraph.length === 0) return []
+  
+  let text = paragraph.join(' ')
+  if (uniformSpacing) {
+    text = normalizeWhitespace(text)
+  } else {
+    text = text.replace(/\s+/g, ' ')
+  }
+  
+  if (splitOnly) {
+    return splitLongLines(text, width)
+  }
+  
+  const words = text.split(/\s+/).filter(w => w.length > 0)
+  if (words.length === 0) return []
+  
+  const result: string[] = []
+  let currentLine = ''
+  
+  for (const word of words) {
+    const testLine = currentLine ? `${currentLine} ${word}` : word
+    
+    if (testLine.length <= width) {
+      currentLine = testLine
+    } else {
+      if (currentLine) {
+        result.push(currentLine)
+      }
+      currentLine = word
+      
+      if (currentLine.length > width) {
+        const split = splitLongLines(currentLine, width)
+        if (split.length > 0) {
+          result.push(...split.slice(0, -1))
+          currentLine = split[split.length - 1] || word
+        }
+      }
+    }
+  }
+  
+  if (currentLine) {
+    result.push(currentLine)
+  }
+  
+  return result
+}
+
+function splitLongLines(text: string, width: number): string[] {
+  if (text.length <= width) return [text]
+  
+  const result: string[] = []
+  let remaining = text
+  
+  while (remaining.length > width) {
+    let breakPoint = width
+    
+    const spaceIndex = remaining.lastIndexOf(' ', width)
+    if (spaceIndex > 0) {
+      breakPoint = spaceIndex
+    }
+    
+    result.push(remaining.slice(0, breakPoint).trim())
+    remaining = remaining.slice(breakPoint).trim()
+  }
+  
+  if (remaining.length > 0) {
+    result.push(remaining)
+  }
+  
+  return result
+}
+
+export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
+  return new TerminalCommand({
+    command: 'fmt',
+    description: 'Reformat paragraph text',
+    kernel,
+    shell,
+    terminal,
+    run: async (pid: number, argv: string[]) => {
+      const process = kernel.processes.get(pid) as Process | undefined
+
+      if (!process) return 1
+
+      if (argv.length > 0 && (argv[0] === '--help' || argv[0] === '-h')) {
+        printUsage(process, terminal)
+        return 0
+      }
+
+      let width = 75
+      let splitOnly = false
+      let uniformSpacing = false
+      const files: string[] = []
+
+      for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i]
+        if (!arg) continue
+
+        if (arg === '--help' || arg === '-h') {
+          printUsage(process, terminal)
+          return 0
+        } else if (arg === '-w' || arg === '--width') {
+          if (i + 1 < argv.length) {
+            const widthStr = argv[++i]
+            if (widthStr !== undefined) {
+              const parsed = parseInt(widthStr, 10)
+              if (!isNaN(parsed) && parsed > 0) {
+                width = parsed
+              } else {
+                await writelnStderr(process, terminal, `fmt: invalid width: ${widthStr}`)
+                return 1
+              }
+            }
+          }
+        } else if (arg.startsWith('--width=')) {
+          const widthStr = arg.slice(8)
+          const parsed = parseInt(widthStr, 10)
+          if (!isNaN(parsed) && parsed > 0) {
+            width = parsed
+          } else {
+            await writelnStderr(process, terminal, `fmt: invalid width: ${widthStr}`)
+            return 1
+          }
+        } else if (arg.startsWith('-w')) {
+          const widthStr = arg.slice(2)
+          if (widthStr) {
+            const parsed = parseInt(widthStr, 10)
+            if (!isNaN(parsed) && parsed > 0) {
+              width = parsed
+            } else {
+              await writelnStderr(process, terminal, `fmt: invalid width: ${widthStr}`)
+              return 1
+            }
+          }
+        } else if (arg === '-s' || arg === '--split-only') {
+          splitOnly = true
+        } else if (arg === '-u' || arg === '--uniform-spacing') {
+          uniformSpacing = true
+        } else if (arg.startsWith('-')) {
+          const flags = arg.slice(1).split('')
+          if (flags.includes('s')) splitOnly = true
+          if (flags.includes('u')) uniformSpacing = true
+          const invalidFlags = flags.filter(f => !['s', 'u'].includes(f))
+          if (invalidFlags.length > 0) {
+            await writelnStderr(process, terminal, `fmt: invalid option -- '${invalidFlags[0]}'`)
+            await writelnStderr(process, terminal, "Try 'fmt --help' for more information.")
+            return 1
+          }
+        } else {
+          files.push(arg)
+        }
+      }
+
+      const writer = process.stdout.getWriter()
+
+      try {
+        let lines: string[] = []
+
+        if (files.length === 0) {
+          if (!process.stdin) {
+            return 0
+          }
+
+          const reader = process.stdin.getReader()
+          const decoder = new TextDecoder()
+          let buffer = ''
+
+          try {
+            while (true) {
+              const { done, value } = await reader.read()
+              if (done) break
+              if (value) {
+                buffer += decoder.decode(value, { stream: true })
+                const newLines = buffer.split('\n')
+                buffer = newLines.pop() || ''
+                lines.push(...newLines)
+              }
+            }
+            if (buffer) {
+              lines.push(buffer)
+            }
+          } finally {
+            reader.releaseLock()
+          }
+        } else {
+          for (const file of files) {
+            const fullPath = path.resolve(shell.cwd, file)
+
+            let interrupted = false
+            const interruptHandler = () => { interrupted = true }
+            kernel.terminal.events.on(TerminalEvents.INTERRUPT, interruptHandler)
+
+            try {
+              if (fullPath.startsWith('/dev')) {
+                await writelnStderr(process, terminal, `fmt: ${file}: cannot process device files`)
+                continue
+              }
+
+              const handle = await shell.context.fs.promises.open(fullPath, 'r')
+              const stat = await shell.context.fs.promises.stat(fullPath)
+
+              const decoder = new TextDecoder()
+              let content = ''
+              let bytesRead = 0
+              const chunkSize = 1024
+
+              while (bytesRead < stat.size) {
+                if (interrupted) break
+                const data = new Uint8Array(chunkSize)
+                const readSize = Math.min(chunkSize, stat.size - bytesRead)
+                await handle.read(data, 0, readSize, bytesRead)
+                const chunk = data.subarray(0, readSize)
+                content += decoder.decode(chunk, { stream: true })
+                bytesRead += readSize
+              }
+
+              const fileLines = content.split('\n')
+              if (fileLines[fileLines.length - 1] === '') {
+                fileLines.pop()
+              }
+              lines.push(...fileLines)
+            } catch (error) {
+              await writelnStderr(process, terminal, `fmt: ${file}: ${error instanceof Error ? error.message : 'Unknown error'}`)
+            } finally {
+              kernel.terminal.events.off(TerminalEvents.INTERRUPT, interruptHandler)
+            }
+          }
+        }
+
+        const formatted = formatText(lines, width, splitOnly, uniformSpacing)
+        for (const line of formatted) {
+          await writer.write(new TextEncoder().encode(line + '\n'))
+        }
+
+        return 0
+      } catch (error) {
+        await writelnStderr(process, terminal, `fmt: ${error instanceof Error ? error.message : 'Unknown error'}`)
+        return 1
+      } finally {
+        writer.releaseLock()
+      }
+    }
+  })
+}