@lifo-sh/core 0.5.0 → 0.5.6

package/dist/ls-Ce1mcASB.js

@@ -0,0 +1,132 @@
+import { p as parseArgs } from "./args-BhoL0JcG.js";
+import { r as resolve, V as VFSError, B as BOLD, a as BLUE, R as RESET } from "./index-GLjTMF7C.js";
+const spec = {
+  long: { type: "boolean", short: "l" },
+  all: { type: "boolean", short: "a" },
+  one: { type: "boolean", short: "1" }
+};
+function formatMode(mode, isDir) {
+  const d = isDir ? "d" : "-";
+  const perms = [
+    mode & 256 ? "r" : "-",
+    mode & 128 ? "w" : "-",
+    mode & 64 ? "x" : "-",
+    mode & 32 ? "r" : "-",
+    mode & 16 ? "w" : "-",
+    mode & 8 ? "x" : "-",
+    mode & 4 ? "r" : "-",
+    mode & 2 ? "w" : "-",
+    mode & 1 ? "x" : "-"
+  ].join("");
+  return d + perms;
+}
+function formatDate(ts) {
+  const d = new Date(ts);
+  const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+  const mon = months[d.getMonth()];
+  const day = String(d.getDate()).padStart(2, " ");
+  const hour = String(d.getHours()).padStart(2, "0");
+  const min = String(d.getMinutes()).padStart(2, "0");
+  return `${mon} ${day} ${hour}:${min}`;
+}
+function formatEntry(entry, long) {
+  const displayName = entry.type === "directory" ? `${BOLD}${BLUE}${entry.name}${RESET}` : entry.name;
+  if (long) {
+    const mode = formatMode(entry.mode, entry.type === "directory");
+    const size = String(entry.size).padStart(6, " ");
+    const date = formatDate(entry.mtime);
+    return `${mode}  1 user user ${size} ${date} ${displayName}
+`;
+  }
+  return displayName;
+}
+function listDirectory(path, flags, ctx) {
+  const entries = ctx.vfs.readdirStat(path);
+  const filtered = flags.all ? entries : entries.filter((e) => !e.name.startsWith("."));
+  filtered.sort((a, b) => a.name.localeCompare(b.name));
+  return filtered;
+}
+const command = async (ctx) => {
+  const { flags, positional } = parseArgs(ctx.args, spec);
+  const targets = positional.length > 0 ? positional : [ctx.cwd];
+  let exitCode = 0;
+  const fileEntries = [];
+  const dirTargets = [];
+  for (const target of targets) {
+    const targetPath = resolve(ctx.cwd, target);
+    try {
+      const stat = ctx.vfs.stat(targetPath);
+      if (stat.type === "file") {
+        fileEntries.push({
+          name: target,
+          type: stat.type,
+          size: stat.size,
+          mtime: stat.mtime,
+          mode: stat.mode
+        });
+      } else {
+        dirTargets.push(target);
+      }
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`ls: ${e.message}
+`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+  if (fileEntries.length > 0) {
+    if (flags.long) {
+      for (const entry of fileEntries) {
+        ctx.stdout.write(formatEntry(entry, true));
+      }
+    } else if (flags.one) {
+      for (const entry of fileEntries) {
+        ctx.stdout.write(formatEntry(entry, false) + "\n");
+      }
+    } else {
+      const names = fileEntries.map((e) => formatEntry(e, false));
+      ctx.stdout.write(names.join("  ") + "\n");
+    }
+  }
+  for (let i = 0; i < dirTargets.length; i++) {
+    const target = dirTargets[i];
+    const targetPath = resolve(ctx.cwd, target);
+    if (dirTargets.length > 1 || fileEntries.length > 0) {
+      if (fileEntries.length > 0 || i > 0) ctx.stdout.write("\n");
+      ctx.stdout.write(`${target}:
+`);
+    }
+    try {
+      const entries = listDirectory(targetPath, flags, ctx);
+      if (flags.long) {
+        for (const entry of entries) {
+          ctx.stdout.write(formatEntry(entry, true));
+        }
+      } else if (flags.one) {
+        for (const entry of entries) {
+          ctx.stdout.write(formatEntry(entry, false) + "\n");
+        }
+      } else {
+        const names = entries.map((e) => formatEntry(e, false));
+        if (names.length > 0) {
+          ctx.stdout.write(names.join("  ") + "\n");
+        }
+      }
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`ls: ${e.message}
+`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+  return exitCode;
+};
+export {
+  command as default
+};

package/dist/{man-Dg26tZ-a.js → man-DjxHeM01.js}

@@ -1,4 +1,4 @@
-const a = {
+const PAGES = {
   // Shell builtins
   cd: { synopsis: "cd [DIR]", description: "Change the current working directory to DIR. If DIR is not specified, change to HOME." },
   pwd: { synopsis: "pwd", description: "Print the current working directory." },
@@ -101,35 +101,54 @@ const a = {
   // Node.js
   node: { synopsis: "node [-e CODE] [FILE]", description: "Execute JavaScript using the Node.js-compatible runtime." },
   pkg: { synopsis: "pkg install|remove|list [PACKAGE]", description: "Package manager for installing and managing packages." }
-}, p = async (s) => {
-  if (s.args.length === 0)
-    return s.stderr.write(`man: missing command name
-`), s.stderr.write(`Usage: man [-k] COMMAND
-`), 1;
-  if (s.args[0] === "-k") {
-    if (s.args.length < 2)
-      return s.stderr.write(`man: -k requires a keyword
-`), 1;
-    const n = s.args[1].toLowerCase();
-    let o = !1;
-    for (const [r, t] of Object.entries(a))
-      (r.includes(n) || t.synopsis.toLowerCase().includes(n) || t.description.toLowerCase().includes(n)) && (s.stdout.write(`${r}(1) - ${t.description.split(".")[0]}
-`), o = !0);
-    return o ? 0 : (s.stderr.write(`man: nothing appropriate for "${s.args[1]}"
-`), 1);
+};
+const command = async (ctx) => {
+  if (ctx.args.length === 0) {
+    ctx.stderr.write("man: missing command name\n");
+    ctx.stderr.write("Usage: man [-k] COMMAND\n");
+    return 1;
+  }
+  if (ctx.args[0] === "-k") {
+    if (ctx.args.length < 2) {
+      ctx.stderr.write("man: -k requires a keyword\n");
+      return 1;
+    }
+    const keyword = ctx.args[1].toLowerCase();
+    let found = false;
+    for (const [name2, page2] of Object.entries(PAGES)) {
+      if (name2.includes(keyword) || page2.synopsis.toLowerCase().includes(keyword) || page2.description.toLowerCase().includes(keyword)) {
+        ctx.stdout.write(`${name2}(1) - ${page2.description.split(".")[0]}
+`);
+        found = true;
+      }
+    }
+    if (!found) {
+      ctx.stderr.write(`man: nothing appropriate for "${ctx.args[1]}"
+`);
+      return 1;
+    }
+    return 0;
+  }
+  const name = ctx.args[0];
+  const page = PAGES[name];
+  if (!page) {
+    ctx.stderr.write(`man: no manual entry for ${name}
+`);
+    return 1;
   }
-  const i = s.args[0], e = a[i];
-  return e ? (s.stdout.write(`NAME
-    ${i} - ${e.description.split(".")[0].toLowerCase()}
+  ctx.stdout.write(`NAME
+    ${name} - ${page.description.split(".")[0].toLowerCase()}
 
-`), s.stdout.write(`SYNOPSIS
-    ${e.synopsis}
+`);
+  ctx.stdout.write(`SYNOPSIS
+    ${page.synopsis}
 
-`), s.stdout.write(`DESCRIPTION
-    ${e.description}
-`), 0) : (s.stderr.write(`man: no manual entry for ${i}
-`), 1);
+`);
+  ctx.stdout.write(`DESCRIPTION
+    ${page.description}
+`);
+  return 0;
 };
 export {
-  p as default
+  command as default
 };

package/dist/mime-B5knsVEw.js

@@ -0,0 +1,101 @@
+const mimeTypes = /* @__PURE__ */ new Map([
+  // Text
+  [".txt", "text/plain"],
+  [".md", "text/markdown"],
+  [".json", "application/json"],
+  [".js", "text/javascript"],
+  [".ts", "text/typescript"],
+  [".jsx", "text/jsx"],
+  [".tsx", "text/tsx"],
+  [".css", "text/css"],
+  [".html", "text/html"],
+  [".xml", "text/xml"],
+  [".yaml", "text/yaml"],
+  [".yml", "text/yaml"],
+  [".toml", "text/toml"],
+  [".ini", "text/plain"],
+  [".cfg", "text/plain"],
+  [".conf", "text/plain"],
+  [".sh", "text/x-shellscript"],
+  [".bash", "text/x-shellscript"],
+  [".zsh", "text/x-shellscript"],
+  [".py", "text/x-python"],
+  [".rb", "text/x-ruby"],
+  [".go", "text/x-go"],
+  [".rs", "text/x-rust"],
+  [".c", "text/x-c"],
+  [".cpp", "text/x-c++"],
+  [".h", "text/x-c"],
+  [".hpp", "text/x-c++"],
+  [".java", "text/x-java"],
+  [".csv", "text/csv"],
+  [".log", "text/plain"],
+  [".env", "text/plain"],
+  [".gitignore", "text/plain"],
+  [".dockerignore", "text/plain"],
+  [".sql", "text/x-sql"],
+  [".graphql", "text/x-graphql"],
+  [".vue", "text/x-vue"],
+  [".svelte", "text/x-svelte"],
+  // Images
+  [".png", "image/png"],
+  [".jpg", "image/jpeg"],
+  [".jpeg", "image/jpeg"],
+  [".gif", "image/gif"],
+  [".svg", "image/svg+xml"],
+  [".webp", "image/webp"],
+  [".ico", "image/x-icon"],
+  [".bmp", "image/bmp"],
+  [".tiff", "image/tiff"],
+  // Video
+  [".mp4", "video/mp4"],
+  [".webm", "video/webm"],
+  [".avi", "video/x-msvideo"],
+  [".mov", "video/quicktime"],
+  [".mkv", "video/x-matroska"],
+  // Audio
+  [".mp3", "audio/mpeg"],
+  [".wav", "audio/wav"],
+  [".ogg", "audio/ogg"],
+  [".flac", "audio/flac"],
+  [".aac", "audio/aac"],
+  [".m4a", "audio/mp4"],
+  // Archives
+  [".zip", "application/zip"],
+  [".tar", "application/x-tar"],
+  [".gz", "application/gzip"],
+  [".tgz", "application/gzip"],
+  [".bz2", "application/x-bzip2"],
+  [".7z", "application/x-7z-compressed"],
+  [".rar", "application/vnd.rar"],
+  // Binary / Application
+  [".pdf", "application/pdf"],
+  [".wasm", "application/wasm"],
+  [".exe", "application/x-msdownload"],
+  [".dll", "application/x-msdownload"],
+  [".so", "application/x-sharedlib"],
+  [".dylib", "application/x-sharedlib"]
+]);
+function getMimeType(filename) {
+  const dot = filename.lastIndexOf(".");
+  if (dot === -1) return "application/octet-stream";
+  const ext = filename.slice(dot).toLowerCase();
+  return mimeTypes.get(ext) ?? "application/octet-stream";
+}
+function getFileCategory(mime) {
+  if (mime.startsWith("text/") || mime === "application/json") return "text";
+  if (mime.startsWith("image/")) return "image";
+  if (mime.startsWith("video/")) return "video";
+  if (mime.startsWith("audio/")) return "audio";
+  if (mime === "application/zip" || mime === "application/x-tar" || mime === "application/gzip" || mime === "application/x-bzip2" || mime === "application/x-7z-compressed" || mime === "application/vnd.rar") {
+    return "archive";
+  }
+  return "binary";
+}
+function isBinaryMime(mime) {
+  return getFileCategory(mime) !== "text";
+}
+export {
+  getMimeType as g,
+  isBinaryMime as i
+};

package/dist/mkdir-CtDdaiaM.js

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

package/dist/mktemp-DwAY8Lz2.js

@@ -0,0 +1,44 @@
+import { p as parseArgs } from "./args-BhoL0JcG.js";
+import { r as resolve } from "./index-GLjTMF7C.js";
+const spec = {
+  directory: { type: "boolean", short: "d" },
+  tmpdir: { type: "string", short: "p" }
+};
+function randomChars(n) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < n; i++) {
+    result += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return result;
+}
+const command = async (ctx) => {
+  const { flags, positional } = parseArgs(ctx.args, spec);
+  const dir = flags.tmpdir || "/tmp";
+  const template = positional[0] || "tmp.XXXXXXXXXX";
+  const xMatch = template.match(/X+$/);
+  const xCount = xMatch ? xMatch[0].length : 0;
+  const name = xCount > 0 ? template.slice(0, -xCount) + randomChars(xCount) : template + "." + randomChars(10);
+  const fullPath = resolve(dir, name);
+  try {
+    try {
+      ctx.vfs.stat(dir);
+    } catch {
+      ctx.vfs.mkdir(dir, { recursive: true });
+    }
+    if (flags.directory) {
+      ctx.vfs.mkdir(fullPath);
+    } else {
+      ctx.vfs.writeFile(fullPath, "");
+    }
+    ctx.stdout.write(fullPath + "\n");
+    return 0;
+  } catch (e) {
+    ctx.stderr.write(`mktemp: failed to create ${flags.directory ? "directory" : "file"}: ${e.message}
+`);
+    return 1;
+  }
+};
+export {
+  command as default
+};

package/dist/mv-vS020rcy.js

@@ -0,0 +1,29 @@
+import { r as resolve, b as basename, V as VFSError } from "./index-GLjTMF7C.js";
+const command = async (ctx) => {
+  if (ctx.args.length < 2) {
+    ctx.stderr.write("mv: missing operand\n");
+    return 1;
+  }
+  const src = resolve(ctx.cwd, ctx.args[0]);
+  let dest = resolve(ctx.cwd, ctx.args[1]);
+  try {
+    if (ctx.vfs.exists(dest)) {
+      const stat = ctx.vfs.stat(dest);
+      if (stat.type === "directory") {
+        dest = resolve(dest, basename(src));
+      }
+    }
+    ctx.vfs.rename(src, dest);
+    return 0;
+  } catch (e) {
+    if (e instanceof VFSError) {
+      ctx.stderr.write(`mv: ${e.message}
+`);
+      return 1;
+    }
+    throw e;
+  }
+};
+export {
+  command as default
+};