@ecmaos/coreutils 0.4.0 → 0.4.2

package/src/commands/echo.ts

@@ -6,11 +6,122 @@ function printUsage(process: Process | undefined, terminal: Terminal): void {
   const usage = `Usage: echo [OPTION]... [STRING]...
 Echo the STRING(s) to standard output.
 
+  -e     enable interpretation of backslash escapes
   -n     do not output the trailing newline
   --help display this help and exit`
   writelnStderr(process, terminal, usage)
 }
 
+function interpretEscapes(text: string): string {
+  let result = ''
+  let i = 0
+  
+  while (i < text.length) {
+    if (text[i] === '\\' && i + 1 < text.length) {
+      const next = text[i + 1]
+      switch (next) {
+        case '\\':
+          result += '\\'
+          i += 2
+          break
+        case 'a':
+          result += '\x07'
+          i += 2
+          break
+        case 'b':
+          result += '\b'
+          i += 2
+          break
+        case 'c':
+          return result
+        case 'e':
+        case 'E':
+          result += '\x1b'
+          i += 2
+          break
+        case 'f':
+          result += '\f'
+          i += 2
+          break
+        case 'n':
+          result += '\n'
+          i += 2
+          break
+        case 'r':
+          result += '\r'
+          i += 2
+          break
+        case 't':
+          result += '\t'
+          i += 2
+          break
+        case 'v':
+          result += '\v'
+          i += 2
+          break
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7': {
+          let octal = ''
+          let j = i + 1
+          while (j < text.length && j < i + 4) {
+            const char = text[j]
+            if (char && /[0-7]/.test(char)) {
+              octal += char
+              j++
+            } else {
+              break
+            }
+          }
+          if (octal) {
+            result += String.fromCharCode(parseInt(octal, 8))
+            i = j
+          } else {
+            result += text[i]
+            i++
+          }
+          break
+        }
+        case 'x': {
+          let hex = ''
+          let j = i + 2
+          while (j < text.length && j < i + 4) {
+            const char = text[j]
+            if (char && /[0-9a-fA-F]/.test(char)) {
+              hex += char
+              j++
+            } else {
+              break
+            }
+          }
+          if (hex) {
+            result += String.fromCharCode(parseInt(hex, 16))
+            i = j
+          } else {
+            result += text[i]
+            i++
+          }
+          break
+        }
+        default:
+          result += text[i]
+          i++
+          break
+      }
+    } else {
+      result += text[i]
+      i++
+    }
+  }
+  
+  return result
+}
+
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
     command: 'echo',
@@ -27,6 +138,7 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
       }
 
       let noNewline = false
+      let enableEscapes = false
       const textParts: string[] = []
       let i = 0
 
@@ -41,12 +153,17 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           return 0
         } else if (arg === '-n') {
           noNewline = true
+        } else if (arg === '-e') {
+          enableEscapes = true
         } else if (arg.startsWith('-') && arg.length > 1 && arg !== '--') {
           const flags = arg.slice(1).split('')
           if (flags.includes('n')) {
             noNewline = true
           }
-          const invalidFlag = flags.find(f => f !== 'n')
+          if (flags.includes('e')) {
+            enableEscapes = true
+          }
+          const invalidFlag = flags.find(f => f !== 'n' && f !== 'e')
           if (invalidFlag) {
             await writelnStdout(process, terminal, `echo: invalid option -- '${invalidFlag}'`)
             return 1
@@ -57,7 +174,10 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         i++
       }
 
-      const text = textParts.join(' ')
+      let text = textParts.join(' ')
+      if (enableEscapes) {
+        text = interpretEscapes(text)
+      }
       const output = noNewline ? text : text + '\n'
 
       if (process) {

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
+    }
+  })
+}