@cardstack/boxel-cli 0.3.2-unstable.58 → 0.3.2-unstable.60

package/bundled-test-harness/assets/skills-test-DlMgZrPV.js

@@ -0,0 +1,568 @@
+import { s as __toESM } from "./chunk-CGdGNDIi.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime-CYyqkz5q-z3Y1hsJm.js";
+import { Mi as skillCardRef, On as APP_BOXEL_MESSAGE_MSGTYPE, Pn as APP_BOXEL_ROOM_SKILLS_EVENT_TYPE, Zn as testRealmURL, di as SEARCH_MARKER, fi as SEPARATOR_MARKER, li as REPLACE_MARKER, ua as rri, vi as baseRealm, yn as APP_BOXEL_COMMAND_REQUESTS_KEY } from "./runtime-common-C7uLt5dN.js";
+import { $n as setComponentTemplate } from "./service-DJ87xpDt.js";
+import { V as templateFactory } from "./index-DaCZcoCY-D2gI_aMw.js";
+import { i as envSkillId } from "./utils-C7xS5xXC.js";
+import { o as Component } from "./dist-CXaz7pMY.js";
+import "./template-D3TMIrc1.js";
+import "./template-factory-DMEv2kVd.js";
+import { t as OperatorModeContainer } from "./container-C8gu0I0Q.js";
+import { A as settled, I as waitUntil, d as click, o as waitFor, s as fillIn } from "./dist-D1U_uSwt.js";
+import { t as require_qunit } from "./qunit-Cqwmt9Vl.js";
+import { r as getService } from "./dist-CY3T64Hs.js";
+import { A as setupIntegrationTestRealm, E as setMonacoContent, M as setupOnSave, O as setupCardLogs, b as getMonacoContent, et as setupOperatorModeStateCleanup, j as setupLocalIndexing, o as addSkillToAiAssistant, rt as setupRenderingTest, t as setupMockMatrix, w as realmConfigCardJSON } from "./mock-matrix-BhFWlMMr.js";
+import { G as contains, I as StringField, Q as field, a as CardDef, b as FieldDef, d as Component$1, lt as linksTo, mt as setupBaseRealm, s as CardsGrid, ut as linksToMany } from "./base-realm-DpSTsZxD.js";
+import { n as renderComponent } from "./render-component-Bs21y6iv.js";
+//#region tests/integration/components/ai-assistant-panel/skills-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+(0, import_qunit.module)("Integration | ai-assistant-panel | skills", function(hooks) {
+	const realmName = "Operator Mode Workspace";
+	let loader;
+	let operatorModeStateService;
+	setupRenderingTest(hooks);
+	setupOperatorModeStateCleanup(hooks);
+	setupBaseRealm(hooks);
+	hooks.beforeEach(function() {
+		loader = getService("loader-service").loader;
+	});
+	setupLocalIndexing(hooks);
+	setupOnSave(hooks);
+	setupCardLogs(hooks, async () => await loader.import(`${baseRealm.url}card-api`));
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: true,
+		now: (() => {
+			let clock = new Date(2024, 8, 19).getTime();
+			return () => clock += 10;
+		})()
+	});
+	let { getRoomState, getRoomEvents, simulateRemoteMessage } = mockMatrixUtils;
+	let noop = () => {};
+	hooks.beforeEach(async function() {
+		operatorModeStateService = getService("operator-mode-state-service");
+		class Pet extends CardDef {
+			static displayName = "Pet";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
+					return contains(StringField, { computeVia: function() {
+						return this.name;
+					} });
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+			static fitted = class Fitted extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "2co+OexH",
+						"block": "[[[10,\"h3\"],[15,\"data-test-pet\",[30,1,[\"name\"]]],[12],[1,\"\\n  \"],[8,[30,2,[\"name\"]],null,null,null],[1,\"\\n\"],[13]],[\"@model\",\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/skills-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		class Address extends FieldDef {
+			static displayName = "Address";
+			static {
+				decorateFieldV2(this.prototype, "city", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#city = (initializeDeferredDecorator(this, "city"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "country", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#country = (initializeDeferredDecorator(this, "country"), void 0);
+			static embedded = class Embedded extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "z7D7BuBa",
+						"block": "[[[10,0],[14,\"data-test-address\",\"\"],[12],[1,\"\\n  \"],[10,\"h3\"],[15,\"data-test-city\",[30,1,[\"city\"]]],[12],[1,\"\\n    \"],[8,[30,2,[\"city\"]],null,null,null],[1,\"\\n  \"],[13],[1,\"\\n  \"],[10,\"h3\"],[15,\"data-test-country\",[30,1,[\"country\"]]],[12],[1,\"\\n    \"],[8,[30,2,[\"country\"]],null,null,null],[1,\"\\n  \"],[13],[1,\"\\n\"],[13]],[\"@model\",\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/skills-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		class Person extends CardDef {
+			static displayName = "Person";
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "pet", [field], function() {
+					return linksTo(Pet);
+				});
+			}
+			#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "friends", [field], function() {
+					return linksToMany(Pet);
+				});
+			}
+			#friends = (initializeDeferredDecorator(this, "friends"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "firstLetterOfTheName", [field], function() {
+					return contains(StringField, { computeVia: function() {
+						return this.firstName[0];
+					} });
+				});
+			}
+			#firstLetterOfTheName = (initializeDeferredDecorator(this, "firstLetterOfTheName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
+					return contains(StringField, { computeVia: function() {
+						return this.firstName;
+					} });
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "address", [field], function() {
+					return contains(Address);
+				});
+			}
+			#address = (initializeDeferredDecorator(this, "address"), void 0);
+			static isolated = class Isolated extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "fzep1f1m",
+						"block": "[[[10,\"h2\"],[15,\"data-test-person\",[30,1,[\"firstName\"]]],[12],[1,\"\\n  \"],[8,[30,2,[\"firstName\"]],null,null,null],[1,\"\\n\"],[13],[1,\"\\n\"],[10,2],[15,\"data-test-first-letter-of-the-name\",[30,1,[\"firstLetterOfTheName\"]]],[12],[1,\"\\n  \"],[8,[30,2,[\"firstLetterOfTheName\"]],null,null,null],[1,\"\\n\"],[13],[1,\"\\nPet:\\n\"],[8,[30,2,[\"pet\"]],null,null,null],[1,\"\\nFriends:\\n\"],[8,[30,2,[\"friends\"]],null,null,null],[1,\"\\n\"],[10,0],[14,\"data-test-addresses\",\"\"],[12],[1,\"Address: \"],[8,[30,2,[\"address\"]],null,null,null],[13]],[\"@model\",\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/skills-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		let petMango = new Pet({ name: "Mango" });
+		await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"pet.gts": { Pet },
+				"address.gts": { Address },
+				"person.gts": { Person },
+				"Pet/mango.json": petMango,
+				"Person/fadhlan.json": new Person({
+					firstName: "Fadhlan",
+					address: new Address({
+						city: "Bandung",
+						country: "Indonesia"
+					}),
+					pet: petMango
+				}),
+				"search-and-open-card-command.ts": `
+            import { Command } from '@cardstack/runtime-common';
+            import { SearchCardsByTypeAndTitleCommand } from '@cardstack/boxel-host/commands/search-cards';
+            import ShowCardCommand from '@cardstack/boxel-host/commands/show-card';
+            import type { SearchCardsByTypeAndTitleInput } from 'https://cardstack.com/base/commands/search-card-result';
+
+            export default class SearchAndOpenCardCommand extends Command<
+              typeof SearchCardsByTypeAndTitleInput,
+              undefined
+            > {
+              static displayName = 'SearchAndOpenCardCommand';
+              static actionVerb = 'Search';
+              async getInputType() {
+                return new SearchCardsByTypeAndTitleCommand(
+                  this.commandContext,
+                ).getInputType();
+              }
+              protected async run(
+                input: SearchCardsByTitleInput,
+              ): Promise<undefined> {
+                let searchCommand = new SearchCardsByTypeAndTitleCommand(
+                  this.commandContext,
+                );
+                let searchResult = await searchCommand.execute(input);
+                if (searchResult.cardIds.length > 0) {
+                  let showCardCommand = new ShowCardCommand(this.commandContext);
+                  await showCardCommand.execute({
+                    cardId: searchResult.cardIds[0],
+                  });
+                }
+                return undefined;
+              }
+            }
+        `,
+				"placeholder-command.ts": `
+            import { Command } from '@cardstack/runtime-common';
+
+            export default class PlaceholderCommand extends Command<undefined, undefined> {
+              static displayName = 'PlaceholderCommand';
+              static actionVerb = 'Placeholder';
+              async getInputType() {
+                return undefined;
+              }
+              protected async run(): Promise<undefined> {
+                return undefined;
+              }
+            }
+        `,
+				"Skill/example.json": { data: {
+					attributes: {
+						cardTitle: "Exanple Skill",
+						cardDescription: "This skill card is for testing purposes",
+						instructions: "This is an example skill card",
+						commands: [{
+							codeRef: {
+								name: "default",
+								module: `${testRealmURL}search-and-open-card-command`
+							},
+							requiresApproval: true
+						}]
+					},
+					meta: { adoptsFrom: skillCardRef }
+				} },
+				"Skill/example2.json": { data: {
+					attributes: {
+						cardTitle: "Exanple 2 Skill",
+						cardDescription: "This skill card is also for testing purposes",
+						instructions: "This is a second example skill card",
+						commands: [{
+							codeRef: {
+								name: "default",
+								module: `${testRealmURL}search-and-open-card-command`
+							},
+							requiresApproval: true
+						}, {
+							codeRef: {
+								name: "default",
+								module: `${testRealmURL}placeholder-command`
+							},
+							requiresApproval: true
+						}]
+					},
+					meta: { adoptsFrom: skillCardRef }
+				} },
+				"hello.txt": "Hello, world!",
+				"index.json": new CardsGrid(),
+				"realm.json": realmConfigCardJSON({ name: realmName })
+			}
+		});
+	});
+	async function renderAiAssistantPanel(id) {
+		operatorModeStateService.restore({
+			stacks: id ? [[{
+				id,
+				format: "isolated"
+			}]] : [[]],
+			aiAssistantOpen: true
+		});
+		await renderComponent(class TestDriver extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "CRRkP+iR",
+					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/ai-assistant-panel/skills-test.gts",
+					"scope": () => [OperatorModeContainer, noop],
+					"isStrictMode": true
+				}), this);
+			}
+		});
+		await waitFor("[data-test-room-settled]");
+		await waitUntil(() => document.querySelector("[data-test-active-skills-count]")?.textContent?.trim() === "1 Skill", {
+			timeout: 5e3,
+			timeoutMessage: "Timed out waiting for env skill to be active"
+		});
+		let roomId = document.querySelector("[data-test-room]")?.getAttribute("data-test-room");
+		if (!roomId) throw new Error("Expected a room ID");
+		return roomId;
+	}
+	(0, import_qunit.test)("same skill card added twice with no changes results in no-op", async function(assert) {
+		const roomId = await renderAiAssistantPanel(`${testRealmURL}Person/fadhlan`);
+		assert.dom("[data-test-active-skills-count]").containsText("1 Skill");
+		await click("[data-test-skill-menu][data-test-pill-menu-button]");
+		assert.dom("[data-test-skill-menu]").containsText("Skills: 1 of 1 active");
+		await addSkillToAiAssistant(`${testRealmURL}Skill/example`);
+		await waitUntil(() => document.querySelector("[data-test-skill-menu]")?.textContent?.includes("Skills: 2 of 2 active"));
+		assert.dom("[data-test-skill-menu]").containsText("Skills: 2 of 2 active");
+		const initialRoomStateSkillsJson = getRoomState(roomId, APP_BOXEL_ROOM_SKILLS_EVENT_TYPE);
+		await click("[data-test-attach-button]");
+		await click("[data-test-attach-card-btn]");
+		await click("[data-test-card-catalog-item=\"http://test-realm/test/Skill/example\"]");
+		await click("[data-test-card-catalog-go-button]");
+		await click("[data-test-attached-card=\"http://test-realm/test/Person/fadhlan\"] [data-test-remove-card-btn]");
+		await click("[data-test-send-message-btn]");
+		const finalRoomStateSkillsJson = getRoomState(roomId, APP_BOXEL_ROOM_SKILLS_EVENT_TYPE);
+		assert.deepEqual(finalRoomStateSkillsJson.enabledSkillCards.map((c) => c.sourceUrl), initialRoomStateSkillsJson.enabledSkillCards.map((c) => c.sourceUrl), "enabled skill cards have not changed");
+		assert.deepEqual(finalRoomStateSkillsJson.disabledSkillCards, initialRoomStateSkillsJson.disabledSkillCards, "disabled skill cards have not changed");
+		assert.deepEqual(finalRoomStateSkillsJson.commandDefinitions.map((c) => c.sourceUrl), initialRoomStateSkillsJson.commandDefinitions.map((c) => c.sourceUrl), "command definitions have not changed");
+	});
+	(0, import_qunit.test)("skill picker can add a skill through the UI", async function(assert) {
+		const roomId = await renderAiAssistantPanel();
+		let skillId = `${testRealmURL}Skill/example`;
+		await click("[data-test-skill-menu][data-test-pill-menu-button]");
+		await waitFor("[data-test-skill-menu] [data-test-pill-menu-add-button]");
+		await click("[data-test-skill-menu] [data-test-pill-menu-add-button]");
+		await waitFor(`[data-test-card-catalog-item="${skillId}"]`);
+		await click(`[data-test-card-catalog-item="${skillId}"]`);
+		await click("[data-test-card-catalog-go-button]");
+		await waitUntil(() => Boolean(getRoomState(roomId, APP_BOXEL_ROOM_SKILLS_EVENT_TYPE)?.enabledSkillCards?.some((card) => card.sourceUrl === skillId)), {
+			timeout: 5e3,
+			timeoutMessage: `timed out waiting for ${skillId} to be enabled`
+		});
+		await click("[data-test-skill-menu]");
+		assert.dom(`[data-test-skill-options-button="${skillId}"]`).exists("selected skill is shown in the skill menu");
+		assert.dom("[data-test-skill-menu]").containsText("Skills: 2 of 2 active");
+	});
+	(0, import_qunit.test)("skill picker excludes already-enabled skills", async function(assert) {
+		await renderAiAssistantPanel();
+		let enabledSkillId = `${testRealmURL}Skill/example`;
+		let availableSkillId = `${testRealmURL}Skill/example2`;
+		await addSkillToAiAssistant(enabledSkillId);
+		if (!document.querySelector("[data-test-skill-menu] [data-test-pill-menu-add-button]")) await click("[data-test-skill-menu][data-test-pill-menu-button]");
+		await waitFor("[data-test-skill-menu] [data-test-pill-menu-add-button]");
+		await click("[data-test-skill-menu] [data-test-pill-menu-add-button]");
+		await fillIn("[data-test-search-field]", "Exanple");
+		await waitFor(`[data-test-card-catalog-item="${availableSkillId}"]`);
+		assert.dom(`[data-test-card-catalog-item="${enabledSkillId}"]`).doesNotExist("already-enabled skill is excluded from the picker");
+		assert.dom(`[data-test-card-catalog-item="${availableSkillId}"]`).exists("a different skill remains available in the picker");
+	});
+	(0, import_qunit.test)("skill pill menu opens the skill card", async function(assert) {
+		await renderAiAssistantPanel();
+		let skillId = rri(`${testRealmURL}Skill/example`);
+		await addSkillToAiAssistant(skillId);
+		assert.false(operatorModeStateService.getOpenCardIds().includes(skillId), "skill card is not open before using the menu");
+		await click("[data-test-skill-menu]");
+		await click(`[data-test-skill-options-button="${skillId}"]`);
+		await waitFor("[data-test-boxel-menu-item-text=\"Open Skill Card\"]");
+		await click("[data-test-boxel-menu-item-text=\"Open Skill Card\"]");
+		await waitUntil(() => operatorModeStateService.getOpenCardIds().includes(skillId));
+		assert.true(operatorModeStateService.getOpenCardIds().includes(skillId), "skill card is opened in operator mode");
+	});
+	(0, import_qunit.test)("skill pill menu opens the skill card while in code mode", async function(assert) {
+		await renderAiAssistantPanel(`${testRealmURL}Skill/example`);
+		let skillId = `${testRealmURL}Skill/example`;
+		await addSkillToAiAssistant(skillId);
+		await click("[data-test-submode-switcher] button");
+		await click("[data-test-boxel-menu-item-text=\"Code\"]");
+		await click("[data-test-skill-menu]");
+		let initialCodePath = operatorModeStateService.codePathString;
+		await click(`[data-test-skill-options-button="${skillId}"]`);
+		await waitFor("[data-test-boxel-menu-item-text=\"Open Skill Card\"]");
+		await click("[data-test-boxel-menu-item-text=\"Open Skill Card\"]");
+		await waitUntil(() => operatorModeStateService.codePathString && operatorModeStateService.codePathString !== initialCodePath && operatorModeStateService.codePathString.includes("skill"), { timeoutMessage: "timed out waiting for code mode to open skill card" });
+		assert.ok(operatorModeStateService.codePathString?.includes("skill"), "skill definition is opened in code mode");
+	});
+	(0, import_qunit.test)("ensures command definitions are reuploaded only when content changes (different rooms)", async function(assert) {
+		const roomId1 = await renderAiAssistantPanel(`${testRealmURL}Skill/example`);
+		const skillId = `${testRealmURL}Skill/example`;
+		await addSkillToAiAssistant(skillId);
+		await fillIn("[data-test-boxel-input-id=\"ai-chat-input\"]", "Upload the skill cards and command definitions");
+		await click("[data-test-send-message-btn]");
+		const room1StateSkillsJson = getRoomState(roomId1, APP_BOXEL_ROOM_SKILLS_EVENT_TYPE);
+		await click("[data-test-create-room-btn]");
+		await waitFor("[data-test-room-settled]");
+		const roomId2 = document.querySelector("[data-test-room]")?.getAttribute("data-test-room");
+		if (!roomId2) throw new Error("Expected a room ID");
+		await addSkillToAiAssistant(skillId);
+		await fillIn("[data-test-boxel-input-id=\"ai-chat-input\"]", "Use the previous command definition");
+		await click("[data-test-send-message-btn]");
+		const room2StateSkillsJson = getRoomState(roomId2, APP_BOXEL_ROOM_SKILLS_EVENT_TYPE);
+		assert.ok(room1StateSkillsJson.commandDefinitions?.length > 0, "first room has command definitions");
+		assert.ok(room2StateSkillsJson.commandDefinitions?.length > 0, "second room has command definitions");
+		assert.deepEqual(room1StateSkillsJson.commandDefinitions, room2StateSkillsJson.commandDefinitions, "command definitions are the same between rooms when content hasn't changed");
+		await click("[data-test-submode-switcher] button");
+		await click("[data-test-boxel-menu-item-text=\"Code\"]");
+		await click("[data-test-file-browser-toggle]");
+		await click("[data-test-file=\"search-and-open-card-command.ts\"]");
+		setMonacoContent(getMonacoContent().replace(`static displayName = 'SearchAndOpenCardCommand';`, `static displayName = 'SearchAndOpenCardCommand';\ndescription = 'Search for a card, and then open it in interact mode';`));
+		await settled();
+		await click("[data-test-submode-switcher] button");
+		await click("[data-test-boxel-menu-item-text=\"Interact\"]");
+		await click("[data-test-create-room-btn]");
+		await waitFor("[data-test-room-settled]");
+		const roomId3 = document.querySelector("[data-test-room]")?.getAttribute("data-test-room");
+		if (!roomId3) throw new Error("Expected a room ID");
+		await addSkillToAiAssistant(skillId);
+		await fillIn("[data-test-boxel-input-id=\"ai-chat-input\"]", "Change the command");
+		await click("[data-test-send-message-btn]");
+		const room3StateSkillsJson = getRoomState(roomId3, APP_BOXEL_ROOM_SKILLS_EVENT_TYPE);
+		assert.notDeepEqual(room2StateSkillsJson.commandDefinitions, room3StateSkillsJson.commandDefinitions, "command definitions are different after content change");
+		const room2CommandUrls = room2StateSkillsJson.commandDefinitions.map((cmd) => cmd.url);
+		const room3CommandUrls = room3StateSkillsJson.commandDefinitions.map((cmd) => cmd.url);
+		const room2CommandSourceUrls = room2StateSkillsJson.commandDefinitions.map((cmd) => cmd.sourceUrl);
+		const room3CommandSourceUrls = room3StateSkillsJson.commandDefinitions.map((cmd) => cmd.sourceUrl);
+		const room2CommandHashes = room2StateSkillsJson.commandDefinitions.map((cmd) => cmd.contentHash);
+		const room3CommandHashes = room3StateSkillsJson.commandDefinitions.map((cmd) => cmd.contentHash);
+		assert.notDeepEqual(room2CommandUrls, room3CommandUrls, "command definition URLs are different after content change");
+		assert.deepEqual(room2CommandSourceUrls, room3CommandSourceUrls, "command definition source URLs are the same between rooms");
+		assert.notDeepEqual(room2CommandHashes, room3CommandHashes, "command definition hashes are different after content change");
+	});
+	(0, import_qunit.skip)("ensures command definitions are reuploaded only when content changes (same room)", async function(assert) {
+		const roomId1 = await renderAiAssistantPanel(`${testRealmURL}Skill/example`);
+		await waitFor("[data-test-room-settled]");
+		assert.dom("[data-test-active-skills-count]").containsText("1 Skill");
+		await click("[data-test-skill-menu][data-test-pill-menu-button]");
+		assert.dom("[data-test-skill-menu]").containsText("Skills: 1 of 1 active");
+		await addSkillToAiAssistant(`${testRealmURL}Skill/example`);
+		await fillIn("[data-test-boxel-input-id=\"ai-chat-input\"]", "Upload the skill cards and command definitions");
+		await click("[data-test-send-message-btn]");
+		const room1State1SkillsJson = getRoomState(roomId1, APP_BOXEL_ROOM_SKILLS_EVENT_TYPE);
+		await click("[data-test-submode-switcher] button");
+		await click("[data-test-boxel-menu-item-text=\"Code\"]");
+		await click("[data-test-file-browser-toggle]");
+		await click("[data-test-file=\"search-and-open-card-command.ts\"]");
+		setMonacoContent(getMonacoContent().replace(`static displayName = 'SearchAndOpenCardCommand';`, `static displayName = 'SearchAndOpenCardCommand';\ndescription = 'Search for a card, and then open it in interact mode';`));
+		await settled();
+		await click("[data-test-submode-switcher] button");
+		await click("[data-test-boxel-menu-item-text=\"Interact\"]");
+		await fillIn("[data-test-boxel-input-id=\"ai-chat-input\"]", "Hey, I updated the command");
+		let room1EventsCount = getRoomEvents(roomId1).length;
+		await click("[data-test-send-message-btn]");
+		await waitUntil(() => getRoomEvents(roomId1).length > room1EventsCount, { timeoutMessage: "timed out waiting for room events to increase" });
+		const room1State2SkillsJson = getRoomState(roomId1, APP_BOXEL_ROOM_SKILLS_EVENT_TYPE);
+		assert.notDeepEqual(room1State1SkillsJson.commandDefinitions, room1State2SkillsJson.commandDefinitions, "command definitions are different after content change");
+		const room1State1CommandUrls = room1State1SkillsJson.commandDefinitions.map((cmd) => cmd.url);
+		const room1State2CommandUrls = room1State2SkillsJson.commandDefinitions.map((cmd) => cmd.url);
+		const room1State1CommandSourceUrls = room1State1SkillsJson.commandDefinitions.map((cmd) => cmd.sourceUrl);
+		const room1State2CommandSourceUrls = room1State2SkillsJson.commandDefinitions.map((cmd) => cmd.sourceUrl);
+		const room1State1CommandHashes = room1State1SkillsJson.commandDefinitions.map((cmd) => cmd.contentHash);
+		const room1State2CommandHashes = room1State2SkillsJson.commandDefinitions.map((cmd) => cmd.contentHash);
+		assert.notDeepEqual(room1State1CommandUrls, room1State2CommandUrls, "command definition URLs are different after content change");
+		assert.deepEqual(room1State1CommandSourceUrls, room1State2CommandSourceUrls, "command definition source URLs are the same between rooms");
+		assert.notDeepEqual(room1State1CommandHashes, room1State2CommandHashes, "command definition hashes are different after content change");
+	});
+	(0, import_qunit.test)("updated skill card instructions result in new event and updated room state when sending message", async function(assert) {
+		const roomId = await renderAiAssistantPanel(`${testRealmURL}Skill/example`);
+		await addSkillToAiAssistant(`${testRealmURL}Skill/example`);
+		const initialRoomStateSkillsJson = getRoomState(roomId, APP_BOXEL_ROOM_SKILLS_EVENT_TYPE);
+		await click("[data-test-edit-button]");
+		await fillIn("[data-test-field=\"instructions\"] textarea", "Updated instructions");
+		await click("[data-test-edit-button]");
+		await click("[data-test-close-button]");
+		await fillIn("[data-test-boxel-input-id=\"ai-chat-input\"]", "This message should trigger uploading the updated");
+		await click("[data-test-send-message-btn]");
+		const finalRoomStateSkillsJson = getRoomState(roomId, APP_BOXEL_ROOM_SKILLS_EVENT_TYPE);
+		assert.notDeepEqual(finalRoomStateSkillsJson, initialRoomStateSkillsJson, "room state has changed");
+		assert.strictEqual(finalRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl === envSkillId).sourceUrl, initialRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl === envSkillId).sourceUrl, "unchanged skill card is still present");
+		assert.notStrictEqual(finalRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl.endsWith("example")).contentHash, initialRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl.endsWith("example")).contentHash, "skill card instructions have changed");
+		assert.notStrictEqual(finalRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl.endsWith("example")).url, initialRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl.endsWith("example")).url, "skill card instructions have changed");
+		assert.strictEqual(finalRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl.endsWith("example")).sourceUrl, initialRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl.endsWith("example")).sourceUrl, "skill card source URL has not changed");
+	});
+	(0, import_qunit.test)("updated skill card instructions result in new event and updated room state when command is completing", async function(assert) {
+		const roomId = await renderAiAssistantPanel(`${testRealmURL}Skill/example`);
+		await addSkillToAiAssistant(`${testRealmURL}Skill/example`);
+		const initialRoomStateSkillsJson = getRoomState(roomId, APP_BOXEL_ROOM_SKILLS_EVENT_TYPE);
+		await click("[data-test-edit-button]");
+		await fillIn("[data-test-field=\"instructions\"] textarea", "Updated instructions");
+		await click("[data-test-edit-button]");
+		await click("[data-test-close-button]");
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			body: "",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_COMMAND_REQUESTS_KEY]: [{
+				id: "721c8c78-d8c1-4cc1-a7e9-51d2d3143e4d",
+				name: "SearchCardsByTypeAndTitleCommand_a959",
+				arguments: JSON.stringify({ attributes: {
+					cardDescription: "Searching for card",
+					type: {
+						module: `${testRealmURL}person`,
+						name: "Person"
+					}
+				} })
+			}]
+		});
+		await settled();
+		await waitFor("[data-test-message-idx=\"0\"] [data-test-command-apply]");
+		await click("[data-test-message-idx=\"0\"] [data-test-command-apply]");
+		const finalRoomStateSkillsJson = getRoomState(roomId, APP_BOXEL_ROOM_SKILLS_EVENT_TYPE);
+		assert.notDeepEqual(finalRoomStateSkillsJson, initialRoomStateSkillsJson, "room state has changed");
+		assert.strictEqual(finalRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl === envSkillId).sourceUrl, initialRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl === envSkillId).sourceUrl, "unchanged skill card is still present");
+		assert.notStrictEqual(finalRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl.endsWith("example")).contentHash, initialRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl.endsWith("example")).contentHash, "skill card instructions have changed");
+		assert.notStrictEqual(finalRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl.endsWith("example")).url, initialRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl.endsWith("example")).url, "skill card instructions have changed");
+		assert.strictEqual(finalRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl.endsWith("example")).sourceUrl, initialRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl.endsWith("example")).sourceUrl, "skill card source URL has not changed");
+	});
+	(0, import_qunit.test)("updated skill card instructions result in new event and updated room state when code patch is completing", async function(assert) {
+		const roomId = await renderAiAssistantPanel(`${testRealmURL}Skill/example`);
+		await addSkillToAiAssistant(`${testRealmURL}Skill/example`);
+		const initialRoomStateSkillsJson = getRoomState(roomId, APP_BOXEL_ROOM_SKILLS_EVENT_TYPE);
+		await click("[data-test-edit-button]");
+		await fillIn("[data-test-field=\"instructions\"] textarea", "Updated instructions");
+		await click("[data-test-edit-button]");
+		await click("[data-test-close-button]");
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			body: `\`\`\`
+http://test-realm/test/hello.txt
+${SEARCH_MARKER}
+Hello, world!
+${SEPARATOR_MARKER}
+Hi, world!
+${REPLACE_MARKER}
+\`\`\``,
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true
+		});
+		await settled();
+		await waitFor("[data-test-apply-code-button]");
+		await click("[data-test-apply-code-button]");
+		const finalRoomStateSkillsJson = getRoomState(roomId, APP_BOXEL_ROOM_SKILLS_EVENT_TYPE);
+		assert.notDeepEqual(finalRoomStateSkillsJson, initialRoomStateSkillsJson, "room state has changed");
+		assert.strictEqual(finalRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl === envSkillId).sourceUrl, initialRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl === envSkillId).sourceUrl, "unchanged skill card is still present");
+		assert.notStrictEqual(finalRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl.endsWith("example")).contentHash, initialRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl.endsWith("example")).contentHash, "skill card instructions have changed");
+		assert.notStrictEqual(finalRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl.endsWith("example")).url, initialRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl.endsWith("example")).url, "skill card instructions have changed");
+		assert.strictEqual(finalRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl.endsWith("example")).sourceUrl, initialRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl.endsWith("example")).sourceUrl, "skill card source URL has not changed");
+	});
+	(0, import_qunit.test)("updated command definition results in new event and updated room state", async function(assert) {
+		const roomId = await renderAiAssistantPanel(`${testRealmURL}Skill/example`);
+		await addSkillToAiAssistant(`${testRealmURL}Skill/example`);
+		const initialRoomStateSkillsJson = getRoomState(roomId, APP_BOXEL_ROOM_SKILLS_EVENT_TYPE);
+		await click("[data-test-submode-switcher] button");
+		await click("[data-test-boxel-menu-item-text=\"Code\"]");
+		await click("[data-test-file-browser-toggle]");
+		await click("[data-test-file=\"search-and-open-card-command.ts\"]");
+		setMonacoContent(getMonacoContent().replace(`static displayName = 'SearchAndOpenCardCommand';`, `static displayName = 'SearchAndOpenCardCommand';\ndescription = 'Search for a card, and then open it in interact mode';`));
+		await settled();
+		const afterCodeModeRoomStateSkillsJson = getRoomState(roomId, APP_BOXEL_ROOM_SKILLS_EVENT_TYPE);
+		assert.notDeepEqual(afterCodeModeRoomStateSkillsJson, initialRoomStateSkillsJson, "room state has changed to reference new skill card events");
+		await click("[data-test-submode-switcher] button");
+		await click("[data-test-boxel-menu-item-text=\"Interact\"]");
+		await click("[data-test-send-message-btn]");
+		await waitFor("[data-test-message-idx]");
+		let expectedCommandDefinitionCount = afterCodeModeRoomStateSkillsJson.commandDefinitions?.length ?? 0;
+		await waitUntil(() => {
+			return (getRoomState(roomId, "app.boxel.room.skills")?.commandDefinitions?.length ?? 0) === expectedCommandDefinitionCount;
+		}, { timeoutMessage: "timed out waiting for command definitions to settle to expected count" });
+		const finalRoomStateSkillsJson = getRoomState(roomId, APP_BOXEL_ROOM_SKILLS_EVENT_TYPE);
+		if ((finalRoomStateSkillsJson.commandDefinitions?.length ?? 0) !== expectedCommandDefinitionCount) console.log(`command definition count mismatch: afterCodeModeRoomStateSkills:\n${JSON.stringify(afterCodeModeRoomStateSkillsJson, null, 2)}\nfinalRoomStateSkillsJson:\n${JSON.stringify(finalRoomStateSkillsJson, null, 2)}`);
+		assert.deepEqual(finalRoomStateSkillsJson.enabledSkillCards.map((c) => c.sourceUrl), afterCodeModeRoomStateSkillsJson.enabledSkillCards.map((c) => c.sourceUrl), "enabled skill cards are the same");
+		assert.deepEqual(finalRoomStateSkillsJson.disabledSkillCards.map((c) => c.sourceUrl), afterCodeModeRoomStateSkillsJson.disabledSkillCards.map((c) => c.sourceUrl), "disabled skill cards are the same");
+		assert.notDeepEqual(finalRoomStateSkillsJson.commandDefinitions, afterCodeModeRoomStateSkillsJson.commandDefinitions, "command definitions are different");
+		let baselineUnchangedCommandDefinitions = afterCodeModeRoomStateSkillsJson.commandDefinitions.filter((cmd) => cmd.sourceUrl !== `${testRealmURL}search-and-open-card-command/default`);
+		let baselineChangedCommandDefinitions = afterCodeModeRoomStateSkillsJson.commandDefinitions.filter((cmd) => cmd.sourceUrl === `${testRealmURL}search-and-open-card-command/default`);
+		let finalUnchangedCommandDefinitions = finalRoomStateSkillsJson.commandDefinitions.filter((cmd) => cmd.sourceUrl !== `${testRealmURL}search-and-open-card-command/default`);
+		let finalChangedCommandDefinitions = finalRoomStateSkillsJson.commandDefinitions.filter((cmd) => cmd.sourceUrl === `${testRealmURL}search-and-open-card-command/default`);
+		assert.deepEqual(finalUnchangedCommandDefinitions, baselineUnchangedCommandDefinitions, "unchanged command definitions are the same");
+		assert.notDeepEqual(finalChangedCommandDefinitions, baselineChangedCommandDefinitions, "changed command definitions are different");
+	});
+	(0, import_qunit.test)("adding skill card results in new command definitions being added but not duplicated", async function(assert) {
+		const roomId = await renderAiAssistantPanel(`${testRealmURL}Skill/example`);
+		await addSkillToAiAssistant(`${testRealmURL}Skill/example`);
+		await click("[data-test-send-message-btn]");
+		const initialRoomStateSkillsJson = getRoomState(roomId, APP_BOXEL_ROOM_SKILLS_EVENT_TYPE);
+		assert.strictEqual(initialRoomStateSkillsJson.commandDefinitions.filter((cmd) => cmd.name.includes("search-and-open-card-command")).length, 1, "search-and-open-card-command is present");
+		assert.strictEqual(initialRoomStateSkillsJson.commandDefinitions.filter((cmd) => cmd.name.includes("placeholder")).length, 0, "placeholder is not present");
+		await addSkillToAiAssistant(`${testRealmURL}Skill/example2`);
+		await click("[data-test-send-message-btn]");
+		const finalRoomStateSkillsJson = getRoomState(roomId, APP_BOXEL_ROOM_SKILLS_EVENT_TYPE);
+		assert.strictEqual(finalRoomStateSkillsJson.commandDefinitions.filter((cmd) => cmd.name.includes("search-and-open-card-command")).length, 1, "search-and-open-card-command is still present");
+		assert.strictEqual(finalRoomStateSkillsJson.commandDefinitions.filter((cmd) => cmd.name.includes("placeholder")).length, 1, "placeholder is now present");
+	});
+});
+//#endregion