@tt-a1i/openpi 0.1.0

package/extensions/ui-customization/index.ts

@@ -0,0 +1,217 @@
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+  ReadonlyFooterDataProvider,
+} from "@earendil-works/pi-coding-agent";
+import {
+  getCapabilities,
+  hyperlink,
+  truncateToWidth,
+  visibleWidth,
+} from "@earendil-works/pi-tui";
+import {
+  loadSetupConfig,
+  SETUP_CONFIG_CHANGED_CHANNEL,
+} from "../shared/setup-config.ts";
+import {
+  emptyGitInfoState,
+  emptyModelInfoState,
+  GIT_INFO_CHANNEL,
+  MODEL_INFO_CHANNEL,
+  REFRESH_CHANNEL,
+  isGitInfoState,
+  isModelInfoState,
+  type GitInfoState,
+  type ModelInfoState,
+} from "../shared/dashboard-state.ts";
+import { formatDirectory, renderFooter } from "./footer.ts";
+
+export { buildFooterContent, formatDirectory, renderFooter } from "./footer.ts";
+
+type Rgb = [number, number, number];
+
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const PALETTE: Rgb[] = [
+  [22, 83, 189],
+  [48, 129, 247],
+  [93, 171, 255],
+  [151, 205, 255],
+  [93, 171, 255],
+  [48, 129, 247],
+];
+const TITLE_LINES = [
+  "  ██████╗  ██╗ ",
+  "  ██╔══██╗ ██║ ",
+  "  ██████╔╝ ██║ ",
+  "  ██╔═══╝  ██║ ",
+  "  ██║      ██║ ",
+  "  ╚═╝      ╚═╝ ",
+];
+
+function mix(a: number, b: number, amount: number) {
+  return Math.round(a + (b - a) * amount);
+}
+
+function sampleGradient(position: number) {
+  const wrapped = ((position % 1) + 1) % 1;
+  const scaled = wrapped * PALETTE.length;
+  const index = Math.floor(scaled);
+  const nextIndex = (index + 1) % PALETTE.length;
+  const amount = scaled - index;
+  const start = PALETTE[index]!;
+  const end = PALETTE[nextIndex]!;
+
+  return [
+    mix(start[0], end[0], amount),
+    mix(start[1], end[1], amount),
+    mix(start[2], end[2], amount),
+  ] satisfies Rgb;
+}
+
+function foreground([red, green, blue]: Rgb, text: string) {
+  return `\x1b[38;2;${red};${green};${blue}m${text}${RESET}`;
+}
+
+function gradientText(text: string, phase: number) {
+  const characters = [...text];
+  const span = Math.max(characters.length - 1, 1);
+
+  return characters
+    .map((character, index) =>
+      character === " "
+        ? character
+        : foreground(sampleGradient(index / span + phase), character),
+    )
+    .join("");
+}
+
+function center(text: string, width: number) {
+  const padding = Math.max(0, Math.floor((width - visibleWidth(text)) / 2));
+  return truncateToWidth(`${" ".repeat(padding)}${text}`, width);
+}
+
+export default function uiCustomization(pi: ExtensionAPI) {
+  let title = "pi";
+  let modelInfo = emptyModelInfoState();
+  let gitInfo = emptyGitInfoState();
+  let requestRender: (() => void) | undefined;
+  let activeSession: ExtensionContext | undefined;
+
+  let stopModelListener: (() => void) | undefined;
+  let stopGitListener: (() => void) | undefined;
+
+  const stopDashboardListeners = () => {
+    stopModelListener?.();
+    stopGitListener?.();
+    stopModelListener = undefined;
+    stopGitListener = undefined;
+  };
+
+  const startDashboardListeners = () => {
+    stopDashboardListeners();
+    stopModelListener = pi.events.on(MODEL_INFO_CHANNEL, (value) => {
+      if (!isModelInfoState(value)) return;
+      modelInfo = value;
+      requestRender?.();
+    });
+    stopGitListener = pi.events.on(GIT_INFO_CHANNEL, (value) => {
+      if (!isGitInfoState(value)) return;
+      gitInfo = value;
+      requestRender?.();
+    });
+  };
+
+  // Kept for process lifetime so configure_my_pi_setup still refreshes later sessions.
+  pi.events.on(SETUP_CONFIG_CHANGED_CHANNEL, () => {
+    if (!activeSession || activeSession.mode !== "tui") return;
+    install(activeSession);
+    requestRender?.();
+  });
+
+  function install(ctx: ExtensionContext) {
+    if (ctx.mode !== "tui") return;
+    const config = loadSetupConfig().ui;
+
+    if (config.showHeader) {
+      ctx.ui.setHeader((tui) => {
+        requestRender = () => tui.requestRender();
+
+        return {
+          render(width: number) {
+            const art = TITLE_LINES.map((line, row) =>
+              center(gradientText(line, row * 0.045), width),
+            );
+            const subtitle = center(
+              `${BOLD}${gradientText(title, 0.18)}${RESET}`,
+              width,
+            );
+            return ["", ...art, subtitle, ""];
+          },
+          invalidate() {},
+        };
+      });
+    } else {
+      ctx.ui.setHeader(undefined);
+    }
+
+    if (config.customFooter) {
+      ctx.ui.setFooter((tui, theme, footerData: ReadonlyFooterDataProvider) => {
+        requestRender = () => tui.requestRender();
+
+        return {
+          invalidate() {},
+          render(width: number) {
+            const statuses = footerData.getExtensionStatuses();
+            const statusLines = Array.from(statuses.entries())
+              .sort(([a], [b]) => a.localeCompare(b))
+              .flatMap(([, text]) => text.split("\n"));
+
+            return renderFooter({
+              cwd: ctx.cwd,
+              modelInfo,
+              gitInfo,
+              style: config.footerStyle,
+              lines: config.footerLines,
+              width,
+              theme,
+              formatPullRequest: (number, url) => {
+                const label = `PR #${number}`;
+                return getCapabilities().hyperlinks
+                  ? hyperlink(label, url)
+                  : label;
+              },
+              statuses: statusLines,
+            });
+          },
+        };
+      });
+    } else {
+      ctx.ui.setFooter(undefined);
+    }
+
+    ctx.ui.setTitle(`pi · ${title}`);
+    pi.events.emit(REFRESH_CHANNEL, undefined);
+  }
+
+  pi.on("session_start", (_event, ctx) => {
+    title = formatDirectory(ctx.cwd);
+    modelInfo = emptyModelInfoState();
+    gitInfo = emptyGitInfoState();
+    activeSession = ctx;
+    startDashboardListeners();
+    install(ctx);
+  });
+
+  pi.on("session_shutdown", (_event, ctx) => {
+    // Drop the session pointer first so a late config event cannot reinstall
+    // against a shut-down context. The config listener stays armed for later sessions.
+    activeSession = undefined;
+    stopDashboardListeners();
+    requestRender = undefined;
+    if (ctx.mode === "tui") {
+      ctx.ui.setHeader(undefined);
+      ctx.ui.setFooter(undefined);
+    }
+  });
+}

