@zgeoff/chex 0.0.0 → 0.0.2

package/src/parse-added-lines.ts

@@ -0,0 +1,112 @@
+export interface AddedLine {
+  readonly hash: string;
+
+  // Relative to the repo root.
+  readonly path: string;
+
+  // The line's number in the file as the commit leaves it.
+  readonly line: number;
+
+  readonly text: string;
+}
+
+// The patch is `git log -p -U0 --format=%x00%h` output: each commit starts with a NUL and its hash,
+// which no line of a patch can start with.
+export function parseAddedLines(patch: string): AddedLine[] {
+  const hunkHeader = /^@@ -\d+(?:,\d+)? \+(?<start>\d+)(?:,\d+)? @@/u;
+  const added: AddedLine[] = [];
+  let hash = '';
+  let path: string | null = null;
+  let line = 0;
+
+  // A file's header runs from its `diff --git` line to its first hunk. Inside a hunk, an added line
+  // that starts with `++` reads like a `+++` header line, so the state tells the two apart.
+  let inHeader = false;
+
+  for (const text of patch.split('\n')) {
+    if (text.startsWith('\0')) {
+      hash = text.slice(1);
+      path = null;
+      inHeader = false;
+    } else if (text.startsWith('diff --git ')) {
+      path = null;
+      inHeader = true;
+    } else if (inHeader && text.startsWith('+++ ')) {
+      path = parseNewPath(text.slice('+++ '.length));
+    } else if (hunkHeader.test(text)) {
+      line = Number(hunkHeader.exec(text)?.groups?.['start']);
+      inHeader = false;
+    } else if (!inHeader && path !== null && text.startsWith('+')) {
+      added.push({ hash, path, line, text: text.slice(1) });
+
+      line += 1;
+    } else if (!inHeader && path !== null && text.startsWith(' ')) {
+      // A repo's diff.interHunkContext joins nearby hunks with the unchanged lines between them,
+      // even under -U0.
+      line += 1;
+    }
+  }
+
+  return added;
+}
+
+// `b/path`, or `/dev/null` for a file the commit deletes. git ends the name with a tab when it holds
+// a space, and quotes it in C style when it holds a tab, a newline, a quote or a backslash.
+function parseNewPath(name: string): string | null {
+  const bare = name.replace(/\t$/u, '');
+
+  if (bare === '/dev/null') {
+    return null;
+  }
+
+  const unquoted =
+    bare.startsWith('"') && bare.endsWith('"') ? parseQuotedName(bare.slice(1, -1)) : bare;
+
+  return unquoted.replace(/^b\//u, '');
+}
+
+const ESCAPED_BYTES: ReadonlyMap<string, number> = new Map([
+  ['a', 0x07],
+  ['b', 0x08],
+  ['t', 0x09],
+  ['n', 0x0a],
+  ['v', 0x0b],
+  ['f', 0x0c],
+  ['r', 0x0d],
+  ['"', 0x22],
+  ['\\', 0x5c],
+]);
+
+// git writes each escaped byte as a letter or as three octal digits, and the bytes are UTF-8.
+function parseQuotedName(quoted: string): string {
+  const bytes: number[] = [];
+
+  const encoder = new TextEncoder();
+
+  for (let index = 0; index < quoted.length; index += 1) {
+    // A character outside the Basic Multilingual Plane, such as an emoji, spans two code units.
+    const character = String.fromCodePoint(quoted.codePointAt(index) ?? 0);
+
+    if (character !== '\\') {
+      bytes.push(...encoder.encode(character));
+
+      index += character.length - 1;
+      continue;
+    }
+
+    const next = quoted.charAt(index + 1);
+    const octal = /^[0-7]{3}/u.exec(quoted.slice(index + 1))?.[0];
+
+    if (octal === undefined) {
+      bytes.push(ESCAPED_BYTES.get(next) ?? next.codePointAt(0) ?? 0x5c);
+
+      index += 1;
+    } else {
+      bytes.push(Number.parseInt(octal, 8));
+
+      index += 3;
+    }
+  }
+
+  return new TextDecoder().decode(new Uint8Array(bytes));
+}

package/src/parse-chex-args.ts

@@ -0,0 +1,76 @@
+import { parseArgs } from 'node:util';
+import type { CheckName } from './check-names.ts';
+import { checkNames, isCheckName } from './check-names.ts';
+
+export type ChexRequest =
+  | { readonly kind: 'init' }
+  | {
+      readonly kind: 'checks';
+      readonly names: readonly CheckName[];
+      readonly args: readonly string[];
+    }
+  | { readonly kind: 'refused'; readonly message: string };
+
+const checksWithArgs: ReadonlySet<CheckName> = new Set([
+  'prose',
+  'links',
+  'skill',
+  'commits',
+  'local-paths',
+  'workflows',
+]);
+
+export const chexUsage = `usage: chex <check>... | chex <check> [args...] | chex init
+checks: ${checkNames.join(', ')}`;
+
+export function parseChexArgs(argv: readonly string[]): ChexRequest {
+  const [first, ...rest] = argv;
+
+  if (first === undefined) {
+    return { kind: 'refused', message: 'name a check to run' };
+  }
+
+  if (first === 'init') {
+    return rest.length === 0
+      ? { kind: 'init' }
+      : { kind: 'refused', message: 'init takes no arguments' };
+  }
+
+  // Each check parses its own options, so the tokens only mark where the check names end.
+  const tokens = parseArgs({
+    args: [...argv],
+    strict: false,
+    allowPositionals: true,
+    tokens: true,
+  }).tokens;
+
+  const firstArg = tokens.find((token) => token.kind !== 'positional' || !isCheckName(token.value));
+
+  const names = (firstArg === undefined ? argv : argv.slice(0, firstArg.index)).filter((word) =>
+    isCheckName(word),
+  );
+
+  const args = firstArg === undefined ? [] : argv.slice(firstArg.index);
+  const [only, ...others] = names;
+
+  if (only === undefined) {
+    return { kind: 'refused', message: `unknown check "${first}"` };
+  }
+
+  if (args.length === 0) {
+    return { kind: 'checks', names: [...new Set(names)], args };
+  }
+
+  if (others.length > 0) {
+    return {
+      kind: 'refused',
+      message: `"${args[0]}" is no check name; arguments follow one check name alone`,
+    };
+  }
+
+  if (!checksWithArgs.has(only)) {
+    return { kind: 'refused', message: `${only} takes no arguments, and got "${args[0]}"` };
+  }
+
+  return { kind: 'checks', names, args };
+}

package/src/parse-lane-limits.ts

@@ -0,0 +1,59 @@
+// The limits match the max-test-timeout rule in @zgeoff/oxlint-config, which CI cannot import: the
+// workflow downloads this file and the modules it imports one by one.
+const standardLaneLimits: readonly (readonly [string, number])[] = [
+  ['browser', 10_000],
+  ['e2e', 15_000],
+  ['docker', 15_000],
+  ['host', 15_000],
+  ['agent-sdk', 5000],
+  ['model-api', 120_000],
+];
+
+const listedLaneLimitMs = 15_000;
+
+export function parseLaneLimits(configText: string | null): ReadonlyMap<string, number> {
+  const limits = new Map(standardLaneLimits);
+
+  const lanes = configText === null ? undefined : parseLanesOption(configText);
+
+  if (Array.isArray(lanes)) {
+    for (const lane of lanes) {
+      if (typeof lane === 'string' && !limits.has(lane)) {
+        limits.set(lane, listedLaneLimitMs);
+      }
+    }
+  } else if (typeof lanes === 'object' && lanes !== null) {
+    for (const [lane, limitMs] of Object.entries(lanes)) {
+      if (typeof limitMs === 'number') {
+        limits.set(lane, limitMs);
+      }
+    }
+  }
+
+  return limits;
+}
+
+function parseLanesOption(text: string): unknown {
+  const config = parseConfig(text);
+  const setting = findMember(findMember(config, 'rules'), 'zgeoff/max-test-timeout');
+  const ruleOptions: unknown = Array.isArray(setting) ? setting[1] : undefined;
+
+  return findMember(ruleOptions, 'lanes');
+}
+
+function parseConfig(text: string): unknown {
+  try {
+    return Bun.JSONC.parse(text);
+  } catch (error) {
+    throw new Error(
+      `cannot parse .oxlintrc.json: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error },
+    );
+  }
+}
+
+function findMember(value: unknown, key: string): unknown {
+  return typeof value === 'object' && value !== null && Object.hasOwn(value, key)
+    ? Reflect.get(value, key)
+    : undefined;
+}

package/src/parse-pushed-refs.ts

@@ -0,0 +1,29 @@
+export interface PushedRef {
+  readonly localSha: string;
+
+  // Null when the push creates the remote ref.
+  readonly remoteSha: string | null;
+}
+
+const zeroSha = /^0+$/u;
+
+// git writes one `<local ref> <local sha> <remote ref> <remote sha>` line per ref it pushes.
+export function parsePushedRefs(text: string): PushedRef[] {
+  return text
+    .split('\n')
+    .filter((line) => line.trim() !== '')
+    .flatMap((line) => {
+      const [, localSha, , remoteSha] = line.trim().split(' ');
+
+      if (localSha === undefined || remoteSha === undefined) {
+        throw new Error(`cannot read the pushed ref line: ${line}`);
+      }
+
+      // A push that deletes the remote ref sends no commit.
+      if (zeroSha.test(localSha)) {
+        return [];
+      }
+
+      return [{ localSha, remoteSha: zeroSha.test(remoteSha) ? null : remoteSha }];
+    });
+}