@mrclrchtr/supi-antigravity 6.4.0

package/node_modules/@mrclrchtr/supi-core/src/report.ts

@@ -0,0 +1,121 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+
+/** Minimal theme surface required by the shared report helpers. */
+export type ReportTheme = Pick<Theme, "fg">;
+
+/** Color keys accepted by the report helpers. */
+export type ReportColor = Parameters<Theme["fg"]>[0];
+
+/** Options for rendering a themed key/value report row. */
+export interface KeyValueLineOptions {
+  /** The label shown on the left. */
+  label: string;
+  /** The value shown on the right. */
+  value: string;
+  /** Theme used for color formatting. */
+  theme: ReportTheme;
+  /** Maximum rendered width. */
+  width: number;
+  /** Left indentation in spaces. */
+  indent?: number;
+  /** Theme color applied to the label. Defaults to `"text"`. */
+  labelColor?: ReportColor;
+  /** Theme color applied to the value. Defaults to `"dim"`. */
+  valueColor?: ReportColor;
+  /** Separator placed between label and value. Defaults to `": "`. */
+  separator?: string;
+}
+
+/** Options for rendering a preview-overflow hint. */
+export interface OverflowHintOptions {
+  /** Optional follow-up hint such as `run /supi-context full`. */
+  hint?: string | null;
+  /** Left indentation in spaces. Defaults to `2`. */
+  indent?: number;
+}
+
+/** Ensure a report width never drops below the minimum readable width. */
+export function clampReportWidth(width: number, minWidth = 24): number {
+  return Math.max(minWidth, width);
+}
+
+/** Render a top-level report title line with theme color and truncation. */
+export function formatReportTitle(
+  title: string,
+  theme: ReportTheme,
+  width: number,
+  color: ReportColor = "accent",
+): string {
+  return truncateToWidth(theme.fg(color, title), width);
+}
+
+/**
+ * Render a section header with optional dimmed metadata.
+ *
+ * Example: `Usage by category  42.3k tokens`
+ */
+export function formatSectionHeader(
+  title: string,
+  meta: string | null,
+  theme: ReportTheme,
+  width: number,
+): string {
+  const left = theme.fg("text", title);
+  const content = meta ? `${left}${theme.fg("dim", `  ${meta}`)}` : left;
+  return truncateToWidth(content, width);
+}
+
+/** Render a single dimmed report line with optional left indentation. */
+export function formatDimLine(text: string, theme: ReportTheme, width: number, indent = 0): string {
+  const safeIndent = Math.max(0, indent);
+  return truncateToWidth(`${" ".repeat(safeIndent)}${theme.fg("dim", text)}`, width);
+}
+
+/** Render a dimmed preview-overflow hint such as `… and 3 more — run /foo full`. */
+export function formatOverflowHint(
+  hiddenCount: number,
+  theme: ReportTheme,
+  width: number,
+  options: OverflowHintOptions = {},
+): string {
+  const { hint = null, indent = 2 } = options;
+  const suffix = hint ? ` — ${hint}` : "";
+  return formatDimLine(`… and ${hiddenCount} more${suffix}`, theme, width, indent);
+}
+
+/** Render a single themed `label: value` row with truncation. */
+export function formatKeyValueLine(options: KeyValueLineOptions): string {
+  const {
+    label,
+    value,
+    theme,
+    width,
+    indent = 2,
+    labelColor = "text",
+    valueColor = "dim",
+    separator = ": ",
+  } = options;
+  const safeIndent = Math.max(0, indent);
+
+  return truncateToWidth(
+    `${" ".repeat(safeIndent)}${theme.fg(labelColor, label)}${separator}${theme.fg(valueColor, value)}`,
+    width,
+  );
+}
+
+/**
+ * Wrap a report text block to the available width and optionally prefix each line.
+ *
+ * This is useful for wrapped bullets or explanatory notes that should align
+ * under an existing report indent.
+ */
+export function wrapReportText(
+  text: string,
+  width: number,
+  options: { indent?: string } = {},
+): string[] {
+  const indent = options.indent ?? "";
+  const wrapped = wrapTextWithAnsi(text, Math.max(1, width - indent.length));
+  return indent ? wrapped.map((line) => `${indent}${line}`) : wrapped;
+}

package/node_modules/@mrclrchtr/supi-core/src/session-utils.ts

