@ecmaos/coreutils 0.2.1 → 0.3.1

package/src/commands/less.ts

@@ -33,6 +33,7 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
 
       let lines: string[] = []
       let currentLine = 0
+      let horizontalOffset = 0
       let keyListener: IDisposable | null = null
       let linesRendered = 0
 
@@ -94,6 +95,40 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         const displayRows = rows - 1
 
         const render = () => {
+          const cols = terminal.cols
+          const stripAnsi = (s: string) => s.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '')
+          
+          const getVisibleSlice = (line: string, offset: number): string => {
+            const visibleLen = stripAnsi(line).length
+            
+            if (offset < 0) offset = 0
+            if (offset > visibleLen) offset = visibleLen
+            
+            let visible = 0
+            let result = ''
+            let inEscape = false
+            let charsSkipped = 0
+            
+            for (const char of line) {
+              if (char === '\x1b') inEscape = true
+              if (inEscape) {
+                if (charsSkipped >= offset) {
+                  result += char
+                }
+                if (/[a-zA-Z]/.test(char)) inEscape = false
+              } else {
+                if (charsSkipped < offset) {
+                  charsSkipped++
+                } else {
+                  if (visible >= cols) break
+                  result += char
+                  visible++
+                }
+              }
+            }
+            return result
+          }
+
           const maxLine = Math.max(0, lines.length - displayRows)
           if (currentLine > maxLine) {
             currentLine = maxLine
@@ -102,6 +137,11 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
             currentLine = 0
           }
 
+          const maxLineLength = Math.max(...lines.map(l => stripAnsi(l).length), 0)
+          const maxHorizontalOffset = Math.max(0, maxLineLength - cols)
+          if (horizontalOffset > maxHorizontalOffset) horizontalOffset = maxHorizontalOffset
+          if (horizontalOffset < 0) horizontalOffset = 0
+
           if (linesRendered > 0) {
             terminal.write(ansi.cursor.up(linesRendered))
           }
@@ -111,7 +151,7 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           
           for (let i = currentLine; i < endLine; i++) {
             terminal.write(ansi.erase.inLine(2))
-            const line = lines[i] || ''
+            const line = getVisibleSlice(lines[i] || '', horizontalOffset)
             terminal.write(line)
             linesRendered++
             if (i < endLine - 1) {
@@ -129,7 +169,7 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           const statusLine = `-- ${currentLine + 1}-${endLine} / ${lines.length} (${percentage}%)`
           terminal.write('\n')
           terminal.write(ansi.erase.inLine(2))
-          terminal.write(statusLine)
+          terminal.write(getVisibleSlice(statusLine, 0))
           linesRendered++
         }
 
@@ -163,6 +203,14 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
                 currentLine++
                 render()
                 break
+              case 'ArrowLeft':
+                horizontalOffset = Math.max(0, horizontalOffset - Math.floor(terminal.cols / 2))
+                render()
+                break
+              case 'ArrowRight':
+                horizontalOffset += Math.floor(terminal.cols / 2)
+                render()
+                break
               case 'PageDown':
               case ' ':
                 currentLine = Math.min(currentLine + displayRows, Math.max(0, lines.length - displayRows))

package/src/commands/ls.ts

@@ -4,14 +4,14 @@ import columnify from 'columnify'
 import humanFormat from 'human-format'
 import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
 import { TerminalCommand } from '../shared/terminal-command.js'
-import { writelnStdout } from '../shared/helpers.js'
+import { writelnStdout, writelnStderr } from '../shared/helpers.js'
 
 function printUsage(process: Process | undefined, terminal: Terminal): void {
   const usage = `Usage: ls [OPTION]... [FILE]...
 List information about the FILEs (the current directory by default).
 
   --help  display this help and exit`
-  writelnStdout(process, terminal, usage)
+  writelnStderr(process, terminal, usage)
 }
 
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
@@ -29,12 +29,37 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         return 0
       }
 
