@nimbus-sh/core 0.1.0

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

@@ -0,0 +1,102 @@
+import type { Command } from '../types.js';
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+
+function toBase64(data: Uint8Array): string {
+  let binary = '';
+  for (let i = 0; i < data.length; i++) {
+    binary += String.fromCharCode(data[i]);
+  }
+  return btoa(binary);
+}
+
+function fromBase64(str: string): string {
+  try {
+    return atob(str.replace(/\s/g, ''));
+  } catch {
+    throw new Error('invalid input');
+  }
+}
+
+const command: Command = async (ctx) => {
+  let decode = false;
+  let wrap = 76;
+  const files: string[] = [];
+
+  for (let i = 0; i < ctx.args.length; i++) {
+    const arg = ctx.args[i];
+    if (arg === '-d' || arg === '--decode') {
+      decode = true;
+    } else if (arg === '-w' && i + 1 < ctx.args.length) {
+      wrap = parseInt(ctx.args[++i], 10);
+    } else if (arg === '--wrap' && i + 1 < ctx.args.length) {
+      wrap = parseInt(ctx.args[++i], 10);
+    } else if (!arg.startsWith('-') || arg === '-') {
+      files.push(arg);
+    }
+  }
+
+  let input: string | Uint8Array;
+
+  if (files.length === 1 && files[0] === '-') {
+    // Explicit stdin via '-'
+    if (ctx.stdin) {
+      input = await ctx.stdin.readAll();
+    } else {
+      ctx.stderr.write('base64: missing input\n');
+      return 1;
+    }
+  } else if (files.length === 0) {
+    ctx.stderr.write(`Usage: base64 [-d] [-w COLS] [FILE]\n`);
+    ctx.stderr.write(`Encode or decode base64. Use '-' to read from stdin.\n`);
+    return 1;
+  } else {
+    const path = resolve(ctx.cwd, files[0]);
+    try {
+      if (decode) {
+        input = ctx.vfs.readFileString(path);
+      } else {
+        input = ctx.vfs.readFile(path);
+      }
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`base64: ${files[0]}: ${e.message}\n`);
+        return 1;
+      }
+      throw e;
+    }
+  }
+
+  if (decode) {
+    try {
+      const text = typeof input === 'string' ? input : new TextDecoder().decode(input);
+      ctx.stdout.write(fromBase64(text));
+    } catch {
+      ctx.stderr.write('base64: invalid input\n');
+      return 1;
+    }
+  } else {
+    let data: Uint8Array;
+    if (typeof input === 'string') {
+      data = new TextEncoder().encode(input);
+    } else {
+      data = input;
+    }
+    let encoded = toBase64(data);
+
+    // Wrap lines
+    if (wrap > 0) {
+      const wrapped: string[] = [];
+      for (let i = 0; i < encoded.length; i += wrap) {
+        wrapped.push(encoded.slice(i, i + wrap));
+      }
+      encoded = wrapped.join('\n');
+    }
+
+    ctx.stdout.write(encoded + '\n');
+  }
+
+  return 0;
+};
+
+export default command;

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

