@cortexkit/aft-opencode 0.12.1 → 0.12.2

package/src/shared/status.ts

@@ -0,0 +1,206 @@
+export interface AftStatusSnapshot {
+  version: string;
+  project_root: string | null;
+  features: {
+    format_on_edit: boolean;
+    validate_on_edit: string;
+    restrict_to_project_root: boolean;
+    experimental_search_index: boolean;
+    experimental_semantic_search: boolean;
+  };
+  search_index: {
+    status: string;
+    files: number | null;
+    trigrams: number | null;
+  };
+  semantic_index: {
+    status: string;
+    entries: number | null;
+    dimension: number | null;
+  };
+  disk: {
+    storage_dir: string | null;
+    trigram_disk_bytes: number;
+    semantic_disk_bytes: number;
+  };
+  lsp_servers: number;
+  symbol_cache: {
+    local_entries: number;
+    warm_entries: number;
+  };
+  storage_dir: string | null;
+}
+
+function asRecord(value: unknown): Record<string, unknown> {
+  return typeof value === "object" && value !== null ? (value as Record<string, unknown>) : {};
+}
+
+function readString(value: unknown, fallback = ""): string {
+  return typeof value === "string" ? value : fallback;
+}
+
+function readNullableString(value: unknown): string | null {
+  return typeof value === "string" ? value : null;
+}
+
+function readBoolean(value: unknown, fallback = false): boolean {
+  return typeof value === "boolean" ? value : fallback;
+}
+
+function readNumber(value: unknown, fallback = 0): number {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+function readOptionalNumber(value: unknown): number | null {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+function formatFlag(enabled: boolean): string {
+  return enabled ? "enabled" : "disabled";
+}
+
+function formatCount(value: number | null): string {
+  return value == null ? "—" : value.toLocaleString("en-US");
+}
+
+export function formatBytes(bytes: number): string {
+  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]}`;
+}
+
+export function coerceAftStatus(response: Record<string, unknown>): AftStatusSnapshot {
+  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),
+  };
+}
+
+export function formatStatusDialogMessage(status: AftStatusSnapshot): string {
+  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("\n");
+}
+
+export function formatStatusMarkdown(status: AftStatusSnapshot): string {
+  const lines = [
+    "## AFT Status",
+    "",
+    `- **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("\n");
+}

package/src/shared/tui-config.ts

@@ -0,0 +1,58 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { parse, stringify } from "comment-json";
+import { log } from "../logger";
+import { getOpenCodeConfigPaths } from "./opencode-config-dir";
+
+const PLUGIN_NAME = "@cortexkit/aft-opencode";
+const PLUGIN_ENTRY = `${PLUGIN_NAME}@latest`;
+
+function resolveTuiConfigPath(): string {
+  const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
+  const jsoncPath = join(configDir, "tui.jsonc");
+  const jsonPath = join(configDir, "tui.json");
+
+  if (existsSync(jsoncPath)) return jsoncPath;
+  if (existsSync(jsonPath)) return jsonPath;
+  return jsonPath;
+}
+
+export function ensureTuiPluginEntry(): boolean {
+  try {
+    const configPath = resolveTuiConfigPath();
+
+    let config: Record<string, unknown> = {};
+    if (existsSync(configPath)) {
+      config = (parse(readFileSync(configPath, "utf-8")) as Record<string, unknown>) ?? {};
+    }
+
+    const plugins = Array.isArray(config.plugin)
+      ? config.plugin.filter((value): value is string => typeof value === "string")
+      : [];
+
+    if (
+      plugins.some(
+        (plugin) =>
+          plugin === PLUGIN_NAME ||
+          plugin.startsWith(`${PLUGIN_NAME}@`) ||
+          plugin.includes("opencode-plugin") ||
+          plugin.includes("aft-opencode"),
+      )
+    ) {
+      return false;
+    }
+
+    plugins.push(PLUGIN_ENTRY);
+    config.plugin = plugins;
+
+    mkdirSync(dirname(configPath), { recursive: true });
+    writeFileSync(configPath, `${stringify(config, null, 2)}\n`);
+    log(`[aft-plugin] added TUI plugin entry to ${configPath}`);
+    return true;
+  } catch (error) {
+    log(
+      `[aft-plugin] failed to update tui.json: ${error instanceof Error ? error.message : String(error)}`,
+    );
+    return false;
+  }
+}