@@ -0,0 +1,71 @@
+// Generic session-file tree-walking utilities.
+
+import type { FileEntry, SessionEntry } from "@earendil-works/pi-coding-agent";
+
+/**
+ * Minimal pi API surface needed to track the current session display name reactively.
+ * Accept `ExtensionAPI` or any object satisfying this shape.
+ */
+export interface SessionNameTrackerHost {
+  on(event: string, handler: (...args: unknown[]) => unknown): void;
+  getSessionName(): string | undefined;
+}
+
+/**
+ * Create a reactive session-name tracker that stays consistent across
+ * session starts, renames, and shutdowns without polling.
+ *
+ * Subscribes to `session_start` (initial name), `session_info_changed`
+ * (renames via `/name`, `pi.setSessionName()`, or RPC), and
+ * `session_shutdown` (reset to `undefined`).
+ *
+ * @returns a zero-arg getter that always returns the current session name
+ *
+ * @example
+ * ```ts
+ * const getSessionName = createSessionNameTracker(pi);
+ * // …later, during tool execute or spinner rendering:
+ * const name = getSessionName();
+ * ```
+ */
+export function createSessionNameTracker(pi: SessionNameTrackerHost): () => string | undefined {
+  let name: string | undefined;
+
+  pi.on("session_start", () => {
+    name = pi.getSessionName();
+  });
+  pi.on("session_info_changed", (event) => {
+    name = (event as { name?: string }).name;
+  });
+  pi.on("session_shutdown", () => {
+    name = undefined;
+  });
+
+  return () => name;
+}
+
+/**
+ * Resolve the active branch path using PI's append-only tree semantics.
+ *
+ * The active branch is the path from the **last entry** (current leaf)
+ * back to the root via `parentId`. This follows PI's tree structure where
+ * entries are append-only and the last entry in the file is always the
+ * current leaf of the active branch.
+ */
+export function getActiveBranchEntries(entries: FileEntry[]): SessionEntry[] {
+  const sessionEntries = entries.filter((e): e is SessionEntry => e.type !== "session");
+  const byId = new Map(sessionEntries.map((entry) => [entry.id, entry]));
+  const leaf = sessionEntries.at(-1);
+  if (!leaf) return [];
+
+  const path: SessionEntry[] = [];
+  const visited = new Set<string>();
+  let current: SessionEntry | undefined = leaf;
+  while (current) {
+    if (visited.has(current.id)) break;
+    visited.add(current.id);
+    path.unshift(current);
+    current = current.parentId ? byId.get(current.parentId) : undefined;
+  }
+  return path;
+}

package/node_modules/@mrclrchtr/supi-core/src/session.ts

@@ -0,0 +1,8 @@
+// supi-core session domain — session utilities and registries.
+
+export { createRegistry, createSessionStateRegistry } from "./registry-utils.ts";
+export type { SessionNameTrackerHost } from "./session-utils.ts";
+export {
+  createSessionNameTracker,
+  getActiveBranchEntries,
+} from "./session-utils.ts";

package/node_modules/@mrclrchtr/supi-core/src/settings/settings-registry.ts

@@ -0,0 +1,105 @@
+// Event-backed settings module registration and collection.
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ScopedFieldValue, SettingsAction } from "./settings-schema.ts";
+
+export const SUPI_SETTINGS_COLLECT_EVENT = "supi:settings:collect";
+
+export type SettingsScope = "project" | "global";
+
+/** Scope and PI runtime state supplied for each settings read. */
+export interface SettingsContext {
+  scope: SettingsScope;
+  cwd: string;
+  ctx?: ExtensionContext;
+}
+
+/** A resolved, source-aware settings view. */
+export interface SettingsSnapshot {
+  rows: ScopedFieldValue[];
+}
+
+/** One user action routed to its owning settings module. */
+export interface SettingsActionRequest extends SettingsContext {
+  fieldKey: string;
+  action: SettingsAction;
+}
+
+/** Optional user-facing result from a successful settings action. */
+export interface SettingsApplyResult {
+  notice?: {
+    message: string;
+    level: "info" | "warning" | "error";
+  };
+}
+
+/**
+ * Canonical settings interface consumed by `/supi-settings`.
+ *
+ * Reads are always asynchronous. Apply resolves only after durable writes and
+ * module-owned refresh work complete. Implementations throw on failed writes.
+ */
+export interface SettingsModule {
+  id: string;
+  /** Human-readable section label shown in the UI. */
+  label: string;
+  /** Optional label that groups this module within its section. */
+  subsection?: string;
+  read(context: SettingsContext): Promise<SettingsSnapshot>;
+  apply(request: SettingsActionRequest): Promise<SettingsApplyResult>;
+}
+
+export interface SettingsContributionCollector {
+  add(module: SettingsModule): void;
+}
+
+export interface SettingsCollectionDiagnostic {
+  kind: "warning";
+  message: string;
+}
+
+export interface SettingsCollectionResult {
+  modules: SettingsModule[];
+  diagnostics: SettingsCollectionDiagnostic[];
+}
+
+export function isSettingsContributionCollector(
+  value: unknown,
+): value is SettingsContributionCollector {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    typeof (value as { add?: unknown }).add === "function"
+  );
+}
+
+/** Create a collector with last-wins duplicate handling and warning diagnostics. */
+export function createSettingsContributionCollector(): SettingsContributionCollector & {
+  result(): SettingsCollectionResult;
+} {
+  const modules = new Map<string, SettingsModule>();
+  const diagnostics: SettingsCollectionDiagnostic[] = [];
+
+  return {
+    add(module: SettingsModule): void {
+      if (modules.has(module.id)) {
+        diagnostics.push({
+          kind: "warning",
+          message: `Duplicate SuPi settings contribution "${module.id}"; using the last contribution.`,
+        });
+      }
+      modules.set(module.id, module);
+    },
+    result(): SettingsCollectionResult {
+      return { modules: Array.from(modules.values()), diagnostics: [...diagnostics] };
+    },
+  };
+}
+
+/** Register one settings module during extension factory setup. */
+export function registerSettings(pi: ExtensionAPI, module: SettingsModule): void {
+  const dispose = pi.events.on(SUPI_SETTINGS_COLLECT_EVENT, (collector) => {
+    if (isSettingsContributionCollector(collector)) collector.add(module);
+  });
+  pi.on("session_shutdown", () => dispose());
+}