@ramusriram/versus 0.1.0

package/src/util/view.js

@@ -0,0 +1,107 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+function shQuote(s) {
+  // Minimal POSIX shell quoting.
+  const str = String(s ?? "");
+  return `'${str.replace(/'/g, `'"'"'`)}'`;
+}
+
+async function ensureDir(dir) {
+  await fs.mkdir(dir, { recursive: true });
+}
+
+export async function writeTextFile(filePath, text) {
+  const dir = path.dirname(filePath);
+  await ensureDir(dir);
+  await fs.writeFile(filePath, String(text ?? ""), "utf8");
+}
+
+export async function pageText(text, { pager } = {}) {
+  const t = String(text ?? "");
+
+  // If we're not in an interactive terminal, just print.
+  if (!process.stdout.isTTY) {
+    process.stdout.write(t);
+    if (!t.endsWith("\n")) process.stdout.write("\n");
+    return { ok: true, mode: "stdout" };
+  }
+
+  const cmd = pager || process.env.PAGER || "less -R";
+
+  const run = (command) =>
+    new Promise((resolve) => {
+      const child = spawn(command, {
+        shell: true,
+        stdio: ["pipe", "inherit", "inherit"],
+      });
+
+      child.on("error", () => resolve(false));
+      child.on("close", () => resolve(true));
+
+      try {
+        child.stdin.write(t);
+        if (!t.endsWith("\n")) child.stdin.write("\n");
+        child.stdin.end();
+      } catch {
+        resolve(false);
+      }
+    });
+
+  const ok = await run(cmd);
+  if (ok) return { ok: true, mode: "pager", pager: cmd };
+
+  // Fallback to `more` if `less` isn't available.
+  const okMore = await run("more");
+  if (okMore) return { ok: true, mode: "pager", pager: "more" };
+
+  // Final fallback: stdout.
+  process.stdout.write(t);
+  if (!t.endsWith("\n")) process.stdout.write("\n");
+  return { ok: false, mode: "stdout" };
+}
+
+export async function editText(text, { editor, filePath, keepFile = false } = {}) {
+  const t = String(text ?? "");
+
+  // Non-interactive: can't open an editor.
+  if (!process.stdout.isTTY) {
+    process.stdout.write(t);
+    if (!t.endsWith("\n")) process.stdout.write("\n");
+    return { ok: true, mode: "stdout" };
+  }
+
+  const editorCmd = editor || process.env.EDITOR || process.env.VISUAL || "nano";
+
+  let temp = false;
+  let fp = filePath;
+  if (!fp) {
+    temp = true;
+    fp = path.join(os.tmpdir(), `versus-prompt-${process.pid}-${Date.now()}.txt`);
+  }
+
+  await writeTextFile(fp, t);
+
+  const cmd = `${editorCmd} ${shQuote(fp)}`;
+
+  const ok = await new Promise((resolve) => {
+    const child = spawn(cmd, {
+      shell: true,
+      stdio: "inherit",
+    });
+    child.on("error", () => resolve(false));
+    child.on("close", () => resolve(true));
+  });
+
+  if (temp && !keepFile) {
+    try {
+      await fs.rm(fp, { force: true });
+    } catch {
+      // ignore
+    }
+  }
+
+  return { ok, mode: "editor", file: fp, editor: editorCmd };
+}

package/test/argv.test.js

@@ -0,0 +1,12 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { hasAnyFlag } from "../src/util/argv.js";
+
+test("hasAnyFlag detects both --flag value and --flag=value", () => {
+  const argv = ["nano", "vim", "--backend=gemini", "--ttl-hours=24", "-d"];
+
+  assert.equal(hasAnyFlag(argv, ["--backend"]), true);
+  assert.equal(hasAnyFlag(argv, ["--ttl-hours"]), true);
+  assert.equal(hasAnyFlag(argv, ["-d", "--debug"]), true);
+  assert.equal(hasAnyFlag(argv, ["--no-cache"]), false);
+});

package/test/markdown.test.js

