@nimbus-sh/core 0.1.0

package/src/substrate/lifo/commands/text/sed.ts

@@ -0,0 +1,297 @@
+import type { Command, CommandOutputStream } from '../types.js';
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+import { getMimeType, isBinaryMime } from '../../utils/mime.js';
+
+type SedVfs = {
+  stat(path: string): object;
+  readFileString(path: string): string;
+  writeFile(path: string, content: string | Uint8Array): void;
+};
+
+type SedInput = {
+  readAll(): Promise<string>;
+};
+
+export type SedExecutionContext = {
+  args: string[];
+  cwd: string;
+  vfs: SedVfs;
+  stdout: CommandOutputStream;
+  stderr: CommandOutputStream;
+  stdin?: SedInput;
+};
+
+interface SedExpr {
+  type: 's' | 'd' | 'p';
+  pattern?: RegExp;
+  replacement?: string;
+  global?: boolean;
+  print?: boolean;
+}
+
+type SedCommandOptions = {
+  inPlace: boolean;
+  quiet: boolean;
+  expressions: string[];
+  files: string[];
+};
+
+function parseSedExpr(expr: string): SedExpr | null {
+  if (expr === 'd') {
+    return { type: 'd' };
+  }
+  if (expr === 'p') {
+    return { type: 'p' };
+  }
+  // s/pattern/replacement/flags
+  if (expr.startsWith('s')) {
+    const delim = expr[1];
+    if (!delim) return null;
+    const parts: string[] = [];
+    let current = '';
+    let escaped = false;
+    for (let i = 2; i < expr.length; i++) {
+      if (escaped) {
+        current += expr[i];
+        escaped = false;
+      } else if (expr[i] === '\\') {
+        escaped = true;
+        current += '\\';
+      } else if (expr[i] === delim) {
+        parts.push(current);
+        current = '';
+      } else {
+        current += expr[i];
+      }
+    }
+    parts.push(current); // remaining flags part
+    if (parts.length < 2) return null;
+
+    const patternStr = parts[0];
+    const replacement = parts[1] ?? '';
+    const flagStr = parts[2] || '';
+    const globalFlag = flagStr.includes('g');
+    const caseInsensitive = flagStr.includes('i');
+    const print = flagStr.includes('p');
+
+    let regex: RegExp;
+    try {
+      let flags = '';
+      if (globalFlag) flags += 'g';
+      if (caseInsensitive) flags += 'i';
+      regex = new RegExp(toJavascriptPattern(patternStr ?? ''), flags);
+    } catch {
+      return null;
+    }
+
+    return { type: 's', pattern: regex, replacement, global: globalFlag, print };
+  }
+  return null;
+}
+
+function toJavascriptPattern(pattern: string): string {
+  let result = '';
+  for (let i = 0; i < pattern.length; i++) {
+    const char = pattern[i];
+    const next = pattern[i + 1];
+    if (char === '\\' && (next === '(' || next === ')')) {
+      result += next;
+      i++;
+      continue;
+    }
+    result += char;
+  }
+  return result;
+}
+
+function isDigit(value: string): boolean {
+  const code = value.charCodeAt(0);
+  return code >= 48 && code <= 57;
+}
+
+export async function runSed(ctx: SedExecutionContext): Promise<number> {
+  const options = parseSedArgs(ctx.args);
+
+  if (options.expressions.length === 0) {
+    ctx.stderr.write('sed: missing expression\n');
+    return 1;
+  }
+
+  const parsedExprs: SedExpr[] = [];
+  for (const expr of options.expressions) {
+    const parsed = parseSedExpr(expr);
+    if (!parsed) {
+      ctx.stderr.write(`sed: invalid expression: ${expr}\n`);
+      return 1;
+    }
+    parsedExprs.push(parsed);
+  }
+
+  function processText(text: string): string {
+    const lines = text.replace(/\n$/, '').split('\n');
+    const output: string[] = [];
+
+    for (let line of lines) {
+      let deleted = false;
+      for (const expr of parsedExprs) {
+        if (expr.type === 's' && expr.pattern && expr.replacement !== undefined) {
+          let changed = false;
+          expr.pattern.lastIndex = 0;
+          line = line.replace(expr.pattern, (...match) => {
+            changed = true;
+            return expandReplacement(expr.replacement ?? '', match.slice(1, -2), String(match[0]));
+          });
+          if (changed && expr.print) {
+            output.push(line);
+          }
+        } else if (expr.type === 'd') {
+          deleted = true;
+          break;
+        } else if (expr.type === 'p') {
+          output.push(line);
+        }
+      }
+      if (!deleted && !options.quiet) {
+        output.push(line);
+      }
+    }
+
+    return output.join('\n') + '\n';
+  }
+
+  if (options.files.length === 0) {
+    if (ctx.stdin) {
+      const text = await ctx.stdin.readAll();
+      ctx.stdout.write(processText(text));
+    } else {
+      ctx.stderr.write('sed: missing file operand\n');
+      return 1;
+    }
+    return 0;
+  }
+
+  let exitCode = 0;
+  for (const file of options.files) {
+    const path = resolve(ctx.cwd, file);
+    try {
+      ctx.vfs.stat(path);
+      if (isBinaryMime(getMimeType(path))) {
+        ctx.stderr.write(`sed: ${file}: binary file, skipping\n`);
+        continue;
+      }
+      const content = ctx.vfs.readFileString(path);
+      const result = processText(content);
+      if (options.inPlace) {
+        ctx.vfs.writeFile(path, result);
+      } else {
+        ctx.stdout.write(result);
+      }
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`sed: ${file}: ${e.message}\n`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  return exitCode;
+}
+
+function parseSedArgs(args: string[]): SedCommandOptions {
+  const options: SedCommandOptions = {
+    inPlace: false,
+    quiet: false,
+    expressions: [],
+    files: [],
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i] ?? '';
+
+    if (arg === '-i') {
+      options.inPlace = true;
+      continue;
+    }
+    if (arg === '-n' || arg === '--quiet' || arg === '--silent') {
+      options.quiet = true;
+      continue;
+    }
+    if (arg === '-e') {
+      options.expressions.push(args[++i] ?? '');
+      continue;
+    }
+    if (arg.startsWith('-') && arg.length > 2 && parseSedShortCluster(options, arg, args, i)) {
+      if (clusterNeedsNextArg(arg)) i++;
+      continue;
+    }
+    if (options.expressions.length === 0 && !arg.startsWith('-')) {
+      options.expressions.push(arg);
+      continue;
+    }
+
+    options.files.push(arg);
+  }
+
+  return options;
+}
+
+function parseSedShortCluster(options: SedCommandOptions, arg: string, args: string[], index: number): boolean {
+  for (let j = 1; j < arg.length; j++) {
+    const flag = arg[j];
+    if (flag === 'n') {
+      options.quiet = true;
+      continue;
+    }
+    if (flag === 'i') {
+      options.inPlace = true;
+      continue;
+    }
+    if (flag === 'e') {
+      const rest = arg.slice(j + 1);
+      options.expressions.push(rest || args[index + 1] || '');
+      return true;
+    }
+    return false;
+  }
+  return true;
+}
+
+function clusterNeedsNextArg(arg: string): boolean {
+  const eIndex = arg.indexOf('e');
+  return eIndex !== -1 && eIndex === arg.length - 1;
+}
+
+function expandReplacement(
+  replacement: string,
+  captures: readonly string[],
+  matched: string,
+): string {
+  let result = '';
+  for (let i = 0; i < replacement.length; i++) {
+    const char = replacement[i];
+    const next = replacement[i + 1];
+    if (char === '\\' && next !== undefined) {
+      if (isDigit(next)) {
+        result += String(captures[Number(next) - 1] ?? '');
+        i++;
+        continue;
+      }
+      result += next;
+      i++;
+      continue;
+    }
+    if (char === '&') {
+      result += matched;
+      continue;
+    }
+    result += char;
+  }
+  return result;
+}
+
+const command: Command = async (ctx) => runSed(ctx);
+
+export default command;

package/src/substrate/lifo/commands/text/seq.ts

@@ -0,0 +1,76 @@
+import type { Command } from '../types.js';
+
+const command: Command = async (ctx) => {
+  const args = ctx.args;
+
+  if (args.length === 0) {
+    ctx.stderr.write('Usage: seq [-s SEP] [FIRST [INCR]] LAST\n');
+    ctx.stderr.write('Print a sequence of numbers.\n');
+    return 1;
+  }
+
+  let first = 1;
+  let increment = 1;
+  let last: number;
+  let separator = '\n';
+  let equalWidth = false;
+
+  // Parse -s / -w options
+  const positional: string[] = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '-s' && i + 1 < args.length) {
+      separator = args[++i];
+    } else if (args[i] === '-w') {
+      equalWidth = true;
+    } else {
+      positional.push(args[i]);
+    }
+  }
+
+  if (positional.length === 1) {
+    last = parseFloat(positional[0]);
+  } else if (positional.length === 2) {
+    first = parseFloat(positional[0]);
+    last = parseFloat(positional[1]);
+  } else {
+    first = parseFloat(positional[0]);
+    increment = parseFloat(positional[1]);
+    last = parseFloat(positional[2]);
+  }
+
+  if (isNaN(first) || isNaN(increment) || isNaN(last)) {
+    ctx.stderr.write('seq: invalid argument\n');
+    return 1;
+  }
+
+  if (increment === 0) {
+    ctx.stderr.write('seq: zero increment\n');
+    return 1;
+  }
+
+  const results: string[] = [];
+  const isInt = Number.isInteger(first) && Number.isInteger(increment) && Number.isInteger(last);
+
+  if (increment > 0) {
+    for (let n = first; n <= last + 1e-10; n += increment) {
+      results.push(isInt ? String(Math.round(n)) : String(n));
+    }
+  } else {
+    for (let n = first; n >= last - 1e-10; n += increment) {
+      results.push(isInt ? String(Math.round(n)) : String(n));
+    }
+  }
+
+  if (results.length > 0) {
+    if (equalWidth && isInt) {
+      const maxLen = Math.max(...results.map(r => r.length));
+      ctx.stdout.write(results.map(r => r.padStart(maxLen, '0')).join(separator) + '\n');
+    } else {
+      ctx.stdout.write(results.join(separator) + '\n');
+    }
+  }
+
+  return 0;
+};
+
+export default command;

