@bashlife/boxbox-beta 69.0.0

package/src/commands/cut.js

@@ -0,0 +1,42 @@
+import fs from "fs";
+
+export default function cut(args) {
+  let delimiter = "\t";
+  let field = null;
+  let file = null;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg.startsWith("-d")) {
+      delimiter = arg.length > 2 ? arg.slice(2) : args[++i];
+    } 
+    else if (arg.startsWith("-f")) {
+      field = Number(arg.length > 2 ? arg.slice(2) : args[++i]);
+    } 
+    else {
+      file = arg;
+    }
+  }
+
+  if (!field || !file) {
+    console.log("Usage: cut -d delimiter -f field file");
+    return;
+  }
+
+  if (!fs.existsSync(file)) {
+    console.log(`cut: ${file}: No such file`);
+    return;
+  }
+
+  const content = fs.readFileSync(file, "utf8");
+
+  const lines = content.split("\n");
+
+  for (const line of lines) {
+    if (line.length === 0) continue;
+
+    const parts = line.split(delimiter);
+    console.log(parts[field - 1] ?? "");
+  }
+}

package/src/commands/date.js

@@ -0,0 +1,5 @@
+export default function(args) {
+  const now = new Date();
+
+  console.log(now.toString());
+}

package/src/commands/df.js

@@ -0,0 +1,35 @@
+import fs from "fs";
+
+export default function(args) {
+  try {
+    const path = args[0] || ".";
+
+    const stats = fs.statfsSync(path);
+
+    const total = stats.blocks * stats.bsize;
+    const free = stats.bfree * stats.bsize;
+    const used = total - free;
+
+    console.log("Filesystem usage:");
+    console.log(`Total: ${format(total)}`);
+    console.log(`Used:  ${format(used)}`);
+    console.log(`Free:  ${format(free)}`);
+
+  } catch (err) {
+    console.log(`df: ${err.message}`);
+  }
+}
+
+function format(bytes) {
+  const units = ["B", "KB", "MB", "GB", "TB"];
+
+  let size = bytes;
+  let unit = 0;
+
+  while (size >= 1024 && unit < units.length - 1) {
+    size /= 1024;
+    unit++;
+  }
+
+  return `${size.toFixed(2)} ${units[unit]}`;
+}

package/src/commands/diff.js

@@ -0,0 +1,33 @@
+import fs from "fs";
+
+export default function diff(args) {
+  if (args.length < 2) {
+    console.log("diff: missing operand");
+    return;
+  }
+
+  const file1 = args[0];
+  const file2 = args[1];
+
+  if (!fs.existsSync(file1)) {
+    console.log(`diff: ${file1}: No such file`);
+    return;
+  }
+
+  if (!fs.existsSync(file2)) {
+    console.log(`diff: ${file2}: No such file`);
+    return;
+  }
+
+  const a = fs.readFileSync(file1, "utf8").split("\n");
+  const b = fs.readFileSync(file2, "utf8").split("\n");
+
+  const max = Math.max(a.length, b.length);
+
+  for (let i = 0; i < max; i++) {
+    if (a[i] !== b[i]) {
+      if (a[i] !== undefined) console.log(`< ${a[i]}`);
+      if (b[i] !== undefined) console.log(`> ${b[i]}`);
+    }
+  }
+}

package/src/commands/dirname.js

@@ -0,0 +1,10 @@
+import path from "path";
+
+export default function dirname(args) {
+  if (!args[0]) {
+    console.log("dirname: missing operand");
+    return;
+  }
+
+  console.log(path.dirname(args[0]));
+}

package/src/commands/du.js

@@ -0,0 +1,31 @@
+import fs from "fs";
+import path from "path";
+
+export default function(args) {
+  const target = args[0] || ".";
+
+  function getSize(file) {
+    const stat = fs.statSync(file);
+
+    if (stat.isDirectory()) {
+      let total = 0;
+
+      for (const item of fs.readdirSync(file)) {
+        total += getSize(path.join(file, item));
+      }
+
+      return total;
+    }
+
+    return stat.size;
+  }
+
+  try {
+    const size = getSize(target);
+
+    console.log(`${size}\t${target}`);
+
+  } catch (err) {
+    console.log(`du: ${err.message}`);
+  }
+}

