@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/src/history/prune.ts

@@ -1,48 +0,0 @@
-import type { HistoryStore } from "./store.ts";
-import type { OwnedRun } from "./types.ts";
-import { text } from "./rows.ts";
-
-function pruneRuns(
-  store: Readonly<HistoryStore>,
-  runs: Readonly<ReadonlyMap<string, OwnedRun>>,
-): boolean {
-  let removed = false;
-  for (const row of store.all("SELECT id FROM runs")) {
-    const id = text(row, "id");
-    if (!runs.has(id)) {
-      store.run("DELETE FROM runs WHERE id=?", id);
-      removed = true;
-    }
-  }
-  return removed;
-}
-
-/** Remove unreferenced projections only after their live ingestion/watch owner releases them. */
-export function pruneHistory(
-  store: Readonly<HistoryStore>,
-  runs: Readonly<ReadonlyMap<string, OwnedRun>>,
-  previousSources: readonly string[] | undefined,
-  release: (id: string, path: string) => void,
-): boolean {
-  if (previousSources?.length === 0) {
-    return false;
-  }
-  return store.transaction(() => {
-    let removed = previousSources === undefined && pruneRuns(store, runs);
-    for (const source of store.all(
-      `SELECT id,path FROM sources WHERE NOT EXISTS (SELECT 1 FROM children WHERE children.source_id=sources.id)${previousSources ? ` AND id IN (${previousSources.map(() => "?").join(",")})` : ""}`,
-      ...(previousSources ?? []),
-    )) {
-      const id = text(source, "id");
-      release(id, text(source, "path"));
-      store.deleteDocuments(id);
-      store.run("DELETE FROM entries WHERE source_id=?", id);
-      store.run("DELETE FROM sources WHERE id=?", id);
-      removed = true;
-    }
-    if (removed) {
-      store.bump();
-    }
-    return removed;
-  });
-}

package/src/history/queries.ts

