@lifo-sh/core 0.5.0 → 0.5.6

package/dist/sort-DYZuiMaO.js

@@ -0,0 +1,87 @@
+import { r as resolve, V as VFSError } from "./index-GLjTMF7C.js";
+import { i as isBinaryMime, g as getMimeType } from "./mime-B5knsVEw.js";
+const command = async (ctx) => {
+  let reverse = false;
+  let numeric = false;
+  let unique = false;
+  let keyField = 0;
+  const files = [];
+  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
+`);
+          continue;
+        }
+        text += ctx.vfs.readFileString(path);
+      } catch (e) {
+        if (e instanceof VFSError) {
+          ctx.stderr.write(`sort: ${file}: ${e.message}
+`);
+          return 1;
+        }
+        throw e;
+      }
+    }
+  }
+  let lines = text.replace(/\n$/, "").split("\n");
+  function getKey(line) {
+    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;
+    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 {
+  command as default
+};

package/dist/stat-CXSSmsrA.js

@@ -0,0 +1,38 @@
+import { r as resolve, V as VFSError } from "./index-GLjTMF7C.js";
+const command = async (ctx) => {
+  if (ctx.args.length === 0) {
+    ctx.stderr.write("stat: missing operand\n");
+    return 1;
+  }
+  let exitCode = 0;
+  for (const arg of ctx.args) {
+    const path = resolve(ctx.cwd, arg);
+    try {
+      const st = ctx.vfs.stat(path);
+      const mode = "0" + st.mode.toString(8);
+      const type = st.type === "directory" ? "directory" : "regular file";
+      ctx.stdout.write(`  File: ${arg}
+`);
+      ctx.stdout.write(`  Size: ${st.size}	Type: ${type}
+`);
+      ctx.stdout.write(`  Mode: ${mode}
+`);
+      ctx.stdout.write(`  Created: ${new Date(st.ctime).toISOString()}
+`);
+      ctx.stdout.write(`  Modified: ${new Date(st.mtime).toISOString()}
+`);
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`stat: ${arg}: ${e.message}
+`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+  return exitCode;
+};
+export {
+  command as default
+};

package/dist/strings-BwqQy-zL.js

@@ -0,0 +1,63 @@
+import { r as resolve, V as VFSError } from "./index-GLjTMF7C.js";
+function extractStrings(data, minLen) {
+  const results = [];
+  let current = "";
+  for (let i = 0; i < data.length; i++) {
+    const byte = data[i];
+    if (byte >= 32 && byte <= 126 || byte === 9) {
+      current += String.fromCharCode(byte);
+    } else {
+      if (current.length >= minLen) {
+        results.push(current);
+      }
+      current = "";
+    }
+  }
+  if (current.length >= minLen) {
+    results.push(current);
+  }
+  return results;
+}
+const command = async (ctx) => {
+  let minLen = 4;
+  const files = [];
+  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}
+`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+  return exitCode;
+};
+export {
+  command as default
+};

package/dist/tac-CuZSbu_c.js

@@ -0,0 +1,32 @@
+import { r as resolve, V as VFSError } from "./index-GLjTMF7C.js";
+const command = async (ctx) => {
+  let exitCode = 0;
+  const processContent = (content) => {
+    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}
+`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+  return exitCode;
+};
+export {
+  command as default
+};

package/dist/tail-DH7xR0rW.js

@@ -0,0 +1,62 @@
+import { r as resolve, V as VFSError } from "./index-GLjTMF7C.js";
+import { i as isBinaryMime, g as getMimeType } from "./mime-B5knsVEw.js";
+const command = async (ctx) => {
+  let count = 10;
+  const files = [];
+  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) {
+    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
+`);
+        continue;
+      }
+      const content = ctx.vfs.readFileString(path);
+      if (files.length > 1) ctx.stdout.write(`==> ${file} <==
+`);
+      await tailText(content);
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`tail: ${file}: ${e.message}
+`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+  return exitCode;
+};
+export {
+  command as default
+};

package/dist/tar-AnR03GXP.js