package/extensions/workflows/acceptance.ts

@@ -0,0 +1,298 @@
+export const ACCEPTANCE_STATUSES = ["accepted", "rejected"] as const;
+export type AcceptanceStatus = (typeof ACCEPTANCE_STATUSES)[number];
+
+export interface AcceptanceCriterion {
+  readonly id: string;
+  readonly description: string;
+  readonly requiredEvidence?: readonly string[];
+}
+
+export interface AcceptanceContract {
+  readonly criteria: readonly AcceptanceCriterion[];
+}
+
+export interface AcceptanceCriterionResult {
+  readonly id: string;
+  readonly status: AcceptanceStatus;
+  readonly evidence: readonly string[];
+  readonly note?: string;
+}
+
+export interface AcceptanceLedger {
+  readonly status: "accepted" | "rejected" | "missing" | "malformed";
+  readonly criteria: readonly AcceptanceCriterionResult[];
+  readonly errors: readonly string[];
+}
+
+const ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+const MAX_CRITERIA = 32;
+
+function record(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+export function parseAcceptanceContract(
+  value: unknown,
+): AcceptanceContract | undefined {
+  if (value === undefined) return undefined;
+  if (!record(value) || !Array.isArray(value.criteria)) {
+    throw new Error("acceptance must be { criteria: [...] }");
+  }
+  if (value.criteria.length === 0 || value.criteria.length > MAX_CRITERIA) {
+    throw new Error(`acceptance.criteria must contain 1-${MAX_CRITERIA} items`);
+  }
+  const seen = new Set<string>();
+  const criteria = value.criteria.map((raw, index): AcceptanceCriterion => {
+    if (!record(raw))
+      throw new Error(`acceptance criterion ${index + 1} must be an object`);
+    const id = typeof raw.id === "string" ? raw.id.trim() : "";
+    const description =
+      typeof raw.description === "string" ? raw.description.trim() : "";
+    if (!ID_PATTERN.test(id))
+      throw new Error(`acceptance criterion ${index + 1} has an invalid id`);
+    if (seen.has(id))
+      throw new Error(`acceptance criterion id "${id}" is duplicated`);
+    seen.add(id);
+    if (!description || description.length > 500)
+      throw new Error(
+        `acceptance criterion "${id}" needs a 1-500 character description`,
+      );
+    let requiredEvidence: string[] | undefined;
+    if (raw.requiredEvidence !== undefined) {
+      if (
+        !Array.isArray(raw.requiredEvidence) ||
+        raw.requiredEvidence.length > 16
+      ) {
+        throw new Error(
+          `acceptance criterion "${id}" requiredEvidence must be an array of at most 16 labels`,
+        );
+      }
+      requiredEvidence = raw.requiredEvidence.map((entry) => {
+        if (typeof entry !== "string" || !entry.trim() || entry.length > 120) {
+          throw new Error(
+            `acceptance criterion "${id}" has an invalid evidence label`,
+          );
+        }
+        return entry.trim();
+      });
+    }
+    return {
+      id,
+      description,
+      ...(requiredEvidence?.length ? { requiredEvidence } : {}),
+    };
+  });
+  return { criteria };
+}
+
+export function acceptanceSchema(
+  schema: unknown,
+  contract: AcceptanceContract,
+) {
+  const ledger = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      criteria: {
+        type: "array",
+        minItems: contract.criteria.length,
+        maxItems: contract.criteria.length,
+        items: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            id: { type: "string" },
+            status: { type: "string", enum: [...ACCEPTANCE_STATUSES] },
+            evidence: {
+              type: "array",
+              items: { type: "string" },
+              maxItems: 64,
+            },
+            note: { type: "string", maxLength: 1000 },
+          },
+          required: ["id", "status", "evidence"],
+        },
+      },
+    },
+    required: ["criteria"],
+  };
+  if (schema === undefined) {
+    return {
+      type: "object",
+      properties: { acceptance: ledger },
+      required: ["acceptance"],
+    };
+  }
+  if (!record(schema) || schema.type !== "object") {
+    throw new Error("acceptance can only compose with an object JSON Schema");
+  }
+  const properties =
+    schema.properties === undefined
+      ? {}
+      : record(schema.properties)
+        ? schema.properties
+        : undefined;
+  if (!properties) {
+    throw new Error("acceptance schema properties must be an object");
+  }
+  if (Object.hasOwn(properties, "acceptance")) {
+    throw new Error(
+      'the caller schema already defines reserved property "acceptance"',
+    );
+  }
+  const required =
+    schema.required === undefined
+      ? []
+      : Array.isArray(schema.required) &&
+          schema.required.every((entry) => typeof entry === "string")
+        ? schema.required
+        : undefined;
+  if (!required)
+    throw new Error("acceptance schema required must be a string array");
+  return {
+    ...schema,
+    properties: { ...properties, acceptance: ledger },
+    required: [...new Set([...required, "acceptance"])],
+  };
+}
+
+export function isAcceptanceLedger(value: unknown): value is AcceptanceLedger {
+  if (
+    !record(value) ||
+    !Array.isArray(value.criteria) ||
+    !Array.isArray(value.errors)
+  ) {
+    return false;
+  }
+  return (
+    (value.status === "accepted" ||
+      value.status === "rejected" ||
+      value.status === "missing" ||
+      value.status === "malformed") &&
+    value.errors.every((error) => typeof error === "string") &&
+    value.criteria.every(
+      (criterion) =>
+        record(criterion) &&
+        typeof criterion.id === "string" &&
+        (criterion.status === "accepted" || criterion.status === "rejected") &&
+        Array.isArray(criterion.evidence) &&
+        criterion.evidence.every((entry) => typeof entry === "string"),
+    )
+  );
+}
+
+export function acceptanceInstruction(contract: AcceptanceContract) {
+  const criteria = contract.criteria.map(
+    (criterion) =>
+      `- ${criterion.id}: ${criterion.description}${criterion.requiredEvidence?.length ? `; required evidence labels: ${criterion.requiredEvidence.join(", ")}` : ""}`,
+  );
+  return [
+    "Acceptance is explicit evidence, not a self-awarded success claim.",
+    "Include an `acceptance.criteria` array in structured_output with exactly these ids. Mark rejected when the criterion is not demonstrated. Evidence entries must be concise labels or concrete references; do not invent evidence.",
+    ...criteria,
+  ].join("\n");
+}
+
+export function evaluateAcceptance(
+  contract: AcceptanceContract,
+  structured: unknown,
+): AcceptanceLedger {
+  if (!record(structured) || !record(structured.acceptance)) {
+    return {
+      status: "missing",
+      criteria: [],
+      errors: ["structured result omitted acceptance"],
+    };
+  }
+  const rawCriteria = structured.acceptance.criteria;
+  if (!Array.isArray(rawCriteria)) {
+    return {
+      status: "malformed",
+      criteria: [],
+      errors: ["acceptance.criteria is not an array"],
+    };
+  }
+  const errors: string[] = [];
+  const byId = new Map<string, AcceptanceCriterionResult>();
+  for (const raw of rawCriteria) {
+    if (!record(raw) || typeof raw.id !== "string") {
+      errors.push("acceptance contains a criterion without an id");
+      continue;
+    }
+    if (byId.has(raw.id)) {
+      errors.push(`acceptance criterion "${raw.id}" is duplicated`);
+      continue;
+    }
+    const status = raw.status;
+    const evidence = Array.isArray(raw.evidence)
+      ? raw.evidence
+          .filter((entry): entry is string => typeof entry === "string")
+          .map((entry) => entry.trim())
+          .filter(Boolean)
+      : [];
+    if (status !== "accepted" && status !== "rejected") {
+      errors.push(`acceptance criterion "${raw.id}" has an invalid status`);
+      continue;
+    }
+    byId.set(raw.id, {
+      id: raw.id,
+      status,
+      evidence,
+      ...(typeof raw.note === "string" && raw.note.trim()
+        ? { note: raw.note.trim().slice(0, 1000) }
+        : {}),
+    });
+  }
+  const results: AcceptanceCriterionResult[] = [];
+  for (const criterion of contract.criteria) {
+    const result = byId.get(criterion.id);
+    if (!result) {
+      errors.push(`acceptance criterion "${criterion.id}" is missing`);
+      continue;
+    }
+    const missingEvidence = (criterion.requiredEvidence ?? []).filter(
+      (required) => !result.evidence.includes(required),
+    );
+    if (missingEvidence.length) {
+      errors.push(
+        `acceptance criterion "${criterion.id}" lacks evidence: ${missingEvidence.join(", ")}`,
+      );
+    }
+    results.push(result);
+  }
+  for (const id of byId.keys()) {
+    if (!contract.criteria.some((criterion) => criterion.id === id)) {
+      errors.push(`unexpected acceptance criterion "${id}"`);
+    }
+  }
+  if (errors.length) return { status: "malformed", criteria: results, errors };
+  return {
+    status: results.every((result) => result.status === "accepted")
+      ? "accepted"
+      : "rejected",
+    criteria: results,
+    errors: [],
+  };
+}
+
+export function applyAcceptance(options: {
+  contract?: AcceptanceContract;
+  structured: unknown;
+  agentOk: boolean;
+  agentError?: string;
+}) {
+  const ledger = options.contract
+    ? evaluateAcceptance(options.contract, options.structured)
+    : undefined;
+  const acceptanceError =
+    ledger && ledger.status !== "accepted"
+      ? `Acceptance ${ledger.status}${ledger.errors.length ? `: ${ledger.errors.join("; ")}` : ": one or more criteria were rejected"}`
+      : undefined;
+  const ok = options.agentOk && !acceptanceError;
+  const error = ok
+    ? undefined
+    : options.agentError
+      ? `${options.agentError}${acceptanceError ? `; ${acceptanceError}` : ""}`
+      : (acceptanceError ?? "Agent failed");
+  return { ok, ...(ledger ? { ledger } : {}), ...(error ? { error } : {}) };
+}