package/src/commands/echo.js

@@ -0,0 +1,32 @@
+import fs from "fs";
+
+export default function(args) {
+  if (args.length === 0) {
+    console.log("");
+    return;
+  }
+
+  const outputIndex = args.indexOf("-o");
+
+  if (outputIndex !== -1) {
+    const file = args[outputIndex + 1];
+    const text = args
+      .slice(0, outputIndex)
+      .join(" ");
+
+    if (!file) {
+      console.log("Usage: echo <text> -o <file>");
+      return;
+    }
+
+    try {
+      fs.writeFileSync(file, text + "\n");
+    } catch (err) {
+      console.log(`echo: ${err.message}`);
+    }
+
+    return;
+  }
+
+  console.log(args.join(" "));
+}

package/src/commands/env.js

@@ -0,0 +1,38 @@
+import { spawn } from "child_process";
+
+export default function env(args) {
+  let customEnv = {};
+  let commandIndex = 0;
+
+  while (commandIndex < args.length && args[commandIndex].includes("=")) {
+    const [key, ...valueParts] = args[commandIndex].split("=");
+    customEnv[key] = valueParts.join("=");
+    commandIndex++;
+  }
+
+  // No command = print environment
+  if (commandIndex >= args.length) {
+    for (const [key, value] of Object.entries(process.env)) {
+      console.log(`${key}=${value}`);
+    }
+    return;
+  }
+
+  const command = args[commandIndex];
+  const commandArgs = args.slice(commandIndex + 1);
+
+  const newEnv = {
+    ...process.env,
+    ...customEnv
+  };
+
+  const child = spawn(command, commandArgs, {
+    env: newEnv,
+    stdio: "inherit",
+    shell: true
+  });
+
+  child.on("error", (err) => {
+    console.error(`env: ${err.message}`);
+  });
+}

package/src/commands/expr.js

@@ -0,0 +1,97 @@
+export default function expr(args) {
+  if (args.length === 0) {
+    console.log("expr: missing expression");
+    return;
+  }
+
+  const vars = {};
+
+  // Collect variable assignments
+  while (args.length > 0 && /^[a-zA-Z_][a-zA-Z0-9_]*=/.test(args[0])) {
+    const [name, value] = args.shift().split("=");
+
+    const num = Number(value);
+
+    if (Number.isNaN(num)) {
+      console.log(`expr: invalid value for ${name}`);
+      return;
+    }
+
+    vars[name] = num;
+  }
+
+  let expression = args.join(" ");
+
+  // Replace variables
+  for (const [name, value] of Object.entries(vars)) {
+    const regex = new RegExp(`\\b${name}\\b`, "g");
+    expression = expression.replace(regex, value);
+  }
+
+  // Comparisons
+  const comparison = expression.match(
+    /^(.+)\s*(=|!=|<=|>=|<|>)\s*(.+)$/
+  );
+
+  if (comparison) {
+    const left = calculate(comparison[1]);
+    const op = comparison[2];
+    const right = calculate(comparison[3]);
+
+    switch (op) {
+      case "=":
+        console.log(left === right ? 1 : 0);
+        return;
+
+      case "!=":
+        console.log(left !== right ? 1 : 0);
+        return;
+
+      case "<":
+        console.log(left < right ? 1 : 0);
+        return;
+
+      case ">":
+        console.log(left > right ? 1 : 0);
+        return;
+
+      case "<=":
+        console.log(left <= right ? 1 : 0);
+        return;
+
+      case ">=":
+        console.log(left >= right ? 1 : 0);
+        return;
+    }
+  }
+
+  try {
+    console.log(calculate(expression));
+  } catch {
+    console.log("expr: invalid expression");
+  }
+}
+
+
+function calculate(expression) {
+  expression = expression.trim();
+  expression = expression.replace(/\bx\b/g, "*");
+
+  const tokens = expression.match(
+    /-?\d+(?:\.\d+)?|[+\-*/%()]|\s+/g
+  );
+
+  if (!tokens) {
+    throw new Error();
+  }
+
+  const clean = tokens
+    .filter(t => !/\s/.test(t))
+    .join("");
+
+  if (!/^[0-9+\-*/%.()]+$/.test(clean)) {
+    throw new Error();
+  }
+
+  return Function(`"use strict"; return (${clean})`)();
+}

