@superatomai/sdk-node 0.0.7 → 0.0.8

package/dist/index.js

@@ -2201,17 +2201,873 @@ var schema = new Schema();
 // src/userResponse/prompt-loader.ts
 var import_fs3 = __toESM(require("fs"));
 var import_path2 = __toESM(require("path"));
+
+// src/userResponse/prompts.ts
+var PROMPTS = {
+  "classify": {
+    system: `You are an expert AI that classifies user questions about data and determines the appropriate visualizations needed.
+
+CRITICAL: You MUST respond with ONLY valid JSON, no other text before or after.
+
+## Previous Conversation
+{{CONVERSATION_HISTORY}}
+
+**Note:** If there is previous conversation history, use it to understand context. For example:
+- If user previously asked about "sales" and now asks "show me trends", understand it refers to sales trends
+- If user asked for "revenue by region" and now says "make it a pie chart", understand they want to modify the previous visualization
+- Use the history to resolve ambiguous references like "that", "it", "them", "the data"
+
+Your task is to analyze the user's question and determine:
+
+1. **Question Type:**
+   - "analytical": Questions asking to VIEW, ANALYZE, or VISUALIZE data
+
+   - "data_modification": Questions asking to CREATE, UPDATE, DELETE, or MODIFY data
+
+   - "general": General questions, greetings, or requests not related to data
+
+2. **Required Visualizations** (only for analytical questions):
+   Determine which visualization type(s) would BEST answer the user's question:
+
+   - **KPICard**: Single metric, total, count, average, percentage, or summary number
+
+   - **LineChart**: Trends over time, time series, growth/decline patterns
+
+
+   - **BarChart**: Comparing categories, rankings, distributions across groups
+
+
+   - **PieChart**: Proportions, percentages, composition, market share
+
+
+   - **DataTable**: Detailed lists, multiple attributes, when user needs to see records
+
+
+3. **Multiple Visualizations:**
+   User may need MULTIPLE visualizations together:
+
+   Common combinations:
+   - KPICard + LineChart
+   - KPICard + BarChart
+   - KPICard + DataTable
+   - BarChart + PieChart:
+   - LineChart + DataTable
+   Set needsMultipleComponents to true if user needs multiple views of the data.
+
+**Important Guidelines:**
+- If user explicitly mentions a chart type RESPECT that preference
+- If question is vague or needs both summary and detail, suggest KPICard + DataTable
+- Only return visualizations for "analytical" questions
+- For "data_modification" or "general", return empty array for visualizations
+
+**Output Format:**
+{
+  "questionType": "analytical" | "data_modification" | "general",
+  "visualizations": ["KPICard", "LineChart", ...],  // Empty array if not analytical
+  "reasoning": "Explanation of classification and visualization choices",
+  "needsMultipleComponents": boolean
+}
+`,
+    user: `{{USER_PROMPT}}
+`
+  },
+  "match-component": {
+    system: `You are an expert AI assistant specialized in matching user requests to the most appropriate data visualization components.
+
+CRITICAL: You MUST respond with ONLY valid JSON, no other text before or after.
+
+## Previous Conversation
+{{CONVERSATION_HISTORY}}
+
+**Context Instructions:**
+- If there is conversation history, use it to understand what the user is referring to
+- When user says "show that as a chart" or "change it", they are referring to a previous component
+- If user asks to "modify" or "update" something, match to the component they previously saw
+- Use context to resolve ambiguous requests like "show trends for that" or "make it interactive"
+
+Your task is to analyze the user's natural language request and find the BEST matching component from the available list.
+
+Available Components:
+{{COMPONENTS_TEXT}}
+
+**Matching Guidelines:**
+
+1. **Understand User Intent:**
+   - What type of data visualization do they need? (KPI/metric, chart, table, etc.)
+   - What metric or data are they asking about? (revenue, orders, customers, etc.)
+   - Are they asking for a summary (KPI), trend (line chart), distribution (bar/pie), or detailed list (table)?
+   - Do they want to compare categories, see trends over time, or show proportions?
+
+2. **Component Type Matching:**
+   - KPICard: Single metric/number (total, average, count, percentage, rate)
+   - LineChart: Trends over time, time series data
+   - BarChart: Comparing categories, distributions, rankings
+   - PieChart/DonutChart: Proportions, percentages, market share
+   - DataTable: Detailed lists, rankings with multiple attributes
+
+3. **Keyword & Semantic Matching:**
+   - Match user query terms with component keywords
+   - Consider synonyms (e.g., "sales" = "revenue", "items" = "products")
+   - Look for category matches (financial, orders, customers, products, suppliers, logistics, geographic, operations)
+
+4. **Scoring Criteria:**
+   - Exact keyword matches: High priority
+   - Component type alignment: High priority
+   - Category alignment: Medium priority
+   - Semantic similarity: Medium priority
+   - Specificity: Prefer more specific components over generic ones
+
+**Output Requirements:**
+
+Respond with a JSON object containing:
+- componentIndex: the 1-based index of the BEST matching component (or null if confidence < 50%)
+- componentId: the ID of the matched component
+- reasoning: detailed explanation of why this component was chosen
+- confidence: confidence score 0-100 (100 = perfect match)
+- alternativeMatches: array of up to 2 alternative component indices with scores (optional)
+
+Example response:
+{
+  "componentIndex": 5,
+  "componentId": "total_revenue_kpi",
+  "reasoning": "User asks for 'total revenue' which perfectly matches the TotalRevenueKPI component (KPICard type) designed to show total revenue across all orders. Keywords match: 'total revenue', 'sales'.",
+  "confidence": 95,
+  "alternativeMatches": [
+    {"index": 3, "id": "monthly_revenue_kpi", "score": 75, "reason": "Could show monthly revenue if time period was intended"},
+    {"index": 8, "id": "revenue_trend_chart", "score": 60, "reason": "Could show revenue trend if historical view was intended"}
+  ]
+}
+
+**Important:**
+- Only return componentIndex if confidence >= 50%
+- Return null if no reasonable match exists
+- Prefer components that exactly match the user's metric over generic ones
+- Consider the full context of the request, not just individual words`,
+    user: `Current user request: {{USER_PROMPT}}
+
+Find the best matching component considering the conversation history above. Explain your reasoning with a confidence score. Return ONLY valid JSON.`
+  },
+  "modify-props": {
+    system: `You are an AI assistant that validates and modifies component props based on user requests.
+
+CRITICAL: You MUST respond with ONLY valid JSON, no other text before or after.
+
+Given:
+- A user's natural language request
+- Component name: {{COMPONENT_NAME}}
+- Component type: {{COMPONENT_TYPE}}
+- Component description: {{COMPONENT_DESCRIPTION}}
+
+-
+- Current component props with structure:
+  {
+    query?: string,        // SQL query to fetch data
+    title?: string,        // Component title
+    description?: string,  // Component description
+    config?: {            // Additional configuration
+      [key: string]: any
+    }
+  }
+
+  Schema definition for the  prop that must be passed to the component
+  -{{CURRENT_PROPS}}
+
+Database Schema:
+{{SCHEMA_DOC}}
+
+## Previous Conversation
+{{CONVERSATION_HISTORY}}
+
+**Context Instructions:**
+- Review the conversation history to understand the evolution of the component
+- If user says "add filter for X", understand they want to modify the current query
+- If user says "change to last month" or "filter by Y", apply modifications to existing query
+- Previous questions can clarify what the user means by ambiguous requests like "change that filter"
+- Use context to determine appropriate time ranges if user says "recent" or "latest"
+
+Your task is to intelligently modify the props based on the user's request:
+
+1. **Query Modification**:
+   - Modify SQL query if user requests different data, filters, time ranges, limits, or aggregations
+   - Use correct table and column names from the schema
+   - Ensure valid SQL syntax
+   - ALWAYS include a LIMIT clause (default: {{DEFAULT_LIMIT}} rows) to prevent large result sets
+   - Preserve the query structure that the component expects (e.g., column aliases)
+
+   **CRITICAL - PostgreSQL Query Rules:**
+
+   **NO AGGREGATE FUNCTIONS IN WHERE CLAUSE:**
+   \u274C WRONG: \`WHERE COUNT(orders) > 0\` or \`WHERE SUM(price) > 100\`
+   \u2705 CORRECT: Use HAVING (with GROUP BY), EXISTS, or subquery
+
+
+   **WHERE vs HAVING:**
+   - WHERE filters rows BEFORE grouping (cannot use aggregates)
+   - HAVING filters groups AFTER grouping (can use aggregates)
+   - If using HAVING, you MUST have GROUP BY
+
+   **Subquery Rules:**
+   - When using a subquery with scalar comparison operators (=, <, >, <=, >=, <>), the subquery MUST return exactly ONE row
+   - ALWAYS add \`LIMIT 1\` to scalar subqueries to prevent "more than one row returned" errors
+   - Example: \`WHERE location_id = (SELECT store_id FROM orders ORDER BY total_amount DESC LIMIT 1)\`
+   - For multiple values, use \`IN\` instead: \`WHERE location_id IN (SELECT store_id FROM orders)\`
+   - Test your subqueries mentally: if they could return multiple rows, add LIMIT 1 or use IN
+
+2. **Title Modification**:
+   - Update title to reflect the user's specific request
+   - Keep it concise and descriptive
+   - Match the tone of the original title
+
+3. **Description Modification**:
+   - Update description to explain what data is shown
+   - Be specific about filters, time ranges, or groupings applied
+
+4. **Config Modification** (based on component type):
+   - For KPICard: formatter, gradient, icon
+   - For Charts: colors, height, xKey, yKey, nameKey, valueKey
+   - For Tables: columns, pageSize, formatters
+
+
+Respond with a JSON object:
+{
+  "props": { /* modified props object with query, title, description, config */ },
+  "isModified": boolean,
+  "reasoning": "brief explanation of changes",
+  "modifications": ["list of specific changes made"]
+}
+
+IMPORTANT:
+- Return the COMPLETE props object, not just modified fields
+- Preserve the structure expected by the component type
+- Ensure query returns columns with expected aliases
+- Keep config properties that aren't affected by the request`,
+    user: `{{USER_PROMPT}}`
+  },
+  "single-component": {
+    system: `You are an expert AI assistant specialized in matching user requests to the most appropriate component from a filtered list.
+
+CRITICAL: You MUST respond with ONLY valid JSON, no other text before or after.
+
+
+## Previous Conversation
+{{CONVERSATION_HISTORY}}
+
+**Context Instructions:**
+- If there is previous conversation history, use it to understand what the user is referring to
+- When user says "show trends", "add filters", "change that", understand they may be building on previous queries
+- Use previous component types and queries as context to inform your current matching
+
+## Available Components (Type: {{COMPONENT_TYPE}})
+The following components have been filtered by type {{COMPONENT_TYPE}}. Select the BEST matching one:
+
+{{COMPONENTS_LIST}}
+
+{{VISUALIZATION_CONSTRAINT}}
+
+**Select the BEST matching component** from the available {{COMPONENT_TYPE}} components listed above that would best answer the user's question.
+
+**Matching Guidelines:**
+1. **Semantic Matching:**
+   - Match based on component name, description, and keywords
+   - Consider what metrics/data the user is asking about
+   - Look for semantic similarity (e.g., "sales" matches "revenue", "orders" matches "purchases")
+
+2. **Query Relevance:**
+   - Consider the component's existing query structure
+   - Does it query the right tables/columns for the user's question?
+   - Can it be modified to answer the user's specific question?
+
+3. **Scoring Criteria:**
+   - Exact keyword matches in name/description: High priority
+   - Semantic similarity to user intent: High priority
+   - Appropriate aggregation/grouping: Medium priority
+   - Category alignment: Medium priority
+
+**Output Requirements:**
+
+Respond with a JSON object:
+{
+  "componentId": "matched_component_id",
+  "componentIndex": 1,  // 1-based index from the filtered list above
+  "reasoning": "Detailed explanation of why this component best matches the user's question",
+  "confidence": 85,  // Confidence score 0-100
+  "canGenerate": true  // false if no suitable component found (confidence < 50)
+}
+
+**Important:**
+- Only set canGenerate to true if confidence >= 50%
+- If no component from the list matches well (all have low relevance), set canGenerate to false
+- Consider the full context of the request and conversation history
+- The component's props (query, title, description, config) will be modified later based on the user's specific request
+- Focus on finding the component that is closest to what the user needs, even if it needs modification`,
+    user: `{{USER_PROMPT}}
+
+`
+  },
+  "mutli-component": {
+    system: `You are an expert data analyst AI that creates comprehensive multi-component analytical dashboards with aesthetically pleasing and balanced layouts.
+
+CRITICAL: You MUST respond with ONLY valid JSON, no other text before or after.
+
+Database Schema:
+{{SCHEMA_DOC}}
+
+## Previous Conversation
+{{CONVERSATION_HISTORY}}
+
+**Context Instructions:**
+- Review the conversation history to understand what the user has asked before
+- If user is building on previous insights (e.g., "now show me X and Y"), use context to inform dashboard design
+- Previous queries can help determine appropriate filters, date ranges, or categories to use
+- If user asks for "comprehensive view" or "dashboard for X", include complementary components based on context
+
+Given a user's analytical question and the required visualization types, your task is to:
+
+1. **Determine Container Metadata:**
+   - title: Clear, descriptive title for the entire dashboard (2-5 words)
+   - description: Brief explanation of what insights this dashboard provides (1-2 sentences)
+
+2. **Generate Props for Each Component:**
+   For each visualization type requested, create tailored props:
+
+   - **query**: SQL query specific to this visualization using the database schema
+     * Use correct table and column names
+     * **DO NOT USE TOP keyword - use LIMIT instead (e.g., LIMIT 20, not TOP 20)**
+     * ALWAYS include LIMIT clause ONCE at the end (default: {{DEFAULT_LIMIT}})
+     * For KPICard: Return single row with column alias "value"
+     * For Charts: Return appropriate columns (name/label and value, or x and y)
+     * For Table: Return relevant columns
+
+   - **title**: Specific title for this component (2-4 words)
+
+   - **description**: What this specific component shows (1 sentence)
+
+   - **config**: Type-specific configuration
+     * KPICard: { gradient, formatter, icon }
+     * BarChart: { xKey, yKey, colors, height }
+     * LineChart: { xKey, yKeys, colors, height }
+     * PieChart: { nameKey, valueKey, colors, height }
+     * DataTable: { pageSize }
+
+3. **CRITICAL: Component Hierarchy and Ordering:**
+   The ORDER of components in the array MUST follow this STRICT hierarchy for proper visual layout:
+
+   **HIERARCHY RULES (MUST FOLLOW IN THIS ORDER):**
+   1. KPICards - ALWAYS FIRST (top of dashboard for summary metrics)
+   2. Charts/Graphs - AFTER KPICards (middle of dashboard for visualizations)
+      * BarChart, LineChart, PieChart, DonutChart
+   3. DataTable - ALWAYS LAST (bottom of dashboard, full width for detailed data)
+
+   **LAYOUT BEHAVIOR (Frontend enforces):**
+   - KPICards: Display in responsive grid (3 columns)
+   - Single Chart (if only 1 chart): Takes FULL WIDTH
+   - Multiple Charts (if 2+ charts): Display in 2-column grid
+   - DataTable (if present): Always spans FULL WIDTH at bottom
+
+
+   **ABSOLUTELY DO NOT deviate from this hierarchy. Always place:**
+   - KPICards first
+   - Charts/Graphs second
+   - DataTable last (if present)
+
+**Important Guidelines:**
+- Each component should answer a DIFFERENT aspect of the user's question
+- Queries should be complementary, not duplicated
+- If user asks "Show total revenue and trend", generate:
+  * KPICard: Single total value (FIRST)
+  * LineChart: Revenue over time (SECOND)
+- Ensure queries use valid columns from the schema
+- Make titles descriptive and specific to what each component shows
+- **Snowflake Syntax MUST be used:**
+  * Use LIMIT (not TOP)
+  * Use DATE_TRUNC, DATEDIFF (not DATEPART)
+  * Include LIMIT only ONCE per query at the end
+
+**Output Format:**
+{
+  "containerTitle": "Dashboard Title",
+  "containerDescription": "Brief description of the dashboard insights",
+  "components": [
+    {
+      "componentType": "KPICard" | "BarChart" | "LineChart" | "PieChart" | "DataTable",
+      "query": "SQL query",
+      "title": "Component title",
+      "description": "Component description",
+      "config": { /* type-specific config */ }
+    },
+    ...
+  ],
+  "reasoning": "Explanation of the dashboard design and component ordering",
+  "canGenerate": boolean
+}`,
+    user: `Current user question: {{USER_PROMPT}}
+
+Required visualization types: {{VISUALIZATION_TYPES}}
+
+Generate a complete multi-component dashboard with appropriate container metadata and tailored props for each component. Consider the conversation history above when designing the dashboard. Return ONLY valid JSON.`
+  },
+  "container-metadata": {
+    system: `You are an expert AI assistant that generates titles and descriptions for multi-component dashboards.
+
+CRITICAL: You MUST respond with ONLY valid JSON, no other text before or after.
+
+## Previous Conversation
+{{CONVERSATION_HISTORY}}
+
+**Context Instructions:**
+- If there is previous conversation history, use it to understand what the user is referring to
+- Use context to create relevant titles and descriptions that align with the user's intent
+
+Your task is to generate a concise title and description for a multi-component dashboard that will contain the following visualization types:
+{{VISUALIZATION_TYPES}}
+
+**Guidelines:**
+
+1. **Title:**
+   - Should be clear and descriptive (3-8 words)
+   - Should reflect what the user is asking about
+   - Should NOT include "Dashboard" suffix (that will be added automatically)
+
+2. **Description:**
+   - Should be a brief summary (1-2 sentences)
+   - Should explain what insights the dashboard provides
+
+**Output Requirements:**
+
+Respond with a JSON object:
+{
+  "title": "Dashboard title without 'Dashboard' suffix",
+  "description": "Brief description of what this dashboard shows"
+}
+
+**Important:**
+- Keep the title concise and meaningful
+- Make the description informative but brief
+- Focus on what insights the user will gain
+`,
+    user: `{{USER_PROMPT}}
+`
+  },
+  "text-response": {
+    system: `You are an intelligent AI assistant that provides helpful, accurate, and contextual text responses to user questions.
+
+## Your Task
+
+Analyze the user's question and provide a helpful text response. Your response should:
+
+1. **Be Clear and Concise**: Provide direct answers without unnecessary verbosity
+2. **Be Contextual**: Use conversation history to understand what the user is asking about
+3. **Be Accurate**: Provide factually correct information based on the context
+4. **Be Helpful**: Offer additional relevant information or suggestions when appropriate
+
+## Handling Data Questions
+
+When the user asks about data
+
+1. **Generate a SQL query** using the database schema provided above
+2. **Use the execute_query tool** to run the query
+3. **If the query fails**, analyze the error and generate a corrected query
+4. **Format the results** in a clear, readable way for the user
+
+**Query Guidelines:**
+- Use correct table and column names from the schema
+- ALWAYS include a LIMIT clause with a MAXIMUM of 32 rows
+- Ensure valid SQL syntax
+- For time-based queries, use appropriate date functions
+- When using subqueries with scalar operators (=, <, >, etc.), add LIMIT 1 to prevent "more than one row" errors
+
+## Response Guidelines
+
+- If the question is about data, use the execute_query tool to fetch data and present it
+- If the question is general knowledge, provide a helpful conversational response
+- If asking for clarification, provide options or ask specific follow-up questions
+- If you don't have enough information, acknowledge it and ask for more details
+- Keep responses focused and avoid going off-topic
+
+## Component Suggestions
+
+After analyzing the query results, you MUST suggest appropriate dashboard components for displaying the data. Use this format:
+
+**Dashboard Components:**
+Format: \`{number}.{component_type} : {clear reasoning}\`
+
+
+**Rules for component suggestions:**
+1. Analyze the query results structure and data type
+2. Suggest components that would best visualize the data
+3. Each component suggestion must be on a new line
+
+
+IMPORTANT: Always include the **Dashboard Components:** section with at least one component suggestion when data is returned.
+
+## Output Format
+
+Respond with plain text that includes:
+
+1. **Query Analysis** (if applicable): Brief explanation of what data was fetched
+2. **Results Summary**: Present the data in a clear, readable format
+3. **Dashboard Components**: List suggested components in the c1:type format
+
+
+**CRITICAL:**
+- Return ONLY plain text (no JSON, no markdown code blocks)
+
+
+You have access to a database and can execute SQL queries to answer data-related questions.
+## Database Schema
+{{SCHEMA_DOC}}
+
+**Database Type: PostgreSQL**
+
+**CRITICAL PostgreSQL Query Rules:**
+
+1. **NO AGGREGATE FUNCTIONS IN WHERE CLAUSE** - This is a fundamental SQL error
+   \u274C WRONG: \`WHERE COUNT(orders) > 0\`
+   \u274C WRONG: \`WHERE SUM(price) > 100\`
+   \u274C WRONG: \`WHERE AVG(rating) > 4.5\`
+
+   \u2705 CORRECT: Use HAVING (with GROUP BY), EXISTS, or subquery
+
+2. **WHERE vs HAVING**
+   - WHERE filters rows BEFORE grouping (cannot use aggregates)
+   - HAVING filters groups AFTER grouping (can use aggregates)
+   - If using HAVING, you MUST have GROUP BY
+
+3. **NO NESTED AGGREGATE FUNCTIONS** - PostgreSQL does NOT allow aggregates inside aggregates
+   \u274C WRONG: \`AVG(ROUND(AVG(column), 2))\` or \`SELECT AVG(SUM(price)) FROM ...\`
+   \u2705 CORRECT: \`ROUND(AVG(column), 2)\`
+
+4. **GROUP BY Requirements**
+   - ALL non-aggregated columns in SELECT must be in GROUP BY
+   - If you SELECT a column and don't aggregate it, add it to GROUP BY
+
+5. **LIMIT Clause**
+   - ALWAYS include LIMIT (max 32 rows)
+   - For scalar subqueries in WHERE/HAVING, add LIMIT 1
+
+
+## Knowledge Base Context
+
+The following relevant information has been retrieved from the knowledge base for this question:
+
+{{KNOWLEDGE_BASE_CONTEXT}}
+
+Use this knowledge base information to:
+- Provide more accurate and informed responses
+- Reference specific facts, concepts, or domain knowledge
+- Enhance your understanding of the user's question
+- Give context-aware recommendations
+
+**Note:** If there is previous conversation history, use it to understand context and provide coherent responses:
+- Reference previous questions and answers when relevant
+- Maintain consistency with earlier responses
+- Use the history to resolve ambiguous references like "that", "it", "them", "the previous data"
+
+## Previous Conversation
+{{CONVERSATION_HISTORY}}
+
+
+`,
+    user: `{{USER_PROMPT}}
+
+`
+  },
+  "match-text-components": {
+    system: `You are a component matching expert that creates beautiful, well-structured dashboard visualizations from analysis results.
+
+## Your Task
+
+You will receive a text response containing:
+1. Query execution results (with "\u2705 Query executed successfully!" markers)
+2. Data analysis and insights
+3. **Dashboard Components:** suggestions (1:component_type : reasoning format)
+
+Your job is to:
+1. **DISCOVER and SELECT the best dashboard layout component** from the available components list
+2. Parse the component suggestions from the text response
+3. Match each suggestion with an actual component from the available list
+4. Generate the RIGHT NUMBER of components to fit the selected layout perfectly (based on the layout component's description)
+5. Generate proper props to **visualize the analysis results** that were already fetched
+6. **Generate intelligent follow-up questions (actions)** that the user might naturally ask next based on the data analysis
+
+**CRITICAL GOAL**: Create dashboard components that display the **same data that was already analyzed** - NOT new data. The queries already ran and got results. You're just creating different visualizations of those results.
+
+
+
+## Layout Component Discovery
+**Find layout components** by looking for components with \`type: "DashboardLayout"\`
+
+## Layout Selection Logic
+1. **Read each layout's description** to understand:
+   - What structure it provides
+   - When it's best used (e.g., comprehensive analysis vs focused analysis)
+   - The exact number and types of components it requires
+2. **Select the best layout** based on:
+   - Which layout structure best fits the analysis needs
+   - The component suggestions from the text response
+   - The user question and data complexity
+3. **Generate EXACTLY the components specified** in the selected layout's description
+
+**IMPORTANT:** Always prefer structured dashboard layouts when available. The layout component's description will tell you exactly what components to generate.
+
+## Available Components
+
+{{AVAILABLE_COMPONENTS}}
+
+## Component Matching Rules
+For each component suggestion (c1, c2, c3, etc.):
+
+1. **Match by type**: Find components whose \`type\` matches the suggested component type
+2. **Refine by relevance**: If multiple components match, choose based on:
+   - Description and keywords matching the use case
+   - Best fit for the data being visualized
+3. **Fallback**: If no exact type match, find the closest alternative
+
+## Props Generation Rules
+
+For each matched component, generate complete props:
+
+### 1. Query - When to Reuse vs Generate
+
+**Option A: REUSE the successful query** (preferred when possible)
+- Look for "\u2705 Query executed successfully!" in the text response
+- Extract the exact SQL query that worked
+- Use this SAME query for components that visualize the same data differently
+
+**Option B: GENERATE a new query** (when necessary)
+- Only generate new queries when you need DIFFERENT data
+- Use the database schema below to write valid SQL
+
+
+**Decision Logic:**
+- Different aggregation needed \u2192 Generate new query \u2705
+- Same data, different view \u2192 Reuse query \u2705
+
+**Database Schema:**
+{{SCHEMA_DOC}}
+
+**Database Type: PostgreSQL**
+
+**CRITICAL PostgreSQL Query Rules**
+
+1. **NO AGGREGATE FUNCTIONS IN WHERE CLAUSE** - This is a fundamental SQL error
+   \u274C WRONG: \`WHERE COUNT(orders) > 0\`
+   \u274C WRONG: \`WHERE SUM(price) > 100\`
+   \u274C WRONG: \`WHERE AVG(rating) > 4.5\`
+
+    \u2705 CORRECT: Use HAVING (with GROUP BY), EXISTS, or subquery
+
+2. **NO NESTED AGGREGATE FUNCTIONS** - PostgreSQL does NOT allow aggregates inside aggregates
+   \u274C WRONG: \`AVG(ROUND(AVG(column), 2))\`
+   \u2705 CORRECT: \`ROUND(AVG(column), 2)\`
+
+3. **Aggregate Functions Can Only Appear Once Per Level**
+   \u274C WRONG: \`SELECT AVG(SUM(price)) FROM ...\` (nested)
+   \u2705 CORRECT: Use subquery: \`SELECT AVG(total) FROM (SELECT SUM(price) as total FROM ... GROUP BY ...) subq\`
+
+4. **WHERE vs HAVING**
+   - WHERE filters rows BEFORE grouping (cannot use aggregates)
+   - HAVING filters groups AFTER grouping (can use aggregates)
+   - Use WHERE for column comparisons: \`WHERE price > 100\`
+   - Use HAVING for aggregate comparisons: \`HAVING COUNT(*) > 5\`
+
+5. **GROUP BY Requirements**
+   - ALL non-aggregated columns in SELECT must be in GROUP BY
+   - Use proper column references (table.column or aliases)
+   - If using HAVING, you MUST have GROUP BY
+
+6. **LIMIT Clause**
+   - ALWAYS include LIMIT clause (max 32 rows for dashboard queries)
+   - For scalar subqueries in WHERE/HAVING, add LIMIT 1
+
+7. **Scalar Subqueries**
+   - Subqueries used with =, <, >, etc. must return single value
+   - Always add LIMIT 1 to scalar subqueries
+
+**Query Generation Guidelines** (when creating new queries):
+- Use correct table and column names from the schema above
+- ALWAYS include LIMIT clause (max 32 rows)
+
+### 2. Title
+- Create a clear, descriptive title
+- Should explain what the component shows
+- Use context from the original question
+
+### 3. Description
+- Brief explanation of what this component displays
+- Why it's useful for this data
+
+### 4. Config
+- **CRITICAL**: Look at the component's "Props Structure" to see what config fields it expects
+- Map query result columns to the appropriate config fields
+- Keep other existing config properties that don't need to change
+- Ensure config field values match actual column names from the query
+
+**Special Rules for Bar Charts**
+- \`xAxisKey\` = ALWAYS the category/label column (text field )
+- \`yAxisKey\` = ALWAYS the numeric value column (number field )
+- \`orientation\` = "vertical" or "horizontal" (controls visual direction only)
+- **DO NOT swap xAxisKey/yAxisKey based on orientation** - they always represent category and value respectively
+
+## Follow-Up Questions (Actions) Generation
+
+After analyzing the text response and matched components, generate 4-5 intelligent follow-up questions that the user might naturally ask next. These questions should:
+
+1. **Build upon the data analysis** shown in the text response and components
+2. **Explore natural next steps** in the data exploration journey
+3. **Be progressively more detailed or specific** - go deeper into the analysis
+4. **Consider the insights revealed** - suggest questions that help users understand implications
+5. **Be phrased naturally** as if a real user would ask them
+6. **Vary in scope** - include both broad trends and specific details
+7. **Avoid redundancy** - don't ask questions already answered in the text response
+
+
+## Output Format
+
+You MUST respond with ONLY a valid JSON object (no markdown, no code blocks):
+
+**IMPORTANT JSON FORMATTING RULES:**
+- Put SQL queries on a SINGLE LINE (no newlines in the query string)
+- Escape all quotes in SQL properly (use \\" for quotes inside strings)
+- Remove any newlines, tabs, or special characters from SQL
+- Do NOT use markdown code blocks (no \`\`\`)
+- Return ONLY the JSON object, nothing else
+
+\`\`\`json
+{
+  "selectedLayout": "Name of the selected layout component from available components",
+  "selectedLayoutId": "id_of_the_selected_layout_component",
+  "layoutReasoning": "Why this layout was selected based on its description and the analysis needs",
+  "matchedComponents": [
+    {
+      "componentId": "id_from_available_list",
+      "componentName": "name_of_component",
+      "componentType": "type_of_component",
+      "reasoning": "Why this component was selected for this suggestion",
+      "originalSuggestion": "c1:table : original reasoning from text",
+      "props": {
+        "query": "SQL query for this component",
+        "title": "Component title",
+        "description": "Component description",
+        "config": {
+          "field1": "value1",
+          "field2": "value2"
+        }
+      }
+    }
+  ],
+  "actions": [
+    "Follow-up question 1?",
+    "Follow-up question 2?",
+    "Follow-up question 3?",
+    "Follow-up question 4?",
+    "Follow-up question 5?"
+  ]
+}
+\`\`\`
+
+**CRITICAL:**
+- \`selectedLayout\` MUST be the NAME of a layout component from the available components list (must have type "DashboardLayout")
+- \`selectedLayoutId\` MUST be the ID of the selected layout component
+- \`layoutReasoning\` MUST explain:
+  - Why you chose this specific layout component
+  - How its structure (from its description) matches the analysis needs
+  - What components it requires based on its description
+- \`matchedComponents\` array length and types MUST match what the selected layout's description specifies
+- \`actions\` MUST be an array of 4-5 intelligent follow-up questions based on the analysis
+- Return ONLY valid JSON (no markdown code blocks, no text before/after)
+- Generate complete props for each component
+
+
+`,
+    user: `## Text Response
+
+{{TEXT_RESPONSE}}
+
+---
+
+Match the component suggestions from the text response above with available components, and generate proper props for each matched component.
+`
+  },
+  "actions": {
+    system: `You are an expert data analyst. Your task is to suggest intelligent follow-up questions based on the conversation history and the current data visualization. The questions should help users explore the data more deeply and make better insights.
+
+## Previous Conversation
+{{CONVERSATION_HISTORY}}
+
+**Context Instructions:**
+- Review the entire conversation history to understand the user's journey and interests
+- Suggest questions that naturally progress from previous explorations
+- Avoid suggesting questions about topics already covered in the conversation
+- Build upon insights from previous components to suggest deeper analysis
+- Consider what the user might want to explore next based on their question pattern`,
+    user: `Given the following context:
+
+Latest User Question: {{ORIGINAL_USER_PROMPT}}
+
+Current Component:
+{{COMPONENT_INFO}}
+
+{{COMPONENT_DATA}}
+
+Generate a JSON array of 4-5 intelligent follow-up questions that the user might naturally ask next. These questions should:
+1. Build upon the conversation history and insights shown in the current component
+2. NOT repeat questions or topics already covered in the conversation history
+3. Explore natural next steps in the data exploration journey
+4. Be progressively more detailed or specific
+5. Consider the user's apparent interests based on their question pattern
+6. Be phrased naturally as if a real user would ask them
+
+Format your response as a JSON object with this structure:
+{
+  "nextQuestions": [
+    "Question 1?",
+    "Question 2?",
+    ...
+  ]
+}
+
+Return ONLY valid JSON.`
+  }
+};
+
+// src/userResponse/prompt-loader.ts
 var PromptLoader = class {
   constructor(config) {
     this.promptCache = /* @__PURE__ */ new Map();
     this.isInitialized = false;
-    logger.debug("Initializing PromptLoader...", process.cwd());
+    logger.debug("Initializing PromptLoader...");
     this.promptsDir = config?.promptsDir || import_path2.default.join(process.cwd(), ".prompts");
-    this.defaultPromptsDir = import_path2.default.join(__dirname, "..", "..", ".prompts");
+    logger.debug(`Prompts directory set to: ${this.promptsDir}`);
+  }
+  /**
+   * Load a prompt template from file system OR fallback to hardcoded prompts
+   * @param promptName - Name of the prompt folder
+   * @returns Template with system and user prompts
+   */
+  loadPromptTemplate(promptName) {
+    try {
+      const systemPath = import_path2.default.join(this.promptsDir, promptName, "system.md");
+      const userPath = import_path2.default.join(this.promptsDir, promptName, "user.md");
+      if (import_fs3.default.existsSync(systemPath) && import_fs3.default.existsSync(userPath)) {
+        const system = import_fs3.default.readFileSync(systemPath, "utf-8");
+        const user = import_fs3.default.readFileSync(userPath, "utf-8");
+        logger.info(`\u2713 Loaded prompt '${promptName}' from file system: ${this.promptsDir}`);
+        return { system, user };
+      }
+    } catch (error) {
+      logger.error(`Could not load '${promptName}' from file system, trying fallback...`);
+    }
+    const hardcodedPrompt = PROMPTS[promptName];
+    if (hardcodedPrompt) {
+      logger.info(`\u2713 Loaded prompt '${promptName}' from hardcoded fallback`);
+      return hardcodedPrompt;
+    }
+    throw new Error(`Prompt template '${promptName}' not found in either ${this.promptsDir} or hardcoded prompts. Available prompts: ${Object.keys(PROMPTS).join(", ")}`);
   }
   /**
    * Initialize and cache all prompts into memory
-   * This should be called once at SDK startup
+   * Tries file system first, then falls back to hardcoded prompts
    */
   async initialize() {
     if (this.isInitialized) {
@@ -2219,61 +3075,19 @@ var PromptLoader = class {
       return;
     }
     logger.info("Loading prompts into memory...");
-    const promptTypes = [
-      "classify",
-      "match-component",
-      "modify-props",
-      "single-component",
-      "mutli-component",
-      "actions",
-      "container-metadata",
-      "text-response",
-      "match-text-components"
-    ];
-    for (const promptType of promptTypes) {
+    const promptTypes = Object.keys(PROMPTS);
+    for (const promptName of promptTypes) {
       try {
-        const template = await this.loadPromptTemplate(promptType);
-        this.promptCache.set(promptType, template);
-        logger.debug(`Cached prompt: ${promptType}`);
+        const template = this.loadPromptTemplate(promptName);
+        this.promptCache.set(promptName, template);
       } catch (error) {
-        logger.error(`Failed to load prompt '${promptType}':`, error);
+        logger.error(`Failed to load prompt '${promptName}':`, error);
         throw error;
       }
     }
     this.isInitialized = true;
     logger.info(`Successfully loaded ${this.promptCache.size} prompt templates into memory`);
   }
-  /**
-   * Load a prompt template from file system (tries custom dir first, then defaults to SDK dir)
-   * @param promptName - Name of the prompt folder
-   * @returns Template with system and user prompts
-   */
-  async loadPromptTemplate(promptName) {
-    const tryLoadFromDir = (dir) => {
-      try {
-        const systemPath = import_path2.default.join(dir, promptName, "system.md");
-        const userPath = import_path2.default.join(dir, promptName, "user.md");
-        if (import_fs3.default.existsSync(systemPath) && import_fs3.default.existsSync(userPath)) {
-          const system = import_fs3.default.readFileSync(systemPath, "utf-8");
-          const user = import_fs3.default.readFileSync(userPath, "utf-8");
-          logger.debug(`Loaded prompt '${promptName}' from ${dir}`);
-          return { system, user };
-        }
-        return null;
-      } catch (error) {
-        return null;
-      }
-    };
-    let template = tryLoadFromDir(this.promptsDir);
-    if (!template) {
-      logger.warn(`Prompt '${promptName}' not found in ${this.promptsDir}, trying default location...`);
-      template = tryLoadFromDir(this.defaultPromptsDir);
-    }
-    if (!template) {
-      throw new Error(`Prompt template '${promptName}' not found in either ${this.promptsDir} or ${this.defaultPromptsDir}`);
-    }
-    return template;
-  }
   /**
    * Replace variables in a template string using {{VARIABLE_NAME}} pattern
    * @param template - Template string with placeholders
@@ -2291,13 +3105,13 @@ var PromptLoader = class {
   }
   /**
    * Load both system and user prompts from cache and replace variables
-   * @param promptName - Name of the prompt folder
+   * @param promptName - Name of the prompt
    * @param variables - Variables to replace in the templates
    * @returns Object containing both system and user prompts
    */
   async loadPrompts(promptName, variables) {
     if (!this.isInitialized) {
-      logger.warn("PromptLoader not initialized, loading prompts on-demand (not recommended)");
+      logger.warn("PromptLoader not initialized, initializing now...");
       await this.initialize();
     }
     const template = this.promptCache.get(promptName);
@@ -2325,6 +3139,7 @@ var PromptLoader = class {
     this.promptsDir = dir;
     this.isInitialized = false;
     this.promptCache.clear();
+    logger.debug(`Prompts directory changed to: ${dir}`);
   }
   /**
    * Get current prompts directory
@@ -6396,6 +7211,7 @@ var SuperatomSDK = class {
   }
   /**
    * Initialize PromptLoader and load prompts into memory
+   * Tries to load from file system first, then falls back to hardcoded prompts
    */
   async initializePromptLoader(promptsDir) {
     try {