contextspin 0.1.0

package/src/config.js

@@ -0,0 +1,232 @@
+// src/config.js — path constants, config defaults, and load/normalize/validate.
+
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+
+/** The current user's home directory. */
+const HOME = os.homedir();
+
+/** Directory holding ContextSpin's runtime state (daemon pid, statusline, logs). */
+export const STATE_DIR = path.join(HOME, ".contextspin");
+
+/**
+ * Path to the user config. Honors the CONTEXTSPIN_CONFIG env override (resolved
+ * once at module load, primarily so tests can point at a temp file).
+ */
+export const CONFIG_PATH =
+  process.env.CONTEXTSPIN_CONFIG || path.join(HOME, ".contextspin.json");
+
+/**
+ * Path to the snippet cache the daemon writes and the injectors read. Honors the
+ * CONTEXTSPIN_CACHE env override (resolved once at module load).
+ */
+export const CACHE_PATH =
+  process.env.CONTEXTSPIN_CACHE || path.join(HOME, ".contextspin-cache.json");
+
+/** Path to the daemon PID file. */
+export const PID_PATH = path.join(STATE_DIR, "daemon.pid");
+
+/** Path to the daemon log file. */
+export const LOG_PATH = path.join(STATE_DIR, "daemon.log");
+
+/** Path to the generated statusline bash wrapper. */
+export const STATUSLINE_SH = path.join(STATE_DIR, "statusline.sh");
+
+/** Path to the generated statusline Node render script. */
+export const STATUSLINE_JS = path.join(STATE_DIR, "statusline-render.js");
+
+/** Path to Claude Code's settings file (patched by the statusline injector). */
+export const CLAUDE_SETTINGS_PATH = path.join(HOME, ".claude", "settings.json");
+
+/** Path to Claude Code's user config (read by MCP discovery). */
+export const CLAUDE_USER_CONFIG_PATH = path.join(HOME, ".claude.json");
+
+/** Suffix appended to a Claude install path to name its patcher backup. */
+export const PATCHER_BACKUP_SUFFIX = ".contextspin.backup";
+
+/** Default top-level config sections. */
+export const DEFAULTS = {
+  injection: { mode: "statusline", refresh: 30, maxVisible: 5 },
+  snippets: { deduplication: true, cooldownAfterShown: 3, priorityOrder: [] },
+};
+
+/** Per-source defaults applied when a field is omitted. */
+export const SOURCE_DEFAULTS = { cooldown: 300, maxSnippets: 2 };
+
+/** Source types ContextSpin understands. */
+const VALID_SOURCE_TYPES = ["mcp", "cli", "http"];
+
+/** Valid injection modes. */
+const VALID_INJECTION_MODES = ["statusline", "patcher", "both"];
+
+/**
+ * Derive a human-readable label for a source from its type/fields.
+ *  - mcp  -> the tool name
+ *  - cli  -> the first whitespace-delimited token of the command
+ *  - http -> the URL hostname
+ *  - fallback -> the source type
+ * @param {object} src
+ * @returns {string}
+ */
+function deriveLabel(src) {
+  if (src.type === "mcp" && src.tool) return String(src.tool);
+  if (src.type === "cli" && src.command) {
+    const first = String(src.command).trim().split(/\s+/)[0];
+    return first || "cli";
+  }
+  if (src.type === "http" && src.url) {
+    try {
+      return new URL(String(src.url)).hostname || "http";
+    } catch {
+      return "http";
+    }
+  }
+  return src.type || "source";
+}
+
+/**
+ * Normalize a raw config: fill in DEFAULTS and SOURCE_DEFAULTS, assign each
+ * source an `id` (its index), and derive a `label` when one is missing. Pure —
+ * the input object is never mutated.
+ *
+ * @param {object} raw - The parsed config (possibly partial).
+ * @returns {object} A new, fully-populated config object.
+ */
+export function normalizeConfig(raw) {
+  const input = raw && typeof raw === "object" ? raw : {};
+
+  const injectionIn =
+    input.injection && typeof input.injection === "object" ? input.injection : {};
+  const injection = { ...DEFAULTS.injection, ...injectionIn };
+
+  const snippetsIn =
+    input.snippets && typeof input.snippets === "object" ? input.snippets : {};
+  const snippets = {
+    ...DEFAULTS.snippets,
+    ...snippetsIn,
+    priorityOrder: Array.isArray(snippetsIn.priorityOrder)
+      ? snippetsIn.priorityOrder.slice()
+      : DEFAULTS.snippets.priorityOrder.slice(),
+  };
+
+  const sourcesIn = Array.isArray(input.sources) ? input.sources : [];
+  const sources = sourcesIn.map((s, i) => {
+    const src = { ...SOURCE_DEFAULTS, ...(s && typeof s === "object" ? s : {}) };
+    src.id = i;
+    if (src.label === undefined || src.label === null || src.label === "") {
+      src.label = deriveLabel(src);
+    }
+    return src;
+  });
+
+  return { ...input, injection, snippets, sources };
+}
+
+/**
+ * Validate a config (raw or normalized). Throws an Error with a clear message on
+ * any problem; returns the same config object on success.
+ *
+ * @param {object} config
+ * @returns {object} The validated config (same reference).
+ */
+export function validateConfig(config) {
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw new Error("Invalid config: expected a JSON object.");
+  }
+  if (!Array.isArray(config.sources) || config.sources.length === 0) {
+    throw new Error('Invalid config: "sources" must be a non-empty array.');
+  }
+
+  config.sources.forEach((src, i) => {
+    if (!src || typeof src !== "object") {
+      throw new Error(`Invalid config: source #${i} must be an object.`);
+    }
+    if (!src.type) {
+      throw new Error(`Invalid config: source #${i} is missing "type".`);
+    }
+    if (!VALID_SOURCE_TYPES.includes(src.type)) {
+      throw new Error(
+        `Invalid config: source #${i} has invalid type "${src.type}" (expected mcp, cli, or http).`,
+      );
+    }
+    if (src.type === "mcp" && !src.tool) {
+      throw new Error(`Invalid config: mcp source #${i} is missing "tool".`);
+    }
+    if (src.type === "cli" && !src.command) {
+      throw new Error(`Invalid config: cli source #${i} is missing "command".`);
+    }
+    if (src.type === "http" && !src.url) {
+      throw new Error(`Invalid config: http source #${i} is missing "url".`);
+    }
+    if (!src.format) {
+      throw new Error(`Invalid config: source #${i} is missing "format".`);
+    }
+  });
+
+  if (
+    config.injection &&
+    config.injection.mode !== undefined &&
+    !VALID_INJECTION_MODES.includes(config.injection.mode)
+  ) {
+    throw new Error(
+      `Invalid config: injection.mode must be one of statusline, patcher, both (got "${config.injection.mode}").`,
+    );
+  }
+
+  return config;
+}
+
+/**
+ * Load, normalize, and validate the config from disk.
+ *
+ * @param {string} [configPath=CONFIG_PATH]
+ * @returns {Promise<object>} The normalized, validated config.
+ * @throws If the file is missing (with a setup hint), unparseable (message
+ *   includes the path), or invalid.
+ */
+export async function loadConfig(configPath = CONFIG_PATH) {
+  let raw;
+  try {
+    raw = await fsp.readFile(configPath, "utf8");
+  } catch {
+    throw new Error(
+      `No ContextSpin config at ${configPath}. Run: contextspin setup`,
+    );
+  }
+
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(
+      `Failed to parse ContextSpin config at ${configPath}: ${err.message}`,
+    );
+  }
+
+  return validateConfig(normalizeConfig(parsed));
+}
+
+/**
+ * Whether a config file exists at the given path (sync).
+ * @param {string} [configPath=CONFIG_PATH]
+ * @returns {boolean}
+ */
+export function configExists(configPath = CONFIG_PATH) {
+  try {
+    return fs.existsSync(configPath);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Write a config to disk as pretty-printed JSON (2-space indent).
+ * @param {object} config
+ * @param {string} [configPath=CONFIG_PATH]
+ * @returns {Promise<void>}
+ */
+export async function saveConfig(config, configPath = CONFIG_PATH) {
+  await fsp.writeFile(configPath, JSON.stringify(config, null, 2));
+}

package/src/daemon-entry.js

@@ -0,0 +1,8 @@
+// src/daemon-entry.js — the detached daemon entrypoint: starts the poll loop and logs any fatal error.
+
+import { runDaemonLoop } from "./daemon.js";
+
+runDaemonLoop().catch((err) => {
+  console.error(`contextspin daemon crashed: ${err && err.stack ? err.stack : err}`);
+  process.exit(1);
+});

package/src/daemon.js

@@ -0,0 +1,294 @@
+// src/daemon.js — the background poller: cache I/O, snippet merging, the poll loop, and process lifecycle.
+
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import process from "node:process";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { CACHE_PATH, STATE_DIR, PID_PATH, LOG_PATH, loadConfig } from "./config.js";
+import { runSource } from "./runner.js";
+
+/**
+ * Current time as an ISO-8601 string.
+ * @returns {string}
+ */
+function nowISO() {
+  return new Date().toISOString();
+}
+
+/**
+ * Read the snippet cache.
+ * @returns {Promise<{updatedAt: string|null, snippets: import("./runner.js").Snippet[]}>}
+ *   On a missing file or parse error, returns { updatedAt: null, snippets: [] }.
+ */
+export async function readCache() {
+  try {
+    const raw = await fsp.readFile(CACHE_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return { updatedAt: null, snippets: [] };
+    return {
+      updatedAt: parsed.updatedAt ?? null,
+      snippets: Array.isArray(parsed.snippets) ? parsed.snippets : [],
+    };
+  } catch {
+    return { updatedAt: null, snippets: [] };
+  }
+}
+
+/**
+ * Atomically write the snippet cache (write a .tmp file, then rename).
+ * @param {{updatedAt: string, snippets: import("./runner.js").Snippet[]}} state
+ * @returns {Promise<void>}
+ */
+export async function writeCache(state) {
+  const tmp = CACHE_PATH + ".tmp";
+  await fsp.writeFile(tmp, JSON.stringify(state, null, 2));
+  await fsp.rename(tmp, CACHE_PATH);
+}
+
+/**
+ * Merge freshly fetched snippets into the existing set. Pure (no mutation of inputs).
+ *
+ * - Preserves shownCount from oldSnippets for any new snippet whose text matches.
+ * - If config.snippets.deduplication, dedup by text (keeps the first occurrence).
+ * - Sorts by priority: index of snippet.source within config.snippets.priorityOrder
+ *   (case-insensitive; not-found sorts last), then by fetchedAt descending. Stable.
+ * - Caps the result to config.injection.maxVisible.
+ *
+ * @param {import("./runner.js").Snippet[]} oldSnippets
+ * @param {import("./runner.js").Snippet[]} newSnippets
+ * @param {object} config - Normalized config (snippets + injection sections).
+ * @returns {import("./runner.js").Snippet[]}
+ */
+export function mergeSnippets(oldSnippets, newSnippets, config) {
+  const oldList = Array.isArray(oldSnippets) ? oldSnippets : [];
+  const newList = Array.isArray(newSnippets) ? newSnippets : [];
+
+  // Index prior shownCounts by snippet text so we can carry them forward.
+  const shownByText = new Map();
+  for (const s of oldList) {
+    if (s && typeof s.text === "string" && !shownByText.has(s.text)) {
+      shownByText.set(s.text, s.shownCount || 0);
+    }
+  }
+
+  // Copy each new snippet, preserving any prior shownCount for the same text.
+  let merged = newList.map((s) => ({
+    ...s,
+    shownCount: shownByText.has(s.text) ? shownByText.get(s.text) : s.shownCount || 0,
+  }));
+
+  // Optional dedup by text, keeping the first occurrence.
+  if (config?.snippets?.deduplication) {
+    const seen = new Set();
+    const deduped = [];
+    for (const s of merged) {
+      if (seen.has(s.text)) continue;
+      seen.add(s.text);
+      deduped.push(s);
+    }
+    merged = deduped;
+  }
+
+  // Precompute priority rank (case-insensitive) for each source label.
+  const priorityOrder = Array.isArray(config?.snippets?.priorityOrder)
+    ? config.snippets.priorityOrder.map((p) => String(p).toLowerCase())
+    : [];
+  const rankOf = (label) => {
+    const idx = priorityOrder.indexOf(String(label ?? "").toLowerCase());
+    return idx === -1 ? Number.MAX_SAFE_INTEGER : idx;
+  };
+
+  // Stable sort: priority ascending, then fetchedAt descending.
+  const decorated = merged.map((s, i) => ({ s, i }));
+  decorated.sort((a, b) => {
+    const ra = rankOf(a.s.source);
+    const rb = rankOf(b.s.source);
+    if (ra !== rb) return ra - rb;
+    const ta = String(a.s.fetchedAt ?? "");
+    const tb = String(b.s.fetchedAt ?? "");
+    if (ta !== tb) return ta < tb ? 1 : -1; // descending
+    return a.i - b.i; // stability
+  });
+  const sorted = decorated.map((d) => d.s);
+
+  const maxVisible = config?.injection?.maxVisible;
+  return typeof maxVisible === "number" ? sorted.slice(0, maxVisible) : sorted;
+}
+
+/**
+ * Run one polling pass over all sources, respecting per-source cooldowns.
+ *
+ * For each source, if (now - lastRun) >= cooldown*1000 ms, runSource is attempted;
+ * on success its result is stored in runtime.buckets[source.id] and lastRun updated.
+ * On error, a concise message is logged and the previous bucket is kept. After all
+ * sources, every bucket is flattened (preserving per-source order) and merged into
+ * runtime.snippets via mergeSnippets.
+ *
+ * @param {object} config - Normalized config (with sources array).
+ * @param {{lastRun: object, buckets: object, snippets: import("./runner.js").Snippet[]}} runtime
+ * @returns {Promise<import("./runner.js").Snippet[]>}
+ */
+export async function pollOnce(config, runtime) {
+  const now = Date.now();
+  for (const source of config.sources) {
+    const last = runtime.lastRun[source.id] || 0;
+    if (now - last >= source.cooldown * 1000) {
+      try {
+        const result = await runSource(source, {});
+        runtime.buckets[source.id] = result;
+        runtime.lastRun[source.id] = Date.now();
+      } catch (err) {
+        console.error(`source "${source.label}" (#${source.id}) failed: ${err.message}`);
+        // Keep the previous bucket unchanged.
+      }
+    }
+  }
+
+  // Flatten all buckets, preserving per-source order (by source id ordering).
+  const flattened = [];
+  for (const source of config.sources) {
+    const bucket = runtime.buckets[source.id];
+    if (Array.isArray(bucket)) flattened.push(...bucket);
+  }
+
+  runtime.snippets = mergeSnippets(runtime.snippets, flattened, config);
+  return runtime.snippets;
+}
+
+/**
+ * Run the daemon poll loop. Writes the PID file, installs signal handlers, and
+ * loops: pollOnce -> writeCache -> wait config.injection.refresh seconds.
+ *
+ * @param {{once?: boolean, configPath?: string}} [opts]
+ * @returns {Promise<void>}
+ */
+export async function runDaemonLoop(opts = {}) {
+  await fsp.mkdir(STATE_DIR, { recursive: true });
+  const config = await loadConfig(opts.configPath);
+  await fsp.writeFile(PID_PATH, String(process.pid));
+
+  const shutdown = () => {
+    try {
+      fs.rmSync(PID_PATH, { force: true });
+    } catch {
+      // ignore
+    }
+    process.exit(0);
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+
+  console.log(`contextspin daemon started (pid ${process.pid})`);
+
+  const runtime = { lastRun: {}, buckets: {}, snippets: [] };
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    try {
+      const snippets = await pollOnce(config, runtime);
+      await writeCache({ updatedAt: nowISO(), snippets });
+    } catch (err) {
+      console.error(`poll failed: ${err.message}`);
+    }
+    if (opts.once) break;
+    await new Promise((resolve) => setTimeout(resolve, config.injection.refresh * 1000));
+  }
+}
+
+/**
+ * Whether the daemon appears to be running, based on the PID file.
+ * @returns {{running: boolean, pid: number|null}}
+ */
+export function isDaemonRunning() {
+  let pid = null;
+  try {
+    pid = parseInt(fs.readFileSync(PID_PATH, "utf8").trim(), 10);
+  } catch {
+    return { running: false, pid: null };
+  }
+  if (!Number.isInteger(pid) || pid <= 0) return { running: false, pid: null };
+  try {
+    process.kill(pid, 0);
+    return { running: true, pid };
+  } catch {
+    return { running: false, pid };
+  }
+}
+
+/**
+ * Spawn the daemon as a detached background process writing to LOG_PATH.
+ *
+ * If already running, returns { already: true, pid }. Otherwise spawns
+ * process.execPath against src/daemon-entry.js (resolved relative to this module),
+ * detached with stdout/stderr redirected to LOG_PATH, unrefs it, records the pid,
+ * and returns { pid }.
+ *
+ * @param {{configPath?: string}} [opts]
+ * @returns {{already?: boolean, pid: number}}
+ */
+export function startDaemonDetached(opts = {}) {
+  const existing = isDaemonRunning();
+  if (existing.running) return { already: true, pid: existing.pid };
+
+  fs.mkdirSync(STATE_DIR, { recursive: true });
+  const logFd = fs.openSync(LOG_PATH, "a");
+
+  // Resolve the entry path relative to this module (never hard-coded).
+  const entryPath = fileURLToPath(new URL("./daemon-entry.js", import.meta.url));
+
+  const env = { ...process.env };
+  if (opts.configPath) env.CONTEXTSPIN_CONFIG = opts.configPath;
+
+  const child = spawn(process.execPath, [entryPath], {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    env,
+  });
+  child.unref();
+
+  fs.writeFileSync(PID_PATH, String(child.pid));
+  return { pid: child.pid };
+}
+
+/**
+ * Stop the daemon: send SIGTERM, poll up to ~3s for exit, then remove the PID file.
+ * @returns {Promise<{stopped: boolean, pid: number|null}>}
+ */
+export async function stopDaemon() {
+  const { running, pid } = isDaemonRunning();
+  if (!running || !pid) {
+    try {
+      fs.rmSync(PID_PATH, { force: true });
+    } catch {
+      // ignore
+    }
+    return { stopped: false, pid: pid ?? null };
+  }
+
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    // Process may already be gone.
+  }
+
+  // Poll up to ~3s for the process to exit.
+  let stopped = false;
+  const deadline = Date.now() + 3000;
+  while (Date.now() < deadline) {
+    try {
+      process.kill(pid, 0);
+    } catch {
+      stopped = true;
+      break;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+
+  try {
+    fs.rmSync(PID_PATH, { force: true });
+  } catch {
+    // ignore
+  }
+
+  return { stopped, pid };
+}

package/src/formatter.js

@@ -0,0 +1,166 @@
+// src/formatter.js — path resolution, template interpolation, and safe filter evaluation.
+
+/**
+ * Resolve a dot/bracket path (e.g. "a.b[0].c" or "results[0].value") against an
+ * object. Returns undefined if any segment is missing. Pure.
+ * @param {*} obj
+ * @param {string} pathStr
+ * @returns {*}
+ */
+export function getPath(obj, pathStr) {
+  if (obj == null || typeof pathStr !== 'string' || pathStr === '') {
+    return undefined;
+  }
+
+  // Normalize bracket notation (e.g. a[0].b) into dot segments (a.0.b).
+  const normalized = pathStr.replace(/\[(\d+)\]/g, '.$1');
+  const segments = normalized.split('.').filter((s) => s.length > 0);
+
+  let current = obj;
+  for (const segment of segments) {
+    if (current == null) return undefined;
+    current = current[segment];
+  }
+  return current;
+}
+
+/**
+ * Replace {{ token }} placeholders in a template against `data`.
+ * A token of the form env.NAME resolves to env[NAME]; otherwise getPath(data, token).
+ * undefined/null -> "", non-string -> String(value). Inner spaces are allowed.
+ * @param {string} template
+ * @param {*} data
+ * @param {object} [env=process.env]
+ * @returns {string}
+ */
+export function interpolate(template, data, env = process.env) {
+  if (typeof template !== 'string') return '';
+
+  return template.replace(/\{\{\s*([^}]*?)\s*\}\}/g, (_match, rawToken) => {
+    const token = rawToken.trim();
+    let value;
+    if (token.startsWith('env.')) {
+      value = env ? env[token.slice(4)] : undefined;
+    } else {
+      value = getPath(data, token);
+    }
+    if (value === undefined || value === null) return '';
+    return typeof value === 'string' ? value : String(value);
+  });
+}
+
+/**
+ * Strip one layer of matching surrounding single or double quotes.
+ * @param {string} s
+ * @returns {string}
+ */
+function stripQuotes(s) {
+  if (
+    s.length >= 2 &&
+    ((s[0] === '"' && s[s.length - 1] === '"') ||
+      (s[0] === "'" && s[s.length - 1] === "'"))
+  ) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+
+/**
+ * Safely evaluate a filter expression against `data`.
+ *
+ * NO eval / NO Function constructor. The whole expression is first interpolated
+ * against `data`, then parsed as a single `LEFT OP RIGHT` comparison where OP is
+ * one of: == != >= <= > < or the word `includes`. Numeric comparison is used when
+ * both sides are finite numbers, otherwise string comparison (== / != are loose).
+ * With no operator, the expression is treated as truthy: non-empty AND not
+ * "false"/"0" => true.
+ *
+ * LIMITATION: only a single comparison is supported — there is no support for
+ * boolean operators (&&, ||), parentheses, or chained comparisons.
+ *
+ * @param {string|undefined|null} filterExpr
+ * @param {*} data
+ * @param {object} [env=process.env]
+ * @returns {boolean}
+ */
+export function applyFilter(filterExpr, data, env = process.env) {
+  if (!filterExpr) return true;
+
+  const expr = interpolate(filterExpr, data, env);
+
+  // Operators ordered so multi-char operators are matched before single-char.
+  const operators = ['==', '!=', '>=', '<=', '>', '<', 'includes'];
+
+  let op = null;
+  let opIndex = -1;
+  for (const candidate of operators) {
+    const pattern =
+      candidate === 'includes'
+        ? /\bincludes\b/
+        : new RegExp(candidate.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+    const match = pattern.exec(expr);
+    if (match) {
+      op = candidate;
+      opIndex = match.index;
+      break;
+    }
+  }
+
+  if (op === null) {
+    // No operator: treat as a truthiness check.
+    const trimmed = expr.trim();
+    return trimmed !== '' && trimmed !== 'false' && trimmed !== '0';
+  }
+
+  const leftRaw = expr.slice(0, opIndex).trim();
+  const rightRaw = expr.slice(opIndex + op.length).trim();
+  const left = stripQuotes(leftRaw);
+  const right = stripQuotes(rightRaw);
+
+  if (op === 'includes') {
+    return left.includes(right);
+  }
+
+  const leftNum = Number(left);
+  const rightNum = Number(right);
+  const bothNumbers =
+    left !== '' &&
+    right !== '' &&
+    Number.isFinite(leftNum) &&
+    Number.isFinite(rightNum);
+
+  if (bothNumbers) {
+    switch (op) {
+      case '==':
+        return leftNum === rightNum;
+      case '!=':
+        return leftNum !== rightNum;
+      case '>=':
+        return leftNum >= rightNum;
+      case '<=':
+        return leftNum <= rightNum;
+      case '>':
+        return leftNum > rightNum;
+      case '<':
+        return leftNum < rightNum;
+    }
+  }
+
+  // String comparison (== / != are loose equality on strings).
+  switch (op) {
+    case '==':
+      return left === right;
+    case '!=':
+      return left !== right;
+    case '>=':
+      return left >= right;
+    case '<=':
+      return left <= right;
+    case '>':
+      return left > right;
+    case '<':
+      return left < right;
+  }
+
+  return false;
+}