@@ -0,0 +1,92 @@
+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';
+
+function parseFieldSpec(spec: string): number[] {
+  const fields: number[] = [];
+  for (const part of spec.split(',')) {
+    const rangeParts = part.split('-');
+    if (rangeParts.length === 2) {
+      const start = parseInt(rangeParts[0], 10);
+      const end = parseInt(rangeParts[1], 10);
+      if (!isNaN(start) && !isNaN(end)) {
+        for (let i = start; i <= end; i++) fields.push(i);
+      }
+    } else {
+      const n = parseInt(part, 10);
+      if (!isNaN(n)) fields.push(n);
+    }
+  }
+  return fields;
+}
+
+const command: Command = async (ctx) => {
+  let delimiter = '\t';
+  let fieldSpec = '';
+  const files: string[] = [];
+
+  for (let i = 0; i < ctx.args.length; i++) {
+    const arg = ctx.args[i];
+    if (arg === '-d' && i + 1 < ctx.args.length) {
+      delimiter = ctx.args[++i];
+    } else if (arg === '-f' && i + 1 < ctx.args.length) {
+      fieldSpec = ctx.args[++i];
+    } else if (arg.startsWith('-d') && arg.length > 2) {
+      delimiter = arg.slice(2);
+    } else if (arg.startsWith('-f') && arg.length > 2) {
+      fieldSpec = arg.slice(2);
+    } else {
+      files.push(arg);
+    }
+  }
+
+  if (!fieldSpec) {
+    ctx.stderr.write('cut: you must specify a list of fields\n');
+    return 1;
+  }
+
+  const fields = parseFieldSpec(fieldSpec);
+
+  function cutLine(line: string): string {
+    const parts = line.split(delimiter);
+    return fields.map((f) => parts[f - 1] || '').join(delimiter);
+  }
+
+  let text = '';
+  if (files.length === 0) {
+    if (ctx.stdin) {
+      text = await ctx.stdin.readAll();
+    } else {
+      ctx.stderr.write('cut: 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(`cut: ${file}: binary file, skipping\n`);
+          continue;
+        }
+        text += ctx.vfs.readFileString(path);
+      } catch (e) {
+        if (e instanceof VFSError) {
+          ctx.stderr.write(`cut: ${file}: ${e.message}\n`);
+          return 1;
+        }
+        throw e;
+      }
+    }
+  }
+
+  const lines = text.replace(/\n$/, '').split('\n');
+  for (const line of lines) {
+    ctx.stdout.write(cutLine(line) + '\n');
+  }
+
+  return 0;
+};
+
+export default command;

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

