mos-tui 1.0.1 → 1.0.2

package/core/OS_CP.c

@@ -1,6 +1,7 @@
 #include<stdio.h>
 #include <stdbool.h>
 #include<time.h>
+#include <stdlib.h>
 
 // Declaring the required Memory and Registers
 char M[100][4];     // main storage of size 100 x 4
@@ -261,8 +262,11 @@ int main() {
 
     start = clock();
 
-    fin = fopen("input.txt", "r");
-    fout = fopen("output.txt", "w");
+    char *infile = getenv("MOS_INPUT");
+    char *outfile = getenv("MOS_OUTPUT");
+
+    fin = fopen(infile ? infile : "input.txt", "r");
+    fout = fopen(outfile ? outfile : "output.txt", "w");
 
     if (fin == NULL) {
         printf("Input file not found\n");

package/core/mos.sh

@@ -1,44 +1,43 @@
 #!/usr/bin/env bash
+# ─────────────────────────────────────────────────────────────
+#  MOS Terminal UI Launcher
+#  Usage: ./mos.sh
+#         Run from the same directory as OS_CP.c
+# ─────────────────────────────────────────────────────────────
 set -e
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 TUI="$SCRIPT_DIR/mos_tui.py"
-DEFAULT_OS="$SCRIPT_DIR/OS_CP.c"
+PROJECT_DIR="$(pwd)"   # where the user IS standing — must have OS_CP.c
 
 # Check Python 3
 if ! command -v python3 &>/dev/null; then
-  echo "python3 not found. Install it with: sudo apt install python3"
+  echo "python3 not found. Install: sudo apt install python3"
   exit 1
 fi
 
 # Check gcc
 if ! command -v gcc &>/dev/null; then
-  echo "gcc not found. Install it with: sudo apt install gcc"
+  echo "gcc not found. Install: sudo apt install gcc"
   exit 1
 fi
 
-# Decide which OS_CP.c to use
-if [ -f "OS_CP.c" ]; then
-  OS_FILE="$(pwd)/OS_CP.c"
-  echo "📄 Using OS_CP.c from current directory"
-else
-  OS_FILE="$DEFAULT_OS"
-  echo "📦 Using bundled OS_CP.c"
+# Warn if OS_CP.c is missing
+if [ ! -f "$PROJECT_DIR/OS_CP.c" ]; then
+  echo "WARNING: OS_CP.c not found in: $PROJECT_DIR"
+  echo "         cd into the folder that contains OS_CP.c, then run mos.sh again."
 fi
 
-# Export so Python can use it
-export MOS_OS_FILE="$OS_FILE"
-
-# Ensure the TUI script exists
 if [ ! -f "$TUI" ]; then
   echo "mos_tui.py not found at: $TUI"
   exit 1
 fi
 
-# Terminal setup
 export TERM="${TERM:-xterm-256color}"
 
-echo "🚀 Starting MOS Terminal UI..."
-sleep 0.3
+# cd into the project dir so Python's os.getcwd() == where OS_CP.c is
+cd "$PROJECT_DIR"
 
+echo "Starting MOS Terminal UI..."
+sleep 0.2
 python3 "$TUI"

package/core/mos_tui.py

@@ -28,18 +28,45 @@ C_INPUT    = 9   # green on black (input text)
 C_ORANGE   = 10  # yellow bright (used for EXEC tags)
 C_STAT_VAL = 11  # cyan bold for stat values
 
-# Correct base directory (where this script is installed)
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-
-# Get source file (user provided OR bundled)
-SOURCE = os.environ.get(
-    "MOS_OS_FILE",
-    os.path.join(BASE_DIR, "OS_CP.c")
-)
+# Locate OS_CP.c by searching:
+#   1. Directory explicitly set via MOS_SOURCE env var
+#   2. Current working directory
+#   3. Walk UP from cwd (handles npm package subdirectory installs)
+#   4. Walk UP from script location
+def _find_source():
+    # Env override — highest priority
+    env_src = os.environ.get("MOS_SOURCE")
+    if env_src and os.path.exists(env_src):
+        return os.path.abspath(env_src)
+
+    # Search upward from cwd
+    search = os.getcwd()
+    for _ in range(6):
+        candidate = os.path.join(search, "OS_CP.c")
+        if os.path.exists(candidate):
+            return candidate
+        parent = os.path.dirname(search)
+        if parent == search:
+            break
+        search = parent
+
+    # Search upward from script location
+    search = os.path.dirname(os.path.abspath(__file__))
+    for _ in range(6):
+        candidate = os.path.join(search, "OS_CP.c")
+        if os.path.exists(candidate):
+            return candidate
+        parent = os.path.dirname(search)
+        if parent == search:
+            break
+        search = parent
 
-# Binary will be created in same directory as source
-BINARY = os.path.join(os.path.dirname(SOURCE), "mos_bin")
+    # Fallback — cwd (will show a clear error)
+    return os.path.join(os.getcwd(), "OS_CP.c")
 
+SOURCE = _find_source()
+_CWD   = os.path.dirname(SOURCE)   # always the folder that contains OS_CP.c
+BINARY = os.path.join(_CWD, "mos_bin")
 
 # ── STATE ─────────────────────────────────────────────────────────────────────
 class State:
@@ -74,15 +101,15 @@ state = State()
 # ── COMPILE ───────────────────────────────────────────────────────────────────
 def compile_source():
     if not os.path.exists(SOURCE):
-        state.compile_error = f"'{SOURCE}' not found in current directory."
-        state.add_debug("ERR", f"Source file {SOURCE} not found")
+        state.add_debug("ERR", f"OS_CP.c not found at: {SOURCE}")
+        state.add_debug("WARN", f"Run this tool from the folder containing OS_CP.c")
+        state.add_debug("WARN", f"Current dir: {_CWD}")
         return False
     state.add_debug("INFO", f"Compiling {SOURCE}...")
     result = subprocess.run(
         ["gcc", "-o", BINARY, SOURCE, "-lm"],
-        cwd=os.path.dirname(SOURCE),
-        capture_output=True,
-        text=True
+        cwd=_CWD,
+        capture_output=True, text=True
     )
     if result.returncode != 0:
         state.compile_error = result.stderr.strip()
@@ -99,24 +126,32 @@ def run_program(input_text, callback):
     state.status = "RUNNING"
     state.add_debug("INFO", f"─── Run #{state.run_count} started ───")
 
-    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False, prefix='mos_in_') as fin:
-        fin.write(input_text)
-        fin_path = fin.name
+    # Use a dedicated temp directory so input.txt and output.txt are isolated
+    run_dir = tempfile.mkdtemp(prefix='mos_run_')
+    fin_path  = os.path.join(run_dir, "input.txt")
+    fout_path = os.path.join(run_dir, "output.txt")
 
-    fout_path = fin_path.replace('mos_in_', 'mos_out_').replace('.txt', '_out.txt')
+    with open(fin_path, 'w') as f:
+        f.write(input_text)
+
+    state.add_debug("INFO", f"Input written → {fin_path}")
 
     t0 = time.perf_counter()
     try:
         result = subprocess.run(
             [BINARY],
-            stdin=open(fin_path),
             capture_output=True,
             text=True,
             timeout=10,
-            env={**os.environ, 'MOS_INPUT': fin_path, 'MOS_OUTPUT': fout_path}
+            cwd=run_dir,                          # binary runs inside temp dir
+            env={**os.environ,
+                 'MOS_INPUT':  fin_path,           # env var override (your updated C uses this)
+                 'MOS_OUTPUT': fout_path}
         )
         elapsed_ms = (time.perf_counter() - t0) * 1000
 
+        state.add_debug("INFO", f"Process exited (code={result.returncode})")
+
         # Parse stdout debug lines from the C program
         for line in result.stdout.strip().splitlines():
             line = line.strip()
@@ -143,20 +178,32 @@ def run_program(input_text, callback):
             for line in result.stderr.strip().splitlines():
                 state.add_debug("ERR", line)
 
-        # Read output.txt if it was produced
+        # Read output.txt from the run directory (guaranteed location)
         output_content = []
-        if os.path.exists("output.txt"):
-            with open("output.txt") as f:
-                output_content = f.read().splitlines()
-        elif os.path.exists(fout_path):
+        if os.path.exists(fout_path):
             with open(fout_path) as f:
                 output_content = f.read().splitlines()
-
-        for line in output_content:
-            state.add_output(line)
-
-        if not output_content and result.returncode == 0:
-            state.add_output("[No output written — check PD instruction addresses]")
+            state.add_debug("OK", f"Output read from {fout_path} ({len(output_content)} lines)")
+        else:
+            state.add_debug("WARN", f"output.txt not created at {fout_path}")
+
+        # Debug: show raw repr of each line so we can see spaces vs real content
+        for idx, line in enumerate(output_content):
+            stripped = line.rstrip()
+            if stripped:
+                state.add_output(stripped)
+            else:
+                # Don't add pure-blank lines from TERMINATE()'s \n\n — skip them
+                # but log them so user can see in debug
+                state.add_debug("INFO", f"output line {idx+1}: (blank/whitespace only)")
+
+        if result.returncode == 0:
+            if not output_content:
+                state.add_output("[output.txt was empty — check your PD instruction address]")
+            elif not any(l.strip() for l in output_content):
+                state.add_output("[output.txt had only blank lines — PD address may point to empty memory]")
+                state.add_debug("WARN", "All output lines were blank — GD and PD addresses must match")
+                state.add_debug("WARN", "e.g. GD10 reads into addr 10-19, so use PD10 to print it")
 
         state.exec_time_ms = elapsed_ms
         state.run_history.append((f"Run #{state.run_count}", elapsed_ms))
@@ -170,7 +217,8 @@ def run_program(input_text, callback):
         state.add_debug("ERR", f"Runner error: {e}")
         state.status = "ERROR"
     finally:
-        try: os.unlink(fin_path)
+        import shutil
+        try: shutil.rmtree(run_dir, ignore_errors=True)
         except: pass
 
     callback()
@@ -312,10 +360,14 @@ def draw_output_panel(win, active):
         fill_line(win, y)
         if li < len(lines):
             line = lines[li]
+            # line number gutter
+            gutter = f"{li+1:3} "
+            safe_addstr(win, y, 1, gutter, curses.color_pair(C_DIM))
             col = curses.color_pair(C_GREEN)
             if not line.strip():
-                col = curses.color_pair(C_DIM)
-            safe_addstr(win, y, 1, line[:inner_w], col)
+                safe_addstr(win, y, 5, "~", curses.color_pair(C_DIM))
+            else:
+                safe_addstr(win, y, 5, line[:inner_w-5], col)
 
 # ── PANEL: CHART ──────────────────────────────────────────────────────────────
 SPARK_CHARS = " ▁▂▃▄▅▆▇█"
@@ -446,33 +498,34 @@ def draw_titlebar(stdscr, W):
 
 # ── SAMPLE PROGRAMS ───────────────────────────────────────────────────────────
 SAMPLES = [
+# Sample 1: Read data into addr 10, print from addr 10
 """$AMJ
-LR10
-GD20
-SR30
-LR30
-PD30
+GD10
+PD10
 H
 $DTA
-Hello MOS!  
+Hello MOS!
 $END""",
+# Sample 2: Read two lines, print both
 """$AMJ
 GD10
 PD10
-GD20
-PD20
+GD30
+PD30
 H
 $DTA
-First Data  
-Second Data 
+First Line
+Second Line
 $END""",
+# Sample 3: Load, store, compare, branch
 """$AMJ
-LR05
-CR05
-BT07
-PD05
+GD10
+LR10
+SR20
+PD20
 H
 $DTA
+Stored Data
 $END""",
 ]
 _sample_idx = [0]
@@ -585,12 +638,12 @@ def main(stdscr):
     stdscr.keypad(True)
 
     state.add_debug("INFO", "MOS Terminal UI started")
-    state.add_debug("INFO", f"Using source: {SOURCE}")
+    state.add_debug("INFO", f"Working dir: {_CWD}")
     if os.path.exists(SOURCE):
-        state.add_debug("OK",   f"Found {SOURCE} — press F6 to compile")
+        state.add_debug("OK",   f"Found OS_CP.c — press F6 to compile")
     else:
-        state.add_debug("WARN", f"{SOURCE} not found in current directory")
-        state.add_debug("WARN", "Place OS_CP.c here and press F6")
+        state.add_debug("ERR",  f"OS_CP.c not found in: {_CWD}")
+        state.add_debug("WARN", "cd into your project folder, then rerun ./mos.sh")
 
     load_sample()
 
@@ -687,6 +740,8 @@ def main(stdscr):
                 state.debug_scroll = 0
 
                 def done():
+                    state.focus = 2          # auto-switch to Output panel
+                    state.output_scroll = 0  # scroll to top of output
                     redraw()
 
                 t = threading.Thread(target=run_program, args=(input_text, done), daemon=True)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mos-tui",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "MOS Terminal UI Launcher",
   "bin": {
     "mos": "./bin/mos.js"