Function useFormulateData

src/app/useFormulateData.ts:79–606

()

 * Used by both EncodingShelfCard (chart-aware formulation) and ChartRecBox (NL-driven formulation).
 */
export function useFormulateData() {
    const dispatch = useDispatch<AppDispatch>();
    const { t } = useTranslation();
    const tables = useSelector((state: DataFormulatorState) => state.tables);
    const config = useSelector((state: DataFormulatorState) => state.config);
    const conceptShelfItems = useSelector((state: DataFormulatorState) => state.conceptShelfItems);
    const charts = useSelector(dfSelectors.getAllCharts);
    const activeModel = useSelector(dfSelectors.getActiveModel);

    /**
     * Resolve the actual chart that's rendered for a derived table. The
     * `trigger.chart` saved on the table is just an "Auto" stub generated
     * during the agent run — the chart the user actually sees lives in the
     * Redux `charts` slice. Mirrors the lookup in `SimpleChartRecBox`.
     */
    function resolveChartForTable(tableId: string) {
        return charts.find(c => c.tableRef === tableId && c.source === 'trigger')
            || charts.find(c => c.tableRef === tableId);
    }

    /** Map a chart's encodingMap to `{ channel: fieldName }` (skips empties). */
    function chartEncodingsByName(chart: Chart | undefined): Record<string, string> {
        if (!chart?.encodingMap) return {};
        return Object.fromEntries(
            Object.entries(chart.encodingMap)
                .filter(([, v]: [string, any]) => v?.fieldID)
                .map(([k, v]: [string, any]) => {
                    const field = conceptShelfItems.find(f => f.id === v.fieldID);
                    return [k, field?.name || v.fieldID];
                })
        );
    }

    /**
     * Build a rich focused thread from the current table's derivation chain.
     * Each step includes: user question, display instruction, chart type + encodings,
     * created table metadata, and agent summary.
     */
    function buildFocusedThread(currentTable: DictTable): any[] {
        if (!currentTable.derive || currentTable.anchored) return [];
        const triggers = getTriggers(currentTable, tables);
        return triggers.map(trigger => {
            const resultTable = tables.find(t2 => t2.id === trigger.resultTableId);
            const interaction = trigger.interaction || [];
            const userPrompt = interaction.find(e => e.role === 'prompt')?.content;
            const instruction = interaction.find(e => e.role === 'instruction');
            const summary = interaction.find(e => e.role === 'summary');
            // Resolve the actual rendered chart (not the trigger's "Auto" stub)
            // so chart_type + encodings reflect what the user is looking at.
            const resolvedChart = resolveChartForTable(trigger.resultTableId);
            return {
                user_question: userPrompt || instruction?.content || '',
                display_instruction: instruction?.displayContent || instruction?.content || '',
                agent_thinking: instruction?.plan,
                agent_summary: summary?.content,
                table_name: resultTable?.virtual?.tableId || trigger.resultTableId,
                columns: resultTable?.names || [],
                row_count: resultTable?.virtual?.rowCount ?? resultTable?.rows?.length ?? 0,