tmux-ide 1.0.0

package/src/init.js

@@ -0,0 +1,81 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve, basename } from "node:path";
+import { writeFileSync } from "node:fs";
+import { detectStack, suggestConfig } from "./detect.js";
+import { printLayout } from "./lib/output.js";
+
+export async function init({ template, json } = {}) {
+  const dir = process.cwd();
+  const configPath = resolve(dir, "ide.yml");
+
+  if (existsSync(configPath)) {
+    if (json) {
+      console.error(JSON.stringify({ error: "ide.yml already exists", code: "EXISTS" }));
+    } else {
+      console.error("ide.yml already exists in this directory");
+    }
+    process.exit(1);
+  }
+
+  // If a specific template is requested, use it
+  if (template) {
+    const templatePath = resolve(import.meta.dirname, "..", "templates", `${template}.yml`);
+    if (!existsSync(templatePath)) {
+      if (json) {
+        console.error(JSON.stringify({ error: `Template "${template}" not found`, code: "NOT_FOUND" }));
+      } else {
+        console.error(`Template "${template}" not found. Available: default, nextjs, convex, vite, python, go, agent-team, agent-team-nextjs, agent-team-monorepo`);
+      }
+      process.exit(1);
+    }
+
+    let content = readFileSync(templatePath, "utf-8");
+    const name = basename(dir);
+    content = content.replace(/^name: .+/m, `name: ${name}`);
+    writeFileSync(configPath, content);
+
+    if (json) {
+      console.log(JSON.stringify({ created: true, template, name }));
+    } else {
+      console.log(`Created ide.yml from "${template}" template for "${name}"`);
+      const yaml = (await import("js-yaml")).default;
+      printLayout(yaml.load(content));
+    }
+    return;
+  }
+
+  // Smart detection
+  const detected = detectStack(dir);
+  const name = basename(dir);
+
+  if (detected.frameworks.length > 0) {
+    // Use detected stack to generate config
+    const config = suggestConfig(dir, detected);
+    const yaml = (await import("js-yaml")).default;
+    writeFileSync(configPath, yaml.dump(config, { lineWidth: -1, noRefs: true, quotingType: '"' }));
+
+    const desc = detected.frameworks.join(" + ");
+    if (json) {
+      console.log(JSON.stringify({ created: true, detected: detected.frameworks, name }));
+    } else {
+      console.log(`Detected ${desc}. Created ide.yml for "${name}".`);
+      printLayout(config);
+      console.log("Edit it to customize, then run: tmux-ide");
+    }
+  } else {
+    // Fallback to default template
+    const templatePath = resolve(import.meta.dirname, "..", "templates", "default.yml");
+    let content = readFileSync(templatePath, "utf-8");
+    content = content.replace(/^name: .+/m, `name: ${name}`);
+    writeFileSync(configPath, content);
+
+    if (json) {
+      console.log(JSON.stringify({ created: true, template: "default", name }));
+    } else {
+      console.log(`Created ide.yml for "${name}"`);
+      const yaml = (await import("js-yaml")).default;
+      printLayout(yaml.load(content));
+      console.log("Edit it to configure your workspace, then run: tmux-ide");
+    }
+  }
+}

package/src/integration.test.js

