@agent-native/toolkit 0.6.0 → 0.8.0

package/src/composer/use-file-search.ts

@@ -0,0 +1,64 @@
+import { useState, useEffect, useRef } from "react";
+
+import { useComposerRuntimeAdapters } from "./runtime-adapters.js";
+import type { FileResult } from "./types.js";
+
+export function useFileSearch(query: string, enabled: boolean) {
+  const { resolvePath = (path) => path } = useComposerRuntimeAdapters();
+  const [files, setFiles] = useState<FileResult[]>([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const requestIdRef = useRef(0);
+  const abortRef = useRef<AbortController | null>(null);
+
+  useEffect(() => {
+    if (!enabled) {
+      setFiles([]);
+      setIsLoading(false);
+      return;
+    }
+
+    setIsLoading(true);
+    const id = ++requestIdRef.current;
+    // Abort any in-flight request so a superseded/unmounted query stops fetching
+    // (mirrors use-mention-search). The requestId guard still protects state.
+    abortRef.current?.abort();
+    const abort = new AbortController();
+    abortRef.current = abort;
+
+    const timer = setTimeout(
+      async () => {
+        try {
+          const res = await fetch(
+            resolvePath(
+              `/_agent-native/agent-chat/files?q=${encodeURIComponent(query)}`,
+            ),
+            { signal: abort.signal },
+          );
+          if (!res.ok) throw new Error();
+          const data = await res.json();
+          // Only update if this is still the latest request
+          if (id === requestIdRef.current) {
+            setFiles(data.files || []);
+          }
+        } catch (err) {
+          if ((err as Error)?.name === "AbortError") return;
+          if (id === requestIdRef.current) {
+            setFiles([]);
+          }
+        } finally {
+          if (id === requestIdRef.current) {
+            setIsLoading(false);
+          }
+        }
+      },
+      query.length === 0 ? 0 : 200,
+    );
+
+    return () => {
+      clearTimeout(timer);
+      abort.abort();
+    };
+  }, [query, enabled, resolvePath]);
+
+  return { files, isLoading };
+}

package/src/composer/use-mention-search.ts

@@ -0,0 +1,90 @@
+import { useState, useEffect, useRef } from "react";
+
+import { useComposerRuntimeAdapters } from "./runtime-adapters.js";
+import type { MentionItem } from "./types.js";
+
+export function useMentionSearch(
+  query: string,
+  enabled: boolean,
+  resolvePathOverride?: (path: string) => string,
+) {
+  const { resolvePath = (path) => path } = useComposerRuntimeAdapters();
+  const resolveRequestPath = resolvePathOverride ?? resolvePath;
+  const [items, setItems] = useState<MentionItem[]>([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const abortRef = useRef<AbortController | null>(null);
+  const requestIdRef = useRef(0);
+
+  useEffect(() => {
+    if (!enabled) {
+      setItems([]);
+      setIsLoading(false);
+      return;
+    }
+
+    // Cancel any in-flight stream
+    abortRef.current?.abort();
+    const abort = new AbortController();
+    abortRef.current = abort;
+    const id = ++requestIdRef.current;
+
+    setItems([]);
+    setIsLoading(true);
+
+    const debounceMs = query.length === 0 ? 0 : 150;
+
+    const timer = setTimeout(async () => {
+      try {
+        const res = await fetch(
+          resolveRequestPath(
+            `/_agent-native/agent-chat/mentions?q=${encodeURIComponent(query)}`,
+          ),
+          { signal: abort.signal },
+        );
+        if (!res.ok || !res.body) throw new Error();
+
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buf = "";
+
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+
+          buf += decoder.decode(value, { stream: true });
+          const lines = buf.split("\n");
+          buf = lines.pop()!; // last line may be incomplete
+
+          for (const line of lines) {
+            if (!line.trim()) continue;
+            try {
+              const { items: batch } = JSON.parse(line) as {
+                items: MentionItem[];
+              };
+              if (id === requestIdRef.current && batch?.length) {
+                setItems((prev) => {
+                  // Deduplicate by id
+                  const seen = new Set(prev.map((x) => x.id));
+                  const fresh = batch.filter((x) => !seen.has(x.id));
+                  return fresh.length ? [...prev, ...fresh] : prev;
+                });
+              }
+            } catch {}
+          }
+        }
+      } catch (err: unknown) {
+        if (err instanceof Error && err.name === "AbortError") return;
+        if (id === requestIdRef.current) setItems([]);
+      } finally {
+        if (id === requestIdRef.current) setIsLoading(false);
+      }
+    }, debounceMs);
+
+    return () => {
+      clearTimeout(timer);
+      abort.abort();
+    };
+  }, [query, enabled, resolveRequestPath]);
+
+  return { items, isLoading };
+}

package/src/composer/use-skills.ts

@@ -0,0 +1,45 @@
+import { useState, useEffect, useRef } from "react";
+
+import { useComposerRuntimeAdapters } from "./runtime-adapters.js";
+import type { SkillResult } from "./types.js";
+
+export function useSkills(enabled: boolean) {
+  const { resolvePath = (path) => path } = useComposerRuntimeAdapters();
+  const [skills, setSkills] = useState<SkillResult[]>([]);
+  const [hint, setHint] = useState<string | undefined>();
+  const [isLoading, setIsLoading] = useState(false);
+  const requestIdRef = useRef(0);
+
+  useEffect(() => {
+    if (!enabled) {
+      return;
+    }
+
+    setIsLoading(true);
+    const id = ++requestIdRef.current;
+
+    fetch(resolvePath("/_agent-native/agent-chat/skills"))
+      .then((res) => {
+        if (!res.ok) throw new Error();
+        return res.json();
+      })
+      .then((data) => {
+        if (id === requestIdRef.current) {
+          setSkills(data.skills || []);
+          setHint(data.hint);
+        }
+      })
+      .catch(() => {
+        if (id === requestIdRef.current) {
+          setSkills([]);
+        }
+      })
+      .finally(() => {
+        if (id === requestIdRef.current) {
+          setIsLoading(false);
+        }
+      });
+  }, [enabled, resolvePath]);
+
+  return { skills, hint, isLoading };
+}