@@ -0,0 +1,32 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { renderMarkdownToTerminal } from "../src/util/markdown.js";
+import { stripAnsi } from "../src/util/text.js";
+
+test("renderMarkdownToTerminal renders headings without markdown markers", () => {
+  const out = renderMarkdownToTerminal("# Title");
+  assert.equal(stripAnsi(out).trim(), "Title");
+});
+
+test("renderMarkdownToTerminal renders bold without ** markers", () => {
+  const out = renderMarkdownToTerminal("This is **bold**.");
+  const plain = stripAnsi(out);
+  assert.match(plain, /This is bold\./);
+  assert.equal(plain.includes("**"), false);
+});
+
+test("renderMarkdownToTerminal renders a simple markdown table", () => {
+  const md = [
+    "| Feature | nano | vim |",
+    "| --- | --- | --- |",
+    "| Mode | modeless | modal |",
+  ].join("\n");
+
+  const out = stripAnsi(renderMarkdownToTerminal(md));
+  // We don't assert exact layout, just that it becomes an ASCII table.
+  assert.match(out, /\+[-+]+\+/);
+  assert.match(out, /Feature/);
+  assert.match(out, /nano/);
+  assert.match(out, /vim/);
+});

package/test/prompt.test.js

@@ -0,0 +1,20 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { buildPrompt } from "../src/prompt.js";
+
+test("buildPrompt includes both labels and docs blocks", () => {
+  const p = buildPrompt({
+    left: "curl",
+    right: "wget",
+    leftDocs: "LEFTDOC",
+    rightDocs: "RIGHTDOC",
+    level: "beginner",
+    mode: "summary",
+  });
+
+  assert.match(p, /Compare "curl" and "wget"/);
+  assert.match(p, /--- DOCS: curl ---/);
+  assert.match(p, /LEFTDOC/);
+  assert.match(p, /--- DOCS: wget ---/);
+  assert.match(p, /RIGHTDOC/);
+});

package/test/sanitize.test.js

@@ -0,0 +1,16 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { validateTargetForExec } from "../src/util/sanitize.js";
+
+test("validateTargetForExec accepts common commands", () => {
+  assert.equal(validateTargetForExec("curl").ok, true);
+  assert.equal(validateTargetForExec("git fetch").ok, true);
+  assert.equal(validateTargetForExec("docker compose up").ok, true);
+  assert.equal(validateTargetForExec("python3.12").ok, true);
+});
+
+test("validateTargetForExec rejects shell injection chars", () => {
+  assert.equal(validateTargetForExec("ls; rm -rf /").ok, false);
+  assert.equal(validateTargetForExec("$(whoami)").ok, false);
+  assert.equal(validateTargetForExec("cat /etc/passwd").ok, false); // contains '/'
+});

package/test/text.test.js

@@ -0,0 +1,16 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { truncateAtWordBoundary } from "../src/util/text.js";
+
+test("truncateAtWordBoundary does not chop a normal word in half", () => {
+  const text = "hello world this is a test";
+  const out = truncateAtWordBoundary(text, 10, { suffix: "" });
+  // 10 chars would cut "world" in the middle; word-boundary cut should end at "hello".
+  assert.equal(out, "hello");
+});
+
+test("truncateAtWordBoundary falls back to hard cut when no whitespace is available", () => {
+  const text = "supercalifragilisticexpialidocious";
+  const out = truncateAtWordBoundary(text, 5, { suffix: "" });
+  assert.equal(out, "super");
+});

package/test/time.test.js

@@ -0,0 +1,12 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { formatRelativeTime } from "../src/util/time.js";
+
+test("formatRelativeTime formats minutes and hours with rounding down", () => {
+  const now = 1_000_000_000;
+
+  assert.equal(formatRelativeTime(now - 3 * 60 * 1000, now), "3m ago");
+  assert.equal(formatRelativeTime(now - 59 * 60 * 1000, now), "59m ago");
+  assert.equal(formatRelativeTime(now - 2 * 60 * 60 * 1000, now), "2h ago");
+});