@finos/legend-lego 2.0.196 → 2.0.198

package/src/legend-ai/components/LegendAIChatHelpers.ts

@@ -0,0 +1,117 @@
+/**
+ * Copyright (c) 2026-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { PRIMITIVE_TYPE } from '@finos/legend-graph';
+import type {
+  LegendAIProductMetadata,
+  TDSServiceSchema,
+  TDSColumnSchema,
+} from '../LegendAITypes.js';
+
+const MAX_SUGGESTED_QUERIES = 8;
+
+const STRING_TYPES = new Set<string>([PRIMITIVE_TYPE.STRING]);
+
+const NUMERIC_TYPES = new Set<string>([
+  PRIMITIVE_TYPE.NUMBER,
+  PRIMITIVE_TYPE.INTEGER,
+  PRIMITIVE_TYPE.FLOAT,
+  PRIMITIVE_TYPE.DECIMAL,
+]);
+
+const DATE_TYPES = new Set<string>([
+  PRIMITIVE_TYPE.DATE,
+  PRIMITIVE_TYPE.STRICTDATE,
+  PRIMITIVE_TYPE.DATETIME,
+]);
+
+export function isStringColumn(c: TDSColumnSchema): boolean {
+  return STRING_TYPES.has(c.type ?? '') && !c.name.toLowerCase().includes('id');
+}
+
+export function isNumericColumn(c: TDSColumnSchema): boolean {
+  return NUMERIC_TYPES.has(c.type ?? '');
+}
+
+export function isDateColumn(c: TDSColumnSchema): boolean {
+  return (
+    DATE_TYPES.has(c.type ?? '') ||
+    c.name.toLowerCase().includes('date') ||
+    c.name.toLowerCase().includes('time')
+  );
+}
+
+function buildDataInsightSuggestions(
+  primary: TDSServiceSchema,
+  stringCol: TDSColumnSchema | undefined,
+  numericCol: TDSColumnSchema | undefined,
+): string[] {
+  const result: string[] = [];
+  if (stringCol) {
+    result.push(
+      `Show the distinct ${stringCol.name} values from ${primary.title}`,
+    );
+  }
+
+  if (numericCol && !stringCol) {
+    result.push(`What is the total ${numericCol.name} in ${primary.title}?`);
+  }
+  return result;
+}
+
+function buildMultiServiceSuggestion(services: TDSServiceSchema[]): string[] {
+  if (services.length < 2) {
+    return [];
+  }
+  return [`Show 10 records from ${services[1]?.title}`];
+}
+
+export function buildSuggestedQueries(
+  services: TDSServiceSchema[],
+  metadata: LegendAIProductMetadata,
+): string[] {
+  const suggestions: string[] = [
+    `What data does ${metadata.name} offer and how can I use it?`,
+  ];
+
+  if (services.length === 0) {
+    return [
+      ...suggestions,
+      'What access points are available?',
+      'Describe the data model and key entities',
+    ];
+  }
+
+  const primary = services[0];
+  if (!primary) {
+    return [
+      ...suggestions,
+      'What access points are available and what columns do they have?',
+    ];
+  }
+
+  const stringCol = primary.columns.find(isStringColumn);
+  const numericCol = primary.columns.find(isNumericColumn);
+
+  const multiSvcSuggestions = buildMultiServiceSuggestion(services);
+
+  return [
+    ...suggestions,
+    `Show 10 records from ${primary.title}`,
+    ...buildDataInsightSuggestions(primary, stringCol, numericCol),
+    ...multiSvcSuggestions,
+  ].slice(0, MAX_SUGGESTED_QUERIES);
+}

package/src/legend-ai/components/LegendAIChatInput.tsx

@@ -0,0 +1,209 @@
+/**
+ * Copyright (c) 2026-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { useRef, useLayoutEffect, useEffect, useState, useMemo } from 'react';
+import {
+  SendIcon,
+  LoadingIcon,
+  SquareIcon,
+  SparkleStarsIcon,
+  CheckIcon,
+  clsx,
+} from '@finos/legend-art';
+import type { LegendAIChatState, LegendAIScopeItem } from '../LegendAITypes.js';
+import { LegendAIScopeSelector } from './LegendAIScopeSelector.js';
+
+const MAX_TEXTAREA_HEIGHT = 160;
+
+export const LegendAIChatInput = (props: {
+  state: LegendAIChatState;
+  scopes: LegendAIScopeItem[];
+}): React.ReactNode => {
+  const { state, scopes } = props;
+  const textareaRef = useRef<HTMLTextAreaElement>(null);
+  const modelDropdownRef = useRef<HTMLDivElement>(null);
+  const [isModelDropdownOpen, setIsModelDropdownOpen] = useState(false);
+
+  const modelLabel = useMemo(() => {
+    const modelName = state.selectedModelName ?? 'Auto';
+    return modelName.length > 18 ? `${modelName.slice(0, 17)}...` : modelName;
+  }, [state.selectedModelName]);
+
+  const effectiveModelName =
+    state.selectedModelName ?? state.availableModelNames[0];
+
+  useEffect(() => {
+    if (!isModelDropdownOpen) {
+      return undefined;
+    }
+    const handleClickOutside = (event: MouseEvent): void => {
+      if (
+        modelDropdownRef.current &&
+        !modelDropdownRef.current.contains(event.target as Node)
+      ) {
+        setIsModelDropdownOpen(false);
+      }
+    };
+    const handleEscape = (event: KeyboardEvent): void => {
+      if (event.key === 'Escape') {
+        setIsModelDropdownOpen(false);
+      }
+    };
+    document.addEventListener('mousedown', handleClickOutside);
+    document.addEventListener('keydown', handleEscape);
+    return (): void => {
+      document.removeEventListener('mousedown', handleClickOutside);
+      document.removeEventListener('keydown', handleEscape);
+    };
+  }, [isModelDropdownOpen]);
+
+  useLayoutEffect(() => {
+    const el = textareaRef.current;
+    if (el) {
+      el.style.height = 'auto';
+      const nextHeight = Math.min(el.scrollHeight, MAX_TEXTAREA_HEIGHT);
+      el.style.height = `${nextHeight}px`;
+    }
+  }, [state.questionText]);
+
+  return (
+    <div className="legend-ai__input-area">
+      <div className="legend-ai__question-wrapper">
+        {state.selectedScopes.length > 0 && (
+          <LegendAIScopeSelector
+            scopes={scopes}
+            selectedScopes={state.selectedScopes}
+            onToggleScope={state.toggleScope}
+            onRemoveScope={state.removeScope}
+            hideSelector={true}
+          />
+        )}
+
+        <div className="legend-ai__input-top">
+          <textarea
+            ref={textareaRef}
+            className="legend-ai__question"
+            placeholder="Ask anything about your data..."
+            rows={1}
+            spellCheck={false}
+            value={state.questionText}
+            onChange={(e): void => state.setQuestionText(e.target.value)}
+            onKeyDown={(e): void => {
+              if (e.key === 'Enter' && !e.shiftKey) {
+                e.preventDefault();
+                if (!state.isSending && state.questionText.trim()) {
+                  state.askQuestion();
+                }
+              }
+            }}
+          />
+        </div>
+
+        <div className="legend-ai__input-bottom">
+          <div className="legend-ai__input-bottom-left">
+            <LegendAIScopeSelector
+              scopes={scopes}
+              selectedScopes={state.selectedScopes}
+              onToggleScope={state.toggleScope}
+              onRemoveScope={state.removeScope}
+              hidePills={true}
+            />
+
+            {state.availableModelNames.length > 0 && (
+              <div className="legend-ai__model-selector" ref={modelDropdownRef}>
+                <button
+                  type="button"
+                  className="legend-ai__model-btn"
+                  title="Select model"
+                  aria-label="Select model"
+                  aria-haspopup="true"
+                  aria-expanded={isModelDropdownOpen}
+                  onClick={(): void =>
+                    setIsModelDropdownOpen((current) => !current)
+                  }
+                >
+                  <span className="legend-ai__model-btn-icon">
+                    <SparkleStarsIcon />
+                  </span>
+                  <span className="legend-ai__model-btn-label">
+                    {modelLabel}
+                  </span>
+                </button>
+                {isModelDropdownOpen && (
+                  <div className="legend-ai__model-dropdown">
+                    {state.availableModelNames.map((modelName) => {
+                      const isSelected = modelName === effectiveModelName;
+                      return (
+                        <button
+                          key={modelName}
+                          type="button"
+                          aria-pressed={isSelected}
+                          className={clsx('legend-ai__model-dropdown-item', {
+                            'legend-ai__model-dropdown-item--selected':
+                              isSelected,
+                          })}
+                          onClick={(): void => {
+                            state.setSelectedModelName(modelName);
+                            setIsModelDropdownOpen(false);
+                          }}
+                        >
+                          <span className="legend-ai__model-dropdown-item-label">
+                            {modelName}
+                          </span>
+                          <span className="legend-ai__model-dropdown-item-check">
+                            {isSelected ? <CheckIcon /> : null}
+                          </span>
+                        </button>
+                      );
+                    })}
+                  </div>
+                )}
+              </div>
+            )}
+          </div>
+
+          <div className="legend-ai__input-bottom-right">
+            {state.isSending && (
+              <button
+                type="button"
+                title="Stop generation"
+                aria-label="Stop generation"
+                className="legend-ai__stop-btn"
+                onClick={(): void => state.stopGeneration()}
+              >
+                <SquareIcon />
+              </button>
+            )}
+            <button
+              type="button"
+              title="Send"
+              aria-label="Send"
+              className="legend-ai__send-btn"
+              disabled={state.isSending || !state.questionText.trim()}
+              onClick={(): void => state.askQuestion()}
+            >
+              {state.isSending ? (
+                <LoadingIcon isLoading={true} />
+              ) : (
+                <SendIcon />
+              )}
+            </button>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+};

package/src/legend-ai/components/LegendAIScopeSelector.tsx

@@ -0,0 +1,199 @@
+/**
+ * Copyright (c) 2026-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { useState, useRef, useEffect, useCallback, useMemo } from 'react';
+import {
+  PlusCircleIcon,
+  SearchIcon,
+  CheckIcon,
+  TimesIcon,
+} from '@finos/legend-art';
+import type { LegendAIScopeItem } from '../LegendAITypes.js';
+
+export const LegendAIScopeSelector = (props: {
+  scopes: LegendAIScopeItem[];
+  selectedScopes: LegendAIScopeItem[];
+  onToggleScope: (scope: LegendAIScopeItem) => void;
+  onRemoveScope: (scopeId: string) => void;
+  hidePills?: boolean;
+  hideSelector?: boolean;
+}): React.ReactNode => {
+  const {
+    scopes,
+    selectedScopes,
+    onToggleScope,
+    onRemoveScope,
+    hidePills,
+    hideSelector,
+  } = props;
+  const [dropdownOpen, setDropdownOpen] = useState(false);
+  const [searchText, setSearchText] = useState('');
+  const dropdownRef = useRef<HTMLDivElement>(null);
+  const btnRef = useRef<HTMLButtonElement>(null);
+  const searchRef = useRef<HTMLInputElement>(null);
+
+  const filteredScopes = useMemo(
+    () =>
+      searchText.trim()
+        ? scopes.filter(
+            (s) =>
+              s.label.toLowerCase().includes(searchText.toLowerCase()) ||
+              s.description?.toLowerCase().includes(searchText.toLowerCase()),
+          )
+        : scopes,
+    [scopes, searchText],
+  );
+
+  const closeDropdown = useCallback((): void => {
+    setDropdownOpen(false);
+    setSearchText('');
+    btnRef.current?.focus();
+  }, []);
+
+  useEffect(() => {
+    if (!dropdownOpen) {
+      return undefined;
+    }
+    const handleClickOutside = (e: MouseEvent): void => {
+      if (
+        dropdownRef.current &&
+        !dropdownRef.current.contains(e.target as Node)
+      ) {
+        setDropdownOpen(false);
+        setSearchText('');
+      }
+    };
+    const handleEscape = (e: KeyboardEvent): void => {
+      if (e.key === 'Escape') {
+        closeDropdown();
+      }
+    };
+    document.addEventListener('mousedown', handleClickOutside);
+    document.addEventListener('keydown', handleEscape);
+    return (): void => {
+      document.removeEventListener('mousedown', handleClickOutside);
+      document.removeEventListener('keydown', handleEscape);
+    };
+  }, [dropdownOpen, closeDropdown]);
+
+  useEffect(() => {
+    if (dropdownOpen) {
+      requestAnimationFrame(() => searchRef.current?.focus());
+    }
+  }, [dropdownOpen]);
+
+  return (
+    <>
+      {!hidePills && selectedScopes.length > 0 && (
+        <div className="legend-ai__scope-pills">
+          {selectedScopes.map((scope) => (
+            <span key={scope.id} className="legend-ai__scope-pill">
+              <span className="legend-ai__scope-pill-label">{scope.label}</span>
+              <button
+                type="button"
+                className="legend-ai__scope-pill-remove"
+                aria-label={`Remove ${scope.label}`}
+                onClick={(): void => onRemoveScope(scope.id)}
+              >
+                <TimesIcon />
+              </button>
+            </span>
+          ))}
+        </div>
+      )}
+      {!hideSelector && (
+        <div className="legend-ai__scope-selector" ref={dropdownRef}>
+          <button
+            ref={btnRef}
+            type="button"
+            className="legend-ai__scope-btn"
+            title="Add scope"
+            aria-label="Add scope"
+            aria-haspopup="true"
+            aria-expanded={dropdownOpen}
+            onClick={(): void => {
+              if (dropdownOpen) {
+                closeDropdown();
+              } else {
+                setDropdownOpen(true);
+                setSearchText('');
+              }
+            }}
+          >
+            <PlusCircleIcon />
+          </button>
+          {dropdownOpen && (
+            <div
+              className="legend-ai__scope-dropdown"
+              aria-multiselectable="true"
+            >
+              <div className="legend-ai__scope-dropdown-search">
+                <SearchIcon />
+                <input
+                  ref={searchRef}
+                  type="text"
+                  className="legend-ai__scope-dropdown-search-input"
+                  placeholder="Search scopes..."
+                  value={searchText}
+                  onChange={(e): void => setSearchText(e.target.value)}
+                  onKeyDown={(e): void => {
+                    if (e.key === 'Escape') {
+                      e.stopPropagation();
+                      closeDropdown();
+                    }
+                  }}
+                />
+              </div>
+              <div className="legend-ai__scope-dropdown-list">
+                {filteredScopes.length === 0 ? (
+                  <div className="legend-ai__scope-dropdown-empty">
+                    No matching scopes
+                  </div>
+                ) : (
+                  filteredScopes.map((scope) => {
+                    const isSelected = selectedScopes.some(
+                      (s) => s.id === scope.id,
+                    );
+                    return (
+                      <button
+                        key={scope.id}
+                        type="button"
+                        aria-pressed={isSelected}
+                        className={`legend-ai__scope-dropdown-item${isSelected ? 'legend-ai__scope-dropdown-item--selected' : ''}`}
+                        onClick={(): void => {
+                          onToggleScope(scope);
+                          setDropdownOpen(false);
+                          setSearchText('');
+                        }}
+                      >
+                        <span className="legend-ai__scope-dropdown-item-check">
+                          {isSelected && <CheckIcon />}
+                        </span>
+                        <span className="legend-ai__scope-dropdown-item-label">
+                          {scope.label}
+                        </span>
+                      </button>
+                    );
+                  })
+                )}
+              </div>
+            </div>
+          )}
+        </div>
+      )}
+    </>
+  );
+};

package/src/legend-ai/index.ts

@@ -19,15 +19,19 @@ export * from './LegendAI_LegendApplicationPlugin_Extension.js';
 export {
   LegendAIChat,
   LEGEND_AI_ANCHOR_ID,
+  renderStepStatusIcon,
+} from './components/LegendAIChat.js';
+export {
   isStringColumn,
   isNumericColumn,
   isDateColumn,
   buildSuggestedQueries,
-  renderStepStatusIcon,
-} from './components/LegendAIChat.js';
+} from './components/LegendAIChatHelpers.js';
+export { LegendAIScopeSelector } from './components/LegendAIScopeSelector.js';
+export { LegendAIChatInput } from './components/LegendAIChatInput.js';
 export { LegendAIErrorBoundary } from './components/LegendAIErrorBoundary.js';
+export { useLegendAIChatState } from './stores/LegendAIChatState.js';
 export {
-  useLegendAIChatState,
   updateLastAssistant,
   addThinkingStep,
   completeThinkingSteps,
@@ -37,18 +41,32 @@ export {
   buildGenerationFailureMessage,
   buildExecutionErrorMessage,
   generateAndJudgeSql,
+  generateAndJudgeAccessPointSql,
   executeSqlAndReport,
   executePureQueryAndReport,
   processQuestionViaOrchestrator,
   processQuestion,
   processQuestionWithIntent,
   handleMetadataQuestion,
+  buildMetadataOverview,
+  attachMetadataOverview,
   elapsedSeconds,
   createMessagePair,
   analyzeOrchestratorResults,
+  cleanLlmSqlResponse,
+  isValidSqlCorrection,
+  sanitizeJoinOrderBy,
+  sanitizeLiteralColumns,
+  stripGuessedNonDateServiceParams,
+  ensureDateParameters,
+  detectMissingServiceParams,
+  buildMissingParamsWarning,
+  ensureSafeLimit,
+  preFilterServicesByRelevance,
   type MessageSetter,
   type LegendAIOperationContext,
-} from './stores/LegendAIChatState.js';
+  type MissingParamInfo,
+} from './stores/LegendAIChatProcessors.js';
 export { LegendAIResultGrid } from './components/LegendAIResultGrid.js';
 export { LegendAIAnalysisPanel } from './components/LegendAIAnalysisPanel.js';
 export {
@@ -56,9 +74,18 @@ export {
   LegendAIDonutChart,
 } from './components/LegendAICharts.js';
 export {
+  type LegendAIGridAnalysis,
   computeKeyMetrics,
   computeChartData,
   inferChartType,
   computeTopItems,
   findNumericColumnName,
+  analyzeGridData,
 } from './components/LegendAIAnalysisUtils.js';
+export {
+  buildPropertyDocIndex,
+  enrichColumnsFromElementDocs,
+  inferServiceRelationshipsFromAssociations,
+  extractLambdaPreFilters,
+  formatPreFiltersForContext,
+} from './LegendAIDocEnrichment.js';