@cortexkit/aft-opencode 0.55.1 → 0.56.0

package/src/tui/v2.tsx

@@ -0,0 +1,209 @@
+/** @jsxImportSource @opentui/solid */
+// @ts-nocheck
+
+import { createEffect, createSignal, onCleanup } from "solid-js";
+import {
+  type AftStatusSnapshot,
+  coerceAftStatus,
+  formatStatusDialogMessage,
+} from "../shared/status";
+import { AftRpc } from "./aft-rpc";
+import { formatAftStatusSegment, summarizeAftSidebar } from "./v2-status";
+
+type AftRpcClient = {
+  getStatus(
+    input: { sessionID?: string },
+    options?: { location?: unknown; signal?: AbortSignal },
+  ): Promise<Record<string, unknown>>;
+  events: {
+    on(
+      name: "statusInvalidated" | "showStatusDialog" | "indexProgress",
+      handler: (event: { data: { sessionID?: string } }) => void | Promise<void>,
+      options?: { signal?: AbortSignal },
+    ): () => void;
+  };
+};
+
+type V2TuiContext = {
+  location?: unknown;
+  client: { rpc(definition: typeof AftRpc): AftRpcClient };
+  keymap: {
+    layer(input: () => { commands: Array<Record<string, unknown>>; bindings: string[] }): void;
+  };
+  ui: {
+    dialog: { alert(input: { title: string; message: string }): Promise<void> };
+    router: { current(): { type: string; sessionID?: string } };
+    slot(claim: {
+      append: "prompt.footer.status" | "sidebar.content";
+      render(input: { sessionID?: string }): unknown;
+    }): () => void;
+  };
+};
+
+function eventMatchesSession(
+  eventSessionID: string | undefined,
+  sessionID: string | undefined,
+): boolean {
+  return eventSessionID === undefined || eventSessionID === sessionID;
+}
+
+async function fetchStatus(
+  context: V2TuiContext,
+  rpc: AftRpcClient,
+  sessionID: string | undefined,
+  signal?: AbortSignal,
+): Promise<AftStatusSnapshot> {
+  const response = await rpc.getStatus(sessionID ? { sessionID } : {}, {
+    ...(context.location ? { location: context.location } : {}),
+    ...(signal ? { signal } : {}),
+  });
+  return coerceAftStatus(response);
+}
+
+export function subscribeV2StatusRefresh(
+  rpc: AftRpcClient,
+  sessionID: () => string | undefined,
+  refresh: () => void,
+): () => void {
+  const unsubscribes = [
+    rpc.events.on("statusInvalidated", (event) => {
+      if (eventMatchesSession(event.data.sessionID, sessionID())) refresh();
+    }),
+    rpc.events.on("indexProgress", (event) => {
+      if (eventMatchesSession(event.data.sessionID, sessionID())) refresh();
+    }),
+  ];
+  return () => {
+    for (const unsubscribe of unsubscribes) unsubscribe();
+  };
+}
+
+function useAftStatus(
+  context: V2TuiContext,
+  rpc: AftRpcClient,
+  sessionID: () => string | undefined,
+): () => AftStatusSnapshot | null {
+  const [status, setStatus] = createSignal<AftStatusSnapshot | null>(null);
+  let refreshGeneration = 0;
+  let refreshController: AbortController | undefined;
+
+  const refresh = async (): Promise<void> => {
+    const requestedSessionID = sessionID();
+    const generation = ++refreshGeneration;
+    refreshController?.abort();
+    const controller = new AbortController();
+    refreshController = controller;
+    try {
+      const next = await fetchStatus(context, rpc, requestedSessionID, controller.signal);
+      if (controller.signal.aborted || generation !== refreshGeneration) return;
+      if (sessionID() !== requestedSessionID) return;
+      setStatus(next);
+    } catch {
+      // Status is best-effort UI data; the next typed invalidation retries it.
+    }
+  };
+
+  createEffect(() => {
+    sessionID();
+    void refresh();
+  });
+  const unsubscribe = subscribeV2StatusRefresh(rpc, sessionID, () => {
+    void refresh();
+  });
+  onCleanup(() => {
+    refreshGeneration += 1;
+    refreshController?.abort();
+    unsubscribe();
+  });
+  return status;
+}
+
+function FooterStatus(props: { context: V2TuiContext; rpc: AftRpcClient; sessionID?: string }) {
+  const status = useAftStatus(props.context, props.rpc, () => props.sessionID);
+  return <text>{formatAftStatusSegment(status())}</text>;
+}
+
+function SidebarStatus(props: { context: V2TuiContext; rpc: AftRpcClient; sessionID: string }) {
+  const status = useAftStatus(props.context, props.rpc, () => props.sessionID);
+  const summary = () => summarizeAftSidebar(status());
+  return (
+    <box width="100%" flexDirection="column">
+      <text>
+        <b>{summary().title}</b>
+        {summary().version ? ` v${summary().version}` : ""}
+      </text>
+      <text>Search: {summary().search}</text>
+      <text>Semantic: {summary().semantic}</text>
+      <text>Health: {summary().health}</text>
+    </box>
+  );
+}
+
+function activeSessionID(context: V2TuiContext): string | undefined {
+  const route = context.ui.router.current();
+  return route.type === "session" ? route.sessionID : undefined;
+}
+
+async function showStatusDialog(
+  context: V2TuiContext,
+  rpc: AftRpcClient,
+  sessionID: string | undefined,
+): Promise<void> {
+  try {
+    const status = await fetchStatus(context, rpc, sessionID);
+    await context.ui.dialog.alert({
+      title: "AFT Status",
+      message: formatStatusDialogMessage(status),
+    });
+  } catch {
+    await context.ui.dialog.alert({
+      title: "AFT Status",
+      message: "AFT is starting up. Status will refresh automatically.",
+    });
+  }
+}
+
+export async function setupV2Tui(context: V2TuiContext): Promise<() => void> {
+  const rpc = context.client.rpc(AftRpc);
+  const controller = new AbortController();
+  const slotCleanups = [
+    context.ui.slot({
+      append: "prompt.footer.status",
+      render: (input) => <FooterStatus context={context} rpc={rpc} sessionID={input.sessionID} />,
+    }),
+    context.ui.slot({
+      append: "sidebar.content",
+      render: (input) => <SidebarStatus context={context} rpc={rpc} sessionID={input.sessionID!} />,
+    }),
+  ];
+
+  const stopDialogEvents = rpc.events.on(
+    "showStatusDialog",
+    (event) => showStatusDialog(context, rpc, event.data.sessionID ?? activeSessionID(context)),
+    { signal: controller.signal },
+  );
+
+  context.keymap.layer(() => ({
+    commands: [
+      {
+        id: "aft.status",
+        title: "AFT: Status",
+        description: "Show AFT status, index health, and cache usage",
+        group: "AFT",
+        palette: true,
+        // V2's KeymapCommand contract (plugin/tui/context.ts:379-385) dispatches
+        // slash entries unless `arguments: true`; omitting it prevents this text
+        // from remaining in the prompt or being submitted to the model.
+        slash: { name: "aft-status" },
+        run: () => showStatusDialog(context, rpc, activeSessionID(context)),
+      },
+    ],
+    bindings: [],
+  }));
+
+  return () => {
+    controller.abort();
+    stopDialogEvents();
+    for (const cleanup of slotCleanups) cleanup();
+  };
+}

