attention-manifest-protocol 0.4.2 → 0.4.4

package/src/diagnosis/frame.ts

@@ -1,256 +0,0 @@
-import { LayerOrder, clamp01 } from "./types.ts";
-import type {
-    DiagnosticFrame,
-    DiagnosticLayer,
-    DiagnosticSignal,
-    DiagnosticStep,
-    Hypothesis,
-    HypothesisAssessment,
-    IncidentInput,
-    SignalPattern,
-} from "./types.ts";
-import { stepsFor } from "./checklist.ts";
-import type { PlanTask } from "../goal/plan.ts";
-import type { ActionPlan } from "../runtime/action.ts";
-
-export const DefaultHypotheses: readonly Hypothesis[] = [
-    {
-        id: "thread_pool_exhaustion",
-        cause: "worker threads are exhausted or blocked",
-        layer: "thread_pool",
-        supports: [
-            { layer: "thread_pool", kind: "saturation", name: "thread.queue" },
-            { layer: "thread_pool", kind: "utilization", name: "thread.active_max" },
-            { layer: "thread_pool", kind: "errors", name: "thread.reject" },
-        ],
-        contradicts: [{ layer: "thread_pool", kind: "utilization", name: "thread.idle" }],
-        discriminatingTest: "thread dump: are active threads blocked on a pool, a lock, or CPU?",
-        baseConfidence: 0.25,
-        rootWeight: 0,
-    },
-    {
-        id: "connection_pool_exhaustion",
-        cause: "connection pool is exhausted or leaking",
-        layer: "connection_pool",
-        supports: [
-            { layer: "connection_pool", kind: "saturation", name: "pool.pending" },
-            { layer: "connection_pool", kind: "utilization", name: "pool.active_max" },
-            { layer: "connection_pool", kind: "latency", name: "pool.checkout_wait" },
-        ],
-        contradicts: [{ layer: "connection_pool", kind: "utilization", name: "pool.idle" }],
-        discriminatingTest: "checkout wait vs active vs held-time: pool exhaustion, leak, or slow owner?",
-        baseConfidence: 0.25,
-        rootWeight: 0,
-    },
-    {
-        id: "connect_latency",
-        cause: "new connections are slow to establish",
-        layer: "connect",
-        supports: [
-            { layer: "connect", kind: "latency", name: "connect.p99" },
-            { layer: "connect", kind: "errors", name: "connect.error" },
-            { layer: "connect", kind: "latency", name: "tls.handshake" },
-        ],
-        contradicts: [{ layer: "connect", kind: "latency", name: "connect.ok" }],
-        discriminatingTest: "split connect into TCP RTT, TLS, auth, DNS; is pool wait high while active is low?",
-        baseConfidence: 0.25,
-        rootWeight: 0.1,
-    },
-    {
-        id: "db_slow_query",
-        cause: "database queries are slow",
-        layer: "database",
-        supports: [
-            { layer: "database", kind: "latency", name: "db.query_p99" },
-            { layer: "database", kind: "utilization", name: "db.cpu" },
-            { layer: "database", kind: "saturation", name: "db.temp_spill" },
-        ],
-        contradicts: [{ layer: "database", kind: "latency", name: "db.query_ok" }],
-        discriminatingTest: "EXPLAIN ANALYZE: seq scan, temp spill, bad row estimate, or missing index?",
-        baseConfidence: 0.25,
-        rootWeight: 0.15,
-    },
-    {
-        id: "db_lock",
-        cause: "database locks are blocking progress",
-        layer: "database",
-        supports: [
-            { layer: "database", kind: "saturation", name: "db.lock_wait" },
-            { layer: "database", kind: "saturation", name: "db.blocking_chain" },
-        ],
-        contradicts: [{ layer: "database", kind: "saturation", name: "db.no_lock_wait" }],
-        discriminatingTest: "pg_locks + pg_blocking_pids: who blocks whom, and for how long?",
-        baseConfidence: 0.25,
-        rootWeight: 0.15,
-    },
-    {
-        id: "queue_backlog",
-        cause: "consumers cannot keep up with the queue",
-        layer: "queue",
-        supports: [
-            { layer: "queue", kind: "saturation", name: "queue.lag" },
-            { layer: "queue", kind: "latency", name: "queue.consume_rate" },
-            { layer: "queue", kind: "errors", name: "queue.retry" },
-        ],
-        contradicts: [{ layer: "queue", kind: "saturation", name: "queue.drained" }],
-        discriminatingTest: "lag with idle consumers (blocked) vs busy consumers (capacity)?",
-        baseConfidence: 0.2,
-        rootWeight: 0.1,
-    },
-    {
-        id: "code_regression",
-        cause: "application code or GC is the bottleneck",
-        layer: "application",
-        supports: [
-            { layer: "application", kind: "utilization", name: "app.cpu" },
-            { layer: "application", kind: "saturation", name: "app.gc_pause" },
-            { layer: "release", kind: "errors", name: "release.only_new_version" },
-        ],
-        contradicts: [{ layer: "database", kind: "latency", name: "db.query_p99" }],
-        discriminatingTest: "DB fast + app CPU/GC high + blocked stack in app code?",
-        baseConfidence: 0.2,
-        rootWeight: 0.1,
-    },
-];
-
-const patternMatches = (pattern: SignalPattern, signal: DiagnosticSignal): boolean => {
-    if (pattern.layer !== signal.layer) {
-        return false;
-    }
-    if (pattern.kind !== (void 0) && pattern.kind !== signal.kind) {
-        return false;
-    }
-    if (pattern.name !== (void 0) && signal.name !== pattern.name && !signal.name.startsWith(`${pattern.name}.`)) {
-        return false;
-    }
-    return true;
-};
-
-const label = (pattern: SignalPattern): string => [pattern.layer, pattern.kind, pattern.name].filter((part) => part !== (void 0)).join(".");
-
-export const assessHypotheses = (frame: DiagnosticFrame): HypothesisAssessment[] => {
-    return frame.hypotheses
-        .map((hypothesis) => {
-            const matched = hypothesis.supports.filter((pattern) => frame.incident.signals?.some((signal) => patternMatches(pattern, signal))).map(label);
-            const contradicted = (hypothesis.contradicts ?? [])
-                .filter((pattern) => frame.incident.signals?.some((signal) => patternMatches(pattern, signal)))
-                .map(label);
-            const missing = hypothesis.supports.filter((pattern) => !matched.includes(label(pattern))).map(label);
-            const score = matched.length - contradicted.length * 2;
-            return {
-                hypothesis,
-                score,
-                confidence: clamp01(hypothesis.baseConfidence + matched.length * 0.12 + (hypothesis.rootWeight ?? 0) - contradicted.length * 0.2),
-                matched,
-                missing,
-                contradicted,
-            };
-        })
-        .sort((left, right) => right.confidence - left.confidence || right.score - left.score);
-};
-
-export const selectHypothesis = (frame: DiagnosticFrame): HypothesisAssessment | undefined => assessHypotheses(frame)[0];
-
-export const buildDiagnosisFrame = (incident: IncidentInput): DiagnosticFrame => {
-    const layers = incident.layers ?? LayerOrder;
-    return {
-        id: `diag.${incident.id}`,
-        incident,
-        layers: [...layers],
-        hypotheses: DefaultHypotheses.map((hypothesis) => ({ ...hypothesis })),
-        steps: stepsFor(layers),
-        phase: (incident.signals?.length ?? 0) > 0 ? "observing" : "framing",
-    };
-};
-
-/**
- * Add an observation without mutating the original frame.
- */
-export const observe = (frame: DiagnosticFrame, signal: DiagnosticSignal): DiagnosticFrame => ({
-    ...frame,
-    incident: { ...frame.incident, signals: [...(frame.incident.signals ?? []), signal] },
-    phase: frame.phase === "framing" ? "observing" : frame.phase,
-});
-
-export const nextStep = (frame: DiagnosticFrame): DiagnosticStep | undefined => frame.steps[0];
-
-/**
- * Route to the step that best matches the current evidence. The static layer
- * order is only a fallback: a strong DB hypothesis must not be routed to
- * `thread_pool` just because it is first in the checklist.
- */
-export const routeStep = (frame: DiagnosticFrame, minConfidence = 0.5): DiagnosticStep | undefined => {
-    const top = selectHypothesis(frame);
-    if (top !== (void 0) && top.confidence >= minConfidence) {
-        const matched = frame.steps.find((step) => step.layer === top.hypothesis.layer);
-        if (matched !== (void 0)) {
-            return matched;
-        }
-    }
-    return nextStep(frame);
-};
-
-export const validateDiagnosisFrame = (frame: DiagnosticFrame): string[] => {
-    const problems: string[] = [];
-    if (frame.layers.length === 0) {
-        problems.push("diagnosis requires at least one layer");
-    }
-    if (frame.hypotheses.length === 0) {
-        problems.push("diagnosis requires at least one hypothesis");
-    }
-    for (const hypothesis of frame.hypotheses) {
-        if (hypothesis.discriminatingTest.trim().length === 0) {
-            problems.push(`hypothesis ${hypothesis.id} lacks a discriminating test`);
-        }
-    }
-    if (frame.steps.some((step) => step.readOnly !== true)) {
-        problems.push("diagnostic steps must be read-only");
-    }
-    if (new Set(frame.steps.map((step) => step.id)).size !== frame.steps.length) {
-        problems.push("duplicate diagnostic step ids");
-    }
-    return problems;
-};
-
-/**
- * Render the next diagnostic step as a bounded, read-only ActionPlan.
- */
-export const toActionPlan = (frame: DiagnosticFrame): ActionPlan | undefined => {
-    const step = routeStep(frame);
-    if (step === (void 0)) {
-        return undefined;
-    }
-    return {
-        goal: `discriminate the incident cause at ${step.layer}`,
-        intent: `diagnose:${step.layer}`,
-        expectedEffect: `evidence for or against ${step.layer} hypotheses`,
-        preconditions: ["diagnostic step is read-only", "no production mutation before discrimination"],
-        successCriteria: step.successCriteria,
-        risk: "read",
-    };
-};
-
-/**
- * Render diagnostic steps as existing PlanTasks (all irreversibility 0).
- */
-export const toPlanTasks = (frame: DiagnosticFrame): PlanTask[] =>
-    frame.steps.map((step, index) => ({
-        id: step.id,
-        intent: step.intent,
-        actor: "tool",
-        pre: index === 0 ? [] : [frame.steps[index - 1].id],
-        expect: { observation: step.probe, check: step.successCriteria.join("; ") },
-        irreversibility: 0,
-        status: "pending",
-    }));
-
-/**
- * Select the layer that best explains the current evidence, with an explicit reason.
- */
-export const selectLayer = (frame: DiagnosticFrame): { layer: DiagnosticLayer | null; reason: string } => {
-    const top = selectHypothesis(frame);
-    if (top === (void 0)) {
-        return { layer: null, reason: "no hypotheses" };
-    }
-    return { layer: top.hypothesis.layer, reason: `${top.hypothesis.id} confidence=${top.confidence.toFixed(2)} matched=${top.matched.join(",") || "none"}` };
-};

