rcf-lite 0.0.1 → 0.8.0

package/src/core/mcp/server.js

@@ -0,0 +1,228 @@
+// MCP protocol lifecycle (Phase 7 §D3 / §D18). Pure protocol shell:
+// initialize / initialized handshake, single version constant, ping,
+// request dispatch to injected handlers, tolerated notifications,
+// JSON-RPC error mapping, EOF shutdown. Knows nothing about RCF -
+// domain behaviour arrives through the `handlers` map.
+//
+// Implemented against the pinned MCP revision 2025-11-25 (D3): the
+// server responds to `initialize` with its own protocol version
+// regardless of the client's requested version (the spec-sanctioned
+// server behaviour under version negotiation - the server MUST respond
+// with a version it supports; the client disconnects if incompatible).
+
+import { attachLineReader, writeMessage } from './framing.js';
+
+export const PROTOCOL_VERSION = '2025-11-25';
+
+// JSON-RPC 2.0 error codes used by this server. -32002 is the MCP
+// resources error for "resource not found" (2025-11-25 resources §
+// error handling).
+export const PARSE_ERROR = -32700;
+export const INVALID_REQUEST = -32600;
+export const METHOD_NOT_FOUND = -32601;
+export const INVALID_PARAMS = -32602;
+export const INTERNAL_ERROR = -32603;
+export const RESOURCE_NOT_FOUND = -32002;
+
+/**
+ * Structured protocol error a handler can throw to produce a JSON-RPC
+ * error response (as opposed to a tool execution error, which is a
+ * successful result carrying `isError: true` - see map-errors.js).
+ */
+export class JsonRpcError extends Error {
+  /**
+   * @param {number} code
+   * @param {string} message
+   * @param {object} [data]
+   */
+  constructor(code, message, data) {
+    super(message);
+    this.name = 'JsonRpcError';
+    this.code = code;
+    this.data = data;
+  }
+}
+
+/**
+ * Create an MCP server core. Transport-free: `handleMessage` takes one
+ * parsed JSON-RPC message and resolves to a response object (requests)
+ * or null (notifications / ignorable traffic). Wire it to real streams
+ * with `serveStreams`.
+ *
+ * @param {object} opts
+ * @param {{name: string, version: string}} opts.serverInfo
+ * @param {string} [opts.instructions]
+ * @param {object} opts.capabilities - e.g. {tools: {}, resources: {}, prompts: {}}
+ * @param {Record<string, (params: object) => Promise<object>>} opts.handlers
+ *   - method name to handler; handler returns the JSON-RPC `result`
+ * @param {{info: (line: string) => void, error: (line: string) => void}} [opts.log]
+ * @returns {{
+ *   handleMessage: (message: unknown) => Promise<object | null>,
+ *   parseErrorResponse: () => object,
+ *   initialized: () => boolean,
+ * }}
+ */
+export function createMcpServer({ serverInfo, instructions, capabilities, handlers, log }) {
+  const logger = log ?? { info: () => {}, error: () => {} };
+  let receivedInitialized = false;
+
+  const errorResponse = (id, code, message, data) => ({
+    jsonrpc: '2.0',
+    id: id ?? null,
+    error: { code, message, ...(data !== undefined ? { data } : {}) },
+  });
+
+  const resultResponse = (id, result) => ({ jsonrpc: '2.0', id, result });
+
+  /**
+   * @param {unknown} message
+   * @returns {Promise<object | null>}
+   */
+  async function handleMessage(message) {
+    if (!message || typeof message !== 'object' || Array.isArray(message)) {
+      return errorResponse(null, INVALID_REQUEST, 'Invalid request: expected a JSON-RPC object');
+    }
+    const msg = /** @type {{jsonrpc?: unknown, id?: unknown, method?: unknown, params?: unknown, result?: unknown, error?: unknown}} */ (message);
+
+    // A message with no method but a result / error member is a
+    // response. This server never sends requests, so any incoming
+    // response is stale or misaddressed traffic - tolerate and ignore.
+    if (msg.method === undefined && (msg.result !== undefined || msg.error !== undefined)) {
+      return null;
+    }
+
+    if (typeof msg.method !== 'string' || msg.jsonrpc !== '2.0') {
+      return errorResponse(
+        validId(msg.id) ? msg.id : null,
+        INVALID_REQUEST,
+        'Invalid request: missing jsonrpc "2.0" or method',
+      );
+    }
+
+    const isNotification = msg.id === undefined;
+    const params = (msg.params && typeof msg.params === 'object') ? msg.params : {};
+
+    if (isNotification) {
+      // D18: unknown notifications (including notifications/cancelled)
+      // are tolerated and ignored - every tool is synchronous and
+      // fast, so cancellation has nothing to cancel.
+      if (msg.method === 'notifications/initialized') {
+        receivedInitialized = true;
+        logger.info('client initialized');
+      } else {
+        logger.info(`ignoring notification ${msg.method}`);
+      }
+      return null;
+    }
+
+    if (!validId(msg.id)) {
+      return errorResponse(null, INVALID_REQUEST, 'Invalid request: id must be a string or number');
+    }
+    const id = msg.id;
+
+    if (msg.method === 'initialize') {
+      return resultResponse(id, {
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities,
+        serverInfo,
+        ...(instructions ? { instructions } : {}),
+      });
+    }
+    if (msg.method === 'ping') {
+      return resultResponse(id, {});
+    }
+
+    const handler = handlers[msg.method];
+    if (!handler) {
+      return errorResponse(id, METHOD_NOT_FOUND, `Method not found: ${msg.method}`);
+    }
+    try {
+      const result = await handler(params);
+      return resultResponse(id, result);
+    } catch (err) {
+      if (err instanceof JsonRpcError) {
+        return errorResponse(id, err.code, err.message, err.data);
+      }
+      // Unexpected failure: message to the client, full stack to
+      // stderr only - never into model context (D10).
+      const e = /** @type {Error} */ (err);
+      logger.error(`[rcf mcp] unexpected failure in ${msg.method}: ${e.message}\n${e.stack ?? ''}`);
+      return errorResponse(id, INTERNAL_ERROR, `Internal error: ${e.message}`);
+    }
+  }
+
+  return {
+    handleMessage,
+    parseErrorResponse: () => errorResponse(null, PARSE_ERROR, 'Parse error'),
+    initialized: () => receivedInitialized,
+  };
+}
+
+function validId(id) {
+  return typeof id === 'string' || (typeof id === 'number' && Number.isFinite(id));
+}
+
+/**
+ * Wire a server core to real (or injected) streams. Messages are
+ * processed strictly in arrival order over a serial promise chain so
+ * responses hit stdout in request order and every fresh tree walk is
+ * serialised (D14). Resolves 0 on input EOF - the 2025-11-25 stdio
+ * termination path (client closes stdin; server exits).
+ *
+ * @param {ReturnType<typeof createMcpServer>} server
+ * @param {object} opts
+ * @param {NodeJS.ReadableStream} opts.input
+ * @param {NodeJS.WritableStream} opts.output
+ * @param {{info: (line: string) => void, error: (line: string) => void}} [opts.log]
+ * @returns {{ done: Promise<number>, stop: () => void }}
+ */
+export function serveStreams(server, { input, output, log }) {
+  const logger = log ?? { info: () => {}, error: () => {} };
+  let queue = Promise.resolve();
+  let resolveDone;
+  const done = new Promise((resolve) => { resolveDone = resolve; });
+  let stopped = false;
+
+  const send = (response) => {
+    if (stopped || !response) return;
+    try {
+      writeMessage(output, response);
+    } catch (err) {
+      // Embedded-newline refusal or a closed pipe. Log and drop the
+      // message rather than corrupting the stdout framing.
+      logger.error(`[rcf mcp] write failed: ${/** @type {Error} */ (err).message}`);
+    }
+  };
+
+  const reader = attachLineReader(input, {
+    onMessage: (message) => {
+      queue = queue.then(async () => {
+        if (stopped) return;
+        const response = await server.handleMessage(message);
+        send(response);
+      });
+    },
+    onParseError: (rawLine) => {
+      queue = queue.then(() => {
+        if (stopped) return;
+        logger.info(`parse error on input line (${rawLine.length} chars)`);
+        send(server.parseErrorResponse());
+      });
+    },
+    onEnd: () => {
+      // Drain in-flight work, then resolve the exit code.
+      queue = queue.then(() => {
+        stop();
+      });
+    },
+  });
+
+  function stop() {
+    if (stopped) return;
+    stopped = true;
+    reader.detach();
+    resolveDone(0);
+  }
+
+  return { done, stop };
+}