@@ -1,125 +0,0 @@
-import {
-  HistoryIndexError,
-  type HistoryVersion,
-  type HistoryRunOptions,
-  type HistoryRunPage,
-  type HistoryPageInput,
-  type HistoryPage,
-  type HistorySearchInput,
-  type HistorySearchPage,
-  type HistoryEntryInput,
-  type HistoryEntry,
-  type HistoryByteRef,
-} from "./types.ts";
-import type { HistoryStore } from "./store.ts";
-import { entryRow, type EntryRow, type SourceRow } from "./rows.ts";
-import { QueryScope, type Boundary } from "./query-scope.ts";
-import { RunQueries } from "./run-queries.ts";
-import { TranscriptQueries } from "./transcript-queries.ts";
-import { SearchQueries } from "./search-queries.ts";
-import { validateRecord } from "./selected-record.ts";
-import { compactEntry } from "./preview.ts";
-import { hasText } from "./text.ts";
-
-/** One query facade with separate run, transcript, search and selected-detail responsibilities. */
-export class HistoryQueries {
-  private readonly scope: Readonly<QueryScope>;
-  private readonly runs: RunQueries;
-  private readonly transcript: TranscriptQueries;
-  private readonly searchQueries: SearchQueries;
-  constructor(store: Readonly<HistoryStore>, info: () => HistoryVersion) {
-    this.scope = new QueryScope(store, info);
-    this.runs = new RunQueries(this.scope);
-    this.transcript = new TranscriptQueries(this.scope);
-    this.searchQueries = new SearchQueries(this.scope);
-  }
-  sourcesRemoved(): void {
-    this.scope.sourcesRemoved();
-  }
-  listRuns(options: HistoryRunOptions): HistoryRunPage {
-    return this.runs.list(options);
-  }
-  historyPage(input: HistoryPageInput): HistoryPage {
-    return this.transcript.page(input);
-  }
-  search(input: HistorySearchInput): HistorySearchPage {
-    return this.searchQueries.search(input);
-  }
-  finalResultId(
-    input: Pick<HistoryPageInput, "runId" | "index" | "terminalEntryId" | "endedAt">,
-    digest: string,
-    preferredRange?: readonly [number, number],
-  ): string | undefined {
-    return this.scope.finalResultId(input, digest, preferredRange);
-  }
-  private selectedRow(input: HistoryEntryInput): EntryRow | undefined {
-    const { source } = this.scope.child(input.runId, input.index);
-    if (!source) {
-      return;
-    }
-    const boundary = this.scope.boundary(source, input);
-    const where = boundary.clauses.join(" AND ");
-    let row;
-    if (input.ref) {
-      return this.referenceRow(input.ref, source, boundary);
-    } else if (hasText(input.entryId)) {
-      row = this.scope.store.get(
-        `SELECT * FROM entries WHERE ${where} AND id=?`,
-        ...boundary.params,
-        input.entryId,
-      );
-    } else if (hasText(input.toolCallId) && ["call", "result"].includes(input.kind ?? "call")) {
-      const toolBoundary = this.scope.boundary(source, input, "e");
-      row = this.scope.store.get(
-        `SELECT e.* FROM tools t JOIN entries e ON e.rowid=t.entry_rowid WHERE ${toolBoundary.clauses.join(" AND ")} AND t.call_id=? AND t.kind=? ORDER BY e.start DESC LIMIT 1`,
-        ...toolBoundary.params,
-        input.toolCallId,
-        input.kind ?? "call",
-      );
-    } else {
-      throw new HistoryIndexError(
-        "INVALID",
-        "Select an entry ID, byte reference, or tool call/result ID.",
-      );
-    }
-    return row ? entryRow(row) : undefined;
-  }
-  private referenceRow(ref: HistoryByteRef, source: SourceRow, boundary: Boundary): EntryRow {
-    if (ref.sourceId !== source.id || ref.generation !== source.generation) {
-      throw new HistoryIndexError(
-        "SOURCE_CHANGED",
-        "Selected source generation changed; refresh history.",
-      );
-    }
-    const row = this.scope.store.get(
-      `SELECT * FROM entries WHERE ${boundary.clauses.join(" AND ")} AND start=? AND end=? AND digest=?`,
-      ...boundary.params,
-      ref.start,
-      ref.end,
-      ref.digest,
-    );
-    if (!row) {
-      throw new HistoryIndexError(
-        "SOURCE_CHANGED",
-        "Selected byte reference is no longer indexed.",
-      );
-    }
-    return entryRow(row);
-  }
-  selected(input: HistoryEntryInput, full: true): Readonly<Record<string, unknown>> | null;
-  selected(input: HistoryEntryInput, full: false): HistoryEntry | null;
-  selected(
-    input: HistoryEntryInput,
-    full: boolean,
-  ): Readonly<Record<string, unknown>> | HistoryEntry | null {
-    const { source } = this.scope.child(input.runId, input.index);
-    const row = this.selectedRow(input);
-    if (!source || !row) {
-      return null;
-    }
-    const body = validateRecord(source, row, full);
-    return full
-      ? body
-      : { ...this.scope.store.entry(row), entry: { ...compactEntry(body), id: row.id } };
-  }
-}

package/src/history/query-scope.ts

