~ knotless Search/
↑↓ move↵ open⇧↵ all results

grain.social/grain-support-agent

grain's support agent: triages mentions and reports, investigates bugs, proposes fixes

1 collaborator
0
0
main
341 lines · 12.7 KB Raw History
import { DatabaseSync } from "node:sqlite";
import { mkdirSync } from "node:fs";
import { join } from "node:path";
import { config } from "./config.ts";

// The work queue. One row per thing that came in from outside: a Bluesky post,
// a user report, or a report one of the appview's classifiers filed. `status` is where it sits in the pipeline:
//
//   new           waiting for triage
//   needs_review  triage was unsure, or it is a moderation matter; a person looks
//   triaged       understood, no investigation wanted (praise, a question, ...)
//   investigate   queued for the investigation agent
//   investigating the agent is on it
//   reported      the agent wrote a report
//   failed        triage or investigation errored; `error` says why
//   done          a person dealt with it
//   dismissed     not about grain, or spam

export type Status =
  | "new"
  | "needs_review"
  | "triaged"
  | "investigate"
  | "investigating"
  | "reported"
  | "failed"
  | "done"
  | "dismissed";

export type Source = "bluesky" | "report" | "classifier";

export interface Item {
  id: number;
  source: Source;
  source_ref: string;
  author: string;
  text: string;
  url: string;
  images: string[];
  received_at: string;
  status: Status;
  triage: Triage | null;
  route_reason: string;
  session_id: string;
  investigated_at: string;
  report: string;
  cost: number;
  error: string;
  updated_at: string;
  fix_repo: string;
  fix_session_id: string;
  fix_branch: string;
  fix_status: FixStatus;
  fix_summary: string;
  fix_title: string;
  fix_body: string;
  fix_pr_url: string;
  fix_error: string;
  /** JSON: for each repository, Clef's probability that the fix needs it. */
  fix_targets: string;
  /** What the person asked the fix agent, kept so a fix cut off before it began can start again. */
  fix_instructions: string;
  /** A follow-up question the investigation agent is answering. Empty when none is. */
  chat_pending: string;
  chat_error: string;
  /** JSON: the fix's before and after screenshots, see screenshots.ts. */
  fix_shots: string;
  /** For a report: the DID of the account it concerns. */
  subject_did: string;
  /** For a report: what it is about, an at:// URI or, for an account, its DID. */
  subject_uri: string;
  /** JSON Moderation: an action the agent proposed that waits for the maintainer's click. */
  moderation_pending: string;
  /** JSON Moderation: the action taken on the report's subject, once it is. */
  moderation_done: string;
  /**
   * 1 for a report about the safety of a child, or on an account that is (see
   * child-safety.ts): `text` is for a person alone, and `report` holds what a
   * model may read of it.
   */
  child_safety: number;
}

// A fix, at most one per item:
//   working    the fix agent is editing
//   ready      it finished; the diff waits for a person
//   failed     the agent errored; fix_error says why
//   pr_open    a person approved it and a draft pull request is open
export type FixStatus = "" | "working" | "ready" | "failed" | "pr_open";

export interface Triage {
  relevant: number;
  kind: string;
  kindConfidence: number;
  severity: number;
  area: string;
  platform: string;
  needsReply: number;
}

mkdirSync(config.stateDir, { recursive: true });
const db = new DatabaseSync(join(config.stateDir, "agent.db"));
db.exec(`
  PRAGMA journal_mode = WAL;
  PRAGMA busy_timeout = 5000;
  CREATE TABLE IF NOT EXISTS items (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    source TEXT NOT NULL,
    source_ref TEXT NOT NULL,
    author TEXT NOT NULL DEFAULT '',
    text TEXT NOT NULL DEFAULT '',
    url TEXT NOT NULL DEFAULT '',
    images TEXT NOT NULL DEFAULT '[]',
    received_at TEXT NOT NULL,
    status TEXT NOT NULL DEFAULT 'new',
    triage TEXT,
    route_reason TEXT NOT NULL DEFAULT '',
    session_id TEXT NOT NULL DEFAULT '',
    investigated_at TEXT NOT NULL DEFAULT '',
    report TEXT NOT NULL DEFAULT '',
    cost REAL NOT NULL DEFAULT 0,
    error TEXT NOT NULL DEFAULT '',
    updated_at TEXT NOT NULL,
    UNIQUE (source, source_ref)
  );
  CREATE INDEX IF NOT EXISTS items_status ON items (status, id);
  -- A person's correction of a triage call. Kept from day one so there is
  -- labeled data if Clef is ever fine-tuned on grain's traffic.
  CREATE TABLE IF NOT EXISTS triage_feedback (
    item_id INTEGER NOT NULL,
    field TEXT NOT NULL,
    predicted TEXT NOT NULL,
    corrected TEXT NOT NULL,
    created_at TEXT NOT NULL
  );
  CREATE TABLE IF NOT EXISTS cursors (
    name TEXT PRIMARY KEY,
    value TEXT NOT NULL
  );
`);

