@cardstack/boxel-cli 0.13.0-unstable.4 → 0.13.0-unstable.6

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

@@ -0,0 +1,648 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Br as testRealmURL, Kn as APP_BOXEL_MESSAGE_MSGTYPE, Yr as buildToolFunctionNameFromResolvedRef, ar as APP_BOXEL_TOOL_REQUESTS_KEY, nr as APP_BOXEL_ROOM_SKILLS_EVENT_TYPE } from "./runtime-common-BTaLJEw-.js";
+import { T as rri } from "./paths-C9-NYXnM.js";
+import { q as skillCardRef } from "./constants-Icc0nFW-.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import { t as Component } from "./dist-CkA1rgqO.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as OperatorModeContainer } from "./container-CBZZ8uFw.js";
+import { o as skillsIndexId } from "./utils-DjDK6b6F.js";
+import { M as waitUntil, T as settled, d as click, o as waitFor, s as fillIn } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { D as realmConfigCardJSON, F as setupLocalIndexing, I as setupOnSave, M as setupCardLogs, P as setupIntegrationTestRealm, S as getMonacoContent, k as setMonacoContent, lt as setupRenderingTest, o as addSkillToAiAssistant, ot as setupOperatorModeStateCleanup, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { A as field, H as linksTo, U as linksToMany, a as CardDef, l as FieldDef, s as Component$1, w as contains } from "./card-api-Cc8uZunB.js";
+import { t as string_default } from "./string-5IAMEUit.js";
+import { t as CardsGrid } from "./cards-grid-CbyLapaw.js";
+import { n as renderComponent } from "./render-component-B15Z0e2v.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";
+	const exampleSkillToolName = buildToolFunctionNameFromResolvedRef({
+		module: `${testRealmURL}search-and-open-card-command`,
+		name: "default"
+	});
+	let loader;
+	let operatorModeStateService;
+	setupRenderingTest(hooks);
+	setupOperatorModeStateCleanup(hooks);
+	hooks.beforeEach(function() {
+		loader = getService("loader-service").loader;
+	});
+	setupLocalIndexing(hooks);
+	setupOnSave(hooks);
+	setupCardLogs(hooks, async () => await loader.import("@cardstack/base/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, waitForToolResult } = 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(string_default);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
+					return contains(string_default, { 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(string_default);
+				});
+			}
+			#city = (initializeDeferredDecorator(this, "city"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "country", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#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(string_default);
+				});
+			}
+			#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(string_default, { computeVia: function() {
+						return this.firstName[0];
+					} });
+				});
+			}
+			#firstLetterOfTheName = (initializeDeferredDecorator(this, "firstLetterOfTheName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
+					return contains(string_default, { 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 { SearchCardsByTypeAndTitleTool } from '@cardstack/boxel-host/commands/search-cards';
+            import ShowCardTool from '@cardstack/boxel-host/commands/show-card';
+            import type { SearchCardsByTypeAndTitleInput } from '@cardstack/base/commands/search-card-result';
+
+            export default class SearchAndOpenCardCommand extends Command<
+              typeof SearchCardsByTypeAndTitleInput,
+              undefined
+            > {
+              static displayName = 'SearchAndOpenCardCommand';
+              static actionVerb = 'Search';
+              async getInputType() {
+                return new SearchCardsByTypeAndTitleTool(
+                  this.toolContext,
+                ).getInputType();
+              }
+              protected async run(
+                input: SearchCardsByTitleInput,
+              ): Promise<undefined> {
+                let searchCommand = new SearchCardsByTypeAndTitleTool(
+                  this.toolContext,
+                );
+                let searchResult = await searchCommand.execute(input);
+                if (searchResult.cardIds.length > 0) {
+                  let showCardCommand = new ShowCardTool(this.toolContext);
+                  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 }
+				} },
+				"realm-sync-skill.md": `---
+name: Realm Sync Skill
+description: A skill expressed as a markdown file
+boxel:
+  kind: skill
+  commands:
+    - codeRef:
+        module: '${testRealmURL}placeholder-command'
+        name: default
+      requiresApproval: false
+---
+# Realm Sync Skill
+
+Instructions live in the markdown body.
+`,
+				"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)("a room whose enabled skill card no longer exists still opens", async function(assert) {
+		let missingSkillId = `${testRealmURL}Skill/deleted-skill`;
+		let roomId = mockMatrixUtils.createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "room with a deleted skill"
+		});
+		mockMatrixUtils.setRoomState(roomId, APP_BOXEL_ROOM_SKILLS_EVENT_TYPE, {
+			enabledSkillCards: [{
+				sourceUrl: missingSkillId,
+				url: "mxc://mock-server/deleted-skill",
+				name: "deleted-skill.json",
+				contentType: "application/vnd.card+json"
+			}],
+			disabledSkillCards: [],
+			toolDefinitionFileDefs: []
+		});
+		operatorModeStateService.restore({
+			stacks: [[]],
+			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]");
+		getService("ai-assistant-panel-service").enterRoom(roomId);
+		await waitFor(`[data-test-room="${roomId}"][data-test-room-settled]`);
+		await click("[data-test-skill-menu]");
+		await waitFor(`[data-test-skill-unavailable="${missingSkillId}"]`);
+		assert.dom(`[data-test-skill-unavailable="${missingSkillId}"]`).containsText("Skill unavailable");
+		assert.dom(`[data-test-skill-toggle="${missingSkillId}-on"]`).exists("the dead reference can still be toggled off");
+	});
+	(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-item-button=\"http://test-realm/test/Skill/example\"]");
+		await click("[data-test-card-chooser-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.toolDefinitions.map((c) => c.sourceUrl), initialRoomStateSkillsJson.toolDefinitions.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-item-button="${skillId}"]`);
+		await click(`[data-test-item-button="${skillId}"]`);
+		await click("[data-test-card-chooser-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 can add a skill markdown file through the UI", async function(assert) {
+		const roomId = await renderAiAssistantPanel();
+		let skillId = `${testRealmURL}realm-sync-skill.md`;
+		await click("[data-test-skill-menu][data-test-pill-menu-button]");
+		await waitFor("[data-test-skill-menu] [data-test-pill-menu-add-markdown-button]");
+		await click("[data-test-skill-menu] [data-test-pill-menu-add-markdown-button]");
+		await waitFor("[data-test-choose-file-modal]");
+		await waitFor("[data-test-file=\"realm-sync-skill.md\"]");
+		await click("[data-test-file=\"realm-sync-skill.md\"]");
+		await click("[data-test-choose-file-modal-add-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`
+		});
+		let skillsState = getRoomState(roomId, APP_BOXEL_ROOM_SKILLS_EVENT_TYPE);
+		assert.ok(skillsState.toolDefinitions?.some((c) => c.sourceUrl?.includes("placeholder-command")), "the markdown skill's frontmatter command is uploaded as a command definition");
+		await click("[data-test-skill-menu]");
+		assert.dom(`[data-test-skill-toggle="${skillId}-on"]`).exists("the attached skill markdown is enabled in the menu");
+		assert.dom("[data-test-skill-menu]").containsText("Realm Sync Skill", "the pill is titled from the markdown frontmatter name");
+	});
+	(0, import_qunit.test)("canceling the skill-file chooser re-enables the add-markdown button", async function(assert) {
+		await renderAiAssistantPanel();
+		await click("[data-test-skill-menu][data-test-pill-menu-button]");
+		await waitFor("[data-test-skill-menu] [data-test-pill-menu-add-markdown-button]");
+		await click("[data-test-skill-menu] [data-test-pill-menu-add-markdown-button]");
+		await waitFor("[data-test-choose-file-modal]");
+		await click("[data-test-choose-file-modal-cancel-button]");
+		await waitUntil(() => !document.querySelector("[data-test-choose-file-modal]"));
+		assert.dom("[data-test-skill-menu] [data-test-pill-menu-add-markdown-button]").isNotDisabled("the add-markdown button is re-enabled after canceling");
+		await click("[data-test-skill-menu] [data-test-pill-menu-add-markdown-button]");
+		await waitFor("[data-test-choose-file-modal]");
+		assert.dom("[data-test-choose-file-modal]").exists("the chooser reopens after canceling");
+	});
+	(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-item-button="${availableSkillId}"]`);
+		assert.dom(`[data-test-item-button="${enabledSkillId}"]`).doesNotExist("already-enabled skill is excluded from the picker");
+		assert.dom(`[data-test-item-button="${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 markdown file", async function(assert) {
+		await renderAiAssistantPanel();
+		let skillId = `${testRealmURL}realm-sync-skill.md`;
+		await addSkillToAiAssistant(skillId);
+		assert.dom(`[data-test-stack-card="${skillId}"]`).doesNotExist("skill file 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 File\"]");
+		await click("[data-test-boxel-menu-item-text=\"Open Skill File\"]");
+		await waitFor(`[data-test-stack-card="${skillId}"]`);
+		assert.dom(`[data-test-stack-card="${skillId}"]`).exists("skill markdown file is opened as a stack item");
+	});
+	(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.state.codePath;
+		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.state.codePath && operatorModeStateService.state.codePath !== initialCodePath && operatorModeStateService.state.codePath.includes("skill"), { timeoutMessage: "timed out waiting for code mode to open skill card" });
+		assert.ok(operatorModeStateService.state.codePath?.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.toolDefinitions?.length > 0, "first room has command definitions");
+		assert.ok(room2StateSkillsJson.toolDefinitions?.length > 0, "second room has command definitions");
+		assert.deepEqual(room1StateSkillsJson.toolDefinitions, room2StateSkillsJson.toolDefinitions, "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.toolDefinitions, room3StateSkillsJson.toolDefinitions, "command definitions are different after content change");
+		const room2CommandUrls = room2StateSkillsJson.toolDefinitions.map((cmd) => cmd.url);
+		const room3CommandUrls = room3StateSkillsJson.toolDefinitions.map((cmd) => cmd.url);
+		const room2CommandSourceUrls = room2StateSkillsJson.toolDefinitions.map((cmd) => cmd.sourceUrl);
+		const room3CommandSourceUrls = room3StateSkillsJson.toolDefinitions.map((cmd) => cmd.sourceUrl);
+		const room2CommandHashes = room2StateSkillsJson.toolDefinitions.map((cmd) => cmd.contentHash);
+		const room3CommandHashes = room3StateSkillsJson.toolDefinitions.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.toolDefinitions, room1State2SkillsJson.toolDefinitions, "command definitions are different after content change");
+		const room1State1CommandUrls = room1State1SkillsJson.toolDefinitions.map((cmd) => cmd.url);
+		const room1State2CommandUrls = room1State2SkillsJson.toolDefinitions.map((cmd) => cmd.url);
+		const room1State1CommandSourceUrls = room1State1SkillsJson.toolDefinitions.map((cmd) => cmd.sourceUrl);
+		const room1State2CommandSourceUrls = room1State2SkillsJson.toolDefinitions.map((cmd) => cmd.sourceUrl);
+		const room1State1CommandHashes = room1State1SkillsJson.toolDefinitions.map((cmd) => cmd.contentHash);
+		const room1State2CommandHashes = room1State2SkillsJson.toolDefinitions.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 === skillsIndexId).sourceUrl, initialRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl === skillsIndexId).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]");
+		let toolCallId = "721c8c78-d8c1-4cc1-a7e9-51d2d3143e4d";
+		simulateRemoteMessage(roomId, "@aibot:localhost", {
+			body: "",
+			msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+			format: "org.matrix.custom.html",
+			isStreamingFinished: true,
+			[APP_BOXEL_TOOL_REQUESTS_KEY]: [{
+				id: toolCallId,
+				name: exampleSkillToolName,
+				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-tool-call-apply]");
+		await click("[data-test-message-idx=\"0\"] [data-test-pretui-tool-gate-action=\"apply\"]");
+		let toolResult = await waitForToolResult(roomId, toolCallId);
+		assert.strictEqual(toolResult.content["m.relates_to"]?.key, "applied", `tool call applied (failure reason: ${toolResult.content.failureReason ?? "none"})`);
+		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 === skillsIndexId).sourceUrl, initialRoomStateSkillsJson.enabledSkillCards.find((c) => c.sourceUrl === skillsIndexId).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();
+		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 = initialRoomStateSkillsJson.toolDefinitions?.length ?? 0;
+		await waitUntil(() => {
+			return (getRoomState(roomId, "app.boxel.room.skills")?.toolDefinitions?.length ?? 0) === expectedCommandDefinitionCount;
+		}, { timeoutMessage: "timed out waiting for command definitions to settle to expected count" });
+		await waitUntil(() => {
+			let skillsState = getRoomState(roomId, APP_BOXEL_ROOM_SKILLS_EVENT_TYPE);
+			return JSON.stringify(skillsState?.toolDefinitions) !== JSON.stringify(initialRoomStateSkillsJson.toolDefinitions);
+		}, { timeoutMessage: "timed out waiting for command definitions content to update" });
+		const finalRoomStateSkillsJson = getRoomState(roomId, APP_BOXEL_ROOM_SKILLS_EVENT_TYPE);
+		if ((finalRoomStateSkillsJson.toolDefinitions?.length ?? 0) !== expectedCommandDefinitionCount) console.log(`command definition count mismatch: initialRoomStateSkills:\n${JSON.stringify(initialRoomStateSkillsJson, null, 2)}\nfinalRoomStateSkillsJson:\n${JSON.stringify(finalRoomStateSkillsJson, null, 2)}`);
+		assert.deepEqual(finalRoomStateSkillsJson.enabledSkillCards.map((c) => c.sourceUrl), initialRoomStateSkillsJson.enabledSkillCards.map((c) => c.sourceUrl), "enabled skill cards are the same");
+		assert.deepEqual(finalRoomStateSkillsJson.disabledSkillCards.map((c) => c.sourceUrl), initialRoomStateSkillsJson.disabledSkillCards.map((c) => c.sourceUrl), "disabled skill cards are the same");
+		assert.notDeepEqual(finalRoomStateSkillsJson.toolDefinitions, initialRoomStateSkillsJson.toolDefinitions, "command definitions are different");
+		let baselineUnchangedCommandDefinitions = initialRoomStateSkillsJson.toolDefinitions.filter((cmd) => cmd.sourceUrl !== `${testRealmURL}search-and-open-card-command/default`);
+		let baselineChangedCommandDefinitions = initialRoomStateSkillsJson.toolDefinitions.filter((cmd) => cmd.sourceUrl === `${testRealmURL}search-and-open-card-command/default`);
+		let finalUnchangedCommandDefinitions = finalRoomStateSkillsJson.toolDefinitions.filter((cmd) => cmd.sourceUrl !== `${testRealmURL}search-and-open-card-command/default`);
+		let finalChangedCommandDefinitions = finalRoomStateSkillsJson.toolDefinitions.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.toolDefinitions.filter((cmd) => cmd.name.includes("search-and-open-card-command")).length, 1, "search-and-open-card-command is present");
+		assert.strictEqual(initialRoomStateSkillsJson.toolDefinitions.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.toolDefinitions.filter((cmd) => cmd.name.includes("search-and-open-card-command")).length, 1, "search-and-open-card-command is still present");
+		assert.strictEqual(finalRoomStateSkillsJson.toolDefinitions.filter((cmd) => cmd.name.includes("placeholder")).length, 1, "placeholder is now present");
+	});
+});
+//#endregion