@@ -1,278 +0,0 @@
-import { Type, Check } from "../shared/native-typebox.ts";
-import {
-  HistoryIndexError,
-  type HistoryVersion,
-  type HistoryPageInput,
-  type HistoryConfiguration,
-} from "./types.ts";
-import { hash, integer, hasText } from "./text.ts";
-import type { HistoryStore } from "./store.ts";
-import {
-  type SourceRow,
-  type Row,
-  type IndexInput,
-  number,
-  nullableText,
-  nullableNumber,
-  text,
-} from "./rows.ts";
-import { parseObject } from "./values.ts";
-
-const cursorSchema = Type.Object({
-  generation: Type.String(),
-  owner: Type.String(),
-  version: Type.Number(),
-  query: Type.String(),
-  keys: Type.Array(Type.Union([Type.Number(), Type.String()]), { maxItems: 8 }),
-  offset: Type.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
-});
-export interface Cursor {
-  readonly generation: string;
-  readonly owner: string;
-  readonly version: number;
-  readonly query: string;
-  readonly keys: readonly (string | number)[];
-  readonly offset: number;
-}
-export interface Boundary {
-  readonly clauses: readonly string[];
-  readonly params: readonly IndexInput[];
-  readonly terminalSequence?: number;
-}
-function configurationValues(
-  facts: Row,
-  leaf: string | null | undefined,
-  strict: boolean,
-): HistoryConfiguration {
-  const count = number(facts, "count");
-  if (count === 0 && hasText(leaf) && strict) {
-    throw new HistoryIndexError(
-      "BOUNDARY_UNAVAILABLE",
-      "Selected configuration leaf is not available in the indexed generation.",
-    );
-  }
-  if (count > 0 && number(facts, "rooted") === 0) {
-    if (!strict) {
-      return {};
-    }
-    throw new HistoryIndexError(
-      "MALFORMED_ANCESTRY",
-      "Selected native configuration has cyclic ancestry.",
-    );
-  }
-  const model = nullableText(facts, "model");
-  const thinking = nullableText(facts, "thinking");
-  return {
-    ...(model === null
-      ? {}
-      : { model, modelRecordedAt: nullableNumber(facts, "recorded_at") ?? undefined }),
-    ...(thinking === null ? {} : { thinking }),
-  };
-}
-function configurationKey(
-  source: SourceRow,
-  input: Pick<HistoryPageInput, "terminalEntryId" | "endedAt" | "leaf">,
-  strict: boolean,
-): string {
-  const terminal = hasText(input.terminalEntryId);
-  return JSON.stringify([
-    source.id,
-    source.generation,
-    source.cursor,
-    source.stamp,
-    terminal ? input.terminalEntryId : null,
-    terminal ? null : (input.endedAt ?? null),
-    input.leaf === undefined ? null : [typeof input.leaf, input.leaf],
-    strict,
-  ]);
-}
-export class QueryScope {
-  readonly store: Readonly<HistoryStore>;
-  readonly info: () => HistoryVersion;
-  private readonly configurations = new Map<string, HistoryConfiguration>();
-  constructor(store: Readonly<HistoryStore>, info: () => HistoryVersion) {
-    this.store = store;
-    this.info = info;
-  }
-  sourcesRemoved(): void {
-    this.configurations.clear();
-  }
-  key(parts: readonly unknown[]): string {
-    return hash(JSON.stringify(parts));
-  }
-  cursor(query: string, keys: readonly (string | number)[], offset: number): string {
-    return Buffer.from(
-      JSON.stringify({
-        generation: this.store.generation,
-        owner: this.store.owner,
-        version: this.info().version,
-        query,
-        keys,
-        offset,
-      } satisfies Cursor),
-    ).toString("base64url");
-  }
-  parseCursor(value: string | undefined, query: string): Cursor | undefined {
-    if (value === undefined) {
-      return;
-    }
-    let cursor: Cursor;
-    try {
-      if (value.length > 4096) {
-        throw new Error("Cursor exceeds budget.");
-      }
-      const parsed = parseObject(Buffer.from(value, "base64url").toString("utf8"));
-      if (!Check(cursorSchema, parsed)) {
-        throw new Error("Invalid cursor fields.");
-      }
-      cursor = parsed;
-    } catch {
-      throw new HistoryIndexError("INVALID_CURSOR", "Invalid history cursor.");
-    }
-    if (
-      cursor.generation !== this.store.generation ||
-      cursor.owner !== this.store.owner ||
-      cursor.query !== query ||
-      cursor.version !== this.info().version
-    ) {
-      throw new HistoryIndexError(
-        "STALE_CURSOR",
-        "History changed or this cursor belongs to a different query/source; restart paging.",
-      );
-    }
-    return cursor;
-  }
-  child(runId: string, index: number): { readonly source?: SourceRow; readonly agent: string } {
-    integer(index, 0);
-    const child = this.store.get(
-      "SELECT * FROM children WHERE run_id=? AND child_index=?",
-      runId,
-      index,
-    );
-    if (!child) {
-      throw new HistoryIndexError(
-        "OWNERSHIP",
-        "Run/child is not in the current owner's admitted handles.",
-      );
-    }
-    const sourceId = nullableText(child, "source_id");
-    return {
-      source: sourceId === null ? undefined : this.store.source(sourceId),
-      agent: text(child, "agent"),
-    };
-  }
-  boundary(
-    source: SourceRow,
-    input: Pick<HistoryPageInput, "terminalEntryId" | "endedAt">,
-    alias: "" | "e" = "",
-  ): Boundary {
-    const column = alias.length > 0 ? `${alias}.` : "";
-    const clauses = [`${column}source_id=?`, `${column}generation=?`, `${column}published=1`];
-    const params: IndexInput[] = [source.id, source.generation];
-    let terminalSequence: number | undefined;
-    if (input.terminalEntryId !== undefined && input.terminalEntryId.length > 0) {
-      const terminal = this.store.get(
-        "SELECT start FROM entries WHERE source_id=? AND generation=? AND id=? AND published=1",
-        source.id,
-        source.generation,
-        input.terminalEntryId,
-      );
-      if (!terminal) {
-        throw new HistoryIndexError(
-          "BOUNDARY_UNAVAILABLE",
-          "Saved terminal entry is not available in the current indexed generation.",
-        );
-      }
-      terminalSequence = number(terminal, "start");
-      clauses.push(`${column}start<=?`);
-      params.push(terminalSequence);
-    } else if (input.endedAt !== undefined) {
-      clauses.push(`${column}timestamp<=?`);
-      params.push(integer(input.endedAt, 0));
-    }
-    return { clauses, params, terminalSequence };
-  }
-  private configurationFacts(
-    source: SourceRow,
-    input: Pick<HistoryPageInput, "terminalEntryId" | "endedAt" | "leaf">,
-  ): ReturnType<HistoryStore["get"]> {
-    const boundary = this.boundary(source, input);
-    const latest = this.store.get(
-      `SELECT id FROM entries WHERE ${boundary.clauses.join(" AND ")} ORDER BY start DESC LIMIT 1`,
-      ...boundary.params,
-    );
-    const leaf = input.leaf ?? (latest ? text(latest, "id") : undefined);
-    if (leaf === undefined || leaf.length === 0) {
-      return;
-    }
-    // Resolve each child's parent by its indexed ID, not a transcript rescan at every step.
-    const ancestry = `WITH RECURSIVE eligible AS (SELECT rowid,id,parent_id,start,timestamp,configuration_model,configuration_thinking FROM entries WHERE ${boundary.clauses.join(" AND ")}), branch AS (SELECT * FROM eligible WHERE id=? UNION SELECT parent.* FROM branch child CROSS JOIN eligible parent WHERE parent.id=child.parent_id)`;
-    return this.store.require(
-      `${ancestry} SELECT
-      (SELECT COUNT(*) FROM branch) AS count,
-      EXISTS(SELECT 1 FROM branch child WHERE parent_id IS NULL OR NOT EXISTS(SELECT 1 FROM eligible parent WHERE parent.id=child.parent_id)) AS rooted,
-      (SELECT configuration_model FROM branch WHERE configuration_model IS NOT NULL ORDER BY start DESC LIMIT 1) AS model,
-      (SELECT timestamp FROM branch WHERE configuration_model IS NOT NULL ORDER BY start DESC LIMIT 1) AS recorded_at,
-      (SELECT configuration_thinking FROM branch WHERE configuration_thinking IS NOT NULL ORDER BY start DESC LIMIT 1) AS thinking`,
-      ...boundary.params,
-      leaf,
-    );
-  }
-  configuration(
-    source: SourceRow,
-    input: Pick<HistoryPageInput, "terminalEntryId" | "endedAt" | "leaf">,
-    strict = true,
-  ): HistoryConfiguration {
-    if (input.leaf === null) {
-      return {};
-    }
-    try {
-      // Validate boundaries before reuse. Only committed source changes invalidate ancestry.
-      this.boundary(source, input);
-      const key = configurationKey(source, input, strict);
-      const cached = this.configurations.get(key);
-      if (cached) {
-        return { ...cached };
-      }
-      const facts = this.configurationFacts(source, input);
-      if (!facts) {
-        return {};
-      }
-      const configuration = configurationValues(facts, input.leaf, strict);
-      this.cacheConfiguration(key, configuration);
-      return { ...configuration };
-    } catch (error) {
-      if (!strict && error instanceof HistoryIndexError && error.code === "BOUNDARY_UNAVAILABLE") {
-        return {};
-      }
-      throw error;
-    }
-  }
-  private cacheConfiguration(key: string, configuration: HistoryConfiguration): void {
-    if (this.configurations.size >= 128) {
-      const oldest = this.configurations.keys().next().value;
-      if (oldest !== undefined) {
-        this.configurations.delete(oldest);
-      }
-    }
-    this.configurations.set(key, configuration);
-  }
-  finalResultId(
-    input: Pick<HistoryPageInput, "runId" | "index" | "terminalEntryId" | "endedAt">,
-    digest: string,
-    preferredRange?: readonly [number, number],
-  ): string | undefined {
-    const { source } = this.child(input.runId, input.index);
-    if (!source) {
-      return;
-    }
-    const boundary = this.boundary(source, input, "e");
-    const row = this.store.get(
-      `SELECT a.item_id FROM answers a JOIN entries e ON e.rowid=a.entry_rowid WHERE a.digest=? AND ${boundary.clauses.join(" AND ")} ORDER BY ${preferredRange ? "(e.start BETWEEN ? AND ?) DESC," : ""}e.start DESC LIMIT 1`,
-      digest,
-      ...boundary.params,
-      ...(preferredRange ?? []),
-    );
-    return row ? text(row, "item_id") : undefined;
-  }
-}

