windmill-components 1.558.3 → 1.596.0

package/package/components/copilot/chat/__tests__/app/appEvalRunner.js

@@ -0,0 +1,92 @@
+import { getAppTools, prepareAppSystemMessage, prepareAppUserMessage } from '../../app/core';
+import { createAppEvalHelpers } from './appEvalHelpers';
+import { evaluateAppGeneration } from './appEvalComparison';
+import { runEval, resolveSystemPrompt, resolveTools, resolveModel } from '../shared';
+import { writeAppComparisonResultsToFolders } from './appResultsWriter';
+/**
+ * App-specific variant defaults.
+ */
+const appDefaults = {
+    prepareSystemMessage: prepareAppSystemMessage,
+    tools: getAppTools()
+};
+/**
+ * Runs an app chat evaluation with real OpenAI API calls.
+ * Executes tool calls using the actual app tools from core.ts or variant-configured tools.
+ */
+export async function runAppEval(userPrompt, openaiApiKey, options) {
+    const { helpers, getFiles } = createAppEvalHelpers(options?.initialFrontend ?? {}, options?.initialBackend ?? {});
+    // Resolve variant configuration
+    const variantName = options?.variant?.name ?? 'baseline';
+    const systemMessage = resolveSystemPrompt(options?.variant, appDefaults, options?.customSystemPrompt);
+    const { toolDefs, tools } = resolveTools(options?.variant, appDefaults);
+    const model = resolveModel(options?.variant, options?.model);
+    // Build user message
+    const userMessage = prepareAppUserMessage(userPrompt, helpers.getSelectedContext());
+    // Run the base evaluation
+    const rawResult = await runEval({
+        userPrompt,
+        systemMessage,
+        userMessage,
+        toolDefs,
+        tools,
+        helpers,
+        apiKey: openaiApiKey,
+        getOutput: getFiles,
+        options: {
+            maxIterations: options?.maxIterations,
+            model,
+            workspace: 'test-workspace'
+        }
+    });
+    // Run LLM evaluation unless explicitly disabled
+    let evaluationResult;
+    if (options?.evaluateWithLLM !== false) {
+        const generatedApp = getFiles();
+        const initialApp = options?.initialFrontend || options?.initialBackend
+            ? {
+                frontend: options.initialFrontend ?? {},
+                backend: options.initialBackend ?? {}
+            }
+            : undefined;
+        evaluationResult = await evaluateAppGeneration(userPrompt, generatedApp, initialApp);
+    }
+    return {
+        ...rawResult,
+        variantName,
+        files: rawResult.output,
+        evaluationResult
+    };
+}
+/**
+ * Runs the same prompt against multiple variants sequentially for comparison.
+ * Returns results in the same order as the input variants.
+ */
+export async function runVariantComparison(userPrompt, variants, openaiApiKey, baseOptions) {
+    const results = await Promise.all(variants.map(async (variant) => {
+        return await runAppEval(userPrompt, openaiApiKey, {
+            ...baseOptions,
+            variant
+        });
+    }));
+    return results;
+}
+/**
+ * Writes app comparison results to a folder-based structure.
+ * Each variant gets its own folder with frontend/, backend/, and details.json.
+ */
+export async function writeAppComparisonResults(userPrompt, results, outputDir) {
+    // @ts-ignore
+    const { dirname, join } = await import('path');
+    // @ts-ignore
+    const { fileURLToPath } = await import('url');
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const resultsDir = outputDir ?? join(__dirname, 'results');
+    const result = await writeAppComparisonResultsToFolders({
+        userPrompt,
+        results,
+        outputDir: resultsDir
+    });
+    return { summaryPath: result.summaryPath, appPaths: result.variantPaths };
+}

package/package/components/copilot/chat/__tests__/app/appFixtureLoader.d.ts

