zuejs 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 proplayer919
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+# zue
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run start
+```
+
+This project was created using `bun init` in bun v1.3.7. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "zuejs",
+  "version": "0.1.0",
+  "description": "Terminal math editor for context-based symbolic and numeric computations.",
+  "module": "src/index.ts",
+  "type": "module",
+  "private": false,
+  "license": "MIT",
+  "author": "proplayer919",
+  "keywords": [
+    "math",
+    "terminal",
+    "bun",
+    "cli",
+    "symbolic"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/proplayer919/zue.git"
+  },
+  "bugs": {
+    "url": "https://github.com/proplayer919/zue/issues"
+  },
+  "homepage": "https://github.com/proplayer919/zue#readme",
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "start": "bun src/index.ts",
+    "dev": "bun --watch src/index.ts",
+    "check": "tsc --noEmit",
+    "prepublishOnly": "npm run check"
+  },
+  "devDependencies": {
+    "@types/blessed": "^0.1.27",
+    "@types/bun": "latest",
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "blessed": "^0.1.81",
+    "mathjs": "^15.1.1"
+  }
+}

package/src/compute.ts

@@ -0,0 +1,255 @@
+import { evaluate, parse } from "mathjs";
+
+const QUERY_PATTERN = /^(.+)\s*=\s*\?$/;
+const FUNCTION_DEFINITION_PATTERN = /^([A-Za-z_]\w*)\s*\(([^)]*)\)\s*=\s*(.+)$/;
+
+type FunctionDefinition = {
+  params: string[];
+  body: string;
+};
+
+function formatValue(value: unknown): string {
+  if (typeof value === "string") {
+    return value;
+  }
+
+  if (typeof value === "number") {
+    return Number.isInteger(value)
+      ? value.toString()
+      : value.toFixed(10).replace(/\.0+$/, "").replace(/(\.\d*?)0+$/, "$1");
+  }
+
+  return JSON.stringify(value);
+}
+
+function splitTopLevelArgs(input: string): string[] {
+  const args: string[] = [];
+  let current = "";
+  let depth = 0;
+
+  for (const char of input) {
+
+    if (char === "(") {
+      depth += 1;
+    } else if (char === ")") {
+      depth -= 1;
+    }
+
+    if (char === "," && depth === 0) {
+      args.push(current.trim());
+      current = "";
+      continue;
+    }
+
+    current += char;
+  }
+
+  if (current.trim().length > 0) {
+    args.push(current.trim());
+  }
+
+  return args;
+}
+
+function getKnownSymbols(term: string, scope: Record<string, unknown>): Array<[string, unknown]> {
+  const node = parse(term);
+  const symbols = new Set<string>();
+
+  node.traverse((child) => {
+    if (child.type === "SymbolNode" && "name" in child && typeof child.name === "string") {
+      symbols.add(child.name);
+    }
+  });
+
+  return [...symbols]
+    .filter((name) => Object.hasOwn(scope, name))
+    .map((name) => [name, scope[name]])
+    .filter((entry): entry is [string, unknown] => entry[1] !== undefined);
+}
+
+function buildFunctionWorkingSteps(
+  term: string,
+  scope: Record<string, unknown>,
+  functions: Map<string, FunctionDefinition>
+): string[] {
+  const directCall = /^([A-Za-z_]\w*)\s*\((.*)\)$/.exec(term);
+  if (!directCall) {
+    return [];
+  }
+
+  const fnName = (directCall[1] ?? "").trim();
+  const argsRaw = (directCall[2] ?? "").trim();
+  const definition = functions.get(fnName);
+  if (!definition) {
+    return [];
+  }
+
+  const args = argsRaw.length === 0 ? [] : splitTopLevelArgs(argsRaw);
+  if (args.length !== definition.params.length) {
+    return [];
+  }
+
+  let substituted = definition.body;
+  const bindings: string[] = [];
+
+  for (let index = 0; index < definition.params.length; index += 1) {
+    const param = definition.params[index] ?? "";
+    const arg = args[index] ?? "";
+    bindings.push(`${param} = ${arg}`);
+    substituted = substituted.replaceAll(new RegExp(String.raw`\b${param}\b`, "g"), `(${arg})`);
+  }
+
+  const steps: string[] = [];
+  steps.push(
+    `  2) Function rule: ${fnName}(${definition.params.join(", ")}) = ${definition.body}`,
+    `  3) Substitute arguments: ${bindings.join(", ")}`,
+    `  4) Expanded form: ${substituted}`
+  );
+
+  try {
+    const expandedValue = evaluate(substituted, scope);
+    steps.push(`  5) Evaluate expanded form: ${formatValue(expandedValue)}`);
+  } catch {
+    // If expanded form can't be directly evaluated, keep earlier steps.
+  }
+
+  return steps;
+}
+
+function buildGenericWorkingSteps(term: string, scope: Record<string, unknown>): string[] {
+  const known = getKnownSymbols(term, scope);
+  if (known.length === 0) {
+    return [];
+  }
+
+  const substitutions = known
+    .map(([name, value]) => `${name} = ${formatValue(value)}`)
+    .join(", ");
+
+  let substituted = term;
+  for (const [name, value] of known) {
+    if (typeof value === "number" || typeof value === "string") {
+      substituted = substituted.replaceAll(new RegExp(String.raw`\b${name}\b`, "g"), `(${formatValue(value)})`);
+    }
+  }
+
+  return [`  2) Substitute known values: ${substitutions}`, `  3) Evaluate: ${substituted}`];
+}
+
+export function computeInput(text: string): string {
+  const lines = text.split(/\r?\n/);
+  const scope: Record<string, unknown> = {};
+  const functions = new Map<string, FunctionDefinition>();
+  const contextLogs: string[] = [];
+  const resultLogs: string[] = [];
+  let contextCount = 0;
+  let queryCount = 0;
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const raw = lines[index] ?? "";
+    const line = raw.trim();
+    const lineNo = index + 1;
+
+    if (line.length === 0 || line.startsWith("#") || line.startsWith("//")) {
+      continue;
+    }
+
+    const queryMatch = new RegExp(QUERY_PATTERN).exec(line);
+    if (queryMatch) {
+      queryCount += 1;
+      const term = (queryMatch[1] ?? "").trim();
+
+      if (!term) {
+        resultLogs.push(`[ERR] Line ${lineNo}: empty query`, "  Use format: term = ?", "");
+        continue;
+      }
+
+      try {
+        const functionWorking = buildFunctionWorkingSteps(term, scope, functions);
+        const genericWorking = functionWorking.length > 0 ? [] : buildGenericWorkingSteps(term, scope);
+        const value = evaluate(term, scope);
+        let resultStepNumber = "2";
+        if (genericWorking.length > 0) {
+          resultStepNumber = "4";
+        }
+        if (functionWorking.length > 0) {
+          resultStepNumber = "6";
+        }
+        resultLogs.push(
+          `[OK] Line ${lineNo}: ${term} = ?`,
+          "  1) Read term using the current context",
+          ...functionWorking,
+          ...genericWorking,
+          `  ${resultStepNumber}) Result: ${formatValue(value)}`,
+          ""
+        );
+      } catch (error) {
+        resultLogs.push(
+          `[ERR] Line ${lineNo}: ${term} = ?`,
+          `  ${error instanceof Error ? error.message : "Unable to evaluate query"}`,
+          ""
+        );
+      }
+
+      continue;
+    }
+
+    contextCount += 1;
+    try {
+      const functionMatch = new RegExp(FUNCTION_DEFINITION_PATTERN).exec(line);
+      if (functionMatch) {
+        const name = (functionMatch[1] ?? "").trim();
+        const paramsRaw = (functionMatch[2] ?? "").trim();
+        const body = (functionMatch[3] ?? "").trim();
+        const params = paramsRaw
+          .split(",")
+          .map((item) => item.trim())
+          .filter((item) => item.length > 0);
+
+        functions.set(name, {
+          params,
+          body,
+        });
+      }
+
+      evaluate(line, scope);
+      contextLogs.push(`- L${lineNo}: ${line}`);
+    } catch (error) {
+      resultLogs.push(
+        `[ERR] Line ${lineNo}: ${line}`,
+        `  ${error instanceof Error ? error.message : "Invalid context statement"}`,
+        ""
+      );
+    }
+  }
+
+  if (contextCount === 0 && queryCount === 0) {
+    return [
+      "No input to compute.",
+      "",
+      "Use one shared context:",
+      "  a = 8",
+      "  f(x) = x^2 + a",
+      "  f(3) = ?",
+    ].join("\n");
+  }
+
+  const output: string[] = [];
+  output.push(`Context statements: ${contextCount}`, `Queries: ${queryCount}`);
+
+  if (contextLogs.length > 0) {
+    output.push("", "Context", ...contextLogs);
+  }
+
+  if (queryCount === 0) {
+    output.push("", "No query lines found.", "Add one or more lines like: term = ?");
+
+    if (resultLogs.length > 0) {
+      output.push("", "Errors", ...resultLogs);
+    }
+  } else {
+    output.push("", "Results", ...resultLogs);
+  }
+
+  return output.join("\n").trimEnd();
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+import { runTerminalApp } from "./ui";
+
+runTerminalApp();

package/src/ui.ts

@@ -0,0 +1,215 @@
+import blessed from "blessed";
+import { spawnSync } from "node:child_process";
+import { computeInput } from "./compute";
+
+const DEFAULT_EDITOR_VALUE = "a = 8\nb = 3 * a\nf(x) = x^2 + b\na + b = ?\nf(4) = ?";
+
+export function runTerminalApp(): void {
+  const shouldManageFlowControl = process.platform !== "win32";
+  if (shouldManageFlowControl) {
+    spawnSync("stty", ["-ixon"], { stdio: "inherit" });
+  }
+
+  const screen = blessed.screen({
+    smartCSR: true,
+    title: "Zue Math Editor",
+    fullUnicode: true,
+  });
+
+  const editor = blessed.textarea({
+    parent: screen,
+    label: " Math Editor ",
+    top: 0,
+    left: 0,
+    width: "100%",
+    height: "100%-3",
+    border: "line",
+    scrollbar: {
+      ch: " ",
+    },
+    inputOnFocus: true,
+    mouse: true,
+    keys: true,
+    vi: false,
+    padding: {
+      left: 1,
+      right: 1,
+    },
+    style: {
+      border: {
+        fg: "cyan",
+      },
+      focus: {
+        border: {
+          fg: "green",
+        },
+      },
+    },
+    value: DEFAULT_EDITOR_VALUE,
+  });
+
+  (editor as unknown as { readEditor: (_callback?: unknown) => void }).readEditor =
+    (_callback?: unknown): void => {
+      // no-op
+    };
+
+  const results = blessed.box({
+    parent: screen,
+    label: " Results ",
+    top: 0,
+    left: 0,
+    width: "100%",
+    height: "100%-3",
+    border: "line",
+    scrollable: true,
+    alwaysScroll: true,
+    hidden: true,
+    mouse: true,
+    keys: false,
+    tags: false,
+    scrollbar: {
+      ch: " ",
+    },
+    padding: {
+      left: 1,
+      right: 1,
+    },
+    style: {
+      border: {
+        fg: "magenta",
+      },
+      focus: {
+        border: {
+          fg: "green",
+        },
+      },
+    },
+  });
+
+  const status = blessed.box({
+    parent: screen,
+    bottom: 2,
+    left: 0,
+    width: "100%",
+    height: 1,
+    tags: false,
+    style: {
+      fg: "black",
+      bg: "white",
+    },
+    content: " Mode: Editor | Define context, then compute term = ? with Ctrl+E ",
+  });
+
+  blessed.box({
+    parent: screen,
+    bottom: 0,
+    left: 0,
+    width: "100%",
+    height: 2,
+    tags: false,
+    style: {
+      fg: "black",
+      bg: "green",
+    },
+    content:
+      " ^E Compute   ^R Results   ^T Editor   ^↑/↓ Scroll Results   ^Q Quit\n Use shared context: defs/functions, then term = ? on one or more lines ",
+  });
+
+  let mode: "editor" | "results" = "editor";
+
+  const quitApp = (): void => {
+    if (shouldManageFlowControl) {
+      spawnSync("stty", ["ixon"], { stdio: "inherit" });
+    }
+    screen.destroy();
+    process.exit(0);
+  };
+
+  const setStatus = (message: string): void => {
+    status.setContent(` ${message} `);
+  };
+
+  const showEditor = (): void => {
+    mode = "editor";
+    results.hide();
+    editor.show();
+    editor.focus();
+    setStatus("Mode: Editor | Define context + use term = ?, then Ctrl+E");
+    screen.render();
+  };
+
+  const showResults = (): void => {
+    mode = "results";
+    editor.hide();
+    results.show();
+    results.focus();
+    setStatus("Mode: Results | Scroll with Up/Down");
+    screen.render();
+  };
+
+  const computeAndShowResults = (): void => {
+    const input = editor.getValue();
+    const output = computeInput(input);
+    results.setContent(output);
+    results.setScroll(0);
+    showResults();
+  };
+
+  screen.key(["C-e"], () => {
+    computeAndShowResults();
+  });
+
+  editor.key(["C-e"], () => {
+    computeAndShowResults();
+  });
+
+  screen.key(["C-r"], () => {
+    showResults();
+  });
+
+  screen.key(["C-t"], () => {
+    showEditor();
+  });
+
+  screen.key(["up"], () => {
+    if (mode === "results") {
+      results.scroll(-1);
+      screen.render();
+    }
+  });
+
+  screen.key(["down"], () => {
+    if (mode === "results") {
+      results.scroll(1);
+      screen.render();
+    }
+  });
+
+  screen.key(["pageup"], () => {
+    if (mode === "results") {
+      results.scroll(-10);
+      screen.render();
+    }
+  });
+
+  screen.key(["pagedown"], () => {
+    if (mode === "results") {
+      results.scroll(10);
+      screen.render();
+    }
+  });
+
+  const quitKeys = ["C-q", "C-c", "escape"];
+  screen.key(quitKeys, quitApp);
+  editor.key(quitKeys, quitApp);
+  results.key(quitKeys, quitApp);
+
+  process.once("exit", () => {
+    if (shouldManageFlowControl) {
+      spawnSync("stty", ["ixon"], { stdio: "inherit" });
+    }
+  });
+
+  showEditor();
+  screen.render();
+}