@scelar/nodepod 1.0.0

package/src/shell/commands/yarn.ts

@@ -0,0 +1,84 @@
+import type { ShellCommand } from "../shell-types";
+import type { PmDeps } from "./pm-types";
+import { VERSIONS } from "../../constants/config";
+
+const A_RESET = "\x1b[0m";
+const A_BOLD = "\x1b[1m";
+const A_CYAN = "\x1b[36m";
+
+export function createYarnCommand(deps: PmDeps): ShellCommand {
+  return {
+    name: "yarn",
+    async execute(params, ctx) {
+      if (!deps.hasFile("/"))
+        return { stdout: "", stderr: "Volume unavailable\n", exitCode: 1 };
+
+      const sub = params[0];
+      if (!sub) return deps.installPackages([], ctx, "yarn");
+      if (sub === "help" || sub === "--help") {
+        return {
+          stdout:
+            `${A_BOLD}Usage:${A_RESET} yarn <command>\n\n` +
+            `${A_BOLD}Commands:${A_RESET}\n` +
+            `  ${A_CYAN}add${A_RESET} [pkg]         Install packages\n` +
+            `  ${A_CYAN}install${A_RESET}           Install from manifest\n` +
+            `  ${A_CYAN}remove${A_RESET} <pkg>      Remove a package\n` +
+            `  ${A_CYAN}list${A_RESET}              List installed packages\n` +
+            `  ${A_CYAN}run${A_RESET} <script>      Run a script\n` +
+            `  ${A_CYAN}dlx${A_RESET} <pkg>         Download and execute a package\n` +
+            `  ${A_CYAN}init${A_RESET}              Create a package.json\n` +
+            `  ${A_CYAN}create${A_RESET} <pkg>      Create a project\n` +
+            `  ${A_CYAN}version${A_RESET}           Show version info\n`,
+          stderr: "",
+          exitCode: 0,
+        };
+      }
+
+      switch (sub) {
+        case "add":
+          return deps.installPackages(params.slice(1), ctx, "yarn");
+        case "install":
+        case "i":
+          return deps.installPackages(params.slice(1), ctx, "yarn");
+        case "remove":
+        case "rm":
+        case "uninstall":
+          return deps.uninstallPackages(params.slice(1), ctx, "yarn");
+        case "list":
+        case "ls":
+          return deps.listPackages(ctx, "yarn");
+        case "run":
+          return deps.runScript(params.slice(1), ctx);
+        case "start":
+          return deps.runScript(["start"], ctx);
+        case "test":
+        case "t":
+          return deps.runScript(["test"], ctx);
+        case "exec":
+          return deps.npxExecute(params.slice(1), ctx);
+        case "dlx":
+          return deps.npxExecute(params.slice(1), ctx);
+        case "init":
+        case "create":
+          return deps.npmInitOrCreate(params.slice(1), sub, ctx);
+        case "version":
+        case "-v":
+        case "--version":
+          return { stdout: VERSIONS.YARN + "\n", stderr: "", exitCode: 0 };
+        case "info":
+          return deps.npmInfo(params.slice(1), ctx);
+        case "audit":
+          return { stdout: "0 vulnerabilities found\n", stderr: "", exitCode: 0 };
+        case "outdated":
+          return { stdout: "", stderr: "", exitCode: 0 };
+        case "why":
+          return { stdout: "", stderr: deps.formatWarn("why: not available in nodepod", "yarn"), exitCode: 0 };
+        case "global":
+          return { stdout: "", stderr: deps.formatWarn("global: not available in nodepod", "yarn"), exitCode: 0 };
+        default:
+          // yarn classic treats unknown commands as `yarn run <cmd>`
+          return deps.runScript(params, ctx);
+      }
+    },
+  };
+}

package/src/shell/shell-builtins.ts