@@ -0,0 +1,29 @@
+import type { AppFiles, BackendRunnable } from '../../app/core';
+/**
+ * Loads an app fixture from a directory structure.
+ *
+ * Expected structure:
+ * ```
+ * fixturePath/
+ * ├── frontend/
+ * │   └── index.tsx           # → frontend["/index.tsx"]
+ * │   └── components/
+ * │       └── Button.tsx      # → frontend["/components/Button.tsx"]
+ * └── backend/
+ *     └── incrementCounter/
+ *         ├── main.ts         # The code content
+ *         └── meta.json       # { "name": "...", "language": "bun" }
+ * ```
+ *
+ * @param fixturePath - Path to the fixture directory
+ * @returns AppFiles object with frontend and backend
+ */
+export declare function loadAppFixture(fixturePath: string): Promise<AppFiles>;
+/**
+ * Loads an app fixture and returns the separate frontend and backend objects.
+ * Convenience function for use with runAppEval options.
+ */
+export declare function loadAppFixtureForEval(fixturePath: string): Promise<{
+    initialFrontend: Record<string, string>;
+    initialBackend: Record<string, BackendRunnable>;
+}>;

package/package/components/copilot/chat/__tests__/app/appFixtureLoader.js

@@ -0,0 +1,134 @@
+/**
+ * Recursively reads all files in a directory and returns them as a record.
+ * File paths are relative to the base directory with a leading '/'.
+ */
+async function readFilesRecursively(dir, basePath = '') {
+    // @ts-ignore - Node.js fs/promises
+    const { readdir, readFile } = await import('fs/promises');
+    // @ts-ignore - Node.js path
+    const { join } = await import('path');
+    const result = {};
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        const relativePath = basePath ? `${basePath}/${entry.name}` : `/${entry.name}`;
+        if (entry.isDirectory()) {
+            const subFiles = await readFilesRecursively(fullPath, relativePath);
+            Object.assign(result, subFiles);
+        }
+        else {
+            const content = await readFile(fullPath, 'utf-8');
+            result[relativePath] = content;
+        }
+    }
+    return result;
+}
+/**
+ * Loads frontend files from a directory.
+ * All files are read recursively and paths become keys with leading '/'.
+ */
+async function loadFrontend(frontendPath) {
+    // @ts-ignore - Node.js fs/promises
+    const { access } = await import('fs/promises');
+    try {
+        await access(frontendPath);
+    }
+    catch {
+        // Directory doesn't exist, return empty
+        return {};
+    }
+    return readFilesRecursively(frontendPath);
+}
+/**
+ * Loads backend runnables from a directory.
+ * Each subdirectory is a runnable with:
+ * - main.ts or main.py: The code content
+ * - meta.json: Metadata { name, language }
+ */
+async function loadBackend(backendPath) {
+    // @ts-ignore - Node.js fs/promises
+    const { readdir, readFile, access } = await import('fs/promises');
+    // @ts-ignore - Node.js path
+    const { join } = await import('path');
+    try {
+        await access(backendPath);
+    }
+    catch {
+        // Directory doesn't exist, return empty
+        return {};
+    }
+    const result = {};
+    const entries = await readdir(backendPath, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const runnableKey = entry.name;
+        const runnablePath = join(backendPath, entry.name);
+        // Read meta.json
+        const metaPath = join(runnablePath, 'meta.json');
+        let meta;
+        try {
+            const metaContent = await readFile(metaPath, 'utf-8');
+            meta = JSON.parse(metaContent);
+        }
+        catch {
+            console.warn(`Missing or invalid meta.json for runnable '${runnableKey}', skipping`);
+            continue;
+        }
+        // Find and read the main file (main.ts or main.py)
+        const runnableFiles = await readdir(runnablePath);
+        const mainFile = runnableFiles.find((f) => f === 'main.ts' || f === 'main.py');
+        if (!mainFile) {
+            console.warn(`No main.ts or main.py found for runnable '${runnableKey}', skipping`);
+            continue;
+        }
+        const content = await readFile(join(runnablePath, mainFile), 'utf-8');
+        const inlineScript = {
+            language: meta.language,
+            content
+        };
+        result[runnableKey] = {
+            name: meta.name,
+            type: 'inline',
+            inlineScript
+        };
+    }
+    return result;
+}
+/**
+ * Loads an app fixture from a directory structure.
+ *
+ * Expected structure:
+ * ```
+ * fixturePath/
+ * ├── frontend/
+ * │   └── index.tsx           # → frontend["/index.tsx"]
+ * │   └── components/
+ * │       └── Button.tsx      # → frontend["/components/Button.tsx"]
+ * └── backend/
+ *     └── incrementCounter/
+ *         ├── main.ts         # The code content
+ *         └── meta.json       # { "name": "...", "language": "bun" }
+ * ```
+ *
+ * @param fixturePath - Path to the fixture directory
+ * @returns AppFiles object with frontend and backend
+ */
+export async function loadAppFixture(fixturePath) {
+    // @ts-ignore - Node.js path
+    const { join } = await import('path');
+    const frontend = await loadFrontend(join(fixturePath, 'frontend'));
+    const backend = await loadBackend(join(fixturePath, 'backend'));
+    return { frontend, backend };
+}
+/**
+ * Loads an app fixture and returns the separate frontend and backend objects.
+ * Convenience function for use with runAppEval options.
+ */
+export async function loadAppFixtureForEval(fixturePath) {
+    const { frontend, backend } = await loadAppFixture(fixturePath);
+    return {
+        initialFrontend: frontend,
+        initialBackend: backend
+    };
+}

