import { useState } from "react";
import type {
AdaptationRule,
TriggerProof,
} from "../../../../hooks/lib/adaptation-rules";
import type { OpinionEffect } from "../../../../hooks/lib/correction-rates";
import type {
ActiveRule,
DraftRule,
PageDecision,
PipelineCandidate,
RelationshipView,
} from "../../relationship";
import { Badge } from "../components/badge";
import { Button } from "../components/button";
import { clock } from "../format";
import { Empty, Panel, Pending } from "../frame";
import { useLoaded } from "../lib/api";
import { decideRule } from "../lib/write";
const REACTIONS = ["approved", "follow-up", "new-topic", "corrected", "repeated"];
function proofLine(proof: TriggerProof | undefined): string {
if (!proof) return "not proven";
return `fired on ${proof.firedCorrections}/${proof.corrections} corrections, ${proof.firedOrdinary}/${proof.ordinary} ordinary turns`;
}
function Facts({ rows }: { rows: [string, string | undefined][] }) {
return (
{rows
.filter(([, value]) => value)
.map(([label, value]) => (
- {label}
- {value}
))}
);
}
function triggerLine(rule: AdaptationRule): string {
if (rule.delivery === "always") return "none, an opinion steers every session";
return rule.trigger ? `${rule.trigger.side} · /${rule.trigger.pattern}/i` : "none";
}
function ruleFacts(rule: AdaptationRule): [string, string | undefined][] {
return [
["trigger", triggerLine(rule)],
["steering", rule.steering],
["check", rule.check],
["proof", proofLine(rule.proof)],
];
}
function Evidence({ items }: { items: string[] }) {
if (items.length === 0) return null;
return (
{items.map((item) => (
- {item}
))}
);
}
function replacedTrigger(rule: AdaptationRule, active: ActiveRule[]): string | undefined {
if (!rule.widens) return undefined;
const target = active.find((r) => r.id === rule.widens);
if (!target?.trigger) return `the trigger of rule ${rule.widens}`;
return `/${target.trigger.pattern}/i`;
}
function useDecision(id: string, onDecided: () => void) {
const [error, setError] = useState(null);
const [busy, setBusy] = useState(false);
const decide = (decision: PageDecision) => {
setBusy(true);
void decideRule(id, decision).then((failure) => {
setBusy(false);
setError(failure);
if (!failure) onDecided();
});
};
return { error, busy, decide };
}
function Refusal({ error }: { error: string | null }) {
if (!error) return null;
return (
{error}
);
}
function offeredDecisions(rule: AdaptationRule): [PageDecision, string][] {
if (rule.widens) return [["approved", "Approve"]];
const asOpinion: [PageDecision, string][] =
rule.kind && !rule.opinionGate ? [["opinion", "Keep as opinion"]] : [];
if (rule.offer === "opinion-only") return asOpinion;
return [["approved", "Approve as rule"], ...asOpinion];
}
function offerLine(rule: AdaptationRule): string | undefined {
if (rule.offer !== "opinion-only" || rule.opinionGate) return undefined;
const why = rule.trigger ? "the trigger did not prove" : "no trigger";
return `${why}; keep it as an opinion or deny it`;
}
function Draft({
rule,
active,
onDecided,
}: {
rule: DraftRule;
active: ActiveRule[];
onDecided: () => void;
}) {
const { error, busy, decide } = useDecision(rule.id, onDecided);
return (
{rule.when}
{offeredDecisions(rule).map(([decision, label], i) => (
))}
);
}
function firingLine(rule: ActiveRule): string {
const { fired, sentBack, judged, correctedAfter } = rule.effect;
if (fired === 0) return "has not fired yet";
const back = rule.trigger?.side === "reply" ? `, sent back ${sentBack}` : "";
return `fired ${fired}${back} · corrected after ${correctedAfter} of ${judged} judged`;
}
function windowsLine({ before, after }: Pick): string {
return `${before.per100.toFixed(1)}/100 before (${before.count} in ${before.turns}) → ${after.per100.toFixed(1)}/100 after (${after.count} in ${after.turns})`;
}
function effectRows(rule: ActiveRule): [string, string | undefined][] {
const opinion = rule.opinionEffect;
if (!opinion) return [["effect", firingLine(rule)]];
return [
["kind", opinion.kind],
["effect", `${windowsLine(opinion)} · ${opinion.verdict}`],
["other kinds", windowsLine(opinion.control)],
];
}
function Active({ rule, onDecided }: { rule: ActiveRule; onDecided: () => void }) {
const { error, busy, decide } = useDecision(rule.id, onDecided);
return (
{rule.when}
);
}
function percent(part: number, whole: number): string {
return whole === 0 ? "—" : `${Math.round((part / whole) * 100)}%`;
}
function LastDays({ view }: { view: RelationshipView }) {
const { turns } = view;
const corrected = turns.byReaction.corrected ?? 0;
return (
{REACTIONS.map((reaction) => (
{reaction} {turns.byReaction[reaction] ?? 0}
))}
{turns.recentCorrections.length === 0 ? (
No confirmed correction in this window.
) : (
{turns.recentCorrections.map((c) => (
-
{clock(c.ts)}
{c.issue}
“{c.message}”
))}
)}
);
}
function pipelineLine(candidate: PipelineCandidate): string {
if (candidate.verdict === "waiting")
return `needs ${candidate.ordinaryNeeded} more ordinary turns`;
return `failed · ${proofLine(candidate.proof)}`;
}
function Pipeline({ candidates }: { candidates: PipelineCandidate[] }) {
return (
{candidates.length === 0 ? (
Nothing being proven.
) : (
candidates.map((candidate) => (
{candidate.when}
{pipelineLine(candidate)}
))
)}
);
}
function Denied({ rules }: { rules: AdaptationRule[] }) {
if (rules.length === 0) return null;
return (
{rules.length} denied
{rules.map((rule) => (
-
{rule.when}
{rule.steering}
))}
);
}
export function Relationship() {
const [version, setVersion] = useState(0);
const view = useLoaded(`/api/relationship?v=${version}`);
if (view.state !== "ready") return ;
const { drafts, active, denied, pipeline } = view.data;
const reload = () => setVersion(version + 1);
return (
{drafts.length === 0 ? (
No rule draft waits for a decision.
) : (
drafts.map((rule) => (
))
)}
{active.length === 0 ? (
No rule approved yet.
) : (
active.map((rule) => )
)}
);
}