package/src/diagnosis/index.ts

@@ -1,5 +0,0 @@
-export * from "./types.ts";
-export * from "./checklist.ts";
-export * from "./frame.ts";
-export * from "./context.ts";
-export * from "./router.ts";

package/src/diagnosis/router.ts

@@ -1,72 +0,0 @@
-/**
- * Tool routing: AST/diagnosis candidates -> read-only probe.
- *
- * This is deliberately not an executor. It selects a tool and explains why; the
- * runtime still wraps it in an Action/Operation and approval policy.
- */
-import { selectHypothesis } from "./frame.ts";
-import type { DiagnosticFrame, DiagnosticLayer, HypothesisAssessment } from "./types.ts";
-
-export type ToolIntent = "inspect" | "discriminate" | "confirm" | "refute";
-
-export interface ToolBinding {
-    layer: DiagnosticLayer;
-    hypothesisId?: string;
-    tool: string;
-    intent: ToolIntent;
-    readOnly: true;
-    produces: "metric" | "trace" | "log" | "lock" | "profile";
-}
-
-export interface ToolRoute {
-    tool: string;
-    layer: DiagnosticLayer;
-    hypothesisId?: string;
-    intent: ToolIntent;
-    readOnly: true;
-    reason: string;
-}
-
-export const DefaultToolBindings: readonly ToolBinding[] = [
-    { layer: "thread_pool", tool: "thread_dump", intent: "inspect", readOnly: true, produces: "profile" },
-    { layer: "connection_pool", tool: "pool_stats", intent: "inspect", readOnly: true, produces: "metric" },
-    { layer: "connect", tool: "connect_stats", intent: "inspect", readOnly: true, produces: "metric" },
-    { layer: "database", hypothesisId: "db_lock", tool: "pg_locks", intent: "discriminate", readOnly: true, produces: "lock" },
-    { layer: "database", hypothesisId: "db_slow_query", tool: "pg_stat_statements", intent: "discriminate", readOnly: true, produces: "trace" },
-    { layer: "database", tool: "pg_stat_statements", intent: "inspect", readOnly: true, produces: "trace" },
-    { layer: "queue", tool: "queue_lag", intent: "inspect", readOnly: true, produces: "metric" },
-    { layer: "application", tool: "app_profile", intent: "inspect", readOnly: true, produces: "profile" },
-    { layer: "release", tool: "version_diff", intent: "inspect", readOnly: true, produces: "log" },
-];
-
-type ToolRouter = (frame: DiagnosticFrame, bindings?: readonly ToolBinding[], minConfidence?: number) => ToolRoute | undefined;
-
-export const routeTool: ToolRouter = (frame: DiagnosticFrame, bindings: readonly ToolBinding[] = DefaultToolBindings, minConfidence = 0.5) => {
-    const top: HypothesisAssessment | undefined = selectHypothesis(frame);
-    if (top !== (void 0) && top.confidence >= minConfidence) {
-        const exact: ToolBinding[] = bindings.filter((binding) => binding.layer === top.hypothesis.layer && binding.hypothesisId === top.hypothesis.id);
-        const layer: ToolBinding[] = bindings.filter((binding) => binding.layer === top.hypothesis.layer && binding.hypothesisId === (void 0));
-        const selected: ToolBinding | undefined = exact[0] ?? layer[0];
-        if (selected !== (void 0)) {
-            return {
-                tool: selected.tool,
-                layer: selected.layer,
-                hypothesisId: top.hypothesis.id,
-                intent: selected.intent,
-                readOnly: true,
-                reason: `${top.hypothesis.id} confidence=${top.confidence.toFixed(2)}; matched=${top.matched.join(",") || "none"}`,
-            };
-        }
-    }
-    const fallback: ToolBinding | undefined = bindings.find((binding) => binding.layer === "thread_pool") ?? bindings[0];
-    if (fallback === (void 0)) {
-        return undefined;
-    }
-    return {
-        tool: fallback.tool,
-        layer: fallback.layer,
-        intent: fallback.intent,
-        readOnly: true,
-        reason: top === (void 0) ? "no hypothesis; start with thread dump" : `weak hypothesis confidence=${top.confidence.toFixed(2)}; start with thread dump`,
-    };
-};