package/package/components/copilot/chat/__tests__/app/appResultsWriter.d.ts

@@ -0,0 +1,30 @@
+import type { AppEvalResult } from './appEvalRunner';
+/**
+ * Parameters for writing app comparison results.
+ */
+export interface WriteAppResultsParams {
+    userPrompt: string;
+    results: AppEvalResult[];
+    outputDir: string;
+}
+/**
+ * Writes app comparison results to a folder-based structure.
+ *
+ * Creates:
+ * ```
+ * results/{timestamp}/
+ * ├── summary.md
+ * └── {variant_name}/
+ *     ├── details.json    # Metadata (toolsCalled, evaluationResult, etc.)
+ *     ├── frontend/       # Frontend files
+ *     │   └── index.tsx
+ *     └── backend/        # Backend runnables
+ *         └── myFunction/
+ *             ├── main.ts
+ *             └── meta.json
+ * ```
+ */
+export declare function writeAppComparisonResultsToFolders(params: WriteAppResultsParams): Promise<{
+    summaryPath: string;
+    variantPaths: string[];
+}>;

package/package/components/copilot/chat/__tests__/app/appResultsWriter.js

@@ -0,0 +1,197 @@
+import { generateTimestamp } from '../shared';
+/**
+ * Writes frontend files to a folder, preserving directory structure.
+ * File paths like "/components/Button.tsx" become "frontend/components/Button.tsx"
+ */
+async function writeFrontendFiles(frontend, frontendPath) {
+    // @ts-ignore - Node.js fs/promises
+    const { writeFile, mkdir } = await import('fs/promises');
+    // @ts-ignore - Node.js path
+    const { join, dirname } = await import('path');
+    for (const [filePath, content] of Object.entries(frontend)) {
+        // Remove leading slash and join with frontend path
+        const relativePath = filePath.startsWith('/') ? filePath.slice(1) : filePath;
+        const fullPath = join(frontendPath, relativePath);
+        // Ensure parent directory exists
+        await mkdir(dirname(fullPath), { recursive: true });
+        await writeFile(fullPath, content);
+    }
+}
+/**
+ * Writes backend runnables to a folder structure.
+ * Each runnable becomes a folder with main.ts/main.py and meta.json
+ */
+async function writeBackendRunnables(backend, backendPath) {
+    // @ts-ignore - Node.js fs/promises
+    const { writeFile, mkdir } = await import('fs/promises');
+    // @ts-ignore - Node.js path
+    const { join } = await import('path');
+    for (const [key, runnable] of Object.entries(backend)) {
+        const runnablePath = join(backendPath, key);
+        await mkdir(runnablePath, { recursive: true });
+        // Write meta.json
+        const meta = {
+            name: runnable.name
+        };
+        if (runnable.type === 'inline' && runnable.inlineScript) {
+            meta.language = runnable.inlineScript.language;
+            // Write main file
+            const extension = runnable.inlineScript.language === 'python3' ? 'py' : 'ts';
+            const mainPath = join(runnablePath, `main.${extension}`);
+            await writeFile(mainPath, runnable.inlineScript.content);
+        }
+        else {
+            // For non-inline runnables, store type and path in meta
+            meta.type = runnable.type;
+            if (runnable.path) {
+                meta.path = runnable.path;
+            }
+        }
+        const metaPath = join(runnablePath, 'meta.json');
+        await writeFile(metaPath, JSON.stringify(meta, null, '\t'));
+    }
+}
+/**
+ * Writes app files (frontend + backend) to a folder structure.
+ */
+async function writeAppToFolder(appFiles, folderPath) {
+    // @ts-ignore - Node.js path
+    const { join } = await import('path');
+    if (Object.keys(appFiles.frontend).length > 0) {
+        await writeFrontendFiles(appFiles.frontend, join(folderPath, 'frontend'));
+    }
+    if (Object.keys(appFiles.backend).length > 0) {
+        await writeBackendRunnables(appFiles.backend, join(folderPath, 'backend'));
+    }
+}
+/**
+ * Writes app comparison results to a folder-based structure.
+ *
+ * Creates:
+ * ```
+ * results/{timestamp}/
+ * ├── summary.md
+ * └── {variant_name}/
+ *     ├── details.json    # Metadata (toolsCalled, evaluationResult, etc.)
+ *     ├── frontend/       # Frontend files
+ *     │   └── index.tsx
+ *     └── backend/        # Backend runnables
+ *         └── myFunction/
+ *             ├── main.ts
+ *             └── meta.json
+ * ```
+ */
+export async function writeAppComparisonResultsToFolders(params) {
+    // @ts-ignore - Node.js fs/promises
+    const { writeFile, mkdir } = await import('fs/promises');
+    // @ts-ignore - Node.js path
+    const { join } = await import('path');
+    const { userPrompt, results, outputDir } = params;
+    const timestamp = generateTimestamp();
+    // Ensure results directory exists
+    await mkdir(outputDir, { recursive: true });
+    const resultFolder = join(outputDir, timestamp);
+    await mkdir(resultFolder, { recursive: true });
+    // Check if any results have evaluation data
+    const hasEvaluation = results.some((r) => r.evaluationResult);
+    // Build summary markdown
+    const summaryLines = [
+        `# App Eval Results - ${timestamp}`,
+        '',
+        '## User Prompt',
+        '```',
+        userPrompt.trim(),
+        '```',
+        '',
+        '## Results',
+        ''
+    ];
+    // Add results table header based on whether evaluation data exists
+    if (hasEvaluation) {
+        summaryLines.push('| Variant | Success | Total Tokens | Tool Calls | Iterations | Resemblance Score |');
+        summaryLines.push('|---------|---------|--------------|------------|------------|-------------------|');
+    }
+    else {
+        summaryLines.push('| Variant | Success | Total Tokens | Tool Calls | Iterations |');
+        summaryLines.push('|---------|---------|--------------|------------|------------|');
+    }
+    for (const result of results) {
+        const baseRow = `| ${result.variantName} | ${result.success} | ${result.tokenUsage.total} | ${result.toolsCalled.length} | ${result.iterations}`;
+        if (hasEvaluation) {
+            const score = result.evaluationResult?.resemblanceScore ?? 'N/A';
+            summaryLines.push(`${baseRow} | ${score} |`);
+        }
+        else {
+            summaryLines.push(`${baseRow} |`);
+        }
+    }
+    // Add evaluation details section if available
+    if (hasEvaluation) {
+        summaryLines.push('');
+        summaryLines.push('## Evaluation Details');
+        summaryLines.push('');
+        for (const result of results) {
+            if (result.evaluationResult) {
+                summaryLines.push(`### ${result.variantName}`);
+                summaryLines.push('');
+                summaryLines.push(`**Score:** ${result.evaluationResult.resemblanceScore}/100`);
+                summaryLines.push('');
+                summaryLines.push(`**Statement:** ${result.evaluationResult.statement}`);
+                summaryLines.push('');
+                if (result.evaluationResult.missingRequirements &&
+                    result.evaluationResult.missingRequirements.length > 0) {
+                    summaryLines.push('**Missing Requirements:**');
+                    for (const req of result.evaluationResult.missingRequirements) {
+                        summaryLines.push(`- ${req}`);
+                    }
+                    summaryLines.push('');
+                }
+                if (result.evaluationResult.error) {
+                    summaryLines.push(`**Error:** ${result.evaluationResult.error}`);
+                    summaryLines.push('');
+                }
+            }
+        }
+    }
+    // Add errors section for failed variants
+    const failedResults = results.filter((r) => !r.success && r.error);
+    if (failedResults.length > 0) {
+        summaryLines.push('');
+        summaryLines.push('## Errors');
+        summaryLines.push('');
+        for (const result of failedResults) {
+            summaryLines.push(`### ${result.variantName}`);
+            summaryLines.push('');
+            summaryLines.push('```');
+            summaryLines.push(result.error);
+            summaryLines.push('```');
+            summaryLines.push('');
+        }
+    }
+    const variantPaths = [];
+    // Write each variant to its own folder
+    for (const result of results) {
+        const variantFolder = join(resultFolder, result.variantName);
+        await mkdir(variantFolder, { recursive: true });
+        variantPaths.push(variantFolder);
+        // Write details.json (metadata without app files)
+        const details = {
+            variantName: result.variantName,
+            success: result.success,
+            error: result.error ?? null,
+            evaluationResult: result.evaluationResult ?? null,
+            toolsCalled: result.toolsCalled,
+            toolCallDetails: result.toolCallDetails,
+            tokenUsage: result.tokenUsage,
+            iterations: result.iterations,
+            messages: result.messages
+        };
+        await writeFile(join(variantFolder, 'details.json'), JSON.stringify(details, null, '\t'));
+        // Write app files to frontend/ and backend/ folders
+        await writeAppToFolder(result.files, variantFolder);
+    }
+    // Write summary markdown file
+    const summaryPath = join(resultFolder, 'summary.md');
+    await writeFile(summaryPath, summaryLines.join('\n'));
+    return { summaryPath, variantPaths };
+}

