Fully autonomous AI Agents system capable of performing complex penetration testing tasks
Go ai-agentsai-security-toolanthropicautonomous-agentsgolanggptgraphqlmulti-agent-systemoffensive-securityopen-sourceopenaipenetration-testingpenetration-testing-toolsreactsecurity-automationsecurity-testingsecurity-toolsself-hosted
feat(autocomplete): substring filter and code-language suggestions
Sergey Kozyrenkoba63992e88fc
diff --git a/frontend/src/components/ui/autocomplete.tsx b/frontend/src/components/ui/autocomplete.tsxindex 33e24a6a..1562c443 100644--- a/frontend/src/components/ui/autocomplete.tsx+++ b/frontend/src/components/ui/autocomplete.tsx@@ -12,15 +12,20 @@ import {} from '@/components/ui/command';import { Input } from '@/components/ui/input';import { Popover, PopoverAnchor } from '@/components/ui/popover';+import { useControllable } from '@/hooks/use-controllable';import { cn } from '@/lib/utils';/**- * Free-text input with a popover dropdown of fuzzy-filtered suggestions.+ * Free-text input with a popover dropdown of substring-filtered suggestions.*- * Built on top of `cmdk` (filtering + arrow/Enter navigation) and Radix- * Popover (positioning, outside-click, escape). The visible field is a real- * text input — unlike the shadcn `Combobox` pattern, the user can type- * arbitrary values that are not in the suggestion list.+ * Built on top of `cmdk` (keyboard navigation) and Radix Popover (positioning,+ * outside-click, escape). The visible field is a real text input — unlike the+ * shadcn `Combobox` pattern, the user can type arbitrary values that are not+ * in the suggestion list.+ *+ * Filtering defaults to a case-insensitive substring match against item+ * `value` and `keywords`. Pass a custom `filter` prop (e.g. cmdk's+ * `command-score` fuzzy matcher) when subsequence matching is desired.** @example* <Autocomplete value={path} onValueChange={setPath} onCommit={navigateTo}>@@ -59,38 +64,29 @@ const useAutocompleteContext = (): AutocompleteContextValue => {return ctx;};-/**- * Minimal controllable-state hook so we don't pull in- * `@radix-ui/react-use-controllable-state` just for two state slots.- *- * Mirrors Radix's behaviour: when `controlled` is `undefined` the hook owns- * the state; otherwise the parent does and we just forward updates via- * `onChange`. Updates always call `onChange` so consumers can observe even- * fully-controlled changes (e.g. logging).- */-const useControllable = <T,>(controlled: T | undefined, defaultValue: T, onChange?: (value: T) => void) => {- const [internal, setInternal] = React.useState<T>(defaultValue);- const isControlled = controlled !== undefined;- const value = isControlled ? (controlled as T) : internal;-- const onChangeRef = React.useRef(onChange);-- React.useEffect(() => {- onChangeRef.current = onChange;- }, [onChange]);+// Case-insensitive substring matcher used as the default. cmdk ships+// `command-score` (fuzzy/subsequence), which is great for command palettes+// but surprising in plain autocomplete usage — e.g. typing `baa` would still+// highlight `bash` because the characters appear in order. Substring matching+// is the conventional autocomplete contract: results contain the typed text+// somewhere, or they don't appear at all. Consumers that need fuzzy semantics+// can opt back in via the `filter` prop.+const substringFilter = (value: string, search: string, keywords?: string[]): number => {+ const needle = search.trim().toLowerCase();++ if (!needle) {+ return 1;+ }- const set = React.useCallback(- (next: T) => {- if (!isControlled) {- setInternal(next);- }+ if (value.toLowerCase().includes(needle)) {+ return 1;+ }- onChangeRef.current?.(next);- },- [isControlled],- );+ if (keywords?.some((kw) => kw.toLowerCase().includes(needle))) {+ return 1;+ }- return [value, set] as const;+ return 0;};export interface AutocompleteProps {@@ -99,7 +95,9 @@ export interface AutocompleteProps {defaultValue?: string;/*** Custom matcher forwarded to `cmdk`. Returns `0..1` (1 = best match,- * 0 = hidden). Defaults to `command-score` fuzzy matching.+ * 0 = hidden). Defaults to a case-insensitive substring match against+ * the item `value` (and any provided `keywords`); pass cmdk's+ * `command-score` here to opt back into fuzzy/subsequence matching.*/filter?: (value: string, search: string, keywords?: string[]) => number;/**@@ -174,7 +172,7 @@ const Autocomplete = ({open={open}><Command- filter={filter}+ filter={filter ?? substringFilter}label="Suggestions"shouldFilter={shouldFilter}>@@ -196,28 +194,18 @@ const AutocompleteInput = React.forwardRef<HTMLInputElement, AutocompleteInputPr({ className, id, onFocus, onKeyDown, onPointerDown, ...props }, forwardedRef) => {const { commit, inputId, inputRef, inputValue, openOnFocus, setInputValue, setOpen } = useAutocompleteContext();- // Read live cmdk store so we know whether Enter would land on a real- // match. When there are no matches (or no highlighted value), we- // commit the raw input ourselves; otherwise we let cmdk fire the- // selected item's `onSelect`, which will commit through the context.- //- // Single subscription returning a primitive boolean — `useSyncExternalStore`- // does referential equality, so collapsing the two slots into one boolean- // halves the per-keystroke re-renders without breaking the snapshot check- // (which would happen if we returned a fresh object each time).+ // True when Enter would land on a real match. Selecting a suggestion+ // commits through cmdk's `onSelect`; Enter without a match commits the+ // raw input ourselves. Returning a primitive (not an object) lets+ // `useSyncExternalStore`'s referential check halve per-keystroke renders.const hasActiveMatch = useCommandState((state) => state.filtered.count > 0 && Boolean(state.value));- // Skip the very first focus event — it's the `autoFocus` case (or any- // other focus the parent fires synchronously during mount). Auto-opening- // a popover before the user did anything is jarring; browser address- // bars (Chrome, Firefox) behave the same way.- //- // No `setTimeout` needed: React's `autoFocus` lives in the commit phase- // (`commitMount`), and the native `focus` event fires synchronously- // inside that `el.focus()` call — so our `onFocus` handler runs before- // any passive effect. The flag is therefore still `true` during the- // mount-time focus and is flipped to `false` here, in time for every- // subsequent user-driven focus (click, Tab, re-focus after Escape).+ // Suppress the autoFocus-fired `focus` on mount: opening the popover+ // before the user did anything is jarring (browser address bars behave+ // the same). React's autoFocus fires the native event synchronously+ // during `commitMount`, before any effect — so the flag is still `true`+ // for that first focus and flipped to `false` here for every+ // user-driven focus (click, Tab, re-focus after Escape).const isMountFocusRef = React.useRef(true);React.useEffect(() => {@@ -240,6 +228,10 @@ const AutocompleteInput = React.forwardRef<HTMLInputElement, AutocompleteInputPrconst handleFocus = (event: React.FocusEvent<HTMLInputElement>) => {onFocus?.(event);+ if (event.defaultPrevented) {+ return;+ }+if (openOnFocus && !isMountFocusRef.current) {setOpen(true);}@@ -304,16 +296,11 @@ const AutocompleteInput = React.forwardRef<HTMLInputElement, AutocompleteInputPrreturn (<PopoverAnchor asChild>{/*- * `asChild` makes cmdk render through Radix `Slot`, which lets us- * delegate the actual DOM `<input>` (and its shadcn styling) to- * the project-wide `Input` component. cmdk still owns the value- * sync, ARIA combobox attributes and `cmdk-input=""` data hook,- * Slot just merges them into `Input` — handlers compose, primitive- * props from cmdk fill in whatever the child doesn't define.- *- * Note: cmdk hard-codes `autoComplete="off"`, `autoCorrect="off"`- * and `spellCheck={false}` on its primitive after the props spread,- * so we don't repeat them here.+ * `asChild` delegates the DOM input (and shadcn styling) to the+ * project's `Input` while cmdk keeps value sync, ARIA combobox+ * attributes and `cmdk-input=""`. cmdk also hard-codes+ * `autoComplete/autoCorrect="off"` and `spellCheck={false}` —+ * don't repeat them.*/}<CommandPrimitive.InputasChild@@ -354,6 +341,7 @@ const AutocompleteContent = React.forwardRef<children,className,listClassName,+ onFocusOutside,onInteractOutside,onOpenAutoFocus,sideOffset = 4,@@ -362,6 +350,19 @@ const AutocompleteContent = React.forwardRef<ref,) => {const { inputRef } = useAutocompleteContext();+ const contentRef = React.useRef<null | React.ElementRef<typeof PopoverPrimitive.Content>>(null);+ const composedRef = React.useCallback(+ (node: null | React.ElementRef<typeof PopoverPrimitive.Content>) => {+ contentRef.current = node;++ if (typeof ref === 'function') {+ ref(node);+ } else if (ref) {+ (ref as React.MutableRefObject<typeof node>).current = node;+ }+ },+ [ref],+ );return (/*@@ -387,6 +388,31 @@ const AutocompleteContent = React.forwardRef<'max-h-(--radix-popover-content-available-height) w-(--radix-popover-trigger-width) min-w-(--radix-popover-trigger-width) overflow-hidden p-0',className,)}+ onFocusOutside={(event) => {+ onFocusOutside?.(event);++ if (event.defaultPrevented) {+ return;+ }++ // Radix `DismissableLayer` treats the anchor input as+ // "outside" (it isn't a Trigger), and its React-tree flag+ // races on Content's own focusin when our `CommandList`+ // synchronously bounces focus back to the input — both+ // produce spurious `focusOutside` events that would+ // dismiss the popover. Treat focus on the anchor input+ // or anywhere inside Content as "inside".+ //+ // Radix dispatches this event directly on the focused+ // element (`bubbles: false`), so `event.target` IS it.+ const focusTarget = event.target as Node | null;+ const focusInsideInput = !!(focusTarget && inputRef.current?.contains(focusTarget));+ const focusInsideContent = !!(focusTarget && contentRef.current?.contains(focusTarget));++ if (focusInsideInput || focusInsideContent) {+ event.preventDefault();+ }+ }}onInteractOutside={(event) => {onInteractOutside?.(event);@@ -395,8 +421,13 @@ const AutocompleteContent = React.forwardRef<}// Clicking the input itself shouldn't dismiss the popover —- // Radix treats the anchor as "outside" since it isn't a Trigger.- if (inputRef.current?.contains(event.target as Node)) {+ // Radix treats the anchor as "outside" since it isn't a+ // Trigger. The real pointer target is the focused+ // element via `event.target` (custom event is+ // dispatched on the target, `bubbles: false`).+ const interactTarget = event.target as Node | null;++ if (interactTarget && inputRef.current?.contains(interactTarget)) {event.preventDefault();}}}@@ -410,7 +441,7 @@ const AutocompleteContent = React.forwardRef<// Keep focus on the input so typing keeps working immediately.event.preventDefault();}}- ref={ref}+ ref={composedRef}sideOffset={sideOffset}{...props}>@@ -422,7 +453,23 @@ const AutocompleteContent = React.forwardRef<* list so a long suggestion set scrolls inside the popover* instead of pushing the popover past the viewport.*/}- <CommandList className={cn('max-h-[280px] overflow-x-hidden overflow-y-auto', listClassName)}>+ <CommandList+ className={cn('max-h-[280px] overflow-x-hidden overflow-y-auto', listClassName)}+ onFocus={(event) => {+ // cmdk re-focuses the input by id when its value+ // changes (`document.getElementById(inputId).focus()`),+ // falling back to the list when the lookup fails — and+ // it fails as soon as a wrapper like `FormControl`+ // overrides the input's id via Radix Slot. The listbox+ // then steals focus and typing breaks. Per the+ // aria-activedescendant pattern the listbox shouldn't+ // hold real focus (tabindex=-1), so bounce it back.+ // `target === currentTarget` skips legitimate child focus.+ if (event.target === event.currentTarget) {+ inputRef.current?.focus();+ }+ }}+ >{children}</CommandList></PopoverPrimitive.Content>diff --git a/frontend/src/features/knowledges/knowledge-form-controls.tsx b/frontend/src/features/knowledges/knowledge-form-controls.tsxindex fa176a17..417b805b 100644--- a/frontend/src/features/knowledges/knowledge-form-controls.tsx+++ b/frontend/src/features/knowledges/knowledge-form-controls.tsx@@ -6,8 +6,15 @@ import type {} from '@/graphql/types';import { MarkdownEditor } from '@/components/shared/markdown-editor';+import {+ Autocomplete,+ AutocompleteContent,+ AutocompleteEmpty,+ AutocompleteGroup,+ AutocompleteInput,+ AutocompleteItem,+} from '@/components/ui/autocomplete';import { FormControl, FormField, FormItem, FormLabel, FormMessage } from '@/components/ui/form';-import { Input } from '@/components/ui/input';import { InputGroup, InputGroupTextareaAutosize } from '@/components/ui/input-group';import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select';import { KnowledgeAnswerType, KnowledgeDocType, KnowledgeGuideType } from '@/graphql/types';@@ -22,6 +29,45 @@ const docTypeValues = [KnowledgeDocType.Answer, KnowledgeDocType.Guide, Knowledgconst guideTypeValues = Object.values(KnowledgeGuideType) as KnowledgeGuideTypeT[];const answerTypeValues = Object.values(KnowledgeAnswerType) as KnowledgeAnswerTypeT[];+// The backend stores `code_lang` as a free-form string and uses it both as a+// vector-store filter and as the markdown code-block tag (see+// `backend/pkg/tools/code.go`). There is no enum to sync against — this is+// purely a UX list of common values surfaced as combobox suggestions; users+// can still type any custom identifier.+const LANGUAGES = [+ 'bash',+ 'c',+ 'cpp',+ 'csharp',+ 'css',+ 'dockerfile',+ 'go',+ 'groovy',+ 'haskell',+ 'html',+ 'java',+ 'javascript',+ 'json',+ 'kotlin',+ 'lua',+ 'markdown',+ 'nginx',+ 'perl',+ 'php',+ 'powershell',+ 'python',+ 'ruby',+ 'rust',+ 'scala',+ 'shell',+ 'sql',+ 'swift',+ 'toml',+ 'typescript',+ 'xml',+ 'yaml',+] as const;+interface KnowledgeMetaFieldsProps {control: Control<FormValues>;isNew: boolean;@@ -168,14 +214,40 @@ export const KnowledgeMetaFields = ({ control, isNew, isSaving }: KnowledgeMetaFrender={({ field }) => (<FormItem><FormLabel>Code language</FormLabel>- <FormControl>- <Input- disabled={isSaving}- maxLength={KNOWLEDGE_LIMITS.codeLang}- placeholder="e.g. python, go, typescript"- {...field}- />- </FormControl>+ {/*+ * `Autocomplete` is a free-text input with a+ * suggestion popover — the backend accepts any+ * string here, so the dropdown is a UX hint+ * rather than a closed enum.+ */}+ <Autocomplete+ onValueChange={field.onChange}+ value={field.value ?? ''}+ >+ <FormControl>+ <AutocompleteInput+ disabled={isSaving}+ maxLength={KNOWLEDGE_LIMITS.codeLang}+ name={field.name}+ onBlur={field.onBlur}+ placeholder="e.g. python, go, typescript"+ ref={field.ref}+ />+ </FormControl>+ <AutocompleteContent>+ <AutocompleteEmpty>No matching language</AutocompleteEmpty>+ <AutocompleteGroup>+ {LANGUAGES.map((lang) => (+ <AutocompleteItem+ key={lang}+ value={lang}+ >+ {lang}+ </AutocompleteItem>+ ))}+ </AutocompleteGroup>+ </AutocompleteContent>+ </Autocomplete><FormMessage /></FormItem>)}diff --git a/frontend/src/hooks/use-controllable.ts b/frontend/src/hooks/use-controllable.tsnew file mode 100644index 00000000..90279515--- /dev/null+++ b/frontend/src/hooks/use-controllable.ts@@ -0,0 +1,33 @@+import { useCallback, useState } from 'react';++import { useLatestRef } from '@/hooks/use-latest-ref';++/**+ * Radix-style controllable state. When `controlled` is `undefined` the hook+ * owns the state; otherwise the parent does and we forward updates via+ * `onChange`. `onChange` always fires so fully-controlled consumers can+ * observe every set (e.g. for logging).+ *+ * Mirrors `@radix-ui/react-use-controllable-state` without pulling in the+ * dependency for a couple of state slots.+ */+export const useControllable = <T>(controlled: T | undefined, defaultValue: T, onChange?: (value: T) => void) => {+ const [internal, setInternal] = useState<T>(defaultValue);+ const isControlled = controlled !== undefined;+ const value = isControlled ? (controlled as T) : internal;++ const onChangeRef = useLatestRef(onChange);++ const set = useCallback(+ (next: T) => {+ if (!isControlled) {+ setInternal(next);+ }++ onChangeRef.current?.(next);+ },+ [isControlled, onChangeRef],+ );++ return [value, set] as const;+};