package/src/substrate/lifo/commands/text/sort.ts

@@ -0,0 +1,88 @@
+import type { Command } from '../types.js';
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+import { getMimeType, isBinaryMime } from '../../utils/mime.js';
+
+const command: Command = async (ctx) => {
+  let reverse = false;
+  let numeric = false;
+  let unique = false;
+  let keyField = 0; // 0 = whole line, 1-based field index
+  const files: string[] = [];
+
+  for (let i = 0; i < ctx.args.length; i++) {
+    const arg = ctx.args[i];
+    if (arg === '-k' && i + 1 < ctx.args.length) {
+      keyField = parseInt(ctx.args[++i], 10);
+    } else if (arg.startsWith('-') && arg.length > 1) {
+      for (let j = 1; j < arg.length; j++) {
+        switch (arg[j]) {
+          case 'r': reverse = true; break;
+          case 'n': numeric = true; break;
+          case 'u': unique = true; break;
+        }
+      }
+    } else {
+      files.push(arg);
+    }
+  }
+
+  let text = '';
+  if (files.length === 0) {
+    if (ctx.stdin) {
+      text = await ctx.stdin.readAll();
+    } else {
+      ctx.stderr.write('sort: missing file operand\n');
+      return 1;
+    }
+  } else {
+    for (const file of files) {
+      const path = resolve(ctx.cwd, file);
+      try {
+        ctx.vfs.stat(path);
+        if (isBinaryMime(getMimeType(path))) {
+          ctx.stderr.write(`sort: ${file}: binary file, skipping\n`);
+          continue;
+        }
+        text += ctx.vfs.readFileString(path);
+      } catch (e) {
+        if (e instanceof VFSError) {
+          ctx.stderr.write(`sort: ${file}: ${e.message}\n`);
+          return 1;
+        }
+        throw e;
+      }
+    }
+  }
+
+  let lines = text.replace(/\n$/, '').split('\n');
+
+  function getKey(line: string): string {
+    if (keyField > 0) {
+      const fields = line.split(/\s+/);
+      return fields[keyField - 1] || '';
+    }
+    return line;
+  }
+
+  lines.sort((a, b) => {
+    const ka = getKey(a);
+    const kb = getKey(b);
+    let cmp: number;
+    if (numeric) {
+      cmp = (parseFloat(ka) || 0) - (parseFloat(kb) || 0);
+    } else {
+      cmp = ka.localeCompare(kb);
+    }
+    return reverse ? -cmp : cmp;
+  });
+
+  if (unique) {
+    lines = lines.filter((line, idx) => idx === 0 || line !== lines[idx - 1]);
+  }
+
+  ctx.stdout.write(lines.join('\n') + '\n');
+  return 0;
+};
+
+export default command;

