commit initial 09-12-2025 40

src/App.js

@@ -1,4 +1,4 @@
-// App.js (complete updated file)
+// src/App.js
 import { useState, useEffect, useRef } from "react";
 import Editor from "@monaco-editor/react";
 import { askAgent } from "./agent/assistant";
@@ -18,7 +18,7 @@ import { downloadProjectZip } from "./zipExport";
 import { parseProblems } from "./problemParser";
 import "./App.css";
 import "xterm/css/xterm.css";
-import XTerm from "./Terminal"; // keep your existing XTerm wrapper
+import XTerm from "./Terminal"; // your existing wrapper
 
 // =================== SUPPORTED LANGUAGES ===================
 const LANGUAGE_OPTIONS = [
@@ -36,7 +36,7 @@ const LANGUAGE_OPTIONS = [
 const RUNNABLE_LANGS = ["python", "javascript", "java"];
 
 // =================== Heuristics ===================
-// output patterns that indicate the program is waiting for console input
+// patterns that indicate program is waiting for input
 function outputLooksForInput(output) {
   if (!output) return false;
   const o = output.toString();
@@ -52,40 +52,35 @@ function outputLooksForInput(output) {
     /awaiting input/i,
     /provide input/i,
     /stdin/i,
+    /enter a value/i,
   ];
   return patterns.some((p) => p.test(o));
 }
 
-// code-level heuristics to detect input() or equivalent calls
+// code-level heuristics to detect input calls
 function codeNeedsInput(code, langId) {
   if (!code) return false;
   try {
     const c = code.toString();
-    // Python
     if (langId === "python") {
-      // input(), sys.stdin.read(), sys.stdin.readline()
       if (/\binput\s*\(/i.test(c)) return true;
       if (/\bsys\.stdin\.(read|readline|readlines)\s*\(/i.test(c)) return true;
-      if (/\braw_input\s*\(/i.test(c)) return true; // py2
+      if (/\braw_input\s*\(/i.test(c)) return true;
     }
-    // Java
     if (langId === "java") {
       if (/\bScanner\s*\(/i.test(c)) return true;
       if (/\bBufferedReader\b.*readLine/i.test(c)) return true;
       if (/\bSystem\.console\(\)/i.test(c)) return true;
       if (/\bnext(Int|Line|Double|)\b/i.test(c)) return true;
     }
-    // JavaScript/Node
     if (langId === "javascript") {
       if (/process\.stdin|readline|readlineSync|prompt\(|require\(['"]readline['"]\)/i.test(c)) return true;
     }
-    // C/C++/C: scanf / cin
     if (langId === "cpp" || langId === "c") {
       if (/\bscanf\s*\(/i.test(c)) return true;
       if (/\bstd::cin\b|cin\s*>>/i.test(c)) return true;
       if (/\bgets?\s*\(/i.test(c)) return true;
     }
-    // Generic fallback
     if (/\binput\b|\bscanf\b|\bscanf_s\b|\bcin\b|\bScanner\b|readLine|readline/i.test(c)) return true;
     return false;
   } catch {
@@ -100,49 +95,45 @@ function focusXtermHelper() {
     if (ta) {
       try {
         ta.focus();
-        // move caret to end
         const len = ta.value?.length ?? 0;
         ta.setSelectionRange(len, len);
       } catch {}
     } else {
-      // Fallback: focus container to encourage user to click
       const cont = document.getElementById("terminal-container");
       if (cont) cont.focus();
     }
-  }, 120); // small delay to ensure xterm is ready
+  }, 120);
 }
 
 // =================== APP ===================
 function App() {
+  // ----- file tree + selection -----
   const [tree, setTree] = useState(loadTree());
   const [activePath, setActivePath] = useState("main.py");
 
-  // Terminal state
-  const [accumStdin, setAccumStdin] = useState("");
+  // ----- terminal / interactive state -----
+  const [accumStdin, setAccumStdin] = useState(""); // accumulated input for interactive runs
   const [awaitingInput, setAwaitingInput] = useState(false);
-  const [output, setOutput] = useState("");
+  const [terminalLines, setTerminalLines] = useState([]); // visible lines in terminal area
+  const [output, setOutput] = useState(""); // "write" prop for XTerm (Terminal component picks this up)
+  const [interactivePromptShown, setInteractivePromptShown] = useState(false);
+
+  // ----- AI + editor state -----
   const [prompt, setPrompt] = useState("");
   const [explanation, setExplanation] = useState("");
-const [terminalLines, setTerminalLines] = useState([]);
-  // legacy small-input & helpers (kept for convenience)
-  const [terminalInput, setTerminalInput] = useState("");
-  const [stdin, setStdin] = useState("");
   const [problems, setProblems] = useState([]);
   const [theme, setTheme] = useState("vs-dark");
   const [searchOpen, setSearchOpen] = useState(false);
   const [searchQuery, setSearchQuery] = useState("");
   const [aiSuggestions, setAiSuggestions] = useState([]);
   const [contextMenu, setContextMenu] = useState(null);
-  const editorRef = useRef(null);
-  const fileInputRef = useRef(null);
-
-  // loading flags
   const [isRunning, setIsRunning] = useState(false);
   const [isFixing, setIsFixing] = useState(false);
   const [isExplaining, setIsExplaining] = useState(false);
-  // near other useState declarations
-const [interactivePromptShown, setInteractivePromptShown] = useState(false);
 
+  // refs & helpers
+  const editorRef = useRef(null);
+  const fileInputRef = useRef(null);
 
   useEffect(() => {
     saveTree(tree);
@@ -153,7 +144,7 @@ const [interactivePromptShown, setInteractivePromptShown] = useState(false);
     LANGUAGE_OPTIONS.find((l) => currentNode?.name?.endsWith(l.ext)) ||
     LANGUAGE_OPTIONS[0];
 
-  // ---------- File/Folder helpers (unchanged) ----------
+  // ---------- File / Folder actions ----------
   const collectFolderPaths = (node, acc = []) => {
     if (!node) return acc;
     if (node.type === "folder") acc.push(node.path || "");
@@ -164,7 +155,6 @@ const [interactivePromptShown, setInteractivePromptShown] = useState(false);
   const handleNewFile = () => {
     const filename = window.prompt("Filename (with extension):", "untitled.js");
     if (!filename) return;
-
     const selected = getNodeByPath(tree, activePath);
     let parentPath = "";
     if (selected?.type === "folder") parentPath = selected.path;
@@ -172,7 +162,6 @@ const [interactivePromptShown, setInteractivePromptShown] = useState(false);
       const parts = selected.path.split("/").slice(0, -1);
       parentPath = parts.join("/");
     }
-
     const folders = collectFolderPaths(tree);
     const suggestion = parentPath || folders[0] || "";
     const chosen = window.prompt(
@@ -180,10 +169,8 @@ const [interactivePromptShown, setInteractivePromptShown] = useState(false);
       suggestion
     );
     const targetParent = chosen == null ? parentPath : (chosen.trim() || "");
-
     const updated = addFile(tree, filename, targetParent);
     setTree(updated);
-
     const newPath = (targetParent ? targetParent + "/" : "") + filename;
     setActivePath(newPath);
   };
@@ -205,7 +192,6 @@ const [interactivePromptShown, setInteractivePromptShown] = useState(false);
     if (!newName || newName === node.name) return;
     const updated = renameNode(tree, activePath, newName);
     setTree(updated);
-
     const parts = activePath.split("/");
     parts.pop();
     const parent = parts.join("/");
@@ -217,7 +203,6 @@ const [interactivePromptShown, setInteractivePromptShown] = useState(false);
     if (!activePath) return;
     const node = getNodeByPath(tree, activePath);
     if (!node) return;
-
     if (node.type === "folder" && node.children?.length > 0) {
       const ok = window.confirm(`Folder "${node.name}" has ${node.children.length} items. Delete anyway?`);
       if (!ok) return;
@@ -225,7 +210,6 @@ const [interactivePromptShown, setInteractivePromptShown] = useState(false);
       const ok = window.confirm(`Delete "${node.name}"?`);
       if (!ok) return;
     }
-
     const updated = deleteNode(tree, activePath);
     setTree(updated);
     setActivePath("");
@@ -241,19 +225,15 @@ const [interactivePromptShown, setInteractivePromptShown] = useState(false);
     a.click();
   };
 
-  // import file
   const handleImportFileClick = () => fileInputRef.current?.click();
-
   const handleFileInputChange = async (e) => {
     const f = e.target.files?.[0];
     if (!f) return;
     const text = await f.text();
-
     const selected = getNodeByPath(tree, activePath);
     let parentPath = "";
     if (selected?.type === "folder") parentPath = selected.path;
     else if (selected?.type === "file") parentPath = selected.path.split("/").slice(0, -1).join("");
-
     const updated = addFile(tree, f.name, parentPath);
     const newPath = (parentPath ? parentPath + "/" : "") + f.name;
     const finalTree = updateFileContent(updated, newPath, text);
@@ -263,181 +243,144 @@ const [interactivePromptShown, setInteractivePromptShown] = useState(false);
   };
 
   // ---------- Terminal helpers ----------
+  const appendTerminal = (text) => {
+    // push to visible lines and set `output` (which Terminal writes)
+    setTerminalLines((prev) => {
+      const next = [...prev, text];
+      // also keep the XTerm single-output prop to trigger Terminal.writeln
+      setOutput(text);
+      return next;
+    });
+  };
+
+  const clearTerminal = () => {
+    // ANSI sequence to clear screen + move cursor home (xterm will honor)
+    setTerminalLines([]);
+    setOutput("\x1b[2J\x1b[H");
+    setAccumStdin("");
+    setAwaitingInput(false);
+    setInteractivePromptShown(false);
+  };
+
   const resetTerminal = (keepAccum = false) => {
+    setTerminalLines([]);
     setOutput("");
     if (!keepAccum) {
       setAccumStdin("");
     }
     setAwaitingInput(false);
-    setTerminalInput("");
+    setInteractivePromptShown(false);
   };
 
-  // Core run with updated input (used by XTerm onData and Send button)
+  // Unified runner used when terminal provides input (or small input)
   const runCodeWithUpdatedInput = async (inputLine) => {
-  if (typeof inputLine !== "string") inputLine = String(inputLine || "");
-  const trimmed = inputLine.replace(/\r$/, ""); // normalize
-  if (trimmed.length === 0 && !accumStdin) {
-    // nothing to send
-    return;
-  }
-
-  // append newline like a real console
-  const newAccum = (accumStdin || "") + trimmed + "\n";
-  setAccumStdin(newAccum);
-  setInteractivePromptShown(false); // first input arrived -> clear prompt-shown flag
-
-  const node = getNodeByPath(tree, activePath);
-  if (!node || node.type !== "file") {
-    setOutput((prev) => prev + "\n[Error] No file selected to run.");
-    setAwaitingInput(false);
-    return;
-  }
+    if (typeof inputLine !== "string") inputLine = String(inputLine || "");
+    const trimmed = inputLine.replace(/\r$/, "");
+    // if user pressed Enter with empty line and no accum, ignore
+    if (trimmed.length === 0 && !accumStdin) {
+      return;
+    }
 
-  const selectedLang = LANGUAGE_OPTIONS.find((l) => node.name.endsWith(l.ext))?.id;
-  if (!selectedLang || !RUNNABLE_LANGS.includes(selectedLang)) {
-    setOutput((prev) => prev + `\n[Error] Run not supported for ${node.name}`);
-    setAwaitingInput(false);
-    return;
-  }
+    // append newline like console
+    const newAccum = (accumStdin || "") + trimmed + "\n";
+    setAccumStdin(newAccum);
+    setInteractivePromptShown(false);
 
-  setIsRunning(true);
-  try {
-    const res = await runCode(node.content, selectedLang, newAccum);
-    const out = res.output ?? "";
-    setOutput(out);
-    setProblems(res.error ? parseProblems(res.output) : []);
-    if (outputLooksForInput(out)) {
-      // program still waits for more input — keep accumStdin so input can be appended
-      setAwaitingInput(true);
-      focusXtermHelper();
-    } else {
-      // program finished — clear accumulated stdin so next Run asks fresh
+    const node = getNodeByPath(tree, activePath);
+    if (!node || node.type !== "file") {
+      appendTerminal("[Error] No file selected to run.");
       setAwaitingInput(false);
-      setAccumStdin("");
+      return;
     }
-  } catch (err) {
-    setOutput(String(err));
-    // on error, allow user to continue the interactive session
-    setAwaitingInput(true);
-  } finally {
-    setIsRunning(false);
-  }
-};
-
-// append a line to the terminal
-const appendTerminal = (text) => {
-  setTerminalLines((prev) => [...prev, text]);
-};
-
-  // Initial Run: do NOT run if code needs interactive input and there's no accumulated stdin.
-// Replace your existing handleRun with this version.
-// This version clears accumulated stdin at the start so "Run" asks fresh input every time.
-// Replace your existing handleRun with this
-const handleRun = async () => {
-  const node = getNodeByPath(tree, activePath);
-  if (!node || node.type !== "file") {
-    setOutput("Select a file to run.");
-    return;
-  }
-
-  const selectedLang = LANGUAGE_OPTIONS.find((l) =>
-    node.name.endsWith(l.ext)
-  )?.id;
-  if (!selectedLang || !RUNNABLE_LANGS.includes(selectedLang)) {
-    setOutput(`⚠️ Run not supported for this file type.`);
-    return;
-  }
 
-  // --- FORCE a fresh run: clear any previous accumulated stdin and terminal ---
-  setAccumStdin("");
-  resetTerminal(false); // clear terminalLines + terminalInput and also clears accumStdin because keepAccum=false
-  setAwaitingInput(false);
-  setInteractivePromptShown(false);
-
-  // detect whether the code likely needs interactive input
-  const needs = codeNeedsInput(node.content, selectedLang);
-
-  // If code needs input, show a clear interactive message (do NOT run yet)
-  if (needs) {
-    appendTerminal("[Interactive program detected — type input directly into the terminal]");
-    setAwaitingInput(true);
-    setInteractivePromptShown(true);
-    focusXtermHelper();
-    return; // wait for user's first input (avoids EOFError)
-  }
-
-  // If not interactive, run immediately with empty stdin
-  const stdinToSend = ""; // fresh run uses no previous input
-
-  appendTerminal(`[Running (fresh) with stdin length=${stdinToSend.length}]`);
-  setIsRunning(true);
-  setProblems([]);
-  try {
-    const res = await runCode(node.content, selectedLang, stdinToSend);
-    const out = res.output ?? "";
-    setOutput(out);
-    appendTerminal(out);
-    setProblems(res.error ? parseProblems(res.output) : []);
-
-    // If output suggests further input, enter interactive mode (rare since we checked 'needs', but handle anyway)
-    if (outputLooksForInput(out)) {
-      setAwaitingInput(true);
-      focusXtermHelper();
-    } else {
+    const selectedLang = LANGUAGE_OPTIONS.find((l) => node.name.endsWith(l.ext))?.id;
+    if (!selectedLang || !RUNNABLE_LANGS.includes(selectedLang)) {
+      appendTerminal(`[Error] Run not supported for ${node.name}`);
       setAwaitingInput(false);
-      setInteractivePromptShown(false);
-      setAccumStdin(""); // ensure accum cleared after finish
+      return;
     }
-  } catch (err) {
-    const errStr = String(err);
-    setOutput(errStr);
-    appendTerminal(errStr);
-    // if error looks like EOF or program expects input, enable interactive mode
-    setAwaitingInput(true);
-    setInteractivePromptShown(true);
-    focusXtermHelper();
-  } finally {
-    setIsRunning(false);
-  }
-};
-
 
+    setIsRunning(true);
+    try {
+      const res = await runCode(node.content, selectedLang, newAccum);
+      const out = res.output ?? "";
+      if (out) appendTerminal(out);
+      setProblems(res.error ? parseProblems(res.output) : []);
+      if (outputLooksForInput(out)) {
+        setAwaitingInput(true);
+        focusXtermHelper();
+      } else {
+        setAwaitingInput(false);
+        setAccumStdin(""); // finished -> clear accumulated input so next Run is fresh
+      }
+    } catch (err) {
+      appendTerminal(String(err));
+      setAwaitingInput(true);
+    } finally {
+      setIsRunning(false);
+    }
+  };
 
+  // ---------- Initial Run handler (fresh runs) ----------
+  const handleRun = async () => {
+    const node = getNodeByPath(tree, activePath);
+    if (!node || node.type !== "file") {
+      appendTerminal("Select a file to run.");
+      return;
+    }
 
-  // Send from the small input box: delegate to runCodeWithUpdatedInput to keep behavior uniform
- const sendTerminalInput = async () => {
-  const line = (terminalInput || "").replace(/\r$/, "");
-  if (!line) {
-    // If there is no typed small-input but interactivePromptShown is true, just focus terminal
-    if (interactivePromptShown) {
-      focusXtermHelper();
+    const selectedLang = LANGUAGE_OPTIONS.find((l) => node.name.endsWith(l.ext))?.id;
+    if (!selectedLang || !RUNNABLE_LANGS.includes(selectedLang)) {
+      appendTerminal(`⚠️ Run not supported for this file type.`);
+      return;
     }
-    return;
-  }
 
-  // show echo in output
-  setOutput((prev) => (prev ? prev + `\n> ${line}` : `> ${line}`));
-  setTerminalInput("");
+    // Force fresh run: clear accumulated input and terminal
+    setAccumStdin("");
+    resetTerminal(false);
+    setAwaitingInput(false);
+    setInteractivePromptShown(false);
 
-  // Use the unified runner that appends input and runs
-  await runCodeWithUpdatedInput(line);
-};
+    const needs = codeNeedsInput(node.content, selectedLang);
 
+    if (needs) {
+      appendTerminal("[Interactive program detected — type input directly into the terminal]");
+      setAwaitingInput(true);
+      setInteractivePromptShown(true);
+      focusXtermHelper();
+      return; // wait for user's input to avoid EOFError
+    }
 
-  // handle press Enter for small input
-  const onTerminalKeyDown = (e) => {
-    if (e.key === "Enter") {
-      e.preventDefault();
-      if (!awaitingInput) return;
-      sendTerminalInput();
+    // Non-interactive: run immediately with empty stdin
+    appendTerminal(`[Running (fresh)]`);
+    setIsRunning(true);
+    setProblems([]);
+    try {
+      const res = await runCode(node.content, selectedLang, "");
+      const out = res.output ?? "";
+      if (out) appendTerminal(out);
+      setProblems(res.error ? parseProblems(res.output) : []);
+      if (outputLooksForInput(out)) {
+        setAwaitingInput(true);
+        focusXtermHelper();
+      } else {
+        setAwaitingInput(false);
+        setAccumStdin("");
+      }
+    } catch (err) {
+      appendTerminal(String(err));
+      setAwaitingInput(true);
+      focusXtermHelper();
+    } finally {
+      setIsRunning(false);
     }
   };
 
-  // ---------- Agent functions (unchanged) ----------
+  // ---------- Agent functions ----------
   const handleAskFix = async () => {
     const node = getNodeByPath(tree, activePath);
     if (!node || node.type !== "file") {
-      setOutput("Select a file to apply fix.");
+      appendTerminal("Select a file to apply fix.");
       return;
     }
     setIsFixing(true);
@@ -448,8 +391,9 @@ const handleRun = async () => {
       );
       const updatedTree = updateFileContent(tree, node.path, reply);
       setTree(updatedTree);
+      appendTerminal("[AI] Applied fixes to file.");
     } catch (err) {
-      setOutput(String(err));
+      appendTerminal(String(err));
     } finally {
       setIsFixing(false);
     }
@@ -494,7 +438,6 @@ const handleRun = async () => {
 
   // ---------- Search ----------
   const handleSearchToggle = () => setSearchOpen(!searchOpen);
-
   const handleSearchNow = () => {
     if (!searchQuery) return;
     const results = searchTree(tree, searchQuery);
@@ -535,9 +478,12 @@ const handleRun = async () => {
 
   const anyLoading = isRunning || isFixing || isExplaining;
 
-  // JSX
+  // ---------- JSX ----------
   return (
-    <div className={`ide-root ${theme === "vs-dark" ? "ide-dark" : "ide-light"}`}>
+    <div
+      className={`ide-root ${theme === "vs-dark" ? "ide-dark" : "ide-light"}`}
+      style={{ overflowX: "hidden" }} // prevent horizontal white gap / scroller issue
+    >
       <input ref={fileInputRef} id="file-import-input" type="file" style={{ display: "none" }} onChange={handleFileInputChange} />
 
       <div className="ide-menubar">
@@ -557,14 +503,15 @@ const handleRun = async () => {
           <button onClick={handleSearchToggle} disabled={anyLoading}>🔍 Search</button>
           <button onClick={handleRun} disabled={isRunning || anyLoading}>{isRunning ? "⏳ Running..." : "▶ Run"}</button>
           <button onClick={handleAskFix} disabled={isFixing || anyLoading}>{isFixing ? "⏳ Fixing..." : "🤖 Fix"}</button>
-          <button onClick={handleExplainSelection} disabled={isExplaining || anyLoading}>{isExplaining ? "⏳ Explaining..." : "📖 Explain"}</button>
+          <button onClick={handleExplainSelection} disabled={isExplaining || anyLoading}>{isExplaining ? "⏳ Explaining" : "📖 Explain"}</button>
           <button onClick={() => setTheme((t) => (t === "vs-dark" ? "light" : "vs-dark"))} disabled={anyLoading}>
             {theme === "vs-dark" ? "☀️" : "🌙"}
           </button>
+          <button onClick={clearTerminal} disabled={anyLoading} title="Clear terminal">🧹 Clear</button>
         </div>
       </div>
 
-      {anyLoading && (
+      {(isRunning || isFixing || isExplaining) && (
         <div className="ide-progress-wrap">
           <div className="ide-progress" />
         </div>
@@ -605,78 +552,31 @@ const handleRun = async () => {
             <div style={{ marginBottom: 8 }}>
               <div style={{ fontSize: 12, color: "#ccc", marginBottom: 6 }}>Terminal</div>
 
-             <XTerm
-  output={output}
-  onData={(line) => {
-    // line is a clean string (no CR)
-    const trimmed = (line || "").replace(/\r$/, "");
-    if (!trimmed && !awaitingInput) {
-      // nothing typed
-      return;
-    }
-    // Always delegate to the unified runner which appends to accumulated stdin
-    runCodeWithUpdatedInput(trimmed);
-  }}
-/>
-
+              <XTerm
+                output={output}
+                onData={(line) => {
+                  // line is the typed content (no CR), pass to unified runner
+                  const trimmed = (line || "").replace(/\r$/, "");
+                  if (!trimmed && !awaitingInput) {
+                    // nothing typed and not expecting input
+                    return;
+                  }
+                  runCodeWithUpdatedInput(trimmed);
+                }}
+              />
 
-              {/* When interactive program detected and waiting for user input */}
               {awaitingInput && (
                 <div style={{ marginTop: 8, padding: 8, background: "#252526", border: "1px solid #333", borderRadius: 6 }}>
                   <div style={{ marginBottom: 6, color: "#ddd" }}>
                     This program appears to be interactive and requires console input.
                   </div>
                   <div style={{ display: "flex", gap: 8 }}>
-                    <button
-                      onClick={() => {
-                        focusXtermHelper();
-                        // ensure terminal is ready to accept typed input
-                      }}
-                      className="ide-button"
-                    >
-                      ▶ Focus Terminal
-                    </button>
-                    <button
-                      onClick={() => {
-                        // start interactive session: clear output but keep accum
-                        resetTerminal(true);
-                        setOutput("[Interactive session started — type into the terminal]");
-                        setAwaitingInput(true);
-                        focusXtermHelper();
-                      }}
-                      className="ide-button"
-                    >
-                      ▶ Start interactive session
-                    </button>
-                    <div style={{ color: "#999", alignSelf: "center" }}>Type & press Enter in terminal or use Send below.</div>
+                    <button onClick={() => { focusXtermHelper(); }} className="ide-button">▶ Focus Terminal</button>
+                    <button onClick={() => { resetTerminal(true); appendTerminal("[Interactive session started — type into the terminal]"); setAwaitingInput(true); focusXtermHelper(); }} className="ide-button">▶ Start interactive session</button>
+                    <div style={{ color: "#999", alignSelf: "center" }}>Type & press Enter in terminal.</div>
                   </div>
                 </div>
               )}
-
-              {/* If not awaiting input show legacy small input for single-run */}
-              {!awaitingInput && (
-                <div style={{ display: "flex", gap: 6, marginTop: 6 }}>
-                  <input className="ide-input-box" placeholder="(Optional) Program input for single-run" value={stdin} onChange={(e) => setStdin(e.target.value)} />
-                  <div style={{ alignSelf: "center", color: "#999", fontSize: 12 }}>Press Run → to execute</div>
-                </div>
-              )}
-
-              {/* Always show small input/send option so users can type without xterm if they prefer */}
-              <div style={{ display: "flex", gap: 6, marginTop: 8 }}>
-                <input
-                  className="ide-input-box"
-                  placeholder={awaitingInput ? "Type input and press Send (or press Enter in terminal)" : "Optional input (press Send to append and run)"}
-                  value={terminalInput}
-                  onChange={(e) => setTerminalInput(e.target.value)}
-                  onKeyDown={(e) => {
-                    if (e.key === "Enter") {
-                      e.preventDefault();
-                      sendTerminalInput();
-                    }
-                  }}
-                />
-                <button onClick={sendTerminalInput} className="ide-button" disabled={isRunning}>{isRunning ? "⏳" : "Send"}</button>
-              </div>
             </div>
 
             {problems.length > 0 && (