// Columns added after the table first shipped. ADD COLUMN for each one a
// database is missing, so an existing queue keeps its rows.
const LATER_COLUMNS: Record<string, string> = {
  fix_repo: "TEXT NOT NULL DEFAULT ''",
  fix_session_id: "TEXT NOT NULL DEFAULT ''",
  fix_branch: "TEXT NOT NULL DEFAULT ''",
  fix_status: "TEXT NOT NULL DEFAULT ''",
  fix_summary: "TEXT NOT NULL DEFAULT ''",
  fix_title: "TEXT NOT NULL DEFAULT ''",
  fix_body: "TEXT NOT NULL DEFAULT ''",
  fix_pr_url: "TEXT NOT NULL DEFAULT ''",
  fix_error: "TEXT NOT NULL DEFAULT ''",
  fix_targets: "TEXT NOT NULL DEFAULT ''",
  fix_instructions: "TEXT NOT NULL DEFAULT ''",
  chat_pending: "TEXT NOT NULL DEFAULT ''",
  chat_error: "TEXT NOT NULL DEFAULT ''",
  fix_shots: "TEXT NOT NULL DEFAULT ''",
  subject_did: "TEXT NOT NULL DEFAULT ''",
  subject_uri: "TEXT NOT NULL DEFAULT ''",
  moderation_pending: "TEXT NOT NULL DEFAULT ''",
  moderation_done: "TEXT NOT NULL DEFAULT ''",
  child_safety: "INTEGER NOT NULL DEFAULT 0",
};
const existing = new Set(db.prepare(`SELECT name FROM pragma_table_info('items')`).all().map((r) => String(r.name)));
for (const [column, type] of Object.entries(LATER_COLUMNS)) {
  if (!existing.has(column)) db.exec(`ALTER TABLE items ADD COLUMN ${column} ${type}`);
}
db.exec(
  `UPDATE items SET route_reason = substr(route_reason, 1, length(route_reason) - length(': gathering evidence'))
   WHERE route_reason LIKE '%: gathering evidence' AND status NOT IN ('investigate', 'investigating')`,
);
// Reports queued before subject_did existed carry the subject only in their
// text, on the "Subject:" line the poller writes ahead of anything a person typed.
for (const row of db.prepare(`SELECT id, text FROM items WHERE source != 'bluesky' AND subject_uri = ''`).all()) {
  const m = String(row.text).match(/^Subject: ((?:at:\/\/)?(did:[a-z0-9]+:[A-Za-z0-9._:%-]+)\S*)/m);
  if (m) db.prepare(`UPDATE items SET subject_uri = ?, subject_did = ? WHERE id = ?`).run(m[1], m[2], Number(row.id));
}
// Reports queued before child_safety existed whose own label or reason type is
// child safety, as the poller wrote them: any brief a model wrote of one is
// dropped. An earlier report on an account that is child safety is caught
// when a model would next read it.
db.exec(
  `UPDATE items SET child_safety = 1, report = ''
   WHERE source != 'bluesky' AND child_safety = 0
     AND (text LIKE 'Report label: csae%' OR text LIKE '% filed a csae report.%' OR text LIKE '%Reason type: tools.ozone.report.defs#reasonChildSafety%')`,
);

const now = () => new Date().toISOString();

function hydrate(row: Record<string, unknown>): Item {
  return {
    ...(row as unknown as Item),
    images: JSON.parse(String(row.images)),
    triage: row.triage ? JSON.parse(String(row.triage)) : null,
  };
}