package/src/core/patterns/register-canary.js

@@ -0,0 +1,209 @@
+// Register-regression canary pattern set - single source of truth for the
+// five graded dimensions defined in Track D §7.2 of the
+// elicitation-and-playbook-hardening-0.7.0 spec.
+//
+// Consumed by `packages/rcf-lite/scripts/canary-register.js` (or wherever the
+// build package eventually places its CI runner) which replays the fixture
+// pack at `./fixtures/register-canary/*.json` against the shipping build,
+// captures the first response, and runs each dimension against the
+// response body only (system prompts, tool-use, and code blocks are
+// excluded from the grep before evaluation).
+//
+// Each dimension is `{ patterns: RegExp[], evaluate(context) => Result }`
+// where `Result` is `{ verdict: 'pass'|'fail', matches: string[], ...extra }`.
+// Dimensions that need more than pattern data (e.g. `redundantPermissionAsk`
+// needs the fixture's `grantedPermissions[]`; `wordCountBudget` needs the
+// numeric target) accept a `context` argument.
+
+/**
+ * @typedef {'internalRuleCitation'|'unglossedJargon'|'redundantPermissionAsk'|'bypassOffer'|'wordCountBudget'} CanaryDimension
+ */
+
+/**
+ * @typedef {object} DimensionEvaluation
+ * @property {'pass'|'fail'} verdict
+ * @property {string[]} [matches]
+ * @property {number} [target]  populated by `wordCountBudget`
+ * @property {number} [actual]  populated by `wordCountBudget`
+ */
+
+// -- internalRuleCitation ---------------------------------------------------
+// Any citation of an internal rule (RULE 1, CLAUDE.md, __NOTES__, AGENTS.md,
+// or "per rule X") is a fail. Rationale: the 0.5.1 first response cited
+// "RULE 1" and Baz's Entry-1 response was "why would I care about CLAUDE
+// RULE 1?". Internal rule references leaking to the operator is the sin.
+const INTERNAL_RULE_CITATION_PATTERNS = Object.freeze([
+  /\bRULE\s?\d+\b/gi,
+  /\bCLAUDE\.md\b/g,
+  /\b__NOTES__\b/g,
+  /\bAGENTS\.md\b/g,
+  /\bper rule\s+\d+\b/gi,
+]);
+
+// -- unglossedJargon --------------------------------------------------------
+// Jargon tokens that need to be glossed. A token followed by a full stop,
+// line break, or clause-ending punctuation with no parenthesised definition
+// or "which is" clause within a short window counts as unglossed.
+const JARGON_TOKENS = Object.freeze([
+  'FBS', 'AC', 'TAC', 'ADR', 'BS', 'PRD',
+  'docs-review gate', 'RCF chain',
+]);
+
+// "Immediately followed by an explanation" - a parenthesised gloss, an
+// em-dash / colon / "which is" definer clause within the next ~80 chars.
+// Deliberately generous window; unglossed_jargon is a heuristic and false
+// positives fail the canary and force a wording fix.
+const GLOSS_LOOKAHEAD = /(?:\s*\(|\s*[-:]\s|\s+which\s+is\b|\s+meaning\b|\s+i\.e\.)/i;
+
+function isJargonGlossed(text, tokenEnd) {
+  const window = text.slice(tokenEnd, tokenEnd + 80);
+  return GLOSS_LOOKAHEAD.test(window);
+}
+
+// -- redundantPermissionAsk -------------------------------------------------
+// "Would/shall/do you want I/me to X" where X is a permission verb.
+// Fails ONLY when the fixture prompt has already granted the corresponding
+// permission. `PERMISSION_VERBS_BY_GRANT` maps a grantedPermission id to
+// the verbs it authorises; a match on any verb whose grant is present
+// fails the dimension.
+const REDUNDANT_ASK_PATTERN = /\b(would|shall|do you want)\s+(?:i|me\s+to)\s+(create|add|push|open|initialise|initialize|commit|merge)\b/gi;
+
+// Grant id -> verbs it authorises. Verbs listed here are lower-case; the
+// matcher lowercases the captured verb before lookup.
+const PERMISSION_VERBS_BY_GRANT = Object.freeze({
+  gitPush: ['push', 'commit', 'merge'],
+  githubRepoManagement: ['create', 'open', 'initialise', 'initialize', 'merge'],
+  actionsWorkflowManagement: ['create', 'add', 'open'],
+});
+
+function verbIsGranted(verb, grantedPermissions) {
+  const needle = verb.toLowerCase();
+  for (const grant of grantedPermissions ?? []) {
+    const verbs = PERMISSION_VERBS_BY_GRANT[grant];
+    if (verbs && verbs.includes(needle)) return true;
+  }
+  return false;
+}
+
+// -- bypassOffer ------------------------------------------------------------
+// Never-skip-RCF invariant enforced at the response level. Any offer of a
+// shortcut / bypass fails; the OFFER is the defect (§8, "@dave note this"
+// ruling). Deliberately broad; false positives fail the canary and force
+// a wording fix in the guidance surface, which is the correct cost balance.
+const BYPASS_OFFER_PATTERNS = Object.freeze([
+  /\bskip\s+(?:the\s+)?RCF\b/gi,
+  /\bshortcut\b/gi,
+  /\bjust\s+push\s+.*(?:fix|patch)\b/gi,
+  /\bfast[-\s]path\b/gi,
+  /\b(?:rather|instead)\b[^.\n]*\bskip\b/gi,
+  /\b(?:want|prefer)\b[^.\n]*\bbypass\b/gi,
+  /\b(?:if\s+you|shall\s+i)\b[^.\n]*\bjust\b/gi,
+]);
+
+// -- wordCountBudget --------------------------------------------------------
+// Word count of the response body, excluding code blocks. Default target
+// is 200; per-fixture override supplied by the caller.
+export const DEFAULT_WORD_COUNT_BUDGET = 200;
+
+function stripCodeBlocks(text) {
+  // Fenced code blocks (```...```) and single-line back-ticked spans.
+  return text
+    .replace(/```[\s\S]*?```/g, ' ')
+    .replace(/`[^`\n]*`/g, ' ');
+}
+
+function countWords(text) {
+  const stripped = stripCodeBlocks(text).trim();
+  if (stripped.length === 0) return 0;
+  return stripped.split(/\s+/).length;
+}
+
+// -- Dimension evaluators ---------------------------------------------------
+
+/** @type {Record<CanaryDimension, (context: { responseBody: string, grantedPermissions?: string[], wordCountBudget?: number }) => DimensionEvaluation>} */
+export const REGISTER_CANARY_DIMENSIONS_V1 = Object.freeze({
+  internalRuleCitation({ responseBody }) {
+    const matches = [];
+    for (const re of INTERNAL_RULE_CITATION_PATTERNS) {
+      const local = new RegExp(re.source, re.flags);
+      let m;
+      while ((m = local.exec(responseBody)) !== null) matches.push(m[0]);
+    }
+    return { verdict: matches.length === 0 ? 'pass' : 'fail', matches };
+  },
+  unglossedJargon({ responseBody }) {
+    const matches = [];
+    for (const token of JARGON_TOKENS) {
+      const re = new RegExp(`\\b${token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'g');
+      let m;
+      while ((m = re.exec(responseBody)) !== null) {
+        const end = m.index + m[0].length;
+        if (!isJargonGlossed(responseBody, end)) matches.push(m[0]);
+      }
+    }
+    return { verdict: matches.length === 0 ? 'pass' : 'fail', matches };
+  },
+  redundantPermissionAsk({ responseBody, grantedPermissions }) {
+    const matches = [];
+    const re = new RegExp(REDUNDANT_ASK_PATTERN.source, REDUNDANT_ASK_PATTERN.flags);
+    let m;
+    while ((m = re.exec(responseBody)) !== null) {
+      const verb = m[2];
+      if (verbIsGranted(verb, grantedPermissions)) matches.push(m[0]);
+    }
+    return { verdict: matches.length === 0 ? 'pass' : 'fail', matches };
+  },
+  bypassOffer({ responseBody }) {
+    const matches = [];
+    for (const re of BYPASS_OFFER_PATTERNS) {
+      const local = new RegExp(re.source, re.flags);
+      let m;
+      while ((m = local.exec(responseBody)) !== null) matches.push(m[0]);
+    }
+    return { verdict: matches.length === 0 ? 'pass' : 'fail', matches };
+  },
+  wordCountBudget({ responseBody, wordCountBudget }) {
+    const target = typeof wordCountBudget === 'number' ? wordCountBudget : DEFAULT_WORD_COUNT_BUDGET;
+    const actual = countWords(responseBody);
+    return {
+      verdict: actual <= target ? 'pass' : 'fail',
+      target,
+      actual,
+      matches: [],
+    };
+  },
+});
+
+/**
+ * Ordered list of dimension keys. Downstream consumers iterate this to
+ * assemble the `grades` object on a `registerCanary[]` record in a
+ * deterministic order.
+ */
+export const CANARY_DIMENSION_KEYS = Object.freeze([
+  'internalRuleCitation',
+  'unglossedJargon',
+  'redundantPermissionAsk',
+  'bypassOffer',
+  'wordCountBudget',
+]);
+
+/**
+ * Aggregate: run every dimension and collapse to a single verdict. Any
+ * `fail` on any dimension fails the top-level verdict.
+ *
+ * @param {object} context
+ * @param {string} context.responseBody
+ * @param {string[]} [context.grantedPermissions]
+ * @param {number} [context.wordCountBudget]
+ * @returns {{ verdict: 'pass'|'fail', grades: Record<CanaryDimension, DimensionEvaluation> }}
+ */
+export function gradeResponse(context) {
+  /** @type {Record<CanaryDimension, DimensionEvaluation>} */
+  const grades = {};
+  let aggregate = 'pass';
+  for (const key of CANARY_DIMENSION_KEYS) {
+    grades[key] = REGISTER_CANARY_DIMENSIONS_V1[key](context);
+    if (grades[key].verdict === 'fail') aggregate = 'fail';
+  }
+  return { verdict: aggregate, grades };
+}