@@ -0,0 +1,94 @@
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { execSync, execFileSync } from "node:child_process";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+// Skip entire suite if tmux is not available
+let tmuxAvailable = false;
+try {
+  execSync("tmux -V", { stdio: "ignore" });
+  tmuxAvailable = true;
+} catch {}
+
+describe("integration", { skip: !tmuxAvailable && "tmux not available" }, () => {
+  let tmpDir;
+  const session = "tmux-ide-test-integration";
+  const cli = join(import.meta.dirname, "..", "bin", "cli.js");
+
+  function run(args) {
+    return execFileSync("node", [cli, ...args], { cwd: tmpDir, encoding: "utf-8" });
+  }
+
+  function runJSON(args) {
+    return JSON.parse(run([...args, "--json"]));
+  }
+
+  function killSession() {
+    try {
+      execSync(`tmux kill-session -t "${session}"`, { stdio: "ignore" });
+    } catch {}
+  }
+
+  function createSession() {
+    execSync(`tmux new-session -d -s "${session}" -x 80 -y 24`, { stdio: "ignore" });
+  }
+
+  before(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "tmux-ide-test-"));
+    writeFileSync(
+      join(tmpDir, "ide.yml"),
+      `name: ${session}\nrows:\n  - panes:\n      - title: Shell\n`
+    );
+  });
+
+  after(() => {
+    killSession();
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("status --json reports not running when no session exists", () => {
+    killSession();
+    const result = runJSON(["status"]);
+    assert.strictEqual(result.running, false);
+  });
+
+  it("status --json reports running after session is created", () => {
+    killSession();
+    createSession();
+    const result = runJSON(["status"]);
+    assert.strictEqual(result.running, true);
+    killSession();
+  });
+
+  it("stop --json kills a running session", () => {
+    createSession();
+    run(["stop"]);
+    // Verify it's gone
+    const result = runJSON(["status"]);
+    assert.strictEqual(result.running, false);
+  });
+
+  it("validate --json reports valid for our test config", () => {
+    const result = runJSON(["validate"]);
+    assert.strictEqual(result.valid, true);
+    assert.deepStrictEqual(result.errors, []);
+  });
+
+  it("doctor --json passes checks", () => {
+    const result = runJSON(["doctor"]);
+    assert.strictEqual(result.ok, true);
+  });
+
+  it("config --json dumps config", () => {
+    const result = runJSON(["config"]);
+    assert.strictEqual(result.name, session);
+    assert.ok(Array.isArray(result.rows));
+  });
+
+  it("ls --json returns sessions list", () => {
+    const result = runJSON(["ls"]);
+    assert.ok(Array.isArray(result.sessions));
+  });
+});

package/src/launch.js

