@cortexkit/aft-opencode 0.12.0 → 0.12.2

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA8BxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwC1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AA8HxD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAwBjE"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA8BxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwC1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAmIxD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAwBjE"}

package/dist/index.js

@@ -7805,12 +7805,13 @@ var require_src2 = __commonJS((exports, module) => {
 // src/index.ts
 import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
 import { createRequire as createRequire2 } from "module";
-import { homedir as homedir6 } from "os";
+import { homedir as homedir7 } from "os";
 import { join as join13 } from "path";
 
 // src/config.ts
 var import_comment_json = __toESM(require_src2(), 1);
 import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
 import { join as join2 } from "path";
 
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
@@ -21514,7 +21515,11 @@ function mergeConfigs(base, override) {
   };
 }
 function getOpenCodeConfigDir() {
-  const xdgConfig = process.env.XDG_CONFIG_HOME || join2(process.env.HOME || "~", ".config");
+  const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+  if (envDir) {
+    return envDir;
+  }
+  const xdgConfig = process.env.XDG_CONFIG_HOME || join2(homedir(), ".config");
   return join2(xdgConfig, "opencode");
 }
 function loadAftConfig(projectDirectory) {
@@ -21535,7 +21540,7 @@ function loadAftConfig(projectDirectory) {
 
 // src/downloader.ts
 import { chmodSync, existsSync as existsSync2, mkdirSync, unlinkSync } from "fs";
-import { homedir } from "os";
+import { homedir as homedir2 } from "os";
 import { join as join3 } from "path";
 
 // src/platform.ts
@@ -21557,10 +21562,10 @@ var REPO = "cortexkit/aft";
 function getCacheDir() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join3(homedir(), "AppData", "Local");
+    const base2 = localAppData || join3(homedir2(), "AppData", "Local");
     return join3(base2, "aft", "bin");
   }
-  const base = process.env.XDG_CACHE_HOME || join3(homedir(), ".cache");
+  const base = process.env.XDG_CACHE_HOME || join3(homedir2(), ".cache");
   return join3(base, "aft", "bin");
 }
 function getBinaryName() {
@@ -21755,7 +21760,7 @@ function normalizeToolMap(tools) {
 
 // src/notifications.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { homedir as homedir2, platform } from "os";
+import { homedir as homedir3, platform } from "os";
 import { join as join4 } from "path";
 function isTuiMode() {
   return process.env.OPENCODE_CLIENT === "cli";
@@ -21777,7 +21782,7 @@ var WARNING_MARKER = `${AFT_MARKER} \u26A0\uFE0F`;
 var STATUS_MARKER = `${AFT_MARKER} \u2705`;
 function getDesktopStatePath() {
   const os2 = platform();
-  const home = homedir2();
+  const home = homedir3();
   if (os2 === "darwin") {
     return join4(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
   }
@@ -22059,8 +22064,7 @@ async function downloadOnnxRuntime(info, targetDir) {
       const { execSync } = await import("child_process");
       execSync(`tar xzf "${archivePath}" -C "${tmpDir}"`, { stdio: "pipe" });
     } else {
-      const { execSync } = await import("child_process");
-      execSync(`unzip -q "${archivePath}" -d "${tmpDir}"`, { stdio: "pipe" });
+      await extractZipArchive(archivePath, tmpDir);
     }
     const extractedDir = join5(tmpDir, info.assetName, "lib");
     if (!existsSync4(extractedDir)) {
@@ -22118,10 +22122,42 @@ async function downloadOnnxRuntime(info, targetDir) {
     return null;
   }
 }
+async function extractZipArchive(archivePath, destinationDir) {
+  const { execFileSync } = await import("child_process");
+  if (process.platform === "win32") {
+    let powershellError;
+    try {
+      execFileSync("powershell.exe", [
+        "-NoProfile",
+        "-NonInteractive",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-Command",
+        "& { Expand-Archive -LiteralPath $args[0] -DestinationPath $args[1] -Force }",
+        archivePath,
+        destinationDir
+      ], { stdio: "pipe", timeout: 120000 });
+      return;
+    } catch (err) {
+      powershellError = err;
+      warn(`PowerShell Expand-Archive failed, falling back to cmd/tar: ${String(err)}`);
+    }
+    try {
+      execFileSync("cmd.exe", ["/d", "/s", "/c", `tar -xf "${archivePath}" -C "${destinationDir}"`], { stdio: "pipe", timeout: 120000 });
+      return;
+    } catch (cmdError) {
+      throw new Error(`ZIP extraction failed via PowerShell and cmd/tar. PowerShell: ${String(powershellError)} | cmd/tar: ${String(cmdError)}`);
+    }
+  }
+  execFileSync("unzip", ["-q", archivePath, "-d", destinationDir], {
+    stdio: "pipe",
+    timeout: 120000
+  });
+}
 
 // src/bridge.ts
 import { spawn } from "child_process";
-import { homedir as homedir3 } from "os";
+import { homedir as homedir4 } from "os";
 import { join as join6 } from "path";
 function compareSemver(a, b) {
   const pa = a.split(".").map(Number);
@@ -22279,7 +22315,7 @@ class BinaryBridge {
       stdio: ["pipe", "pipe", "pipe"],
       env: {
         ...process.env,
-        FASTEMBED_CACHE_DIR: process.env.FASTEMBED_CACHE_DIR || (typeof this.configOverrides.storage_dir === "string" ? join6(this.configOverrides.storage_dir, "semantic", "models") : join6(homedir3() || "", ".cache", "fastembed")),
+        FASTEMBED_CACHE_DIR: process.env.FASTEMBED_CACHE_DIR || (typeof this.configOverrides.storage_dir === "string" ? join6(this.configOverrides.storage_dir, "semantic", "models") : join6(homedir4() || "", ".cache", "fastembed")),
         ...typeof this.configOverrides._ort_dylib_dir === "string" && {
           ORT_DYLIB_PATH: join6(this.configOverrides._ort_dylib_dir, process.platform === "win32" ? "onnxruntime.dll" : process.platform === "darwin" ? "libonnxruntime.dylib" : "libonnxruntime.so")
         }
@@ -22493,7 +22529,7 @@ class BridgePool {
 import { execSync, spawnSync } from "child_process";
 import { chmodSync as chmodSync3, copyFileSync, existsSync as existsSync5, mkdirSync as mkdirSync4 } from "fs";
 import { createRequire } from "module";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir5 } from "os";
 import { join as join7 } from "path";
 function copyToVersionedCache(npmBinaryPath) {
   try {
@@ -22573,7 +22609,7 @@ function findBinarySync() {
     if (result)
       return result;
   } catch {}
-  const cargoPath = join7(homedir4(), ".cargo", "bin", `aft${ext}`);
+  const cargoPath = join7(homedir5(), ".cargo", "bin", `aft${ext}`);
   if (existsSync5(cargoPath))
     return cargoPath;
   return null;
@@ -22856,7 +22892,7 @@ import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as rea
 import { dirname as dirname2, join as join10 } from "path";
 
 // src/shared/opencode-config-dir.ts
-import { homedir as homedir5 } from "os";
+import { homedir as homedir6 } from "os";
 import { join as join9, resolve } from "path";
 function getCliConfigDir() {
   const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
@@ -22864,9 +22900,9 @@ function getCliConfigDir() {
     return resolve(envConfigDir);
   }
   if (process.platform === "win32") {
-    return join9(homedir5(), ".config", "opencode");
+    return join9(homedir6(), ".config", "opencode");
   }
-  return join9(process.env.XDG_CONFIG_HOME || join9(homedir5(), ".config"), "opencode");
+  return join9(process.env.XDG_CONFIG_HOME || join9(homedir6(), ".config"), "opencode");
 }
 function getOpenCodeConfigDir2(_options) {
   return getCliConfigDir();
@@ -25234,7 +25270,7 @@ var plugin = async (input) => {
     configOverrides.experimental_search_index = aftConfig.experimental_search_index;
   if (aftConfig.experimental_semantic_search !== undefined)
     configOverrides.experimental_semantic_search = aftConfig.experimental_semantic_search;
-  const dataHome = process.env.XDG_DATA_HOME || join13(homedir6(), ".local", "share");
+  const dataHome = process.env.XDG_DATA_HOME || join13(homedir7(), ".local", "share");
   configOverrides.storage_dir = join13(dataHome, "opencode", "storage", "plugin", "aft");
   if (aftConfig.experimental_semantic_search) {
     const storageDir2 = configOverrides.storage_dir;

package/dist/onnx-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"onnx-runtime.d.ts","sourceRoot":"","sources":["../src/onnx-runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AA0DH,4DAA4D;AAC5D,wBAAgB,0BAA0B,IAAI,OAAO,CAEpD;AAED,6EAA6E;AAC7E,wBAAgB,oBAAoB,IAAI,MAAM,CAQ7C;AAED;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA4BlF;AAgJD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAU3D"}
+{"version":3,"file":"onnx-runtime.d.ts","sourceRoot":"","sources":["../src/onnx-runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AA0DH,4DAA4D;AAC5D,wBAAgB,0BAA0B,IAAI,OAAO,CAEpD;AAED,6EAA6E;AAC7E,wBAAgB,oBAAoB,IAAI,MAAM,CAQ7C;AAED;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA4BlF;AA8LD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAU3D"}

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.2",
   "type": "module",
   "description": "OpenCode plugin for Agent File Tools (AFT) — tree-sitter and lsp powered code analysis",
   "main": "dist/index.js",
@@ -20,7 +20,7 @@
     "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 +35,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.2",
+    "@cortexkit/aft-darwin-x64": "0.12.2",
+    "@cortexkit/aft-linux-arm64": "0.12.2",
+    "@cortexkit/aft-linux-x64": "0.12.2",
+    "@cortexkit/aft-win32-x64": "0.12.2"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",

package/src/shared/rpc-client.ts

@@ -1,5 +1,5 @@
 import { readFileSync } from "node:fs";
-import { rpcPortFilePath } from "./rpc-utils.js";
+import { rpcPortFilePath } from "./rpc-utils";
 
 const MAX_RETRIES = 10;
 const RETRY_DELAY_MS = 500;

package/src/shared/rpc-server.ts

@@ -1,8 +1,8 @@
 import { mkdirSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
 import { dirname } from "node:path";
-import { log, warn } from "../logger.js";
-import { rpcPortFilePath } from "./rpc-utils.js";
+import { log, warn } from "../logger";
+import { rpcPortFilePath } from "./rpc-utils";
 
 type RpcHandler = (params: Record<string, unknown>) => Promise<Record<string, unknown>>;
 

package/src/shared/tui-config.ts

@@ -1,8 +1,8 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { parse, stringify } from "comment-json";
-import { log } from "../logger.js";
-import { getOpenCodeConfigPaths } from "./opencode-config-dir.js";
+import { log } from "../logger";
+import { getOpenCodeConfigPaths } from "./opencode-config-dir";
 
 const PLUGIN_NAME = "@cortexkit/aft-opencode";
 const PLUGIN_ENTRY = `${PLUGIN_NAME}@latest`;

package/src/shared/url-fetch.ts

@@ -8,7 +8,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { join } from "node:path";
-import { log, warn } from "../logger.js";
+import { log, warn } from "../logger";
 
 /** Max response body size (10 MB) */
 const MAX_RESPONSE_BYTES = 10 * 1024 * 1024;