package/src/tui-compiled/aft-rpc.ts

@@ -0,0 +1,43 @@
+import { Schema } from "effect";
+
+/**
+ * The V2 host's Rpc.define returns its input after checking reserved custom
+ * error names. AFT defines no custom RPC errors, so this local identity has the
+ * same result and also loads on V1, where @opencode-ai/schema is unavailable.
+ */
+const Rpc = {
+  define<const Definition>(definition: Definition): Definition {
+    return definition;
+  },
+};
+
+export const RpcSession = Schema.Struct({
+  sessionID: Schema.optional(Schema.String),
+});
+
+export const IndexProgress = Schema.Struct({
+  index: Schema.Literals(["search", "semantic"]),
+  status: Schema.String,
+  sessionID: Schema.optional(Schema.String),
+  stage: Schema.optional(Schema.NullOr(Schema.String)),
+  completed: Schema.optional(Schema.Number),
+  total: Schema.optional(Schema.Number),
+});
+
+export type AftRpcSession = typeof RpcSession.Type;
+export type AftIndexProgress = typeof IndexProgress.Type;
+
+export const AftRpc = Rpc.define({
+  id: "aft",
+  methods: {
+    getStatus: {
+      input: RpcSession,
+      output: Schema.Record(Schema.String, Schema.Unknown),
+    },
+  },
+  events: {
+    statusInvalidated: { schema: RpcSession },
+    showStatusDialog: { schema: RpcSession },
+    indexProgress: { schema: IndexProgress },
+  },
+});