package/src/commands/file.js

@@ -0,0 +1,35 @@
+import fs from "fs";
+import path from "path";
+
+export default function(args) {
+  const target = args[0];
+
+  if (!target) {
+    console.log("Usage: file <filename>");
+    return;
+  }
+
+  try {
+    const stat = fs.statSync(target);
+
+    if (stat.isDirectory()) {
+      console.log(`${target}: directory`);
+      return;
+    }
+
+    const ext = path.extname(target).toLowerCase();
+
+    let type = "regular file";
+
+    if (ext === ".js") type = "JavaScript source";
+    else if (ext === ".json") type = "JSON data";
+    else if (ext === ".txt") type = "text file";
+    else if (ext === ".png") type = "PNG image";
+    else if (ext === ".jpg" || ext === ".jpeg") type = "JPEG image";
+
+    console.log(`${target}: ${type}`);
+
+  } catch (err) {
+    console.log(`file: ${err.message}`);
+  }
+}

package/src/commands/find.js

@@ -0,0 +1,25 @@
+import fs from "fs";
+import path from "path";
+
+export default function(args) {
+  const start = args[0] || ".";
+
+  function walk(dir) {
+    const entries = fs.readdirSync(dir);
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry);
+      console.log(fullPath);
+
+      if (fs.statSync(fullPath).isDirectory()) {
+        walk(fullPath);
+      }
+    }
+  }
+
+  try {
+    walk(start);
+  } catch (err) {
+    console.log(`find: ${err.message}`);
+  }
+}

package/src/commands/fmt.js

@@ -0,0 +1,36 @@
+import fs from "fs";
+
+export default function fmt(args) {
+  if (!args[0]) {
+    console.log("Usage: fmt file");
+    return;
+  }
+
+  const file = args[0];
+
+  if (!fs.existsSync(file)) {
+    console.log(`fmt: ${file}: No such file`);
+    return;
+  }
+
+  const width = 75;
+  const words = fs.readFileSync(file, "utf8")
+    .replace(/\s+/g, " ")
+    .trim()
+    .split(" ");
+
+  let line = "";
+
+  for (const word of words) {
+    if ((line + word).length > width) {
+      console.log(line.trim());
+      line = "";
+    }
+
+    line += word + " ";
+  }
+
+  if (line.trim()) {
+    console.log(line.trim());
+  }
+}

package/src/commands/fold.js

@@ -0,0 +1,40 @@
+import fs from "fs";
+
+export default function fold(args) {
+  let width = 80;
+  let file = null;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "-w" && args[i + 1]) {
+      width = Number(args[i + 1]);
+      i++;
+    } else {
+      file = args[i];
+    }
+  }
+
+  if (!file) {
+    console.log("Usage: fold -w width file");
+    return;
+  }
+
+  if (!fs.existsSync(file)) {
+    console.log(`fold: ${file}: No such file`);
+    return;
+  }
+
+  const text = fs.readFileSync(file, "utf8");
+
+  for (const line of text.split("\n")) {
+    let current = line;
+
+    while (current.length > width) {
+      console.log(current.slice(0, width));
+      current = current.slice(width);
+    }
+
+    if (current.length > 0) {
+      console.log(current);
+    }
+  }
+}

package/src/commands/grep.js

@@ -0,0 +1,25 @@
+import fs from "fs";
+
+export default function(args) {
+  const pattern = args[0];
+  const file = args[1];
+
+  if (!pattern || !file) {
+    console.log("Usage: grep <pattern> <file>");
+    return;
+  }
+
+  try {
+    const content = fs.readFileSync(file, "utf8");
+    const lines = content.split("\n");
+
+    for (const line of lines) {
+      if (line.includes(pattern)) {
+        console.log(line);
+      }
+    }
+
+  } catch (err) {
+    console.log(`grep: ${err.message}`);
+  }
+}