@@ -0,0 +1,238 @@
+import { resolve } from "node:path";
+import { execSync } from "node:child_process";
+import { readConfig, getSessionName } from "./lib/yaml-io.js";
+import { computeSizes, toSplitPercents } from "./lib/sizes.js";
+
+function tmux(cmd) {
+  execSync(`tmux ${cmd}`, { stdio: "inherit" });
+}
+
+function tmuxQuiet(cmd) {
+  try {
+    execSync(`tmux ${cmd}`, { stdio: "ignore" });
+  } catch {}
+}
+
+export async function launch(targetDir) {
+  const dir = resolve(targetDir ?? ".");
+
+  let config;
+  try {
+    ({ config } = readConfig(dir));
+  } catch {
+    console.error(`No ide.yml found in ${dir}. Run "tmux-ide init" to create one.`);
+    process.exit(1);
+  }
+
+  // Validate config structure before building tmux session
+  if (!Array.isArray(config.rows) || config.rows.length === 0) {
+    console.error("Invalid ide.yml: 'rows' must be a non-empty array");
+    console.error("Run: tmux-ide validate");
+    process.exit(1);
+  }
+  for (const row of config.rows) {
+    if (!Array.isArray(row.panes) || row.panes.length === 0) {
+      console.error("Invalid ide.yml: each row must have a non-empty 'panes' array");
+      console.error("Run: tmux-ide validate");
+      process.exit(1);
+    }
+  }
+
+  const session = config.name ?? getSessionName(dir);
+  const rows = config.rows;
+  const theme = config.theme ?? {};
+  const team = config.team ?? null;
+
+  // Run before hook
+  if (config.before) {
+    console.log(`Running: ${config.before}`);
+    try {
+      execSync(config.before, { cwd: dir, stdio: "inherit" });
+    } catch (e) {
+      console.error(`"before" hook failed: ${config.before}`);
+      process.exit(1);
+    }
+  }
+
+  // If session already exists, just attach to it
+  try {
+    execSync(`tmux has-session -t "${session}"`, { stdio: "ignore" });
+    console.log(`Session "${session}" is already running. Attaching...`);
+    tmux(`attach -t "${session}"`);
+    return;
+  } catch {
+    // Session doesn't exist, continue with creation
+  }
+
+  // Get terminal dimensions
+  const cols = process.stdout.columns ?? 200;
+  const lines = process.stdout.rows ?? 50;
+
+  // Create session with first pane
+  tmux(`new-session -d -s "${session}" -c "${dir}" -x ${cols} -y ${lines}`);
+
+  // Set agent teams env var if team config is present
+  if (team) {
+    tmux(`set-environment -t "${session}" CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS 1`);
+  }
+
+  // Compute row sizes and convert to tmux split percentages
+  const rowSizes = computeSizes(rows);
+  const rowSplitPercents = toSplitPercents(rowSizes);
+
+  // Phase 1: Create all rows (vertical splits) BEFORE any horizontal splits.
+  // This ensures each row spans the full window width.
+  const rowPaneIndices = [0]; // rowPaneIndices[i] = tmux pane index for row i
+  let nextPaneIndex = 1;
+
+  for (let rowIdx = 1; rowIdx < rows.length; rowIdx++) {
+    const splitFrom = rowPaneIndices[rowIdx - 1];
+    tmux(
+      `split-window -t "${session}:0.${splitFrom}" -v -c "${dir}" -p ${rowSplitPercents[rowIdx - 1]}`
+    );
+    rowPaneIndices.push(nextPaneIndex);
+    nextPaneIndex++;
+  }
+
+  // Phase 2: Create panes within each row (horizontal splits).
+  // paneMap[row][col] = tmux pane index
+  const paneMap = [];
+  const firstPanesOfRows = new Set(rowPaneIndices);
+
+  for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+    const row = rows[rowIdx];
+    const panes = row.panes ?? [];
+    const rowPane = rowPaneIndices[rowIdx];
+    const rowPanes = [rowPane];
+
+    // Compute pane sizes within this row and convert to split percentages
+    const paneSizes = computeSizes(panes);
+    const paneSplitPercents = toSplitPercents(paneSizes);
+
+    // Split this row's panes horizontally
+    for (let paneIdx = 1; paneIdx < panes.length; paneIdx++) {
+      const pane = panes[paneIdx];
+      const targetPane = rowPanes[paneIdx - 1];
+
+      // Per-pane working directory
+      const paneDir = pane.dir ? resolve(dir, pane.dir) : dir;
+
+      tmux(
+        `split-window -t "${session}:0.${targetPane}" -h -c "${paneDir}" -p ${paneSplitPercents[paneIdx - 1]}`
+      );
+      rowPanes.push(nextPaneIndex);
+      nextPaneIndex++;
+    }
+
+    paneMap.push(rowPanes);
+  }
+
+  // Build the command for a pane, transforming claude commands for team roles
+  function buildCommand(p) {
+    if (!p.command) return null;
+    if (!team || !p.role) return p.command;
+
+    if (p.role === "lead") {
+      return `claude --team "${team.name}"`;
+    } else if (p.role === "teammate") {
+      let cmd = `claude --teammate-mode in-process --team "${team.name}"`;
+      if (p.task) {
+        cmd += ` --task "${p.task.replace(/"/g, '\\"')}"`;
+      }
+      return cmd;
+    }
+    return p.command;
+  }
+
+  // Send commands, set titles, handle env/focus/dir for first panes
+  // Two-pass approach for teams: lead + non-teammates first, then teammates
+  let focusPane = paneMap[0][0];
+  const teammateCommands = [];
+
+  for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+    const row = rows[rowIdx];
+    const panes = row.panes ?? [];
+    for (let paneIdx = 0; paneIdx < panes.length; paneIdx++) {
+      const p = panes[paneIdx];
+      const tmuxPane = paneMap[rowIdx][paneIdx];
+
+      if (p.title) {
+        tmux(`select-pane -t "${session}:0.${tmuxPane}" -T "${p.title}"`);
+      }
+
+      // Per-pane directory for first panes of each row (created with project root)
+      if (p.dir && firstPanesOfRows.has(tmuxPane)) {
+        const paneDir = resolve(dir, p.dir);
+        tmux(`send-keys -t "${session}:0.${tmuxPane}" "cd ${paneDir}" C-m`);
+      }
+
+      // Environment variables
+      if (p.env && typeof p.env === "object") {
+        for (const [key, val] of Object.entries(p.env)) {
+          tmux(`send-keys -t "${session}:0.${tmuxPane}" "export ${key}=${val}" C-m`);
+        }
+      }
+
+      const cmd = buildCommand(p);
+      if (cmd) {
+        if (team && p.role === "teammate") {
+          // Defer teammate launches to second pass
+          teammateCommands.push({ pane: tmuxPane, cmd });
+        } else {
+          tmux(`send-keys -t "${session}:0.${tmuxPane}" "${cmd}" C-m`);
+        }
+      }
+
+      if (p.focus) {
+        focusPane = tmuxPane;
+      }
+    }
+  }
+
+  // Second pass: launch teammates after a brief delay for the lead to initialize
+  if (teammateCommands.length > 0) {
+    execSync("sleep 2");
+    for (const { pane: p, cmd } of teammateCommands) {
+      tmux(`send-keys -t "${session}:0.${p}" "${cmd}" C-m`);
+    }
+  }
+
+  // Apply styling
+  const accent = theme.accent ?? "colour75";
+  const border = theme.border ?? "colour238";
+  const bg = theme.bg ?? "colour235";
+  const fg = theme.fg ?? "colour248";
+
+  tmux(`set-option -t "${session}" pane-border-status top`);
+  tmux(
+    `set-option -t "${session}" pane-border-format " #{?pane_active,#[bold]▸,·} #T "`
+  );
+  tmux(`set-option -t "${session}" pane-border-style "fg=${border}"`);
+  tmux(`set-option -t "${session}" pane-active-border-style "fg=${accent}"`);
+
+  tmux(`set-option -t "${session}" status-style "bg=${bg},fg=${fg}"`);
+  tmux(
+    `set-option -t "${session}" status-left "#[fg=colour0,bg=${accent},bold]  ${session.toUpperCase()} IDE #[default] "`
+  );
+  tmux(`set-option -t "${session}" status-left-length 30`);
+  tmux(
+    `set-option -t "${session}" status-right "#[fg=colour243]%H:%M #[fg=${accent}]│ #[fg=${fg}]%b %d "`
+  );
+  tmux(`set-option -t "${session}" status-justify centre`);
+  tmux(
+    `set-option -t "${session}" window-status-current-format "#[fg=${accent},bold]●"`
+  );
+  tmux(
+    `set-option -t "${session}" window-status-format "#[fg=${border}]○"`
+  );
+
+  // Focus the correct pane
+  tmux(`select-pane -t "${session}:0.${focusPane}"`);
+
+  // Launch summary
+  const totalPanes = rows.reduce((sum, r) => sum + (r.panes?.length ?? 0), 0);
+  console.log(`Starting "${session}" (${rows.length} row${rows.length === 1 ? "" : "s"}, ${totalPanes} pane${totalPanes === 1 ? "" : "s"})...`);
+
+  // Attach
+  tmux(`attach -t "${session}"`);
+}