@@ -0,0 +1,314 @@
+import type { Command } from '../types.js';
+import { parseArgs } from '../../utils/args.js';
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+import { getMimeType, isBinaryMime } from '../../utils/mime.js';
+
+const spec = {
+  unified: { type: 'boolean' as const, short: 'u' },
+};
+
+interface EditOp {
+  type: 'keep' | 'delete' | 'insert';
+  oldLine?: string;
+  newLine?: string;
+}
+
+function computeLCS(a: string[], b: string[]): EditOp[] {
+  const m = a.length;
+  const n = b.length;
+
+  // Build DP table
+  const dp: number[][] = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (a[i - 1] === b[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1] + 1;
+      } else {
+        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+      }
+    }
+  }
+
+  // Backtrack to get edit operations
+  const ops: EditOp[] = [];
+  let i = m, j = n;
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && a[i - 1] === b[j - 1]) {
+      ops.push({ type: 'keep', oldLine: a[i - 1] });
+      i--; j--;
+    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+      ops.push({ type: 'insert', newLine: b[j - 1] });
+      j--;
+    } else {
+      ops.push({ type: 'delete', oldLine: a[i - 1] });
+      i--;
+    }
+  }
+
+  return ops.reverse();
+}
+
+function formatNormal(ops: EditOp[]): string {
+  const output: string[] = [];
+  let oldIdx = 0;
+  let newIdx = 0;
+  let i = 0;
+
+  while (i < ops.length) {
+    const op = ops[i];
+    if (op.type === 'keep') {
+      oldIdx++; newIdx++; i++;
+      continue;
+    }
+
+    // Collect contiguous change block
+    const delStart = oldIdx;
+    const insStart = newIdx;
+    const delLines: string[] = [];
+    const insLines: string[] = [];
+
+    while (i < ops.length && ops[i].type !== 'keep') {
+      if (ops[i].type === 'delete') {
+        delLines.push(ops[i].oldLine!);
+        oldIdx++;
+      } else {
+        insLines.push(ops[i].newLine!);
+        newIdx++;
+      }
+      i++;
+    }
+
+    // Format range
+    const delRange = delLines.length === 1
+      ? `${delStart + 1}`
+      : delLines.length > 0
+        ? `${delStart + 1},${delStart + delLines.length}`
+        : `${delStart}`;
+
+    const insRange = insLines.length === 1
+      ? `${insStart + 1}`
+      : insLines.length > 0
+        ? `${insStart + 1},${insStart + insLines.length}`
+        : `${insStart}`;
+
+    if (delLines.length > 0 && insLines.length > 0) {
+      output.push(`${delRange}c${insRange}`);
+      for (const l of delLines) output.push(`< ${l}`);
+      output.push('---');
+      for (const l of insLines) output.push(`> ${l}`);
+    } else if (delLines.length > 0) {
+      output.push(`${delRange}d${insRange}`);
+      for (const l of delLines) output.push(`< ${l}`);
+    } else {
+      output.push(`${delRange}a${insRange}`);
+      for (const l of insLines) output.push(`> ${l}`);
+    }
+  }
+
+  return output.length > 0 ? output.join('\n') + '\n' : '';
+}
+
+interface Hunk {
+  oldStart: number;
+  oldCount: number;
+  newStart: number;
+  newCount: number;
+  lines: string[];
+}
+
+function formatUnified(ops: EditOp[], file1: string, file2: string): string {
+  if (ops.every(o => o.type === 'keep')) return '';
+
+  // Build annotated lines with indices
+  const annotated: Array<{ type: 'keep' | 'delete' | 'insert'; line: string; oldIdx: number; newIdx: number }> = [];
+  let oldIdx = 0, newIdx = 0;
+  for (const op of ops) {
+    if (op.type === 'keep') {
+      annotated.push({ type: 'keep', line: op.oldLine!, oldIdx, newIdx });
+      oldIdx++; newIdx++;
+    } else if (op.type === 'delete') {
+      annotated.push({ type: 'delete', line: op.oldLine!, oldIdx, newIdx });
+      oldIdx++;
+    } else {
+      annotated.push({ type: 'insert', line: op.newLine!, oldIdx, newIdx });
+      newIdx++;
+    }
+  }
+
+  // Group into hunks with 3 lines of context
+  const context = 3;
+  const hunks: Hunk[] = [];
+  let currentHunk: Hunk | null = null;
+  let lastChangeIdx = -Infinity;
+
+  for (let i = 0; i < annotated.length; i++) {
+    const a = annotated[i];
+    if (a.type !== 'keep') {
+      if (!currentHunk || i - lastChangeIdx > context * 2 + 1) {
+        // Start new hunk with leading context
+        if (currentHunk) {
+          // Add trailing context to previous hunk
+          for (let j = lastChangeIdx + 1; j < Math.min(lastChangeIdx + 1 + context, annotated.length); j++) {
+            if (annotated[j].type === 'keep') {
+              currentHunk.lines.push(` ${annotated[j].line}`);
+              currentHunk.oldCount++;
+              currentHunk.newCount++;
+            }
+          }
+          hunks.push(currentHunk);
+        }
+
+        const ctxStart = Math.max(0, i - context);
+        // Count old/new lines from context start
+        let oStart = 0, nStart = 0;
+        for (let j = 0; j < ctxStart; j++) {
+          if (annotated[j].type !== 'insert') oStart++;
+          if (annotated[j].type !== 'delete') nStart++;
+        }
+
+        currentHunk = {
+          oldStart: oStart + 1,
+          newStart: nStart + 1,
+          oldCount: 0,
+          newCount: 0,
+          lines: [],
+        };
+
+        for (let j = ctxStart; j < i; j++) {
+          if (annotated[j].type === 'keep') {
+            currentHunk.lines.push(` ${annotated[j].line}`);
+            currentHunk.oldCount++;
+            currentHunk.newCount++;
+          }
+        }
+      } else if (i - lastChangeIdx > 1) {
+        // Add intermediate context
+        for (let j = lastChangeIdx + 1; j < i; j++) {
+          if (annotated[j].type === 'keep') {
+            currentHunk!.lines.push(` ${annotated[j].line}`);
+            currentHunk!.oldCount++;
+            currentHunk!.newCount++;
+          }
+        }
+      }
+
+      if (a.type === 'delete') {
+        currentHunk!.lines.push(`-${a.line}`);
+        currentHunk!.oldCount++;
+      } else {
+        currentHunk!.lines.push(`+${a.line}`);
+        currentHunk!.newCount++;
+      }
+      lastChangeIdx = i;
+    }
+  }
+
+  if (currentHunk) {
+    // Trailing context
+    for (let j = lastChangeIdx + 1; j < Math.min(lastChangeIdx + 1 + context, annotated.length); j++) {
+      if (annotated[j].type === 'keep') {
+        currentHunk.lines.push(` ${annotated[j].line}`);
+        currentHunk.oldCount++;
+        currentHunk.newCount++;
+      }
+    }
+    hunks.push(currentHunk);
+  }
+
+  const output: string[] = [];
+  output.push(`--- ${file1}`);
+  output.push(`+++ ${file2}`);
+  for (const hunk of hunks) {
+    output.push(`@@ -${hunk.oldStart},${hunk.oldCount} +${hunk.newStart},${hunk.newCount} @@`);
+    output.push(...hunk.lines);
+  }
+
+  return output.join('\n') + '\n';
+}
+
+const command: Command = async (ctx) => {
+  const { flags, positional } = parseArgs(ctx.args, spec);
+
+  if (positional.length < 2) {
+    ctx.stderr.write('diff: missing operand\n');
+    return 2;
+  }
+
+  const file1 = positional[0];
+  const file2 = positional[1];
+
+  let content1: string;
+  let content2: string;
+
+  const path1 = resolve(ctx.cwd, file1);
+  const path2 = resolve(ctx.cwd, file2);
+  const binary1 = isBinaryMime(getMimeType(path1));
+  const binary2 = isBinaryMime(getMimeType(path2));
+
+  if (binary1 || binary2) {
+    // Verify files exist before reporting binary diff
+    try { ctx.vfs.stat(path1); } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`diff: ${file1}: ${e.message}
+`);
+        return 2;
+      }
+      throw e;
+    }
+    try { ctx.vfs.stat(path2); } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`diff: ${file2}: ${e.message}
+`);
+        return 2;
+      }
+      throw e;
+    }
+    ctx.stdout.write(`Binary files ${file1} and ${file2} differ
+`);
+    return 2;
+  }
+
+  try {
+    content1 = ctx.vfs.readFileString(resolve(ctx.cwd, file1));
+  } catch (e) {
+    if (e instanceof VFSError) {
+      ctx.stderr.write(`diff: ${file1}: ${e.message}\n`);
+      return 2;
+    }
+    throw e;
+  }
+
+  try {
+    content2 = ctx.vfs.readFileString(resolve(ctx.cwd, file2));
+  } catch (e) {
+    if (e instanceof VFSError) {
+      ctx.stderr.write(`diff: ${file2}: ${e.message}\n`);
+      return 2;
+    }
+    throw e;
+  }
+
+  if (content1 === content2) {
+    return 0;
+  }
+
+  const lines1 = content1.split('\n');
+  const lines2 = content2.split('\n');
+
+  // Remove trailing empty from final newline
+  if (lines1.length > 0 && lines1[lines1.length - 1] === '') lines1.pop();
+  if (lines2.length > 0 && lines2[lines2.length - 1] === '') lines2.pop();
+
+  const ops = computeLCS(lines1, lines2);
+
+  if (flags.unified) {
+    ctx.stdout.write(formatUnified(ops, file1, file2));
+  } else {
+    ctx.stdout.write(formatNormal(ops));
+  }
+
+  return 1;
+};
+
+export default command;

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

