Simplify RuntimeContext: make runCommand required, remove IPyodideContext, refactor useWandbox with curried functions

Co-authored-by: na-trium-144 <100704180+na-trium-144@users.noreply.github.com>

Author: Copilot

app/terminal/python/pyodide.tsx

@@ -14,15 +14,9 @@ import { Mutex, MutexInterface } from "async-mutex";
 import { useEmbedContext } from "../embedContext";
 import { RuntimeContext } from "../runtime";
 
-interface IPyodideContext extends RuntimeContext {
-  runPython: (code: string) => Promise<ReplOutput[]>;
-  runCommand: (command: string) => Promise<ReplOutput[]>; // Alias for runPython for consistency
-  runFile: (name: string) => Promise<ReplOutput[]>;
-}
-
-const PyodideContext = createContext<IPyodideContext>(null!);
+const PyodideContext = createContext<RuntimeContext>(null!);
 
-export function usePyodide() {
+export function usePyodide(): RuntimeContext {
   const context = useContext(PyodideContext);
   if (!context) {
     throw new Error("usePyodide must be used within a PyodideProvider");
@@ -125,10 +119,10 @@ export function PyodideProvider({ children }: { children: ReactNode }) {
     }
   }, []);
 
-  const runPython = useCallback(
+  const runCommand = useCallback(
     async (code: string): Promise<ReplOutput[]> => {
       if (!mutex.current.isLocked()) {
-        throw new Error("mutex of PyodideContext must be locked for runPython");
+        throw new Error("mutex of PyodideContext must be locked for runCommand");
       }
       if (!workerRef.current || !ready) {
         return [{ type: "error", message: "Pyodide is not ready yet." }];
@@ -150,29 +144,6 @@ export function PyodideProvider({ children }: { children: ReactNode }) {
     [ready, writeFile]
   );
 
-  const runFile = useCallback(
-    async (name: string): Promise<ReplOutput[]> => {
-      if (!workerRef.current || !ready) {
-        return [{ type: "error", message: "Pyodide is not ready yet." }];
-      }
-      if (interruptBuffer.current) {
-        interruptBuffer.current[0] = 0;
-      }
-      return mutex.current.runExclusive(async () => {
-        const { output, updatedFiles } =
-          await postMessage<RunPayloadFromWorker>({
-            type: "runFile",
-            payload: { name, files },
-          });
-        for (const [newName, content] of updatedFiles) {
-          writeFile(newName, content);
-        }
-        return output;
-      });
-    },
-    [files, ready, writeFile]
-  );
-
   const checkSyntax = useCallback(
     async (code: string): Promise<SyntaxStatus> => {
       if (!workerRef.current || !ready) return "invalid";
@@ -197,9 +168,26 @@ export function PyodideProvider({ children }: { children: ReactNode }) {
           },
         ];
       }
-      return runFile(filenames[0]);
+      // Incorporate runFile logic directly
+      if (!workerRef.current || !ready) {
+        return [{ type: "error", message: "Pyodide is not ready yet." }];
+      }
+      if (interruptBuffer.current) {
+        interruptBuffer.current[0] = 0;
+      }
+      return mutex.current.runExclusive(async () => {
+        const { output, updatedFiles } =
+          await postMessage<RunPayloadFromWorker>({
+            type: "runFile",
+            payload: { name: filenames[0], files },
+          });
+        for (const [newName, content] of updatedFiles) {
+          writeFile(newName, content);
+        }
+        return output;
+      });
     },
-    [runFile]
+    [files, ready, writeFile]
   );
 
   const splitContents = useCallback((content: string): ReplCommand[] => {
@@ -231,11 +219,9 @@ export function PyodideProvider({ children }: { children: ReactNode }) {
         init,
         initializing,
         ready,
-        runPython,
-        runCommand: runPython, // Alias for consistency with RuntimeContext
+        runCommand,
         checkSyntax,
         mutex: mutex.current,
-        runFile,
         runFiles,
         interrupt,
         splitContents,

app/terminal/runtime.ts

@@ -12,7 +12,7 @@ export interface RuntimeContext {
   ready: boolean;
   mutex: MutexInterface;
   runFiles: (filenames: string[]) => Promise<ReplOutput[]>;
-  runCommand?: (command: string) => Promise<ReplOutput[]>; // For REPL command execution
+  runCommand: (command: string) => Promise<ReplOutput[]>; // For REPL command execution
   checkSyntax?: (code: string) => Promise<SyntaxStatus>;
   interrupt?: () => void;
   splitContents?: (content: string) => ReplCommand[];
@@ -28,7 +28,7 @@ export interface RuntimeContext {
  */
 export function useRuntime(language: string): RuntimeContext {
   const pyodide = usePyodide();
-  const wandbox = useWandbox();
+  const wandbox = useWandbox("C++");
 
   switch (language) {
     case "python":

app/terminal/wandbox/wandbox.tsx

@@ -10,18 +10,35 @@ import { MutexInterface } from "async-mutex";
 
 type WandboxLang = "C++";
 
-interface IWandboxContext extends RuntimeContext {
-  // 表示用のコマンドライン文字列を取得 (language-specific version)
-  getCommandlineStrWithLang: (lang: WandboxLang, filenames: string[]) => string;
+interface IWandboxContext {
+  init: () => Promise<void>;
+  initializing: boolean;
+  ready: boolean;
+  mutex: MutexInterface;
+  runFilesWithLang: (lang: WandboxLang) => (filenames: string[]) => Promise<ReturnType<typeof cppRunFiles>>;
+  getCommandlineStrWithLang: (lang: WandboxLang) => (filenames: string[]) => string;
 }
 
 const WandboxContext = createContext<IWandboxContext>(null!);
-export function useWandbox() {
+
+export function useWandbox(lang: WandboxLang = "C++"): RuntimeContext {
   const context = useContext(WandboxContext);
   if (!context) {
     throw new Error("useWandbox must be used within a WandboxProvider");
   }
-  return context;
+  
+  return {
+    init: context.init,
+    initializing: context.initializing,
+    ready: context.ready,
+    mutex: context.mutex,
+    runFiles: context.runFilesWithLang(lang),
+    runCommand: async () => {
+      // Wandbox doesn't support REPL, so return error
+      return [{ type: "error" as const, message: "REPL not supported for this language" }];
+    },
+    getCommandlineStr: context.getCommandlineStrWithLang(lang),
+  };
 }
 
 export function WandboxProvider({ children }: { children: ReactNode }) {
@@ -33,8 +50,9 @@ export function WandboxProvider({ children }: { children: ReactNode }) {
 
   const ready = !!compilerList;
 
-  const getCommandlineStr = useCallback(
-    (lang: WandboxLang, filenames: string[]) => {
+  // Curried function for language-specific commandline string generation
+  const getCommandlineStrWithLang = useCallback(
+    (lang: WandboxLang) => (filenames: string[]) => {
       if (compilerList) {
         switch (lang) {
           case "C++":
@@ -50,14 +68,9 @@ export function WandboxProvider({ children }: { children: ReactNode }) {
     [compilerList]
   );
 
-  // Wrapper for RuntimeContext compatibility
-  const getCommandlineStrSimple = useCallback(
-    (filenames: string[]) => getCommandlineStr("C++", filenames),
-    [getCommandlineStr]
-  );
-
+  // Curried function for language-specific file execution
   const runFilesWithLang = useCallback(
-    async (lang: WandboxLang, filenames: string[]) => {
+    (lang: WandboxLang) => async (filenames: string[]) => {
       if (!compilerList) {
         return [
           { type: "error" as const, message: "Wandbox is not ready yet." },
@@ -80,13 +93,6 @@ export function WandboxProvider({ children }: { children: ReactNode }) {
     [compilerList, files]
   );
 
-  const runFiles = useCallback(
-    async (filenames: string[]) => {
-      return runFilesWithLang("C++", filenames);
-    },
-    [runFilesWithLang]
-  );
-
   const init = useCallback(async () => {
     // Wandbox doesn't need initialization
   }, []);
@@ -114,9 +120,8 @@ export function WandboxProvider({ children }: { children: ReactNode }) {
         initializing: false,
         ready,
         mutex,
-        runFiles,
-        getCommandlineStr: getCommandlineStrSimple, // RuntimeContext compatible version
-        getCommandlineStrWithLang: getCommandlineStr, // Language-specific version
+        runFilesWithLang,
+        getCommandlineStrWithLang,
       }}
     >
       {children}