sandlot 0.1.3 → 0.2.0

package/src/commands/compile.ts

@@ -1,236 +0,0 @@
-/**
- * Compile-related commands: tsc and build
- */
-
-import { defineCommand, type CommandContext } from "just-bash/browser";
-import { typecheck, formatDiagnosticsForAgent, type TypecheckResult } from "../typechecker";
-import { bundle } from "../bundler";
-import { loadModule } from "../loader";
-import { type CommandDeps, formatEsbuildMessages } from "./types";
-
-/**
- * Create the `tsc` command for type checking
- */
-export function createTscCommand(deps: CommandDeps) {
-  const { fs, libFiles, tsconfigPath } = deps;
-
-  return defineCommand("tsc", async (args, _ctx: CommandContext) => {
-    const entryPoint = args[0];
-    if (!entryPoint) {
-      return {
-        stdout: "",
-        stderr: `Usage: tsc <entry-point>\n\nExample: tsc /src/index.ts\n`,
-        exitCode: 1,
-      };
-    }
-
-    try {
-      // Check if entry point exists
-      if (!(await fs.exists(entryPoint))) {
-        return {
-          stdout: "",
-          stderr: `Error: Entry point not found: ${entryPoint}\n`,
-          exitCode: 1,
-        };
-      }
-
-      const result = await typecheck({
-        fs,
-        entryPoint,
-        tsconfigPath,
-        libFiles,
-      });
-
-      if (result.hasErrors) {
-        const formatted = formatDiagnosticsForAgent(result.diagnostics);
-        return {
-          stdout: "",
-          stderr: formatted + "\n",
-          exitCode: 1,
-        };
-      }
-
-      const checkedCount = result.checkedFiles.length;
-      const warningCount = result.diagnostics.filter((d) => d.category === "warning").length;
-
-      let output = `Type check passed. Checked ${checkedCount} file(s).\n`;
-      if (warningCount > 0) {
-        output += `\nWarnings:\n${formatDiagnosticsForAgent(result.diagnostics.filter((d) => d.category === "warning"))}\n`;
-      }
-
-      return {
-        stdout: output,
-        stderr: "",
-        exitCode: 0,
-      };
-    } catch (err) {
-      return {
-        stdout: "",
-        stderr: `Type check failed: ${err instanceof Error ? err.message : String(err)}\n`,
-        exitCode: 1,
-      };
-    }
-  });
-}
-
-/**
- * Create the `build` command for bundling (with automatic type checking)
- */
-export function createBuildCommand(deps: CommandDeps) {
-  const { fs, libFiles, tsconfigPath, onBuild, getValidation, sharedModules } = deps;
-
-  return defineCommand("build", async (args, _ctx: CommandContext) => {
-    // Parse arguments
-    let entryPoint: string | null = null;
-    let skipTypecheck = false;
-    let minify = false;
-    let format: "esm" | "iife" | "cjs" = "esm";
-
-    for (let i = 0; i < args.length; i++) {
-      const arg = args[i];
-      if (arg === "--skip-typecheck" || arg === "-s") {
-        skipTypecheck = true;
-      } else if (arg === "--minify" || arg === "-m") {
-        minify = true;
-      } else if ((arg === "--format" || arg === "-f") && args[i + 1]) {
-        const f = args[++i]!.toLowerCase();
-        if (f === "esm" || f === "iife" || f === "cjs") {
-          format = f;
-        }
-      } else if (!arg!.startsWith("-")) {
-        entryPoint = arg!;
-      }
-    }
-
-    // Entry point is required
-    if (!entryPoint) {
-      return {
-        stdout: "",
-        stderr: `Usage: build <entry-point> [options]\n\nOptions:\n  --skip-typecheck, -s  Skip type checking\n  --minify, -m          Minify output\n  --format, -f <fmt>    Output format (esm|iife|cjs)\n\nExample: build /src/index.ts\n`,
-        exitCode: 1,
-      };
-    }
-
-    try {
-      // Check if entry point exists
-      if (!(await fs.exists(entryPoint))) {
-        return {
-          stdout: "",
-          stderr: `Error: Entry point not found: ${entryPoint}\n`,
-          exitCode: 1,
-        };
-      }
-
-      // Step 1: Type check (unless skipped)
-      let typecheckResult: TypecheckResult | null = null;
-      if (!skipTypecheck) {
-        typecheckResult = await typecheck({
-          fs,
-          entryPoint,
-          tsconfigPath,
-          libFiles,
-        });
-
-        if (typecheckResult.hasErrors) {
-          const formatted = formatDiagnosticsForAgent(typecheckResult.diagnostics);
-          return {
-            stdout: "",
-            stderr: `Build failed: Type errors found.\n\n${formatted}\n`,
-            exitCode: 1,
-          };
-        }
-      }
-
-      // Step 2: Bundle
-      const bundleResult = await bundle({
-        fs,
-        entryPoint,
-        format,
-        minify,
-        sharedModules,
-      });
-
-      // Step 3: Load module
-      let loadedModule: Record<string, unknown>;
-      try {
-        loadedModule = await loadModule<Record<string, unknown>>(bundleResult);
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        return {
-          stdout: "",
-          stderr: `Build failed: Module failed to load.\n\n${errorMessage}\n`,
-          exitCode: 1,
-        };
-      }
-
-      // Step 4: Validate (if validation function is set)
-      const validateFn = getValidation?.();
-      let validatedModule = loadedModule;
-
-      if (validateFn) {
-        try {
-          validatedModule = validateFn(loadedModule);
-        } catch (err) {
-          const errorMessage = err instanceof Error ? err.message : String(err);
-          return {
-            stdout: "",
-            stderr: `Build failed: Validation error.\n\n${errorMessage}\n`,
-            exitCode: 1,
-          };
-        }
-      }
-
-      // Invoke callback with build output (bundle + validated module)
-      if (onBuild) {
-        await onBuild({ bundle: bundleResult, module: validatedModule });
-      }
-
-      // Build success message
-      let output = `Build successful!\n`;
-      output += `Entry: ${entryPoint}\n`;
-      output += `Format: ${format}\n`;
-      output += `Size: ${(bundleResult.code.length / 1024).toFixed(2)} KB\n`;
-
-      if (typecheckResult) {
-        output += `Type checked: ${typecheckResult.checkedFiles.length} file(s)\n`;
-      }
-
-      output += `Bundled: ${bundleResult.includedFiles.length} file(s)\n`;
-
-      // Show exports for visibility
-      const exportNames = Object.keys(loadedModule).filter((k) => !k.startsWith("__"));
-      if (exportNames.length > 0) {
-        output += `Exports: ${exportNames.join(", ")}\n`;
-      }
-
-      if (validateFn) {
-        output += `Validation: passed\n`;
-      }
-
-      // Include warnings if any
-      if (bundleResult.warnings.length > 0) {
-        output += `\nBuild warnings:\n${formatEsbuildMessages(bundleResult.warnings)}\n`;
-      }
-
-      if (typecheckResult) {
-        const warnings = typecheckResult.diagnostics.filter((d) => d.category === "warning");
-        if (warnings.length > 0) {
-          output += `\nType warnings:\n${formatDiagnosticsForAgent(warnings)}\n`;
-        }
-      }
-
-      return {
-        stdout: output,
-        stderr: "",
-        exitCode: 0,
-      };
-    } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      return {
-        stdout: "",
-        stderr: `Build failed: ${errorMessage}\n`,
-        exitCode: 1,
-      };
-    }
-  });
-}