@@ -0,0 +1,155 @@
+import { r as resolve, c as collectFiles, d as createTar, f as compressGzip, h as decompressGzip, p as parseTar, i as dirname, V as VFSError } from "./index-GLjTMF7C.js";
+const command = async (ctx) => {
+  let create = false;
+  let extract = false;
+  let list = false;
+  let gzipFlag = false;
+  let verbose = false;
+  let archiveFile = "";
+  let changeDir = "";
+  const files = [];
+  let i = 0;
+  while (i < ctx.args.length) {
+    const arg = ctx.args[i];
+    if (arg === "--help") {
+      ctx.stdout.write("Usage: tar [-c|-x|-t] [-z] [-v] [-f file] [-C dir] [files...]\n");
+      ctx.stdout.write("  -c   create archive\n");
+      ctx.stdout.write("  -x   extract archive\n");
+      ctx.stdout.write("  -t   list archive contents\n");
+      ctx.stdout.write("  -z   gzip compression\n");
+      ctx.stdout.write("  -v   verbose\n");
+      ctx.stdout.write("  -f   archive file\n");
+      ctx.stdout.write("  -C   change directory\n");
+      return 0;
+    }
+    if (arg.startsWith("-") && arg !== "-") {
+      const chars = arg.slice(1);
+      for (let j = 0; j < chars.length; j++) {
+        switch (chars[j]) {
+          case "c":
+            create = true;
+            break;
+          case "x":
+            extract = true;
+            break;
+          case "t":
+            list = true;
+            break;
+          case "z":
+            gzipFlag = true;
+            break;
+          case "v":
+            verbose = true;
+            break;
+          case "f": {
+            const rest = chars.slice(j + 1);
+            archiveFile = rest || ctx.args[++i] || "";
+            j = chars.length;
+            break;
+          }
+          case "C": {
+            const rest = chars.slice(j + 1);
+            changeDir = rest || ctx.args[++i] || "";
+            j = chars.length;
+            break;
+          }
+          default:
+            ctx.stderr.write(`tar: unknown option: -${chars[j]}
+`);
+            return 1;
+        }
+      }
+    } else {
+      files.push(arg);
+    }
+    i++;
+  }
+  const modeCount = [create, extract, list].filter(Boolean).length;
+  if (modeCount === 0) {
+    ctx.stderr.write("tar: must specify one of -c, -x, -t\n");
+    return 1;
+  }
+  if (modeCount > 1) {
+    ctx.stderr.write("tar: conflicting options\n");
+    return 1;
+  }
+  if (!archiveFile) {
+    ctx.stderr.write("tar: -f is required\n");
+    return 1;
+  }
+  const archivePath = resolve(ctx.cwd, archiveFile);
+  const targetDir = changeDir ? resolve(ctx.cwd, changeDir) : ctx.cwd;
+  try {
+    if (create) {
+      if (files.length === 0) {
+        ctx.stderr.write("tar: no files to archive\n");
+        return 1;
+      }
+      const entries = collectFiles(ctx.vfs, targetDir, files);
+      let data = createTar(entries);
+      if (gzipFlag) {
+        data = await compressGzip(data);
+      }
+      ctx.vfs.writeFile(archivePath, data);
+      if (verbose) {
+        for (const entry of entries) {
+          ctx.stdout.write(`${entry.path}
+`);
+        }
+      }
+    } else if (extract) {
+      let data = ctx.vfs.readFile(archivePath);
+      if (gzipFlag) {
+        data = await decompressGzip(data);
+      }
+      const entries = parseTar(data);
+      if (changeDir) {
+        try {
+          ctx.vfs.mkdir(targetDir, { recursive: true });
+        } catch {
+        }
+      }
+      for (const entry of entries) {
+        const entryPath = resolve(targetDir, entry.path);
+        if (entry.type === "directory") {
+          try {
+            ctx.vfs.mkdir(entryPath, { recursive: true });
+          } catch {
+          }
+        } else {
+          const parent = dirname(entryPath);
+          try {
+            ctx.vfs.mkdir(parent, { recursive: true });
+          } catch {
+          }
+          ctx.vfs.writeFile(entryPath, entry.data);
+        }
+        if (verbose) {
+          ctx.stdout.write(`${entry.path}
+`);
+        }
+      }
+    } else if (list) {
+      let data = ctx.vfs.readFile(archivePath);
+      if (gzipFlag) {
+        data = await decompressGzip(data);
+      }
+      const entries = parseTar(data);
+      for (const entry of entries) {
+        ctx.stdout.write(`${entry.path}${entry.type === "directory" ? "/" : ""}
+`);
+      }
+    }
+  } catch (e) {
+    if (e instanceof VFSError) {
+      ctx.stderr.write(`tar: ${e.message}
+`);
+      return 2;
+    }
+    throw e;
+  }
+  return 0;
+};
+export {
+  command as default
+};