package/src/diagnosis/types.ts

@@ -1,89 +0,0 @@
-/**
- * Diagnostic frame: a bounded, read-only investigation of a failing system.
- *
- * This is deliberately independent of the runtime. It can be rendered into a
- * Plan, an Action, or a prompt; it does not execute anything.
- */
-export type DiagnosticLayer = "thread_pool" | "connection_pool" | "connect" | "database" | "queue" | "application" | "release";
-
-export type SignalKind = "utilization" | "saturation" | "errors" | "latency";
-
-export type ObservationState = "ok" | "warn" | "critical";
-
-export interface DiagnosticSignal {
-    layer: DiagnosticLayer;
-    kind: SignalKind;
-    name: string;
-    state: ObservationState;
-    value?: number;
-    note?: string;
-}
-
-export interface SignalPattern {
-    layer: DiagnosticLayer;
-    kind?: SignalKind;
-    name?: string;
-}
-
-export interface Hypothesis {
-    id: string;
-    cause: string;
-    layer: DiagnosticLayer;
-    supports: SignalPattern[];
-    contradicts?: SignalPattern[];
-    /**
-     * A check that separates this cause from its neighbors.
-     */
-    discriminatingTest: string;
-    baseConfidence: number;
-    /**
-     * Root-cause evidence weighs more than a downstream saturation symptom.
-     */
-    rootWeight?: number;
-}
-
-export interface HypothesisAssessment {
-    hypothesis: Hypothesis;
-    score: number;
-    confidence: number;
-    matched: string[];
-    missing: string[];
-    contradicted: string[];
-}
-
-export interface DiagnosticStep {
-    id: string;
-    layer: DiagnosticLayer;
-    intent: string;
-    probe: string;
-    readOnly: true;
-    successCriteria: string[];
-    stopIf?: string;
-}
-
-export interface IncidentInput {
-    id: string;
-    summary: string;
-    symptoms: string[];
-    signals?: DiagnosticSignal[];
-    recentChanges?: string[];
-    constraints?: string[];
-    /**
-     * Optional narrowing; defaults to all layers.
-     */
-    layers?: DiagnosticLayer[];
-}
-
-export interface DiagnosticFrame {
-    id: string;
-    incident: IncidentInput;
-    layers: DiagnosticLayer[];
-    hypotheses: Hypothesis[];
-    steps: DiagnosticStep[];
-    phase: "framing" | "observing" | "discriminating" | "deciding" | "verifying";
-    selected?: string;
-}
-
-export const LayerOrder: readonly DiagnosticLayer[] = ["thread_pool", "connection_pool", "connect", "database", "queue", "application", "release"];
-
-export const clamp01: (value: number) => number = (value: number): number => Math.max(0, Math.min(1, value));