package/package/components/copilot/chat/__tests__/app/initial/file_manager/backend/createFolder/main.d.ts

@@ -0,0 +1,10 @@
+interface Folder {
+    id: string;
+    name: string;
+    parentId: string | null;
+}
+export declare function main({ name, parentId }: {
+    name: string;
+    parentId: string | null;
+}): Promise<Folder>;
+export {};

package/package/components/copilot/chat/__tests__/app/initial/file_manager/backend/createFolder/main.js

@@ -0,0 +1,9 @@
+export async function main({ name, parentId }) {
+    // In a real implementation, this would create a folder in storage
+    const newFolder = {
+        id: `folder_${Date.now()}`,
+        name,
+        parentId
+    };
+    return newFolder;
+}

package/package/components/copilot/chat/__tests__/app/initial/file_manager/backend/createFolder/meta.json

@@ -0,0 +1,4 @@
+{
+	"name": "Create Folder",
+	"language": "bun"
+}

package/package/components/copilot/chat/__tests__/app/initial/file_manager/backend/deleteItem/main.d.ts

@@ -0,0 +1,6 @@
+export declare function main({ id, type }: {
+    id: string;
+    type: 'file' | 'folder';
+}): Promise<{
+    success: boolean;
+}>;

package/package/components/copilot/chat/__tests__/app/initial/file_manager/backend/deleteItem/main.js