package/src/substrate/lifo/commands/text/strings.ts

@@ -0,0 +1,73 @@
+import type { Command } from '../types.js';
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+
+function extractStrings(data: Uint8Array, minLen: number): string[] {
+  const results: string[] = [];
+  let current = '';
+
+  for (let i = 0; i < data.length; i++) {
+    const byte = data[i];
+    // Printable ASCII range (space through tilde) plus tab
+    if ((byte >= 0x20 && byte <= 0x7e) || byte === 0x09) {
+      current += String.fromCharCode(byte);
+    } else {
+      if (current.length >= minLen) {
+        results.push(current);
+      }
+      current = '';
+    }
+  }
+  if (current.length >= minLen) {
+    results.push(current);
+  }
+
+  return results;
+}
+
+const command: Command = async (ctx) => {
+  let minLen = 4;
+  const files: string[] = [];
+
+  for (let i = 0; i < ctx.args.length; i++) {
+    const arg = ctx.args[i];
+    if (arg === '-n' && i + 1 < ctx.args.length) {
+      minLen = parseInt(ctx.args[++i], 10);
+      if (isNaN(minLen) || minLen < 1) minLen = 4;
+    } else if (arg.startsWith('-') && arg.length > 1 && !isNaN(parseInt(arg.slice(1), 10))) {
+      minLen = parseInt(arg.slice(1), 10);
+      if (minLen < 1) minLen = 4;
+    } else {
+      files.push(arg);
+    }
+  }
+
+  let exitCode = 0;
+
+  if (files.length === 0) {
+    ctx.stderr.write('Usage: strings [-n MIN] FILE...\n');
+    ctx.stderr.write('Print sequences of printable characters from files.\n');
+    return 1;
+  }
+
+  for (const file of files) {
+    const path = resolve(ctx.cwd, file);
+    try {
+      const data = ctx.vfs.readFile(path);
+      for (const s of extractStrings(data, minLen)) {
+        ctx.stdout.write(s + '\n');
+      }
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`strings: ${file}: ${e.message}\n`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  return exitCode;
+};
+
+export default command;

package/src/substrate/lifo/commands/text/tac.ts

@@ -0,0 +1,37 @@
+import type { Command } from '../types.js';
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+
+const command: Command = async (ctx) => {
+  let exitCode = 0;
+
+  const processContent = (content: string) => {
+    const lines = content.replace(/\n$/, '').split('\n');
+    lines.reverse();
+    ctx.stdout.write(lines.join('\n') + '\n');
+  };
+
+  if (ctx.args.length === 0) {
+    ctx.stderr.write('Usage: tac FILE...\n');
+    ctx.stderr.write('Print files in reverse line order.\n');
+    return 1;
+  }
+
+  for (const arg of ctx.args) {
+    const path = resolve(ctx.cwd, arg);
+    try {
+      processContent(ctx.vfs.readFileString(path));
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`tac: ${arg}: ${e.message}\n`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  return exitCode;
+};
+
+export default command;

package/src/substrate/lifo/commands/text/tail.ts

@@ -0,0 +1,63 @@
+import type { Command } from '../types.js';
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+import { getMimeType, isBinaryMime } from '../../utils/mime.js';
+
+const command: Command = async (ctx) => {
+  let count = 10;
+  const files: string[] = [];
+
+  for (let i = 0; i < ctx.args.length; i++) {
+    const arg = ctx.args[i];
+    if (arg === '-n' && i + 1 < ctx.args.length) {
+      count = parseInt(ctx.args[++i], 10);
+      if (isNaN(count)) { ctx.stderr.write('tail: invalid number of lines\n'); return 1; }
+    } else if (/^-\d+$/.test(arg)) {
+      count = parseInt(arg.slice(1), 10);
+    } else {
+      files.push(arg);
+    }
+  }
+
+  async function tailText(text: string): Promise<void> {
+    const lines = text.replace(/\n$/, '').split('\n');
+    const selected = lines.slice(-count);
+    ctx.stdout.write(selected.join('\n') + '\n');
+  }
+
+  if (files.length === 0) {
+    if (ctx.stdin) {
+      await tailText(await ctx.stdin.readAll());
+    } else {
+      ctx.stderr.write('tail: missing file operand\n');
+      return 1;
+    }
+    return 0;
+  }
+
+  let exitCode = 0;
+  for (const file of files) {
+    const path = resolve(ctx.cwd, file);
+    try {
+      ctx.vfs.stat(path);
+      if (isBinaryMime(getMimeType(path))) {
+        ctx.stderr.write(`tail: ${file}: binary file, skipping\n`);
+        continue;
+      }
+      const content = ctx.vfs.readFileString(path);
+      if (files.length > 1) ctx.stdout.write(`==> ${file} <==\n`);
+      await tailText(content);
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`tail: ${file}: ${e.message}\n`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  return exitCode;
+};
+
+export default command;