@drkmttr/adhere 0.4.1 → 0.6.0

package/src/services/Jev.http.ts

@@ -2,16 +2,24 @@ import { AdhereConfig } from "#services/AdhereConfig.ts";
 import { Credentials } from "#services/Credentials.ts";
 import {
   blockBody,
+  type Body,
+  type ComparedRule,
+  conflictBody,
+  contradictBody,
   Jev,
   JevUnavailable,
   judgeBody,
   type Lines,
   locateBody,
+  namedPairs,
   needsBlocks,
+  type Pair,
+  pairProbability,
+  requestsOf,
   type Rules,
 } from "#services/Jev.ts";
-import { Effect, Layer, Record, Schedule, Schema } from "effect";
-import { HttpClient, HttpClientResponse } from "effect/unstable/http";
+import { type Cause, Effect, Layer, Record, Schedule, Schema } from "effect";
+import { HttpClient, HttpClientError, HttpClientResponse } from "effect/unstable/http";
 import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
 
 const SYSTEM_ONE = "https://api.typesafe.ai/v1/systemone";
@@ -25,6 +33,27 @@ const ChoiceAnswers = Schema.Struct({
 
 const refused = (message: string) => JevUnavailable.make({ message });
 
+/** Jev's error body, on one line and cut short, or nothing when it sent none. */
+const detailOf = (body: string): string => {
+  const text = body.trim().replace(/\s+/g, " ");
+  return text.length === 0 ? "" : `: ${text.slice(0, 300)}`;
+};
+
+/**
+ * A failed request as a refusal: for an answer outside 2xx, its status and
+ * what Jev said, since the status alone does not say why; otherwise the cause.
+ */
+const refusalOf = (problem: HttpClientError.HttpClientError | Cause.TimeoutError) => {
+  if (!HttpClientError.isHttpClientError(problem) || problem.reason._tag !== "StatusCodeError") {
+    return Effect.succeed(refused(`System One request failed: ${problem.message}`));
+  }
+  const { response } = problem.reason;
+  return Effect.map(
+    Effect.orElseSucceed(response.text, () => ""),
+    (body) => refused(`Jev answered HTTP ${response.status}${detailOf(body)}`),
+  );
+};
+
 export const JevLive = Layer.effect(Jev)(
   Effect.gen(function* () {
     const config = yield* AdhereConfig;
@@ -38,7 +67,7 @@ export const JevLive = Layer.effect(Jev)(
       }),
     );
 
-    const ask = <A>(body: unknown, Answers: Schema.Codec<A, unknown, never, never>) =>
+    const ask = <A>(body: Body, Answers: Schema.Codec<A, unknown, never, never>) =>
       Effect.gen(function* () {
         // Read here, not in the layer: a run with nothing pending needs no key.
         const apiKey = yield* credentials.apiKey.pipe(
@@ -50,9 +79,7 @@ export const JevLive = Layer.effect(Jev)(
         ).pipe(Effect.orDie);
         const response = yield* client
           .execute(HttpClientRequest.bearerToken(request, apiKey))
-          .pipe(
-            Effect.mapError((problem) => refused(`System One request failed: ${problem.message}`)),
-          );
+          .pipe(Effect.catch((problem) => Effect.flatMap(refusalOf(problem), Effect.fail)));
         return yield* HttpClientResponse.schemaBodyJson(Answers)(response).pipe(
           Effect.mapError((problem) =>
             refused(`System One response did not decode: ${problem.message}`),
@@ -60,8 +87,27 @@ export const JevLive = Layer.effect(Jev)(
         );
       });
 
+    /** Every answer to a body, over as many requests as Jev's context needs. */
+    const answersTo = <A>(
+      body: Body,
+      Answers: Schema.Codec<
+        { readonly answers: Readonly<Record<string, A>> },
+        unknown,
+        never,
+        never
+      >,
+    ) =>
+      Effect.map(
+        Effect.forEach(requestsOf(body), (request) => ask(request, Answers)),
+        (responses) =>
+          responses.reduce<Record<string, A>>(
+            (answers, response) => ({ ...answers, ...response.answers }),
+            {},
+          ),
+      );
+
     const judge = Effect.fn("Jev.judge")(function* (lines: Lines, rules: Rules) {
-      const { answers } = yield* ask(judgeBody(config.model, lines, rules), NoulAnswers);
+      const answers = yield* answersTo(judgeBody(config.model, lines, rules), NoulAnswers);
       return Record.map(answers, (answer) => answer.noul);
     });
 
@@ -70,12 +116,35 @@ export const JevLive = Layer.effect(Jev)(
 
     const locate = Effect.fn("Jev.locate")(function* (lines: Lines, rules: Rules) {
       const blocks = needsBlocks(lines)
-        ? chosen((yield* ask(blockBody(config.model, lines, rules), ChoiceAnswers)).answers)
+        ? chosen(yield* answersTo(blockBody(config.model, lines, rules), ChoiceAnswers))
         : undefined;
-      const { answers } = yield* ask(locateBody(config.model, lines, rules, blocks), ChoiceAnswers);
-      return chosen(answers);
+      return chosen(
+        yield* answersTo(locateBody(config.model, lines, rules, blocks), ChoiceAnswers),
+      );
+    });
+
+    const conflicts = Effect.fn("Jev.conflicts")(function* (
+      rules: ReadonlyArray<ComparedRule>,
+      partners: ReadonlyArray<ReadonlyArray<number>>,
+    ) {
+      const answers = yield* answersTo(conflictBody(config.model, rules, partners), ChoiceAnswers);
+      return namedPairs(answers, partners);
+    });
+
+    const contradicts = Effect.fn("Jev.contradicts")(function* (
+      rules: ReadonlyArray<ComparedRule>,
+      pairs: ReadonlyArray<Pair>,
+    ) {
+      return yield* Effect.forEach(
+        pairs,
+        (pair) =>
+          Effect.map(ask(contradictBody(config.model, rules, pair), NoulAnswers), ({ answers }) =>
+            pairProbability(answers, pair),
+          ),
+        { concurrency: 8 },
+      );
     });
 
-    return Jev.of({ judge, locate });
+    return Jev.of({ judge, locate, conflicts, contradicts });
   }),
 );

package/src/services/Jev.ts

@@ -19,13 +19,58 @@ export class Jev extends Context.Service<
       lines: Lines,
       rules: Rules,
     ) => Effect.Effect<Record<RuleId, number>, JevUnavailable>;
+    /**
+     * Per rule, the partner Jev names as impossible to follow in the same code,
+     * as `[rule, partner]` indexes into `rules`. A rule Jev names none for is
+     * left out.
+     */
+    readonly conflicts: (
+      rules: ReadonlyArray<ComparedRule>,
+      partners: ReadonlyArray<ReadonlyArray<number>>,
+    ) => Effect.Effect<ReadonlyArray<Pair>, JevUnavailable>;
+    /**
+     * Per pair, in order, Jev's probability that no code can follow both rules,
+     * each pair asked on its own.
+     */
+    readonly contradicts: (
+      rules: ReadonlyArray<ComparedRule>,
+      pairs: ReadonlyArray<Pair>,
+    ) => Effect.Effect<ReadonlyArray<number>, JevUnavailable>;
   }
 >()("@drkmttr/adhere/services/Jev") {}
 
+/** A rule compared with other rules rather than with a file. */
+export interface ComparedRule {
+  readonly id: RuleId;
+  readonly rule: Rule;
+}
+
+/** Two rules, as indexes into the rules being compared. */
+export type Pair = readonly [number, number];
+
 /** A `choice` question accepts at most this many criteria. */
 const CHOICE_LIMIT = 255;
 const LINES_PER_BLOCK = 20;
-export const MAX_LINES = CHOICE_LIMIT * LINES_PER_BLOCK;
+const MAX_LINES = CHOICE_LIMIT * LINES_PER_BLOCK;
+
+/**
+ * Jev 1.13's context, from its model card: the state with its longest
+ * question, and the state with every question in the request.
+ */
+const QUESTION_CONTEXT = 32_000;
+const REQUEST_CONTEXT = 64_000;
+/** Room for what Jev wraps around a request, which `tokensOf` does not see. */
+const WRAPPER = 1_000;
+
+const encoder = new TextEncoder();
+
+/**
+ * An estimate, meant to run high, of the tokens Jev reads for a value: one
+ * per three bytes of its JSON. Code runs a little over three bytes a token,
+ * prose about four.
+ */
+export const tokensOf = (value: unknown): number =>
+  Math.ceil(encoder.encode(JSON.stringify(value)).length / 3);
 
 export const snippetOf = (line: string): string => line.trim().slice(0, 120);
 
@@ -34,37 +79,61 @@ const isBlank = (line: string): boolean => line.trim().length === 0;
 export const needsBlocks = (lines: Lines): boolean =>
   lines.filter((line) => !isBlank(line)).length > CHOICE_LIMIT;
 
-const stateOf = (lines: Lines, rules: Rules) => ({
+/** The file, numbered so a line question can name a line. The only thing the questions share. */
+const stateOf = (lines: Lines) => ({
   code: lines.map((line, index) => `${index + 1} | ${line}`).join("\n"),
-  rules: Record.map(rules, ({ description, reference, avoid }) => ({
-    description,
-    ...(reference === undefined ? {} : { reference }),
-    ...(avoid === undefined ? {} : { avoid }),
-  })),
 });
 
-const field = (id: RuleId, key: "avoid" | "description" | "reference") =>
-  `state.rules["${id}"].${key}`;
+/** One side of a noul: what it means, with the rule's code for that side as an example. */
+const sideOf = (what: string, example: string | undefined) =>
+  example === undefined ? { what } : { what, examples: [example] };
+
+/** A rule's text as a comparison of rules reads it. Code a rule lacks is left out, not sent empty. */
+const ruleState = ({ description, reference, avoid }: Rule) => ({
+  description,
+  ...(reference === undefined ? {} : { reference }),
+  ...(avoid === undefined ? {} : { avoid }),
+});
 
 /**
- * A rule with a reference asks whether the file diverges from it, with the
- * code to avoid as an example when there is some. A rule without one asks
- * whether the file contains the code to avoid.
+ * The compared rules a question mentions, keyed by index: ids alone would
+ * collide, since a nested rule can share its id with the rule it shadows.
  */
-const judgeInstructions = (id: RuleId, rule: Rule): string =>
-  rule.reference === undefined
-    ? `Does state.code contain the pattern shown in ${field(id, "avoid")}, which ${field(id, "description")} rules out? Answer no if nothing in this file resembles it.`
-    : `Does state.code diverge from the pattern shown in ${field(id, "reference")}${
-        rule.avoid === undefined ? "" : `, for example by doing what ${field(id, "avoid")} shows`
-      }, as described by ${field(id, "description")}? Answer no if the pattern does not apply to this file.`;
-
-/** What the offending line does, for the line and block questions. */
-const offense = (id: RuleId, rule: Rule): string =>
-  rule.reference === undefined
-    ? `shows the pattern in ${field(id, "avoid")}`
-    : rule.avoid === undefined
-      ? `diverges from ${field(id, "reference")}`
-      : `diverges from ${field(id, "reference")} or resembles ${field(id, "avoid")}`;
+const comparedState = (rules: ReadonlyArray<ComparedRule>, mentioned: Iterable<number>) => {
+  const state: Record<string, { readonly id: RuleId } & ReturnType<typeof ruleState>> = {};
+  for (const index of [...new Set(mentioned)].sort((a, b) => a - b)) {
+    const compared = rules[index];
+    if (compared !== undefined) {
+      state[String(index)] = { id: compared.id, ...ruleState(compared.rule) };
+    }
+  }
+  return { rules: state };
+};
+
+/**
+ * Whether the file breaks the rule. The rule rides in the question, not the
+ * state, so each question reads its own rule and no other. The criteria draw
+ * the line: code to avoid is a yes, and the reference is a no, as is a file
+ * with nothing the rule covers.
+ */
+export const judgeQuestion = (rule: Rule) => ({
+  type: "noul" as const,
+  instructions: { question: "Does `code` break `rule`?", rule: rule.description },
+  criteria: {
+    true: sideOf("Part of `code` breaks `rule`", rule.avoid),
+    false: sideOf(
+      "Every part of `code` that `rule` covers follows it, or `rule` covers no part of `code`",
+      rule.reference,
+    ),
+  },
+});
+
+/** The rule as a line question carries it: the description, and its code on either side. */
+const ruleFields = (rule: Rule) => ({
+  rule: rule.description,
+  ...(rule.reference === undefined ? {} : { follows_rule: rule.reference }),
+  ...(rule.avoid === undefined ? {} : { breaks_rule: rule.avoid }),
+});
 
 const lineCriteria = (lines: Lines, from: number, to: number): Record<string, string> => {
   const criteria: Record<string, string> = {};
@@ -77,11 +146,8 @@ const lineCriteria = (lines: Lines, from: number, to: number): Record<string, st
 
 export const judgeBody = (model: string, lines: Lines, rules: Rules) => ({
   model,
-  state: stateOf(lines, rules),
-  questions: Record.map(rules, (rule, id) => ({
-    type: "noul" as const,
-    instructions: judgeInstructions(id, rule),
-  })),
+  state: stateOf(lines),
+  questions: Record.map(rules, (rule) => judgeQuestion(rule)),
 });
 
 export const locateBody = (
@@ -91,12 +157,15 @@ export const locateBody = (
   blocks?: Readonly<Record<RuleId, number>>,
 ) => ({
   model,
-  state: stateOf(lines, rules),
+  state: stateOf(lines),
   questions: Record.map(rules, (rule, id) => {
     const block = blocks?.[id];
     return {
       type: "choice" as const,
-      instructions: `Which line of state.code most clearly ${offense(id, rule)}?`,
+      instructions: {
+        question: "Which line of `code` most clearly breaks `rule`?",
+        ...ruleFields(rule),
+      },
       criteria:
         block === undefined
           ? lineCriteria(lines, 1, lines.length)
@@ -115,11 +184,150 @@ export const blockBody = (model: string, lines: Lines, rules: Rules) => {
   }
   return {
     model,
-    state: stateOf(lines, rules),
-    questions: Record.map(rules, (rule, id) => ({
+    state: stateOf(lines),
+    questions: Record.map(rules, (rule) => ({
       type: "choice" as const,
-      instructions: `Which block of state.code contains the line that most clearly ${offense(id, rule)}?`,
+      instructions: {
+        question: "Which block of `code` contains the line that most clearly breaks `rule`?",
+        ...ruleFields(rule),
+      },
       criteria,
     })),
   };
 };
+
+/**
+ * Whether Jev can take every request a file may need: its lines within two
+ * line choices, and its code beside the longest question any rule asks.
+ */
+export const fits = (lines: Lines, rules: Rules): boolean => {
+  if (lines.length > MAX_LINES) return false;
+  const located = needsBlocks(lines) ? blockBody("", lines, rules) : locateBody("", lines, rules);
+  const questions = [
+    ...Object.values(judgeBody("", lines, rules).questions),
+    ...Object.values(located.questions),
+  ];
+  const longest = Math.max(0, ...questions.map(tokensOf));
+  return tokensOf(stateOf(lines)) + longest <= QUESTION_CONTEXT - WRAPPER;
+};
+
+export interface Body {
+  readonly model: string;
+  readonly state: unknown;
+  readonly questions: Readonly<Record<string, unknown>>;
+}
+
+/**
+ * A body as requests Jev can take: its questions in order, with a new
+ * request whenever the next question would not fit beside the state and
+ * the questions before it.
+ */
+export const requestsOf = (body: Body): ReadonlyArray<Body> => {
+  const room = REQUEST_CONTEXT - WRAPPER - tokensOf(body.state);
+  const requests: Array<{ readonly questions: Record<string, unknown>; tokens: number }> = [];
+  for (const [id, question] of Object.entries(body.questions)) {
+    const tokens = tokensOf(question);
+    const last = requests.at(-1);
+    if (last !== undefined && last.tokens + tokens <= room) {
+      last.questions[id] = question;
+      last.tokens += tokens;
+    } else {
+      requests.push({ questions: { [id]: question }, tokens });
+    }
+  }
+  return requests.map(({ questions }) => ({ ...body, questions }));
+};
+
+/** The requests judging `rules` over a file takes: the judge body, split to fit, as `judge` sends it. */
+export const judgeRequests = (lines: Lines, rules: Rules): number =>
+  requestsOf(judgeBody("", lines, rules)).length;
+
+/**
+ * The requests locating `rules` in a file takes, split to fit as `locate`
+ * sends them: a block choice first for a long file, then a line choice. For a
+ * long file the line choice is counted before a block is chosen, so it can
+ * run high.
+ */
+export const locateRequests = (lines: Lines, rules: Rules): number =>
+  (needsBlocks(lines) ? requestsOf(blockBody("", lines, rules)).length : 0) +
+  requestsOf(locateBody("", lines, rules)).length;
+
+/** A choice keeps one criterion for "none", which leaves this many for partners. */
+const PARTNERS_PER_QUESTION = CHOICE_LIMIT - 1;
+
+interface ChoiceQuestion {
+  readonly type: "choice";
+  readonly instructions: string;
+  readonly criteria: Record<string, string>;
+}
+
+/**
+ * Per rule, one `choice` among the rules that apply to the same files: which
+ * of them cannot be followed in the same code, or none. The questions grow
+ * with the rules, not with every pair of them. A rule with more partners than
+ * a choice holds gets one question per chunk, keyed `rule:chunk`.
+ */
+export const conflictBody = (
+  model: string,
+  rules: ReadonlyArray<ComparedRule>,
+  partners: ReadonlyArray<ReadonlyArray<number>>,
+) => {
+  const questions: Record<string, ChoiceQuestion> = {};
+  const mentioned: Array<number> = [];
+  partners.forEach((some, index) => {
+    for (let chunk = 0; chunk * PARTNERS_PER_QUESTION < some.length; chunk++) {
+      const from = chunk * PARTNERS_PER_QUESTION;
+      const offered = some.slice(from, from + PARTNERS_PER_QUESTION);
+      const criteria: Record<string, string> = { none: "None of them" };
+      for (const partner of offered) {
+        criteria[String(partner)] = rules[partner]?.rule.description ?? "";
+      }
+      mentioned.push(index, ...offered);
+      questions[`${index}:${chunk}`] = {
+        type: "choice",
+        instructions: `Each choice other than none is the rule in state.rules under its key. Which of them demands the opposite of what state.rules["${index}"] demands of the same code, so that following one breaks the other? Choose none if code can follow each of them alongside it.`,
+        criteria,
+      };
+    }
+  });
+  return { model, state: comparedState(rules, mentioned), questions };
+};
+
+const pairKey = ([first, second]: Pair): string => `${first}-${second}`;
+
+/**
+ * A `noul` for one pair Jev named: do the two rules demand opposite things of
+ * the same code? One pair per request, with only its two rules in the state.
+ * Other rules beside them dilute the judgment: over the effect preset, a real
+ * contradiction scored 0.89 alone and 0.59 among the other named pairs.
+ */
+export const contradictBody = (model: string, rules: ReadonlyArray<ComparedRule>, pair: Pair) => ({
+  model,
+  state: comparedState(rules, pair),
+  questions: {
+    [pairKey(pair)]: {
+      type: "noul" as const,
+      instructions: `Do state.rules["${pair[0]}"] and state.rules["${pair[1]}"] demand opposite things of the same code, so that following one breaks the other? Answer no if code can follow both, or if they are about different things.`,
+    },
+  },
+});
+
+/**
+ * The pairs a conflict answer names: per question, the partner Jev chose, when
+ * it was one the question offered. "none", or a stray answer, names no pair.
+ */
+export const namedPairs = (
+  answers: Readonly<Record<string, { readonly choice: string }>>,
+  partners: ReadonlyArray<ReadonlyArray<number>>,
+): ReadonlyArray<Pair> =>
+  Object.entries(answers).flatMap(([key, { choice }]): ReadonlyArray<Pair> => {
+    const rule = Number(key.split(":")[0]);
+    const partner = Number(choice);
+    return partners[rule]?.includes(partner) === true ? [[rule, partner]] : [];
+  });
+
+/** The probability a contradiction answer gives its pair; 0 when it gives none. */
+export const pairProbability = (
+  answers: Readonly<Record<string, { readonly noul: number }>>,
+  pair: Pair,
+): number => answers[pairKey(pair)]?.noul ?? 0;