package/src/history/rows.ts

@@ -1,118 +0,0 @@
-import { isRecord } from "../shared/unknown.ts";
-import { HistoryIndexError } from "./types.ts";
-
-export type IndexInput = string | number | bigint | null;
-export type Row = Readonly<Record<string, string | number | null>>;
-export function indexRow(input: unknown): Row {
-  if (!isRecord(input)) {
-    throw new HistoryIndexError("CORRUPT", "Invalid index row.");
-  }
-  const row: Record<string, string | number | null> = {};
-  for (const [key, value] of Object.entries(input)) {
-    if (value !== null && typeof value !== "string" && typeof value !== "number") {
-      throw new HistoryIndexError("CORRUPT", `Unsupported index column ${key}.`);
-    }
-    row[key] = value;
-  }
-  return row;
-}
-export function text(row: Row, key: string): string {
-  const value = row[key];
-  if (typeof value !== "string") {
-    throw new HistoryIndexError("CORRUPT", `Invalid index text column ${key}.`);
-  }
-  return value;
-}
-export function number(row: Row, key: string): number {
-  const value = row[key];
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new HistoryIndexError("CORRUPT", `Invalid index numeric column ${key}.`);
-  }
-  return value;
-}
-export function nullableText(row: Row, key: string): string | null {
-  return row[key] === null ? null : text(row, key);
-}
-export function nullableNumber(row: Row, key: string): number | null {
-  return row[key] === null ? null : number(row, key);
-}
-export interface SourceRow {
-  readonly id: string;
-  readonly path: string;
-  readonly generation: number;
-  readonly identity: string | null;
-  readonly stamp: string | null;
-  readonly session_id: string | null;
-  readonly header_digest: string | null;
-  readonly cursor: number;
-  readonly prefix_digest: string | null;
-  readonly state: string;
-  readonly error: string | null;
-  readonly malformed: number;
-  readonly complexity: number;
-  readonly checked_at: number | null;
-  readonly format_version: number | null;
-}
-export interface EntryRow {
-  readonly rowid: number;
-  readonly source_id: string;
-  readonly generation: number;
-  readonly id: string;
-  readonly native_id: string | null;
-  readonly parent_id: string | null;
-  readonly start: number;
-  readonly end: number;
-  readonly digest: string;
-  readonly timestamp: number | null;
-  readonly type: string;
-  readonly preview: string;
-  readonly published: number;
-  readonly role: string | null;
-  readonly assistant_text: number;
-  readonly visible_id: string | null;
-  readonly human_id: string | null;
-  readonly configuration_model: string | null;
-  readonly configuration_thinking: string | null;
-}
-export function sourceRow(row: Row): SourceRow {
-  return {
-    id: text(row, "id"),
-    path: text(row, "path"),
-    generation: number(row, "generation"),
-    identity: nullableText(row, "identity"),
-    stamp: nullableText(row, "stamp"),
-    session_id: nullableText(row, "session_id"),
-    header_digest: nullableText(row, "header_digest"),
-    cursor: number(row, "cursor"),
-    prefix_digest: nullableText(row, "prefix_digest"),
-    state: text(row, "state"),
-    error: nullableText(row, "error"),
-    malformed: number(row, "malformed"),
-    complexity: number(row, "complexity"),
-    checked_at: nullableNumber(row, "checked_at"),
-    format_version: nullableNumber(row, "format_version"),
-  };
-}
-export function entryRow(row: Row): EntryRow {
-  return {
-    rowid: number(row, "rowid"),
-    source_id: text(row, "source_id"),
-    generation: number(row, "generation"),
-    id: text(row, "id"),
-    native_id: nullableText(row, "native_id"),
-    parent_id: nullableText(row, "parent_id"),
-    start: number(row, "start"),
-    end: number(row, "end"),
-    digest: text(row, "digest"),
-    timestamp: nullableNumber(row, "timestamp"),
-    type: text(row, "type"),
-    preview: text(row, "preview"),
-    published: number(row, "published"),
-    role: nullableText(row, "role"),
-    assistant_text: number(row, "assistant_text"),
-    visible_id: nullableText(row, "visible_id"),
-    human_id: nullableText(row, "human_id"),
-    configuration_model: nullableText(row, "configuration_model"),
-    configuration_thinking: nullableText(row, "configuration_thinking"),
-  };
-}