package/src/error/agentError.ts

@@ -1,16 +0,0 @@
-import type { AgentErrorCode } from "../process/agent.ts";
-
-/**
- * Domain error for the agent facets; never a database error.
- */
-export class AgentError extends Error {
-    readonly code: AgentErrorCode;
-    readonly details: readonly string[];
-
-    constructor(code: AgentErrorCode, details: readonly string[] = []) {
-        super(details.length === 0 ? code : `${code}: ${details.join("; ")}`);
-        this.name = "AgentError";
-        this.code = code;
-        this.details = details;
-    }
-}

package/src/error/ampError.ts

@@ -1,20 +0,0 @@
-/**
- * Shared base for AMP errors that carry a machine-readable code and every
- * problem found in one attempt.
- *
- * Boundary rejections are the first user; other fail-closed paths can extend
- * this without changing their own extra fields. The `code` stays narrow through
- * the generic parameter, so `catch (error) { if (error instanceof BoundaryRejection) ... }`
- * still sees a literal union.
- */
-export class AmpError<Code extends string = string> extends Error {
-    readonly code: Code;
-    readonly problems: readonly string[];
-
-    constructor(name: string, code: Code, problems: readonly string[]) {
-        super(`${code}: ${problems.join("; ")}`);
-        this.name = name;
-        this.code = code;
-        this.problems = [...problems];
-    }
-}