@@ -0,0 +1,5 @@
+export async function main({ id, type }) {
+    // In a real implementation, this would delete from storage
+    console.log(`Deleting ${type} with id: ${id}`);
+    return { success: true };
+}

package/package/components/copilot/chat/__tests__/app/initial/file_manager/backend/deleteItem/meta.json

@@ -0,0 +1,4 @@
+{
+	"name": "Delete Item",
+	"language": "bun"
+}

package/package/components/copilot/chat/__tests__/app/initial/file_manager/backend/listFiles/main.d.ts

@@ -0,0 +1,12 @@
+interface FileItem {
+    id: string;
+    name: string;
+    type: 'file' | 'folder';
+    size?: number;
+    modifiedAt: string;
+    parentId: string | null;
+}
+export declare function main({ folderId }: {
+    folderId: string | null;
+}): Promise<FileItem[]>;
+export {};

package/package/components/copilot/chat/__tests__/app/initial/file_manager/backend/listFiles/main.js

@@ -0,0 +1,14 @@
+// Mock file system data
+const mockFiles = [
+    { id: 'f1', name: 'Documents', type: 'folder', modifiedAt: '2024-01-15', parentId: null },
+    { id: 'f2', name: 'Images', type: 'folder', modifiedAt: '2024-01-10', parentId: null },
+    { id: 'f3', name: 'readme.txt', type: 'file', size: 1024, modifiedAt: '2024-01-20', parentId: null },
+    { id: 'f4', name: 'report.pdf', type: 'file', size: 52400, modifiedAt: '2024-01-18', parentId: 'f1' },
+    { id: 'f5', name: 'notes.txt', type: 'file', size: 256, modifiedAt: '2024-01-12', parentId: 'f1' },
+    { id: 'f6', name: 'photo1.jpg', type: 'file', size: 2048000, modifiedAt: '2024-01-08', parentId: 'f2' },
+    { id: 'f7', name: 'photo2.jpg', type: 'file', size: 1536000, modifiedAt: '2024-01-09', parentId: 'f2' },
+    { id: 'f8', name: 'Projects', type: 'folder', modifiedAt: '2024-01-05', parentId: 'f1' }
+];
+export async function main({ folderId }) {
+    return mockFiles.filter((file) => file.parentId === folderId);
+}