-      const target = argv.length > 0 && argv[0] !== undefined && !argv[0].startsWith('-') ? argv[0] : shell.cwd
-      const fullPath = target ? path.resolve(shell.cwd, target === '' ? '.' : target) : shell.cwd
-      const stats = await shell.context.fs.promises.stat(fullPath)
-      const entries: string[] = stats.isDirectory() ? await shell.context.fs.promises.readdir(fullPath) : [fullPath]
+      // Filter out options/flags and get target paths
+      const targets = argv.length > 0 
+        ? argv.filter(arg => !arg.startsWith('-'))
+        : [shell.cwd]
+
+      if (targets.length === 0) targets.push(shell.cwd)
+
       const descriptions = kernel.filesystem.descriptions(kernel.i18n.t)
 
+      // Process each target and collect all entries
+      // We'll determine if each entry is a directory when we stat it later
+      const allEntries: Array<{ fullPath: string, entry: string }> = []
+      
+      for (const target of targets) {
+        const fullPath = path.resolve(shell.cwd, target === '' ? '.' : target)
+        try {
+          const stats = await shell.context.fs.promises.stat(fullPath)
+          if (stats.isDirectory()) {
+            // For directories, list all contents
+            const dirEntries = await shell.context.fs.promises.readdir(fullPath)
+            for (const entry of dirEntries) allEntries.push({ fullPath, entry })
+          } else {
+            // For files, add the file itself
+            allEntries.push({ fullPath: path.dirname(fullPath), entry: path.basename(fullPath) })
+          }
+        } catch {
+          // If target doesn't exist, skip it (standard ls behavior)
+          continue
+        }
+      }
+
       const getModeType = (stats: Awaited<ReturnType<typeof shell.context.fs.promises.stat>>) => {
         let type = '-'
         if (stats.isDirectory()) type = 'd'
@@ -85,9 +110,9 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         return ''
       }
 
-      const filesMap = await Promise.all(entries
-        .map(async entry => {
-          const target = path.resolve(fullPath, entry)
+      const filesMap = await Promise.all(allEntries
+        .map(async ({ fullPath: entryFullPath, entry }) => {
+          const target = path.resolve(entryFullPath, entry)
           try {
             let linkTarget: string | null = null
             let linkStats = null
@@ -119,9 +144,9 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         .filter(entry => entry && entry.stats && !entry.stats.isDirectory())
         .filter((entry): entry is NonNullable<typeof entry> => entry !== null && entry !== undefined)
 
-      const directoryMap = await Promise.all(entries
-        .map(async entry => {
-          const target = path.resolve(fullPath, entry)
+      const directoryMap = await Promise.all(allEntries
+        .map(async ({ fullPath: entryFullPath, entry }) => {
+          const target = path.resolve(entryFullPath, entry)
           try {
             let linkTarget: string | null = null
             let linkStats = null
@@ -154,7 +179,8 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         .filter((entry, index, self) => self.findIndex(e => e?.name === entry?.name) === index)
         .filter((entry): entry is NonNullable<typeof entry> => entry !== null && entry !== undefined)
 
-      const isDevDirectory = fullPath.startsWith('/dev')
+      // Check if any entry is in /dev directory
+      const isDevDirectory = allEntries.some(e => e.fullPath.startsWith('/dev'))
       const columns = isDevDirectory ? ['Name', 'Mode', 'Owner', 'Info'] : ['Name', 'Size', 'Modified', 'Mode', 'Owner', 'Info']
 
       const directoryRows = directories.sort((a, b) => a.name.localeCompare(b.name)).map(directory => {
@@ -209,7 +235,7 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           const linkInfo = getLinkInfo(file.linkTarget, file.linkStats, file.stats)
           if (linkInfo) return linkInfo
           
-          if (descriptions.has(path.resolve(fullPath, file.name))) return descriptions.get(path.resolve(fullPath, file.name)) || ''
+          if (descriptions.has(file.target)) return descriptions.get(file.target) || ''
           if (file.name.includes('.')) {
             const ext = file.name.split('.').pop()
             if (ext && descriptions.has('.' + ext)) return descriptions.get('.' + ext) || ''