@cortexkit/aft-opencode 0.9.1 → 0.10.1

package/src/tui/index.tsx

@@ -0,0 +1,209 @@
+/** @jsxImportSource @opentui/solid */
+// @ts-nocheck
+
+import type { TuiPlugin, TuiPluginApi } from "@opencode-ai/plugin/tui";
+import { AftRpcClient } from "../shared/rpc-client";
+import { coerceAftStatus, formatStatusDialogMessage } from "../shared/status";
+
+const STATUS_COMMAND = "aft-status";
+
+// RPC clients keyed by directory — one per project
+const rpcClients = new Map<string, AftRpcClient>();
+
+function getRpcClient(directory: string): AftRpcClient {
+  let client = rpcClients.get(directory);
+  if (client) return client;
+
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  const dataHome = process.env.XDG_DATA_HOME || `${home}/.local/share`;
+  const storageDir = `${dataHome}/opencode/storage/plugin/aft`;
+
+  client = new AftRpcClient(storageDir, directory);
+  rpcClients.set(directory, client);
+  return client;
+}
+
+function getSessionId(api: TuiPluginApi): string | null {
+  try {
+    const route = api.route.current;
+    if (route?.name === "session" && route.params?.sessionID) {
+      return route.params.sessionID;
+    }
+  } catch {
+    // ignore
+  }
+  return null;
+}
+
+async function showStatusDialog(api: TuiPluginApi): Promise<void> {
+  const sessionID = getSessionId(api);
+  if (!sessionID) {
+    api.ui.toast({ message: "No active session", variant: "warning", duration: 5000 });
+    return;
+  }
+
+  const directory = api.state.path.directory ?? "";
+  if (!directory) {
+    api.ui.toast({ message: "No project directory", variant: "warning", duration: 5000 });
+    return;
+  }
+
+  const client = getRpcClient(directory);
+
+  // Fetch status immediately and show the dialog
+  let currentMessage = "Connecting to AFT...";
+  try {
+    const response = await client.call("status", { sessionID });
+    if ((response as Record<string, unknown>).success !== false) {
+      const status = coerceAftStatus(response as Record<string, unknown>);
+      currentMessage = formatStatusDialogMessage(status);
+    }
+  } catch {
+    currentMessage = "AFT is starting up. Status will refresh automatically...";
+  }
+
+  // Track whether dialog is still open for polling cleanup
+  let dialogOpen = true;
+  let pollTimer: ReturnType<typeof setInterval> | null = null;
+
+  // Show dialog with initial data
+  api.ui.dialog.setSize("large");
+  api.ui.dialog.replace(
+    () => {
+      // Start polling after dialog renders
+      if (!pollTimer) {
+        pollTimer = setInterval(async () => {
+          if (!dialogOpen) {
+            if (pollTimer) clearInterval(pollTimer);
+            return;
+          }
+          try {
+            const response = await client.call("status", { sessionID });
+            if ((response as Record<string, unknown>).success !== false) {
+              const status = coerceAftStatus(response as Record<string, unknown>);
+              const newMessage = formatStatusDialogMessage(status);
+              if (newMessage !== currentMessage) {
+                currentMessage = newMessage;
+                // Re-render dialog with updated status
+                api.ui.dialog.replace(
+                  () => (
+                    <api.ui.DialogAlert
+                      title="AFT Status"
+                      message={currentMessage}
+                      onConfirm={() => {
+                        dialogOpen = false;
+                        if (pollTimer) clearInterval(pollTimer);
+                        api.ui.dialog.setSize("medium");
+                      }}
+                    />
+                  ),
+                  () => {
+                    dialogOpen = false;
+                    if (pollTimer) clearInterval(pollTimer);
+                    api.ui.dialog.setSize("medium");
+                  },
+                );
+              }
+            }
+          } catch {
+            // Polling failure is non-fatal — just skip this tick
+          }
+        }, 1500);
+      }
+
+      return (
+        <api.ui.DialogAlert
+          title="AFT Status"
+          message={currentMessage}
+          onConfirm={() => {
+            dialogOpen = false;
+            if (pollTimer) clearInterval(pollTimer);
+            api.ui.dialog.setSize("medium");
+          }}
+        />
+      );
+    },
+    () => {
+      dialogOpen = false;
+      if (pollTimer) clearInterval(pollTimer);
+      api.ui.dialog.setSize("medium");
+    },
+  );
+}
+
+async function showStartupNotifications(api: TuiPluginApi): Promise<void> {
+  const directory = api.state.path.directory ?? "";
+  if (!directory) return;
+
+  const client = getRpcClient(directory);
+
+  // Check for feature announcements
+  try {
+    const announcement = (await client.call("get-announcement", {})) as {
+      show?: boolean;
+      version?: string;
+      features?: string[];
+    };
+
+    if (announcement.show && announcement.version && announcement.features?.length) {
+      const featureText = announcement.features.map((f: string) => `  • ${f}`).join("\n");
+
+      api.ui.dialog.replace(
+        () => (
+          <api.ui.DialogAlert
+            title={`AFT v${announcement.version}`}
+            message={`What's new:\n\n${featureText}`}
+            onConfirm={() => {
+              // Mark as announced so it doesn't show again
+              void client.call("mark-announced", {});
+            }}
+          />
+        ),
+        () => {
+          void client.call("mark-announced", {});
+        },
+      );
+      return; // Show one dialog at a time
+    }
+  } catch {
+    // RPC server not ready yet — skip announcements
+  }
+
+  // Check for warnings
+  try {
+    const result = (await client.call("get-warnings", {})) as { warnings?: string[] };
+    if (result.warnings?.length) {
+      const warningText = result.warnings.join("\n\n");
+      api.ui.dialog.replace(
+        () => <api.ui.DialogAlert title="AFT Warning" message={warningText} onConfirm={() => {}} />,
+        () => {},
+      );
+    }
+  } catch {
+    // RPC server not ready — skip warnings
+  }
+}
+
+const tui: TuiPlugin = async (api) => {
+  api.command.register(() => [
+    {
+      title: "AFT: Status",
+      value: "aft.status",
+      category: "AFT",
+      slash: { name: STATUS_COMMAND },
+      onSelect() {
+        void showStatusDialog(api);
+      },
+    },
+  ]);
+
+  // Show startup notifications — RPC server is already running by the time TUI loads
+  void showStartupNotifications(api);
+};
+
+const id = "aft-opencode";
+
+export default {
+  id,
+  tui,
+};