package/src/error/authzError.ts

@@ -1,14 +0,0 @@
-/**
- * Authorization errors: a denied capability, or a grant that would amplify
- * rights or lifetime. They share the `AmpError` shape so the kernel can turn
- * any of them into a blocked receipt.
- */
-import { AmpError } from "./ampError.ts";
-
-export type AuthzCode = "permission_denied" | "invalid_grant" | "rights_amplification" | "expiry_amplification" | "unknown_capability";
-
-export class AuthzError extends AmpError<AuthzCode> {
-    constructor(code: AuthzCode, problems: readonly string[]) {
-        super("AuthzError", code, problems);
-    }
-}

package/src/error/boundaryRejection.ts

@@ -1,20 +0,0 @@
-/**
- * Boundary rejections: the only error a constructor in `src/boundary` may throw.
- *
- * The point of the boundary is that an invalid object is never returned. A
- * constructor therefore fails as a whole, carrying every problem it found, so
- * a caller can log one machine-readable reason and one audit receipt instead of
- * a partially valid object that a later checker may or may not notice.
- */
-import { AmpError } from "./ampError.ts";
-
-/**
- * Stable machine-readable reasons; callers may switch on these.
- */
-export type BoundaryCode = "invalid_frame" | "invalid_tool_args" | "unresolvable_ref" | "duplicate_ref" | "invalid_id";
-
-export class BoundaryRejection extends AmpError<BoundaryCode> {
-    constructor(code: BoundaryCode, problems: readonly string[]) {
-        super("BoundaryRejection", code, problems);
-    }
-}

