@ecmaos/coreutils 0.5.1 → 0.5.3

package/src/commands/ls.ts

@@ -5,7 +5,6 @@ import humanFormat from 'human-format'
 import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
 import { TerminalCommand } from '../shared/terminal-command.js'
 import { writelnStdout, writelnStderr } from '../shared/helpers.js'
-import { CoreutilsDescriptions } from '../index.js'
 
 function printUsage(process: Process | undefined, terminal: Terminal): void {
   const usage = `Usage: ls [OPTION]... [FILE]...
@@ -64,8 +63,6 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
 
       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 }> = []
@@ -138,6 +135,8 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         return ''
       }
 
+      const descriptions = kernel.filesystem.descriptions(kernel.i18n.ns.filesystem)
+
       const filesMap = await Promise.all(allEntries
         .map(async ({ fullPath: entryFullPath, entry }) => {
           const target = path.resolve(entryFullPath, entry)
@@ -209,7 +208,9 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
 
       // 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 columns = isDevDirectory
+        ? [kernel.i18n.ns.common('Name'), kernel.i18n.ns.common('Mode'), kernel.i18n.ns.common('Owner'), kernel.i18n.ns.common('Info')]
+        : [kernel.i18n.ns.common('Name'), kernel.i18n.ns.common('Size'), kernel.i18n.ns.common('Modified'), kernel.i18n.ns.common('Mode'), kernel.i18n.ns.common('Owner'), kernel.i18n.ns.common('Info')]
 
       const directoryRows = directories.sort((a, b) => a.name.localeCompare(b.name)).map(directory => {
         const displayName = directory.linkTarget
@@ -229,15 +230,15 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           : chalk.green(displayName)
 
         const row: Record<string, string> = {
-          Name: coloredName,
-          Mode: chalk.gray(modeString),
-          Owner: directory.stats ? chalk.gray(getOwnerString(directory.stats)) : '',
-          Info: truncateInfo(chalk.gray(linkInfo))
+          [kernel.i18n.ns.common('Name')]: coloredName,
+          [kernel.i18n.ns.common('Mode')]: chalk.gray(modeString),
+          [kernel.i18n.ns.common('Owner')]: directory.stats ? chalk.gray(getOwnerString(directory.stats)) : '',
+          [kernel.i18n.ns.common('Info')]: truncateInfo(chalk.gray(linkInfo))
         }
 
         if (!isDevDirectory) {
-          row.Size = ''
-          row.Modified = directory.stats ? chalk.gray(getTimestampString(directory.stats.mtime)) : ''
+          row[kernel.i18n.ns.common('Size')] = ''
+          row[kernel.i18n.ns.common('Modified')] = directory.stats ? chalk.gray(getTimestampString(directory.stats.mtime)) : ''
         }
 
         return row
@@ -263,11 +264,13 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           const linkInfo = getLinkInfo(file.linkTarget, file.linkStats, file.stats)
           if (linkInfo) return linkInfo
           
-          // Check if this is a command in /bin/ and use CoreutilsDescriptions
+          // Check if this is a command in /bin/ and use coreutils translations
           if (file.target.startsWith('/bin/')) {
             const commandName = path.basename(file.target)
-            if (commandName in CoreutilsDescriptions) {
-              return CoreutilsDescriptions[commandName as keyof typeof CoreutilsDescriptions]
+            const translatedDescription = kernel.i18n.ns.coreutils(commandName)
+            // Only use translation if it exists (i18next returns the key if translation is missing)
+            if (translatedDescription !== commandName) {
+              return translatedDescription
             }
           }
           
@@ -278,22 +281,25 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           }
           if (!file.stats) return ''
           if (file.stats.isBlockDevice() || file.stats.isCharacterDevice()) {
-            // TODO: zenfs `fs.mounts` is deprecated - use a better way of getting device info
+            const devicePackage = kernel.devices.get(path.basename(file.target))
+            const description = devicePackage?.device?.pkg?.description || ''
+            const hasCLI = devicePackage?.device?.cli !== undefined
+            return `${description}${hasCLI ? ' ' + `${chalk.bold(`(${kernel.i18n.t('CLI')})`)}${chalk.reset()}` : ''}`
           }
 
           return ''
         })()
 
         const row: Record<string, string> = {
-          Name: coloredName,
-          Mode: chalk.gray(modeString),
-          Owner: file.stats ? chalk.gray(getOwnerString(file.stats)) : '',
-          Info: truncateInfo(chalk.gray(info))
+          [kernel.i18n.ns.common('Name')]: coloredName,
+          [kernel.i18n.ns.common('Mode')]: chalk.gray(modeString),
+          [kernel.i18n.ns.common('Owner')]: file.stats ? chalk.gray(getOwnerString(file.stats)) : '',
+          [kernel.i18n.ns.common('Info')]: truncateInfo(chalk.gray(info))
         }
 
         if (!isDevDirectory) {
-          row.Size = file.stats ? chalk.gray(humanFormat(file.stats.size)) : ''
-          row.Modified = file.stats ? chalk.gray(getTimestampString(file.stats.mtime)) : ''
+          row[kernel.i18n.ns.common('Size')] = file.stats ? chalk.gray(humanFormat(file.stats.size)) : ''
+          row[kernel.i18n.ns.common('Modified')] = file.stats ? chalk.gray(getTimestampString(file.stats.mtime)) : ''
         }
 
         return row

package/src/commands/mkdir.ts

@@ -1,16 +1,31 @@
 import path from 'path'
 import type { Kernel, Process, Shell, Terminal } from '@ecmaos/types'
 import { TerminalCommand } from '../shared/terminal-command.js'
-import { writelnStderr } from '../shared/helpers.js'
+import { writelnStderr, writelnStdout } from '../shared/helpers.js'
 
 function printUsage(process: Process | undefined, terminal: Terminal): void {
   const usage = `Usage: mkdir [OPTION]... DIRECTORY...
 Create the DIRECTORY(ies), if they do not already exist.
 
-  --help  display this help and exit`
+Mandatory arguments to long options are mandatory for short options too.
+  -m, --mode=MODE   set file mode (as in chmod), not a=rwx - umask
+  -p, --parents     no error if existing, make parent directories as needed,
+                    with their file modes unaffected by any -m option.
+  -v, --verbose     print a message for each created directory
+      --help        display this help and exit`
   writelnStderr(process, terminal, usage)
 }
 