/** Adds an item unless one with the same source reference exists. Returns whether it was new. */
export function enqueue(item: {
  source: Source;
  source_ref: string;
  author: string;
  text: string;
  url: string;
  images?: string[];
  received_at: string;
  status?: Status;
  route_reason?: string;
  report?: string;
  subject_did?: string;
  subject_uri?: string;
  child_safety?: boolean;
}): boolean {
  const result = db
    .prepare(
      `INSERT OR IGNORE INTO items (source, source_ref, author, text, url, images, received_at, status, updated_at, subject_did, subject_uri, route_reason, report, child_safety)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
    )
    .run(
      item.source,
      item.source_ref,
      item.author,
      item.text,
      item.url,
      JSON.stringify(item.images ?? []),
      item.received_at,
      item.status ?? "new",
      now(),
      item.subject_did ?? "",
      item.subject_uri ?? "",
      item.route_reason ?? "",
      item.report ?? "",
      item.child_safety ? 1 : 0,
    );
  return result.changes > 0;
}

export function get(id: number): Item | undefined {
  const row = db.prepare(`SELECT * FROM items WHERE id = ?`).get(id);
  return row ? hydrate(row) : undefined;
}

// The dashboard's tabs. Each item is in exactly one: closed items by their
// status, then anything an agent is working on, then open pull requests, then
// whatever waits on a person. Fixed SQL only; nothing here comes from a request.
const CLOSED = `status IN ('done', 'dismissed')`;
const WORKING = `(status IN ('new', 'investigate', 'investigating') OR fix_status = 'working' OR chat_pending != '')`;
const PR_OPEN = `fix_status = 'pr_open'`;

export const VIEWS = {
  inbox: { label: "Needs you", where: `NOT ${CLOSED} AND NOT ${WORKING} AND NOT ${PR_OPEN} AND status IN ('needs_review', 'reported', 'failed')` },
  working: { label: "In progress", where: `NOT ${CLOSED} AND ${WORKING}` },
  pr: { label: "PR open", where: `NOT ${CLOSED} AND NOT ${WORKING} AND ${PR_OPEN}` },
  triaged: { label: "Triaged", where: `status = 'triaged' AND NOT ${WORKING} AND NOT ${PR_OPEN}` },
  done: { label: "Done", where: `status = 'done'` },
  dismissed: { label: "Dismissed", where: `status = 'dismissed'` },
} as const;

export type View = keyof typeof VIEWS;

export function list(view: View, limit = 200): Item[] {
  return db.prepare(`SELECT * FROM items WHERE ${VIEWS[view].where} ORDER BY id DESC LIMIT ?`).all(limit).map(hydrate);
}

export function counts(): Record<View, number> {
  const out = {} as Record<View, number>;
  for (const view of Object.keys(VIEWS) as View[]) {
    out[view] = Number(db.prepare(`SELECT COUNT(*) AS n FROM items WHERE ${VIEWS[view].where}`).get()?.n ?? 0);
  }
  return out;
}

/** The oldest item in a status, for the workers to take next. */
export function next(status: Status): Item | undefined {
  const row = db.prepare(`SELECT * FROM items WHERE status = ? ORDER BY id LIMIT 1`).get(status);
  return row ? hydrate(row) : undefined;
}

type Updatable = Omit<Item, "id" | "source" | "source_ref" | "author" | "text" | "url" | "images" | "received_at" | "updated_at">;

export function update(id: number, fields: Partial<Updatable>): void {
  const sets: string[] = [];
  const values: (string | number | null)[] = [];
  for (const [key, value] of Object.entries(fields)) {
    sets.push(`${key} = ?`);
    values.push(key === "triage" ? JSON.stringify(value) : (value as string | number));
  }
  sets.push("updated_at = ?");
  values.push(now(), id);
  db.prepare(`UPDATE items SET ${sets.join(", ")} WHERE id = ?`).run(...values);
}

/** Investigations started since UTC midnight, for the daily cap. */
export function investigationsToday(): number {
  const midnight = new Date().toISOString().slice(0, 10);
  const row = db
    .prepare(`SELECT COUNT(*) AS n FROM items WHERE investigated_at >= ?`)
    .get(midnight);
  return Number(row?.n ?? 0);
}

export function recordFeedback(itemId: number, field: string, predicted: string, corrected: string): void {
  db.prepare(
    `INSERT INTO triage_feedback (item_id, field, predicted, corrected, created_at) VALUES (?, ?, ?, ?, ?)`,
  ).run(itemId, field, predicted, corrected, now());
}

export function getCursor(name: string): string | undefined {
  const row = db.prepare(`SELECT value FROM cursors WHERE name = ?`).get(name);
  return row ? String(row.value) : undefined;
}

export function setCursor(name: string, value: string): void {
  db.prepare(
    `INSERT INTO cursors (name, value) VALUES (?, ?) ON CONFLICT (name) DO UPDATE SET value = excluded.value`,
  ).run(name, value);
}

/** Adds to an item's running spend. */
export function addCost(id: number, cost: number): void {
  db.prepare(`UPDATE items SET cost = cost + ? WHERE id = ?`).run(cost, id);
}

/**
 * Work a restart cut off. An investigation that had not yet opened a session
 * just goes back on the queue; anything with a session is returned so it can
 * be picked up where it stopped.
 */
export function interrupted(): { investigations: Item[]; chats: Item[]; fixes: Item[]; screenshots: Item[] } {
  db.prepare(
    `UPDATE items SET status = 'investigate', updated_at = ? WHERE status = 'investigating' AND session_id = ''`,
  ).run(now());
  const rows = (where: string) => db.prepare(`SELECT * FROM items WHERE ${where}`).all().map(hydrate);
  return {
    investigations: rows(`status = 'investigating'`),
    chats: rows(`chat_pending != ''`),
    fixes: rows(`fix_status = 'working'`),
    screenshots: rows(`fix_status != 'working' AND fix_shots LIKE '{"status":"running"%'`),
  };
}