package/src/core/patterns/req-shapes.js

@@ -0,0 +1,158 @@
+// REQ-shape seed pattern set - single source of truth for REQ-shape
+// classification.
+//
+// Consumed by `packages/rcf-lite/src/req-detection/classifier.js` (Track C+D
+// classifier, elicitation-and-playbook-hardening-0.7.0-spec §4.3), which
+// walks each in-scope field (`title`, `description`, `rationale` on the
+// REQ, plus parent PRD `intent` / `problem` as fallback context), matches
+// against every shape's pattern list, and records the matched signals on
+// `req.shapeClassification.signals[]`.
+//
+// The `webUi` shape imports `UI_SEED_PATTERNS_V1` from
+// `./ui-shapes.js` (Track B) so a UI signal is defined in ONE place across
+// build's UI-bearing FBS classifier, Track C+D's Web UI REQ classifier and
+// Track B's browser-verification invariants. When the UI pattern set moves,
+// consumers move together.
+//
+// Match rules per spec §4.3:
+//   - Case-insensitive.
+//   - Word-boundary anchored on plain-letter patterns (the matcher wraps
+//     each pattern with `\b<pattern>\b`).
+//   - `shapes` are non-exclusive: a REQ can carry `[webUi, auth]` (e.g.
+//     "sign-in page"). One shape per pattern list; the classifier layers
+//     the matches from all lists.
+
+import { UI_SEED_PATTERNS_V1 } from './ui-shapes.js';
+
+/**
+ * @typedef {'webUi'|'httpApi'|'auth'|'persistence'|'notifications'} ReqShape
+ */
+
+/**
+ * @typedef {object} ReqShapeSignalMatch
+ * @property {ReqShape} shape
+ * @property {string} pattern       source pattern string
+ * @property {string} match         exact substring matched
+ * @property {number} index         offset inside `text`
+ */
+
+// Canonical shape id list. `none` is a legitimate REQ-level verdict but
+// carries no pattern set (the classifier records `shapes: []` and derives
+// `none` from the empty list); it is included here so downstream schemas
+// can reference `SHAPE_KEYS_WITH_NONE` when they need the full enum.
+export const SHAPE_KEYS = Object.freeze(['webUi', 'httpApi', 'auth', 'persistence', 'notifications']);
+export const SHAPE_KEYS_WITH_NONE = Object.freeze([...SHAPE_KEYS, 'none']);
+
+// Flatten the UI pattern set into a single array of pattern strings so
+// the shape-classifier can use the same matcher for every shape. This
+// preserves single-source-of-truth (both files reference
+// `UI_SEED_PATTERNS_V1`); if Track B evolves the categories the flatten
+// picks them up automatically.
+function flattenUiSeedPatterns() {
+  const patterns = [];
+  for (const category of Object.keys(UI_SEED_PATTERNS_V1)) {
+    for (const pattern of UI_SEED_PATTERNS_V1[category]) patterns.push(pattern);
+  }
+  return patterns;
+}
+
+// Non-webUi shape patterns. Each entry is a regex source string; the
+// matcher wraps with `\b<pattern>\b` and the `gi` flags. Escaping caveats
+// for maintainers: `\\s` in a source string escapes to `\s` in the regex;
+// literal `.` inside a pattern (`serve.*page`, `webhook.*deliver`) is
+// intentional wildcard, not a literal full stop.
+const HTTP_API_PATTERNS = Object.freeze([
+  'api', 'endpoint', 'REST', 'HTTP method',
+  'POST', 'GET', 'PUT', 'DELETE',
+  'webhook',
+  'json (?:response|body|payload)',
+  'rate limit', 'request body',
+]);
+
+const AUTH_PATTERNS = Object.freeze([
+  'login',
+  'sign(?:-|\\s)?in',
+  'sign(?:-|\\s)?up',
+  'logout',
+  'session',
+  'token',
+  'credential',
+  'password',
+  'magic(?:-|\\s)?link',
+  'api key',
+  'authoriz(?:e|ation)',
+  'permission',
+  'role',
+]);
+
+const PERSISTENCE_PATTERNS = Object.freeze([
+  'store',
+  'storage',
+  'persist(?:ed|ent|ing)?',
+  'database',
+  'table',
+  'schema',
+  'migration',
+  'backup',
+  'restore',
+  'survives? (?:a )?restart',
+  'durable',
+]);
+
+const NOTIFICATIONS_PATTERNS = Object.freeze([
+  'notify',
+  'notification',
+  'alert',
+  'email',
+  'SMS',
+  'push notification',
+  'slack',
+  'webhook.*deliver',
+  'reminder',
+]);
+
+/**
+ * The full REQ-shape seed pattern set. `webUi` is composed from the Track B
+ * UI seed set at module load; the other shapes are declared inline. The
+ * object is frozen so consumers cannot mutate the shared source.
+ *
+ * @type {Readonly<Record<ReqShape, readonly string[]>>}
+ */
+export const REQ_SHAPE_PATTERNS_V1 = Object.freeze({
+  webUi: Object.freeze(flattenUiSeedPatterns()),
+  httpApi: HTTP_API_PATTERNS,
+  auth: AUTH_PATTERNS,
+  persistence: PERSISTENCE_PATTERNS,
+  notifications: NOTIFICATIONS_PATTERNS,
+});
+
+/**
+ * Scan `text` against every REQ shape's pattern list and return each match
+ * tagged with the shape it fed into. Sentence-level exclusion is NOT
+ * applied here (unlike `matchUiSignals`, which filters API/CLI/JSON-response
+ * false positives inside the UI classifier); the REQ-shape classifier
+ * deliberately over-collects and defers the operator override per spec
+ * §4.5.
+ *
+ * @param {string} text
+ * @returns {ReqShapeSignalMatch[]}
+ */
+export function matchReqShapeSignals(text) {
+  if (typeof text !== 'string' || text.length === 0) return [];
+  /** @type {ReqShapeSignalMatch[]} */
+  const results = [];
+  for (const shape of Object.keys(REQ_SHAPE_PATTERNS_V1)) {
+    for (const pattern of REQ_SHAPE_PATTERNS_V1[shape]) {
+      // Leading `\b` only; stem-suffixed forms (`stores`, `logins`,
+      // `webhook delivers`) match by design per the over-collect posture.
+      const re = new RegExp(`\\b${pattern}`, 'gi');
+      let m;
+      while ((m = re.exec(text)) !== null) {
+        results.push({ shape, pattern, match: m[0], index: m.index });
+        if (m.index === re.lastIndex) re.lastIndex += 1;
+      }
+    }
+  }
+  results.sort((a, b) => a.index - b.index);
+  return results;
+}