package/src/lib/dot-path.js

@@ -0,0 +1,16 @@
+export function getByPath(obj, path) {
+  return path.split(".").reduce((o, k) => o?.[k], obj);
+}
+
+export function setByPath(obj, path, value) {
+  const keys = path.split(".");
+  const last = keys.pop();
+  let i = 0;
+  const target = keys.reduce((o, k) => {
+    const nextKey = keys[i + 1] ?? last;
+    if (o[k] === undefined) o[k] = /^\d+$/.test(nextKey) ? [] : {};
+    i++;
+    return o[k];
+  }, obj);
+  target[last] = value;
+}

package/src/lib/dot-path.test.js

@@ -0,0 +1,67 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { getByPath, setByPath } from "./dot-path.js";
+
+describe("getByPath", () => {
+  it("gets a top-level key", () => {
+    assert.strictEqual(getByPath({ name: "test" }, "name"), "test");
+  });
+
+  it("gets a nested value", () => {
+    const obj = { rows: [{ panes: [{ title: "Shell" }] }] };
+    assert.strictEqual(getByPath(obj, "rows.0.panes.0.title"), "Shell");
+  });
+
+  it("returns undefined for non-existent path", () => {
+    assert.strictEqual(getByPath({}, "a.b.c"), undefined);
+  });
+
+  it("returns undefined for partially valid path", () => {
+    assert.strictEqual(getByPath({ a: { b: 1 } }, "a.b.c"), undefined);
+  });
+});
+
+describe("setByPath", () => {
+  it("sets a top-level key", () => {
+    const obj = {};
+    setByPath(obj, "name", "test");
+    assert.deepStrictEqual(obj, { name: "test" });
+  });
+
+  it("sets a nested value", () => {
+    const obj = { rows: [{ panes: [{ title: "old" }] }] };
+    setByPath(obj, "rows.0.panes.0.title", "new");
+    assert.strictEqual(obj.rows[0].panes[0].title, "new");
+  });
+
+  it("creates arrays for numeric keys", () => {
+    const obj = {};
+    setByPath(obj, "rows.0.title", "test");
+    assert.ok(Array.isArray(obj.rows));
+    assert.strictEqual(obj.rows[0].title, "test");
+  });
+
+  it("creates objects for string keys", () => {
+    const obj = {};
+    setByPath(obj, "a.b.c", "val");
+    assert.deepStrictEqual(obj, { a: { b: { c: "val" } } });
+  });
+
+  it("handles duplicate segment values (regression)", () => {
+    // Bug: rows.0.panes.0 — both "0" segments caused indexOf to return
+    // the same index, breaking the lookahead for array vs object creation
+    const obj = {};
+    setByPath(obj, "rows.0.panes.0", "value");
+    assert.ok(Array.isArray(obj.rows), "rows should be an array");
+    assert.ok(Array.isArray(obj.rows[0].panes), "panes should be an array");
+    assert.strictEqual(obj.rows[0].panes[0], "value");
+  });
+
+  it("handles deeper duplicate segments", () => {
+    const obj = {};
+    setByPath(obj, "a.0.b.0.c", "deep");
+    assert.ok(Array.isArray(obj.a));
+    assert.ok(Array.isArray(obj.a[0].b));
+    assert.strictEqual(obj.a[0].b[0].c, "deep");
+  });
+});