package/dist/tee-ByHsMExU.js

@@ -0,0 +1,29 @@
+import { r as resolve } from "./index-GLjTMF7C.js";
+const command = async (ctx) => {
+  let append = false;
+  const files = [];
+  for (const arg of ctx.args) {
+    if (arg === "-a") {
+      append = true;
+    } else {
+      files.push(arg);
+    }
+  }
+  let text = "";
+  if (ctx.stdin) {
+    text = await ctx.stdin.readAll();
+  }
+  ctx.stdout.write(text);
+  for (const file of files) {
+    const path = resolve(ctx.cwd, file);
+    if (append) {
+      ctx.vfs.appendFile(path, text);
+    } else {
+      ctx.vfs.writeFile(path, text);
+    }
+  }
+  return 0;
+};
+export {
+  command as default
+};

package/dist/touch-CcmnMpg5.js

@@ -0,0 +1,26 @@
+import { r as resolve, V as VFSError } from "./index-GLjTMF7C.js";
+const command = async (ctx) => {
+  if (ctx.args.length === 0) {
+    ctx.stderr.write("touch: missing operand\n");
+    return 1;
+  }
+  let exitCode = 0;
+  for (const arg of ctx.args) {
+    const path = resolve(ctx.cwd, arg);
+    try {
+      ctx.vfs.touch(path);
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`touch: ${arg}: ${e.message}
+`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+  return exitCode;
+};
+export {
+  command as default
+};

package/dist/tr-D_cg13q8.js

@@ -0,0 +1,92 @@
+function expandRange(set) {
+  let result = "";
+  let i = 0;
+  while (i < set.length) {
+    if (i + 2 < set.length && set[i + 1] === "-") {
+      const start = set.charCodeAt(i);
+      const end = set.charCodeAt(i + 2);
+      for (let c = start; c <= end; c++) {
+        result += String.fromCharCode(c);
+      }
+      i += 3;
+    } else {
+      result += set[i];
+      i++;
+    }
+  }
+  return result;
+}
+const command = async (ctx) => {
+  let deleteMode = false;
+  let squeezeMode = false;
+  const sets = [];
+  for (const arg of ctx.args) {
+    if (arg === "-d") {
+      deleteMode = true;
+    } else if (arg === "-s") {
+      squeezeMode = true;
+    } else {
+      sets.push(arg);
+    }
+  }
+  if (sets.length === 0) {
+    ctx.stderr.write("tr: missing operand\n");
+    return 1;
+  }
+  let text = "";
+  if (ctx.stdin) {
+    text = await ctx.stdin.readAll();
+  } else {
+    ctx.stderr.write("tr: missing input\n");
+    return 1;
+  }
+  const set1 = expandRange(sets[0]);
+  if (deleteMode) {
+    let result2 = "";
+    for (const ch of text) {
+      if (!set1.includes(ch)) result2 += ch;
+    }
+    ctx.stdout.write(result2);
+    return 0;
+  }
+  if (squeezeMode && sets.length === 1) {
+    let result2 = "";
+    let lastCh = "";
+    for (const ch of text) {
+      if (set1.includes(ch) && ch === lastCh) continue;
+      result2 += ch;
+      lastCh = ch;
+    }
+    ctx.stdout.write(result2);
+    return 0;
+  }
+  if (sets.length < 2) {
+    ctx.stderr.write("tr: missing operand after set1\n");
+    return 1;
+  }
+  const set2 = expandRange(sets[1]);
+  const map = /* @__PURE__ */ new Map();
+  for (let i = 0; i < set1.length; i++) {
+    map.set(set1[i], set2[Math.min(i, set2.length - 1)]);
+  }
+  let result = "";
+  for (const ch of text) {
+    result += map.get(ch) ?? ch;
+  }
+  if (squeezeMode) {
+    const set2Chars = new Set(set2);
+    let squeezed = "";
+    let lastCh = "";
+    for (const ch of result) {
+      if (set2Chars.has(ch) && ch === lastCh) continue;
+      squeezed += ch;
+      lastCh = ch;
+    }
+    result = squeezed;
+  }
+  ctx.stdout.write(result);
+  return 0;
+};
+export {
+  command as default
+};

package/dist/tree-Ck1ymlSv.js

@@ -0,0 +1,64 @@
+import { r as resolve, V as VFSError } from "./index-GLjTMF7C.js";
+const command = async (ctx) => {
+  let maxDepth = Infinity;
+  let dirsOnly = false;
+  let targetPath = ".";
+  for (let i = 0; i < ctx.args.length; i++) {
+    const arg = ctx.args[i];
+    if (arg === "-L" && i + 1 < ctx.args.length) {
+      maxDepth = parseInt(ctx.args[++i], 10);
+    } else if (arg === "-d") {
+      dirsOnly = true;
+    } else if (!arg.startsWith("-")) {
+      targetPath = arg;
+    }
+  }
+  const absPath = resolve(ctx.cwd, targetPath);
+  let dirCount = 0;
+  let fileCount = 0;
+  function printTree(dirPath, prefix, depth) {
+    if (depth > maxDepth) return;
+    try {
+      const entries = ctx.vfs.readdir(dirPath);
+      const filtered = dirsOnly ? entries.filter((e) => e.type === "directory") : entries;
+      const sorted = filtered.sort((a, b) => a.name.localeCompare(b.name));
+      for (let i = 0; i < sorted.length; i++) {
+        const entry = sorted[i];
+        const isLast = i === sorted.length - 1;
+        const connector = isLast ? "└── " : "├── ";
+        ctx.stdout.write(prefix + connector + entry.name + "\n");
+        if (entry.type === "directory") {
+          dirCount++;
+          const newPrefix = prefix + (isLast ? "    " : "│   ");
+          const fullPath = dirPath === "/" ? "/" + entry.name : dirPath + "/" + entry.name;
+          printTree(fullPath, newPrefix, depth + 1);
+        } else {
+          fileCount++;
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    ctx.vfs.stat(absPath);
+  } catch (e) {
+    if (e instanceof VFSError) {
+      ctx.stderr.write(`tree: '${targetPath}': ${e.message}
+`);
+      return 1;
+    }
+    throw e;
+  }
+  ctx.stdout.write(targetPath + "\n");
+  printTree(absPath, "", 1);
+  const summary = dirsOnly ? `
+${dirCount} directories
+` : `
+${dirCount} directories, ${fileCount} files
+`;
+  ctx.stdout.write(summary);
+  return 0;
+};
+export {
+  command as default
+};

package/dist/uname-07bQ7DTD.js

@@ -0,0 +1,50 @@
+const command = async (ctx) => {
+  const info = {
+    sysname: "Lifo",
+    release: "1.0.0",
+    machine: "wasm"
+  };
+  if (ctx.args.length === 0) {
+    ctx.stdout.write(info.sysname + "\n");
+    return 0;
+  }
+  let showAll = false;
+  let showSysname = false;
+  let showRelease = false;
+  let showMachine = false;
+  for (const arg of ctx.args) {
+    if (arg.startsWith("-")) {
+      for (let i = 1; i < arg.length; i++) {
+        switch (arg[i]) {
+          case "a":
+            showAll = true;
+            break;
+          case "s":
+            showSysname = true;
+            break;
+          case "r":
+            showRelease = true;
+            break;
+          case "m":
+            showMachine = true;
+            break;
+        }
+      }
+    }
+  }
+  if (showAll) {
+    ctx.stdout.write(`${info.sysname} ${info.release} ${info.machine}
+`);
+    return 0;
+  }
+  const parts = [];
+  if (showSysname) parts.push(info.sysname);
+  if (showRelease) parts.push(info.release);
+  if (showMachine) parts.push(info.machine);
+  if (parts.length === 0) parts.push(info.sysname);
+  ctx.stdout.write(parts.join(" ") + "\n");
+  return 0;
+};
+export {
+  command as default
+};