package/src/tui-compiled/index.tsx

@@ -15,6 +15,7 @@ import { AftRpcClient } from "../shared/rpc-client";
 import { coerceAftStatus, formatBytes, formatCacheRoleLabel, formatSemanticIndexStatus, formatSemanticRefreshing } from "../shared/status";
 import { createDebouncedStatusRefresh, refreshAftTuiSocketScope, startAftTuiSocket, stopAftTuiSocket, subscribeStatusInvalidations } from "./notification-socket";
 import { createAftSidebarSlot, formatCompressionSidebarRows, isSnapshotForContext, resolveTuiStorageDir, shouldSuppressUninitializedDowngrade } from "./sidebar";
+import { setupV2Tui } from "./v2";
 
 // The TUI talks to the server plugin via AftRpcClient. The client reads the
 // JSON port file written by AftRpcServer ({ port, token }) and includes that
@@ -1018,5 +1019,6 @@ const tui = async api => {
 const id = "aft-opencode";
 export default {
   id,
-  tui
+  tui,
+  setup: setupV2Tui
 };

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

@@ -1,7 +1,8 @@
-// Type declarations for @opencode-ai/plugin/tui
-// These types are not yet exported by the installed @opencode-ai/plugin package
+// Compatibility declarations for the GA @opencode/plugin/tui entrypoint.
+// AFT's shared TUI still consumes the legacy callback surface while its V2 setup
+// export uses the GA setup context directly.
 
-declare module "@opencode-ai/plugin/tui" {
+declare module "@opencode/plugin/tui" {
   import type {
     createOpencodeClient as createOpencodeClientV2,
     Event as TuiEvent,

package/src/tui-compiled/v2-status.ts

@@ -0,0 +1,56 @@
+import type { AftStatusSnapshot, StatusBar } from "../shared/status";
+
+function count(value: number | undefined): string {
+  return value === undefined ? "?" : String(value);
+}
+
+export function formatAftStatusSegment(status: AftStatusSnapshot | null): string {
+  const bar = status?.status_bar;
+  if (!bar) return "AFT starting…";
+  const stale = bar.tier2_stale ? "~" : "";
+  return (
+    `AFT E${count(bar.errors)} W${count(bar.warnings)} | ` +
+    `${stale}D${count(bar.dead_code)} U${count(bar.unused_exports)} ` +
+    `C${count(bar.duplicates)} | T${count(bar.todos)}`
+  );
+}
+
+export type AftSidebarSummary = {
+  title: string;
+  version?: string;
+  search: string;
+  semantic: string;
+  health: string;
+};
+
+function healthSummary(bar: StatusBar | undefined): string {
+  if (!bar) return "health pending";
+  const stale = bar.tier2_stale ? "~" : "";
+  return (
+    `E${count(bar.errors)} W${count(bar.warnings)} ` +
+    `${stale}D${count(bar.dead_code)} U${count(bar.unused_exports)} ` +
+    `C${count(bar.duplicates)} T${count(bar.todos)}`
+  );
+}
+
+export function summarizeAftSidebar(status: AftStatusSnapshot | null): AftSidebarSummary {
+  if (!status || status.cache_role === "not_initialized") {
+    return {
+      title: "AFT",
+      search: "not initialized",
+      semantic: "not initialized",
+      health: "health pending",
+    };
+  }
+
+  const semantic = status.semantic_index.stage
+    ? `${status.semantic_index.status} (${status.semantic_index.stage})`
+    : status.semantic_index.status;
+  return {
+    title: status.degraded ? "AFT · DEGRADED" : "AFT",
+    version: status.version || undefined,
+    search: status.search_index.status,
+    semantic,
+    health: healthSummary(status.status_bar),
+  };
+}

package/src/tui-compiled/v2.tsx

@@ -0,0 +1,181 @@
+import { createComponent as _$createComponent } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { createTextNode as _$createTextNode } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { insertNode as _$insertNode } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { memo as _$memo } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { setProp as _$setProp } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { insert as _$insert } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { createElement as _$createElement } from "opentui:runtime-module:%40opentui%2Fsolid";
+/** @jsxImportSource @opentui/solid */
+// @ts-nocheck
+
+import { createEffect, createSignal, onCleanup } from "opentui:runtime-module:solid-js";
+import { coerceAftStatus, formatStatusDialogMessage } from "../shared/status";
+import { AftRpc } from "./aft-rpc";
+import { formatAftStatusSegment, summarizeAftSidebar } from "./v2-status";
+function eventMatchesSession(eventSessionID, sessionID) {
+  return eventSessionID === undefined || eventSessionID === sessionID;
+}
+async function fetchStatus(context, rpc, sessionID, signal) {
+  const response = await rpc.getStatus(sessionID ? {
+    sessionID
+  } : {}, {
+    ...(context.location ? {
+      location: context.location
+    } : {}),
+    ...(signal ? {
+      signal
+    } : {})
+  });
+  return coerceAftStatus(response);
+}
+export function subscribeV2StatusRefresh(rpc, sessionID, refresh) {
+  const unsubscribes = [rpc.events.on("statusInvalidated", event => {
+    if (eventMatchesSession(event.data.sessionID, sessionID())) refresh();
+  }), rpc.events.on("indexProgress", event => {
+    if (eventMatchesSession(event.data.sessionID, sessionID())) refresh();
+  })];
+  return () => {
+    for (const unsubscribe of unsubscribes) unsubscribe();
+  };
+}
+function useAftStatus(context, rpc, sessionID) {
+  const [status, setStatus] = createSignal(null);
+  let refreshGeneration = 0;
+  let refreshController;
+  const refresh = async () => {
+    const requestedSessionID = sessionID();
+    const generation = ++refreshGeneration;
+    refreshController?.abort();
+    const controller = new AbortController();
+    refreshController = controller;
+    try {
+      const next = await fetchStatus(context, rpc, requestedSessionID, controller.signal);
+      if (controller.signal.aborted || generation !== refreshGeneration) return;
+      if (sessionID() !== requestedSessionID) return;
+      setStatus(next);
+    } catch {
+      // Status is best-effort UI data; the next typed invalidation retries it.
+    }
+  };
+  createEffect(() => {
+    sessionID();
+    void refresh();
+  });
+  const unsubscribe = subscribeV2StatusRefresh(rpc, sessionID, () => {
+    void refresh();
+  });
+  onCleanup(() => {
+    refreshGeneration += 1;
+    refreshController?.abort();
+    unsubscribe();
+  });
+  return status;
+}
+function FooterStatus(props) {
+  const status = useAftStatus(props.context, props.rpc, () => props.sessionID);
+  return (() => {
+    var _el$ = _$createElement("text");
+    _$insert(_el$, () => formatAftStatusSegment(status()));
+    return _el$;
+  })();
+}
+function SidebarStatus(props) {
+  const status = useAftStatus(props.context, props.rpc, () => props.sessionID);
+  const summary = () => summarizeAftSidebar(status());
+  return (() => {
+    var _el$2 = _$createElement("box"),
+      _el$3 = _$createElement("text"),
+      _el$4 = _$createElement("b"),
+      _el$5 = _$createElement("text"),
+      _el$6 = _$createTextNode(`Search: `),
+      _el$7 = _$createElement("text"),
+      _el$8 = _$createTextNode(`Semantic: `),
+      _el$9 = _$createElement("text"),
+      _el$0 = _$createTextNode(`Health: `);
+    _$insertNode(_el$2, _el$3);
+    _$insertNode(_el$2, _el$5);
+    _$insertNode(_el$2, _el$7);
+    _$insertNode(_el$2, _el$9);
+    _$setProp(_el$2, "width", "100%");
+    _$setProp(_el$2, "flexDirection", "column");
+    _$insertNode(_el$3, _el$4);
+    _$insert(_el$4, () => summary().title);
+    _$insert(_el$3, (() => {
+      var _c$ = _$memo(() => !!summary().version);
+      return () => _c$() ? ` v${summary().version}` : "";
+    })(), null);
+    _$insertNode(_el$5, _el$6);
+    _$insert(_el$5, () => summary().search, null);
+    _$insertNode(_el$7, _el$8);
+    _$insert(_el$7, () => summary().semantic, null);
+    _$insertNode(_el$9, _el$0);
+    _$insert(_el$9, () => summary().health, null);
+    return _el$2;
+  })();
+}
+function activeSessionID(context) {
+  const route = context.ui.router.current();
+  return route.type === "session" ? route.sessionID : undefined;
+}
+async function showStatusDialog(context, rpc, sessionID) {
+  try {
+    const status = await fetchStatus(context, rpc, sessionID);
+    await context.ui.dialog.alert({
+      title: "AFT Status",
+      message: formatStatusDialogMessage(status)
+    });
+  } catch {
+    await context.ui.dialog.alert({
+      title: "AFT Status",
+      message: "AFT is starting up. Status will refresh automatically."
+    });
+  }
+}
+export async function setupV2Tui(context) {
+  const rpc = context.client.rpc(AftRpc);
+  const controller = new AbortController();
+  const slotCleanups = [context.ui.slot({
+    append: "prompt.footer.status",
+    render: input => _$createComponent(FooterStatus, {
+      context: context,
+      rpc: rpc,
+      get sessionID() {
+        return input.sessionID;
+      }
+    })
+  }), context.ui.slot({
+    append: "sidebar.content",
+    render: input => _$createComponent(SidebarStatus, {
+      context: context,
+      rpc: rpc,
+      get sessionID() {
+        return input.sessionID;
+      }
+    })
+  })];
+  const stopDialogEvents = rpc.events.on("showStatusDialog", event => showStatusDialog(context, rpc, event.data.sessionID ?? activeSessionID(context)), {
+    signal: controller.signal
+  });
+  context.keymap.layer(() => ({
+    commands: [{
+      id: "aft.status",
+      title: "AFT: Status",
+      description: "Show AFT status, index health, and cache usage",
+      group: "AFT",
+      palette: true,
+      // V2's KeymapCommand contract (plugin/tui/context.ts:379-385) dispatches
+      // slash entries unless `arguments: true`; omitting it prevents this text
+      // from remaining in the prompt or being submitted to the model.
+      slash: {
+        name: "aft-status"
+      },
+      run: () => showStatusDialog(context, rpc, activeSessionID(context))
+    }],
+    bindings: []
+  }));
+  return () => {
+    controller.abort();
+    stopDialogEvents();
+    for (const cleanup of slotCleanups) cleanup();
+  };
+}

package/dist/tools/refactoring.d.ts

@@ -1,7 +0,0 @@
-import type { ToolDefinition } from "@opencode-ai/plugin";
-import type { PluginContext } from "../types.js";
-/**
- * Tool definitions for refactoring commands: move_symbol, extract_function, inline_symbol.
- */
-export declare function refactoringTools(ctx: PluginContext): Record<string, ToolDefinition>;
-//# sourceMappingURL=refactoring.d.ts.map

package/dist/tools/refactoring.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"refactoring.d.ts","sourceRoot":"","sources":["../../src/tools/refactoring.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAI1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAmBjD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAuJnF"}