@@ -0,0 +1,19 @@
+// Assembles all builtin commands from category modules into one map.
+
+import type { BuiltinFn } from "./shell-types";
+import { fileOpsCommands } from "./commands/file-ops";
+import { directoryCommands } from "./commands/directory";
+import { textProcessingCommands } from "./commands/text-processing";
+import { searchCommands } from "./commands/search";
+import { shellEnvCommands, setBuiltinsRef } from "./commands/shell-env";
+
+export const builtins = new Map<string, BuiltinFn>([
+  ...fileOpsCommands,
+  ...directoryCommands,
+  ...textProcessingCommands,
+  ...searchCommands,
+  ...shellEnvCommands,
+]);
+
+// shell-env needs the builtins ref for `which` and `type`
+setBuiltinsRef(builtins);

package/src/shell/shell-helpers.ts

@@ -0,0 +1,250 @@
+// Shared utilities for shell builtins: colors, arg parsing, path helpers, result builders.
+
+import type { ShellResult } from "./shell-types";
+import * as pathModule from "../polyfills/path";
+
+/* ------------------------------------------------------------------ */
+/*  ANSI color helpers                                                 */
+/* ------------------------------------------------------------------ */
+
+export const RESET = "\x1b[0m";
+export const DIM = "\x1b[2m";
+export const GREEN = "\x1b[32m";
+export const MAGENTA = "\x1b[35m";
+export const CYAN = "\x1b[36m";
+export const BOLD_BLUE = "\x1b[1;34m";
+export const BOLD_RED = "\x1b[1;31m";
+
+/* ------------------------------------------------------------------ */
+/*  ShellResult builders                                               */
+/* ------------------------------------------------------------------ */
+
+export const ok = (stdout = ""): ShellResult => ({
+  stdout,
+  stderr: "",
+  exitCode: 0,
+});
+
+export const fail = (stderr: string, code = 1): ShellResult => ({
+  stdout: "",
+  stderr,
+  exitCode: code,
+});
+
+export const EXIT_OK: ShellResult = { stdout: "", stderr: "", exitCode: 0 };
+export const EXIT_FAIL: ShellResult = { stdout: "", stderr: "", exitCode: 1 };
+
+/* ------------------------------------------------------------------ */
+/*  Date / time constants                                              */
+/* ------------------------------------------------------------------ */
+
+export const MONTHS_SHORT = [
+  "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+] as const;
+
+export const MONTHS_LONG = [
+  "January", "February", "March", "April", "May", "June",
+  "July", "August", "September", "October", "November", "December",
+] as const;
+
+export const DAYS_SHORT = [
+  "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat",
+] as const;
+
+export const DAYS_LONG = [
+  "Sunday", "Monday", "Tuesday", "Wednesday",
+  "Thursday", "Friday", "Saturday",
+] as const;
+
+/* ------------------------------------------------------------------ */
+/*  Path resolution                                                    */
+/* ------------------------------------------------------------------ */
+
+export function resolvePath(p: string, cwd: string): string {
+  if (p.startsWith("/")) return pathModule.normalize(p);
+  return pathModule.normalize(`${cwd}/${p}`);
+}
+
+export { pathModule };
+
+/* ------------------------------------------------------------------ */
+/*  Argument parsing                                                   */
+/* ------------------------------------------------------------------ */
+
+export function parseArgs(
+  args: string[],
+  knownFlags: string[],
+  knownOpts: string[] = [],
+): { flags: Set<string>; opts: Record<string, string>; positional: string[] } {
+  const flags = new Set<string>();
+  const opts: Record<string, string> = {};
+  const positional: string[] = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--") {
+      positional.push(...args.slice(i + 1));
+      break;
+    }
+    if (a.startsWith("--")) {
+      const eq = a.indexOf("=");
+      if (eq > 0) {
+        opts[a.slice(2, eq)] = a.slice(eq + 1);
+      } else {
+        flags.add(a.slice(2));
+      }
+    } else if (a.startsWith("-") && a.length > 1 && !/^-\d/.test(a)) {
+      for (let j = 1; j < a.length; j++) {
+        const ch = a[j];
+        if (knownOpts.includes(ch) && j + 1 < a.length) {
+          opts[ch] = a.slice(j + 1);
+          break;
+        } else if (knownOpts.includes(ch) && i + 1 < args.length) {
+          opts[ch] = args[++i];
+          break;
+        } else if (knownFlags.includes(ch)) {
+          flags.add(ch);
+        }
+      }
+    } else {
+      positional.push(a);
+    }
+  }
+  return { flags, opts, positional };
+}
+
+/* ------------------------------------------------------------------ */
+/*  String processing                                                  */
+/* ------------------------------------------------------------------ */
+
+// Expand POSIX character classes like [:upper:], [:lower:], etc. for `tr`
+export function expandCharClass(s: string): string {
+  return s
+    .replace(/\[:upper:\]/g, "ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+    .replace(/\[:lower:\]/g, "abcdefghijklmnopqrstuvwxyz")
+    .replace(
+      /\[:alpha:\]/g,
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+    )
+    .replace(/\[:digit:\]/g, "0123456789")
+    .replace(
+      /\[:alnum:\]/g,
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
+    )
+    .replace(/\[:space:\]/g, " \t\n\r\x0b\x0c")
+    .replace(/\[:blank:\]/g, " \t")
+    .replace(/\[:punct:\]/g, "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~")
+    .replace(
+      /\[:print:\]/g,
+      (() => {
+        let r = "";
+        for (let i = 32; i < 127; i++) r += String.fromCharCode(i);
+        return r;
+      })(),
+    )
+    .replace(
+      /\[:graph:\]/g,
+      (() => {
+        let r = "";
+        for (let i = 33; i < 127; i++) r += String.fromCharCode(i);
+        return r;
+      })(),
+    )
+    .replace(
+      /\[:cntrl:\]/g,
+      (() => {
+        let r = "";
+        for (let i = 0; i < 32; i++) r += String.fromCharCode(i);
+        r += String.fromCharCode(127);
+        return r;
+      })(),
+    );
+}
+
+export function processEscapes(s: string): string {
+  let out = "";
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === "\\" && i + 1 < s.length) {
+      const c = s[i + 1];
+      if (c === "n") {
+        out += "\n";
+        i++;
+        continue;
+      }
+      if (c === "t") {
+        out += "\t";
+        i++;
+        continue;
+      }
+      if (c === "r") {
+        out += "\r";
+        i++;
+        continue;
+      }
+      if (c === "a") {
+        out += "\x07";
+        i++;
+        continue;
+      }
+      if (c === "b") {
+        out += "\b";
+        i++;
+        continue;
+      }
+      if (c === "f") {
+        out += "\f";
+        i++;
+        continue;
+      }
+      if (c === "v") {
+        out += "\x0b";
+        i++;
+        continue;
+      }
+      if (c === "\\") {
+        out += "\\";
+        i++;
+        continue;
+      }
+      if (c === "0") {
+        let oct = "";
+        let j = i + 2;
+        while (j < s.length && j < i + 5 && s[j] >= "0" && s[j] <= "7")
+          oct += s[j++];
+        out += String.fromCharCode(parseInt(oct || "0", 8));
+        i = j - 1;
+        continue;
+      }
+      if (c === "x") {
+        const hex = s.slice(i + 2, i + 4);
+        if (/^[0-9a-fA-F]{1,2}$/.test(hex)) {
+          out += String.fromCharCode(parseInt(hex, 16));
+          i += 1 + hex.length;
+          continue;
+        }
+      }
+      out += s[i];
+    } else {
+      out += s[i];
+    }
+  }
+  return out;
+}
+
+export function humanSize(bytes: number): string {
+  if (bytes < 1024) return String(bytes);
+  const units = ["K", "M", "G", "T"];
+  let size = bytes;
+  for (const u of units) {
+    size /= 1024;
+    if (size < 1024 || u === "T") return size.toFixed(size < 10 ? 1 : 0) + u;
+  }
+  return String(bytes);
+}
+
+export function globToRegex(pattern: string): string {
+  return pattern
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\*/g, ".*")
+    .replace(/\?/g, ".");
+}