package/src/error/index.ts

@@ -1,7 +0,0 @@
-export * from "./agentError.ts";
-export * from "./ampError.ts";
-export * from "./authzError.ts";
-export * from "./boundaryRejection.ts";
-export * from "./kernelError.ts";
-export * from "./mailboxError.ts";
-export * from "./windowError.ts";

package/src/error/kernelError.ts

@@ -1,27 +0,0 @@
-/**
- * Kernel errors: illegal process/thread transitions and exhausted resources.
- *
- * They share the `AmpError` shape (`code` + every problem found) so a caller can
- * turn any of them into a blocked receipt without special-casing.
- */
-import { AmpError } from "./ampError.ts";
-
-export type KernelCode =
-    | "invalid_process"
-    | "invalid_thread"
-    | "invalid_transition"
-    | "unknown_process"
-    | "unknown_thread"
-    | "budget_exceeded"
-    | "missing_receipt"
-    | "agent_busy"
-    | "claim_failed"
-    | "lease_lost"
-    | "unknown_object"
-    | "duplicate_task";
-
-export class KernelError extends AmpError<KernelCode> {
-    constructor(code: KernelCode, problems: readonly string[]) {
-        super("KernelError", code, problems);
-    }
-}

package/src/error/mailboxError.ts

@@ -1,9 +0,0 @@
-import { AmpError } from "./ampError.ts";
-
-export type MailboxCode = "mailbox_full" | "unknown_message" | "unknown_recipient";
-
-export class MailboxError extends AmpError<MailboxCode> {
-    constructor(code: MailboxCode, problems: readonly string[]) {
-        super("MailboxError", code, problems);
-    }
-}

package/src/error/windowError.ts

@@ -1,12 +0,0 @@
-/**
- * Window errors: the context window cannot hold a page even after eviction.
- */
-import { AmpError } from "./ampError.ts";
-
-export type WindowCode = "window_full" | "unknown_page";
-
-export class WindowError extends AmpError<WindowCode> {
-    constructor(code: WindowCode, problems: readonly string[]) {
-        super("WindowError", code, problems);
-    }
-}