package/src/commands/packages.ts

@@ -1,154 +0,0 @@
-/**
- * Package management commands: install, uninstall, list
- */
-
-import { defineCommand, type CommandContext } from "just-bash/browser";
-import { installPackage, uninstallPackage, listPackages } from "../packages";
-import type { CommandDeps } from "./types";
-
-/**
- * Create the `install` command for adding packages from npm
- */
-export function createInstallCommand(deps: CommandDeps) {
-  const { fs, typesCache } = deps;
-
-  return defineCommand("install", async (args, _ctx: CommandContext) => {
-    if (args.length === 0) {
-      return {
-        stdout: "",
-        stderr: "Usage: install <package>[@version] [...packages]\n\nExamples:\n  install react\n  install lodash@4.17.21\n  install @tanstack/react-query@5\n",
-        exitCode: 1,
-      };
-    }
-
-    const results: string[] = [];
-    let hasError = false;
-
-    for (const packageSpec of args) {
-      try {
-        const result = await installPackage(fs, packageSpec!, { cache: typesCache });
-
-        let status = `+ ${result.name}@${result.version}`;
-        if (result.typesInstalled) {
-          status += ` (${result.typeFilesCount} type file${result.typeFilesCount !== 1 ? "s" : ""})`;
-          if (result.fromCache) {
-            status += " [cached]";
-          }
-        } else if (result.typesError) {
-          status += ` (no types: ${result.typesError})`;
-        }
-        results.push(status);
-      } catch (err) {
-        hasError = true;
-        const message = err instanceof Error ? err.message : String(err);
-        results.push(`x ${packageSpec}: ${message}`);
-      }
-    }
-
-    const output = results.join("\n") + "\n";
-
-    if (hasError) {
-      return {
-        stdout: "",
-        stderr: output,
-        exitCode: 1,
-      };
-    }
-
-    return {
-      stdout: output,
-      stderr: "",
-      exitCode: 0,
-    };
-  });
-}
-
-/**
- * Create the `uninstall` command for removing packages
- */
-export function createUninstallCommand(deps: CommandDeps) {
-  const { fs } = deps;
-
-  return defineCommand("uninstall", async (args, _ctx: CommandContext) => {
-    if (args.length === 0) {
-      return {
-        stdout: "",
-        stderr: "Usage: uninstall <package> [...packages]\n",
-        exitCode: 1,
-      };
-    }
-
-    const results: string[] = [];
-    let hasError = false;
-
-    for (const packageName of args) {
-      try {
-        const removed = await uninstallPackage(fs, packageName!);
-        if (removed) {
-          results.push(`- ${packageName}`);
-        } else {
-          results.push(`x ${packageName}: not installed`);
-          hasError = true;
-        }
-      } catch (err) {
-        hasError = true;
-        const message = err instanceof Error ? err.message : String(err);
-        results.push(`x ${packageName}: ${message}`);
-      }
-    }
-
-    const output = results.join("\n") + "\n";
-
-    if (hasError) {
-      return {
-        stdout: "",
-        stderr: output,
-        exitCode: 1,
-      };
-    }
-
-    return {
-      stdout: output,
-      stderr: "",
-      exitCode: 0,
-    };
-  });
-}
-
-/**
- * Create the `list` command (alias: `ls`) for showing installed packages
- */
-export function createListCommand(deps: CommandDeps) {
-  const { fs } = deps;
-
-  return defineCommand("list", async (_args, _ctx: CommandContext) => {
-    try {
-      const packages = await listPackages(fs);
-
-      if (packages.length === 0) {
-        return {
-          stdout: "No packages installed.\n",
-          stderr: "",
-          exitCode: 0,
-        };
-      }
-
-      const output = packages
-        .map((pkg) => `${pkg.name}@${pkg.version}`)
-        .join("\n") + "\n";
-
-      return {
-        stdout: output,
-        stderr: "",
-        exitCode: 0,
-      };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return {
-        stdout: "",
-        stderr: `Failed to list packages: ${message}\n`,
-        exitCode: 1,
-      };
-    }
-  });
-}