package/src/lib/output.js

@@ -0,0 +1,72 @@
+export function output(data, { json } = {}) {
+  if (json) {
+    console.log(JSON.stringify(data, null, 2));
+  } else if (typeof data === "string") {
+    console.log(data);
+  } else {
+    console.log(data);
+  }
+}
+
+export function printLayout(config) {
+  const INNER = 40;
+  const rows = config.rows ?? [];
+  if (rows.length === 0) return;
+
+  for (let r = 0; r < rows.length; r++) {
+    const panes = rows[r].panes ?? [];
+    const count = panes.length || 1;
+    const widths = [];
+    let remaining = INNER;
+    for (let i = 0; i < count; i++) {
+      const w = i < count - 1 ? Math.floor(INNER / count) : remaining;
+      widths.push(w);
+      remaining -= w;
+    }
+
+    // Top border or mid divider
+    if (r === 0) {
+      let top = "  ┌";
+      for (let i = 0; i < count; i++) {
+        top += "─".repeat(widths[i]);
+        top += i < count - 1 ? "┬" : "┐";
+      }
+      console.log(top);
+    } else {
+      console.log("  ├" + "─".repeat(INNER + count - 1) + "┤");
+    }
+
+    // Content line
+    const sizeLabel = rows[r].size ?? "";
+    let line = "  │";
+    for (let i = 0; i < count; i++) {
+      const title = panes[i]?.title ?? "";
+      const w = widths[i];
+      const pad = Math.max(0, w - title.length);
+      const left = Math.floor(pad / 2);
+      const right = pad - left;
+      line += " ".repeat(left) + title + " ".repeat(right) + "│";
+    }
+    if (sizeLabel) line += "  " + sizeLabel;
+    console.log(line);
+
+    // Bottom border (last row only)
+    if (r === rows.length - 1) {
+      let bot = "  └";
+      for (let i = 0; i < count; i++) {
+        bot += "─".repeat(widths[i]);
+        bot += i < count - 1 ? "┴" : "┘";
+      }
+      console.log(bot);
+    }
+  }
+}
+
+export function outputError(message, code, { json } = {}) {
+  if (json) {
+    console.error(JSON.stringify({ error: message, code }, null, 2));
+  } else {
+    console.error(message);
+  }
+  process.exit(code ?? 1);
+}

