windmill-components 1.623.1 → 1.642.0

package/package/components/copilot/chat/app/core.js

@@ -1,8 +1,5 @@
 import { z } from 'zod';
-import { createSearchHubScriptsTool, createToolDef } from '../shared';
-import { FlowService, ScriptService } from '../../../../gen';
-import uFuzzy from '@leeoniya/ufuzzy';
-import { emptyString } from '../../../../utils';
+import { createSearchHubScriptsTool, createToolDef, createSearchWorkspaceTool, createGetRunnableDetailsTool } from '../shared';
 import { aiChatManager } from '../AIChatManager.svelte';
 // ============= Utility =============
 /** Maximum characters per file in get_files tool */
@@ -94,70 +91,6 @@ const getExecDatatableSqlToolDef = memo(() => createToolDef(getExecDatatableSqlS
 // ============= Selected Context Tool =============
 const getGetSelectedContextSchema = memo(() => z.object({}));
 const getGetSelectedContextToolDef = memo(() => createToolDef(getGetSelectedContextSchema(), 'get_selected_context', 'Get information about what is currently selected in the app editor. Returns the type of selection (frontend file or backend runnable) and the path/key of the selected item.'));
-// ============= Workspace Runnables Search =============
-const getListWorkspaceRunnablesSchema = memo(() => z.object({
-    query: z.string().describe('The search query to find workspace scripts and flows'),
-    type: z
-        .enum(['all', 'scripts', 'flows'])
-        .describe('Filter by type: "scripts" for scripts only, "flows" for flows only, "all" for both. Defaults to "all".')
-}));
-const getListWorkspaceRunnablesToolDef = memo(() => createToolDef(getListWorkspaceRunnablesSchema(), 'list_workspace_runnables', 'Search for workspace scripts and flows by query. Returns fully qualified paths that can be used in backend runnables.'));
-class WorkspaceRunnablesSearch {
-    uf;
-    workspace = undefined;
-    scripts = undefined;
-    flows = undefined;
-    constructor() {
-        this.uf = new uFuzzy();
-    }
-    async initScripts(workspace) {
-        if (this.scripts === undefined || this.workspace !== workspace) {
-            this.scripts = await ScriptService.listScripts({ workspace });
-            this.workspace = workspace;
-        }
-    }
-    async initFlows(workspace) {
-        if (this.flows === undefined || this.workspace !== workspace) {
-            this.flows = await FlowService.listFlows({ workspace });
-            this.workspace = workspace;
-        }
-    }
-    async searchScripts(query, workspace) {
-        await this.initScripts(workspace);
-        const scripts = this.scripts;
-        if (!scripts)
-            return [];
-        const results = this.uf.search(scripts.map((s) => (emptyString(s.summary) ? s.path : s.summary + ' (' + s.path + ')')), query.trim());
-        return (results[2]?.map((id) => ({
-            type: 'script',
-            path: scripts[id].path,
-            summary: scripts[id].summary
-        })) ?? []);
-    }
-    async searchFlows(query, workspace) {
-        await this.initFlows(workspace);
-        const flows = this.flows;
-        if (!flows)
-            return [];
-        const results = this.uf.search(flows.map((f) => (emptyString(f.summary) ? f.path : f.summary + ' (' + f.path + ')')), query.trim());
-        return (results[2]?.map((id) => ({
-            type: 'flow',
-            path: flows[id].path,
-            summary: flows[id].summary
-        })) ?? []);
-    }
-    async search(query, workspace, type = 'all') {
-        const results = [];
-        if (type === 'all' || type === 'scripts') {
-            results.push(...(await this.searchScripts(query, workspace)));
-        }
-        if (type === 'all' || type === 'flows') {
-            results.push(...(await this.searchFlows(query, workspace)));
-        }
-        return results;
-    }
-}
-const workspaceRunnablesSearch = new WorkspaceRunnablesSearch();
 // ============= Lint Result Formatting =============
 function formatLintMessages(messages) {
     let result = '';
@@ -369,7 +302,7 @@ export const getAppTools = memo(() => [
             });
             const lintResult = await helpers.setBackendRunnable(parsedArgs.key, runnable);
             toolCallbacks.setToolStatus(toolId, {
-                content: `Backend runnable '${parsedArgs.key}' analyzed`,
+                content: `Backend runnable '${parsedArgs.key}' set successfully.`,
                 result: 'Success'
             });
             return formatLintResultResponse(`Backend runnable '${parsedArgs.key}' has been set successfully.`, lintResult);
@@ -411,21 +344,8 @@ export const getAppTools = memo(() => [
         }
     },
     // Search tools
-    {
-        def: getListWorkspaceRunnablesToolDef(),
-        fn: async ({ args, workspace, toolId, toolCallbacks }) => {
-            const parsedArgs = getListWorkspaceRunnablesSchema().parse(args);
-            const type = parsedArgs.type ?? 'all';
-            toolCallbacks.setToolStatus(toolId, {
-                content: `Searching workspace ${type} for "${parsedArgs.query}"...`
-            });
-            const results = await workspaceRunnablesSearch.search(parsedArgs.query, workspace, type);
-            toolCallbacks.setToolStatus(toolId, {
-                content: `Found ${results.length} workspace runnables matching "${parsedArgs.query}"`
-            });
-            return JSON.stringify(results, null, 2);
-        }
-    },
+    createSearchWorkspaceTool(),
+    createGetRunnableDetailsTool(),
     // Hub scripts search (reuse from shared)
     createSearchHubScriptsTool(false),
     // Data table tools
@@ -439,7 +359,8 @@ export const getAppTools = memo(() => [
                     toolCallbacks.setToolStatus(toolId, { content: 'No datatables configured' });
                     return 'No datatables are configured in this app. Use the Data panel in the sidebar to add datatable references.';
                 }
-                const totalTables = datatables.reduce((acc, dt) => acc + dt.tables.length, 0);
+                const totalTables = datatables.reduce((acc, dt) => acc +
+                    Object.values(dt.schemas).reduce((schemaAcc, tables) => schemaAcc + Object.keys(tables).length, 0), 0);
                 toolCallbacks.setToolStatus(toolId, {
                     content: `Found ${datatables.length} datatable(s) with ${totalTables} table(s)`
                 });
@@ -520,6 +441,12 @@ export const getAppTools = memo(() => [
     }
 ]);
 export function prepareAppSystemMessage(customPrompt) {
+    // Get policy early so we can use it in the template
+    const policy = aiChatManager.datatableCreationPolicy;
+    const datatableName = policy.datatable ?? 'main';
+    const schemaPrefix = policy.schema ? `${policy.schema}.` : '';
+    // Use wmill.datatable() for 'main' (default), otherwise wmill.datatable('name')
+    const datatableCall = datatableName === 'main' ? 'wmill.datatable()' : `wmill.datatable('${datatableName}')`;
     let content = `You are a helpful assistant that creates and edits apps on the Windmill platform. Apps are defined as a collection of files that contains both the frontend and the backend.
 
 ## App Structure
@@ -555,7 +482,8 @@ For inline scripts, the code must have a \`main\` function as its entrypoint.
 - \`lint()\`: Lint all files. Returns errors/warnings grouped by frontend/backend. Use this to check for issues after making changes.
 
 ### Discovery
-- \`list_workspace_runnables(query, type?)\`: Search workspace scripts and flows
+- \`search_workspace(query, type)\`: Search workspace scripts and flows
+- \`get_runnable_details(path, type)\`: Get details (summary, description, schema, content) of a specific script or flow
 - \`search_hub_scripts(query)\`: Search hub scripts
 
 ### Data Tables
@@ -596,12 +524,10 @@ Backend runnables should only perform **data operations** (SELECT, INSERT, UPDAT
 import * as wmill from 'windmill-client';
 
 export async function main(user_id: string) {
-  // Use default 'main' datatable
-  let sql = wmill.datatable();
-  // Or specify a named datatable: wmill.datatable('named_datatable')
+  const sql = ${datatableCall};
 
   // Safe string interpolation (parameterized query)
-  let user = await sql\`SELECT * FROM users WHERE id = \${user_id}\`.fetchOne();
+  const user = await sql\`SELECT * FROM ${schemaPrefix}users WHERE id = \${user_id}\`.fetchOne();
   return user;
 }
 \`\`\`
@@ -611,22 +537,20 @@ export async function main(user_id: string) {
 import wmill
 
 def main(user_id: str):
-    db = wmill.datatable()  # or wmill.datatable('named_datatable')
+    db = ${datatableCall}
 
     # Use positional arguments ($1, $2, etc.)
-    user = db.query('SELECT * FROM users WHERE id = $1', user_id).fetch_one()
+    user = db.query('SELECT * FROM ${schemaPrefix}users WHERE id = $1', user_id).fetch_one()
     return user
 \`\`\`
 
 ### Common Operations (for use in backend runnables)
 
-- **Fetch all**: \`sql\`SELECT * FROM table\`.fetch()\` or \`db.query('SELECT * FROM table').fetch()\`
+- **Fetch all**: \`sql\`SELECT * FROM ${schemaPrefix}table\`.fetch()\` or \`db.query('SELECT * FROM ${schemaPrefix}table').fetch()\`
 - **Fetch one**: \`.fetchOne()\` or \`.fetch_one()\`
-- **Insert**: \`sql\`INSERT INTO table (col) VALUES (\${value})\`\`
-- **Update**: \`sql\`UPDATE table SET col = \${value} WHERE id = \${id}\`\`
-- **Delete**: \`sql\`DELETE FROM table WHERE id = \${id}\`\`
-
-The "main" datatable is the default and can be accessed without specifying a name.
+- **Insert**: \`sql\`INSERT INTO ${schemaPrefix}table (col) VALUES (\${value})\`\`
+- **Update**: \`sql\`UPDATE ${schemaPrefix}table SET col = \${value} WHERE id = \${id}\`\`
+- **Delete**: \`sql\`DELETE FROM ${schemaPrefix}table WHERE id = \${id}\`\`
 
 ### Schema Modifications (DDL) - Use exec_datatable_sql tool ONLY
 
@@ -706,17 +630,15 @@ When you are using the windmill-client, do not forget that as id for variables o
 3. Make changes using \`set_frontend_file\` and \`set_backend_runnable\`. These return lint diagnostics.
 4. Use \`lint()\` at the end to check for and fix any remaining errors
 
-When creating a new app, use \`list_workspace_runnables\` or \`search_hub_scripts\` to find existing scripts/flows to reuse.
+When creating a new app, use \`search_workspace\` or \`search_hub_scripts\` to find existing scripts/flows to reuse.
 
 `;
     // Add datatable creation policy context
-    const policy = aiChatManager.datatableCreationPolicy;
     if (policy.enabled && policy.datatable) {
-        const schemaPrefix = policy.schema ? `${policy.schema}.` : '';
         content += `## Datatable Creation Policy
 
 **Table creation is ENABLED.** You can create new tables using \`exec_datatable_sql\` with the \`new_table\` parameter.
-- **Default datatable**: ${policy.datatable}${policy.schema ? `\n- **Default schema**: ${policy.schema}` : ''}
+- **Default datatable**: ${datatableName}${policy.schema ? `\n- **Default schema**: ${policy.schema}` : ''}
 
 When creating new tables, you MUST use the default datatable${policy.schema ? ` and schema` : ''} specified above. Do not create tables in other datatables or schemas.
 ${policy.schema ? `\n**IMPORTANT**: Always use the schema prefix \`${schemaPrefix}\` in your SQL queries when creating or referencing tables. For example: \`CREATE TABLE ${schemaPrefix}my_table (...)\` and \`SELECT * FROM ${schemaPrefix}my_table\`. Never create tables without the schema prefix as they would go to the public schema instead.` : ''}
@@ -738,16 +660,134 @@ ${policy.schema ? `\n**IMPORTANT**: Always use the schema prefix \`${schemaPrefi
         content
     };
 }
-export function prepareAppUserMessage(instructions, selectedContext) {
+/** Maximum characters for file content in context */
+const MAX_CONTEXT_CONTENT_LENGTH = 3000;
+export function prepareAppUserMessage(instructions, selectedContext, additionalContext) {
     let content = '';
-    if (selectedContext && selectedContext.type !== 'none') {
+    // Check if we have any context to add
+    const hasSelectedContext = selectedContext && (selectedContext.type !== 'none' || selectedContext.inspectorElement);
+    const hasAdditionalContext = additionalContext && additionalContext.length > 0;
+    if (hasSelectedContext || hasAdditionalContext) {
         content += `## SELECTED CONTEXT:\n`;
-        if (selectedContext.type === 'frontend') {
-            content += `The user is currently viewing the frontend file: ${selectedContext.frontendPath}\n\n`;
+        // Add frontend file context with content (unless excluded)
+        if (selectedContext &&
+            selectedContext.type === 'frontend' &&
+            selectedContext.frontendPath &&
+            !selectedContext.selectionExcluded) {
+            content += `The user is currently viewing the frontend file: **${selectedContext.frontendPath}**\n`;
+            if (selectedContext.frontendContent) {
+                const truncatedContent = selectedContext.frontendContent.length > MAX_CONTEXT_CONTENT_LENGTH
+                    ? selectedContext.frontendContent.slice(0, MAX_CONTEXT_CONTENT_LENGTH) +
+                        '\n... [TRUNCATED]'
+                    : selectedContext.frontendContent;
+                content += `\n\`\`\`\n${truncatedContent}\n\`\`\`\n`;
+            }
+        }
+        // Add backend runnable context with content (unless excluded)
+        if (selectedContext &&
+            selectedContext.type === 'backend' &&
+            selectedContext.backendKey &&
+            !selectedContext.selectionExcluded) {
+            content += `The user is currently viewing the backend runnable: **${selectedContext.backendKey}**\n`;
+            if (selectedContext.backendRunnable) {
+                const runnable = selectedContext.backendRunnable;
+                content += `- **Name**: ${runnable.name}\n`;
+                content += `- **Type**: ${runnable.type}\n`;
+                if (runnable.path) {
+                    content += `- **Path**: ${runnable.path}\n`;
+                }
+                if (runnable.inlineScript) {
+                    const truncatedCode = runnable.inlineScript.content.length > MAX_CONTEXT_CONTENT_LENGTH
+                        ? runnable.inlineScript.content.slice(0, MAX_CONTEXT_CONTENT_LENGTH) +
+                            '\n... [TRUNCATED]'
+                        : runnable.inlineScript.content;
+                    content += `- **Language**: ${runnable.inlineScript.language}\n`;
+                    content += `- **Code**:\n\`\`\`${runnable.inlineScript.language === 'bun' ? 'typescript' : 'python'}\n${truncatedCode}\n\`\`\`\n`;
+                }
+                if (runnable.staticInputs && Object.keys(runnable.staticInputs).length > 0) {
+                    content += `- **Static inputs**: ${JSON.stringify(runnable.staticInputs)}\n`;
+                }
+            }
         }
-        else if (selectedContext.type === 'backend') {
-            content += `The user is currently viewing the backend runnable: ${selectedContext.backendKey}\n\n`;
+        // Add inspector element context if available
+        if (selectedContext?.inspectorElement) {
+            const el = selectedContext.inspectorElement;
+            content += `\nThe user has selected an element in the app preview using the inspector tool:\n`;
+            content += `- **Element**: ${el.tagName}${el.id ? `#${el.id}` : ''}${el.className ? `.${el.className.split(' ').join('.')}` : ''}\n`;
+            content += `- **Selector path**: ${el.path}\n`;
+            content += `- **Dimensions**: ${Math.round(el.rect.width)}x${Math.round(el.rect.height)} at (${Math.round(el.rect.left)}, ${Math.round(el.rect.top)})\n`;
+            if (el.textContent) {
+                const truncatedText = el.textContent.length > 100 ? el.textContent.slice(0, 100) + '...' : el.textContent;
+                content += `- **Text content**: "${truncatedText}"\n`;
+            }
+            // Include HTML (truncated) for more context
+            const truncatedHtml = el.html.length > 500 ? el.html.slice(0, 500) + '...' : el.html;
+            content += `- **HTML**:\n\`\`\`html\n${truncatedHtml}\n\`\`\`\n`;
+        }
+        // Add code selection context if available
+        if (selectedContext?.codeSelection) {
+            const selection = selectedContext.codeSelection;
+            content += `\n### CODE SELECTION:\n`;
+            content += `The user has selected code in the ${selection.sourceType} editor:\n`;
+            content += `- **File/Source**: ${selection.source}\n`;
+            content += `- **Lines**: ${selection.startLine}-${selection.endLine}\n`;
+            const truncatedCode = selection.content.length > MAX_CONTEXT_CONTENT_LENGTH
+                ? selection.content.slice(0, MAX_CONTEXT_CONTENT_LENGTH) + '\n... [TRUNCATED]'
+                : selection.content;
+            content += `\`\`\`\n${truncatedCode}\n\`\`\`\n`;
+        }
+        // Add additional context from @ mentions
+        if (additionalContext && additionalContext.length > 0) {
+            content += `\n### ADDITIONAL CONTEXT (mentioned by user):\n`;
+            for (const ctx of additionalContext) {
+                if (ctx.type === 'app_frontend_file') {
+                    const fileCtx = ctx;
+                    content += `\n**Frontend File: ${fileCtx.path}**\n`;
+                    const truncatedContent = fileCtx.content.length > MAX_CONTEXT_CONTENT_LENGTH
+                        ? fileCtx.content.slice(0, MAX_CONTEXT_CONTENT_LENGTH) + '\n... [TRUNCATED]'
+                        : fileCtx.content;
+                    content += `\`\`\`\n${truncatedContent}\n\`\`\`\n`;
+                }
+                else if (ctx.type === 'app_backend_runnable') {
+                    const runnableCtx = ctx;
+                    const runnable = runnableCtx.runnable;
+                    content += `\n**Backend Runnable: ${runnableCtx.key}**\n`;
+                    content += `- **Name**: ${runnable.name}\n`;
+                    content += `- **Type**: ${runnable.type}\n`;
+                    if (runnable.path) {
+                        content += `- **Path**: ${runnable.path}\n`;
+                    }
+                    if (runnable.inlineScript) {
+                        const truncatedCode = runnable.inlineScript.content.length > MAX_CONTEXT_CONTENT_LENGTH
+                            ? runnable.inlineScript.content.slice(0, MAX_CONTEXT_CONTENT_LENGTH) +
+                                '\n... [TRUNCATED]'
+                            : runnable.inlineScript.content;
+                        content += `- **Language**: ${runnable.inlineScript.language}\n`;
+                        content += `- **Code**:\n\`\`\`${runnable.inlineScript.language === 'bun' ? 'typescript' : 'python'}\n${truncatedCode}\n\`\`\`\n`;
+                    }
+                    if (runnable.staticInputs && Object.keys(runnable.staticInputs).length > 0) {
+                        content += `- **Static inputs**: ${JSON.stringify(runnable.staticInputs)}\n`;
+                    }
+                }
+                else if (ctx.type === 'app_datatable') {
+                    const datatableCtx = ctx;
+                    const tableRef = datatableCtx.schemaName === 'public'
+                        ? `${datatableCtx.datatableName}/${datatableCtx.tableName}`
+                        : `${datatableCtx.datatableName}/${datatableCtx.schemaName}:${datatableCtx.tableName}`;
+                    content += `\n**Table: ${tableRef}**\n`;
+                    content += `- **Datatable**: ${datatableCtx.datatableName}\n`;
+                    content += `- **Schema**: ${datatableCtx.schemaName}\n`;
+                    content += `- **Table**: ${datatableCtx.tableName}\n`;
+                    // Format columns as column_name: type
+                    const columnsStr = JSON.stringify(datatableCtx.columns, null, 2);
+                    const truncatedColumns = columnsStr.length > MAX_CONTEXT_CONTENT_LENGTH
+                        ? columnsStr.slice(0, MAX_CONTEXT_CONTENT_LENGTH) + '\n... [TRUNCATED]'
+                        : columnsStr;
+                    content += `- **Columns** (column_name -> type):\n\`\`\`json\n${truncatedColumns}\n\`\`\`\n`;
+                }
+            }
         }
+        content += '\n';
     }
     content += `## INSTRUCTIONS:\n${instructions}`;
     return {

package/package/components/copilot/chat/context.js

@@ -1,4 +1,5 @@
-import { Code, Database, TriangleAlert, Diff } from 'lucide-svelte';
+import { Code, Database, TriangleAlert, Diff, FileCode, Code2, TextSelect, Table2 } from 'lucide-svelte';
+import BarsStaggered from '../../icons/BarsStaggered.svelte';
 import {} from '../../../stores';
 import {} from 'diff';
 export const ContextIconMap = {
@@ -6,6 +7,12 @@ export const ContextIconMap = {
     error: TriangleAlert,
     db: Database,
     diff: Diff,
-    code_piece: Code
+    code_piece: Code,
+    app_frontend_file: FileCode,
+    app_backend_runnable: Code2,
+    app_code_selection: TextSelect,
+    app_datatable: Table2,
+    workspace_script: Code2,
+    workspace_flow: BarsStaggered
     // flow_module type is handled with FlowModuleIcon
 };

package/package/components/copilot/chat/flow/FlowAIChat.svelte

@@ -142,6 +142,28 @@ const flowHelpers = {
         // Call the UI test function which opens preview panel
         return await onTestFlow?.(conversationId);
     },
+    getLintErrors: async (moduleId) => {
+        const module = getModule(moduleId);
+        if (!module || module.value.type !== 'rawscript') {
+            return { errorCount: 0, warningCount: 0, errors: [], warnings: [] };
+        }
+        // Focus the module first
+        selectionManager.selectId(moduleId);
+        // Poll until editor exists
+        const maxWait = 3000;
+        const pollInterval = 100;
+        let elapsed = 0;
+        while (elapsed < maxWait) {
+            if ($currentEditor?.type === 'script') {
+                // Wait 500ms for LSP to analyze the code
+                await new Promise((resolve) => setTimeout(resolve, 500));
+                return $currentEditor.editor.getLintErrors();
+            }
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+            elapsed += pollInterval;
+        }
+        return { errorCount: 0, warningCount: 0, errors: [], warnings: [] };
+    },
     setFlowJson: async (modules, schema) => {
         try {
             if (modules || schema) {

package/package/components/copilot/chat/flow/core.d.ts

@@ -1,6 +1,6 @@
 import { type FlowModule, type InputTransform } from '../../../../gen';
 import type { ChatCompletionSystemMessageParam, ChatCompletionUserMessageParam } from 'openai/resources/chat/completions.mjs';
-import { type Tool } from '../shared';
+import { type Tool, type ScriptLintResult } from '../shared';
 import type { ContextElement } from '../context';
 import type { ExtendedOpenFlow } from '../../../flows/types';
 /**
@@ -34,6 +34,8 @@ export interface FlowAIChatHelpers {
     selectStep: (id: string) => void;
     /** Run a test of the current flow using the UI's preview mechanism */
     testFlow: (args?: Record<string, any>, conversationId?: string) => Promise<string | undefined>;
+    /** Get lint errors from a specific module (focuses it first, waits for Monaco to analyze) */
+    getLintErrors: (moduleId: string) => Promise<ScriptLintResult>;
 }
 export declare const flowTools: Tool<FlowAIChatHelpers>[];
 export declare function prepareFlowSystemMessage(customPrompt?: string): ChatCompletionSystemMessageParam;