buninu 0.4.19 → 0.4.21

package/apps/bunmsh/help/return.md

@@ -0,0 +1,23 @@
+## return
+
+Return from a function or sourced script. Without STATUS, preserve the previous status.
+
+### Usage
+
+```sh
+return [STATUS]
+```
+
+### Example
+
+```sh
+f () { return 7; }
+f
+echo "$?"
+```
+
+Output:
+
+```text
+7
+```

package/apps/bunmsh/help/sed.md

@@ -1,20 +1,25 @@
 ## sed
 
-Apply supported print and substitution expressions.
+Apply editing commands to pattern and hold spaces.
 
 ### Usage
 
 ```sh
-sed [-nEr] [-e SCRIPT] [-i] [SCRIPT] [FILE ...]
+sed [-nEr] [-e SCRIPT | -f FILE] [-i] [SCRIPT] [FILE ...]
 ```
 
 ### Options and forms
 
 - `-n`: Suppress automatic output.
 - `-e SCRIPT`, `-eSCRIPT`: Add a script.
+- `-f FILE`, `-fFILE`: Read a script from a file.
 - `-E`, `-r`: Use extended regular expressions.
 - `-i`: Edit files in place.
-- Supported commands include numeric `p` and `s///` with `g` and `p` flags.
+- Numeric, last-line (`$`), and regular-expression addresses; ranges, inversion, and `{ ... }` groups.
+- `s///` with `g`, `p`, and occurrence-number flags; `y///` translation.
+- `p`, `P`, `d`, `D`, `q`, `=`, `n`, `N`; hold-space commands `h`, `H`, `g`, `G`, `x`.
+- Labels (`:`), unconditional branches (`b`), and substitution-test branches (`t`, `T`).
+- `a`, `i`, `c` text commands; `r FILE` appends file contents after the current cycle. Missing/unreadable files are skipped. This remains a subset: `w` is not implemented.
 
 ### Example
 

package/apps/bunmsh/help/set.md

@@ -1,16 +1,25 @@
 ## set
 
-Print variables or replace positional parameters.
+Print variables, replace positional parameters, or change shell options.
 
 ### Usage
 
 ```sh
-set [-- [ARG ...]]
+set [-eufxv] [+eufxv] [-o NAME | +o NAME] [-- [ARG ...]]
 ```
 
 ### Options and forms
 
-- `--`: Replace positional parameters with the remaining arguments. With no arguments, print variables.
+- No arguments: print variables.
+- `--`: replace positional parameters, including clearing them with no following arguments.
+- `-`: end options and disable verbose/xtrace; replace positional parameters only when arguments follow.
+- `-e` / `+e`: enable/disable exit on untested failures. Conditions, negation and non-final AND/OR commands suppress it.
+- `-u` / `+u`: enable/disable errors for unset parameters; explicit defaults still work.
+- `-f` / `+f`: disable/enable pathname expansion.
+- `-x` / `+x`: enable/disable execution tracing.
+- `-o` / `+o` without a name: list named option states / reusable set commands.
+- Names: `errexit`, `nounset`, `noglob`, `xtrace`, `verbose`, `posix`. CLI `-v` prints initial input; incremental verbose reading is not yet implemented.
+- `-o posix`: enable compatibility mode. The fallback `ls` prints without icons or automatic directory suffixes; `lsfancy` remains decorative. External programs receive only inherited/exported variables and command-prefix assignments; pipelines and subshells still receive complete shell state. Use `+o posix` to restore the default, which passes all variables to external programs. This option is not a guarantee of complete POSIX semantics.
 
 ### Example
 

package/apps/bunmsh/help/tr.md

@@ -24,3 +24,7 @@ Output:
 ```text
 HELLO
 ```
+
+`-s SET` squeezes repeated characters in SET. With two sets, translation happens
+before squeezing SET2. `-ds SET1 SET2` deletes SET1 then squeezes SET2.
+`--` ends option parsing; unsupported options report an error.

package/apps/bunmsh/help/trap.md

@@ -0,0 +1,22 @@
+## trap
+
+Register shell code for EXIT (0) or a catchable signal. No operands lists handlers; ACTION - resets and an empty ACTION ignores the signal in this shell. Signal handlers are deferred to command boundaries. Background process ownership is unchanged.
+
+### Usage
+
+```sh
+trap [ACTION SIGNAL ...]
+```
+
+### Example
+
+```sh
+trap 'echo done' 0
+exit 0
+```
+
+Output:
+
+```text
+done
+```

package/apps/bunmsh/help/uniq.md

@@ -0,0 +1,27 @@
+## uniq
+
+Collapse adjacent equal lines without sorting. Comparisons preserve bytes.
+
+### Usage
+
+```sh
+uniq [-cdu] [--] [INPUT [OUTPUT]]
+```
+
+`-c` prefixes counts; `-d` selects repeated groups; `-u` selects single lines.
+`-` reads standard input or writes standard output. Missing final newlines
+are added. Field/character skipping and other GNU options are unsupported.
+
+### Example
+
+```sh
+printf 'a\na\nb\na\n' | uniq
+```
+
+Output:
+
+```text
+a
+b
+a
+```

package/apps/bunmsh/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunmsh",
-  "version": "0.3.11",
+  "version": "0.4.0",
   "description": "Cross-platform command shell for Bun JavaScript",
   "license": "MIT",
   "type": "module",

package/apps/bunmsh/src/awk.js

