fauxnix-cli 0.7.1 → 0.9.0

package/dist/commands/files.js

@@ -1,5 +1,5 @@
-import { wordToString } from '../ast.js';
-import { parseWords, psStr } from '../registry.js';
+import { FauxnixParseError, wordToString } from '../ast.js';
+import { parseWords, psStr, } from '../registry.js';
 import { argListExpr, exprOfWord, operandExpr } from '../translator.js';
 /* ------------------------------------------------------------------ */
 /* Shared PS snippets                                                  */
@@ -51,8 +51,8 @@ function psArray(words, fn = operandExpr) {
 /* ls                                                                  */
 /* ------------------------------------------------------------------ */
 const ls = (args) => {
-    const { flags, longs, operandWords } = parseWords(args);
-    const long = flags.has('l') || longs.has('--format=long') || longs.has('--long');
+    const { flags, longs, values, operandWords } = parseWords(args, [], ['--format']);
+    const long = flags.has('l') || longs.has('--long') || values.get('--format') === 'long';
     const all = flags.has('a') || longs.has('--all');
     const almost = flags.has('A') || longs.has('--almost-all');
     const dirOnly = flags.has('d') || longs.has('--directory');
@@ -124,6 +124,7 @@ const cp = (args) => {
     const { flags, longs, operandWords } = parseWords(args);
     const recurse = flags.has('r') || flags.has('R') || longs.has('--recursive');
     const verbose = flags.has('v') || longs.has('--verbose');
+    const noclobber = flags.has('n') || longs.has('--no-clobber');
     return [
         PS_GLOB_FN,
         '$fx_all = ' + argListExpr(operandWords),
@@ -138,6 +139,7 @@ const cp = (args) => {
         '      if ($fx_isdir -and ' + (recurse ? '$false' : '$true') + ') { [Console]::Error.WriteLine("cp: -r not specified; omitting directory \'" + $fx_g + "\'"); $script:fx_exit = 1; continue }',
         '      $fx_target = $fx_dst',
         '      if (Test-Path -LiteralPath $fx_dst -PathType Container) { $fx_target = Join-Path $fx_dst (Split-Path $fx_g -Leaf) }',
+        '      if (' + (noclobber ? '$true' : '$false') + ' -and (Test-Path -LiteralPath $fx_target)) { continue }',
         '      try {',
         '        Copy-Item -LiteralPath $fx_g -Destination $fx_target -Recurse:' + (recurse ? '$true' : '$false') + ' -Force',
         '        if (' + (verbose ? '$true' : '$false') + ') { [Console]::Error.WriteLine("\'" + $fx_g + "\' -> \'" + $fx_target + "\'") }',
@@ -150,6 +152,7 @@ const cp = (args) => {
 const mv = (args) => {
     const { flags, longs, operandWords } = parseWords(args);
     const verbose = flags.has('v') || longs.has('--verbose');
+    const noclobber = flags.has('n') || longs.has('--no-clobber');
     return [
         PS_GLOB_FN,
         '$fx_all = ' + argListExpr(operandWords),
@@ -163,6 +166,7 @@ const mv = (args) => {
         '      if (-not (Test-Path -LiteralPath $fx_g)) { [Console]::Error.WriteLine("mv: cannot stat \'" + $fx_g + "\': No such file or directory"); $script:fx_exit = 1; continue }',
         '      $fx_target = $fx_dst',
         '      if (Test-Path -LiteralPath $fx_dst -PathType Container) { $fx_target = Join-Path $fx_dst (Split-Path $fx_g -Leaf) }',
+        '      if (' + (noclobber ? '$true' : '$false') + ' -and (Test-Path -LiteralPath $fx_target)) { continue }',
         '      try {',
         '        if (Test-Path -LiteralPath $fx_target) { Remove-Item -LiteralPath $fx_target -Recurse -Force }',
         '        Move-Item -LiteralPath $fx_g -Destination $fx_target -Force',
@@ -177,7 +181,7 @@ const rm = (args) => {
     const { flags, longs, operandWords } = parseWords(args);
     const recurse = flags.has('r') || flags.has('R') || longs.has('--recursive');
     const force = flags.has('f') || longs.has('--force');
-    const verbose = flags.has('v');
+    const verbose = flags.has('v') || longs.has('--verbose');
     return [
         PS_GLOB_FN,
         '$fx_files = ' + psArray(operandWords),
@@ -204,7 +208,7 @@ const rm = (args) => {
 const mkdir = (args) => {
     const { flags, longs, operandWords } = parseWords(args);
     const parents = flags.has('p') || longs.has('--parents');
-    const verbose = flags.has('v');
+    const verbose = flags.has('v') || longs.has('--verbose');
     return [
         '$fx_dirs = ' + psArray(operandWords),
         "if ($fx_dirs.Count -eq 0) { [Console]::Error.WriteLine('mkdir: missing operand'); $script:fx_exit = 1 }",
@@ -233,7 +237,8 @@ const rmdir = (args) => {
     ].join('\n');
 };
 const touch = (args) => {
-    const { operandWords } = parseWords(args);
+    const { flags, longs, operandWords } = parseWords(args);
+    const noCreate = flags.has('c') || longs.has('--no-create');
     return [
         '$fx_files = ' + psArray(operandWords),
         "if ($fx_files.Count -eq 0) { [Console]::Error.WriteLine('touch: missing file operand'); $script:fx_exit = 1 }",
@@ -241,6 +246,7 @@ const touch = (args) => {
         '  if (Test-Path -LiteralPath $fx_f) {',
         '    try { (Get-Item -LiteralPath $fx_f).LastWriteTime = Get-Date } catch { [Console]::Error.WriteLine("touch: cannot touch \'" + $fx_f + "\': Permission denied"); $script:fx_exit = 1 }',
         '  } else {',
+        '    if (' + (noCreate ? '$true' : '$false') + ') { continue }',
         '    try { New-Item -ItemType File -Path $fx_f | Out-Null }',
         '    catch { [Console]::Error.WriteLine("touch: cannot touch \'" + $fx_f + "\': No such file or directory"); $script:fx_exit = 1 }',
         '  }',
@@ -248,8 +254,8 @@ const touch = (args) => {
     ].join('\n');
 };
 const mktemp = (args) => {
-    const { flags } = parseWords(args);
-    const dir = flags.has('d');
+    const { flags, longs } = parseWords(args);
+    const dir = flags.has('d') || longs.has('--directory');
     return [
         'try {',
         '  if (' + (dir ? '$true' : '$false') + ') {',
@@ -266,8 +272,8 @@ const mktemp = (args) => {
 /* ln / readlink / realpath                                            */
 /* ------------------------------------------------------------------ */
 const ln = (args) => {
-    const { flags, operandWords } = parseWords(args);
-    const sym = flags.has('s');
+    const { flags, longs, operandWords } = parseWords(args);
+    const sym = flags.has('s') || longs.has('--symbolic');
     const kind = sym ? 'SymbolicLink' : 'HardLink';
     const label = sym ? 'symbolic link' : 'hard link';
     return [
@@ -282,8 +288,8 @@ const ln = (args) => {
     ].join('\n');
 };
 const readlink = (args) => {
-    const { flags, operandWords } = parseWords(args);
-    const canon = flags.has('f');
+    const { flags, longs, operandWords } = parseWords(args);
+    const canon = flags.has('f') || longs.has('--canonicalize');
     return [
         '$fx_p = ' + (operandWords.length ? operandExpr(operandWords[0]) : "''"),
         "if ($fx_p -eq '') { [Console]::Error.WriteLine('readlink: missing operand'); $script:fx_exit = 1 }",
@@ -416,10 +422,31 @@ const file = (args) => {
 /* du / df                                                             */
 /* ------------------------------------------------------------------ */
 const du = (args) => {
-    const { flags, longs, operandWords } = parseWords(args, [], ['--max-depth']);
+    const { flags, longs, values, missingValue, operandWords } = parseWords(args, ['d'], ['--max-depth']);
     const sum = flags.has('s') || longs.has('--summarize');
     const human = flags.has('h') || longs.has('--human-readable');
+    if (missingValue.includes('-d') || missingValue.includes('--max-depth')) {
+        return ('[Console]::Error.WriteLine(' +
+            psStr("du: option requires an argument -- 'max-depth'") +
+            '); $script:fx_exit = 1');
+    }
+    const maxDepthRaw = values.get('-d') ?? values.get('--max-depth');
+    let maxDepth = null;
+    if (maxDepthRaw !== undefined) {
+        if (!/^\d+$/.test(maxDepthRaw)) {
+            return ('[Console]::Error.WriteLine(' +
+                psStr("du: invalid maximum depth '" + maxDepthRaw + "'") +
+                '); $script:fx_exit = 1');
+        }
+        maxDepth = parseInt(maxDepthRaw, 10);
+    }
+    if (sum && maxDepth !== null && maxDepth !== 0) {
+        return ('[Console]::Error.WriteLine(' +
+            psStr('du: summarizing conflicts with --max-depth=' + String(maxDepth)) +
+            '); $script:fx_exit = 1');
+    }
     const targets = operandWords.length ? argListExpr(operandWords) : "@('.')";
+    const onlyRoot = sum || maxDepth === 0;
     return [
         PS_HSIZE_FN,
         'function fx-size($p) {',
@@ -430,7 +457,7 @@ const du = (args) => {
         '$fx_ts = ' + targets,
         'foreach ($fx_t in $fx_ts) {',
         '  if (-not (Test-Path -LiteralPath $fx_t)) { [Console]::Error.WriteLine("du: cannot access \'" + $fx_t + "\': No such file or directory"); $script:fx_exit = 1; continue }',
-        '  if (' + (sum ? '$true' : '$false') + ') {',
+        '  if (' + (onlyRoot ? '$true' : '$false') + ') {',
         '    $fx_kb = fx-size $fx_t',
         '    if (' + (human ? '$true' : '$false') + ') { "{0}`t{1}" -f (fx-hsize ($fx_kb * 1KB)), $fx_t } else { "{0}`t{1}" -f $fx_kb, $fx_t }',
         '  } else {',
@@ -438,6 +465,11 @@ const du = (args) => {
         '    foreach ($fx_d in @(Get-ChildItem -LiteralPath $fx_t -Recurse -Force -Directory -ErrorAction SilentlyContinue)) {',
         '      $fx_kb = fx-size $fx_d.FullName',
         "      $fx_rel = './' + $fx_d.FullName.Substring($fx_root.Length).TrimStart('\\').Replace('\\', '/')",
+        maxDepth !== null && maxDepth > 0
+            ? "      $fx_ddepth = @($fx_rel.ToCharArray() | Where-Object { $_ -eq '/' }).Count; if ($fx_ddepth -gt " +
+                maxDepth +
+                ') { continue }'
+            : '',
         '      if (' + (human ? '$true' : '$false') + ') { "{0}`t{1}" -f (fx-hsize ($fx_kb * 1KB)), $fx_rel } else { "{0}`t{1}" -f $fx_kb, $fx_rel }',
         '    }',
         '    $fx_kb = fx-size $fx_t',
@@ -447,8 +479,8 @@ const du = (args) => {
     ].join('\n');
 };
 const df = (args) => {
-    const { flags } = parseWords(args);
-    const human = flags.has('h') || flags.has('H');
+    const { flags, longs } = parseWords(args);
+    const human = flags.has('h') || flags.has('H') || longs.has('--human-readable');
     return [
         PS_HSIZE_FN,
         '"Filesystem      Size  Used Avail Use% Mounted on"',
@@ -465,15 +497,215 @@ const df = (args) => {
         '}',
     ].join('\n');
 };
-/* ------------------------------------------------------------------ */
-/* find                                                                */
-/* ------------------------------------------------------------------ */
+function findFail(msg) {
+    throw new FauxnixParseError(msg);
+}
+function canStartFindFactor(t) {
+    return (t === '!' ||
+        t === '-not' ||
+        t === '(' ||
+        t === '-name' ||
+        t === '-iname' ||
+        t === '-type' ||
+        t === '-size' ||
+        t === '-mtime' ||
+        t === '-delete' ||
+        t === '-print' ||
+        t === '-maxdepth' ||
+        t === '-mindepth');
+}
+/** GNU find expression: `!` tightest, juxtaposition/`-a` next, `-o` loosest. */
+function parseFindPreds(preds) {
+    const plan = {
+        ast: { kind: 'true' },
+        maxDepth: null,
+        minDepth: null,
+        hasDelete: false,
+        hasPrint: false,
+        hasSize: false,
+    };
+    let i = 0;
+    const peek = () => (i < preds.length ? preds[i] : null);
+    const take = () => preds[i++];
+    const needArg = (opt) => {
+        if (i >= preds.length)
+            findFail("find: missing argument to '" + opt + "'");
+        return take();
+    };
+    const parsePrimary = () => {
+        const t = take();
+        if (t === '-name' || t === '-iname') {
+            return { kind: 'name', pat: needArg(t), ci: t === '-iname' };
+        }
+        if (t === '-type') {
+            const v = needArg(t);
+            if (v !== 'f' && v !== 'd' && v !== 'l')
+                findFail('find: Unknown argument to -type: ' + v);
+            return { kind: 'type', t: v };
+        }
+        if (t === '-size') {
+            const v = needArg(t);
+            const ps = sizeOf(v);
+            if (!ps)
+                findFail("find: Invalid argument '" + v + "' to -size");
+            plan.hasSize = true;
+            return { kind: 'size', ps };
+        }
+        if (t === '-mtime') {
+            const v = needArg(t);
+            const ps = mtimeOf(v);
+            if (!ps)
+                findFail("find: Invalid argument '" + v + "' to -mtime");
+            return { kind: 'mtime', ps };
+        }
+        if (t === '-delete') {
+            plan.hasDelete = true;
+            return { kind: 'delete' };
+        }
+        if (t === '-print') {
+            plan.hasPrint = true;
+            return { kind: 'print' };
+        }
+        if (t === '-maxdepth' || t === '-mindepth') {
+            const v = needArg(t);
+            if (!/^\d+$/.test(v)) {
+                findFail('find: expected a non-negative decimal integer argument to ' +
+                    t +
+                    ", but got '" +
+                    v +
+                    "'");
+            }
+            if (t === '-maxdepth' && plan.maxDepth === null)
+                plan.maxDepth = v;
+            if (t === '-mindepth' && plan.minDepth === null)
+                plan.minDepth = v;
+            return { kind: 'true' };
+        }
+        if (t.startsWith('-'))
+            findFail("find: unknown predicate '" + t + "'");
+        findFail("find: paths must precede expression: '" + t + "'");
+    };
+    const parseFactor = () => {
+        const t = peek();
+        if (t === null)
+            findFail('find: expected an expression');
+        if (t === '-o' || t === '-or' || t === '-a' || t === '-and') {
+            findFail("find: invalid expression; you have used a binary operator '" +
+                t +
+                "' with nothing before it.");
+        }
+        if (t === '!' || t === '-not') {
+            take();
+            if (peek() === null)
+                findFail("find: expected an expression after '" + t + "'");
+            if (peek() === ')')
+                findFail("find: expected an expression between '" + t + "' and ')'");
+            return { kind: 'not', inner: parseFactor() };
+        }
+        if (t === '(') {
+            take();
+            if (peek() === ')')
+                findFail('find: invalid expression; empty parentheses are not allowed.');
+            if (peek() === null) {
+                findFail("find: invalid expression; expected to find a ')' but didn't see one.");
+            }
+            const inner = parseOr();
+            if (peek() !== ')') {
+                findFail("find: invalid expression; expected to find a ')' but didn't see one.");
+            }
+            take();
+            return inner;
+        }
+        if (t === ')')
+            findFail("find: invalid expression; you have too many ')'");
+        return parsePrimary();
+    };
+    const parseAnd = () => {
+        let left = parseFactor();
+        while (true) {
+            const t = peek();
+            if (t === null || t === ')' || t === '-o' || t === '-or')
+                break;
+            if (t === '-a' || t === '-and') {
+                take();
+                if (peek() === null || peek() === ')') {
+                    findFail("find: expected an expression after '" + t + "'");
+                }
+                left = { kind: 'and', left, right: parseFactor() };
+                continue;
+            }
+            if (canStartFindFactor(t)) {
+                left = { kind: 'and', left, right: parseFactor() };
+                continue;
+            }
+            findFail("find: paths must precede expression: '" + t + "'");
+        }
+        return left;
+    };
+    const parseOr = () => {
+        let left = parseAnd();
+        while (peek() === '-o' || peek() === '-or') {
+            const op = take();
+            if (peek() === null || peek() === ')') {
+                findFail("find: expected an expression after '" + op + "'");
+            }
+            left = { kind: 'or', left, right: parseAnd() };
+        }
+        return left;
+    };
+    if (preds.length === 0) {
+        plan.ast = { kind: 'print' };
+        plan.hasPrint = true;
+        return plan;
+    }
+    plan.ast = parseOr();
+    if (i < preds.length) {
+        if (preds[i] === ')')
+            findFail("find: invalid expression; you have too many ')'");
+        findFail("find: paths must precede expression: '" + preds[i] + "'");
+    }
+    if (!plan.hasDelete && !plan.hasPrint) {
+        plan.ast = { kind: 'and', left: plan.ast, right: { kind: 'print' } };
+        plan.hasPrint = true;
+    }
+    return plan;
+}
+function emitFind(n) {
+    switch (n.kind) {
+        case 'true':
+            return '$true';
+        case 'and':
+            return '(' + emitFind(n.left) + ' -and ' + emitFind(n.right) + ')';
+        case 'or':
+            return '(' + emitFind(n.left) + ' -or ' + emitFind(n.right) + ')';
+        case 'not':
+            return '(-not ' + emitFind(n.inner) + ')';
+        case 'name':
+            if (n.ci)
+                return "($fx_i.Name.ToLower() -like '" + likeOf(n.pat).toLowerCase() + "')";
+            return "($fx_i.Name -clike '" + likeOf(n.pat) + "')";
+        case 'type':
+            if (n.t === 'f')
+                return '(-not $fx_i.PSIsContainer)';
+            if (n.t === 'd')
+                return '($fx_i.PSIsContainer)';
+            return '([bool]$fx_i.LinkType)';
+        case 'size':
+            return '(' + n.ps + ')';
+        case 'mtime':
+            return '(' + n.ps + ')';
+        case 'delete':
+            return '(fx-find-delete)';
+        case 'print':
+            return '(fx-find-print)';
+    }
+}
 const find = (args) => {
     const raw = args.map((w) => wordToString(w));
     let pathEnd = 0;
     while (pathEnd < raw.length &&
         !raw[pathEnd].startsWith('-') &&
-        !['(', ')', '!', '-a', '-o'].includes(raw[pathEnd])) {
+        !['(', ')', '!', '-a', '-o', '-not', '-and', '-or'].includes(raw[pathEnd])) {
         pathEnd++;
     }
     const pathWords = args.slice(0, pathEnd);
@@ -483,81 +715,41 @@ const find = (args) => {
             psStr('find: -exec is not supported by fauxnix; pipe into the command instead (e.g. `find . -name "*.log" | xargs rm`)') +
             '); $script:fx_exit = 1');
     }
-    const namePat = extractValue(preds, ['-name']);
-    const inamePat = extractValue(preds, ['-iname']);
-    const typeV = extractValue(preds, ['-type']);
-    const maxDepthS = extractValue(preds, ['-maxdepth']);
-    const minDepthS = extractValue(preds, ['-mindepth']);
-    const sizeExpr = extractValue(preds, ['-size']);
-    const mtimeExpr = extractValue(preds, ['-mtime']);
-    const wantDelete = preds.includes('-delete');
+    const plan = parseFindPreds(preds);
+    const expr = emitFind(plan.ast);
     const paths = pathWords.length ? argListExpr(pathWords) : "@('.')";
-    for (const option of ['-maxdepth', '-mindepth']) {
-        const optionIndex = preds.indexOf(option);
-        if (optionIndex < 0)
-            continue;
-        if (optionIndex + 1 >= preds.length) {
-            return ('[Console]::Error.WriteLine(' +
-                psStr(`find: missing argument to '${option}'`) +
-                '); $script:fx_exit = 1');
-        }
-        const value = preds[optionIndex + 1];
-        if (!/^\d+$/.test(value)) {
-            return ('[Console]::Error.WriteLine(' +
-                psStr(`find: expected a non-negative decimal integer argument to ${option}, but got '${value}'`) +
-                '); $script:fx_exit = 1');
-        }
-    }
-    const conditions = [];
-    if (namePat !== null)
-        conditions.push("($fx_i.Name -like '" + likeOf(namePat) + "')");
-    if (inamePat !== null)
-        conditions.push("($fx_i.Name.ToLower() -like '" + likeOf(inamePat).toLowerCase() + "')");
-    if (typeV === 'f')
-        conditions.push('(-not $fx_i.PSIsContainer)');
-    if (typeV === 'd')
-        conditions.push('($fx_i.PSIsContainer)');
-    if (typeV === 'l')
-        conditions.push('([bool]$fx_i.LinkType)');
-    const cond = conditions.length ? conditions.join(' -and ') : '$true';
-    const sizeCond = sizeOf(sizeExpr);
-    const mtimeCond = mtimeOf(mtimeExpr);
     return [
+        plan.hasPrint
+            ? 'function fx-find-print { $script:fx_find_print = $true; $true }'
+            : '',
+        plan.hasDelete
+            ? 'function fx-find-delete { try { Remove-Item -LiteralPath $fx_i.FullName -Force -ErrorAction SilentlyContinue | Out-Null } catch {}; $true }'
+            : '',
         '$fx_paths = ' + paths,
         'foreach ($fx_p in $fx_paths) {',
         '  if (-not (Test-Path -LiteralPath $fx_p)) { [Console]::Error.WriteLine("find: \'" + $fx_p + "\': No such file or directory"); $script:fx_exit = 1; continue }',
         '  $fx_root = (Get-Item -LiteralPath $fx_p -Force).FullName',
         '  $fx_all = @(Get-Item -LiteralPath $fx_p -Force)',
         '  $fx_all += @(Get-ChildItem -LiteralPath $fx_p -Recurse -Force -ErrorAction SilentlyContinue)',
+        plan.hasDelete ? '  [array]::Reverse($fx_all)' : '',
         '  foreach ($fx_i in $fx_all) {',
         "    $fx_rel = $fx_i.FullName.Substring($fx_root.Length).TrimStart('\\').Replace('\\', '/')",
         "    if ($fx_rel -eq '') { $fx_disp = $fx_p } else { $fx_disp = ($fx_p.TrimEnd('/') + '/' + $fx_rel) }",
         '    $fx_depth = 0; if ($fx_rel -ne \'\') { $fx_depth = 1; foreach ($fx_c in $fx_rel.ToCharArray()) { if ($fx_c -eq \'/\') { $fx_depth++ } } }',
-        '    if ($fx_depth -lt ' + (minDepthS ?? '0') + ') { continue }',
-        maxDepthS !== null ? '    if ($fx_depth -gt ' + maxDepthS + ') { continue }' : '',
-        '    if (-not (' + cond + ')) { continue }',
-        sizeCond ? '    $fx_sz = 0; if (-not $fx_i.PSIsContainer) { try { $fx_sz = $fx_i.Length } catch {} }' : '',
-        sizeCond ? '    if (-not (' + sizeCond + ')) { continue }' : '',
-        mtimeCond ? '    if (-not (' + mtimeCond + ')) { continue }' : '',
-        '    if (' + (wantDelete ? '$true' : '$false') + ') {',
-        '      try { Remove-Item -LiteralPath $fx_i.FullName -Recurse -Force -ErrorAction SilentlyContinue } catch {}',
-        '    } else {',
-        '      $fx_disp',
-        '    }',
+        '    if ($fx_depth -lt ' + (plan.minDepth ?? '0') + ') { continue }',
+        plan.maxDepth !== null ? '    if ($fx_depth -gt ' + plan.maxDepth + ') { continue }' : '',
+        plan.hasSize
+            ? '    $fx_sz = 0; if (-not $fx_i.PSIsContainer) { try { $fx_sz = $fx_i.Length } catch {} }'
+            : '',
+        plan.hasPrint ? '    $script:fx_find_print = $false' : '',
+        '    if (' + expr + ') { }',
+        plan.hasPrint ? '    if ($script:fx_find_print) { $fx_disp }' : '',
         '  }',
         '}',
     ]
         .filter((l) => l !== '')
         .join('\n');
 };
-function extractValue(preds, names) {
-    for (const n of names) {
-        const i = preds.indexOf(n);
-        if (i >= 0 && i + 1 < preds.length)
-            return preds[i + 1];
-    }
-    return null;
-}
 /** fnmatch glob → PowerShell -like pattern (same semantics for * and ?). */
 function likeOf(glob) {
     return glob.replace(/'/g, "''");
@@ -635,9 +827,9 @@ const chown = () => {
 /* diff — LCS-based, GNU normal format (+ -q, -u)                      */
 /* ------------------------------------------------------------------ */
 const diff = (args) => {
-    const { flags, operandWords } = parseWords(args);
-    const unified = flags.has('u') || flags.has('U');
-    const brief = flags.has('q') || flags.has('brief');
+    const { flags, longs, operandWords } = parseWords(args);
+    const unified = flags.has('u') || flags.has('U') || longs.has('--unified');
+    const brief = flags.has('q') || longs.has('--brief');
     void unified;
     return [
         PS_READTEXT_FN,
@@ -700,15 +892,93 @@ const diff = (args) => {
         '}',
     ].join('\n');
 };
+function opt(short, long, support = 'implemented', extra = {}) {
+    const o = { support };
+    if (short)
+        o.short = short;
+    if (long)
+        o.long = long;
+    return extra.takesValue || extra.reason ? { ...o, ...extra } : o;
+}
+function fileSpec(names, effects, options, handler) {
+    return {
+        names,
+        options,
+        effects,
+        platform: 'windows-ps51',
+        dispatch: 'translated',
+        handler,
+    };
+}
+const INTERACTIVE = { reason: 'interactive prompt' };
+/** Destructive file commands migrated first (#130). Unspec'd handlers stay unchecked.
+ *  cp/mv `-f`/`--force` is always-on overwrite (Copy-Item/Move-Item -Force); listed so `cp -rf` stays valid. */
+export const specs = [
+    fileSpec(['cp'], ['read', 'write'], [
+        opt('r', undefined),
+        opt('R', '--recursive'),
+        opt('v', '--verbose'),
+        opt('n', '--no-clobber'),
+        opt('f', '--force'),
+        opt('i', '--interactive', 'unsupported', INTERACTIVE),
+    ], cp),
+    fileSpec(['mv'], ['read', 'write', 'delete'], [
+        opt('v', '--verbose'),
+        opt('n', '--no-clobber'),
+        opt('f', '--force'),
+        opt('i', '--interactive', 'unsupported', INTERACTIVE),
+    ], mv),
+    fileSpec(['rm'], ['delete'], [
+        opt('r', undefined),
+        opt('R', '--recursive'),
+        opt('f', '--force'),
+        opt('v', '--verbose'),
+        opt('i', '--interactive', 'unsupported', INTERACTIVE),
+    ], rm),
+    fileSpec(['touch'], ['write'], [opt('c', '--no-create')], touch),
+    fileSpec(['du'], ['read'], [
+        opt('s', '--summarize'),
+        opt('h', '--human-readable'),
+        opt('d', '--max-depth', 'implemented', { takesValue: true }),
+    ], du),
+    fileSpec(['ls', 'll'], ['read'], [
+        opt('l', '--long'),
+        opt(undefined, '--format', 'implemented', { takesValue: true }),
+        opt('a', '--all'),
+        opt('A', '--almost-all'),
+        opt('d', '--directory'),
+        opt('h', '--human-readable'),
+        opt('F', '--classify'),
+        opt('p', undefined),
+        opt('t', undefined),
+        opt('S', undefined),
+        opt('r', undefined),
+        opt('R', '--recursive', 'unsupported', { reason: 'recursive listing' }),
+    ], ls),
+    fileSpec(['mkdir'], ['write'], [opt('p', '--parents'), opt('v', '--verbose')], mkdir),
+    fileSpec(['rmdir'], ['delete'], [], rmdir),
+    fileSpec(['mktemp'], ['write'], [opt('d', '--directory')], mktemp),
+    fileSpec(['ln'], ['read', 'write'], [opt('s', '--symbolic')], ln),
+    fileSpec(['readlink'], ['read'], [opt('f', '--canonicalize')], readlink),
+    fileSpec(['realpath'], ['read'], [], realpath),
+    fileSpec(['basename'], ['read'], [], basename),
+    fileSpec(['dirname'], ['read'], [], dirname),
+    fileSpec(['stat'], ['read'], [
+        opt('c', undefined, 'implemented', { takesValue: true }),
+        opt(undefined, '--format', 'implemented', { takesValue: true }),
+        opt(undefined, '--printf', 'implemented', { takesValue: true }),
+    ], stat),
+    fileSpec(['file'], ['read'], [], file),
+    fileSpec(['df'], ['read'], [opt('h', '--human-readable'), opt('H', undefined)], df),
+    fileSpec(['chmod'], ['write'], [opt('R', '--recursive', 'unsupported', { reason: 'recursive chmod' })], chmod),
+    fileSpec(['chown'], ['write'], [], chown),
+    fileSpec(['diff'], ['read'], [opt('q', '--brief'), opt('u', '--unified'), opt('U', undefined)], diff),
+];
 export const handlers = {
     ls,
     ll: ls, // common alias
-    cp,
-    mv,
-    rm,
     mkdir,
     rmdir,
-    touch,
     mktemp,
     ln,
     readlink,
@@ -717,10 +987,7 @@ export const handlers = {
     dirname,
     stat,
     file,
-    du,
     df,
+    du,
     find,
-    chmod,
-    chown,
-    diff,
 };

package/dist/commands/install-all.js

@@ -1,7 +1,7 @@
-import { registerAll } from '../registry.js';
-import { handlers as files } from './files.js';
-import { handlers as textFilters } from './text-filters.js';
-import { handlers as textIo } from './text-io.js';
+import { registerAll, registerSpecs } from '../registry.js';
+import { handlers as files, specs as fileSpecs } from './files.js';
+import { handlers as textFilters, specs as textFilterSpecs } from './text-filters.js';
+import { handlers as textIo, specs as textIoSpecs } from './text-io.js';
 import { handlers as sysinfo } from './sysinfo.js';
 import { handlers as net } from './net.js';
 import { handlers as archive } from './archive.js';
@@ -13,5 +13,8 @@ export function installAll() {
     registerAll(sysinfo);
     registerAll(net);
     registerAll(archive);
+    registerSpecs(fileSpecs);
+    registerSpecs(textIoSpecs);
+    registerSpecs(textFilterSpecs);
 }
 installAll();

package/dist/commands/sysinfo.js

@@ -209,8 +209,9 @@ const env = (args, ctx) => {
             break;
         }
         if (t === '-i' || t === '--ignore-environment') {
-            i++; // best-effort: the flag is accepted and ignored
-            continue;
+            return ('[Console]::Error.WriteLine(' +
+                psStr('fauxnix: env -i/--ignore-environment is not supported (would silently keep inherited secrets)') +
+                '); $script:fx_exit = 2');
         }
         if (t === '-u' || t === '--unset') {
             if (i + 1 < raw.length)

package/dist/commands/text-filters.d.ts

@@ -1,2 +1,3 @@
-import { Handler } from '../registry.js';
+import { CommandSpec, Handler } from '../registry.js';
+export declare const specs: CommandSpec[];
 export declare const handlers: Record<string, Handler>;