package/src/commands/run.ts

@@ -1,245 +0,0 @@
-/**
- * Run command for executing code in the sandbox.
- */
-
-import { defineCommand, type CommandContext } from "just-bash/browser";
-import { typecheck, formatDiagnosticsForAgent } from "../typechecker";
-import { bundle } from "../bundler";
-import { loadModule } from "../loader";
-import type { CommandDeps, RunContext } from "./types";
-
-/**
- * Create the `run` command for executing code in the sandbox.
- *
- * The run command:
- * 1. Builds the entry point (with type checking by default)
- * 2. Dynamically imports the bundle
- * 3. If a `main` export exists, calls it with a RunContext
- * 4. Captures all console output (log, warn, error)
- * 5. Returns the captured output and any return value from main()
- *
- * Usage:
- *   run [entry] [--skip-typecheck|-s] [--timeout|-t <ms>] [-- args...]
- *
- * Code can be written in two styles:
- *
- * 1. Script style (top-level code, runs on import):
- *    ```ts
- *    console.log("Hello from script!");
- *    const result = 2 + 2;
- *    console.log("Result:", result);
- *    ```
- *
- * 2. Main function style (with context access):
- *    ```ts
- *    import type { RunContext } from "sandlot";
- *
- *    export async function main(ctx: RunContext) {
- *      ctx.log("Reading file...");
- *      const content = await ctx.fs.readFile("/data/input.txt");
- *      ctx.log("Content:", content);
- *      return { success: true };
- *    }
- *    ```
- */
-export function createRunCommand(deps: CommandDeps) {
-  const { fs, libFiles, tsconfigPath, runOptions = {}, sharedModules } = deps;
-
-  return defineCommand("run", async (args, _ctx: CommandContext) => {
-    // Parse arguments
-    let entryPoint: string | null = null;
-    let skipTypecheck = runOptions.skipTypecheck ?? false;
-    let timeout = runOptions.timeout ?? 30000;
-    const scriptArgs: string[] = [];
-    let collectingArgs = false;
-
-    for (let i = 0; i < args.length; i++) {
-      const arg = args[i];
-
-      if (collectingArgs) {
-        scriptArgs.push(arg!);
-        continue;
-      }
-
-      if (arg === "--") {
-        collectingArgs = true;
-      } else if (arg === "--skip-typecheck" || arg === "-s") {
-        skipTypecheck = true;
-      } else if ((arg === "--timeout" || arg === "-t") && args[i + 1]) {
-        timeout = parseInt(args[++i]!, 10);
-        if (isNaN(timeout)) timeout = 30000;
-      } else if (!arg!.startsWith("-")) {
-        entryPoint = arg!;
-      }
-    }
-
-    // Entry point is required
-    if (!entryPoint) {
-      return {
-        stdout: "",
-        stderr: `Usage: run <entry-point> [options] [-- args...]\n\nOptions:\n  --skip-typecheck, -s  Skip type checking\n  --timeout, -t <ms>    Execution timeout (default: 30000)\n\nExample: run /src/index.ts\n`,
-        exitCode: 1,
-      };
-    }
-
-    // Capture console output
-    const logs: string[] = [];
-    const originalConsole = {
-      log: console.log,
-      warn: console.warn,
-      error: console.error,
-      info: console.info,
-      debug: console.debug,
-    };
-
-    const formatArgs = (...a: unknown[]) =>
-      a.map((v) => (typeof v === "object" ? JSON.stringify(v) : String(v))).join(" ");
-
-    const captureLog = (...a: unknown[]) => {
-      logs.push(formatArgs(...a));
-      originalConsole.log.apply(console, a);
-    };
-    const captureWarn = (...a: unknown[]) => {
-      logs.push(`[warn] ${formatArgs(...a)}`);
-      originalConsole.warn.apply(console, a);
-    };
-    const captureError = (...a: unknown[]) => {
-      logs.push(`[error] ${formatArgs(...a)}`);
-      originalConsole.error.apply(console, a);
-    };
-    const captureInfo = (...a: unknown[]) => {
-      logs.push(`[info] ${formatArgs(...a)}`);
-      originalConsole.info.apply(console, a);
-    };
-    const captureDebug = (...a: unknown[]) => {
-      logs.push(`[debug] ${formatArgs(...a)}`);
-      originalConsole.debug.apply(console, a);
-    };
-
-    const restoreConsole = () => {
-      console.log = originalConsole.log;
-      console.warn = originalConsole.warn;
-      console.error = originalConsole.error;
-      console.info = originalConsole.info;
-      console.debug = originalConsole.debug;
-    };
-
-    try {
-      // Check if entry point exists
-      if (!(await fs.exists(entryPoint))) {
-        return {
-          stdout: "",
-          stderr: `Error: Entry point not found: ${entryPoint}\n`,
-          exitCode: 1,
-        };
-      }
-
-      // Type check (unless skipped)
-      if (!skipTypecheck) {
-        const typecheckResult = await typecheck({
-          fs,
-          entryPoint,
-          tsconfigPath,
-          libFiles,
-        });
-
-        if (typecheckResult.hasErrors) {
-          const formatted = formatDiagnosticsForAgent(typecheckResult.diagnostics);
-          return {
-            stdout: "",
-            stderr: `Type errors:\n${formatted}\n`,
-            exitCode: 1,
-          };
-        }
-      }
-
-      // Bundle the code
-      const bundleResult = await bundle({
-        fs,
-        entryPoint,
-        format: "esm",
-        sharedModules,
-      });
-
-      // Install console interceptors
-      console.log = captureLog;
-      console.warn = captureWarn;
-      console.error = captureError;
-      console.info = captureInfo;
-      console.debug = captureDebug;
-
-      // Create the run context
-      const context: RunContext = {
-        fs,
-        env: { ...runOptions.env },
-        args: scriptArgs,
-        log: captureLog,
-        error: captureError,
-      };
-
-      // Execute the code with optional timeout
-      const startTime = performance.now();
-      let returnValue: unknown;
-
-      const executeCode = async () => {
-        // Load the module (this executes top-level code)
-        const module = await loadModule<{ main?: (ctx: RunContext) => unknown }>(bundleResult);
-
-        // If there's a main export, call it with context
-        if (typeof module.main === "function") {
-          returnValue = await module.main(context);
-        }
-      };
-
-      if (timeout > 0) {
-        const timeoutPromise = new Promise<never>((_, reject) => {
-          setTimeout(() => reject(new Error(`Execution timed out after ${timeout}ms`)), timeout);
-        });
-        await Promise.race([executeCode(), timeoutPromise]);
-      } else {
-        await executeCode();
-      }
-
-      const executionTimeMs = performance.now() - startTime;
-
-      // Restore console before building output
-      restoreConsole();
-
-      // Build output
-      let output = "";
-      if (logs.length > 0) {
-        output = logs.join("\n") + "\n";
-      }
-      if (returnValue !== undefined) {
-        const returnStr =
-          typeof returnValue === "object"
-            ? JSON.stringify(returnValue, null, 2)
-            : String(returnValue);
-        output += `[return] ${returnStr}\n`;
-      }
-      output += `\nExecution completed in ${executionTimeMs.toFixed(2)}ms\n`;
-
-      return {
-        stdout: output,
-        stderr: "",
-        exitCode: 0,
-      };
-    } catch (err) {
-      restoreConsole();
-
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      const errorStack = err instanceof Error && err.stack ? `\n${err.stack}` : "";
-
-      let output = "";
-      if (logs.length > 0) {
-        output = logs.join("\n") + "\n\n";
-      }
-
-      return {
-        stdout: output,
-        stderr: `Runtime error: ${errorMessage}${errorStack}\n`,
-        exitCode: 1,
-      };
-    }
-  });
-}