// Authentication is handled by Convex Auth
// Supports Google OAuth out of the box
const { signIn } = useAuthActions()
await signIn("google")

SELECT product, SUM(revenue) as total_revenue
FROM sales_2024
GROUP BY product
ORDER BY total_revenue DESC

// From QueryEditor.tsx - keyboard shortcut
if ((e.ctrlKey || e.metaKey) && e.key === 'Enter') {
  e.preventDefault()
  onExecute() // Executes the query
}

// From table.$table.tsx - query execution
const startTime = Date.now()
const result = await queryDuckDB({ data: query })
const executionTime = Date.now() - startTime

// Metadata is logged to Convex
await logQuery({
  query,
  tableName: table,
  success: true,
  resultMetadata: {
    rowCount: parsed.rows?.length,
    columnCount: parsed.columns?.length,
    executionTimeMs: executionTime,
  },
})

// From table_agent.ts - two specialized agents
const query_agent = new Agent(components.agent, {
  name: 'Query Agent',
  instructions: `You write DuckDB SQL queries...`,
  tools: { queryDuckDB, getTableSchema, getSampleRows, ... }
})

const analysis_agent = new Agent(components.agent, {
  name: 'Analysis Agent',
  instructions: `You explore and analyze databases...`,
  tools: { queryDuckDB, createChart, generateInsights, ... }
})

Show me the top 5 products by revenue

// Agent response format
{
  "commands": [
    "SELECT product, SUM(revenue) as total_revenue FROM sales_2024 GROUP BY product ORDER BY total_revenue DESC LIMIT 5"
  ],
  "description": "This query aggregates revenue by product and returns the top 5 highest earners"
}

// From QueryEditor.tsx - command queue display
{commandQueue.length > 0 && (
  <Badge size="xs">
    {currentCommandIndex + 1} / {commandQueue.length}
  </Badge>
)}

What are the trends in this data?

// From table_agent.ts - analysis mode with tools
for await (const st_part of stream.fullStream) {
  if (st_part.type === 'tool-call') {
    // Show tool being called (e.g., "queryDuckDB", "createChart")
  }
  if (st_part.type === 'tool-result') {
    // Show tool result (e.g., "Found 1,523 rows")
  }
  if (st_part.type === 'text-delta') {
    // Stream agent's natural language explanation
  }
}

// From table.$table.tsx - insight generation
const statisticalAnalyses = await analyzeTableWithDuckDB(
  table,
  query,
  dataToAnalyze.columns,
)

const result = await generateInsights({
  tableName: table,
  query: query,
  statisticalAnalyses: statisticalAnalyses,
  rowCount: dataToAnalyze.rows.length,
  columnCount: dataToAnalyze.columns.length,
})

// From InsightsPanel.tsx - insight structure
interface Insight {
  title: string
  description: string
  type: 'outlier' | 'trend' | 'aggregation' | 'pattern' | 'anomaly'
  severity: 'low' | 'medium' | 'high'
}

{
  "title": "Revenue spike in Q4",
  "description": "Revenue increased 340% in October-December compared to previous quarters, driven primarily by Widget A sales in the North region",
  "type": "trend",
  "severity": "high"
}

Create a bar chart showing revenue by product

// From agent_tools.ts - createChart tool
createChart: {
  description: "Create an interactive chart from query results",
  parameters: z.object({
    chartType: z.enum(['bar', 'line', 'area', 'pie', 'donut', 'scatter']),
    title: z.string(),
    query: z.string(),
    xAxis: z.string(),
    yAxis: z.string(),
  }),
  execute: async ({ chartType, title, query, xAxis, yAxis }) => {
    // Execute query and build chart config
  },
}

// From ChartCanvas.tsx - draggable implementation
const handlePointerDown = (e: React.PointerEvent) => {
  // Capture pointer and canvas rect
  dragOffsetRef.current = {
    x: e.clientX - canvasLeft - position.x,
    y: e.clientY - canvasTop - position.y,
  }
  setIsDragging(true)
}

// From TableNotifications.tsx - real-time subscription
const notifications = useQuery(api.notifications.getNotifications, {
  tableName,
})

// Broadcasts appear as toasts
notifications.show({
  title: `${userName} executed a query`,
  message: queryPreview,
})

// From schema.ts - queryLog table
queryLog: defineTable({
  query: v.string(),
  executedAt: v.number(),
  userId: v.string(),
  tableName: v.string(),
  success: v.boolean(),
  resultMetadata: v.optional(v.object({
    rowCount: v.optional(v.number()),
    executionTimeMs: v.optional(v.number()),
  })),
})