fauxnix-cli 0.9.2 → 0.11.0

package/dist/commands/text-filters.js

@@ -583,48 +583,45 @@ const grep = (args) => {
             scan.push('    $fx_mleft--');
         if (onlyMatch && !inv) {
             if (fixed) {
+                // GNU -o: emit leftmost-longest matches in input order, not per-needle.
                 if (ci)
                     scan.push('    $lx = $fx_l.ToLower()');
                 const hay = ci ? '$lx' : '$fx_l';
-                const emitFixedHits = (needle, indent) => {
-                    scan.push(indent + '$p = ' + hay + '.IndexOf(' + needle + ')');
-                    scan.push(indent + 'while ($p -ge 0) {');
-                    scan.push(indent + '  $ok = $true');
-                    if (word) {
-                        scan.push(indent +
-                            "  if ($p -gt 0) { $c = " +
-                            hay +
-                            "[$p - 1]; $ok = -not ([char]::IsLetterOrDigit($c) -or $c -eq '_') }");
-                        scan.push(indent +
-                            '  if ($ok) { $e = $p + ' +
-                            needle +
-                            '.Length; if ($e -lt ' +
-                            hay +
-                            '.Length) { $c = ' +
-                            hay +
-                            "[$e]; $ok = -not ([char]::IsLetterOrDigit($c) -or $c -eq '_') } }");
-                        scan.push(indent +
-                            '  if ($ok) { fx-emitline $fx_i (' +
-                            hay +
-                            '.Substring($p, ' +
-                            needle +
-                            '.Length)) }');
-                    }
-                    else {
-                        scan.push(indent + '  fx-emitline $fx_i (' + hay + '.Substring($p, ' + needle + '.Length))');
-                    }
-                    scan.push(indent + '  $p = ' + hay + '.IndexOf(' + needle + ', $p + 1)');
-                    scan.push(indent + '}');
-                };
-                if (multiFixed) {
-                    const arr = ci ? '$fx_needles_ll' : '$fx_needles';
-                    scan.push('    foreach ($fx_needle in ' + arr + ') {');
-                    emitFixedHits('$fx_needle', '      ');
-                    scan.push('    }');
+                const needleArr = multiFixed
+                    ? ci
+                        ? '$fx_needles_ll'
+                        : '$fx_needles'
+                    : '@(' + (ci ? '$fx_needle_ll' : '$fx_needle') + ')';
+                scan.push('    $fx_cands = New-Object System.Collections.Generic.List[object]');
+                scan.push('    foreach ($fx_needle in ' + needleArr + ') {');
+                scan.push('      if ($fx_needle.Length -lt 1) { continue }');
+                scan.push('      $p = ' + hay + '.IndexOf($fx_needle)');
+                scan.push('      while ($p -ge 0) {');
+                if (word) {
+                    scan.push('        $ok = $true');
+                    scan.push("        if ($p -gt 0) { $c = " +
+                        hay +
+                        "[$p - 1]; $ok = -not ([char]::IsLetterOrDigit($c) -or $c -eq '_') }");
+                    scan.push('        if ($ok) { $e = $p + $fx_needle.Length; if ($e -lt ' +
+                        hay +
+                        '.Length) { $c = ' +
+                        hay +
+                        "[$e]; $ok = -not ([char]::IsLetterOrDigit($c) -or $c -eq '_') } }");
+                    scan.push('        if ($ok) { [void]$fx_cands.Add([pscustomobject]@{ Start = $p; Len = $fx_needle.Length }) }');
                 }
                 else {
-                    emitFixedHits(ci ? '$fx_needle_ll' : '$fx_needle', '    ');
+                    scan.push('        [void]$fx_cands.Add([pscustomobject]@{ Start = $p; Len = $fx_needle.Length })');
                 }
+                scan.push('        $p = ' + hay + '.IndexOf($fx_needle, $p + 1)');
+                scan.push('      }');
+                scan.push('    }');
+                scan.push('    $fx_end = 0');
+                scan.push('    foreach ($fx_c in @($fx_cands | Sort-Object Start, @{ Expression = { $_.Len }; Descending = $true })) {');
+                scan.push('      if ($fx_c.Start -ge $fx_end) {');
+                scan.push('        fx-emitline $fx_i (' + hay + '.Substring($fx_c.Start, $fx_c.Len))');
+                scan.push('        $fx_end = $fx_c.Start + $fx_c.Len');
+                scan.push('      }');
+                scan.push('    }');
             }
             else {
                 scan.push('    foreach ($fx_m in $fx_re.Matches($fx_l)) { fx-emitline $fx_i $fx_m.Value }');
@@ -2292,8 +2289,9 @@ function parseCutList(list) {
 const cut = (args) => {
     const { flags, longs, values, operandWords } = parseWords(args, ['d', 'f', 'c', 'b'], []);
     const complement = longs.has('--complement');
-    const charsMode = flags.has('c') || flags.has('b');
-    const fieldsMode = flags.has('f');
+    // -f/-c/-b are value-taking; parseWords records them in `values`, not `flags`.
+    const charsMode = values.has('-c') || values.has('-b');
+    const fieldsMode = values.has('-f');
     const suppress = flags.has('s');
     if (charsMode && fieldsMode) {
         throw new FauxnixParseError('fauxnix: cut only one type of list may be specified');
@@ -2530,7 +2528,67 @@ export const specs = [
         usageExit: 2,
         handler: grep,
     },
+    {
+        names: ['sort'],
+        options: [
+            { short: 'r', long: '--reverse', support: 'implemented' },
+            { short: 'n', long: '--numeric-sort', support: 'implemented' },
+            { short: 'u', long: '--unique', support: 'implemented' },
+            { short: 'f', long: '--ignore-case', support: 'implemented' },
+            { short: 'b', long: '--ignore-leading-blanks', support: 'implemented' },
+            { short: 't', takesValue: true, support: 'implemented' },
+            { short: 'k', takesValue: true, support: 'implemented' },
+            { short: 'z', long: '--zero-terminated', support: 'unsupported', reason: 'NUL-terminated records' },
+        ],
+        effects: ['read'],
+        platform: 'windows-ps51',
+        dispatch: 'translated',
+        usageExit: 2,
+        handler: sort,
+    },
+    {
+        names: ['uniq'],
+        options: [
+            { short: 'c', support: 'implemented' },
+            { short: 'd', support: 'implemented' },
+            { short: 'u', support: 'implemented' },
+            { short: 'i', support: 'implemented' },
+        ],
+        effects: ['read'],
+        platform: 'windows-ps51',
+        dispatch: 'translated',
+        handler: uniq,
+    },
+    {
+        names: ['cut'],
+        options: [
+            { short: 'd', takesValue: true, support: 'implemented' },
+            { short: 'f', takesValue: true, support: 'implemented' },
+            { short: 'c', takesValue: true, support: 'implemented' },
+            { short: 'b', takesValue: true, support: 'implemented' },
+            { short: 's', support: 'implemented' },
+            { long: '--complement', support: 'implemented' },
+        ],
+        effects: ['read'],
+        platform: 'windows-ps51',
+        dispatch: 'translated',
+        handler: cut,
+    },
+    {
+        names: ['tr'],
+        options: [
+            { short: 'd', support: 'implemented' },
+            { short: 's', support: 'implemented' },
+            { short: 'c', long: '--complement', support: 'unsupported', reason: 'complement' },
+            { short: 'C', support: 'unsupported', reason: 'complement' },
+        ],
+        effects: ['read'],
+        platform: 'windows-ps51',
+        dispatch: 'translated',
+        handler: tr,
+    },
 ];
+/** sed/awk stay unspec'd (custom script parsers). egrep injects -E and stays its own handler. */
 export const handlers = {
     egrep: (args, ctx) => grep([[{ kind: 'Text', text: '-E' }], ...args], ctx), // egrep = grep -E
     sed,

package/dist/commands/text-io.js

@@ -1093,6 +1093,9 @@ const xargs = (args) => {
                     noRunIfEmpty = true;
                 else if (ch === 't')
                     trace = true;
+                else if (ch === '0') {
+                    return psErrExpr(psStr('xargs: -0 is not supported by fauxnix'));
+                }
                 else if (ch === 'n' || ch === 'I' || ch === 'L') {
                     const restv = body.slice(c + 1);
                     let val;
@@ -1140,12 +1143,12 @@ const xargs = (args) => {
     }
     const n = chunkN !== null && Number.isFinite(chunkN) && chunkN > 0 ? chunkN : 0;
     const replExpr = repl !== null ? psStr(repl) : null;
+    // fx-native already records $script:fx_exit from ExitCode.
     const invoke = [
         '    if (' +
             pb(trace) +
             ") { [Console]::Error.WriteLine(((@($fx_cmd) + @($fx_argv)) -join ' ')) }",
-        '    & $fx_cmd @fx_argv',
-        '    if ($LASTEXITCODE -ne 0 -and $script:fx_exit -eq 0) { $script:fx_exit = $LASTEXITCODE }',
+        '    fx-native $fx_cmd $fx_argv',
     ];
     let dispatch;
     const guard = '  if (' + pb(noRunIfEmpty) + ' -and $fx_args.Count -eq 0) { }' + '\n' + '  else {';
@@ -1154,7 +1157,7 @@ const xargs = (args) => {
         dispatch = [
             guard,
             '  foreach ($fx_l in $fx_args) {',
-            '    $fx_argv = @()',
+            '    $fx_argv = [object[]]@()',
             '    $fx_hit = $false',
             '    foreach ($fx_a in $fx_base) {',
             '      if ($fx_a.Contains(' + replExpr + ')) {',
@@ -1175,7 +1178,7 @@ const xargs = (args) => {
             '  $fx_i = 0',
             '  $fx_ran = $false',
             '  while ($fx_i -lt $fx_args.Count) {',
-            '    $fx_argv = @($fx_base)',
+            '    $fx_argv = [object[]]@($fx_base)',
             '    $fx_j = 0',
             '    while ($fx_j -lt ' + n + ' -and $fx_i -lt $fx_args.Count) {',
             '      $fx_argv += $fx_args[$fx_i]',
@@ -1185,10 +1188,8 @@ const xargs = (args) => {
             ...invoke,
             '  }',
             '  if (-not $fx_ran) {',
-            '    $fx_argv = @($fx_base)',
-            '    ' + invoke[0],
-            '    ' + invoke[1],
-            '    ' + invoke[2],
+            '    $fx_argv = [object[]]@($fx_base)',
+            ...invoke.map((line) => '  ' + line),
             '  }',
             '  }',
         ];
@@ -1196,17 +1197,27 @@ const xargs = (args) => {
     else {
         dispatch = [
             guard,
-            '  $fx_argv = @($fx_base) + @($fx_args)',
+            '  $fx_argv = [object[]](@($fx_base) + @($fx_args))',
             ...invoke,
             '  }',
         ];
     }
+    // Default GNU xargs splits on blanks; -I keeps whole lines as one item.
+    const collectArgs = replExpr !== null
+        ? "$fx_args = @($fx_in | Where-Object { $_ -ne '' })"
+        : [
+            '$fx_args = @()',
+            'foreach ($fx_l in $fx_in) {',
+            "  if ($fx_l -eq '') { continue }",
+            "  $fx_args += @($fx_l -split '[ \\t]+' | Where-Object { $_ -ne '' })",
+            '}',
+        ].join('\n');
     return [
         PS_SPLITLINES_FN,
         STDIN_INLINES,
         '$fx_tg = ' + argListExpr(target, exprOfWord),
         "if ($fx_tg.Count -eq 0) { $fx_cmd = ''; $fx_base = @() } else { $fx_cmd = [string]$fx_tg[0]; $fx_base = $(if ($fx_tg.Count -gt 1) { @($fx_tg[1..($fx_tg.Count - 1)]) } else { @() }) }",
-        "$fx_args = @($fx_in | Where-Object { $_ -ne '' })",
+        collectArgs,
         ...dispatch,
     ].join('\n');
 };
@@ -1236,6 +1247,74 @@ export const specs = [
         dispatch: 'translated',
         handler: head,
     },
+    {
+        names: ['echo'],
+        options: [
+            { short: 'n', support: 'implemented' },
+            { short: 'e', support: 'implemented' },
+            { short: 'E', support: 'implemented' },
+        ],
+        effects: [],
+        platform: 'windows-ps51',
+        dispatch: 'translated',
+        usageExit: 2,
+        leadingOptions: true,
+        handler: echo,
+    },
+    {
+        names: ['printf'],
+        options: [],
+        effects: [],
+        platform: 'windows-ps51',
+        dispatch: 'translated',
+        usageExit: 2,
+        leadingOptions: true,
+        handler: printf,
+    },
+    {
+        names: ['cat'],
+        options: [
+            { short: 'n', support: 'implemented' },
+            { short: 'b', support: 'implemented' },
+            { short: 's', support: 'implemented' },
+            { short: 'E', support: 'implemented' },
+            { short: 'T', support: 'implemented' },
+            { short: 'A', support: 'implemented' },
+        ],
+        effects: ['read'],
+        platform: 'windows-ps51',
+        dispatch: 'translated',
+        handler: cat,
+    },
+    {
+        names: ['tail'],
+        options: [
+            { short: 'n', long: '--lines', takesValue: true, support: 'implemented' },
+            { short: 'c', long: '--bytes', takesValue: true, support: 'implemented' },
+            { short: 'q', long: '--quiet', support: 'implemented' },
+            { long: '--silent', support: 'implemented' },
+            { short: 'v', long: '--verbose', support: 'implemented' },
+            { short: 'f', support: 'unsupported', reason: 'no persistent tty' },
+            { short: 'F', support: 'unsupported', reason: 'no persistent tty' },
+        ],
+        effects: ['read'],
+        platform: 'windows-ps51',
+        dispatch: 'translated',
+        handler: tail,
+    },
+    {
+        names: ['wc'],
+        options: [
+            { short: 'l', support: 'implemented' },
+            { short: 'w', support: 'implemented' },
+            { short: 'c', support: 'implemented' },
+            { short: 'm', support: 'implemented' },
+        ],
+        effects: ['read'],
+        platform: 'windows-ps51',
+        dispatch: 'translated',
+        handler: wc,
+    },
 ];
 export const handlers = {
     echo,

package/dist/doctor.d.ts

@@ -0,0 +1,20 @@
+export type DoctorOptions = {
+    home?: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    nodeVersion?: string;
+    /** Injected MCP-module loader. Default: dynamic import of ./mcp.js (does not start the server). */
+    loadMcp?: () => Promise<unknown>;
+};
+export type DoctorReport = {
+    lines: string[];
+    ok: boolean;
+};
+export declare function collectDoctorReport(opts?: DoctorOptions): Promise<DoctorReport>;
+export declare function claudeUserConfigPath(home: string, env: NodeJS.ProcessEnv): string;
+export declare function codexConfigPath(home: string, env: NodeJS.ProcessEnv): string;
+export declare function openCodeConfigPath(home: string, env: NodeJS.ProcessEnv): string;
+export declare function hasCodexFauxnix(text: string): boolean;
+export declare function hasOpenCodeFauxnix(data: unknown): boolean;
+export declare function isServerMap(value: unknown): boolean;
+export declare function serverMapHasFauxnix(value: unknown): boolean;

package/dist/doctor.js

@@ -0,0 +1,251 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const VALUE_INDENT = '             ';
+export async function collectDoctorReport(opts = {}) {
+    const home = opts.home ?? homedir();
+    const cwd = opts.cwd ?? process.cwd();
+    const env = opts.env ?? process.env;
+    const nodeVersion = opts.nodeVersion ?? process.version;
+    const lines = [''];
+    lines.push(...encodingLines(env));
+    lines.push('');
+    lines.push(field('claude', detectClaude(home, cwd, env)));
+    lines.push(field('codex', detectCodex(home, env)));
+    lines.push(field('opencode', detectOpenCode(home, env)));
+    lines.push('');
+    const mcp = await mcpLines(nodeVersion, opts.loadMcp);
+    lines.push(...mcp.lines);
+    return { lines, ok: mcp.ok };
+}
+function field(label, value) {
+    return `${label.padEnd(10)} : ${value}`;
+}
+function encodingLines(env) {
+    const raw = env.FAUXNIX_NATIVE_ENCODING;
+    const current = raw === undefined || raw === ''
+        ? 'unset → utf8 (default)'
+        : raw === 'ansi'
+            ? 'ansi → GBK-native admin tools'
+            : `${raw} → utf8 (only ansi selects GBK)`;
+    return [
+        field('encoding', 'UTF-8 default for native-tool pipelines'),
+        VALUE_INDENT + `current FAUXNIX_NATIVE_ENCODING=${current}`,
+        VALUE_INDENT + 'set FAUXNIX_NATIVE_ENCODING=ansi for GBK-native admin tools (ipconfig, tasklist)',
+    ];
+}
+function detectClaude(home, cwd, env) {
+    const userPath = claudeUserConfigPath(home, env);
+    const projectPath = join(cwd, '.mcp.json');
+    const userExists = existsSync(userPath);
+    const projectExists = existsSync(projectPath);
+    let user;
+    let project;
+    if (userExists)
+        user = inspectClaudeJson(userPath);
+    if (projectExists) {
+        const inspected = inspectClaudeJson(projectPath);
+        // Project-scope Claude MCP is always a top-level mcpServers object.
+        if (!inspected.parseError && inspected.hasTopLevelMcpServers)
+            project = inspected;
+    }
+    if (!userExists && !project)
+        return 'not detected — see README';
+    if (user?.hasFauxnix)
+        return `fauxnix MCP configured (${userPath})`;
+    if (project?.hasFauxnix)
+        return `fauxnix MCP configured (${projectPath})`;
+    if (userExists && user?.parseError) {
+        return `found ${userPath} (unreadable JSON) — see README`;
+    }
+    if (userExists) {
+        return `found ${userPath}, fauxnix MCP not listed — run: claude mcp add fauxnix -- fauxnix mcp`;
+    }
+    return `found ${projectPath}, fauxnix MCP not listed — see README`;
+}
+export function claudeUserConfigPath(home, env) {
+    const dir = env.CLAUDE_CONFIG_DIR?.trim();
+    if (dir)
+        return join(dir, '.claude.json');
+    return join(home, '.claude.json');
+}
+export function codexConfigPath(home, env) {
+    const codexHome = env.CODEX_HOME?.trim() || join(home, '.codex');
+    return join(codexHome, 'config.toml');
+}
+export function openCodeConfigPath(home, env) {
+    const xdg = env.XDG_CONFIG_HOME?.trim() || join(home, '.config');
+    return join(xdg, 'opencode', 'opencode.json');
+}
+function inspectClaudeJson(path) {
+    const text = readText(path);
+    if (text === undefined) {
+        return { parseError: true, hasTopLevelMcpServers: false, hasFauxnix: false };
+    }
+    let data;
+    try {
+        data = JSON.parse(stripBom(text));
+    }
+    catch {
+        return { parseError: true, hasTopLevelMcpServers: false, hasFauxnix: false };
+    }
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+        return { parseError: true, hasTopLevelMcpServers: false, hasFauxnix: false };
+    }
+    const rec = data;
+    const hasTopLevelMcpServers = isServerMap(rec.mcpServers);
+    let hasFauxnix = hasTopLevelMcpServers && serverMapHasFauxnix(rec.mcpServers);
+    const projects = rec.projects;
+    if (projects && typeof projects === 'object' && !Array.isArray(projects)) {
+        for (const proj of Object.values(projects)) {
+            if (!proj || typeof proj !== 'object' || Array.isArray(proj))
+                continue;
+            const servers = proj.mcpServers;
+            if (isServerMap(servers) && serverMapHasFauxnix(servers))
+                hasFauxnix = true;
+        }
+    }
+    return { parseError: false, hasTopLevelMcpServers, hasFauxnix };
+}
+function detectCodex(home, env) {
+    const path = codexConfigPath(home, env);
+    if (!existsSync(path))
+        return 'not detected — see README';
+    const text = readText(path);
+    if (text === undefined)
+        return `found ${path} (unreadable) — see README`;
+    if (hasCodexFauxnix(stripBom(text)))
+        return `fauxnix MCP configured (${path})`;
+    return `found ${path}, fauxnix MCP not listed — run: codex mcp add fauxnix -- fauxnix mcp`;
+}
+export function hasCodexFauxnix(text) {
+    if (/^\s*\[mcp_servers\.(?:fauxnix|"fauxnix"|'fauxnix')\]/im.test(text))
+        return true;
+    const tables = text.split(/^\s*\[/m);
+    for (const table of tables) {
+        if (!/^mcp_servers\./i.test(table))
+            continue;
+        const header = (table.split(/[\]\r\n]/, 1)[0] ?? '').trim();
+        if (/^mcp_servers\.(?:fauxnix|"fauxnix"|'fauxnix')$/i.test(header))
+            return true;
+        const cmd = /^\s*command\s*=\s*(?:"([^"]*)"|'([^']*)')/im.exec(table);
+        const command = cmd?.[1] ?? cmd?.[2];
+        if (command && isFauxnixExecutable(command))
+            return true;
+        const args = /^\s*args\s*=\s*\[([^\]]*)\]/im.exec(table);
+        if (args) {
+            const items = [...args[1].matchAll(/"([^"]*)"|'([^']*)'/g)].map((m) => m[1] ?? m[2] ?? '');
+            if (items.some(isFauxnixExecutable))
+                return true;
+        }
+    }
+    return false;
+}
+function detectOpenCode(home, env) {
+    const path = openCodeConfigPath(home, env);
+    if (!existsSync(path))
+        return 'not detected — see README';
+    const text = readText(path);
+    if (text === undefined)
+        return `found ${path} (unreadable) — see README`;
+    let data;
+    try {
+        data = JSON.parse(stripBom(text));
+    }
+    catch {
+        return `found ${path} (unreadable JSON) — see README`;
+    }
+    if (hasOpenCodeFauxnix(data))
+        return `fauxnix MCP configured (${path})`;
+    return `found ${path}, fauxnix MCP not listed — add mcp.fauxnix (see README)`;
+}
+export function hasOpenCodeFauxnix(data) {
+    if (!data || typeof data !== 'object' || Array.isArray(data))
+        return false;
+    const mcp = data.mcp;
+    if (!isServerMap(mcp))
+        return false;
+    if (serverMapHasFauxnix(mcp))
+        return true;
+    const nested = mcp.servers;
+    return isServerMap(nested) && serverMapHasFauxnix(nested);
+}
+export function isServerMap(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+export function serverMapHasFauxnix(value) {
+    if (!isServerMap(value))
+        return false;
+    for (const [name, cfg] of Object.entries(value)) {
+        if (name === 'servers')
+            continue;
+        if (looksLikeFauxnixServer(name, cfg))
+            return true;
+    }
+    return false;
+}
+function looksLikeFauxnixServer(name, cfg) {
+    if (/^fauxnix(-cli)?$/i.test(name))
+        return true;
+    if (!cfg || typeof cfg !== 'object' || Array.isArray(cfg))
+        return false;
+    const rec = cfg;
+    const chunks = [];
+    if (typeof rec.command === 'string')
+        chunks.push(rec.command);
+    if (Array.isArray(rec.command)) {
+        for (const part of rec.command)
+            if (typeof part === 'string')
+                chunks.push(part);
+    }
+    if (Array.isArray(rec.args)) {
+        for (const part of rec.args)
+            if (typeof part === 'string')
+                chunks.push(part);
+    }
+    return chunks.some(isFauxnixExecutable);
+}
+function isFauxnixExecutable(s) {
+    const base = s.replace(/\\/g, '/').split('/').pop()?.trim() ?? '';
+    return /^fauxnix(-cli)?(\.cmd|\.exe)?$/i.test(base);
+}
+async function mcpLines(nodeVersion, loadMcp) {
+    const major = nodeMajor(nodeVersion);
+    const nodeOk = major >= 18;
+    let moduleOk = false;
+    let moduleDetail = '';
+    try {
+        const mod = await (loadMcp ?? defaultLoadMcp)();
+        moduleOk =
+            !!mod && typeof mod.startMcpServer === 'function';
+        if (!moduleOk)
+            moduleDetail = 'startMcpServer export missing';
+    }
+    catch (e) {
+        moduleDetail = e instanceof Error ? e.message : String(e);
+    }
+    const lines = [
+        field('node', `${nodeVersion.startsWith('v') ? nodeVersion : 'v' + nodeVersion}${nodeOk ? ' (>=18 required)' : '  FAILED (requires >=18)'}`),
+        field('mcp', moduleOk ? 'module loads' : `FAILED to load${moduleDetail ? ': ' + moduleDetail : ''}`),
+        VALUE_INDENT + 'start with: fauxnix mcp',
+    ];
+    return { lines, ok: nodeOk && moduleOk };
+}
+async function defaultLoadMcp() {
+    return import('./mcp.js');
+}
+function nodeMajor(version) {
+    const m = /^v?(\d+)/.exec(version);
+    return m ? Number(m[1]) : 0;
+}
+function stripBom(text) {
+    return text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+}
+function readText(path) {
+    try {
+        return readFileSync(path, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/errors.d.ts

@@ -2,4 +2,8 @@
  * Error normalization — make PowerShell failures look like bash failures
  * so agents can pattern-match on familiar Linux error styles.
  */
+/** Missing `python3` on Windows (Mac/Linux agents emit this; do not alias). */
+export declare const PYTHON3_WINDOWS_HINT = " (fauxnix: try `python` or `py` on Windows)";
+/** `.sh` cannot be CreateProcess'd; fx-native never emits the PS not-recognized line. */
+export declare const SH_SCRIPT_WINDOWS_HINT = " (fauxnix: .sh scripts cannot run natively on Windows)";
 export declare function normalizeStderr(stderr: string): string;

package/dist/errors.js

@@ -2,6 +2,19 @@
  * Error normalization — make PowerShell failures look like bash failures
  * so agents can pattern-match on familiar Linux error styles.
  */
+/** Missing `python3` on Windows (Mac/Linux agents emit this; do not alias). */
+export const PYTHON3_WINDOWS_HINT = ' (fauxnix: try `python` or `py` on Windows)';
+/** `.sh` cannot be CreateProcess'd; fx-native never emits the PS not-recognized line. */
+export const SH_SCRIPT_WINDOWS_HINT = ' (fauxnix: .sh scripts cannot run natively on Windows)';
+function commandNotFound(name) {
+    const msg = 'bash: ' + name + ': command not found';
+    const base = name.replace(/^.*[/\\]/, '');
+    if (/^python3(\.exe)?$/i.test(base))
+        return msg + PYTHON3_WINDOWS_HINT;
+    if (/\.sh$/i.test(name))
+        return msg + SH_SCRIPT_WINDOWS_HINT;
+    return msg;
+}
 /** Lines produced by PowerShell error formatting that bash would never show. */
 const PS_NOISE = [
     /^\s*\+ CategoryInfo\s*:/,
@@ -62,15 +75,15 @@ export function normalizeStderr(stderr) {
         // "The term 'x' is not recognized as a name of a cmdlet, function, ..."
         let m = line.match(/^The term '(.+?)' is not recognized/);
         if (m)
-            return 'bash: ' + m[1] + ': command not found';
+            return commandNotFound(m[1]);
         // zh-CN: 无法将"x"项识别为 cmdlet、函数、脚本文件或可运行程序的名称
         m = line.match(/^无法将["'”]?([^"'”]+)["'”]?项识别为/);
         if (m)
-            return 'bash: ' + m[1] + ': command not found';
+            return commandNotFound(m[1]);
         // "x : The term 'y' is not recognized ..." (with source prefix)
         m = line.match(/^(\S+)\s*:\s*The term '(.+?)' is not recognized/);
         if (m)
-            return 'bash: ' + m[2] + ': command not found';
+            return commandNotFound(m[2]);
         // "cat : Cannot find path 'D:\x' because it does not exist."
         m = line.match(/^(\S+)\s*:\s*Cannot find path '(.+?)' because it does not exist\.?$/);
         if (m) {
@@ -93,9 +106,9 @@ export function normalizeStderr(stderr) {
         m = line.match(/^(\S+)\s*:\s*(.*)Access to the path '(.+?)' is denied\.?$/);
         if (m)
             return m[1].toLowerCase() + ': cannot remove \'' + m[3] + '\': Permission denied';
-        // helpful hint for bash scripts
+        // leftover PS not-recognized lines that the rewrites above did not catch
         if (/\.sh'?/.test(line) && /is not recognized/.test(line)) {
-            return line + ' (fauxnix: .sh scripts cannot run natively on Windows)';
+            return line + SH_SCRIPT_WINDOWS_HINT;
         }
         return line;
     });