commit initial 09-12-2025 31

src/App.js

@@ -1,3 +1,4 @@
+// App.js (complete updated file)
 import { useState, useEffect, useRef } from "react";
 import Editor from "@monaco-editor/react";
 import { askAgent } from "./agent/assistant";
@@ -17,7 +18,7 @@ import { downloadProjectZip } from "./zipExport";
 import { parseProblems } from "./problemParser";
 import "./App.css";
 import "xterm/css/xterm.css";
-import XTerm from "./Terminal"; // your xterm wrapper component
+import XTerm from "./Terminal"; // keep your existing XTerm wrapper
 
 // =================== SUPPORTED LANGUAGES ===================
 const LANGUAGE_OPTIONS = [
@@ -34,7 +35,8 @@ const LANGUAGE_OPTIONS = [
 
 const RUNNABLE_LANGS = ["python", "javascript", "java"];
 
-// Utility: detect whether output likely requests input
+// =================== Heuristics ===================
+// output patterns that indicate the program is waiting for console input
 function outputLooksForInput(output) {
   if (!output) return false;
   const o = output.toString();
@@ -47,30 +49,69 @@ function outputLooksForInput(output) {
     /: $/,
     /:\n$/,
     /> $/,
+    /awaiting input/i,
+    /provide input/i,
+    /stdin/i,
   ];
   return patterns.some((p) => p.test(o));
 }
 
-// Heuristic: detect input calls inside source
+// code-level heuristics to detect input() or equivalent calls
 function codeNeedsInput(code, langId) {
   if (!code) return false;
   try {
     const c = code.toString();
+    // Python
     if (langId === "python") {
-      return /\binput\s*\(/i.test(c);
+      // 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
     }
+    // Java
     if (langId === "java") {
-      return /\bScanner\s*\(|\bnext(Int|Line|Double)\b/i.test(c) || /\bSystem\.console\(\)/i.test(c);
+      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") {
-      return /process\.stdin|readline|prompt\(|window\.prompt/i.test(c);
+      if (/process\.stdin|readline|readlineSync|prompt\(|require\(['"]readline['"]\)/i.test(c)) return true;
     }
-    return /\binput\b|\bScanner\b|\bnextInt\b|prompt\(/i.test(c);
+    // 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 {
     return false;
   }
 }
 
+// Helper: focus xterm's hidden textarea (works with xterm.js default markup)
+function focusXtermHelper() {
+  setTimeout(() => {
+    const ta = document.querySelector("#terminal-container .xterm-helper-textarea");
+    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
+}
+
 // =================== APP ===================
 function App() {
   const [tree, setTree] = useState(loadTree());
@@ -83,7 +124,7 @@ function App() {
   const [prompt, setPrompt] = useState("");
   const [explanation, setExplanation] = useState("");
 
-  // legacy and other UI
+  // legacy small-input & helpers (kept for convenience)
   const [terminalInput, setTerminalInput] = useState("");
   const [stdin, setStdin] = useState("");
   const [problems, setProblems] = useState([]);
@@ -109,7 +150,7 @@ function App() {
     LANGUAGE_OPTIONS.find((l) => currentNode?.name?.endsWith(l.ext)) ||
     LANGUAGE_OPTIONS[0];
 
-  // ---------- TREE helpers ----------
+  // ---------- File/Folder helpers (unchanged) ----------
   const collectFolderPaths = (node, acc = []) => {
     if (!node) return acc;
     if (node.type === "folder") acc.push(node.path || "");
@@ -117,12 +158,10 @@ function App() {
     return acc;
   };
 
-  // ---------- File / Folder actions ----------
   const handleNewFile = () => {
     const filename = window.prompt("Filename (with extension):", "untitled.js");
     if (!filename) return;
 
-    // Determine default parent
     const selected = getNodeByPath(tree, activePath);
     let parentPath = "";
     if (selected?.type === "folder") parentPath = selected.path;
@@ -230,8 +269,9 @@ function App() {
     setTerminalInput("");
   };
 
-  // On-line input from XTerm -> append and re-run
+  // Core run with updated input (used by XTerm onData and Send button)
   const runCodeWithUpdatedInput = async (inputLine) => {
+    // append newline like a real console
     const newAccum = (accumStdin || "") + inputLine + "\n";
     setAccumStdin(newAccum);
 
@@ -257,6 +297,8 @@ function App() {
       setProblems(res.error ? parseProblems(res.output) : []);
       if (outputLooksForInput(out)) {
         setAwaitingInput(true);
+        // keep focus
+        focusXtermHelper();
       } else {
         setAwaitingInput(false);
       }
@@ -268,7 +310,7 @@ function App() {
     }
   };
 
-  // Initial run — DO NOT call run if code needs interactive input and we have no accumStdin.
+  // Initial Run: do NOT run if code needs interactive input and there's no accumulated stdin.
   const handleRun = async () => {
     const node = getNodeByPath(tree, activePath);
     if (!node || node.type !== "file") {
@@ -281,22 +323,21 @@ function App() {
       return;
     }
 
-    // If code likely needs input and we have no accumulated stdin, don't run — wait for user input in XTerm.
     const needs = codeNeedsInput(node.content, selectedLang);
     const haveAccum = !!(accumStdin && accumStdin.length > 0);
     const haveLegacyStdin = !!(stdin && stdin.length > 0);
 
     if (needs && !haveAccum && !haveLegacyStdin) {
-      // Show helpful message in terminal and enable awaitingInput so user can type into XTerm.
-      setOutput("[Interactive program detected — type input directly into the terminal]");
+      // Show instruction and enable typing in XTerm; do not perform a run with empty stdin (avoids EOFError)
+      setOutput("[Interactive program detected — click Start interactive session or type in terminal]");
       setAwaitingInput(true);
-      return; // <-- important: do NOT run now
+      focusXtermHelper();
+      return;
     }
 
-    // Otherwise run immediately with whichever stdin we have (accumStdin or legacy stdin)
+    // Otherwise perform run with existing accumulated or legacy input
     const stdinToSend = accumStdin || stdin || "";
-
-    resetTerminal(true); // keep accumStdin
+    resetTerminal(true);
     setOutput(`[Running with stdin length=${stdinToSend ? stdinToSend.length : 0}]\n`);
     setIsRunning(true);
     setProblems([]);
@@ -307,53 +348,31 @@ function App() {
       setProblems(res.error ? parseProblems(res.output) : []);
       if (outputLooksForInput(out)) {
         setAwaitingInput(true);
+        focusXtermHelper();
       } else {
         setAwaitingInput(false);
       }
     } catch (err) {
-      const e = String(err);
-      setOutput(e);
-      // Allow user to type into terminal after EOF errors
+      setOutput(String(err));
+      // allow interactive continuation after EOF
       setAwaitingInput(true);
+      focusXtermHelper();
     } finally {
       setIsRunning(false);
     }
   };
 
-  // Legacy send from input box
+  // Send from the small input box: delegate to runCodeWithUpdatedInput to keep behavior uniform
   const sendTerminalInput = async () => {
-    const node = getNodeByPath(tree, activePath);
-    if (!node || node.type !== "file") {
-      setOutput((prev) => prev + "\nNo file selected.");
-      setAwaitingInput(false);
-      return;
-    }
-
-    const userText = terminalInput;
-    setOutput((prev) => prev + `\n> ${userText}`);
-    const newAccum = (accumStdin || "") + userText + "\n";
-    setAccumStdin(newAccum);
+    if (!terminalInput || terminalInput.length === 0) return;
+    // echo in output for small box then run
+    setOutput((prev) => prev + `\n> ${terminalInput}`);
+    const line = terminalInput;
     setTerminalInput("");
-    setIsRunning(true);
-    try {
-      const selectedLang = LANGUAGE_OPTIONS.find((l) => node.name.endsWith(l.ext))?.id;
-      const res = await runCode(node.content, selectedLang, newAccum);
-      const out = res.output ?? "";
-      setOutput(out);
-      setProblems(res.error ? parseProblems(res.output) : []);
-      if (outputLooksForInput(out)) {
-        setAwaitingInput(true);
-      } else {
-        setAwaitingInput(false);
-      }
-    } catch (err) {
-      setOutput((prev) => prev + "\n" + String(err));
-      setAwaitingInput(false);
-    } finally {
-      setIsRunning(false);
-    }
+    await runCodeWithUpdatedInput(line);
   };
 
+  // handle press Enter for small input
   const onTerminalKeyDown = (e) => {
     if (e.key === "Enter") {
       e.preventDefault();
@@ -362,7 +381,7 @@ function App() {
     }
   };
 
-  // ---------- Agent functions ----------
+  // ---------- Agent functions (unchanged) ----------
   const handleAskFix = async () => {
     const node = getNodeByPath(tree, activePath);
     if (!node || node.type !== "file") {
@@ -537,10 +556,45 @@ function App() {
               <XTerm
                 output={output}
                 onData={(line) => {
+                  // Called when XTerm wrapper detects a full line (ENTER)
                   runCodeWithUpdatedInput(line);
                 }}
               />
 
+              {/* 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>
+                  </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)} />
@@ -548,19 +602,22 @@ function App() {
                 </div>
               )}
 
-              {awaitingInput && (
-                <div style={{ display: "flex", gap: 6, marginTop: 6 }}>
-                  <input
-                    className="ide-input-box"
-                    placeholder="Type input and press Send..."
-                    value={terminalInput}
-                    onChange={(e) => setTerminalInput(e.target.value)}
-                    onKeyDown={onTerminalKeyDown}
-                    disabled={!awaitingInput || isRunning}
-                  />
-                  <button onClick={sendTerminalInput} disabled={!awaitingInput || isRunning} className="ide-button">Send</button>
-                </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 && (