@automaton-labs/aib 0.0.7 → 0.0.8

package/dist/commands/quick-read.js

@@ -1,11 +1,1113 @@
-"use strict";var R=exports&&exports.__createBinding||(Object.create?(function(e,n,r,t){t===void 0&&(t=r);var i=Object.getOwnPropertyDescriptor(n,r);(!i||("get"in i?!n.__esModule:i.writable||i.configurable))&&(i={enumerable:!0,get:function(){return n[r]}}),Object.defineProperty(e,t,i)}):(function(e,n,r,t){t===void 0&&(t=r),e[t]=n[r]})),m=exports&&exports.__setModuleDefault||(Object.create?(function(e,n){Object.defineProperty(e,"default",{enumerable:!0,value:n})}):function(e,n){e.default=n}),h=exports&&exports.__importStar||(function(){var e=function(n){return e=Object.getOwnPropertyNames||function(r){var t=[];for(var i in r)Object.prototype.hasOwnProperty.call(r,i)&&(t[t.length]=i);return t},e(n)};return function(n){if(n&&n.__esModule)return n;var r={};if(n!=null)for(var t=e(n),i=0;i<t.length;i++)t[i]!=="default"&&R(r,n,t[i]);return m(r,n),r}})();Object.defineProperty(exports,"__esModule",{value:!0}),exports.runQuickReadCommand=Q;const p=h(require("node:fs/promises")),q=h(require("node:path")),w=require("../config/path-display"),A=require("../config/path-aliases"),F=require("../shared/agent-text"),f=require("../shared/errors"),N=require("./session-workspace"),I=80;async function Q(e,n,r={}){const t=(0,N.readEffectiveSessionPathAliases)(e),i=(0,w.buildDisplayPathAliases)(e,t),s=n.includes("--stdin")?S(e,t,i,r.rawStdin??await V()):_(e,t,i,n),u=await y(v(s)),l={ok:u.some(o=>o.error===void 0),blocks:u.map(o=>({file:o.file,...o.window!==void 0?{window:o.window}:{},...o.content!==void 0?{content:o.content}:{},...o.error!==void 0?{error:o.error}:{}}))};return(0,F.attachAgentText)(l,W(u))}function v(e){const n=new Set(e.filter(i=>i.windows.some(s=>s.kind==="all")).map(i=>i.resolvedFile));if(n.size===0)return e;const r=new Set,t=[];for(const i of e){if(!n.has(i.resolvedFile)){t.push(i);continue}r.has(i.resolvedFile)||(r.add(i.resolvedFile),t.push({...i,windows:[{kind:"all"}]}))}return t}async function y(e){const n=new Map;for(const t of e)n.has(t.resolvedFile)||n.set(t.resolvedFile,O(t.resolvedFile));const r=[];for(const t of e){const i=await n.get(t.resolvedFile);if(i.error!==void 0||i.lines===void 0){r.push({file:t.displayFile,error:i.error??"read failed"});continue}for(const s of t.windows)r.push({file:t.displayFile,window:B(s),content:x(i.lines,s).join(`
-`)})}return r}async function O(e){let n;try{n=await p.stat(e)}catch(t){return{error:(typeof t=="object"&&t!==null&&"code"in t?String(t.code):"")==="ENOENT"?"file not found":"cannot stat file"}}if(n.isDirectory())return{error:"is a directory"};if(!n.isFile())return{error:"not a regular file"};let r;try{r=await p.readFile(e)}catch{return{error:"cannot read file"}}return $(r)?{error:"binary file"}:{lines:C(r.toString("utf8"))}}function $(e){const n=Math.min(e.length,8192);for(let r=0;r<n;r+=1)if(e[r]===0)return!0;return!1}function C(e){const n=e.replace(/\r\n/g,`
-`).replace(/\r/g,`
-`);return n.endsWith(`
-`)?n.slice(0,-1).split(`
-`):n.split(`
-`)}function x(e,n){return n.kind==="all"?e:n.kind==="head"?e.slice(0,n.count):n.kind==="tail"?e.slice(Math.max(0,e.length-n.count)):e.slice(n.offset-1,n.offset-1+n.limit)}function S(e,n,r,t){const i=t.replace(/^\uFEFF/,"").split(/\r?\n/),s=[];for(let u=0;u<i.length;u+=1){const c=i[u]?.trim()??"";if(!c||c.startsWith("#"))continue;const l=j(c);if(l.length===0)continue;const o=l[0]==="qr"?l.slice(1):l;try{s.push(..._(e,n,r,o))}catch(a){throw a instanceof f.CliError?new f.CliError(a.code,`qr stdin line ${u+1}: ${a.message}`,a.details):a}}if(s.length===0)throw new f.CliError("QR_STDIN_EMPTY","qr --stdin expects at least one qr line.");return s}function _(e,n,r,t){const i=t.filter(c=>c!=="--stdin"),s=i[0]==="qr"?i.slice(1):i,u=b(s);if(u.length===0)throw new f.CliError("QR_FILE_REQUIRED","qr expects a file path.");return u.map(c=>D(e,n,r,c.file,M(c.windowArgs)))}function b(e){const n=[];for(let r=0;r<e.length;r+=1){const t=e[r]??"";if(T(t)){if(n.length===0)throw new f.CliError("QR_FILE_REQUIRED","qr expects a file path before window flags.");n[n.length-1].windowArgs.push(t),U(t)&&(r+=1,n[n.length-1].windowArgs.push(e[r]??""));continue}n.push({file:t,windowArgs:[]})}return n}function D(e,n,r,t,i){if(!t||t.startsWith("-")||E(t))throw new f.CliError("QR_FILE_REQUIRED","qr expects a file path before window flags.");const s=q.resolve(e,(0,A.expandPathAliasValue)(e,t,n));return{file:t,resolvedFile:s,displayFile:(0,w.compactDisplayPath)(e,s,r),windows:i}}function M(e){let n=!1,r=null,t=null,i=null,s=null;for(let l=0;l<e.length;l+=1){const o=e[l]??"",a=P(o);if(a){c(a.key,a.value);continue}if(o==="-a"||o==="--all"||o==="a"||o==="all"||o==="+all"){n=!0;continue}if(o==="-h"||o==="--head"){r=d(e,++l,o);continue}if(o==="-t"||o==="--tail"){t=d(e,++l,o);continue}if(o==="-o"||o==="--offset"){i=d(e,++l,o);continue}if(o==="-l"||o==="--limit"){s=d(e,++l,o);continue}throw new f.CliError("QR_UNKNOWN_ARGUMENT",`Unknown qr argument: ${o}`)}if(i===null&&s!==null&&(r=s,s=null),i===null!=(s===null))throw new f.CliError("QR_RANGE_INCOMPLETE","qr range reads require both o=<line> and l=<count>.");if(n)return[{kind:"all"}];const u=[];return r!==null&&u.push({kind:"head",count:r}),i!==null&&s!==null&&u.push({kind:"range",offset:i,limit:s}),t!==null&&u.push({kind:"tail",count:t}),u.length>0?u:[{kind:"head",count:I}];function c(l,o){if(l==="a"||l==="all"){n=L(o,l);return}const a=g(o,l);if(l==="h"||l==="head"){r=a;return}if(l==="t"||l==="tail"){t=a;return}if(l==="o"||l==="offset"){i=a;return}if(l==="l"||l==="limit"){s=a;return}throw new f.CliError("QR_UNKNOWN_ARGUMENT",`Unknown qr window field: ${l}`)}}function L(e,n){if(e==="true"||e==="1"||e==="yes")return!0;if(e==="false"||e==="0"||e==="no")return!1;throw new f.CliError("QR_INVALID_BOOLEAN",`${n} expects true or false.`)}function P(e){const n=e.indexOf("=");return n<=0?null:{key:e.slice(0,n),value:e.slice(n+1)}}function d(e,n,r){const t=e[n];if(!t||t.startsWith("-"))throw new f.CliError("QR_MISSING_FLAG_VALUE",`Expected a positive integer after ${r}.`);return g(t,r)}function g(e,n){const r=Number(e);if(!Number.isInteger(r)||r<1)throw new f.CliError("QR_INVALID_NUMBER",`${n} expects a positive integer.`);return r}function E(e){return/^(?:h|head|t|tail|o|offset|l|limit|a|all)=/.test(e)||e==="+all"}function T(e){return e.startsWith("-")||E(e)||e==="a"||e==="all"}function U(e){return["-h","--head","-t","--tail","-o","--offset","-l","--limit"].includes(e)}function W(e){return e.map(n=>{if(n.error!==void 0)return`// ${n.file} - ${n.error}`;const r=`// ${n.file}${n.window?` ${n.window}`:""}`;return n.content?`${r}
-${n.content}`:`${r}
-`}).join(`
-
-`)}function B(e){return e.kind==="all"?"all":e.kind==="head"?`h=${e.count}`:e.kind==="tail"?`t=${e.count}`:`o=${e.offset} l=${e.limit}`}function j(e){const n=[];let r="",t=null;for(let i=0;i<e.length;i+=1){const s=e[i]??"";if(t){s===t?t=null:r+=s;continue}if(s==='"'||s==="'"){t=s;continue}if(/\s/.test(s)){r.length>0&&(n.push(r),r="");continue}r+=s}if(t)throw new f.CliError("QR_UNTERMINATED_QUOTE","qr input has an unterminated quote.");return r.length>0&&n.push(r),n}async function V(){const e=[];for await(const n of process.stdin)e.push(Buffer.isBuffer(n)?n:Buffer.from(String(n)));return Buffer.concat(e).toString("utf8")}
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runQuickReadCommand = runQuickReadCommand;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const path_display_1 = require("../config/path-display");
+const path_aliases_1 = require("../config/path-aliases");
+const workspace_root_1 = require("../config/workspace-root");
+const agent_dx_1 = require("../agent-dx/agent-dx");
+const agent_text_1 = require("../shared/agent-text");
+const errors_1 = require("../shared/errors");
+const session_workspace_1 = require("./session-workspace");
+const DEFAULT_HEAD_LINES = 80;
+const QR_OUTPUT_CAP_KB_CONFIG_KEY = "qr.outputCapKb";
+const QR_OUTPUT_CAP_KB_ENV = "AIB_QR_OUTPUT_CAP_KB";
+const GLOBAL_OUTPUT_CAP_ENV = "AIB_OUTPUT_CAP";
+const DEFAULT_QR_OUTPUT_CAP_KB = 32;
+const MAX_QR_CAP_LINE_SAMPLES = 8;
+async function runQuickReadCommand(cwd, restArgs, options = {}) {
+    const aliases = (0, session_workspace_1.readEffectiveSessionPathAliases)(cwd);
+    const displayAliases = (0, path_display_1.buildDisplayPathAliases)(cwd, aliases);
+    const parsed = restArgs.includes("--stdin")
+        ? parseStdinRequests(cwd, aliases, displayAliases, options.rawStdin ?? await readRawStdin())
+        : parseInlineRequests(cwd, aliases, displayAliases, restArgs);
+    const blocks = [
+        ...await executeQrRequests(cwd, collapseAllReadRequests(parsed.requests)),
+        ...parsed.errors
+    ];
+    const hasReadableBlock = blocks.some((block) => block.error === undefined);
+    const response = {
+        ok: hasReadableBlock,
+        blocks: blocks.map((block) => ({
+            file: block.file,
+            ...(block.window !== undefined ? { window: block.window } : {}),
+            ...(block.content !== undefined ? { content: block.content } : {}),
+            ...(block.error !== undefined ? { error: block.error } : {}),
+            ...(block.code !== undefined ? { code: block.code } : {}),
+            ...(block.details !== undefined ? { details: block.details } : {})
+        }))
+    };
+    const agentDxSignals = [
+        ...collectQrAgentDxSignals(blocks),
+        ...(0, agent_dx_1.collectAgentDxObservationSignals)(cwd, buildQrObservation(restArgs, parsed.requests))
+    ];
+    return (0, agent_text_1.attachAgentText)((0, agent_dx_1.applyAgentDxSignals)(cwd, response, agentDxSignals), formatQrBlocks(blocks));
+}
+function collectQrAgentDxSignals(blocks) {
+    const flags = uniqueStrings(blocks
+        .filter((block) => block.code === "QR_UNKNOWN_ARGUMENT")
+        .map((block) => typeof block.details?.argument === "string" ? block.details.argument : null)
+        .filter((item) => typeof item === "string" && item.startsWith("-")));
+    if (flags.length === 0) {
+        return [];
+    }
+    return [{
+            kind: "unknownFlag",
+            command: "qr",
+            flags,
+            helpRefs: [{ topic: "qr", reason: "unknownFlag", priority: 1, mode: "command" }],
+            suggestions: [{ command: "aib help qr", priority: 1 }]
+        }];
+}
+function buildQrObservation(restArgs, requests) {
+    const inline = !restArgs.includes("--stdin");
+    return {
+        command: "qr",
+        family: "read",
+        surface: inline ? "inline" : "stdin-raw",
+        targets: requests.map(formatQrRequestForBatchSuggestion),
+        batchable: inline && requests.length === 1
+    };
+}
+function formatQrRequestForBatchSuggestion(request) {
+    const windowArgs = request.windows
+        .map(formatWindow)
+        .filter((window) => window !== "h=80");
+    return [request.displayFile, ...windowArgs].join(" ");
+}
+function collapseAllReadRequests(requests) {
+    const allFiles = new Set(requests.filter((request) => request.windows.some((window) => window.kind === "all")).map((request) => request.resolvedFile));
+    if (allFiles.size === 0) {
+        return requests;
+    }
+    const emittedAllFiles = new Set();
+    const collapsed = [];
+    for (const request of requests) {
+        if (!allFiles.has(request.resolvedFile)) {
+            collapsed.push(request);
+            continue;
+        }
+        if (emittedAllFiles.has(request.resolvedFile)) {
+            continue;
+        }
+        emittedAllFiles.add(request.resolvedFile);
+        collapsed.push({
+            ...request,
+            windows: [{ kind: "all" }]
+        });
+    }
+    return collapsed;
+}
+async function executeQrRequests(cwd, requests) {
+    const outputCapBytes = readQrOutputCapBytes(cwd, process.env);
+    const fileCache = new Map();
+    for (const request of requests) {
+        if (!fileCache.has(request.resolvedFile)) {
+            fileCache.set(request.resolvedFile, readTextFileLines(request.resolvedFile));
+        }
+    }
+    const blocks = [];
+    for (const request of requests) {
+        const file = await fileCache.get(request.resolvedFile);
+        if (file.error !== undefined || file.lines === undefined) {
+            blocks.push({ file: request.displayFile, error: file.error ?? "read failed" });
+            continue;
+        }
+        blocks.push(...buildQrReadBlocks(request.displayFile, file.lines, request.windows, outputCapBytes));
+    }
+    return blocks;
+}
+function buildQrReadBlocks(file, lines, windows, capBytes) {
+    if (windows.some((window) => window.kind === "all")) {
+        const content = lines.join("\n");
+        const capped = buildQrAllCapBlock(file, "all", lines, content, capBytes);
+        return [capped ?? { file, window: "all", content }];
+    }
+    const sourceWindows = resolveQrSourceWindows(lines, windows);
+    if (sourceWindows.length === 0) {
+        return [{ file, window: "h=0", content: "" }];
+    }
+    if (!isQrCapEnabled(capBytes)) {
+        return renderQrWindows(file, mergeQrWindows(sourceWindows), lines);
+    }
+    const metrics = buildQrLineMetrics(lines);
+    const measured = sourceWindows.map((window) => ({
+        ...window,
+        bytes: qrWindowContentBytes(metrics, window)
+    }));
+    const hidden = measured.filter((window) => window.bytes > capBytes);
+    if (hidden.length === 0) {
+        return renderQrWindows(file, mergeQrWindows(measured), lines);
+    }
+    return [
+        buildQrBlockCapBlock(file, metrics, hidden, capBytes),
+        ...renderQrWindows(file, mergeQrWindows(measured.filter((window) => window.bytes <= capBytes)), lines)
+    ];
+}
+function renderQrWindows(file, windows, lines) {
+    return windows.map((window) => ({
+        file,
+        window: window.label,
+        content: lines.slice(window.start - 1, window.end).join("\n")
+    }));
+}
+function buildQrBlockCapBlock(file, metrics, hiddenWindows, capBytes) {
+    const mergedHiddenWindows = mergeQrWindows(hiddenWindows);
+    const lineSamples = sampleLargestQrLinesInWindows(metrics, hiddenWindows, MAX_QR_CAP_LINE_SAMPLES);
+    const hiddenSourceWindowBytes = hiddenWindows.reduce((sum, window) => sum + window.bytes, 0);
+    const hiddenUniqueBytes = mergedHiddenWindows.reduce((sum, window) => sum + qrWindowContentBytes(metrics, window), 0);
+    return {
+        file,
+        code: "QR_BLOCK_OUTPUT_CAP_EXCEEDED",
+        details: {
+            capScope: "block",
+            hiddenUniqueBytes,
+            hiddenUniqueKb: bytesToKbValue(hiddenUniqueBytes),
+            hiddenSourceWindowBytes,
+            hiddenSourceWindowKb: bytesToKbValue(hiddenSourceWindowBytes),
+            capBytes,
+            capKb: bytesToKbValue(capBytes),
+            hiddenWindows: hiddenWindows.map((window) => ({
+                window: window.label,
+                start: window.start,
+                end: window.end,
+                bytes: window.bytes,
+                sizeKb: bytesToKbValue(window.bytes)
+            })),
+            lineSamples: lineSamples.map((sample) => ({
+                line: sample.line,
+                bytes: sample.bytes,
+                sizeKb: bytesToKbValue(sample.bytes)
+            }))
+        }
+    };
+}
+function buildQrAllCapBlock(file, window, lines, content, capBytes) {
+    if (!isQrCapEnabled(capBytes)) {
+        return null;
+    }
+    const outputBytes = Buffer.byteLength(content, "utf8");
+    if (outputBytes <= capBytes) {
+        return null;
+    }
+    const lineSamples = sampleLargestQrLines(lines, MAX_QR_CAP_LINE_SAMPLES);
+    return {
+        file,
+        window,
+        code: "QR_ALL_OUTPUT_CAP_EXCEEDED",
+        details: {
+            capScope: "all",
+            capAppliedTo: "all",
+            outputBytes,
+            outputKb: bytesToKbValue(outputBytes),
+            capBytes,
+            capKb: bytesToKbValue(capBytes),
+            lineCount: lines.length,
+            lineSamples: lineSamples.map((sample) => ({
+                line: sample.line,
+                bytes: sample.bytes,
+                sizeKb: bytesToKbValue(sample.bytes)
+            }))
+        }
+    };
+}
+function isQrCapEnabled(capBytes) {
+    return typeof capBytes === "number" && Number.isFinite(capBytes) && capBytes > 0;
+}
+function sampleLargestQrLines(lines, limit) {
+    const minSampleBytes = 512;
+    return lines
+        .map((line, index) => ({ line: index + 1, bytes: Buffer.byteLength(line, "utf8") }))
+        .filter((sample) => sample.bytes >= minSampleBytes)
+        .sort((left, right) => right.bytes - left.bytes || left.line - right.line)
+        .slice(0, limit)
+        .sort((left, right) => left.line - right.line);
+}
+function sampleLargestQrLinesInWindows(metrics, windows, limit) {
+    const minSampleBytes = 512;
+    const samplesByLine = new Map();
+    for (const window of windows) {
+        const windowSamples = metrics.lineBytes
+            .slice(window.start - 1, window.end)
+            .map((bytes, index) => ({ line: window.start + index, bytes }))
+            .filter((sample) => sample.bytes >= minSampleBytes)
+            .sort((left, right) => right.bytes - left.bytes || left.line - right.line)
+            .slice(0, 2);
+        for (const sample of windowSamples) {
+            samplesByLine.set(sample.line, sample);
+        }
+    }
+    if (samplesByLine.size < limit) {
+        for (const sample of sampleLargestQrLinesInRanges(metrics, windows, limit)) {
+            samplesByLine.set(sample.line, sample);
+            if (samplesByLine.size >= limit) {
+                break;
+            }
+        }
+    }
+    return Array.from(samplesByLine.values())
+        .sort((left, right) => left.line - right.line)
+        .slice(0, limit);
+}
+function sampleLargestQrLinesInRanges(metrics, windows, limit) {
+    const seen = new Set();
+    const samples = [];
+    for (const window of windows) {
+        for (let line = window.start; line <= window.end; line += 1) {
+            if (seen.has(line)) {
+                continue;
+            }
+            seen.add(line);
+            samples.push({ line, bytes: metrics.lineBytes[line - 1] ?? 0 });
+        }
+    }
+    return samples
+        .filter((sample) => sample.bytes >= 512)
+        .sort((left, right) => right.bytes - left.bytes || left.line - right.line)
+        .slice(0, limit)
+        .sort((left, right) => left.line - right.line);
+}
+function readQrOutputCapBytes(cwd, env) {
+    if (isOutputCapDisabled(env[GLOBAL_OUTPUT_CAP_ENV])) {
+        return null;
+    }
+    const envValue = readQrOutputCapKbEnvOverride(env[QR_OUTPUT_CAP_KB_ENV]);
+    if (envValue !== undefined) {
+        return capKbToBytes(envValue);
+    }
+    const configValue = readWorkspaceQrOutputCapKb(cwd);
+    if (configValue !== undefined) {
+        return capKbToBytes(configValue);
+    }
+    return capKbToBytes(DEFAULT_QR_OUTPUT_CAP_KB);
+}
+function readQrOutputCapKbEnvOverride(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (isDisabledOutputCapToken(normalized)) {
+        return null;
+    }
+    const parsed = Number(normalized);
+    if (!Number.isFinite(parsed)) {
+        return undefined;
+    }
+    return normalizeOutputCapKb(parsed);
+}
+function readWorkspaceQrOutputCapKb(cwd) {
+    const resolved = (0, workspace_root_1.resolveWorkspaceRoot)(cwd);
+    if (!resolved || !Object.prototype.hasOwnProperty.call(resolved.config, QR_OUTPUT_CAP_KB_CONFIG_KEY)) {
+        return undefined;
+    }
+    return readOutputCapKbConfigValue(resolved.config[QR_OUTPUT_CAP_KB_CONFIG_KEY]);
+}
+function readOutputCapKbConfigValue(value) {
+    if (typeof value === "boolean") {
+        return value ? DEFAULT_QR_OUTPUT_CAP_KB : null;
+    }
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (isDisabledOutputCapToken(normalized)) {
+            return null;
+        }
+        const parsed = Number(normalized);
+        return normalizeOutputCapKb(parsed);
+    }
+    return typeof value === "number" ? normalizeOutputCapKb(value) : null;
+}
+function isOutputCapDisabled(value) {
+    return value !== undefined && isDisabledOutputCapToken(value.trim().toLowerCase());
+}
+function isDisabledOutputCapToken(value) {
+    return value === "" || value === "off" || value === "disabled" || value === "false" || value === "0";
+}
+function normalizeOutputCapKb(value) {
+    return Number.isFinite(value) && value > 0 ? value : null;
+}
+function capKbToBytes(value) {
+    return typeof value === "number" ? Math.round(value * 1024) : null;
+}
+function bytesToKbValue(bytes) {
+    return Math.round((bytes / 1024) * 10) / 10;
+}
+function formatKbValue(value) {
+    return Number.isInteger(value) ? String(value) : value.toFixed(1);
+}
+async function readTextFileLines(filePath) {
+    let stat;
+    try {
+        stat = await fs.stat(filePath);
+    }
+    catch (error) {
+        const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
+        return { error: code === "ENOENT" ? "file not found" : "cannot stat file" };
+    }
+    if (stat.isDirectory()) {
+        return { error: "is a directory" };
+    }
+    if (!stat.isFile()) {
+        return { error: "not a regular file" };
+    }
+    let buffer;
+    try {
+        buffer = await fs.readFile(filePath);
+    }
+    catch {
+        return { error: "cannot read file" };
+    }
+    if (isProbablyBinary(buffer)) {
+        return { error: "binary file" };
+    }
+    return { lines: splitLines(buffer.toString("utf8")) };
+}
+function isProbablyBinary(buffer) {
+    const length = Math.min(buffer.length, 8192);
+    for (let index = 0; index < length; index += 1) {
+        if (buffer[index] === 0) {
+            return true;
+        }
+    }
+    return false;
+}
+function splitLines(text) {
+    const normalized = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    return normalized.endsWith("\n") ? normalized.slice(0, -1).split("\n") : normalized.split("\n");
+}
+function parseStdinRequests(cwd, aliases, displayAliases, raw) {
+    const lines = raw.replace(/^\uFEFF/, "").split(/\r?\n/);
+    const requests = [];
+    const errors = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index]?.trim() ?? "";
+        if (!line || line.startsWith("#")) {
+            continue;
+        }
+        let tokens;
+        try {
+            tokens = tokenize(line);
+        }
+        catch (error) {
+            errors.push(errorBlock(`stdin line ${index + 1}`, error));
+            continue;
+        }
+        if (tokens.length === 0) {
+            continue;
+        }
+        const effectiveTokens = tokens[0] === "qr" ? tokens.slice(1) : tokens;
+        const parsed = parseInlineRequests(cwd, aliases, displayAliases, effectiveTokens);
+        requests.push(...parsed.requests);
+        errors.push(...parsed.errors.map((block) => ({
+            ...block,
+            file: `stdin line ${index + 1}: ${block.file}`
+        })));
+    }
+    if (requests.length === 0 && errors.length === 0) {
+        throw new errors_1.CliError("QR_STDIN_EMPTY", "qr --stdin expects at least one qr line.");
+    }
+    return { requests, errors };
+}
+function parseInlineRequests(cwd, aliases, displayAliases, args) {
+    const filteredArgs = args.filter((arg) => arg !== "--stdin");
+    const effectiveArgs = filteredArgs[0] === "qr" ? filteredArgs.slice(1) : filteredArgs;
+    const grouped = groupInlineQrArgs(effectiveArgs);
+    if (grouped.length === 0) {
+        throw new errors_1.CliError("QR_FILE_REQUIRED", "qr expects a file path.");
+    }
+    const requests = [];
+    const errors = [];
+    for (const group of grouped) {
+        if ("error" in group) {
+            errors.push({ file: group.file, error: group.error, code: group.code });
+            continue;
+        }
+        const parsedWindows = parseWindows(group.windowArgs);
+        errors.push(...parsedWindows.errors);
+        try {
+            requests.push(buildRequest(cwd, aliases, displayAliases, group.file, parsedWindows.windows));
+        }
+        catch (error) {
+            errors.push(errorBlock(group.file, error));
+        }
+    }
+    return { requests, errors };
+}
+function groupInlineQrArgs(args) {
+    const grouped = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const current = args[index] ?? "";
+        if (isWindowArg(current)) {
+            if (grouped.length === 0) {
+                grouped.push({
+                    file: current,
+                    windowArgs: [],
+                    error: "qr expects a file path before window flags.",
+                    code: "QR_FILE_REQUIRED"
+                });
+                if (expectsWindowValue(current)) {
+                    index += 1;
+                }
+                continue;
+            }
+            grouped[grouped.length - 1].windowArgs.push(current);
+            if (expectsWindowValue(current)) {
+                index += 1;
+                grouped[grouped.length - 1].windowArgs.push(args[index] ?? "");
+            }
+            continue;
+        }
+        grouped.push({ file: current, windowArgs: [] });
+    }
+    return grouped;
+}
+function buildRequest(cwd, aliases, displayAliases, file, windows) {
+    if (!file || file.startsWith("-") || isWindowToken(file)) {
+        throw new errors_1.CliError("QR_FILE_REQUIRED", "qr expects a file path before window flags.");
+    }
+    const resolvedFile = path.resolve(cwd, (0, path_aliases_1.expandPathAliasValue)(cwd, file, aliases));
+    return {
+        file,
+        resolvedFile,
+        displayFile: (0, path_display_1.compactDisplayPath)(cwd, resolvedFile, displayAliases),
+        windows
+    };
+}
+function parseWindows(args) {
+    let all = false;
+    let head = null;
+    let tail = null;
+    let offset = null;
+    let limit = null;
+    const ranges = [];
+    const errors = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const current = args[index] ?? "";
+        const assignment = parseAssignment(current);
+        if (assignment) {
+            assignWindowValue(assignment.key, assignment.value);
+            continue;
+        }
+        if (current === "-a" || current === "--all" || current === "a" || current === "all" || current === "+all") {
+            all = true;
+            continue;
+        }
+        if (current === "-h" || current === "--head") {
+            const next = args[index + 1];
+            if (!next || next.startsWith("-")) {
+                head = DEFAULT_HEAD_LINES;
+                errors.push(defaultedWindowError(`Expected a value after ${current}, used ${DEFAULT_HEAD_LINES} by default.`));
+            }
+            else {
+                index += 1;
+                head = parsePositiveIntegerOrDefault(next, current, DEFAULT_HEAD_LINES, errors);
+            }
+            continue;
+        }
+        if (current === "-t" || current === "--tail") {
+            const next = args[index + 1];
+            if (!next || next.startsWith("-")) {
+                tail = DEFAULT_HEAD_LINES;
+                errors.push(defaultedWindowError(`Expected a value after ${current}, used ${DEFAULT_HEAD_LINES} by default.`));
+            }
+            else {
+                index += 1;
+                tail = parsePositiveIntegerOrDefault(next, current, DEFAULT_HEAD_LINES, errors);
+            }
+            continue;
+        }
+        if (current === "-o" || current === "--offset") {
+            offset = readNextPositiveOrDefault(args, ++index, current, 1, errors);
+            continue;
+        }
+        if (current === "-l" || current === "--limit") {
+            limit = readNextPositiveOrDefault(args, ++index, current, DEFAULT_HEAD_LINES, errors);
+            continue;
+        }
+        if (current === "-r" || current === "--range" || current === "--ranges") {
+            const next = args[index + 1];
+            if (!next || next.startsWith("-")) {
+                errors.push(defaultedWindowError(`Expected a value after ${current}, ignored range flag.`));
+            }
+            else {
+                index += 1;
+                ranges.push(...parseRangeWindows(next, current, errors));
+            }
+            continue;
+        }
+        if (current === "-s" || current === "--slice" || current === "--slices") {
+            const next = args[index + 1];
+            if (!next || next.startsWith("-")) {
+                errors.push(defaultedWindowError(`Expected a value after ${current}, ignored slice flag.`));
+            }
+            else {
+                index += 1;
+                ranges.push(...parseSliceWindows(next, current, errors));
+            }
+            continue;
+        }
+        errors.push({
+            file: "",
+            error: `Unknown qr argument: ${current}`,
+            code: "QR_UNKNOWN_ARGUMENT",
+            details: { argument: current }
+        });
+    }
+    if (offset === null && limit !== null) {
+        head = limit;
+        limit = null;
+    }
+    if (offset !== null && limit === null) {
+        limit = DEFAULT_HEAD_LINES;
+    }
+    if (all) {
+        return { windows: [{ kind: "all" }], errors };
+    }
+    const windows = [];
+    if (head !== null) {
+        windows.push({ kind: "head", count: head });
+    }
+    if (offset !== null && limit !== null) {
+        windows.push({ kind: "range", offset, limit });
+    }
+    windows.push(...ranges);
+    if (tail !== null) {
+        windows.push({ kind: "tail", count: tail });
+    }
+    return { windows: windows.length > 0 ? windows : [{ kind: "head", count: DEFAULT_HEAD_LINES }], errors };
+    function assignWindowValue(key, value) {
+        if (key === "a" || key === "all") {
+            const parsed = parseBooleanFlagOrNull(value);
+            if (parsed === null) {
+                errors.push(defaultedWindowError(`${key} expects true or false, ignored.`));
+            }
+            else {
+                all = parsed;
+            }
+            return;
+        }
+        if (key === "r" || key === "range" || key === "ranges") {
+            ranges.push(...parseRangeWindows(value, key, errors));
+            return;
+        }
+        if (key === "s" || key === "slice" || key === "slices") {
+            ranges.push(...parseSliceWindows(value, key, errors));
+            return;
+        }
+        if (key === "h" || key === "head") {
+            head = parsePositiveIntegerOrDefault(value, key, DEFAULT_HEAD_LINES, errors);
+            return;
+        }
+        if (key === "t" || key === "tail") {
+            tail = parsePositiveIntegerOrDefault(value, key, DEFAULT_HEAD_LINES, errors);
+            return;
+        }
+        if (key === "o" || key === "offset") {
+            offset = parsePositiveIntegerOrDefault(value, key, 1, errors);
+            return;
+        }
+        if (key === "l" || key === "limit") {
+            limit = parsePositiveIntegerOrDefault(value, key, DEFAULT_HEAD_LINES, errors);
+            return;
+        }
+        errors.push({
+            file: "",
+            error: `Unknown qr window field: ${key}`,
+            code: "QR_UNKNOWN_ARGUMENT",
+            details: { argument: key }
+        });
+    }
+}
+function resolveQrSourceWindows(lines, windows) {
+    if (windows.some((window) => window.kind === "all")) {
+        return [{ label: "all", start: 1, end: lines.length }];
+    }
+    return windows
+        .map((window) => toLineRange(lines.length, window))
+        .filter((range) => range.end >= range.start)
+        .sort((left, right) => left.start - right.start || left.end - right.end);
+}
+function mergeQrWindows(windows) {
+    const ranges = windows
+        .slice()
+        .sort((left, right) => left.start - right.start || left.end - right.end);
+    const merged = [];
+    for (const range of ranges) {
+        const previous = merged[merged.length - 1];
+        if (previous && range.start <= previous.end + 1) {
+            previous.end = Math.max(previous.end, range.end);
+            previous.labels.push(range.label);
+            continue;
+        }
+        merged.push({ ...range, labels: [range.label] });
+    }
+    return merged.map((range) => ({
+        label: range.labels.length === 1 ? range.labels[0] : formatMergedWindowLabel(range.start, range.end, range.labels),
+        start: range.start,
+        end: range.end
+    }));
+}
+function buildQrLineMetrics(lines) {
+    const lineBytes = lines.map((line) => Buffer.byteLength(line, "utf8"));
+    const prefixBytes = [0];
+    for (const bytes of lineBytes) {
+        prefixBytes.push((prefixBytes[prefixBytes.length - 1] ?? 0) + bytes);
+    }
+    return { lineBytes, prefixBytes };
+}
+function qrWindowContentBytes(metrics, window) {
+    if (window.end < window.start) {
+        return 0;
+    }
+    const startIndex = Math.max(0, window.start - 1);
+    const endIndex = Math.min(metrics.lineBytes.length, window.end);
+    if (endIndex <= startIndex) {
+        return 0;
+    }
+    const lineBytes = (metrics.prefixBytes[endIndex] ?? 0) - (metrics.prefixBytes[startIndex] ?? 0);
+    const newlineBytes = Math.max(0, endIndex - startIndex - 1);
+    return lineBytes + newlineBytes;
+}
+function formatMergedWindowLabel(start, end, labels) {
+    if (labels.every((label) => label.startsWith("s="))) {
+        return start === end ? `s=${start}` : `s=${start}:${end}`;
+    }
+    return `r=${start}:${end - start + 1}`;
+}
+function toLineRange(lineCount, window) {
+    if (window.kind === "head") {
+        return {
+            start: 1,
+            end: Math.min(lineCount, window.count),
+            label: formatWindow(window)
+        };
+    }
+    if (window.kind === "tail") {
+        return {
+            start: Math.max(1, lineCount - window.count + 1),
+            end: lineCount,
+            label: formatWindow(window)
+        };
+    }
+    if (window.kind === "range") {
+        return {
+            start: Math.max(1, Math.min(window.offset, lineCount + 1)),
+            end: Math.min(lineCount, window.offset + window.limit - 1),
+            label: formatWindow(window)
+        };
+    }
+    return { start: 1, end: lineCount, label: "all" };
+}
+function parseRangeWindows(value, label, errors) {
+    return value.split(",").map((part) => part.trim()).filter(Boolean).map((part) => {
+        const [offsetValue, limitValue] = part.split(":");
+        const offset = parsePositiveIntegerOrDefault(offsetValue ?? "", label, 1, errors);
+        const limit = limitValue && limitValue.length > 0
+            ? parsePositiveIntegerOrDefault(limitValue, label, DEFAULT_HEAD_LINES, errors)
+            : DEFAULT_HEAD_LINES;
+        return { kind: "range", offset, limit };
+    });
+}
+function parseSliceWindows(value, label, errors) {
+    return value.split(",").map((part) => part.trim()).filter(Boolean).flatMap((part) => {
+        const [fromValue, toValue] = part.split(":");
+        const from = parsePositiveIntegerOrDefault(fromValue ?? "", label, 1, errors);
+        if (toValue === undefined || toValue.length === 0) {
+            return [{ kind: "range", offset: from, limit: 1, display: `s=${from}` }];
+        }
+        const to = parsePositiveIntegerOrDefault(toValue, label, from, errors);
+        if (to < from) {
+            errors.push(defaultedWindowError(`${windowDiagnosticLabel(label)} expects end line >= start line, ignored ${part}.`));
+            return [];
+        }
+        return [{ kind: "range", offset: from, limit: to - from + 1, display: startEndSliceLabel(from, to) }];
+    });
+}
+function startEndSliceLabel(start, end) {
+    return start === end ? `s=${start}` : `s=${start}:${end}`;
+}
+function parseBooleanFlag(value, label) {
+    if (value === "true" || value === "1" || value === "yes") {
+        return true;
+    }
+    if (value === "false" || value === "0" || value === "no") {
+        return false;
+    }
+    throw new errors_1.CliError("QR_INVALID_BOOLEAN", `${label} expects true or false.`);
+}
+function parseAssignment(value) {
+    const index = value.indexOf("=");
+    if (index <= 0) {
+        return null;
+    }
+    return {
+        key: value.slice(0, index),
+        value: value.slice(index + 1)
+    };
+}
+function readNextPositiveOrDefault(args, index, flag, fallback, errors) {
+    const value = args[index];
+    if (!value || value.startsWith("-")) {
+        errors.push(defaultedWindowError(`Expected a value after ${flag}, used ${fallback} by default.`));
+        return fallback;
+    }
+    return parsePositiveIntegerOrDefault(value, flag, fallback, errors);
+}
+function parsePositiveInteger(value, label) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+        throw new errors_1.CliError("QR_INVALID_NUMBER", `${label} expects a positive integer.`);
+    }
+    return parsed;
+}
+function parsePositiveIntegerOrDefault(value, label, fallback, errors) {
+    try {
+        return parsePositiveInteger(value, label);
+    }
+    catch {
+        errors.push(defaultedWindowError(`${windowDiagnosticLabel(label)} expects a positive integer, used ${fallback} by default.`));
+        return fallback;
+    }
+}
+function windowDiagnosticLabel(label) {
+    if (label === "-h" || label === "--head" || label === "head") {
+        return "h";
+    }
+    if (label === "-t" || label === "--tail" || label === "tail") {
+        return "t";
+    }
+    if (label === "-o" || label === "--offset" || label === "offset") {
+        return "o";
+    }
+    if (label === "-l" || label === "--limit" || label === "limit") {
+        return "l";
+    }
+    if (label === "-r" || label === "--range" || label === "--ranges" || label === "range" || label === "ranges") {
+        return "r";
+    }
+    if (label === "-s" || label === "--slice" || label === "--slices" || label === "slice" || label === "slices") {
+        return "s";
+    }
+    return label;
+}
+function parseBooleanFlagOrNull(value) {
+    if (value === "true" || value === "1" || value === "yes") {
+        return true;
+    }
+    if (value === "false" || value === "0" || value === "no") {
+        return false;
+    }
+    return null;
+}
+function defaultedWindowError(error) {
+    return {
+        file: "",
+        error,
+        code: "QR_WINDOW_DEFAULT"
+    };
+}
+function isWindowToken(value) {
+    return /^(?:h|head|t|tail|o|offset|l|limit|r|range|ranges|s|slice|slices|a|all)=/.test(value) || value === "+all";
+}
+function isWindowArg(value) {
+    return value.startsWith("-") || isWindowToken(value) || value === "a" || value === "all";
+}
+function expectsWindowValue(value) {
+    return ["-h", "--head", "-t", "--tail", "-o", "--offset", "-l", "--limit", "-r", "--range", "--ranges", "-s", "--slice", "--slices"].includes(value);
+}
+function formatQrBlocks(blocks) {
+    const readable = blocks.filter((block) => block.error === undefined);
+    const errors = blocks.filter((block) => block.error !== undefined);
+    const parts = formatReadableQrBlocks(readable);
+    if (errors.length > 0) {
+        const errorText = formatQrErrors(errors);
+        if (errorText) {
+            parts.push(errorText);
+        }
+    }
+    return parts.join("\n\n");
+}
+function formatReadableQrBlocks(blocks) {
+    const fileCounts = new Map();
+    for (const block of blocks) {
+        fileCounts.set(block.file, (fileCounts.get(block.file) ?? 0) + 1);
+    }
+    const parts = [];
+    let previousGroupedFile = null;
+    for (const block of blocks) {
+        const grouped = (fileCounts.get(block.file) ?? 0) > 1;
+        if (!grouped) {
+            previousGroupedFile = null;
+            parts.push(formatSingleQrBlock(block));
+            continue;
+        }
+        if (previousGroupedFile !== block.file) {
+            parts.push(`// ${block.file}\n${formatQrWindowBlock(block)}`);
+            previousGroupedFile = block.file;
+            continue;
+        }
+        parts.push(formatQrWindowBlock(block));
+    }
+    return parts;
+}
+function formatSingleQrBlock(block) {
+    const capText = formatQrAllOutputCapBlock(block, `// ${block.file}${block.window ? ` ${block.window}` : ""}`);
+    if (capText) {
+        return capText;
+    }
+    const blockCapText = formatQrBlockOutputCapBlock(block, `// ${block.file}`);
+    if (blockCapText) {
+        return blockCapText;
+    }
+    const header = `// ${block.file}${block.window ? ` ${block.window}` : ""}`;
+    return block.content ? `${header}\n${block.content}` : `${header}\n`;
+}
+function formatQrWindowBlock(block) {
+    const capText = formatQrAllOutputCapBlock(block, `// ${block.window ?? "window"}`);
+    if (capText) {
+        return capText;
+    }
+    const blockCapText = formatQrBlockOutputCapBlock(block, null);
+    if (blockCapText) {
+        return blockCapText;
+    }
+    const header = `// ${block.window ?? "window"}`;
+    return block.content ? `${header}\n${block.content}` : `${header}\n`;
+}
+function formatQrAllOutputCapBlock(block, header) {
+    if (block.code !== "QR_ALL_OUTPUT_CAP_EXCEEDED") {
+        return null;
+    }
+    const outputKb = typeof block.details?.outputKb === "number" ? block.details.outputKb : 0;
+    const capKb = typeof block.details?.capKb === "number" ? block.details.capKb : 0;
+    const lines = [
+        header,
+        `AIB_QR_ALL_OUTPUT_CAP_EXCEEDED: ${formatKbValue(outputKb)} KB > ${formatKbValue(capKb)} KB`,
+        "line  size KB",
+        ...formatQrLineSamples(block.details?.lineSamples)
+    ];
+    return lines.join("\n");
+}
+function formatQrBlockOutputCapBlock(block, header) {
+    if (block.code !== "QR_BLOCK_OUTPUT_CAP_EXCEEDED") {
+        return null;
+    }
+    const capKb = typeof block.details?.capKb === "number" ? block.details.capKb : 0;
+    const lines = [
+        ...(header !== null ? [header] : []),
+        `AIB_QR_BLOCK_OUTPUT_CAP_EXCEEDED: cap = ${formatKbValue(capKb)} KB`,
+        ...formatQrHiddenWindows(block.details?.hiddenWindows),
+        "line  size KB",
+        ...formatQrLineSamples(block.details?.lineSamples)
+    ];
+    return lines.join("\n");
+}
+function formatQrHiddenWindows(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const windows = value.filter((item) => isJsonObject(item) &&
+        typeof item.window === "string" &&
+        typeof item.sizeKb === "number");
+    if (windows.length === 0) {
+        return [];
+    }
+    if (windows.length === 1) {
+        const window = windows[0];
+        return [`${window.window}: ${formatKbValue(window.sizeKb)} KB`];
+    }
+    return [
+        "hidden:",
+        "window    size KB",
+        ...windows.map((window) => `${String(window.window).padEnd(9)} ${formatKbValue(window.sizeKb)}`)
+    ];
+}
+function formatQrLineSamples(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.flatMap((item) => {
+        if (!isJsonObject(item) || typeof item.line !== "number" || typeof item.sizeKb !== "number") {
+            return [];
+        }
+        return `${String(item.line).padEnd(5)} ${formatKbValue(item.sizeKb)}`;
+    });
+}
+function formatWindow(window) {
+    if (window.kind === "all") {
+        return "all";
+    }
+    if (window.kind === "head") {
+        return `h=${window.count}`;
+    }
+    if (window.kind === "tail") {
+        return `t=${window.count}`;
+    }
+    return window.display ?? `r=${window.offset}:${window.limit}`;
+}
+function formatQrErrors(blocks) {
+    const lines = ["errors:"];
+    const diagnostics = uniqueStrings(blocks
+        .filter((block) => block.code === "QR_FILE_REQUIRED" || block.code === "QR_UNTERMINATED_QUOTE")
+        .map((block) => block.error)
+        .filter((item) => Boolean(item)));
+    for (const diagnostic of diagnostics) {
+        lines.push(diagnostic);
+    }
+    const windowDefaults = blocks.filter((block) => block.code === "QR_WINDOW_DEFAULT");
+    for (const block of windowDefaults) {
+        lines.push(block.error ?? "qr window defaulted.");
+    }
+    appendGroupedFileErrors(lines, "files not found:", blocks.filter((block) => block.error === "file not found"));
+    appendGroupedFileErrors(lines, "directories:", blocks.filter((block) => block.error === "is a directory"));
+    appendGroupedFileErrors(lines, "binary files:", blocks.filter((block) => block.error === "binary file"));
+    appendGroupedFileErrors(lines, "read errors:", blocks.filter((block) => block.error !== undefined &&
+        !["file not found", "is a directory", "binary file"].includes(block.error) &&
+        block.code !== "QR_FILE_REQUIRED" &&
+        block.code !== "QR_UNTERMINATED_QUOTE" &&
+        block.code !== "QR_UNKNOWN_ARGUMENT" &&
+        block.code !== "QR_WINDOW_DEFAULT" &&
+        block.code !== "UNKNOWN_PATH_ALIAS"));
+    const unknownAliases = uniqueStrings(blocks
+        .map((block) => typeof block.details?.alias === "string" ? `@${block.details.alias}` : null)
+        .filter((item) => Boolean(item)));
+    if (unknownAliases.length > 0) {
+        lines.push(`unknown AIB path alias: ${unknownAliases.join(" ")}`);
+    }
+    const availableAliases = firstAvailableAliases(blocks);
+    if (availableAliases.length > 0) {
+        lines.push("", "available aliases:");
+        lines.push(availableAliases.join(", "));
+    }
+    return lines.length > 1 ? lines.join("\n") : "";
+}
+function appendGroupedFileErrors(lines, title, blocks) {
+    if (blocks.length === 0) {
+        return;
+    }
+    lines.push(title);
+    for (const file of sortQrErrorFiles(uniqueStrings(blocks.map((block) => block.file).filter(Boolean)))) {
+        lines.push(file);
+    }
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values));
+}
+function sortQrErrorFiles(files) {
+    return files.slice().sort((left, right) => qrErrorFileRank(left) - qrErrorFileRank(right));
+}
+function qrErrorFileRank(file) {
+    if (file === "BATCH") {
+        return 3;
+    }
+    if (file.startsWith("@") || file.includes("/") || file.includes("\\")) {
+        return 0;
+    }
+    return 1;
+}
+function firstAvailableAliases(blocks) {
+    for (const block of blocks) {
+        const available = Array.isArray(block.details?.available)
+            ? block.details.available.filter((item) => typeof item === "string")
+            : [];
+        if (available.length > 0) {
+            return available.map((alias) => `@${alias}`);
+        }
+    }
+    return [];
+}
+function errorBlock(file, error) {
+    if (error instanceof errors_1.CliError) {
+        const details = isJsonObject(error.details) ? error.details : undefined;
+        const alias = typeof details?.alias === "string" ? details.alias : null;
+        return {
+            file,
+            error: alias ? `unknown AIB path alias: @${alias}` : error.message,
+            code: error.code,
+            ...(details ? { details } : {})
+        };
+    }
+    return {
+        file,
+        error: error instanceof Error ? error.message : String(error)
+    };
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function tokenize(line) {
+    const tokens = [];
+    let current = "";
+    let quote = null;
+    for (let index = 0; index < line.length; index += 1) {
+        const char = line[index] ?? "";
+        if (quote) {
+            if (char === quote) {
+                quote = null;
+            }
+            else {
+                current += char;
+            }
+            continue;
+        }
+        if (char === "\"" || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            if (current.length > 0) {
+                tokens.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (quote) {
+        throw new errors_1.CliError("QR_UNTERMINATED_QUOTE", "qr input has an unterminated quote.");
+    }
+    if (current.length > 0) {
+        tokens.push(current);
+    }
+    return tokens;
+}
+async function readRawStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}