+function parseNumericMode(mode: string): number | null {
+  if (/^0?[0-7]{1,4}$/.test(mode)) {
+    return parseInt(mode, 8)
+  }
+  if (/^0o[0-7]{1,4}$/i.test(mode)) {
+    return parseInt(mode.slice(2), 8)
+  }
+  return null
+}
+
 export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal): TerminalCommand {
   return new TerminalCommand({
     command: 'mkdir',
@@ -26,7 +41,104 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         return 0
       }
 
-      if (argv.length === 0) {
+      let parents = false
+      let verbose = false
+      let mode: number | undefined = undefined
+      const directories: string[] = []
+
+      let i = 0
+      while (i < argv.length) {
+        const arg = argv[i]
+        if (!arg) {
+          i++
+          continue
+        }
+
+        if (arg === '--') {
+          i++
+          while (i < argv.length) {
+            const dirArg = argv[i]
+            if (dirArg) {
+              directories.push(dirArg)
+            }
+            i++
+          }
+          break
+        }
+
+        if (arg.startsWith('--')) {
+          if (arg === '--parents') {
+            parents = true
+          } else if (arg === '--verbose') {
+            verbose = true
+          } else if (arg.startsWith('--mode=')) {
+            const modeStr = arg.slice(7)
+            const parsedMode = parseNumericMode(modeStr)
+            if (parsedMode === null) {
+              await writelnStderr(process, terminal, `mkdir: invalid mode '${modeStr}'`)
+              return 1
+            }
+            mode = parsedMode
+          } else if (arg === '--help' || arg === '-h') {
+            printUsage(process, terminal)
+            return 0
+          } else {
+            await writelnStderr(process, terminal, `mkdir: unrecognized option '${arg}'`)
+            await writelnStderr(process, terminal, "Try 'mkdir --help' for more information.")
+            return 1
+          }
+        } else if (arg.startsWith('-') && arg.length > 1) {
+          for (let j = 1; j < arg.length; j++) {
+            const flag = arg[j]
+            if (!flag) continue
+
+            if (flag === 'p') {
+              parents = true
+            } else if (flag === 'v') {
+              verbose = true
+            } else if (flag === 'm') {
+              if (j + 1 < arg.length) {
+                const modeStr = arg.slice(j + 1)
+                const parsedMode = parseNumericMode(modeStr)
+                if (parsedMode === null) {
+                  await writelnStderr(process, terminal, `mkdir: invalid mode '${modeStr}'`)
+                  return 1
+                }
+                mode = parsedMode
+                break
+              } else if (i + 1 < argv.length) {
+                const modeStr = argv[i + 1]
+                if (!modeStr) {
+                  await writelnStderr(process, terminal, "mkdir: option requires an argument -- 'm'")
+                  await writelnStderr(process, terminal, "Try 'mkdir --help' for more information.")
+                  return 1
+                }
+                const parsedMode = parseNumericMode(modeStr)
+                if (parsedMode === null) {
+                  await writelnStderr(process, terminal, `mkdir: invalid mode '${modeStr}'`)
+                  return 1
+                }
+                mode = parsedMode
+                i++
+                break
+              } else {
+                await writelnStderr(process, terminal, "mkdir: option requires an argument -- 'm'")
+                await writelnStderr(process, terminal, "Try 'mkdir --help' for more information.")
+                return 1
+              }
+            } else {
+              await writelnStderr(process, terminal, `mkdir: invalid option -- '${flag}'`)
+              await writelnStderr(process, terminal, "Try 'mkdir --help' for more information.")
+              return 1
+            }
+          }
+        } else {
+          directories.push(arg)
+        }
+        i++
+      }
+
+      if (directories.length === 0) {
         await writelnStderr(process, terminal, 'mkdir: missing operand')
         await writelnStderr(process, terminal, "Try 'mkdir --help' for more information.")
         return 1
@@ -34,17 +146,45 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
 
       let hasError = false
 
-      for (const target of argv) {
-        if (!target || target.startsWith('-')) continue
+      for (const target of directories) {
+        if (!target) continue
 
-        const fullPath = target ? path.resolve(shell.cwd, target) : shell.cwd
+        const fullPath = path.resolve(shell.cwd, target)
         
         try {
-          await shell.context.fs.promises.mkdir(fullPath)
+          const mkdirOptions: { recursive?: boolean; mode?: number } = {}
+          if (parents) {
+            mkdirOptions.recursive = true
+          }
+          if (mode !== undefined) {
+            mkdirOptions.mode = mode
+          }
+
+          let existedBefore = false
+          if (parents) {
+            try {
+              await shell.context.fs.promises.stat(fullPath)
+              existedBefore = true
+            } catch {
+              existedBefore = false
+            }
+          }
+
+          await shell.context.fs.promises.mkdir(fullPath, mkdirOptions)
+
+          if (verbose && !existedBefore) {
+            const relativePath = path.relative(shell.cwd, fullPath) || target
+            await writelnStdout(process, terminal, `mkdir: created directory '${relativePath}'`)
+          }
         } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error)
-          await writelnStderr(process, terminal, `mkdir: ${target}: ${errorMessage}`)
-          hasError = true
+          const err = error as { code?: string; message?: string }
+          if (parents && err.code === 'EEXIST') {
+            continue
+          } else {
+            const errorMessage = error instanceof Error ? error.message : String(error)
+            await writelnStderr(process, terminal, `mkdir: ${target}: ${errorMessage}`)
+            hasError = true
+          }
         }
       }
 

package/src/commands/sed.ts

@@ -236,9 +236,9 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
         const trimmed = arg.trim()
         return (
           trimmed.startsWith('s/') ||
-          trimmed.startsWith('/') ||
-          /^\d+[sd]/.test(trimmed) ||
-          /^\d+,\d*[sd]/.test(trimmed) ||
+          /^\/.+?\/[dp]$/.test(trimmed) ||
+          /^\d+[sd]$/.test(trimmed) ||
+          /^\d+,\d*[sd]$/.test(trimmed) ||
           /^\d+s\//.test(trimmed) ||
           /^\d+,\d*s\//.test(trimmed)
         )
@@ -341,73 +341,6 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           return content.split('\n')
         }
 
-        let inputLines: string[] = []
-
-        if (files.length > 0) {
-          for (const file of files) {
-            const expandedPath = shell.expandTilde(file)
-            const fullPath = path.resolve(shell.cwd, expandedPath)
-            const lines = await processFile(fullPath)
-            inputLines.push(...lines)
-            if (lines.length > 0 && inputLines.length > lines.length) {
-              inputLines.push('')
-            }
-          }
-        } else {
-          if (!process.stdin) {
-            await writelnStderr(process, terminal, 'sed: No input provided')
-            return 1
-          }
-
-          const reader = process.stdin.getReader()
-          const decoder = new TextDecoder()
-          const chunks: string[] = []
-
-          try {
-            while (true) {
-              const { done, value } = await reader.read()
-              if (done) break
-              chunks.push(decoder.decode(value, { stream: true }))
-            }
-            chunks.push(decoder.decode(new Uint8Array(), { stream: false }))
-          } finally {
-            reader.releaseLock()
-          }
-
-          const content = chunks.join('')
-          inputLines = content.split('\n')
-        }
-
-        const outputLines: string[] = []
-        const totalLines = inputLines.length
-
-        for (let i = 0; i < inputLines.length; i++) {
-          let line = inputLines[i] || ''
-          let lineNum = i + 1
-          let shouldPrint = false
-
-          for (const command of commands) {
-            const { result, shouldPrint: print } = applySedCommand(line, lineNum, totalLines, command)
-            if (result === null) {
-              line = null as unknown as string
-              break
-            }
-            line = result
-            if (print) {
-              shouldPrint = true
-            }
-          }
-
-          if (line !== null) {
-            outputLines.push(line)
-            if (shouldPrint && !quiet) {
-              outputLines.push(line)
-            }
-          }
-        }
-
-        const output = outputLines.join('\n')
-
         if (inplace !== undefined && files.length > 0) {
           for (const file of files) {
             const expandedPath = shell.expandTilde(file)
@@ -455,6 +388,72 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
             await shell.context.fs.promises.writeFile(fullPath, fileOutput)
           }
         } else {
+          let inputLines: string[] = []
+
+          if (files.length > 0) {
+            for (const file of files) {
+              const expandedPath = shell.expandTilde(file)
+              const fullPath = path.resolve(shell.cwd, expandedPath)
+              const lines = await processFile(fullPath)
+              inputLines.push(...lines)
+              if (lines.length > 0 && inputLines.length > lines.length) {
+                inputLines.push('')
+              }
+            }
+          } else {
+            if (!process.stdin) {
+              await writelnStderr(process, terminal, 'sed: No input provided')
+              return 1
+            }
+
+            const reader = process.stdin.getReader()
+            const decoder = new TextDecoder()
+            const chunks: string[] = []
+
+            try {
+              while (true) {
+                const { done, value } = await reader.read()
+                if (done) break
+                chunks.push(decoder.decode(value, { stream: true }))
+              }
+              chunks.push(decoder.decode(new Uint8Array(), { stream: false }))
+            } finally {
+              reader.releaseLock()
+            }
+
+            const content = chunks.join('')
+            inputLines = content.split('\n')
+          }
+
+          const outputLines: string[] = []
+          const totalLines = inputLines.length
+
+          for (let i = 0; i < inputLines.length; i++) {
+            let line = inputLines[i] || ''
+            let lineNum = i + 1
+            let shouldPrint = false
+
+            for (const command of commands) {
+              const { result, shouldPrint: print } = applySedCommand(line, lineNum, totalLines, command)
+              if (result === null) {
+                line = null as unknown as string
+                break
+              }
+              line = result
+              if (print) {
+                shouldPrint = true
+              }
+            }
+
+            if (line !== null) {
+              outputLines.push(line)
+              if (shouldPrint && !quiet) {
+                outputLines.push(line)
+              }
+            }
+          }
+
+          const output = outputLines.join('\n')
           await writer.write(new TextEncoder().encode(output))
         }
 

package/src/commands/view.ts

@@ -306,7 +306,6 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
           }
 
           // Read file
-          await writelnStdout(process, terminal, chalk.blue(`Loading: ${file}...`))
           const fileData = await shell.context.fs.promises.readFile(fullPath)
           const fileType = detectFileType(fullPath)
           const mimeType = getMimeType(fullPath, fileType)
@@ -374,8 +373,6 @@ export function createCommand(kernel: Kernel, shell: Shell, terminal: Terminal):
             })
             
             win.mount(container)