package/package/components/copilot/chat/__tests__/app/initial/file_manager/backend/listFiles/meta.json

@@ -0,0 +1,4 @@
+{
+	"name": "List Files",
+	"language": "bun"
+}

package/package/components/copilot/chat/__tests__/app/initial/file_manager/backend/listFolders/main.d.ts

@@ -0,0 +1,8 @@
+interface Folder {
+    id: string;
+    name: string;
+    parentId: string | null;
+    children: Folder[];
+}
+export declare function main(): Promise<Folder[]>;
+export {};

package/package/components/copilot/chat/__tests__/app/initial/file_manager/backend/listFolders/main.js

@@ -0,0 +1,25 @@
+// Mock folder structure
+const mockFolders = [
+    {
+        id: 'f1',
+        name: 'Documents',
+        parentId: null,
+        children: [
+            {
+                id: 'f8',
+                name: 'Projects',
+                parentId: 'f1',
+                children: []
+            }
+        ]
+    },
+    {
+        id: 'f2',
+        name: 'Images',
+        parentId: null,
+        children: []
+    }
+];
+export async function main() {
+    return mockFolders;
+}

package/package/components/copilot/chat/__tests__/app/initial/file_manager/backend/listFolders/meta.json

@@ -0,0 +1,4 @@
+{
+	"name": "List Folders",
+	"language": "bun"
+}

package/package/components/copilot/chat/__tests__/app/initial/file_manager/backend/moveItem/main.d.ts

@@ -0,0 +1,7 @@
+export declare function main({ id, type, targetFolderId }: {
+    id: string;
+    type: 'file' | 'folder';
+    targetFolderId: string | null;
+}): Promise<{
+    success: boolean;
+}>;

package/package/components/copilot/chat/__tests__/app/initial/file_manager/backend/moveItem/main.js

@@ -0,0 +1,5 @@
+export async function main({ id, type, targetFolderId }) {
+    // In a real implementation, this would move the item in storage
+    console.log(`Moving ${type} ${id} to folder: ${targetFolderId ?? 'root'}`);
+    return { success: true };
+}

package/package/components/copilot/chat/__tests__/app/initial/file_manager/backend/moveItem/meta.json

@@ -0,0 +1,4 @@
+{
+	"name": "Move Item",
+	"language": "bun"
+}

package/package/components/copilot/chat/__tests__/app/initial/file_manager/backend/renameItem/main.d.ts

@@ -0,0 +1,8 @@
+export declare function main({ id, type, newName }: {
+    id: string;
+    type: 'file' | 'folder';
+    newName: string;
+}): Promise<{
+    success: boolean;
+    name: string;
+}>;

package/package/components/copilot/chat/__tests__/app/initial/file_manager/backend/renameItem/main.js

@@ -0,0 +1,5 @@
+export async function main({ id, type, newName }) {
+    // In a real implementation, this would rename in storage
+    console.log(`Renaming ${type} ${id} to: ${newName}`);
+    return { success: true, name: newName };
+}

package/package/components/copilot/chat/__tests__/app/initial/file_manager/backend/renameItem/meta.json

@@ -0,0 +1,4 @@
+{
+	"name": "Rename Item",
+	"language": "bun"
+}

package/package/components/copilot/chat/__tests__/app/initial/file_manager/frontend/components/Breadcrumb.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface BreadcrumbProps {
+    path: {
+        id: string | null;
+        name: string;
+    }[];
+    onNavigate: (folderId: string | null, folderName: string) => void;
+}
+export declare const Breadcrumb: React.FC<BreadcrumbProps>;
+export {};