@cortexkit/aft-opencode 0.12.0 → 0.12.1

package/dist/tui.js

@@ -0,0 +1,386 @@
+// @bun
+// src/shared/rpc-client.ts
+import { readFileSync } from "fs";
+
+// src/shared/rpc-utils.ts
+import { createHash } from "crypto";
+import { join } from "path";
+function projectHash(directory) {
+  const normalized = directory.replace(/\/+$/, "");
+  return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+}
+function rpcPortFilePath(storageDir, directory) {
+  const hash = projectHash(directory);
+  return join(storageDir, "rpc", hash, "port");
+}
+
+// src/shared/rpc-client.ts
+var MAX_RETRIES = 10;
+var RETRY_DELAY_MS = 500;
+var REQUEST_TIMEOUT_MS = 5000;
+
+class AftRpcClient {
+  port = null;
+  portFilePath;
+  healthChecked = false;
+  constructor(storageDir, directory) {
+    this.portFilePath = rpcPortFilePath(storageDir, directory);
+  }
+  async call(method, params = {}) {
+    const port = await this.resolvePort();
+    if (!port) {
+      throw new Error("AFT RPC server not available");
+    }
+    const response = await this.fetchWithTimeout(`http://127.0.0.1:${port}/rpc/${method}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(params)
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`RPC ${method} failed (${response.status}): ${text}`);
+    }
+    return await response.json();
+  }
+  async isAvailable() {
+    try {
+      const port = await this.resolvePort();
+      return port !== null;
+    } catch {
+      return false;
+    }
+  }
+  async resolvePort() {
+    if (this.port && this.healthChecked) {
+      return this.port;
+    }
+    if (this.port) {
+      const alive = await this.healthCheck(this.port);
+      if (alive) {
+        this.healthChecked = true;
+        return this.port;
+      }
+      this.port = null;
+      this.healthChecked = false;
+    }
+    for (let attempt = 0;attempt < MAX_RETRIES; attempt++) {
+      const port = this.readPortFile();
+      if (port) {
+        const alive = await this.healthCheck(port);
+        if (alive) {
+          this.port = port;
+          this.healthChecked = true;
+          return port;
+        }
+      }
+      if (attempt < MAX_RETRIES - 1) {
+        await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+      }
+    }
+    return null;
+  }
+  readPortFile() {
+    try {
+      const content = readFileSync(this.portFilePath, "utf-8").trim();
+      const port = Number.parseInt(content, 10);
+      if (Number.isNaN(port) || port <= 0 || port > 65535) {
+        return null;
+      }
+      return port;
+    } catch {
+      return null;
+    }
+  }
+  async healthCheck(port) {
+    try {
+      const response = await this.fetchWithTimeout(`http://127.0.0.1:${port}/health`, {
+        method: "GET"
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  async fetchWithTimeout(url, options) {
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    try {
+      return await fetch(url, { ...options, signal: controller.signal });
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  reset() {
+    this.port = null;
+    this.healthChecked = false;
+  }
+}
+
+// src/shared/status.ts
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+function readString(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function readNullableString(value) {
+  return typeof value === "string" ? value : null;
+}
+function readBoolean(value, fallback = false) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function readNumber(value, fallback = 0) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function readOptionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function formatFlag(enabled) {
+  return enabled ? "enabled" : "disabled";
+}
+function formatCount(value) {
+  return value == null ? "\u2014" : value.toLocaleString("en-US");
+}
+function formatBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes <= 0)
+    return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let value = bytes;
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex++;
+  }
+  const decimals = value >= 10 || unitIndex === 0 ? 0 : 1;
+  return `${value.toFixed(decimals)} ${units[unitIndex]}`;
+}
+function coerceAftStatus(response) {
+  const features = asRecord(response.features);
+  const searchIndex = asRecord(response.search_index);
+  const semanticIndex = asRecord(response.semantic_index);
+  const disk = asRecord(response.disk);
+  const symbolCache = asRecord(response.symbol_cache);
+  return {
+    version: readString(response.version, "unknown"),
+    project_root: readNullableString(response.project_root),
+    features: {
+      format_on_edit: readBoolean(features.format_on_edit),
+      validate_on_edit: readString(features.validate_on_edit, "off"),
+      restrict_to_project_root: readBoolean(features.restrict_to_project_root),
+      experimental_search_index: readBoolean(features.experimental_search_index),
+      experimental_semantic_search: readBoolean(features.experimental_semantic_search)
+    },
+    search_index: {
+      status: readString(searchIndex.status, "unknown"),
+      files: readOptionalNumber(searchIndex.files),
+      trigrams: readOptionalNumber(searchIndex.trigrams)
+    },
+    semantic_index: {
+      status: readString(semanticIndex.status, "unknown"),
+      entries: readOptionalNumber(semanticIndex.entries),
+      dimension: readOptionalNumber(semanticIndex.dimension)
+    },
+    disk: {
+      storage_dir: readNullableString(disk.storage_dir),
+      trigram_disk_bytes: readNumber(disk.trigram_disk_bytes),
+      semantic_disk_bytes: readNumber(disk.semantic_disk_bytes)
+    },
+    lsp_servers: readNumber(response.lsp_servers),
+    symbol_cache: {
+      local_entries: readNumber(symbolCache.local_entries),
+      warm_entries: readNumber(symbolCache.warm_entries)
+    },
+    storage_dir: readNullableString(response.storage_dir)
+  };
+}
+function formatStatusDialogMessage(status) {
+  const lines = [
+    `AFT version: ${status.version}`,
+    `Project root: ${status.project_root ?? "(not configured)"}`,
+    "",
+    "Enabled features",
+    `- format_on_edit: ${formatFlag(status.features.format_on_edit)}`,
+    `- experimental_search_index: ${formatFlag(status.features.experimental_search_index)}`,
+    `- experimental_semantic_search: ${formatFlag(status.features.experimental_semantic_search)}`,
+    "",
+    "Search index",
+    `- status: ${status.search_index.status}`,
+    `- files: ${formatCount(status.search_index.files)}`,
+    `- trigrams: ${formatCount(status.search_index.trigrams)}`,
+    "",
+    "Semantic index",
+    `- status: ${status.semantic_index.status}`,
+    `- entries: ${formatCount(status.semantic_index.entries)}`
+  ];
+  if (status.semantic_index.dimension != null) {
+    lines.push(`- dimension: ${formatCount(status.semantic_index.dimension)}`);
+  }
+  lines.push("", "Disk usage", `- trigram index: ${formatBytes(status.disk.trigram_disk_bytes)}`, `- semantic index: ${formatBytes(status.disk.semantic_disk_bytes)}`, "", "Runtime", `- LSP servers: ${formatCount(status.lsp_servers)}`, `- symbol cache: ${formatCount(status.symbol_cache.local_entries)} local / ${formatCount(status.symbol_cache.warm_entries)} warm`);
+  if (status.storage_dir ?? status.disk.storage_dir) {
+    lines.push(`- storage dir: ${status.storage_dir ?? status.disk.storage_dir}`);
+  }
+  return lines.join(`
+`);
+}
+
+// src/tui/index.tsx
+import { jsxDEV } from "@opentui/solid/jsx-dev-runtime";
+var STATUS_COMMAND = "aft-status";
+var rpcClients = new Map;
+function getRpcClient(directory) {
+  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) {
+  try {
+    const route = api.route.current;
+    if (route?.name === "session" && route.params?.sessionID) {
+      return route.params.sessionID;
+    }
+  } catch {}
+  return null;
+}
+async function showStatusDialog(api) {
+  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);
+  let currentMessage = "Connecting to AFT...";
+  try {
+    const response = await client.call("status", { sessionID });
+    if (response.success !== false) {
+      const status = coerceAftStatus(response);
+      currentMessage = formatStatusDialogMessage(status);
+    }
+  } catch {
+    currentMessage = "AFT is starting up. Status will refresh automatically...";
+  }
+  let dialogOpen = true;
+  let pollTimer = null;
+  api.ui.dialog.setSize("large");
+  api.ui.dialog.replace(() => {
+    if (!pollTimer) {
+      pollTimer = setInterval(async () => {
+        if (!dialogOpen) {
+          if (pollTimer)
+            clearInterval(pollTimer);
+          return;
+        }
+        try {
+          const response = await client.call("status", { sessionID });
+          if (response.success !== false) {
+            const status = coerceAftStatus(response);
+            const newMessage = formatStatusDialogMessage(status);
+            if (newMessage !== currentMessage) {
+              currentMessage = newMessage;
+              api.ui.dialog.replace(() => /* @__PURE__ */ jsxDEV(api.ui.DialogAlert, {
+                title: "AFT Status",
+                message: currentMessage,
+                onConfirm: () => {
+                  dialogOpen = false;
+                  if (pollTimer)
+                    clearInterval(pollTimer);
+                  api.ui.dialog.setSize("medium");
+                }
+              }, undefined, false, undefined, this), () => {
+                dialogOpen = false;
+                if (pollTimer)
+                  clearInterval(pollTimer);
+                api.ui.dialog.setSize("medium");
+              });
+            }
+          }
+        } catch {}
+      }, 1500);
+    }
+    return /* @__PURE__ */ jsxDEV(api.ui.DialogAlert, {
+      title: "AFT Status",
+      message: currentMessage,
+      onConfirm: () => {
+        dialogOpen = false;
+        if (pollTimer)
+          clearInterval(pollTimer);
+        api.ui.dialog.setSize("medium");
+      }
+    }, undefined, false, undefined, this);
+  }, () => {
+    dialogOpen = false;
+    if (pollTimer)
+      clearInterval(pollTimer);
+    api.ui.dialog.setSize("medium");
+  });
+}
+async function showStartupNotifications(api) {
+  const directory = api.state.path.directory ?? "";
+  if (!directory)
+    return;
+  const client = getRpcClient(directory);
+  try {
+    const announcement = await client.call("get-announcement", {});
+    if (announcement.show && announcement.version && announcement.features?.length) {
+      const featureText = announcement.features.map((f) => `  \u2022 ${f}`).join(`
+`);
+      api.ui.dialog.replace(() => /* @__PURE__ */ jsxDEV(api.ui.DialogAlert, {
+        title: `AFT v${announcement.version}`,
+        message: `What's new:
+
+${featureText}`,
+        onConfirm: () => {
+          client.call("mark-announced", {});
+        }
+      }, undefined, false, undefined, this), () => {
+        client.call("mark-announced", {});
+      });
+      return;
+    }
+  } catch {}
+  try {
+    const result = await client.call("get-warnings", {});
+    if (result.warnings?.length) {
+      const warningText = result.warnings.join(`
+
+`);
+      api.ui.dialog.replace(() => /* @__PURE__ */ jsxDEV(api.ui.DialogAlert, {
+        title: "AFT Warning",
+        message: warningText,
+        onConfirm: () => {}
+      }, undefined, false, undefined, this), () => {});
+    }
+  } catch {}
+}
+var tui = async (api) => {
+  api.command.register(() => [
+    {
+      title: "AFT: Status",
+      value: "aft.status",
+      category: "AFT",
+      slash: { name: STATUS_COMMAND },
+      onSelect() {
+        showStatusDialog(api);
+      }
+    }
+  ]);
+  showStartupNotifications(api);
+};
+var id = "aft-opencode";
+var tui_default = {
+  id,
+  tui
+};
+export {
+  tui_default as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/aft-opencode",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "type": "module",
   "description": "OpenCode plugin for Agent File Tools (AFT) — tree-sitter and lsp powered code analysis",
   "main": "dist/index.js",
@@ -15,12 +15,10 @@
   },
   "files": [
     "dist",
-    "src/tui",
-    "src/shared",
     "README.md"
   ],
   "scripts": {
-    "build": "bun build src/index.ts --outdir dist --target bun --format esm --external @opencode-ai/plugin && bun build src/cli/index.ts --outfile dist/cli.js --target node --format esm && tsc --emitDeclarationOnly",
+    "build": "bun build src/index.ts --outdir dist --target bun --format esm --external @opencode-ai/plugin && bun build src/tui/index.tsx --outfile dist/tui.js --target bun --format esm --external @opencode-ai/plugin --external @opencode-ai/plugin/tui --external @opentui/solid --external solid-js && bun build src/cli/index.ts --outfile dist/cli.js --target node --format esm && tsc --emitDeclarationOnly",
     "typecheck": "tsc --noEmit",
     "pretest": "cd ../.. && cargo build",
     "test": "bun test",
@@ -35,11 +33,11 @@
     "zod": "^4.1.8"
   },
   "optionalDependencies": {
-    "@cortexkit/aft-darwin-arm64": "0.12.0",
-    "@cortexkit/aft-darwin-x64": "0.12.0",
-    "@cortexkit/aft-linux-arm64": "0.12.0",
-    "@cortexkit/aft-linux-x64": "0.12.0",
-    "@cortexkit/aft-win32-x64": "0.12.0"
+    "@cortexkit/aft-darwin-arm64": "0.12.1",
+    "@cortexkit/aft-darwin-x64": "0.12.1",
+    "@cortexkit/aft-linux-arm64": "0.12.1",
+    "@cortexkit/aft-linux-x64": "0.12.1",
+    "@cortexkit/aft-win32-x64": "0.12.1"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
@@ -52,7 +50,7 @@
     },
     "./tui": {
       "types": "./src/tui/index.tsx",
-      "import": "./src/tui/index.tsx"
+      "import": "./dist/tui.js"
     }
   },
   "oc-plugin": [

package/src/shared/opencode-config-dir.ts

@@ -1,46 +0,0 @@
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
-
-export type OpenCodeBinaryType = "opencode" | "opencode-desktop";
-
-export interface OpenCodeConfigDirOptions {
-  binary: OpenCodeBinaryType;
-  version?: string | null;
-  checkExisting?: boolean;
-}
-
-export interface OpenCodeConfigPaths {
-  configDir: string;
-  configJson: string;
-  configJsonc: string;
-  packageJson: string;
-  omoConfig: string;
-}
-
-function getCliConfigDir(): string {
-  const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
-  if (envConfigDir) {
-    return resolve(envConfigDir);
-  }
-
-  if (process.platform === "win32") {
-    return join(homedir(), ".config", "opencode");
-  }
-
-  return join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "opencode");
-}
-
-export function getOpenCodeConfigDir(_options: OpenCodeConfigDirOptions): string {
-  return getCliConfigDir();
-}
-
-export function getOpenCodeConfigPaths(options: OpenCodeConfigDirOptions): OpenCodeConfigPaths {
-  const configDir = getOpenCodeConfigDir(options);
-  return {
-    configDir,
-    configJson: join(configDir, "opencode.json"),
-    configJsonc: join(configDir, "opencode.jsonc"),
-    packageJson: join(configDir, "package.json"),
-    omoConfig: join(configDir, "magic-context.jsonc"),
-  };
-}

