@lvce-editor/test-worker 14.14.0 → 14.16.0

package/dist/api.d.ts

@@ -101,6 +101,17 @@ export interface MockOpenAiResponseOptions {
 	readonly value: any;
 }
 
+export interface ToolCallItem {
+	readonly toolCall: {
+		readonly arguments: any;
+		readonly name: "list_files";
+	};
+}
+
+export interface TextItem {
+	readonly text: string;
+}
+
 export interface ChatDebugEvent {
 	readonly [key: string]: unknown;
 }
@@ -145,6 +156,8 @@ export interface SelectItem2Options {
 	readonly label: string;
 }
 
+export type MockRequestInput = ToolCallItem | TextItem;
+
 export type ChatDebugInputName = "closeDetails" | "eventCategoryFilter" | "filter" | "showEventStreamFinishedEvents" | "showInputEvents" | "showResponsePartEvents" | "timelineRangePreset" | "useDevtoolsLayout";
 
 export type TokenRow = readonly string[];
@@ -250,6 +263,7 @@ interface Chat {
   readonly mockOpenAiResponse: (options: MockOpenAiResponseOptions) => Promise<void>;
   readonly mockOpenApiRequestGetAll: () => Promise<readonly any[]>;
   readonly mockOpenApiRequestReset: () => Promise<void>;
+  readonly mockOpenApiSetResponse: (items: readonly MockRequestInput[]) => Promise<void>;
   readonly mockOpenApiStreamFinish: () => Promise<void>;
   readonly mockOpenApiStreamPushChunk: (chunk: string) => Promise<void>;
   readonly mockOpenApiStreamReset: () => Promise<void>;
@@ -315,6 +329,7 @@ interface ChatDebug {
   readonly setShowInputEvents: (enabled: boolean) => Promise<void>;
   readonly setShowResponsePartEvents: (enabled: boolean) => Promise<void>;
   readonly setTimelineRangePreset: (value: string) => Promise<void>;
+  readonly shouldHavePayload: (expectedPayload: any) => Promise<void>;
   readonly toggleHeadersSection: (sectionId: string) => Promise<void>;
   readonly useDevtoolsLayout: () => Promise<void>;
 }

package/dist/testWorkerMain.js

@@ -533,7 +533,7 @@ const execute$2 = (command, ...args) => {
 
 const Two$1 = '2.0';
 const callbacks$1 = Object.create(null);
-const get$2 = id => {
+const get$3 = id => {
   return callbacks$1[id];
 };
 const remove$2 = id => {
@@ -682,7 +682,7 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve$1 = (id, response) => {
-  const fn = get$2(id);
+  const fn = get$3(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
@@ -1091,10 +1091,10 @@ const createMockRpc = ({
 };
 
 const rpcs = Object.create(null);
-const set$4 = (id, rpc) => {
+const set$5 = (id, rpc) => {
   rpcs[id] = rpc;
 };
-const get$1 = id => {
+const get$2 = id => {
   return rpcs[id];
 };
 const remove$1 = id => {
@@ -1105,18 +1105,18 @@ const remove$1 = id => {
 const create = rpcId => {
   return {
     async dispose() {
-      const rpc = get$1(rpcId);
+      const rpc = get$2(rpcId);
       await rpc.dispose();
     },
     // @ts-ignore
     invoke(method, ...params) {
-      const rpc = get$1(rpcId);
+      const rpc = get$2(rpcId);
       // @ts-ignore
       return rpc.invoke(method, ...params);
     },
     // @ts-ignore
     invokeAndTransfer(method, ...params) {
-      const rpc = get$1(rpcId);
+      const rpc = get$2(rpcId);
       // @ts-ignore
       return rpc.invokeAndTransfer(method, ...params);
     },
@@ -1124,7 +1124,7 @@ const create = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$4(rpcId, mockRpc);
+      set$5(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove$1(rpcId);
@@ -1133,7 +1133,7 @@ const create = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$4(rpcId, rpc);
+      set$5(rpcId, rpc);
     }
   };
 };
@@ -1152,18 +1152,18 @@ const TestWorker = 9001;
 
 const {
   invoke: invoke$2,
-  set: set$3
+  set: set$4
 } = create(EditorWorker);
 
 const {
   invoke: invoke$1,
-  set: set$2
+  set: set$3
 } = create(OpenerWorker);
 
 const {
   invoke,
   invokeAndTransfer,
-  set: set$1
+  set: set$2
 } = create(RendererWorker);
 const sendMessagePortToEditorWorker = async (port, rpcId) => {
   const command = 'HandleMessagePort.handleMessagePort';
@@ -1188,7 +1188,7 @@ const initializeEditorWorker = async () => {
     commandMap: {},
     send: send$1
   });
-  set$3(rpc);
+  set$4(rpc);
 };
 
 const send = async port => {
@@ -1199,7 +1199,18 @@ const initializeOpenerWorker = async () => {
     commandMap: {},
     send
   });
-  set$2(rpc);
+  set$3(rpc);
+};
+
+let autoFixError;
+const get$1 = () => {
+  return autoFixError;
+};
+const set$1 = value => {
+  autoFixError = value;
+};
+const clear$3 = () => {
+  autoFixError = undefined;
 };
 
 class AssertionError extends Error {
@@ -2060,6 +2071,9 @@ const setShowChatListTime = async showTime => {
 const handleAgentModeChange = async newAgentMode => {
   return invoke('Chat.handleAgentModeChange', newAgentMode);
 };
+const mockOpenApiSetResponse = async items => {
+  return invoke('Chat.mockOpenApiSetResponse', items);
+};
 
 const Chat = {
   chatListFocusFirst,
@@ -2101,6 +2115,7 @@ const Chat = {
   mockOpenAiResponse,
   mockOpenApiRequestGetAll,
   mockOpenApiRequestReset,
+  mockOpenApiSetResponse,
   mockOpenApiStreamFinish,
   mockOpenApiStreamPushChunk,
   mockOpenApiStreamReset,
@@ -2132,6 +2147,26 @@ const Chat = {
   useMockApi
 };
 
+const defaultMessage = 'ChatDebug.shouldHavePayload assertion failed';
+const getMessage = cause => {
+  if (!cause || typeof cause !== 'object') {
+    return defaultMessage;
+  }
+  if ('message' in cause && typeof cause.message === 'string' && cause.message) {
+    return cause.message;
+  }
+  return defaultMessage;
+};
+class ChatDebugShouldHavePayloadError extends Error {
+  constructor(expectedPayload, actualPayload, cause) {
+    super(getMessage(cause));
+    this.name = 'ChatDebugShouldHavePayloadError';
+    this.code = 'chat-debug.should-have-payload';
+    this.expectedPayload = expectedPayload;
+    this.actualPayload = actualPayload;
+  }
+}
+
 const open$a = async sessionId => {
   await invoke('Main.openUri', `chat-debug://${sessionId}`);
 };
@@ -2169,6 +2204,26 @@ const resetIndexedDbSupportForTest = async () => {
 const selectEventRow = async index => {
   await invoke('ChatDebug.handleEventRowClick', String(index));
 };
+const getActualPayload = error => {
+  if (!error || typeof error !== 'object') {
+    return undefined;
+  }
+  if ('actualPayload' in error) {
+    return error.actualPayload;
+  }
+  if ('actual' in error) {
+    return error.actual;
+  }
+  return undefined;
+};
+const shouldHavePayload = async expectedPayload => {
+  try {
+    await invoke('ChatDebug.shouldHavePayload', expectedPayload);
+  } catch (error) {
+    const actualPayload = getActualPayload(error);
+    throw new ChatDebugShouldHavePayloadError(expectedPayload, actualPayload, error);
+  }
+};
 const handleInput$7 = async (name, value, checked) => {
   await invoke('ChatDebug.handleInput', name, value, checked);
 };
@@ -2282,6 +2337,7 @@ const ChatDebug = {
   setShowInputEvents,
   setShowResponsePartEvents,
   setTimelineRangePreset,
+  shouldHavePayload,
   toggleHeadersSection,
   useDevtoolsLayout
 };
@@ -3482,7 +3538,7 @@ const ExtensionSearch = {
 
 const Memfs = 'memfs';
 
-const toFileUrl = url => {
+const toFileUrl$1 = url => {
   const urlObject = new URL(url);
   const pathName = urlObject.pathname;
   if (!pathName.startsWith('/remote')) {
@@ -3506,7 +3562,7 @@ const getDirents = async fileUrl => {
   return allDirents;
 };
 const getFileMapNode = async url => {
-  const fileUrl = toFileUrl(url);
+  const fileUrl = toFileUrl$1(url);
   const allFiles = await getDirents(fileUrl);
   const fileMap = Object.create(null);
   const contents = await Promise.all(allFiles.map(filePath => {
@@ -4842,6 +4898,19 @@ const executeTest2 = async (name, fn, globals, timestampGenerator) => {
   const duration = end - start;
   const formattedDuration = formatDuration(duration);
   if (error) {
+    const isChatDebugPayloadError = error instanceof ChatDebugShouldHavePayloadError && error.actualPayload !== undefined;
+    const autoFixProperties = isChatDebugPayloadError ? {
+      autoFixError: {
+        actualPayload: error.actualPayload,
+        code: error.code,
+        expectedPayload: error.expectedPayload
+      },
+      overlayActions: [{
+        command: 'Test.tryAutoFix',
+        id: 'chat-debug-should-have-payload-autofix',
+        label: 'Autofix'
+      }]
+    } : {};
     return {
       background: 'red',
       duration,
@@ -4849,6 +4918,7 @@ const executeTest2 = async (name, fn, globals, timestampGenerator) => {
       error,
       formattedDuration,
       name,
+      ...autoFixProperties,
       start,
       text: `test failed: ${error}`,
       type: Fail
@@ -4886,18 +4956,25 @@ const now = () => {
 
 const executeTest = async (name, fn, globals = {}) => {
   const {
+    autoFixError,
     background,
     error,
     formattedDuration,
+    overlayActions,
     text,
     type
   } = await executeTest2(name, fn, globals, now);
+  set$1(autoFixError);
   if (error) {
     await printTestError(error);
   } else {
     // eslint-disable-next-line no-console
     console.info(`PASS ${name} in ${formattedDuration}`);
   }
+  if (overlayActions && overlayActions.length > 0) {
+    await invoke('TestFrameWork.showOverlay', type, background, text, overlayActions);
+    return;
+  }
   await invoke('TestFrameWork.showOverlay', type, background, text);
 };
 
@@ -4989,6 +5066,7 @@ const execute = async (href, platform, assetDir) => {
     }
     // TODO maybe setup file watcher earlier, to not miss events?
   } catch (error) {
+    clear$3();
     await printTestError(error);
     await invoke('TestFrameWork.showOverlay', Fail, 'red', `test failed: ${error}`);
     return;
@@ -5073,17 +5151,152 @@ const handleFileWatcherEvent = async event => {
   await hotReloadTest(lastItem, locationHref, time);
 };
 
+const whitespaceRegex = /\s+/g;
+const shouldHavePayloadRegex = /shouldHavePayload\(([^)]*)\)/gs;
+const normalizeWhitespace = value => {
+  return value.replaceAll(whitespaceRegex, '');
+};
+const trySerialize = value => {
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return undefined;
+  }
+};
+const replaceMatch = (fileContent, index, length, replacement) => {
+  const before = fileContent.slice(0, index);
+  const after = fileContent.slice(index + length);
+  return `${before}${replacement}${after}`;
+};
+const replaceShouldHavePayload = (fileContent, expectedPayload, actualPayload) => {
+  const serializedActual = trySerialize(actualPayload);
+  if (!serializedActual) {
+    return undefined;
+  }
+  const matches = [...fileContent.matchAll(shouldHavePayloadRegex)];
+  if (matches.length === 0) {
+    return undefined;
+  }
+  if (matches.length === 1) {
+    const [match] = matches;
+    if (typeof match.index !== 'number') {
+      return undefined;
+    }
+    return replaceMatch(fileContent, match.index, match[0].length, `shouldHavePayload(${serializedActual})`);
+  }
+  const serializedExpected = trySerialize(expectedPayload);
+  if (!serializedExpected) {
+    return undefined;
+  }
+  const normalizedExpected = normalizeWhitespace(serializedExpected);
+  const matchingCandidates = [];
+  for (const match of matches) {
+    const currentArgument = match[1];
+    if (normalizeWhitespace(currentArgument) === normalizedExpected) {
+      matchingCandidates.push(match);
+    }
+  }
+  if (matchingCandidates.length !== 1) {
+    return undefined;
+  }
+  const [candidate] = matchingCandidates;
+  if (typeof candidate.index !== 'number') {
+    return undefined;
+  }
+  return replaceMatch(fileContent, candidate.index, candidate[0].length, `shouldHavePayload(${serializedActual})`);
+};
+const getFileUrlFromRemotePath = rawPathName => {
+  if (!rawPathName.startsWith('/remote')) {
+    return undefined;
+  }
+  const rest = rawPathName.slice('/remote'.length);
+  return `file://${rest}`;
+};
+const toFileUrl = (url, locationHref) => {
+  const parsedUrl = new URL(url, locationHref);
+  if (parsedUrl.protocol === 'file:') {
+    parsedUrl.hash = '';
+    parsedUrl.search = '';
+    return parsedUrl.toString();
+  }
+  return getFileUrlFromRemotePath(parsedUrl.pathname);
+};
+const isAutoFixError = value => {
+  if (!value) {
+    return false;
+  }
+  return value.code === 'chat-debug.should-have-payload';
+};
+const defaultDependencies = {
+  getAutoFixError() {
+    return get$1();
+  },
+  getLatestTestInfo() {
+    return maybeLast();
+  },
+  getLocationHref() {
+    return location.href;
+  },
+  now: Date.now,
+  readFile(uri) {
+    return readFile(uri);
+  },
+  rerun(url, platform, assetDir) {
+    return execute(url, platform, assetDir);
+  },
+  setAutoFixError(value) {
+    set$1(value);
+  },
+  writeFile(uri, content) {
+    return writeFile(uri, content);
+  }
+};
+const tryAutoFixWith = async dependencies => {
+  const latestTestInfo = dependencies.getLatestTestInfo();
+  if (!latestTestInfo) {
+    return;
+  }
+  if (latestTestInfo.inProgress) {
+    return;
+  }
+  const autoFixError = dependencies.getAutoFixError();
+  if (!isAutoFixError(autoFixError)) {
+    return;
+  }
+  if (autoFixError.actualPayload === undefined) {
+    return;
+  }
+  const locationHref = dependencies.getLocationHref();
+  const fileUrl = toFileUrl(latestTestInfo.url, locationHref);
+  if (!fileUrl) {
+    return;
+  }
+  const fileContent = await dependencies.readFile(fileUrl);
+  const updatedFileContent = replaceShouldHavePayload(fileContent, autoFixError.expectedPayload, autoFixError.actualPayload);
+  if (!updatedFileContent || updatedFileContent === fileContent) {
+    return;
+  }
+  await dependencies.writeFile(fileUrl, updatedFileContent);
+  dependencies.setAutoFixError(undefined);
+  const rerunUrl = createUrlWithQueryParameter(latestTestInfo.url, locationHref, dependencies.now());
+  await dependencies.rerun(rerunUrl, latestTestInfo.platform, latestTestInfo.assetDir);
+};
+const tryAutoFix = async () => {
+  await tryAutoFixWith(defaultDependencies);
+};
+
 const commandMap = {
   'FileWatcher.handleEvent': handleFileWatcherEvent,
   'Test.execute': execute,
-  'Test.executeMock': executeMock
+  'Test.executeMock': executeMock,
+  'Test.tryAutoFix': tryAutoFix
 };
 
 const initializeRendererWorker = async () => {
   const rpc = await create$1({
     commandMap: commandMap
   });
-  set$1(rpc);
+  set$2(rpc);
 };
 
 const listen = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/test-worker",
-  "version": "14.14.0",
+  "version": "14.16.0",
   "description": "Test Worker",
   "repository": {
     "type": "git",