package/src/lib/sizes.js

@@ -0,0 +1,36 @@
+/**
+ * Compute absolute sizes for items where some have explicit sizes and others don't.
+ * Items with `size` (e.g. "70%") keep their value; remaining space is split equally
+ * among items without a size.
+ */
+export function computeSizes(items) {
+  let claimed = 0;
+  let unclaimed = 0;
+  for (const item of items) {
+    if (item.size) {
+      claimed += parseFloat(item.size);
+    } else {
+      unclaimed++;
+    }
+  }
+  const remaining = Math.max(0, 100 - claimed);
+  const defaultSize = unclaimed > 0 ? remaining / unclaimed : 0;
+  return items.map((item) => (item.size ? parseFloat(item.size) : defaultSize));
+}
+
+/**
+ * Convert absolute sizes (e.g. [70, 30]) to tmux split percentages for sequential splits.
+ * Returns array of -p values (one per split after the first item).
+ *
+ * Each tmux split divides the current pane. The percentage given to -p is
+ * the portion allocated to the NEW (bottom/right) pane.
+ */
+export function toSplitPercents(sizes) {
+  const percents = [];
+  for (let i = 1; i < sizes.length; i++) {
+    const remaining = sizes.slice(i - 1).reduce((a, b) => a + b, 0);
+    const topShare = sizes[i - 1];
+    percents.push(Math.round(((remaining - topShare) / remaining) * 100));
+  }
+  return percents;
+}

package/src/lib/sizes.test.js

@@ -0,0 +1,74 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { computeSizes, toSplitPercents } from "./sizes.js";
+
+describe("computeSizes", () => {
+  it("distributes remaining space to items without size", () => {
+    const result = computeSizes([{ size: "70%" }, {}]);
+    assert.deepStrictEqual(result, [70, 30]);
+  });
+
+  it("passes through all explicit sizes", () => {
+    const result = computeSizes([{ size: "60%" }, { size: "40%" }]);
+    assert.deepStrictEqual(result, [60, 40]);
+  });
+
+  it("splits equally when no sizes specified", () => {
+    const result = computeSizes([{}, {}, {}]);
+    const expected = [100 / 3, 100 / 3, 100 / 3];
+    assert.deepStrictEqual(result, expected);
+  });
+
+  it("handles 3 items with mixed sizes", () => {
+    const result = computeSizes([{ size: "60%" }, { size: "25%" }, {}]);
+    assert.deepStrictEqual(result, [60, 25, 15]);
+  });
+
+  it("handles single item without size", () => {
+    const result = computeSizes([{}]);
+    assert.deepStrictEqual(result, [100]);
+  });
+
+  it("handles single item with size", () => {
+    const result = computeSizes([{ size: "50%" }]);
+    assert.deepStrictEqual(result, [50]);
+  });
+
+  it("handles empty array", () => {
+    const result = computeSizes([]);
+    assert.deepStrictEqual(result, []);
+  });
+
+  it("clamps remaining to zero when sizes exceed 100", () => {
+    const result = computeSizes([{ size: "80%" }, { size: "30%" }, {}]);
+    assert.deepStrictEqual(result, [80, 30, 0]);
+  });
+});
+
+describe("toSplitPercents", () => {
+  it("converts 70/30 to [30]", () => {
+    assert.deepStrictEqual(toSplitPercents([70, 30]), [30]);
+  });
+
+  it("converts 60/25/15 correctly", () => {
+    const result = toSplitPercents([60, 25, 15]);
+    assert.deepStrictEqual(result, [40, 38]);
+  });
+
+  it("converts equal 50/50 to [50]", () => {
+    assert.deepStrictEqual(toSplitPercents([50, 50]), [50]);
+  });
+
+  it("converts equal thirds", () => {
+    const result = toSplitPercents([100 / 3, 100 / 3, 100 / 3]);
+    assert.deepStrictEqual(result, [67, 50]);
+  });
+
+  it("returns empty array for single item", () => {
+    assert.deepStrictEqual(toSplitPercents([100]), []);
+  });
+
+  it("returns empty array for empty input", () => {
+    assert.deepStrictEqual(toSplitPercents([]), []);
+  });
+});