-
-            await writelnStdout(process, terminal, chalk.green(`Viewing: ${file}`))
           } else if (fileType === 'json') {
             // Read and parse JSON file
             const jsonText = new TextDecoder().decode(fileData)

package/src/index.ts

@@ -61,6 +61,7 @@ import { createCommand as createColumn } from './commands/column.js'
 import { createCommand as createComm } from './commands/comm.js'
 import { createCommand as createCurl } from './commands/curl.js'
 import { createCommand as createCut } from './commands/cut.js'
+import { createCommand as createDd } from './commands/dd.js'
 import { createCommand as createDate } from './commands/date.js'
 import { createCommand as createDiff } from './commands/diff.js'
 import { createCommand as createDirname } from './commands/dirname.js'
@@ -98,6 +99,7 @@ import { createCommand as createZip } from './commands/zip.js'
 import { createCommand as createUnzip } from './commands/unzip.js'
 import { createCommand as createVideo } from './commands/video.js'
 import { createCommand as createView } from './commands/view.js'
+import { createCommand as createGit } from './commands/git.js'
 
 // Export individual command factories
 export { createCommand as createCat } from './commands/cat.js'
@@ -147,6 +149,7 @@ export { createCommand as createCmp } from './commands/cmp.js'
 export { createCommand as createColumn } from './commands/column.js'
 export { createCommand as createCurl } from './commands/curl.js'
 export { createCommand as createCut } from './commands/cut.js'
+export { createCommand as createDd } from './commands/dd.js'
 export { createCommand as createDate } from './commands/date.js'
 export { createCommand as createDiff } from './commands/diff.js'
 export { createCommand as createDirname } from './commands/dirname.js'
@@ -172,6 +175,7 @@ export { createCommand as createZip } from './commands/zip.js'
 export { createCommand as createUnzip } from './commands/unzip.js'
 export { createCommand as createVideo } from './commands/video.js'
 export { createCommand as createView } from './commands/view.js'
+export { createCommand as createGit } from './commands/git.js'
 
 /**
  * Creates all coreutils commands.
@@ -233,6 +237,7 @@ export function createAllCommands(kernel: Kernel, shell: Shell, terminal: Termin
     comm: createComm(kernel, shell, terminal),
     curl: createCurl(kernel, shell, terminal),
     cut: createCut(kernel, shell, terminal),
+    dd: createDd(kernel, shell, terminal),
     date: createDate(kernel, shell, terminal),
     diff: createDiff(kernel, shell, terminal),
     dirname: createDirname(kernel, shell, terminal),
@@ -269,103 +274,10 @@ export function createAllCommands(kernel: Kernel, shell: Shell, terminal: Termin
     zip: createZip(kernel, shell, terminal),
     unzip: createUnzip(kernel, shell, terminal),
     video: createVideo(kernel, shell, terminal),
-    view: createView(kernel, shell, terminal)
+    view: createView(kernel, shell, terminal),
+    git: createGit(kernel, shell, terminal)
   }
 }
 
 // For backward compatibility, export as TerminalCommands
 export { createAllCommands as TerminalCommands }
-
-export const CoreutilsDescriptions = {
-  awk: 'Pattern scanning and text processing language',
-  basename: 'Strip directory and suffix from filenames',
-  cal: 'Display a calendar',
-  cat: 'Concatenate files and print on the standard output',
-  cd: 'Change the shell working directory',
-  chmod: 'Change file mode bits',
-  chown: 'Change file owner and group',
-  cksum: 'Print CRC checksum and byte count',
-  cmp: 'Compare two files byte by byte',
-  column: 'Format input into columns',
-  comm: 'Compare two sorted files line by line',
-  cp: 'Copy files',
-  cron: 'Manage scheduled tasks (crontabs)',
-  curl: 'Transfer data from or to a server',
-  cut: 'Remove sections from each line of files',
-  date: 'Print or set the system date and time',
-  diff: 'Compare files line by line',
-  dirname: 'Strip last component from file path',
-  echo: 'Print arguments to the standard output',
-  env: 'Run a program in a modified environment',
-  expand: 'Convert tabs to spaces',
-  factor: 'Print prime factors of numbers',
-  false: 'Return an unsuccessful exit status',
-  fetch: 'Fetch a resource from the network',
-  find: 'Search for files in a directory hierarchy',
-  fmt: 'Reformat paragraph text',
-  fold: 'Wrap each input line to fit in specified width',
-  format: 'Delete all IndexedDB and localStorage data',
-  grep: 'Search for patterns in files or standard input',
-  groups: 'Print the groups a user belongs to',
-  hash: 'Compute and display hash values for files or standard input',
-  head: 'Print the first lines of files',
-  hostname: 'Print the system hostname',
-  id: 'Print user and group IDs',
-  join: 'Join lines of two files on a common field',
-  less: 'View file contents interactively',
-  ln: 'Create links between files',
-  ls: 'List directory contents',
-  man: 'Display manual pages',
-  mkdir: 'Create a directory',
-  mktemp: 'Create a temporary file or directory',
-  mount: 'Mount a filesystem',
-  mv: 'Move or rename files',
-  nc: 'Network utilities',
-  nl: 'Number lines of files',
-  od: 'Dump files in octal and other formats',
-  open: 'Open a file or URL',
-  passkey: 'Manage passkey credentials for WebAuthn authentication',
-  paste: 'Merge lines of files',
-  play: 'Play an audio file',
-  pr: 'Paginate or columnate files for printing',
-  printf: 'Format and print data',
-  pwd: 'Print the shell working directory',
-  readlink: 'Print value of a symbolic link or canonical file name',
-  realpath: 'Print the resolved absolute file name',
-  rev: 'Reverse the characters of each line',
-  rm: 'Remove files or directories',
-  rmdir: 'Remove a directory',
-  sed: 'Stream editor for filtering and transforming text',
-  seq: 'Print a sequence of numbers',
-  shuf: 'Write a random permutation of the input lines',
-  sleep: 'Delay for a specified amount of time',
-  sockets: 'Manage socket connections (WebSocket and WebTransport)',
-  sort: 'Sort lines of text files',
-  split: 'Split a file into pieces',
-  stat: 'Display information about a file or directory',
-  strings: 'Print the sequences of printable characters in files',
-  tac: 'Write FILE in reverse line order',
-  tail: 'Print the last lines of files',
-  tar: 'Create, extract, or list tar archives',
-  tee: 'Read from standard input and write to standard output and files',
-  test: 'Check file types and compare values',
-  time: 'Measure command execution time',
-  touch: 'Create an empty file',
-  tr: 'Translate or delete characters',
-  true: 'Return a successful exit status',
-  umount: 'Unmount a filesystem',
-  uname: 'Print system information',
-  unexpand: 'Convert spaces to tabs',
-  uniq: 'Report or omit repeated lines',
-  unzip: 'Extract zip archives',
-  uptime: 'Print how long the system has been running',
-  user: 'Manage users on the system',
-  video: 'Play a video file',
-  view: 'View files in a new window (PDF, images, audio, video)',
-  wc: 'Print newline, word, and byte counts for each file',
-  web: 'Open a URL in a browser window',
-  which: 'Locate a command',
-  whoami: 'Print effective user ID',
-  xxd: 'Display file contents or stdin in hexadecimal format',
-  zip: 'Create zip archives'
-}