package/src/shared/rpc-client.ts

@@ -1,123 +0,0 @@
-import { readFileSync } from "node:fs";
-import { rpcPortFilePath } from "./rpc-utils.js";
-
-const MAX_RETRIES = 10;
-const RETRY_DELAY_MS = 500;
-const REQUEST_TIMEOUT_MS = 5000;
-
-export class AftRpcClient {
-  private port: number | null = null;
-  private portFilePath: string;
-  private healthChecked = false;
-
-  constructor(storageDir: string, directory: string) {
-    this.portFilePath = rpcPortFilePath(storageDir, directory);
-  }
-
-  /** Call an RPC method. Retries port resolution if the server isn't ready yet. */
-  async call<T = Record<string, unknown>>(
-    method: string,
-    params: Record<string, unknown> = {},
-  ): Promise<T> {
-    const port = await this.resolvePort();
-    if (!port) {
-      throw new Error("AFT RPC server not available");
-    }
-
-    const response = await this.fetchWithTimeout(`http://127.0.0.1:${port}/rpc/${method}`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(params),
-    });
-
-    if (!response.ok) {
-      const text = await response.text();
-      throw new Error(`RPC ${method} failed (${response.status}): ${text}`);
-    }
-
-    return (await response.json()) as T;
-  }
-
-  /** Check if the RPC server is reachable. */
-  async isAvailable(): Promise<boolean> {
-    try {
-      const port = await this.resolvePort();
-      return port !== null;
-    } catch {
-      return false;
-    }
-  }
-
-  private async resolvePort(): Promise<number | null> {
-    if (this.port && this.healthChecked) {
-      return this.port;
-    }
-
-    if (this.port) {
-      const alive = await this.healthCheck(this.port);
-      if (alive) {
-        this.healthChecked = true;
-        return this.port;
-      }
-      this.port = null;
-      this.healthChecked = false;
-    }
-
-    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
-      const port = this.readPortFile();
-      if (port) {
-        const alive = await this.healthCheck(port);
-        if (alive) {
-          this.port = port;
-          this.healthChecked = true;
-          return port;
-        }
-      }
-
-      if (attempt < MAX_RETRIES - 1) {
-        await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
-      }
-    }
-
-    return null;
-  }
-
-  private readPortFile(): number | null {
-    try {
-      const content = readFileSync(this.portFilePath, "utf-8").trim();
-      const port = Number.parseInt(content, 10);
-      if (Number.isNaN(port) || port <= 0 || port > 65535) {
-        return null;
-      }
-      return port;
-    } catch {
-      return null;
-    }
-  }
-
-  private async healthCheck(port: number): Promise<boolean> {
-    try {
-      const response = await this.fetchWithTimeout(`http://127.0.0.1:${port}/health`, {
-        method: "GET",
-      });
-      return response.ok;
-    } catch {
-      return false;
-    }
-  }
-
-  private async fetchWithTimeout(url: string, options: RequestInit): Promise<Response> {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
-    try {
-      return await fetch(url, { ...options, signal: controller.signal });
-    } finally {
-      clearTimeout(timeout);
-    }
-  }
-
-  reset(): void {
-    this.port = null;
-    this.healthChecked = false;
-  }
-}