package/src/shared/url-fetch.ts

@@ -0,0 +1,237 @@
+import { createHash } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { log, warn } from "../logger";
+
+/** Max response body size (10 MB) */
+const MAX_RESPONSE_BYTES = 10 * 1024 * 1024;
+/** Cache TTL: 1 day */
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+/** Fetch timeout: 30 seconds */
+const FETCH_TIMEOUT_MS = 30_000;
+
+interface CacheMeta {
+  url: string;
+  contentType: string;
+  extension: string;
+  fetchedAt: number;
+}
+
+function cacheDir(storageDir: string): string {
+  return join(storageDir, "url_cache");
+}
+
+function hashUrl(url: string): string {
+  return createHash("sha256").update(url).digest("hex").slice(0, 16);
+}
+
+function metaPath(storageDir: string, hash: string): string {
+  return join(cacheDir(storageDir), `${hash}.meta.json`);
+}
+
+function contentPath(storageDir: string, hash: string, extension: string): string {
+  return join(cacheDir(storageDir), `${hash}${extension}`);
+}
+
+/**
+ * Map a Content-Type header to a file extension AFT can parse.
+ * Returns null for unsupported types.
+ */
+function resolveExtension(contentType: string): string | null {
+  // Normalize: strip parameters (after `;`) AND pick the first value if the server
+  // echoed back a comma-separated list (GitHub API does this for /readme endpoints).
+  const lower = contentType.toLowerCase().split(";")[0].split(",")[0].trim();
+  if (
+    lower === "text/html" ||
+    lower === "application/xhtml+xml" ||
+    lower === "application/vnd.github.html" ||
+    lower === "application/vnd.github+html"
+  ) {
+    return ".html";
+  }
+  if (
+    lower === "text/markdown" ||
+    lower === "text/x-markdown" ||
+    lower === "application/markdown" ||
+    // GitHub API raw content type — returns raw markdown for README endpoints
+    lower === "application/vnd.github.raw" ||
+    lower === "application/vnd.github+raw" ||
+    lower === "application/vnd.github.v3.raw"
+  ) {
+    return ".md";
+  }
+  if (lower === "text/plain") {
+    // treat plain text as markdown so aft_outline can show headings if present
+    return ".md";
+  }
+  return null;
+}
+
+/**
+ * Fetch a URL to a cached temp file. Uses disk cache with 1-day TTL.
+ * Returns the cached file path the Rust outline/zoom command can read.
+ * Throws on errors (invalid URL, network failure, unsupported content type, oversized body).
+ */
+export async function fetchUrlToTempFile(url: string, storageDir: string): Promise<string> {
+  let parsed: URL;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(`Only http:// and https:// URLs are supported, got: ${parsed.protocol}`);
+  }
+
+  const dir = cacheDir(storageDir);
+  mkdirSync(dir, { recursive: true });
+
+  const hash = hashUrl(url);
+  const metaFile = metaPath(storageDir, hash);
+
+  // Check cache
+  if (existsSync(metaFile)) {
+    try {
+      const meta = JSON.parse(readFileSync(metaFile, "utf8")) as CacheMeta;
+      const age = Date.now() - meta.fetchedAt;
+      const cached = contentPath(storageDir, hash, meta.extension);
+      if (age < CACHE_TTL_MS && existsSync(cached)) {
+        log(`URL cache hit: ${url} (${Math.round(age / 1000)}s old)`);
+        return cached;
+      }
+    } catch {
+      // corrupted meta, re-fetch
+    }
+  }
+
+  log(`Fetching URL: ${url}`);
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  let response: Response;
+  try {
+    response = await fetch(url, {
+      signal: controller.signal,
+      redirect: "follow",
+      headers: {
+        "user-agent": "aft-opencode-plugin",
+        // Prioritize markdown for content-negotiating servers (GitHub API, many docs sites).
+        // `application/vnd.github.raw` is GitHub's custom type — returns raw markdown from
+        // repo file and readme endpoints. Falls back to HTML if markdown is not available.
+        accept:
+          "application/vnd.github.raw, text/markdown, text/x-markdown, text/html;q=0.9, text/plain;q=0.5",
+      },
+    });
+  } catch (err) {
+    throw new Error(`Failed to fetch ${url}: ${(err as Error).message}`);
+  } finally {
+    clearTimeout(timer);
+  }
+
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status} ${response.statusText} fetching ${url}`);
+  }
+
+  const contentType = response.headers.get("content-type") || "text/plain";
+  const extension = resolveExtension(contentType);
+  if (!extension) {
+    throw new Error(
+      `Unsupported content type '${contentType}' for ${url}. Supported: text/html, text/markdown, text/plain`,
+    );
+  }
+
+  const lengthHeader = response.headers.get("content-length");
+  if (lengthHeader) {
+    const length = Number.parseInt(lengthHeader, 10);
+    if (Number.isFinite(length) && length > MAX_RESPONSE_BYTES) {
+      throw new Error(`Response too large: ${length} bytes (max ${MAX_RESPONSE_BYTES})`);
+    }
+  }
+
+  // Stream with size cap
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error(`Failed to read response body for ${url}`);
+  }
+  const chunks: Uint8Array[] = [];
+  let total = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (value) {
+      total += value.length;
+      if (total > MAX_RESPONSE_BYTES) {
+        reader.cancel().catch(() => {});
+        throw new Error(`Response exceeded ${MAX_RESPONSE_BYTES} bytes, aborted`);
+      }
+      chunks.push(value);
+    }
+  }
+
+  // Write content and meta atomically
+  const body = Buffer.concat(chunks);
+  const contentFile = contentPath(storageDir, hash, extension);
+  const tmpContent = `${contentFile}.tmp-${process.pid}`;
+  writeFileSync(tmpContent, body);
+  const { renameSync } = await import("node:fs");
+  renameSync(tmpContent, contentFile);
+
+  const meta: CacheMeta = {
+    url,
+    contentType,
+    extension,
+    fetchedAt: Date.now(),
+  };
+  const tmpMeta = `${metaFile}.tmp-${process.pid}`;
+  writeFileSync(tmpMeta, JSON.stringify(meta));
+  renameSync(tmpMeta, metaFile);
+
+  log(`URL cached (${total} bytes): ${url}`);
+  return contentFile;
+}
+
+/**
+ * Remove cache entries older than TTL. Called periodically at plugin startup.
+ */
+export function cleanupUrlCache(storageDir: string): void {
+  const dir = cacheDir(storageDir);
+  if (!existsSync(dir)) return;
+
+  let removed = 0;
+  try {
+    for (const entry of readdirSync(dir)) {
+      if (!entry.endsWith(".meta.json")) continue;
+      const metaFile = join(dir, entry);
+      try {
+        const meta = JSON.parse(readFileSync(metaFile, "utf8")) as CacheMeta;
+        const age = Date.now() - meta.fetchedAt;
+        if (age > CACHE_TTL_MS) {
+          const hash = entry.slice(0, -".meta.json".length);
+          const content = contentPath(storageDir, hash, meta.extension);
+          if (existsSync(content)) unlinkSync(content);
+          unlinkSync(metaFile);
+          removed++;
+        }
+      } catch {
+        // corrupted meta, remove it too
+        try {
+          unlinkSync(metaFile);
+          removed++;
+        } catch {}
+      }
+    }
+  } catch (err) {
+    warn(`URL cache cleanup failed: ${(err as Error).message}`);
+    return;
+  }
+  if (removed > 0) {
+    log(`URL cache cleanup: removed ${removed} stale entries`);
+  }
+}

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,
+};