package/src/commands/groups.js

@@ -0,0 +1,6 @@
+import os from "os";
+
+export default function groups() {
+  const username = os.userInfo().username;
+  console.log(username);
+}

package/src/commands/head.js

@@ -0,0 +1,23 @@
+import fs from "fs";
+
+export default function(args) {
+  const file = args[0];
+
+  if (!file) {
+    console.log("Usage: head <file>");
+    return;
+  }
+
+  try {
+    const content = fs.readFileSync(file, "utf8");
+
+    const lines = content.split("\n");
+
+    const amount = 10;
+
+    console.log(lines.slice(0, amount).join("\n"));
+
+  } catch (err) {
+    console.log(`head: ${err.message}`);
+  }
+}

package/src/commands/help.js

@@ -0,0 +1,41 @@
+export function commands() {
+  console.log(`
+BoxBox v0.1.0
+Modern Unix toolbox
+
+Commands:
+  ls       List files
+  cat      Show file contents
+  mkdir    Create directory
+  ls
+  mkdir
+  mv
+  cd
+  touch
+  echo
+  cat
+  cp
+  rm
+  pwd
+  find
+  tree
+  wc
+  grep
+  head
+  tail
+  sort
+  uniq
+  which
+  uname
+  chmod
+  du
+  df
+  printenv
+  date
+  file
+  kill
+  call
+  curl
+  help     Show help
+`);
+}

package/src/commands/hexdump.js

@@ -0,0 +1,40 @@
+import fs from "fs";
+
+export default function hexdump(args) {
+  if (!args[0]) {
+    console.log("Usage: hexdump file");
+    return;
+  }
+
+  const file = args[0];
+
+  if (!fs.existsSync(file)) {
+    console.log(`hexdump: ${file}: No such file`);
+    return;
+  }
+
+  const data = fs.readFileSync(file);
+
+  for (let i = 0; i < data.length; i += 16) {
+    const chunk = data.slice(i, i + 16);
+
+    const hex = Array.from(chunk)
+      .map(byte => byte.toString(16).padStart(2, "0"))
+      .join(" ");
+
+    const ascii = Array.from(chunk)
+      .map(byte => {
+        const c = String.fromCharCode(byte);
+        return byte >= 32 && byte <= 126 ? c : ".";
+      })
+      .join("");
+
+    console.log(
+      i.toString(16).padStart(8, "0") +
+      "  " +
+      hex.padEnd(47, " ") +
+      "  " +
+      ascii
+    );
+  }
+}

package/src/commands/hostname.js

@@ -0,0 +1,5 @@
+import os from "os";
+
+export default function hostname() {
+  console.log(os.hostname());
+}

package/src/commands/id.js

@@ -0,0 +1,6 @@
+export default function id() {
+  const uid = process.getuid ? process.getuid() : "unknown";
+  const gid = process.getgid ? process.getgid() : "unknown";
+
+  console.log(`uid=${uid} gid=${gid}`);
+}

package/src/commands/info.js

@@ -0,0 +1,47 @@
+import fs from "fs";
+import path from "path";
+
+export default function info() {
+  const root = process.cwd();
+
+  const packagePath = path.join(
+    root,
+    "package.json"
+  );
+
+  const commandsDir = path.join(
+    root,
+    "src",
+    "commands"
+  );
+
+  let version = "unknown";
+  let commandCount = 0;
+
+  // Read version from package.json
+  if (fs.existsSync(packagePath)) {
+    try {
+      const pkg = JSON.parse(
+        fs.readFileSync(packagePath, "utf8")
+      );
+
+      version = pkg.version || "unknown";
+    } catch {
+      version = "unknown";
+    }
+  }
+
+  // Count commands (files + folders)
+  if (fs.existsSync(commandsDir)) {
+    const entries = fs.readdirSync(commandsDir);
+
+    commandCount = entries.filter((entry) => {
+      return !entry.startsWith(".");
+    }).length;
+  }
+
+  console.log(`BoxBox ${version}`);
+  console.log("Runtime: Node.js");
+  console.log(`Platform: ${process.platform}`);
+  console.log(`Commands: ${commandCount}`);
+}