@@ -0,0 +1,170 @@
+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) => {
+  const args = ctx.args;
+  let ignoreCase = false;
+  let invert = false;
+  let lineNumbers = false;
+  let countOnly = false;
+  let filesWithMatches = false;
+  let recursive = false;
+  let wordMatch = false;
+  let pattern = '';
+  const files: string[] = [];
+
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg === '--') { i++; break; }
+    if (arg.startsWith('-') && arg.length > 1 && arg[1] !== '-') {
+      for (let j = 1; j < arg.length; j++) {
+        switch (arg[j]) {
+          case 'i': ignoreCase = true; break;
+          case 'v': invert = true; break;
+          case 'n': lineNumbers = true; break;
+          case 'c': countOnly = true; break;
+          case 'l': filesWithMatches = true; break;
+          case 'r': recursive = true; break;
+          case 'E': break; // JS regex is already ERE
+          case 'w': wordMatch = true; break;
+        }
+      }
+      i++;
+    } else if (!pattern) {
+      pattern = arg;
+      i++;
+    } else {
+      break;
+    }
+  }
+
+  while (i < args.length) {
+    files.push(args[i++]);
+  }
+
+  if (!pattern) {
+    ctx.stderr.write('grep: missing pattern\n');
+    return 2;
+  }
+
+  let regexPattern = pattern;
+  if (wordMatch) {
+    regexPattern = `\\b${regexPattern}\\b`;
+  }
+
+  let regex: RegExp;
+  try {
+    regex = new RegExp(regexPattern, ignoreCase ? 'i' : '');
+  } catch {
+    ctx.stderr.write(`grep: invalid regex: ${pattern}\n`);
+    return 2;
+  }
+
+  let matched = false;
+  const multiFile = files.length > 1 || recursive;
+
+  async function grepLines(lines: string[], fileName: string | null): Promise<void> {
+    let count = 0;
+    for (let idx = 0; idx < lines.length; idx++) {
+      const line = lines[idx];
+      const matches = regex.test(line);
+      if (matches !== invert) {
+        matched = true;
+        count++;
+        if (filesWithMatches) {
+          if (fileName) ctx.stdout.write(fileName + '\n');
+          return;
+        }
+        if (!countOnly) {
+          let output = '';
+          if (multiFile && fileName) output += fileName + ':';
+          if (lineNumbers) output += (idx + 1) + ':';
+          output += line + '\n';
+          ctx.stdout.write(output);
+        }
+      }
+    }
+    if (countOnly) {
+      let output = '';
+      if (multiFile && fileName) output += fileName + ':';
+      output += count + '\n';
+      ctx.stdout.write(output);
+    }
+  }
+
+  function walkDir(dirPath: string): string[] {
+    const result: string[] = [];
+    try {
+      const entries = ctx.vfs.readdir(dirPath);
+      for (const entry of entries) {
+        const fullPath = dirPath === '/' ? '/' + entry.name : dirPath + '/' + entry.name;
+        if (entry.type === 'file') {
+          result.push(fullPath);
+        } else if (entry.type === 'directory') {
+          result.push(...walkDir(fullPath));
+        }
+      }
+    } catch {
+      // skip inaccessible dirs
+    }
+    return result;
+  }
+
+  if (files.length === 0) {
+    if (ctx.stdin) {
+      const content = await ctx.stdin.readAll();
+      const lines = content.replace(/\n$/, '').split('\n');
+      await grepLines(lines, null);
+    } else {
+      ctx.stderr.write('grep: missing file operand\n');
+      return 2;
+    }
+  } else {
+    for (const file of files) {
+      const path = resolve(ctx.cwd, file);
+      try {
+        const stat = ctx.vfs.stat(path);
+        if (stat.type === 'directory') {
+          if (recursive) {
+            const dirFiles = walkDir(path);
+            for (const f of dirFiles) {
+              try {
+                if (isBinaryMime(getMimeType(f))) {
+                  continue;
+                }
+                const content = ctx.vfs.readFileString(f);
+                const lines = content.replace(/\n$/, '').split('\n');
+                await grepLines(lines, f);
+              } catch {
+                // skip unreadable files
+              }
+            }
+          } else {
+            ctx.stderr.write(`grep: ${file}: Is a directory\n`);
+          }
+          continue;
+        }
+        if (isBinaryMime(getMimeType(path))) {
+          ctx.stderr.write(`grep: ${file}: binary file, skipping\n`);
+          continue;
+        }
+        const content = ctx.vfs.readFileString(path);
+        const lines = content.replace(/\n$/, '').split('\n');
+        await grepLines(lines, multiFile ? file : null);
+      } catch (e) {
+        if (e instanceof VFSError) {
+          ctx.stderr.write(`grep: ${file}: ${e.message}\n`);
+        } else {
+          throw e;
+        }
+      }
+    }
+  }
+
+  return matched ? 0 : 1;
+};
+
+export default command;