Yicong-Huang commented on code in PR #6437: URL: https://github.com/apache/texera/pull/6437#discussion_r3900062289
########## frontend/src/app/workspace/service/operator-recommendation/operator-recommendation.service.ts: ########## @@ -0,0 +1,166 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 { Injectable } from "@angular/core"; +import { HttpClient } from "@angular/common/http"; +import { Observable, catchError, map, of } from "rxjs"; +import { OperatorLink, OperatorPredicate, Point } from "../../types/workflow-common.interface"; +import { WorkflowActionService } from "../workflow-graph/model/workflow-action.service"; +import { WorkflowUtilService } from "../workflow-graph/util/workflow-util.service"; +import { JointUIService } from "../joint-ui/joint-ui.service"; +import { GuiConfigService } from "../../../common/service/gui-config.service"; + +/** + * A single operator suggestion returned by the agent-service `/api/recommend` + * endpoint (apache/texera#5240). Mirrors the backend `OperatorRecommendation`. + */ +export interface OperatorRecommendation { + /** Recommended operator type (validated against the live catalog when available). */ + operatorType: string; + /** Confidence in `[0, 1]`, monotonically non-increasing down the list. */ + score: number; + /** Short, human-readable rationale shown alongside the suggested operator. */ + reason: string; + /** Display name from operator metadata, when available. */ + userFriendlyName?: string; +} + +interface RecommendationResponse { + recommendations: OperatorRecommendation[]; + strategy: "hardcoded" | "llm"; +} + +/** + * Client for the ambient operator recommender. Asks the stateless agent-service + * endpoint what operators are likely to follow the one just added, and turns a + * chosen suggestion into a real operator wired onto the source's output port. + * + * The service never fails loudly: the recommender is a non-essential, ambient + * aid, so a backend error or a disabled feature simply yields no suggestions + * and the canvas behaves exactly as before. + */ +@Injectable({ + providedIn: "root", +}) +export class OperatorRecommendationService { + private static readonly RECOMMEND_API_URL = "/api/recommend"; + + // Horizontal gap between the source operator and a materialized suggestion. + private static readonly MATERIALIZE_GAP_X = 100; + + constructor( + private http: HttpClient, + private config: GuiConfigService, + private workflowActionService: WorkflowActionService, + private workflowUtilService: WorkflowUtilService + ) {} + + /** Whether the opt-in recommender feature is turned on for this deployment. */ + public isEnabled(): boolean { + return this.config.env.operatorRecommendationEnabled === true; + } + + /** + * Fetch ranked next-operator suggestions for the operator just added. + * + * Returns an empty list (never errors) when the feature is disabled, the + * operator has no output port to suggest from, or the backend call fails. + * + * How many suggestions come back is the backend's call: it defaults to three and + * clamps any larger requested limit, so there is nothing useful to send from here. + * + * @param operator the operator that was just added to the canvas + */ + public getRecommendations(operator: OperatorPredicate): Observable<OperatorRecommendation[]> { + // An operator with no output ports (e.g. a chart sink) has no port to anchor + // suggestions on, so we skip the backend call. Review Comment: The sentence and the guard are right, but the example names a shape no operator has. `OperatorInfo.forVisualization` hardcodes `outputPorts = List(OutputPort(mode = OutputMode.SINGLE_SNAPSHOT))` (`OperatorMetadataGenerator.scala:50-61`), which `BarChartOpDesc` calls — so a chart has an output port, and dropping one *does* produce chips. The catalog has no zero-output operator outside test stubs, so there is nothing to substitute: dropping the parenthetical is the fix. This is my own round-1 wording, so the miss is mine. ```suggestion // An operator with no output ports has no port to anchor suggestions on, // so we skip the backend call. ``` ########## frontend/src/app/workspace/component/workflow-editor/workflow-editor.component.ts: ########## @@ -1717,6 +1769,224 @@ export class WorkflowEditorComponent implements OnInit, AfterViewInit, OnDestroy return this.operatorSummaries.get(operatorId)?.sampleRecords?.[0]?.["__is_visualization__"] === true; } + /** + * Ambient operator recommender (apache/texera#5240). When the user drops an + * operator onto the canvas, ask the recommender for likely next operators and + * float them as suggestion chips on the operator's output port; clicking one + * materializes it. The whole feature is opt-in and self-effacing: if it is + * disabled or the backend returns nothing, the canvas is untouched. + */ + private handleNextOperatorSuggestions(): void { + if (!this.operatorRecommendationService.isEnabled()) { + return; + } + + // Repositioning is throttled: change:position fires once per drag frame. + this.repositionNextOperatorSuggestion$ + .pipe(auditTime(100), untilDestroyed(this)) + .subscribe(() => this.repositionNextOperatorSuggestions()); + + // Every suggestion request — from a drop or from chaining after a click — + // goes through this one pipeline. switchMap unsubscribes the previous + // request, so a slow response can neither overwrite newer suggestions nor + // re-open the overlay after the user dismissed it; `null` means "cancel". + this.nextOperatorSuggestionRequest$ + .pipe( + switchMap(operator => + operator === null + ? of(null) + : this.operatorRecommendationService + .getRecommendations(operator) + .pipe(map(recommendations => ({ operator, recommendations }))) + ), + untilDestroyed(this) + ) + .subscribe(result => this.showNextOperatorSuggestions(result)); + + // Trigger: the user interactively dropped an operator onto the canvas. + // Deliberately not the graph's operator-add stream, which also fires on + // workflow load, undo/redo, paste, and remote co-editor edits — none of + // which are a user authoring a next step. + this.dragDropService.operatorDropStream + .pipe(untilDestroyed(this)) + .subscribe(operator => this.requestNextOperatorSuggestionsFor(operator)); + + // Dismiss when the user clicks on blank canvas. + fromJointPaperEvent(this.paper, "blank:pointerdown") + .pipe(untilDestroyed(this)) + .subscribe(() => this.closeNextOperatorSuggestions()); + + // Dismiss when the canvas is frozen — during execution, version preview, or a + // read-only view. Materializing writes to the shared model, and undo refuses + // while the lock is on, so a click here could not be undone; the chips must + // not stay on screen looking clickable either. + this.workflowActionService + .getWorkflowModificationEnabledStream() + .pipe(untilDestroyed(this)) + .subscribe(enabled => { + if (!enabled) { + this.closeNextOperatorSuggestions(); + } + }); + + // Dismiss if the anchor operator is deleted out from under the suggestions. + this.workflowActionService + .getTexeraGraph() + .getOperatorDeleteStream() + .pipe(untilDestroyed(this)) + .subscribe(({ deletedOperatorID }) => { + if (this.nextOperatorSuggestion?.operatorId === deletedOperatorID) { + this.closeNextOperatorSuggestions(); + } + }); + + // Keep the suggestions anchored to the operator's output port as it moves. + fromJointGraphCellEvent(this.paper.model, "change:position") + .pipe(untilDestroyed(this)) + .subscribe(cell => { + if (this.nextOperatorSuggestion && cell.id.toString() === this.nextOperatorSuggestion.operatorId) { + this.repositionNextOperatorSuggestion$.next(); + } + }); + + // Keep the suggestions anchored on zoom. + this.wrapper + .getWorkflowEditorZoomStream() + .pipe(untilDestroyed(this)) + .subscribe(() => { + if (this.nextOperatorSuggestion) { + this.repositionNextOperatorSuggestions(); + } + }); + } + + /** Ask for suggestions on `operator`, cancelling whatever was in flight. */ + private requestNextOperatorSuggestionsFor(operator: OperatorPredicate): void { + this.closeNextOperatorSuggestions(); + // An operator with no output ports (e.g. a chart sink) has no port to + // anchor suggestions on, so there is nothing to ask for. Review Comment: Same sentence as the one on `operator-recommendation.service.ts:91`, same fix — one finding, two places. ```suggestion // An operator with no output ports has no port to anchor suggestions on, // so there is nothing to ask for. ``` -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected]