package/src/tui/types/opencode-plugin-tui.d.ts

@@ -0,0 +1,232 @@
+// Type declarations for @opencode-ai/plugin/tui
+// These types are not yet exported by the installed @opencode-ai/plugin package
+
+declare module "@opencode-ai/plugin/tui" {
+  import type {
+    createOpencodeClient as createOpencodeClientV2,
+    Event as TuiEvent,
+    Message,
+    Part,
+    Provider,
+    Config as SdkConfig,
+  } from "@opencode-ai/sdk/v2";
+
+  import type { CliRenderer, RGBA } from "@opentui/core";
+  import type { JSX, SolidPlugin } from "@opentui/solid";
+
+  type PluginOptions = Record<string, unknown>;
+
+  export type { CliRenderer };
+
+  export type TuiThemeCurrent = {
+    readonly primary: RGBA;
+    readonly secondary: RGBA;
+    readonly accent: RGBA;
+    readonly error: RGBA;
+    readonly warning: RGBA;
+    readonly success: RGBA;
+    readonly info: RGBA;
+    readonly text: RGBA;
+    readonly textMuted: RGBA;
+    readonly background: RGBA;
+    readonly backgroundPanel: RGBA;
+    readonly backgroundElement: RGBA;
+    readonly backgroundMenu: RGBA;
+    readonly border: RGBA;
+    readonly borderActive: RGBA;
+    readonly borderSubtle: RGBA;
+    [key: string]: unknown;
+  };
+
+  export type TuiTheme = {
+    readonly current: TuiThemeCurrent;
+    has: (name: string) => boolean;
+    set: (name: string) => boolean;
+    mode: () => "dark" | "light";
+    readonly ready: boolean;
+  };
+
+  export type TuiSlotMap = {
+    app: Record<string, never>;
+    home_logo: Record<string, never>;
+    home_bottom: Record<string, never>;
+    sidebar_title: {
+      session_id: string;
+      title: string;
+      share_url?: string;
+    };
+    sidebar_content: {
+      session_id: string;
+    };
+    sidebar_footer: {
+      session_id: string;
+    };
+  };
+
+  export type TuiSlotContext = {
+    theme: TuiTheme;
+  };
+
+  export type TuiSlotPlugin = Omit<SolidPlugin<TuiSlotMap, TuiSlotContext>, "id"> & {
+    id?: never;
+  };
+
+  export type TuiToast = {
+    variant?: "info" | "success" | "warning" | "error";
+    title?: string;
+    message: string;
+    duration?: number;
+  };
+
+  export type TuiDialogStack = {
+    replace: (render: () => JSX.Element, onClose?: () => void) => void;
+    clear: () => void;
+    setSize: (size: "medium" | "large" | "xlarge") => void;
+    readonly size: "medium" | "large" | "xlarge";
+    readonly depth: number;
+    readonly open: boolean;
+  };
+
+  export type TuiDialogAlertProps = {
+    title: string;
+    message: string;
+    onConfirm?: () => void;
+  };
+
+  export type TuiDialogConfirmProps = {
+    title: string;
+    message: string;
+    onConfirm?: () => void;
+    onCancel?: () => void;
+  };
+
+  export type TuiDialogPromptProps = {
+    title: string;
+    description?: () => JSX.Element;
+    placeholder?: string;
+    value?: string;
+    busy?: boolean;
+    busyText?: string;
+    onConfirm?: (value: string) => void;
+    onCancel?: () => void;
+  };
+
+  export type TuiDialogSelectOption<Value = unknown> = {
+    title: string;
+    value: Value;
+    description?: string;
+    footer?: JSX.Element | string;
+    category?: string;
+    disabled?: boolean;
+    onSelect?: () => void;
+  };
+
+  export type TuiDialogSelectProps<Value = unknown> = {
+    title: string;
+    placeholder?: string;
+    options: TuiDialogSelectOption<Value>[];
+    flat?: boolean;
+    onMove?: (option: TuiDialogSelectOption<Value>) => void;
+    onFilter?: (query: string) => void;
+    onSelect?: (option: TuiDialogSelectOption<Value>) => void;
+    skipFilter?: boolean;
+    current?: Value;
+  };
+
+  export type TuiState = {
+    readonly ready: boolean;
+    readonly config: SdkConfig;
+    readonly provider: ReadonlyArray<Provider>;
+    readonly path: {
+      state: string;
+      config: string;
+      worktree: string;
+      directory: string;
+    };
+    session: {
+      count: () => number;
+      messages: (sessionID: string) => ReadonlyArray<Message>;
+    };
+    part: (messageID: string) => ReadonlyArray<Part>;
+  };
+
+  export type TuiEventBus = {
+    on: <Type extends TuiEvent["type"]>(
+      type: Type,
+      handler: (event: Extract<TuiEvent, { type: Type }>) => void,
+    ) => () => void;
+  };
+
+  export type TuiLifecycle = {
+    readonly signal: AbortSignal;
+    onDispose: (fn: () => void | Promise<void>) => () => void;
+  };
+
+  export type TuiPluginApi = {
+    app: { readonly version: string };
+    command: {
+      register: (
+        cb: () => Array<{
+          title: string;
+          value: string;
+          description?: string;
+          category?: string;
+          keybind?: string;
+          suggested?: boolean;
+          hidden?: boolean;
+          enabled?: boolean;
+          slash?: {
+            name: string;
+            aliases?: string[];
+          };
+          onSelect?: () => void;
+        }>,
+      ) => () => void;
+      trigger: (value: string) => void;
+    };
+    route: {
+      register: (
+        routes: Array<{
+          name: string;
+          render: (input: { params?: Record<string, unknown> }) => JSX.Element;
+        }>,
+      ) => () => void;
+      navigate: (name: string, params?: Record<string, unknown>) => void;
+      readonly current:
+        | { name: "home" }
+        | { name: "session"; params: { sessionID: string; initialPrompt?: unknown } }
+        | { name: string; params?: Record<string, unknown> };
+    };
+    ui: {
+      DialogAlert: (props: TuiDialogAlertProps) => JSX.Element;
+      DialogConfirm: (props: TuiDialogConfirmProps) => JSX.Element;
+      DialogPrompt: (props: TuiDialogPromptProps) => JSX.Element;
+      DialogSelect: <Value = unknown>(props: TuiDialogSelectProps<Value>) => JSX.Element;
+      toast: (input: TuiToast) => void;
+      dialog: TuiDialogStack;
+    };
+    state: TuiState;
+    theme: TuiTheme;
+    client: ReturnType<typeof createOpencodeClientV2>;
+    event: TuiEventBus;
+    renderer: CliRenderer;
+    slots: {
+      register: (plugin: TuiSlotPlugin) => string;
+    };
+    lifecycle: TuiLifecycle;
+  };
+
+  export type TuiPluginMeta = {
+    state: "first" | "updated" | "same";
+    id: string;
+    source: "file" | "npm" | "internal";
+    spec: string;
+    target: string;
+  };
+
+  export type TuiPlugin = (
+    api: TuiPluginApi,
+    options: PluginOptions | undefined,
+    meta: TuiPluginMeta,
+  ) => Promise<void>;
+}