@@ -0,0 +1,203 @@
+// A tree-walking AWK interpreter. Shell input is data, never JavaScript source.
+class InputString {
+  constructor(text) { this.text=String(text); this.numeric=/^[ \t]*[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?[ \t]*$/.test(this.text); }
+}
+const str=v=>v instanceof InputString?v.text:v==null?'':String(v);
+const num=v=>parseFloat(str(v))||0;
+const numeric=v=>typeof v==='number'||v instanceof InputString&&v.numeric;
+const truth=v=>numeric(v)?num(v)!==0:str(v)!=='';
+const unset=new InputString(''); unset.numeric=true;
+const failure=m=>{throw new Error(`awk: ${m}`);};
+function regex(s,flags='') {
+  s=str(s).replaceAll('[[:space:]]','[\\s]').replaceAll('[[:digit:]]','[0-9]').replaceAll('[[:alnum:]]','[A-Za-z0-9]').replaceAll('[[:alpha:]]','[A-Za-z]').replaceAll('[[:blank:]]','[ \t]');
+  try {return new RegExp(s,flags);}catch(error){failure(`invalid regular expression ${JSON.stringify(s)}: ${error.message}`);}
+}
+function lex(source) {
+  const out=[];let i=0,operand=true;
+  const push=(kind,value)=>{out.push({kind,value});operand=!(kind==='number'||kind==='string'||kind==='regex'||kind==='name'&&!['print','printf','return','exit','getline','in','delete'].includes(value)||[')',']','++','--'].includes(value));};
+  while(i<source.length) {
+    const c=source[i];
+    if(c==='\\'&&source[i+1]==='\n'){i+=2;continue;}
+    if(/[ \t\r]/.test(c)){i++;continue;}
+    if(c==='#'){while(i<source.length&&source[i]!=='\n')i++;continue;}
+    if(c==='\n'){if(!(out.at(-1)?.kind==='op'&&[',','&&','||'].includes(out.at(-1).value)))push('op',';');i++;continue;}
+    if(c==='"'||c==='/'&&operand){
+      const delim=c;let value='';i++;let closed=false;
+      while(i<source.length){const ch=source[i++];if(ch===delim){closed=true;break;}
+        if(ch==='\\') {if(i>=source.length)break;const n=source[i++];
+          if(n==='\n')continue;
+          if(delim==='/'){value+=n==='/'?'/':'\\'+n;continue;}
+          if(/[0-7]/.test(n)){let oct=n;while(oct.length<3&&/[0-7]/.test(source[i]??''))oct+=source[i++];value+=String.fromCharCode(parseInt(oct,8));}
+          else value+=({n:'\n',t:'\t',r:'\r',b:'\b',f:'\f',v:'\v',a:'\x07','\\':'\\','"':'"','/':'/'})[n]??n;
+        }else value+=ch;
+      }
+      if(!closed)failure('unterminated '+(delim==='/'?'regular expression':'string'));
+      push(delim==='/'?'regex':'string',value);continue;
+    }
+    const number=/^(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?/.exec(source.slice(i));
+    if(number){push('number',Number(number[0]));i+=number[0].length;continue;}
+    const name=/^[A-Za-z_][A-Za-z0-9_]*/.exec(source.slice(i));
+    if(name){push('name',name[0]);i+=name[0].length;continue;}
+    const op=/^(?:\+\+|--|\+=|-=|\*=|\/=|%=|\^=|==|!=|<=|>=|!~|&&|\|\||>>|[{}()[\],;?:$+*\/%^<>=!~|\-])/.exec(source.slice(i));
+    if(!op)failure(`unexpected character ${JSON.stringify(c)}`);
+    push('op',op[0]);i+=op[0].length;
+  }
+  out.push({kind:'eof',value:'<eof>'});return out;
+}
+export function compileAwk(source) {
+  const tokens=lex(source);let i=0;
+  // Quoted strings and regex literals are operands even when their contents
+  // happen to spell an operator, separator, or keyword.
+  const peek=()=>['string','regex'].includes(tokens[i].kind)?null:tokens[i].value, take=()=>tokens[i++], eat=v=>peek()===v?(i++,true):false;
+  const need=v=>{if(!eat(v))failure(`expected ${v}, got ${peek()}`);};
+  const separators=()=>{while(eat(';'));};
+  const prec={'=':1,'+=':1,'-=':1,'*=':1,'/=':1,'%=':1,'^=':1,'?':2,'||':3,'&&':4,'in':5,'~':5,'!~':5,'==':6,'!=':6,'<':6,'>':6,'<=':6,'>=':6,'concat':7,'+':8,'-':8,'*':9,'/':9,'%':9,'^':11};
+  const begins=t=>['number','string','regex'].includes(t.kind)||t.kind==='name'&&!['in','else'].includes(t.value)||['(','$'].includes(t.value);
+  function expr(min=0,stopRedirect=false) {
+    let t=take(),node;
+    if(t.kind==='number'||t.kind==='string')node={type:'literal',value:t.value};
+    else if(t.kind==='regex')node={type:'regex',value:t.value};
+    else if(t.value==='('){const values=[expr()];while(eat(','))values.push(expr());need(')');node=values.length===1?values[0]:{type:'list',values};}
+    else if(['!','+','-','++','--','$'].includes(t.value))node={type:t.value==='$'?'field':'unary',op:t.value,value:expr(t.value==='$'?13:10)};
+    else if(t.value==='getline'){
+      let target=null;if(tokens[i].kind==='name'||peek()==='$')target=expr(12);
+      let file=null;if(eat('<'))file=expr(7);
+      node={type:'getline',target,file};
+    }
+    else if(t.kind==='name'){
+      node={type:'variable',name:t.value};
+      if(eat('(')){const args=[];if(peek()!==')')do{args.push(expr());}while(eat(','));need(')');node={type:'call',name:t.value,args};}
+      else if(eat('[')){const keys=[];do{keys.push(expr());}while(eat(','));need(']');node={type:'index',name:t.value,keys};}
+    }else failure(`expected expression, got ${t.value}`);
+    while(true){let op=peek();
+      if(['++','--'].includes(op)){if(12<min)break;i++;node={type:'postfix',op,value:node};continue;}
+      if(stopRedirect&&['>','>>','|'].includes(op))break;
+      let implicit=false;if(prec[op]===undefined&&begins(tokens[i])){op='concat';implicit=true;}
+      const p=prec[op];if(p===undefined||p<min)break;
+      if(!implicit)i++;
+      if(op==='?'){const yes=expr();need(':');node={type:'conditional',condition:node,yes,no:expr(p)};continue;}
+      const right=expr(p+(p===1||op==='^'?0:1),stopRedirect);node={type:p===1?'assign':'binary',op,left:node,right};
+    }
+    return node;
+  }
+  function statement(){separators();
+    if(eat('{')){const body=[];separators();while(peek()!=='}'){if(tokens[i].kind==='eof')failure('unterminated block');body.push(statement());separators();}need('}');return {type:'block',body};}
+    if(eat('if')){need('(');const condition=expr();need(')');const yes=statement();separators();return {type:'if',condition,yes,no:eat('else')?statement():null};}
+    if(eat('while')){need('(');const condition=expr();need(')');return {type:'while',condition,body:statement()};}
+    if(eat('do')){const body=statement();separators();need('while');need('(');const condition=expr();need(')');return {type:'do',body,condition};}
+    if(eat('for')){need('(');const initial=peek()===';'?null:expr();
+      if(initial?.type==='binary'&&initial.op==='in'&&eat(')'))return {type:'forin',initial,body:statement()};
+      need(';');const condition=peek()===';'?null:expr();need(';');const increment=peek()===')'?null:expr();need(')');return {type:'for',initial,condition,increment,body:statement()};}
+    if(['break','continue','next','nextfile','exit','return'].includes(peek())){const op=take().value;const value=['exit','return'].includes(op)&&![';','}','<eof>'].includes(peek())?expr():null;return {type:'flow',op,value};}
+    if(eat('delete'))return {type:'delete',value:expr(12)};
+    if(peek()==='print'||peek()==='printf'){
+      const op=take().value,args=[];
+      if(![';','}','<eof>','>','>>','|'].includes(peek()))do{const value=expr(0,true);args.push(...(value.type==='list'?value.values:[value]));}while(eat(','));
+      let redirect=null;if(['>','>>','|'].includes(peek()))redirect={op:take().value,file:expr()};
+      return {type:'print',op,args,redirect};
+    }
+    return {type:'expression',value:expr()};
+  }
+  const program={begin:[],end:[],rules:[],functions:new Map()};separators();
+  while(tokens[i].kind!=='eof'){
+    if(eat('function')){const name=take();if(name.kind!=='name')failure('expected function name');need('(');const params=[];if(peek()!==')')do{const p=take();if(p.kind!=='name')failure('expected parameter');params.push(p.value);}while(eat(','));need(')');program.functions.set(name.value,{params,body:statement()});}
+    else if(peek()==='BEGIN'||peek()==='END'){const kind=take().value.toLowerCase();separators();if(peek()!=='{')failure(`${kind} requires a block`);program[kind].push(statement());}
+    else {let pattern=null,until=null;if(peek()!=='{'){pattern=expr();if(eat(','))until=expr();}
+      const action=peek()==='{'?statement():{type:'print',op:'print',args:[]};program.rules.push({pattern,until,action});}
+    separators();
+  }
+  return program;
+}
+
+export function executeAwk(program, inputs, options={}) {
+  const vars=new Map(Object.entries({FS:' ',OFS:' ',ORS:'\n',RS:'\n',SUBSEP:'\x1c',CONVFMT:'%.6g',OFMT:'%.6g',NR:0,FNR:0,NF:0,FILENAME:'',RSTART:0,RLENGTH:-1,...Object.fromEntries(Object.entries(options.variables??{}).map(([k,v])=>[k,new InputString(v)]))}));
+  const arrays=new Map(),locals=[];let record='',fields=[],output='',flow=null,status=0,seed=1,inputIndex=0,recordIndex=0,records=[];
+  const readers=new Map(),written=new Set(),ranges=new Map(),pipes=new Map();
+  let stderr='';
+  function closePipe(command) {
+    if(!pipes.has(command))return 0;
+    const text=pipes.get(command);pipes.delete(command);
+    if(!options.runPipe)failure('output pipes require a shell adapter');
+    const p=options.runPipe(command,text);output+=p.stdout??'';stderr+=p.stderr??'';
+    return p.status;
+  }
+  const array=name=>{if(locals.at(-1)?.get(name) instanceof Map)return locals.at(-1).get(name);if(!arrays.has(name))arrays.set(name,new Map());return arrays.get(name);};
+  array('ARGV').set('0','awk');(options.argv??[]).forEach((v,i)=>array('ARGV').set(String(i+1),v));vars.set('ARGC',(options.argv??[]).length+1);
+  for(const [k,v] of Object.entries(options.env??{}))array('ENVIRON').set(k,new InputString(v));
+  const get=name=>{if(locals.at(-1)?.has(name))return locals.at(-1).get(name);return vars.get(name)??unset;};
+  const set=(name,value)=>{if(name==='NF'){const n=Math.trunc(num(value));if(n<0)failure('negative NF');fields.length=n;for(let i=0;i<n;i++)fields[i]??=new InputString('');record=fields.map(str).join(str(get('OFS')));}
+    if(locals.at(-1)?.has(name)){locals.at(-1).set(name,value);return value;}vars.set(name,value);return value;};
+  function split(text,sep){text=str(text);sep=str(sep);if(sep===' ')return text.trim()?text.trim().split(/\s+/):[];if(sep==='')return [...text];return text===''?[]:text.split(sep.length===1?sep:regex(sep));}
+  function setRecord(text){record=str(text);fields=split(record,get('FS')).map(x=>new InputString(x));vars.set('NF',fields.length);}
+  function ref(node){if(node.type==='variable')return {get:()=>get(node.name),set:v=>set(node.name,v)};
+    if(node.type==='index'){const a=array(node.name),k=node.keys.map(x=>str(evaluate(x))).join(str(get('SUBSEP')));return {get:()=>a.get(k)??unset,set:v=>(a.set(k,v),v),remove:()=>a.delete(k)};}
+    if(node.type==='field'){const n=Math.trunc(num(evaluate(node.value)));if(n<0)failure('negative field');return {get:()=>n===0?new InputString(record):fields[n-1]??new InputString(''),set:v=>{if(n===0)setRecord(v);else{while(fields.length<n)fields.push(new InputString(''));fields[n-1]=v;vars.set('NF',fields.length);record=fields.map(str).join(str(get('OFS')));}return v;}};}
+    failure('expression is not assignable');}
+  const pattern=node=>node.type==='regex'?node.value:str(evaluate(node));
+  function sprintf(format,args){let at=0;return str(format).replace(/%([-+ #0]*)(\d*)(?:\.(\d+))?([%csdiouxXeEfFgG])/g,(all,flags,width,precision,kind)=>{
+    if(kind==='%')return '%';const value=args[at++];let s;
+    if(kind==='s')s=str(value).slice(0,precision===undefined?undefined:Number(precision));
+    else if(kind==='c')s=numeric(value)?String.fromCharCode(num(value)):str(value).slice(0,1);
+    else if(/[diouxX]/.test(kind)){let n=Math.trunc(num(value));if(kind==='u')n>>>=0;s=n.toString(kind==='o'?8:/[xX]/.test(kind)?16:10);if(kind==='X')s=s.toUpperCase();}
+    else {const n=num(value),p=precision===undefined?6:Number(precision);s=/f/i.test(kind)?n.toFixed(p):/e/i.test(kind)?n.toExponential(p):String(Number(n.toPrecision(p||1)));if(kind===kind.toUpperCase())s=s.toUpperCase();}
+    if(flags.includes('+')&&num(value)>=0&&kind!=='s')s='+'+s;
+    return flags.includes('-')?s.padEnd(Number(width),' '):s.padStart(Number(width),flags.includes('0')?'0':' ');
+  });}
+  function nextRecord(){while(recordIndex>=records.length){if(inputIndex>=inputs.length)return null;const entry=inputs[inputIndex++];if(entry.assignment){set(entry.assignment[0],new InputString(entry.assignment[1]));continue;}vars.set('FILENAME',entry.name);vars.set('FNR',0);const text=entry.text;const rs=str(get('RS'));records=rs===''?text.replace(/^\n+|\n+$/g,'').split(/\n\n+/):text.split(rs.length===1?rs:regex(rs));if(records.at(-1)==='')records.pop();recordIndex=0;}
+    vars.set('NR',num(get('NR'))+1);vars.set('FNR',num(get('FNR'))+1);return records[recordIndex++];}
+  function call(node){const {name,args}=node;
+    if(name==='split'){const values=split(evaluate(args[0]),args[2]?pattern(args[2]):get('FS'));if(args[1]?.type!=='variable')failure('split requires array name');const a=array(args[1].name);a.clear();values.forEach((v,i)=>a.set(String(i+1),new InputString(v)));return values.length;}
+    if(name==='sub'||name==='gsub'){const re=regex(pattern(args[0]),name==='gsub'?'g':'');const replacement=str(evaluate(args[1]));const target=args[2]?ref(args[2]):{get:()=>record,set:setRecord};let count=0;
+      const text=str(target.get()).replace(re,match=>{count++;let s='';for(let i=0;i<replacement.length;i++){if(replacement[i]==='\\'&&i+1<replacement.length&&['&','\\'].includes(replacement[i+1]))s+=replacement[++i];else s+=replacement[i]==='&'?match:replacement[i];}return s;});target.set(text);return count;}
+    if(name==='match'){const s=str(evaluate(args[0])),m=regex(pattern(args[1])).exec(s);set('RSTART',m?m.index+1:0);set('RLENGTH',m?m[0].length:-1);return get('RSTART');}
+    if(program.functions.has(name)){const fn=program.functions.get(name),scope=new Map();fn.params.forEach((p,i)=>scope.set(p,args[i]?.type==='variable'&&!locals.at(-1)?.has(args[i].name)&&arrays.has(args[i].name)?array(args[i].name):args[i]?evaluate(args[i]):unset));locals.push(scope);let value='';try{run(fn.body);if(flow?.op==='return'){value=flow.value;flow=null;}}finally{locals.pop();}return value;}
+    if(name==='length'&&args[0]?.type==='variable'&&arrays.has(args[0].name))return array(args[0].name).size;
+    const a=args.map(evaluate);
+    switch(name){
+      case 'length':return str(a.length?a[0]:record).length;
+      case 'substr':return str(a[0]).substr(Math.max(0,num(a[1])-1),a.length>2?Math.max(0,num(a[2])):undefined);
+      case 'index':return str(a[0]).indexOf(str(a[1]))+1;
+      case 'sprintf':return sprintf(a[0],a.slice(1));
+      case 'tolower':return str(a[0]).toLowerCase();case 'toupper':return str(a[0]).toUpperCase();
+      case 'int':return Math.trunc(num(a[0]));case 'sqrt':return Math.sqrt(num(a[0]));case 'log':return Math.log(num(a[0]));case 'exp':return Math.exp(num(a[0]));case 'sin':return Math.sin(num(a[0]));case 'cos':return Math.cos(num(a[0]));case 'atan2':return Math.atan2(num(a[0]),num(a[1]));
+      case 'srand':{const old=seed;seed=a.length?num(a[0]):Date.now();return old;}case 'rand':seed=(1664525*seed+1013904223)>>>0;return seed/4294967296;
+      case 'close':{const name=str(a[0]);readers.delete(name);written.delete(name);return closePipe(name);}
+      default:failure(`unsupported function ${name}`);
+    }
+  }
+  function evaluate(n){switch(n.type){
+    case 'literal':return n.value;case 'regex':return Number(regex(n.value).test(record));
+    case 'variable':if(n.name==='length')return record.length;return get(n.name);
+    case 'index':case 'field':return ref(n).get();case 'call':return call(n);
+    case 'conditional':return evaluate(truth(evaluate(n.condition))?n.yes:n.no);
+    case 'getline':{let text;if(n.file){const path=str(evaluate(n.file));try{if(!readers.has(path))readers.set(path,{lines:options.readFile(path).split('\n'),i:0});const r=readers.get(path);if(r.lines.at(-1)==='')r.lines.pop();text=r.i<r.lines.length?r.lines[r.i++]:null;}catch{return -1;}}else text=nextRecord();if(text===null)return 0;if(n.target)ref(n.target).set(new InputString(text));else setRecord(text);return 1;}
+    case 'unary':case 'postfix':{if(n.op==='++'||n.op==='--'){const r=ref(n.value),v=num(r.get()),next=v+(n.op==='++'?1:-1);r.set(next);return n.type==='postfix'?v:next;}const v=evaluate(n.value);return n.op==='!'?Number(!truth(v)):n.op==='-'?-num(v):num(v);}
+    case 'assign':{const r=ref(n.left),v=evaluate(n.right);return r.set(n.op==='='?v:arithmetic(n.op[0],r.get(),v));}
+    case 'binary':{const a=evaluate(n.left);if(n.op==='&&')return Number(truth(a)&&truth(evaluate(n.right)));if(n.op==='||')return Number(truth(a)||truth(evaluate(n.right)));if(n.op==='in'){if(n.right.type!=='variable')failure('in requires an array');return Number(array(n.right.name).has(str(a)));}
+      if(n.op==='~'||n.op==='!~'){const match=regex(pattern(n.right)).test(str(a));return Number(n.op==='~'?match:!match);}
+      const b=evaluate(n.right);if(n.op==='concat')return str(a)+str(b);
+      if(['==','!=','<','>','<=','>='].includes(n.op)){const x=numeric(a)&&numeric(b)?num(a):str(a),y=numeric(a)&&numeric(b)?num(b):str(b);return Number(n.op==='=='?x===y:n.op==='!='?x!==y:n.op==='<'?x<y:n.op==='>'?x>y:n.op==='<='?x<=y:x>=y);}
+      return arithmetic(n.op,a,b);}
+  }failure(`unsupported expression ${n.type}`);}
+  function arithmetic(op,a,b){a=num(a);b=num(b);if((op==='/'||op==='%')&&b===0)failure('division by zero');return op==='+'?a+b:op==='-'?a-b:op==='*'?a*b:op==='/'?a/b:op==='%'?a%b:op==='^'?a**b:failure(`unsupported operator ${op}`);}
+  function run(n){if(flow)return;switch(n.type){
+    case 'block':for(const child of n.body){run(child);if(flow)break;}break;
+    case 'expression':evaluate(n.value);break;
+    case 'if':if(truth(evaluate(n.condition)))run(n.yes);else if(n.no)run(n.no);break;
+    case 'print':{const values=n.args.map(evaluate);const text=n.op==='printf'?sprintf(values[0],values.slice(1)):(values.length?values.map(str).join(str(get('OFS'))):record)+str(get('ORS'));
+      if(n.redirect){const file=str(evaluate(n.redirect.file));if(n.redirect.op==='|')pipes.set(file,(pipes.get(file)??'')+text);else {options.writeFile(file,text,n.redirect.op==='>>'||written.has(file));written.add(file);}}else output+=text;break;}
+    case 'delete':if(n.value.type==='variable')array(n.value.name).clear();else {const r=ref(n.value);if(!r.remove)failure('delete requires an array');r.remove();}break;
+    case 'flow':flow={op:n.op,value:n.value?evaluate(n.value):0};if(n.op==='exit')status=num(flow.value);break;
+    case 'while':case 'do':case 'for':case 'forin':{
+      if(n.type==='for'&&n.initial)evaluate(n.initial);
+      let keys;if(n.type==='forin'){if(n.initial.right.type!=='variable')failure('for-in requires array');keys=[...array(n.initial.right.name).keys()];}
+      let first=true,j=0;while(n.type==='forin'?j<keys.length:n.type==='do'&&first||!n.condition||truth(evaluate(n.condition))){first=false;if(keys)ref(n.initial.left).set(new InputString(keys[j++]));run(n.body);if(flow){if(flow.op==='break'){flow=null;break;}if(flow.op==='continue')flow=null;else break;}if(n.type==='for'&&n.increment)evaluate(n.increment);}break;}
+    default:failure(`unsupported statement ${n.type}`);
+  }}
+  for(const b of program.begin){run(b);if(flow)break;}
+  if(flow&&flow.op!=='exit')failure(`${flow.op} outside a record`);
+  if(!flow&&program.rules.length){let text;while((text=nextRecord())!==null){setRecord(text);for(const rule of program.rules){let yes=!rule.pattern||truth(evaluate(rule.pattern));if(rule.until){yes=ranges.get(rule)||yes;if(yes)ranges.set(rule,!truth(evaluate(rule.until)));}if(yes)run(rule.action);if(flow)break;}if(flow?.op==='exit')break;if(flow&& !['next','nextfile'].includes(flow.op))failure(`${flow.op} outside its context`);if(flow?.op==='nextfile')recordIndex=records.length;flow=null;}}
+  flow=null;for(const b of program.end){run(b);if(flow)break;}
+  for(const command of pipes.keys())closePipe(command);
+  return stderr?{status,stdout:output,stderr}:{status,stdout:output};
+}

package/apps/bunmsh/src/diff.js

@@ -0,0 +1,222 @@
+/*
+Adapted from jsmdcui/src/index.js diffgutter (Myers bisect and merge cleanup).
+
+MIT License
+
+Copyright (c) 2016-2020: Zachary Yedidia, et al.
+Copyright (c) 2026 Dr. John (醫者小智)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+const _DIFF_DELETE = -1, _DIFF_INSERT = 1, _DIFF_EQUAL = 0;
+
+function _arrEq(a, b) { if (a.length !== b.length) return false; for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false; return true; }
+function _commonPrefix(a, b) { const n = Math.min(a.length, b.length); let i = 0; while (i < n && a[i] === b[i]) i++; return i; }
+function _commonSuffix(a, b) { const n = Math.min(a.length, b.length); let i = 0; while (i < n && a[a.length-1-i] === b[b.length-1-i]) i++; return i; }
+function _indexOfSub(longArr, shortArr) { const L = longArr.length, S = shortArr.length; if (S === 0) return 0; outer: for (let i = 0; i + S <= L; i++) { for (let j = 0; j < S; j++) if (longArr[i+j] !== shortArr[j]) continue outer; return i; } return -1; }
+function _hasSuffix(seq, suf) { if (suf.length > seq.length) return false; for (let i = 0; i < suf.length; i++) if (seq[seq.length-suf.length+i] !== suf[i]) return false; return true; }
+function _hasPrefix(seq, pre) { if (pre.length > seq.length) return false; for (let i = 0; i < pre.length; i++) if (seq[i] !== pre[i]) return false; return true; }
+
+function _diffMain(a, b) {
+  if (_arrEq(a, b)) return a.length ? [{ op: _DIFF_EQUAL, seq: a.slice() }] : [];
+  const pre = _commonPrefix(a, b);
+  const commonprefix = a.slice(0, pre);
+  a = a.slice(pre); b = b.slice(pre);
+  const suf = _commonSuffix(a, b);
+  const commonsuffix = a.slice(a.length - suf);
+  a = a.slice(0, a.length - suf); b = b.slice(0, b.length - suf);
+  const diffs = _diffCompute(a, b);
+  if (commonprefix.length) diffs.unshift({ op: _DIFF_EQUAL, seq: commonprefix });
+  if (commonsuffix.length) diffs.push({ op: _DIFF_EQUAL, seq: commonsuffix });
+  return _diffCleanupMerge(diffs);
+}
+
+function _diffCompute(a, b) {
+  if (a.length === 0) return [{ op: _DIFF_INSERT, seq: b.slice() }];
+  if (b.length === 0) return [{ op: _DIFF_DELETE, seq: a.slice() }];
+  const aLonger = a.length > b.length;
+  const long = aLonger ? a : b, short = aLonger ? b : a;
+  const idx = _indexOfSub(long, short);
+  if (idx !== -1) {
+    const op = aLonger ? _DIFF_DELETE : _DIFF_INSERT;
+    return [
+      { op, seq: long.slice(0, idx) },
+      { op: _DIFF_EQUAL, seq: short.slice() },
+      { op, seq: long.slice(idx + short.length) },
+    ];
+  }
+  if (short.length === 1) return [{ op: _DIFF_DELETE, seq: a.slice() }, { op: _DIFF_INSERT, seq: b.slice() }];
+  return _diffBisect(a, b);
+}
+
+function _diffBisect(a, b) {
+  const n = a.length, m = b.length;
+  const maxD = Math.ceil((n + m) / 2);
+  const vOffset = maxD, vLength = 2 * maxD;
+  const v1 = new Int32Array(vLength).fill(-1);
+  const v2 = new Int32Array(vLength).fill(-1);
+  v1[vOffset + 1] = 0; v2[vOffset + 1] = 0;
+  const delta = n - m;
+  const front = (delta % 2 !== 0);
+  let k1start = 0, k1end = 0, k2start = 0, k2end = 0;
+  for (let d = 0; d < maxD; d++) {
+    for (let k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {
+      const k1Offset = vOffset + k1;
+      let x1;
+      if (k1 === -d || (k1 !== d && v1[k1Offset-1] < v1[k1Offset+1])) x1 = v1[k1Offset+1];
+      else x1 = v1[k1Offset-1] + 1;
+      let y1 = x1 - k1;
+      while (x1 < n && y1 < m && a[x1] === b[y1]) { x1++; y1++; }
+      v1[k1Offset] = x1;
+      if (x1 > n) k1end += 2;
+      else if (y1 > m) k1start += 2;
+      else if (front) {
+        const k2Offset = vOffset + delta - k1;
+        if (k2Offset >= 0 && k2Offset < vLength && v2[k2Offset] !== -1) {
+          const x2 = n - v2[k2Offset];
+          if (x1 >= x2) return _diffBisectSplit(a, b, x1, y1);
+        }
+      }
+    }
+    for (let k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {
+      const k2Offset = vOffset + k2;
+      let x2;
+      if (k2 === -d || (k2 !== d && v2[k2Offset-1] < v2[k2Offset+1])) x2 = v2[k2Offset+1];
+      else x2 = v2[k2Offset-1] + 1;
+      let y2 = x2 - k2;
+      while (x2 < n && y2 < m && a[n-x2-1] === b[m-y2-1]) { x2++; y2++; }
+      v2[k2Offset] = x2;
+      if (x2 > n) k2end += 2;
+      else if (y2 > m) k2start += 2;
+      else if (!front) {
+        const k1Offset = vOffset + delta - k2;
+        if (k1Offset >= 0 && k1Offset < vLength && v1[k1Offset] !== -1) {
+          const x1 = v1[k1Offset];
+          const y1 = vOffset + x1 - k1Offset;
+          const x2real = n - x2;
+          if (x1 >= x2real) return _diffBisectSplit(a, b, x1, y1);
+        }
+      }
+    }
+  }
+  return [{ op: _DIFF_DELETE, seq: a.slice() }, { op: _DIFF_INSERT, seq: b.slice() }];
+}
+
+function _diffBisectSplit(a, b, x, y) {
+  return _diffMain(a.slice(0, x), b.slice(0, y)).concat(_diffMain(a.slice(x), b.slice(y)));
+}
+
+function _diffCleanupMerge(diffs) {
+  diffs.push({ op: _DIFF_EQUAL, seq: [] });
+  let pointer = 0, countDelete = 0, countInsert = 0, textDelete = [], textInsert = [];
+  while (pointer < diffs.length) {
+    const d = diffs[pointer];
+    if (d.op === _DIFF_INSERT) { countInsert++; textInsert = textInsert.concat(d.seq); pointer++; }
+    else if (d.op === _DIFF_DELETE) { countDelete++; textDelete = textDelete.concat(d.seq); pointer++; }
+    else {
+      if (countDelete + countInsert > 1) {
+        if (countDelete !== 0 && countInsert !== 0) {
+          let cl = _commonPrefix(textInsert, textDelete);
+          if (cl !== 0) {
+            const x = pointer - countDelete - countInsert;
+            if (x > 0 && diffs[x-1].op === _DIFF_EQUAL) diffs[x-1].seq = diffs[x-1].seq.concat(textInsert.slice(0, cl));
+            else { diffs.unshift({ op: _DIFF_EQUAL, seq: textInsert.slice(0, cl) }); pointer++; }
+            textInsert = textInsert.slice(cl); textDelete = textDelete.slice(cl);
+          }
+          cl = _commonSuffix(textInsert, textDelete);
+          if (cl !== 0) {
+            const insIdx = textInsert.length - cl;
+            diffs[pointer].seq = textInsert.slice(insIdx).concat(diffs[pointer].seq);
+            textInsert = textInsert.slice(0, insIdx); textDelete = textDelete.slice(0, textDelete.length - cl);
+          }
+        }
+        const repl = [];
+        if (textDelete.length) repl.push({ op: _DIFF_DELETE, seq: textDelete });
+        if (textInsert.length) repl.push({ op: _DIFF_INSERT, seq: textInsert });
+        const start = pointer - countDelete - countInsert;
+        diffs.splice(start, countDelete + countInsert, ...repl);
+        pointer = start + repl.length + 1;
+      } else if (pointer !== 0 && diffs[pointer-1].op === _DIFF_EQUAL) {
+        diffs[pointer-1].seq = diffs[pointer-1].seq.concat(d.seq);
+        diffs.splice(pointer, 1);
+      } else pointer++;
+      countInsert = 0; countDelete = 0; textDelete = []; textInsert = [];
+    }
+  }
+  if (diffs[diffs.length-1].seq.length === 0) diffs.pop();
+
+  // Second pass: shift a single edit sandwiched between two equalities sideways.
+  let changes = false;
+  pointer = 1;
+  while (pointer < diffs.length - 1) {
+    const prev = diffs[pointer-1], cur = diffs[pointer], next = diffs[pointer+1];
+    if (prev.op === _DIFF_EQUAL && next.op === _DIFF_EQUAL) {
+      if (_hasSuffix(cur.seq, prev.seq)) {
+        if (prev.seq.length) {
+          cur.seq = prev.seq.concat(cur.seq.slice(0, cur.seq.length - prev.seq.length));
+          next.seq = prev.seq.concat(next.seq);
+        }
+        diffs.splice(pointer-1, 1); changes = true;
+      } else if (_hasPrefix(cur.seq, next.seq)) {
+        prev.seq = prev.seq.concat(next.seq);
+        cur.seq = cur.seq.slice(next.seq.length).concat(next.seq);
+        diffs.splice(pointer+1, 1); changes = true;
+      }
+    }
+    pointer++;
+  }
+  if (changes) return _diffCleanupMerge(diffs);
+  return diffs;
+}
+
+export function normalFileDiff(left, right) {
+  // Keep the terminator as part of line identity, including a missing final LF.
+  const lines = text => text.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+  const a = lines(left), b = lines(right);
+  const operations = _diffMain(a, b);
+  const range = (first, last) => first === last ? String(first) : `${first},${last}`;
+  const render = (values, prefix) => values.map(line =>
+    `${prefix} ${line}${line.endsWith("\n") ? "" : "\n\\n"}`
+  ).join("");
+  let oldLine = 0, newLine = 0, output = "";
+  for (let i = 0; i < operations.length;) {
+    if (operations[i].op === _DIFF_EQUAL) {
+      oldLine += operations[i].seq.length;
+      newLine += operations[i++].seq.length;
+      continue;
+    }
+    const oldStart = oldLine, newStart = newLine;
+    let removed = [], added = [];
+    while (i < operations.length && operations[i].op !== _DIFF_EQUAL) {
+      const change = operations[i++];
+      if (change.op === _DIFF_DELETE) {
+        removed = removed.concat(change.seq);
+        oldLine += change.seq.length;
+      } else {
+        added = added.concat(change.seq);
+        newLine += change.seq.length;
+      }
+    }
+    if (!removed.length) output += `${oldStart}a${range(newStart + 1, newLine)}\n${render(added, ">")}`;
+    else if (!added.length) output += `${range(oldStart + 1, oldLine)}d${newStart}\n${render(removed, "<")}`;
+    else output += `${range(oldStart + 1, oldLine)}c${range(newStart + 1, newLine)}\n${render(removed, "<")}---\n${render(added, ">")}`;
+  }
+  return output;
+}

package/apps/bunmsh/src/fancy-ls.js

@@ -43,8 +43,8 @@ function classifySuffix(stats) {
 }
 
 function displayEntry(entry, options) {
-  const suffix = options.classify ? classifySuffix(entry.stats) : entry.stats.isDirectory() ? "/" : "";
-  return `${iconFor(entry.name, entry.stats, entry.path)} ${entry.name}${suffix}`;
+  const suffix = options.classify ? classifySuffix(entry.stats) : !options.plain && entry.stats.isDirectory() ? "/" : "";
+  return `${options.inode ? `${entry.stats.ino} ` : ""}${options.plain ? "" : `${iconFor(entry.name, entry.stats, entry.path)} `}${entry.name}${suffix}`;
 }
 
 function columns(items, width) {
@@ -98,7 +98,7 @@ function listDirectory(path, options) {
     .filter((entry) => options.all || options.almostAll || !entry.name.startsWith("."))
     .map((entry) => {
       const entryPath = resolve(path, entry.name);
-      return { name: entry.name, stats: lstatSync(entryPath), path: entryPath };
+      return { name: entry.name, stats: options.dereference ? statSync(entryPath) : lstatSync(entryPath), path: entryPath };
     });
   if (options.all) entries = [
     { name: ".", stats: lstatSync(path), path },
@@ -116,6 +116,7 @@ function listDirectory(path, options) {
 
 export function fancyLs(argv, state, terminal = Boolean(process.stdout.isTTY)) {
   const options = {
+    plain: argv[0] === "ls" && Boolean(state.shellOptions?.posix),
     all: false, almostAll: false, directory: false, long: false, human: false,
     recursive: false, time: false, reverse: false, size: false, one: false, classify: false,
   };
@@ -128,6 +129,8 @@ export function fancyLs(argv, state, terminal = Boolean(process.stdout.isTTY)) {
       for (const flag of argument.slice(1)) {
         if (flag === "a") options.all = true;
         else if (flag === "A") options.almostAll = true;
+        else if (flag === "L") options.dereference = true;
+        else if (flag === "i") options.inode = true;
         else if (flag === "d") options.directory = true;
         else if (flag === "l") options.long = true;
         else if (flag === "h") options.human = true;
@@ -148,7 +151,7 @@ export function fancyLs(argv, state, terminal = Boolean(process.stdout.isTTY)) {
   const show = (operand, heading = operands.length > 1, separate = true) => {
     const path = isAbsolute(operand) ? operand : resolve(state.cwd, operand);
     try {
-      const stats = lstatSync(path);
+      const stats = options.dereference ? statSync(path) : lstatSync(path);
       let listingDirectory = stats.isDirectory() && !options.directory;
       // GNU/POSIX-style ls follows a command-line symlink to a directory for
       // an ordinary listing and for -R. -d, -l, and -F request information
@@ -196,6 +199,14 @@ export function fancyLs(argv, state, terminal = Boolean(process.stdout.isTTY)) {
       stderr += `bunmsh: ${argv[0]}: ${operand}: ${error.message}\n`;
     }
   };
+  if (options.time || options.size) operands.sort((a,b) => {
+    try {
+      const stat = options.dereference ? statSync : lstatSync;
+      const left=stat(resolve(state.cwd,a)), right=stat(resolve(state.cwd,b));
+      const order=(options.size ? right.size-left.size : right.mtimeMs-left.mtimeMs) || a.localeCompare(b);
+      return options.reverse ? -order : order;
+    } catch { return 0; }
+  });
   for (const operand of operands) show(operand);
   return { status, stdout, stderr };
 }