package/src/evaluation/agreement.ts

@@ -1,96 +0,0 @@
-/**
- * Inter-annotator agreement metrics. These are for labeled evaluation, not for
- * model confidence; keep them separate from ECE/Brier.
- */
-
-/**
- * Two label sequences over the same items.
- */
-type LabelList = readonly string[];
-
-/**
- * A pairwise agreement statistic over two label sequences.
- */
-type AgreementFn = (left: LabelList, right: LabelList) => number;
-
-export const agreementRate: AgreementFn = (left: LabelList, right: LabelList): number => {
-    if (left.length !== right.length) {
-        throw new Error("label arrays must have equal length");
-    }
-    if (left.length === 0) {
-        return 1;
-    }
-    let matches: number = 0;
-    for (let index: number = 0; index < left.length; index += 1) {
-        if (left[index] === right[index]) {
-            matches += 1;
-        }
-    }
-    return matches / left.length;
-};
-
-/**
- * Cohen's kappa for two raters over the same categorical labels.
- */
-export const cohenKappa: AgreementFn = (left: LabelList, right: LabelList): number => {
-    if (left.length !== right.length) {
-        throw new Error("label arrays must have equal length");
-    }
-    if (left.length === 0) {
-        return 1;
-    }
-    const observed: number = agreementRate(left, right);
-    const categories: string[] = [...new Set([...left, ...right])];
-    let expected: number = 0;
-    for (let categoryIndex: number = 0; categoryIndex < categories.length; categoryIndex += 1) {
-        const category: string = categories[categoryIndex];
-        const leftRate: number = left.filter((label) => label === category).length / left.length;
-        const rightRate: number = right.filter((label) => label === category).length / right.length;
-        expected += leftRate * rightRate;
-    }
-    if (expected === 1) {
-        return observed === 1 ? 1 : 0;
-    }
-    return (observed - expected) / (1 - expected);
-};
-
-/**
- * Fleiss' kappa for n items x m raters.
- */
-export const fleissKappa: (matrix: readonly LabelList[]) => number = (matrix: readonly LabelList[]): number => {
-    if (matrix.length === 0) {
-        return 1;
-    }
-    const raters: number = matrix[0].length;
-    if (raters === 0 || matrix.some((row) => row.length !== raters)) {
-        throw new Error("ragged rating matrix");
-    }
-    const categories: string[] = [...new Set(matrix.flat())];
-    const total: number = matrix.length * raters;
-    const counts: Map<string, number> = new Map<string, number>();
-    for (let rowIndex: number = 0; rowIndex < matrix.length; rowIndex += 1) {
-        const row: LabelList = matrix[rowIndex];
-        for (let labelIndex: number = 0; labelIndex < row.length; labelIndex += 1) {
-            const label: string = row[labelIndex];
-            counts.set(label, (counts.get(label) ?? 0) + 1);
-        }
-    }
-    const observed: number =
-        matrix.reduce((sum: number, row: LabelList): number => {
-            let agreements: number = 0;
-            for (let categoryIndex: number = 0; categoryIndex < categories.length; categoryIndex += 1) {
-                const category: string = categories[categoryIndex];
-                const count: number = row.filter((label) => label === category).length;
-                agreements += count * (count - 1);
-            }
-            return sum + agreements / (raters * (raters - 1));
-        }, 0) / matrix.length;
-    const expected: number = categories.reduce((sum: number, category: string): number => {
-        const rate: number = (counts.get(category) ?? 0) / total;
-        return sum + rate * rate;
-    }, 0);
-    if (expected === 1) {
-        return observed === 1 ? 1 : 0;
-    }
-    return (observed - expected) / (1 - expected);
-};

package/src/evaluation/index.ts

@@ -1,2 +0,0 @@
-export * from "./agreement.ts";
-export * from "./labels.ts";