mos-tui 1.0.0

package/bin/mos.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+const { spawn } = require("child_process");
+const path = require("path");
+
+const scriptPath = path.join(__dirname, "../core/mos.sh");
+
+const child = spawn("bash", [scriptPath], {
+  stdio: "inherit",
+});
+
+child.on("exit", (code) => {
+  process.exit(code);
+});

package/core/OS_CP.c

@@ -0,0 +1,297 @@
+#include<stdio.h>
+#include <stdbool.h>
+#include<time.h>
+
+// Declaring the required Memory and Registers
+char M[100][4];     // main storage of size 100 x 4
+char IR[4];         // IR (Instruction register) of size 4
+char R[4];          // R (General Purpose register) of size 4
+int IC;             // Instruction Counter
+int C;              // Toggle Register
+int SI;             // Supervisor Interept
+
+
+FILE *fin, *fout;
+
+void START_EXECUTION();
+void EXECUTE_USER_PROGRAM();
+void MOS();
+void READ();
+void WRITE();
+void TERMINATE();
+
+// Function to Compare String
+bool cmpString(char s1[], char s2[], int size) {
+    for (int i = 0; i < size; i++) {
+        if (s1[i] != s2[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+int lenString(char s[]) {
+    int ans = 0;
+    while (s[ans] != '\0') {
+        ans++;
+    }
+
+    return ans;
+}
+
+// INIT Function (initialize the system by empty variable)
+void init() {
+    for (int i = 0; i < 100; i++)
+        for (int j = 0; j < 4; j++)
+            M[i][j] = ' ';
+
+    for (int i = 0; i < 4; i++) {
+        IR[i] = ' ';
+        R[i] = ' ';
+    }
+
+    IC = 0;
+    C = 0;
+    SI = 0;    
+}
+
+void LOAD() {
+    int m = 0;          // It Points location at which instructions are stored
+
+    char word[100];     // Stores each instruction which is to be executed
+
+    while (fgets(word, sizeof(word), fin)) {
+        // printf("%s", word);
+
+        if (cmpString(word, "$AMJ", 4)) {
+            printf("%s", "AMJ (initializing the String)\n");
+            init();
+            m = 0;
+        }
+        else if (cmpString(word, "$DTA", 4)) {
+            printf("%s", "DTA (Starting Execution)\n");
+            START_EXECUTION();
+        }
+
+        else if (cmpString(word, "$END", 4)) {
+            printf("%s", "END (Instruction Completed)\n");
+            continue;
+        }
+        else {
+            int k = 0;
+            while (k < lenString(word) && word[k] != '\n')
+            {
+
+                // Validation for memory overflow
+                if (m >= 100) {
+                    printf("Memory overflow\n");
+                    return;
+                }                
+                for (int j = 0; j < 4 && word[k] != '\n' && word[k] != '\0'; j++) {
+                    M[m][j] = word[k++];
+                }
+                m++;
+            }
+        }
+    }
+}
+
+// START EXECUTION
+void START_EXECUTION() {
+    IC = 0;
+    EXECUTE_USER_PROGRAM();
+}
+
+void EXECUTE_USER_PROGRAM() {
+    int step = 0;
+    while (true)
+    {
+        // To avoid Infinite loop
+        if (step++ > 1000) {
+            printf("Infinite loop detected\n");
+            break;
+        }
+        // Fetch the Instruction
+        for (int i = 0; i < 4; i++) {
+            IR[i] = M[IC][i];
+        }
+
+        IC++;
+        
+        // Decode and Execute the Instructions
+
+
+
+        // LR Instruction (Load Register)
+        if (IR[0] == 'L' && IR[1] == 'R') {
+            int addr = (IR[2]-'0')*10 + (IR[3]-'0');
+            if (!(IR[2] >= '0' && IR[2] <= '9' && IR[3] >= '0' && IR[3] <= '9')) {
+                printf("Invalid operand\n");
+                break;
+            }
+            if (addr < 0 || addr >= 100) {
+                printf("Memory address out of bounds\n");
+                break;
+            }
+            for (int i = 0; i < 4; i++) R[i] = M[addr][i];
+        }
+
+        // SR (Store Register)
+        else if (IR[0] == 'S' && IR[1] == 'R') {
+            int addr = (IR[2]-'0')*10 + (IR[3]-'0');
+            if (!(IR[2] >= '0' && IR[2] <= '9' && IR[3] >= '0' && IR[3] <= '9')) {
+                printf("Invalid operand\n");
+                break;
+            }
+            if (addr < 0 || addr >= 100) {
+                printf("Memory address out of bounds\n");
+                break;
+            }
+            for (int i = 0; i < 4; i++) M[addr][i] = R[i];
+        }
+        
+        // CR (Compare Register)
+        else if (IR[0] == 'C' && IR[1] == 'R') {
+            int addr = (IR[2]-'0')*10 + (IR[3]-'0');
+            if (!(IR[2] >= '0' && IR[2] <= '9' && IR[3] >= '0' && IR[3] <= '9')) {
+                printf("Invalid operand\n");
+                break;
+            }
+            if (addr < 0 || addr >= 100) {
+                printf("Memory address out of bounds\n");
+                break;
+            }
+            C = 1;
+            for (int i = 0; i < 4; i++) {
+                if (R[i] != M[addr][i]) {
+                    C = 0;
+                    break;
+                }
+            }
+        }
+
+        // BT (Branch if True)
+        else if (IR[0] == 'B' && IR[1] == 'T') {
+            int addr = (IR[2]-'0')*10 + (IR[3]-'0');
+            if (!(IR[2] >= '0' && IR[2] <= '9' && IR[3] >= '0' && IR[3] <= '9')) {
+                printf("Invalid operand\n");
+                break;
+            }
+            if (addr < 0 || addr >= 100) {
+                printf("Memory address out of bounds\n");
+                break;
+            }
+            if (C == 1)
+                IC = addr;
+        }
+        
+        // GD (Get Data)
+        else if (IR[0] == 'G' && IR[1] == 'D') {
+            SI = 1;
+            MOS();
+        }
+
+        // PD (Put Data)
+        else if (IR[0] == 'P' && IR[1] == 'D') {
+            SI = 2;
+            MOS();
+        }
+
+        // H (Halt)
+        else if (IR[0] == 'H') {
+            SI = 3;
+            MOS();
+            break;
+        }
+
+        else {
+            printf("Invalid instruction: %c%c%c%c\n", IR[0], IR[1], IR[2], IR[3]);
+            break;
+        }        
+    }
+}
+
+void READ() {
+    char word[40];
+    int addr = (IR[2]-'0')*10 + (IR[3]-'0');
+
+    // Reading if Input file is not Empty
+    if (fgets(word, sizeof(word), fin) == NULL) {
+        printf("No data available for GD\n");
+        return;
+    }
+
+    int k = 0;
+    for (int i = addr; i < addr + 10 && i < 100; i++) {
+        for (int j = 0; j < 4; j++) {
+            if (word[k] == '\n' || word[k] == '\0')
+                M[i][j] = ' ';
+            else
+                M[i][j] = word[k++];
+        }
+    }
+}
+
+void WRITE() {
+    int addr = (IR[2]-'0')*10 + (IR[3]-'0');
+
+    for (int i = addr; i < addr + 10 && i < 100; i++) {
+        for (int j = 0; j < 4; j++) {
+            fputc(M[i][j], fout);
+        }
+    }
+    fputc('\n', fout);
+}
+
+void TERMINATE() {
+    fprintf(fout, "\n\n");
+}
+
+void MOS() {
+    if (SI == 1)
+        READ();
+    else if (SI == 2)
+        WRITE();
+    else if (SI == 3)
+        TERMINATE();
+}
+
+int main() {
+    clock_t start, end;
+
+    start = clock();
+
+    fin = fopen("input.txt", "r");
+    fout = fopen("output.txt", "w");
+
+    if (fin == NULL) {
+        printf("Input file not found\n");
+        return 0;
+    }
+    if (fout == NULL) {
+        printf("Output file error\n");
+        return 0;
+    }
+
+    LOAD();
+
+    fclose(fin);
+    fclose(fout);
+
+    end = clock(); 
+    double time_taken = (double)(end - start) / CLOCKS_PER_SEC;
+    printf("Execution time: %f seconds\n", time_taken);
+    
+    return 0;
+}
+
+
+/*
+// Validations Added
+1. Checking if Input and Output File exists
+2. checking Memery Overflow
+3. Invalid Instruction
+4. Avoid Infinite Loop if Halt Instruction is not available
+5. Added Validation for Correct Operand
+6. Vadidation if input file is Empty
+*/

package/core/mos.sh

@@ -0,0 +1,44 @@
+#!/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"
+
+# Check Python 3
+if ! command -v python3 &>/dev/null; then
+  echo "python3 not found. Install it with: 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"
+  exit 1
+fi
+
+# Check OS_CP.c exists in current dir
+if [ ! -f "OS_CP.c" ]; then
+  echo "     OS_CP.c not found in current directory."
+  echo "     Place OS_CP.c here or cd into the right folder, then re-run."
+  echo "     Launching TUI anyway — you can still use it without the source."
+fi
+
+# Ensure the TUI script is alongside
+if [ ! -f "$TUI" ]; then
+  echo "  mos_tui.py not found at: $TUI"
+  exit 1
+fi
+
+# Set up terminal properly
+export TERM="${TERM:-xterm-256color}"
+
+echo "  Starting MOS Terminal UI..."
+sleep 0.3
+
+python3 "$TUI"

package/core/mos_tui.py

@@ -0,0 +1,744 @@
+#!/usr/bin/env python3
+"""
+MOS Terminal UI — Multiprogramming OS Simulator
+Run: python3 mos_tui.py
+Compiles OS_CP.c and provides a full curses TUI.
+"""
+
+import curses
+import curses.textpad
+import subprocess
+import tempfile
+import os
+import sys
+import time
+import textwrap
+import threading
+
+# ── COLORS (pair indices) ─────────────────────────────────────────────────────
+C_NORMAL   = 1   # white on black
+C_BORDER   = 2   # cyan on black
+C_TITLE    = 3   # cyan bold
+C_GREEN    = 4   # green on black
+C_YELLOW   = 5   # yellow on black
+C_RED      = 6   # red on black
+C_DIM      = 7   # dim white
+C_HEADER   = 8   # black on cyan
+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
+
+BINARY     = "./mos_bin"
+SOURCE     = "OS_CP.c"
+
+# ── STATE ─────────────────────────────────────────────────────────────────────
+class State:
+    def __init__(self):
+        self.input_lines   = []          # lines in input editor
+        self.input_cursor  = [0, 0]      # [row, col]
+        self.debug_lines   = []          # (tag, msg) tuples
+        self.output_lines  = []          # strings
+        self.run_history   = []          # (label, ms) for chart
+        self.run_count     = 0
+        self.status        = "READY"
+        self.compiled      = False
+        self.compile_error = ""
+        self.exec_time_ms  = None
+        self.focus         = 0           # 0=input, 1=debug, 2=output, 3=chart
+        self.input_scroll  = 0
+        self.debug_scroll  = 0
+        self.output_scroll = 0
+        self.lock          = threading.Lock()
+
+    def add_debug(self, tag, msg):
+        ts = time.strftime("%H:%M:%S")
+        with self.lock:
+            self.debug_lines.append((ts, tag, msg))
+
+    def add_output(self, line):
+        with self.lock:
+            self.output_lines.append(line)
+
+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")
+        return False
+    state.add_debug("INFO", f"Compiling {SOURCE}...")
+    result = subprocess.run(
+        ["gcc", "-o", BINARY, SOURCE, "-lm"],
+        capture_output=True, text=True
+    )
+    if result.returncode != 0:
+        state.compile_error = result.stderr.strip()
+        state.add_debug("ERR", "Compilation failed")
+        for line in result.stderr.strip().splitlines()[:6]:
+            state.add_debug("ERR", line)
+        return False
+    state.compiled = True
+    state.add_debug("OK", f"Compiled → {BINARY}")
+    return True
+
+# ── RUN ───────────────────────────────────────────────────────────────────────
+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
+
+    fout_path = fin_path.replace('mos_in_', 'mos_out_').replace('.txt', '_out.txt')
+
+    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}
+        )
+        elapsed_ms = (time.perf_counter() - t0) * 1000
+
+        # Parse stdout debug lines from the C program
+        for line in result.stdout.strip().splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            if "Compilation" in line or "compile" in line.lower():
+                state.add_debug("ERR", line)
+            elif line.startswith("AMJ") or "initializ" in line.lower():
+                state.add_debug("OK", line)
+            elif line.startswith("DTA") or "execut" in line.lower():
+                state.add_debug("EXEC", line)
+            elif line.startswith("END") or "complet" in line.lower():
+                state.add_debug("OK", line)
+            elif "error" in line.lower() or "invalid" in line.lower() or "overflow" in line.lower():
+                state.add_debug("ERR", line)
+            elif "infinite" in line.lower() or "loop" in line.lower():
+                state.add_debug("WARN", line)
+            elif "time" in line.lower():
+                state.add_debug("INFO", line)
+            else:
+                state.add_debug("INFO", line)
+
+        if result.stderr.strip():
+            for line in result.stderr.strip().splitlines():
+                state.add_debug("ERR", line)
+
+        # Read output.txt if it was produced
+        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):
+            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.exec_time_ms = elapsed_ms
+        state.run_history.append((f"Run #{state.run_count}", elapsed_ms))
+        state.add_debug("OK", f"Done in {elapsed_ms:.3f}ms | exit={result.returncode}")
+        state.status = "HALTED" if result.returncode == 0 else "ERROR"
+
+    except subprocess.TimeoutExpired:
+        state.add_debug("ERR", "Execution timed out (10s limit)")
+        state.status = "TIMEOUT"
+    except Exception as e:
+        state.add_debug("ERR", f"Runner error: {e}")
+        state.status = "ERROR"
+    finally:
+        try: os.unlink(fin_path)
+        except: pass
+
+    callback()
+
+# ── DRAWING HELPERS ───────────────────────────────────────────────────────────
+def safe_addstr(win, y, x, s, attr=0):
+    h, w = win.getmaxyx()
+    if y < 0 or y >= h or x < 0 or x >= w:
+        return
+    max_len = w - x - 1
+    if max_len <= 0:
+        return
+    try:
+        win.addstr(y, x, s[:max_len], attr)
+    except curses.error:
+        pass
+
+def draw_box(win, title="", active=False):
+    h, w = win.getmaxyx()
+    col = curses.color_pair(C_BORDER) | (curses.A_BOLD if active else 0)
+    try:
+        win.border(
+            curses.ACS_VLINE, curses.ACS_VLINE,
+            curses.ACS_HLINE, curses.ACS_HLINE,
+            curses.ACS_ULCORNER, curses.ACS_URCORNER,
+            curses.ACS_LLCORNER, curses.ACS_LRCORNER
+        )
+    except curses.error:
+        pass
+    if title:
+        label = f" {title} "
+        attr = curses.color_pair(C_TITLE) | curses.A_BOLD if active else curses.color_pair(C_DIM)
+        safe_addstr(win, 0, 2, label, attr)
+
+def fill_line(win, y, attr=0):
+    h, w = win.getmaxyx()
+    try:
+        win.addstr(y, 1, " " * (w - 2), attr)
+    except curses.error:
+        pass
+
+# ── PANEL: INPUT ──────────────────────────────────────────────────────────────
+def draw_input_panel(win, active):
+    draw_box(win, "INPUT  [F1]", active)
+    h, w = win.getmaxyx()
+    inner_h = h - 3
+    inner_w = w - 2
+    lines = state.input_lines
+
+    # hint bar
+    hint = " ↑↓ scroll  F5 run  F2 sample  F3 clear "
+    safe_addstr(win, 1, 1, hint[:inner_w], curses.color_pair(C_DIM))
+
+    for row in range(inner_h):
+        li = row + state.input_scroll
+        y = row + 2
+        fill_line(win, y)
+        if li < len(lines):
+            line = lines[li]
+            col = curses.color_pair(C_INPUT)
+            # color directives
+            if line.startswith('$'):
+                col = curses.color_pair(C_YELLOW) | curses.A_BOLD
+            safe_addstr(win, y, 1, line[:inner_w], col)
+        # draw cursor
+        cr, cc = state.input_cursor
+        if li == cr and active:
+            cx = min(cc, inner_w - 1)
+            try:
+                ch = lines[cr][cc] if cr < len(lines) and cc < len(lines[cr]) else ' '
+                win.addch(y, 1 + cx, ch, curses.color_pair(C_HEADER) | curses.A_BOLD)
+            except curses.error:
+                pass
+
+# ── PANEL: DEBUG ──────────────────────────────────────────────────────────────
+TAG_COLORS = {
+    "INFO": C_BORDER,
+    "OK":   C_GREEN,
+    "WARN": C_YELLOW,
+    "ERR":  C_RED,
+    "EXEC": C_ORANGE,
+}
+
+def draw_debug_panel(win, active):
+    draw_box(win, "DEBUG LOG  [F2 nav]", active)
+    h, w = win.getmaxyx()
+    inner_h = h - 2
+    inner_w = w - 2
+
+    lines = state.debug_lines
+    # auto-scroll to bottom unless user scrolled
+    max_scroll = max(0, len(lines) - inner_h)
+    if state.debug_scroll > max_scroll:
+        state.debug_scroll = max_scroll
+
+    for row in range(inner_h):
+        li = row + state.debug_scroll
+        y = row + 1
+        fill_line(win, y)
+        if li >= len(lines):
+            continue
+        ts, tag, msg = lines[li]
+
+        x = 1
+        # timestamp
+        safe_addstr(win, y, x, ts, curses.color_pair(C_DIM))
+        x += len(ts) + 1
+
+        # tag badge
+        tag_col = curses.color_pair(TAG_COLORS.get(tag, C_DIM)) | curses.A_BOLD
+        badge = f"[{tag:<4}]"
+        safe_addstr(win, y, x, badge, tag_col)
+        x += len(badge) + 1
+
+        # message
+        remaining = inner_w - x
+        safe_addstr(win, y, x, msg[:remaining], curses.color_pair(C_NORMAL))
+
+# ── PANEL: OUTPUT ─────────────────────────────────────────────────────────────
+def draw_output_panel(win, active):
+    draw_box(win, "OUTPUT  [F3 nav]", active)
+    h, w = win.getmaxyx()
+    inner_h = h - 2
+    inner_w = w - 2
+
+    lines = state.output_lines
+    max_scroll = max(0, len(lines) - inner_h)
+    if state.output_scroll > max_scroll:
+        state.output_scroll = max_scroll
+
+    if not lines:
+        msg = "No output yet — press F5 to run"
+        safe_addstr(win, inner_h // 2, max(1, (inner_w - len(msg)) // 2), msg, curses.color_pair(C_DIM))
+        return
+
+    for row in range(inner_h):
+        li = row + state.output_scroll
+        y = row + 1
+        fill_line(win, y)
+        if li < len(lines):
+            line = lines[li]
+            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)
+
+# ── PANEL: CHART ──────────────────────────────────────────────────────────────
+SPARK_CHARS = " ▁▂▃▄▅▆▇█"
+
+def draw_chart_panel(win, active):
+    draw_box(win, "EXECUTION METRICS  [F4 nav]", active)
+    h, w = win.getmaxyx()
+    inner_h = h - 2
+    inner_w = w - 2
+    y = 1
+
+    # Registers / stats row
+    et = f"{state.exec_time_ms:.3f}ms" if state.exec_time_ms else "--"
+    runs = str(state.run_count)
+    hist = state.run_history
+
+    stats = [
+        ("EXEC TIME", et, C_GREEN),
+        ("RUNS",      runs, C_BORDER),
+        ("LAST RUN",  hist[-1][0] if hist else "--", C_YELLOW),
+    ]
+
+    col_w = (inner_w) // 3
+    for i, (label, val, col) in enumerate(stats):
+        bx = 1 + i * col_w
+        safe_addstr(win, y,   bx, label[:col_w-1], curses.color_pair(C_DIM))
+        safe_addstr(win, y+1, bx, val[:col_w-1],   curses.color_pair(col) | curses.A_BOLD)
+    y += 3
+
+    if y >= inner_h + 1:
+        return
+
+    # separator
+    safe_addstr(win, y, 1, "─" * inner_w, curses.color_pair(C_DIM))
+    y += 1
+
+    # chart title
+    safe_addstr(win, y, 1, " EXEC TIME HISTORY (ms):", curses.color_pair(C_DIM))
+    y += 1
+
+    if not hist:
+        safe_addstr(win, y, 1, " No runs yet", curses.color_pair(C_DIM))
+        return
+
+    # bar chart area
+    chart_h = inner_h - (y - 1)
+    if chart_h < 3:
+        return
+
+    max_ms = max(r[1] for r in hist)
+    bar_area_h = chart_h - 2  # leave rows for labels and scale
+
+    # how many bars fit
+    bar_w   = 5
+    spacing = 1
+    max_bars = max(1, inner_w // (bar_w + spacing))
+    visible  = hist[-max_bars:]
+
+    bar_colors = [C_BORDER, C_GREEN, C_YELLOW, C_ORANGE, C_RED]
+
+    for bi, (label, ms) in enumerate(visible):
+        bar_height = max(1, int((ms / max_ms) * bar_area_h)) if max_ms > 0 else 1
+        bx = 1 + bi * (bar_w + spacing)
+        col = curses.color_pair(bar_colors[bi % len(bar_colors)]) | curses.A_BOLD
+
+        # draw bar from bottom up
+        for brow in range(bar_area_h):
+            ry = y + bar_area_h - 1 - brow
+            if ry >= h - 1:
+                continue
+            if brow < bar_height:
+                safe_addstr(win, ry, bx, "█" * bar_w, col)
+            else:
+                safe_addstr(win, ry, bx, "░" * bar_w, curses.color_pair(C_DIM))
+
+        # value above bar
+        val_str = f"{ms:.1f}"[:bar_w]
+        safe_addstr(win, y - 1, bx, val_str.center(bar_w), curses.color_pair(C_YELLOW))
+
+        # label below
+        lbl = (label.split()[1] if ' ' in label else label)[:bar_w]
+        ly = y + bar_area_h
+        if ly < h - 1:
+            safe_addstr(win, ly, bx, lbl.center(bar_w), curses.color_pair(C_DIM))
+
+    # sparkline summary
+    spark_y = y + bar_area_h + 1
+    if spark_y < h - 1 and len(hist) > 1:
+        max_v = max(r[1] for r in hist)
+        spark = "".join(SPARK_CHARS[min(8, int((r[1]/max_v)*8))] for r in hist[-inner_w+4:])
+        safe_addstr(win, spark_y, 1, "▸ " + spark, curses.color_pair(C_BORDER))
+
+# ── STATUS BAR ────────────────────────────────────────────────────────────────
+STATUS_COLORS = {
+    "READY":   C_GREEN,
+    "RUNNING": C_YELLOW,
+    "HALTED":  C_BORDER,
+    "ERROR":   C_RED,
+    "TIMEOUT": C_RED,
+    "COMPILING": C_YELLOW,
+}
+
+def draw_statusbar(stdscr, H, W):
+    y = H - 1
+    try:
+        stdscr.addstr(y, 0, " " * (W - 1), curses.color_pair(C_HEADER))
+    except curses.error:
+        pass
+
+    sc = STATUS_COLORS.get(state.status, C_NORMAL)
+    left = f" MOS v1.0 │ {state.status} │ Runs: {state.run_count} │ {SOURCE}"
+    right = f"F1:Input F2:Debug F3:Output F4:Chart F5:Run F6:Compile Q:Quit "
+    safe_addstr(stdscr, y, 0, left, curses.color_pair(C_HEADER) | curses.A_BOLD)
+    rx = W - len(right) - 1
+    if rx > len(left):
+        safe_addstr(stdscr, y, rx, right, curses.color_pair(C_HEADER))
+
+def draw_titlebar(stdscr, W):
+    title = " ┌─ MOS ─┐  Multiprogramming OS Simulator  ──  OS_CP.c "
+    compiled_str = "  [COMPILED ✓]" if state.compiled else "  [NOT COMPILED]"
+    full = title + compiled_str
+    col = curses.color_pair(C_HEADER) | curses.A_BOLD
+    try:
+        stdscr.addstr(0, 0, " " * (W - 1), col)
+        stdscr.addstr(0, 0, full[:W-1], col)
+    except curses.error:
+        pass
+
+# ── SAMPLE PROGRAMS ───────────────────────────────────────────────────────────
+SAMPLES = [
+"""$AMJ
+LR10
+GD20
+SR30
+LR30
+PD30
+H
+$DTA
+Hello MOS!  
+$END""",
+"""$AMJ
+GD10
+PD10
+GD20
+PD20
+H
+$DTA
+First Data  
+Second Data 
+$END""",
+"""$AMJ
+LR05
+CR05
+BT07
+PD05
+H
+$DTA
+$END""",
+]
+_sample_idx = [0]
+
+def load_sample():
+    prog = SAMPLES[_sample_idx[0] % len(SAMPLES)].strip()
+    _sample_idx[0] += 1
+    state.input_lines = prog.splitlines()
+    state.input_cursor = [0, 0]
+    state.input_scroll = 0
+    state.add_debug("INFO", f"Sample #{_sample_idx[0]} loaded — press F5 to run")
+
+# ── CURSOR / INPUT NAVIGATION ─────────────────────────────────────────────────
+def ensure_line(r):
+    while len(state.input_lines) <= r:
+        state.input_lines.append("")
+
+def cur_line():
+    r, c = state.input_cursor
+    ensure_line(r)
+    return state.input_lines[r]
+
+def input_key(key, panel_h):
+    r, c = state.input_cursor
+    inner_h = panel_h - 3
+
+    if key == curses.KEY_UP:
+        if r > 0:
+            r -= 1
+            c = min(c, len(state.input_lines[r]) if r < len(state.input_lines) else 0)
+            if r < state.input_scroll:
+                state.input_scroll = r
+    elif key == curses.KEY_DOWN:
+        if r < len(state.input_lines) - 1:
+            r += 1
+            c = min(c, len(state.input_lines[r]))
+            if r >= state.input_scroll + inner_h:
+                state.input_scroll = r - inner_h + 1
+    elif key == curses.KEY_LEFT:
+        if c > 0:
+            c -= 1
+        elif r > 0:
+            r -= 1
+            c = len(state.input_lines[r])
+    elif key == curses.KEY_RIGHT:
+        line = cur_line()
+        if c < len(line):
+            c += 1
+        elif r < len(state.input_lines) - 1:
+            r += 1; c = 0
+    elif key == curses.KEY_HOME:
+        c = 0
+    elif key == curses.KEY_END:
+        c = len(cur_line())
+    elif key in (curses.KEY_BACKSPACE, 127, 8):
+        ensure_line(r)
+        line = state.input_lines[r]
+        if c > 0:
+            state.input_lines[r] = line[:c-1] + line[c:]
+            c -= 1
+        elif r > 0:
+            prev = state.input_lines[r-1]
+            c = len(prev)
+            state.input_lines[r-1] = prev + line
+            del state.input_lines[r]
+            r -= 1
+    elif key == curses.KEY_DC:  # Delete
+        ensure_line(r)
+        line = state.input_lines[r]
+        if c < len(line):
+            state.input_lines[r] = line[:c] + line[c+1:]
+        elif r < len(state.input_lines) - 1:
+            state.input_lines[r] = line + state.input_lines[r+1]
+            del state.input_lines[r+1]
+    elif key in (10, 13):  # Enter
+        ensure_line(r)
+        line = state.input_lines[r]
+        state.input_lines[r] = line[:c]
+        state.input_lines.insert(r+1, line[c:])
+        r += 1; c = 0
+        if r >= state.input_scroll + inner_h:
+            state.input_scroll += 1
+    elif 32 <= key <= 126:  # printable
+        ensure_line(r)
+        line = state.input_lines[r]
+        state.input_lines[r] = line[:c] + chr(key) + line[c:]
+        c += 1
+
+    state.input_cursor = [r, c]
+
+# ── MAIN TUI LOOP ─────────────────────────────────────────────────────────────
+def main(stdscr):
+    curses.curs_set(0)
+    curses.start_color()
+    curses.use_default_colors()
+
+    curses.init_pair(C_NORMAL,   curses.COLOR_WHITE,   -1)
+    curses.init_pair(C_BORDER,   curses.COLOR_CYAN,    -1)
+    curses.init_pair(C_TITLE,    curses.COLOR_CYAN,    -1)
+    curses.init_pair(C_GREEN,    curses.COLOR_GREEN,   -1)
+    curses.init_pair(C_YELLOW,   curses.COLOR_YELLOW,  -1)
+    curses.init_pair(C_RED,      curses.COLOR_RED,     -1)
+    curses.init_pair(C_DIM,      curses.COLOR_WHITE,   -1)
+    curses.init_pair(C_HEADER,   curses.COLOR_BLACK,   curses.COLOR_CYAN)
+    curses.init_pair(C_INPUT,    curses.COLOR_GREEN,   -1)
+    curses.init_pair(C_ORANGE,   curses.COLOR_YELLOW,  -1)
+    curses.init_pair(C_STAT_VAL, curses.COLOR_CYAN,    -1)
+
+    stdscr.nodelay(True)
+    stdscr.keypad(True)
+
+    state.add_debug("INFO", "MOS Terminal UI started")
+    state.add_debug("INFO", f"Looking for {SOURCE} in: {os.getcwd()}")
+    if os.path.exists(SOURCE):
+        state.add_debug("OK",   f"Found {SOURCE} — 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")
+
+    load_sample()
+
+    _running_thread = [None]
+
+    def redraw():
+        try:
+            H, W = stdscr.getmaxyx()
+            if H < 20 or W < 60:
+                stdscr.clear()
+                stdscr.addstr(0, 0, "Terminal too small! Need 60x20 minimum.", curses.A_BOLD)
+                stdscr.refresh()
+                return
+
+            stdscr.erase()
+
+            # Layout: title(1) + panels(H-3) + statusbar(1) + gap(1)
+            content_h = H - 2   # minus title and status
+            half_h    = content_h // 2
+            half_w    = W // 2
+
+            draw_titlebar(stdscr, W)
+            draw_statusbar(stdscr, H, W)
+
+            # Create sub-windows (top-left, top-right, bot-left, bot-right)
+            panels = [
+                stdscr.derwin(half_h,       half_w,       1,       0),
+                stdscr.derwin(half_h,       W - half_w,   1,       half_w),
+                stdscr.derwin(content_h - half_h, half_w, 1+half_h, 0),
+                stdscr.derwin(content_h - half_h, W-half_w, 1+half_h, half_w),
+            ]
+
+            draw_input_panel (panels[0], state.focus == 0)
+            draw_debug_panel (panels[1], state.focus == 1)
+            draw_output_panel(panels[2], state.focus == 2)
+            draw_chart_panel (panels[3], state.focus == 3)
+
+            stdscr.refresh()
+            for p in panels:
+                p.refresh()
+        except curses.error:
+            pass
+
+    last_draw = [0.0]
+
+    while True:
+        now = time.monotonic()
+        if now - last_draw[0] > 0.08:   # ~12fps
+            redraw()
+            last_draw[0] = now
+
+        key = stdscr.getch()
+        if key == -1:
+            time.sleep(0.02)
+            continue
+
+        H, W = stdscr.getmaxyx()
+        half_h = (H - 2) // 2
+
+        # ── GLOBAL KEYS ──
+        if key in (ord('q'), ord('Q')):
+            break
+
+        elif key == curses.KEY_F1:
+            state.focus = 0
+        elif key == curses.KEY_F2:
+            state.focus = 1
+        elif key == curses.KEY_F3:
+            state.focus = 2
+        elif key == curses.KEY_F4:
+            state.focus = 3
+
+        elif key == curses.KEY_F6:
+            # Compile
+            state.status = "COMPILING"
+            state.compiled = False
+            redraw()
+            if compile_source():
+                state.status = "READY"
+            else:
+                state.status = "ERROR"
+
+        elif key == curses.KEY_F5:
+            # Run
+            if not state.compiled:
+                state.add_debug("WARN", "Not compiled — press F6 first")
+            elif _running_thread[0] and _running_thread[0].is_alive():
+                state.add_debug("WARN", "Already running")
+            else:
+                input_text = "\n".join(state.input_lines) + "\n"
+                state.run_count += 1
+                state.output_lines = []
+                state.output_scroll = 0
+                state.debug_scroll = 0
+
+                def done():
+                    redraw()
+
+                t = threading.Thread(target=run_program, args=(input_text, done), daemon=True)
+                _running_thread[0] = t
+                t.start()
+
+        # ── F2 sample key (also mapped to load sample when focus=input) ──
+        elif key == ord('s') or key == ord('S'):
+            if state.focus == 0:
+                load_sample()
+
+        elif key == ord('c') or key == ord('C'):
+            if state.focus == 0:
+                state.input_lines = []
+                state.input_cursor = [0, 0]
+                state.input_scroll = 0
+                state.add_debug("INFO", "Input cleared")
+            elif state.focus == 1:
+                state.debug_lines = []
+            elif state.focus == 2:
+                state.output_lines = []
+
+        # ── FOCUS-SPECIFIC NAVIGATION ──
+        elif state.focus == 0:
+            input_key(key, half_h)
+
+        elif state.focus == 1:
+            if key == curses.KEY_UP:
+                state.debug_scroll = max(0, state.debug_scroll - 1)
+            elif key == curses.KEY_DOWN:
+                state.debug_scroll += 1
+            elif key == curses.KEY_PPAGE:
+                state.debug_scroll = max(0, state.debug_scroll - 10)
+            elif key == curses.KEY_NPAGE:
+                state.debug_scroll += 10
+            elif key == ord('G'):
+                state.debug_scroll = max(0, len(state.debug_lines) - (half_h - 2))
+
+        elif state.focus == 2:
+            if key == curses.KEY_UP:
+                state.output_scroll = max(0, state.output_scroll - 1)
+            elif key == curses.KEY_DOWN:
+                state.output_scroll += 1
+            elif key == curses.KEY_PPAGE:
+                state.output_scroll = max(0, state.output_scroll - 10)
+            elif key == curses.KEY_NPAGE:
+                state.output_scroll += 10
+
+        elif state.focus == 3:
+            pass  # chart panel is display-only
+
+# ── ENTRY POINT ───────────────────────────────────────────────────────────────
+def entry():
+    os.environ.setdefault('TERM', 'xterm-256color')
+    try:
+        curses.wrapper(main)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        # cleanup binary
+        if os.path.exists(BINARY):
+            try: os.unlink(BINARY)
+            except: pass
+    print("\n\033[36mMOS TUI exited.\033[0m Thanks for using the simulator!")
+
+if __name__ == "__main__":
+    entry()

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "mos-tui",
+  "version": "1.0.0",
+  "description": "MOS Terminal UI Launcher",
+  "bin": {
+    "mos": "./bin/mos.js"
+  },
+  "type": "commonjs",
+  "author": "Ayush",
+  "license": "MIT"
+}