@agents-inc/cli 0.32.1

package/dist/stores/wizard-store.test.js

@@ -0,0 +1,689 @@
+#!/usr/bin/env node
+import {
+  createMockCategory
+} from "../chunk-BZQBJP34.js";
+import {
+  beforeEach,
+  describe,
+  globalExpect,
+  it
+} from "../chunk-XY3XDVMI.js";
+import {
+  useWizardStore
+} from "../chunk-3ZOIOVKT.js";
+import "../chunk-MM7NK5N2.js";
+import "../chunk-T4EXUIBY.js";
+import "../chunk-BZN2Z5P7.js";
+import {
+  DEFAULT_PRESELECTED_SKILLS
+} from "../chunk-LAPCUV4D.js";
+import {
+  init_esm_shims
+} from "../chunk-DHET7RCE.js";
+
+// src/cli/stores/wizard-store.test.ts
+init_esm_shims();
+function sa(id, preloaded = false) {
+  return { id, preloaded };
+}
+describe("WizardStore", () => {
+  beforeEach(() => {
+    useWizardStore.getState().reset();
+  });
+  describe("initial state", () => {
+    it("should start at stack step", () => {
+      const { step } = useWizardStore.getState();
+      globalExpect(step).toBe("stack");
+    });
+    it("should have no approach selected", () => {
+      const { approach } = useWizardStore.getState();
+      globalExpect(approach).toBeNull();
+    });
+    it("should have no selected stack", () => {
+      const { selectedStackId } = useWizardStore.getState();
+      globalExpect(selectedStackId).toBeNull();
+    });
+    it("should have expert mode off", () => {
+      const { expertMode } = useWizardStore.getState();
+      globalExpect(expertMode).toBe(false);
+    });
+    it("should default to local install mode", () => {
+      const { installMode } = useWizardStore.getState();
+      globalExpect(installMode).toBe("local");
+    });
+    it("should have empty navigation history", () => {
+      const { history } = useWizardStore.getState();
+      globalExpect(history).toEqual([]);
+    });
+    it("should have empty selected domains", () => {
+      const { selectedDomains } = useWizardStore.getState();
+      globalExpect(selectedDomains).toEqual([]);
+    });
+    it("should have empty domain selections", () => {
+      const { domainSelections } = useWizardStore.getState();
+      globalExpect(domainSelections).toEqual({});
+    });
+  });
+  describe("step navigation", () => {
+    it("should update step with setStep", () => {
+      const store = useWizardStore.getState();
+      store.setStep("stack");
+      const { step } = useWizardStore.getState();
+      globalExpect(step).toBe("stack");
+    });
+    it("should track navigation history when setting step", () => {
+      const store = useWizardStore.getState();
+      store.setStep("build");
+      store.setStep("confirm");
+      const { history } = useWizardStore.getState();
+      globalExpect(history).toEqual(["stack", "build"]);
+    });
+    it("should go back through history", () => {
+      const store = useWizardStore.getState();
+      store.setStep("build");
+      store.setStep("confirm");
+      store.goBack();
+      const { step, history } = useWizardStore.getState();
+      globalExpect(step).toBe("build");
+      globalExpect(history).toEqual(["stack"]);
+    });
+    it("when goBack is called with empty history, should return to stack step", () => {
+      const store = useWizardStore.getState();
+      store.setStep("build");
+      store.goBack();
+      store.goBack();
+      const { step } = useWizardStore.getState();
+      globalExpect(step).toBe("stack");
+    });
+  });
+  describe("approach selection", () => {
+    it("should set approach to stack", () => {
+      const store = useWizardStore.getState();
+      store.setApproach("stack");
+      const { approach } = useWizardStore.getState();
+      globalExpect(approach).toBe("stack");
+    });
+    it("should set approach to scratch", () => {
+      const store = useWizardStore.getState();
+      store.setApproach("scratch");
+      const { approach } = useWizardStore.getState();
+      globalExpect(approach).toBe("scratch");
+    });
+  });
+  describe("stack selection", () => {
+    it("should select stack by id", () => {
+      const store = useWizardStore.getState();
+      store.selectStack("nextjs-fullstack");
+      const { selectedStackId } = useWizardStore.getState();
+      globalExpect(selectedStackId).toBe("nextjs-fullstack");
+    });
+    it("when selectStack is called with null, should clear previously selected stack", () => {
+      const store = useWizardStore.getState();
+      store.selectStack("nextjs-fullstack");
+      store.selectStack(null);
+      const { selectedStackId } = useWizardStore.getState();
+      globalExpect(selectedStackId).toBeNull();
+    });
+  });
+  describe("domain selection", () => {
+    it("should toggle domain on", () => {
+      const store = useWizardStore.getState();
+      store.toggleDomain("web");
+      const { selectedDomains } = useWizardStore.getState();
+      globalExpect(selectedDomains).toContain("web");
+    });
+    it("should toggle domain off", () => {
+      const store = useWizardStore.getState();
+      store.toggleDomain("web");
+      store.toggleDomain("web");
+      const { selectedDomains } = useWizardStore.getState();
+      globalExpect(selectedDomains).not.toContain("web");
+    });
+    it("should allow multiple domain selection", () => {
+      const store = useWizardStore.getState();
+      store.toggleDomain("web");
+      store.toggleDomain("api");
+      store.toggleDomain("cli");
+      const { selectedDomains } = useWizardStore.getState();
+      globalExpect(selectedDomains).toEqual(["web", "api", "cli"]);
+    });
+  });
+  describe("technology selection", () => {
+    it("should toggle technology in exclusive mode", () => {
+      const store = useWizardStore.getState();
+      store.toggleTechnology("web", "framework", "web-framework-react", true);
+      const { domainSelections } = useWizardStore.getState();
+      globalExpect(domainSelections.web.framework).toEqual(["web-framework-react"]);
+    });
+    it("should replace technology in exclusive mode", () => {
+      const store = useWizardStore.getState();
+      store.toggleTechnology("web", "framework", "web-framework-react", true);
+      store.toggleTechnology("web", "framework", "web-framework-vue", true);
+      const { domainSelections } = useWizardStore.getState();
+      globalExpect(domainSelections.web.framework).toEqual(["web-framework-vue"]);
+    });
+    it("should toggle off technology in exclusive mode", () => {
+      const store = useWizardStore.getState();
+      store.toggleTechnology("web", "framework", "web-framework-react", true);
+      store.toggleTechnology("web", "framework", "web-framework-react", true);
+      const { domainSelections } = useWizardStore.getState();
+      globalExpect(domainSelections.web.framework).toEqual([]);
+    });
+    it("should allow multiple selections in non-exclusive mode", () => {
+      const store = useWizardStore.getState();
+      store.toggleTechnology("web", "testing", "web-testing-vitest", false);
+      store.toggleTechnology("web", "testing", "web-testing-playwright-e2e", false);
+      const { domainSelections } = useWizardStore.getState();
+      globalExpect(domainSelections.web.testing).toEqual([
+        "web-testing-vitest",
+        "web-testing-playwright-e2e"
+      ]);
+    });
+    it("should toggle off technology in non-exclusive mode", () => {
+      const store = useWizardStore.getState();
+      store.toggleTechnology("web", "testing", "web-testing-vitest", false);
+      store.toggleTechnology("web", "testing", "web-testing-playwright-e2e", false);
+      store.toggleTechnology("web", "testing", "web-testing-vitest", false);
+      const { domainSelections } = useWizardStore.getState();
+      globalExpect(domainSelections.web.testing).toEqual(["web-testing-playwright-e2e"]);
+    });
+  });
+  describe("domain navigation", () => {
+    it("should move to next domain", () => {
+      const store = useWizardStore.getState();
+      store.toggleDomain("web");
+      store.toggleDomain("api");
+      const result = store.nextDomain();
+      const { currentDomainIndex } = useWizardStore.getState();
+      globalExpect(result).toBe(true);
+      globalExpect(currentDomainIndex).toBe(1);
+    });
+    it("when already at the last domain, should return false from nextDomain", () => {
+      const store = useWizardStore.getState();
+      store.toggleDomain("web");
+      const result = store.nextDomain();
+      globalExpect(result).toBe(false);
+    });
+    it("should move to previous domain", () => {
+      const store = useWizardStore.getState();
+      store.toggleDomain("web");
+      store.toggleDomain("api");
+      store.nextDomain();
+      const result = store.prevDomain();
+      const { currentDomainIndex } = useWizardStore.getState();
+      globalExpect(result).toBe(true);
+      globalExpect(currentDomainIndex).toBe(0);
+    });
+    it("when already at the first domain, should return false from prevDomain", () => {
+      const store = useWizardStore.getState();
+      store.toggleDomain("web");
+      const result = store.prevDomain();
+      globalExpect(result).toBe(false);
+    });
+    it("should get current domain", () => {
+      const store = useWizardStore.getState();
+      store.toggleDomain("web");
+      store.toggleDomain("api");
+      store.nextDomain();
+      const domain = store.getCurrentDomain();
+      globalExpect(domain).toBe("api");
+    });
+    it("should return null when no domains selected", () => {
+      const store = useWizardStore.getState();
+      const domain = store.getCurrentDomain();
+      globalExpect(domain).toBeNull();
+    });
+  });
+  describe("mode toggles", () => {
+    it("should toggle expert mode on", () => {
+      const store = useWizardStore.getState();
+      store.toggleExpertMode();
+      const { expertMode } = useWizardStore.getState();
+      globalExpect(expertMode).toBe(true);
+    });
+    it("should toggle expert mode off", () => {
+      const store = useWizardStore.getState();
+      store.toggleExpertMode();
+      store.toggleExpertMode();
+      const { expertMode } = useWizardStore.getState();
+      globalExpect(expertMode).toBe(false);
+    });
+    it("should toggle install mode to plugin", () => {
+      const store = useWizardStore.getState();
+      store.toggleInstallMode();
+      const { installMode } = useWizardStore.getState();
+      globalExpect(installMode).toBe("plugin");
+    });
+    it("should toggle install mode back to local", () => {
+      const store = useWizardStore.getState();
+      store.toggleInstallMode();
+      store.toggleInstallMode();
+      const { installMode } = useWizardStore.getState();
+      globalExpect(installMode).toBe("local");
+    });
+    it("should toggle show descriptions", () => {
+      const store = useWizardStore.getState();
+      store.toggleShowDescriptions();
+      const { showDescriptions } = useWizardStore.getState();
+      globalExpect(showDescriptions).toBe(true);
+    });
+    it("should toggle help on", () => {
+      const store = useWizardStore.getState();
+      store.toggleHelp();
+      const { showHelp } = useWizardStore.getState();
+      globalExpect(showHelp).toBe(true);
+    });
+    it("should toggle help off (show then hide)", () => {
+      const store = useWizardStore.getState();
+      store.toggleHelp();
+      store.toggleHelp();
+      const { showHelp } = useWizardStore.getState();
+      globalExpect(showHelp).toBe(false);
+    });
+    it("should toggle settings on", () => {
+      const store = useWizardStore.getState();
+      store.toggleSettings();
+      const { showSettings } = useWizardStore.getState();
+      globalExpect(showSettings).toBe(true);
+    });
+    it("should toggle settings off (show then hide)", () => {
+      const store = useWizardStore.getState();
+      store.toggleSettings();
+      store.toggleSettings();
+      const { showSettings } = useWizardStore.getState();
+      globalExpect(showSettings).toBe(false);
+    });
+    it("should start with showHelp false", () => {
+      const { showHelp } = useWizardStore.getState();
+      globalExpect(showHelp).toBe(false);
+    });
+    it("should start with showSettings false", () => {
+      const { showSettings } = useWizardStore.getState();
+      globalExpect(showSettings).toBe(false);
+    });
+    it("should reset showHelp to false after reset", () => {
+      const store = useWizardStore.getState();
+      store.toggleHelp();
+      store.reset();
+      const { showHelp } = useWizardStore.getState();
+      globalExpect(showHelp).toBe(false);
+    });
+    it("should reset showSettings to false after reset", () => {
+      const store = useWizardStore.getState();
+      store.toggleSettings();
+      store.reset();
+      const { showSettings } = useWizardStore.getState();
+      globalExpect(showSettings).toBe(false);
+    });
+  });
+  describe("install mode auto-defaulting", () => {
+    it("should default installMode to plugin when set via setState (marketplace available)", () => {
+      useWizardStore.setState({ installMode: "plugin" });
+      const { installMode } = useWizardStore.getState();
+      globalExpect(installMode).toBe("plugin");
+    });
+    it("should keep installMode as local when set via setState (no marketplace)", () => {
+      useWizardStore.setState({ installMode: "local" });
+      const { installMode } = useWizardStore.getState();
+      globalExpect(installMode).toBe("local");
+    });
+    it("should allow toggling installMode after auto-defaulting to plugin", () => {
+      useWizardStore.setState({ installMode: "plugin" });
+      useWizardStore.getState().toggleInstallMode();
+      const { installMode } = useWizardStore.getState();
+      globalExpect(installMode).toBe("local");
+    });
+    it("should reset installMode to local after reset even if previously set to plugin", () => {
+      useWizardStore.setState({ installMode: "plugin" });
+      useWizardStore.getState().reset();
+      const { installMode } = useWizardStore.getState();
+      globalExpect(installMode).toBe("local");
+    });
+  });
+  describe("computed getters", () => {
+    it("should get all selected technologies", () => {
+      const store = useWizardStore.getState();
+      store.toggleTechnology("web", "framework", "web-framework-react", true);
+      store.toggleTechnology("web", "styling", "web-styling-scss-modules", true);
+      store.toggleTechnology("api", "api", "api-framework-hono", true);
+      const technologies = store.getAllSelectedTechnologies();
+      globalExpect(technologies).toContain("web-framework-react");
+      globalExpect(technologies).toContain("web-styling-scss-modules");
+      globalExpect(technologies).toContain("api-framework-hono");
+    });
+    it("should get default methodology skills", () => {
+      const store = useWizardStore.getState();
+      const skills = store.getDefaultMethodologySkills();
+      for (const skill of DEFAULT_PRESELECTED_SKILLS) {
+        globalExpect(skills).toContain(skill);
+      }
+    });
+    it("should get selected technologies per domain", () => {
+      const store = useWizardStore.getState();
+      store.toggleTechnology("web", "framework", "web-framework-react", true);
+      store.toggleTechnology("web", "styling", "web-styling-scss-modules", true);
+      store.toggleTechnology("api", "api", "api-framework-hono", true);
+      const perDomain = store.getSelectedTechnologiesPerDomain();
+      globalExpect(perDomain.web).toEqual(["web-framework-react", "web-styling-scss-modules"]);
+      globalExpect(perDomain.api).toEqual(["api-framework-hono"]);
+      globalExpect(perDomain.cli).toBeUndefined();
+    });
+    it("should return empty object for getSelectedTechnologiesPerDomain with no selections", () => {
+      const store = useWizardStore.getState();
+      const perDomain = store.getSelectedTechnologiesPerDomain();
+      globalExpect(perDomain).toEqual({});
+    });
+    it("should omit domains with empty subcategory arrays from getSelectedTechnologiesPerDomain", () => {
+      const store = useWizardStore.getState();
+      store.toggleTechnology("web", "framework", "web-framework-react", true);
+      store.toggleTechnology("web", "framework", "web-framework-react", true);
+      const perDomain = store.getSelectedTechnologiesPerDomain();
+      globalExpect(perDomain.web).toBeUndefined();
+    });
+    it("should get technology count", () => {
+      const store = useWizardStore.getState();
+      store.toggleTechnology("web", "framework", "web-framework-react", true);
+      store.toggleTechnology("web", "styling", "web-styling-scss-modules", true);
+      store.toggleTechnology("api", "api", "api-framework-hono", true);
+      globalExpect(store.getTechnologyCount()).toBe(3);
+    });
+    it("should return 0 for getTechnologyCount with no selections", () => {
+      const store = useWizardStore.getState();
+      globalExpect(store.getTechnologyCount()).toBe(0);
+    });
+  });
+  describe("navigation guards", () => {
+    it("canGoToNextDomain should return true when not at last domain", () => {
+      const store = useWizardStore.getState();
+      store.toggleDomain("web");
+      store.toggleDomain("api");
+      globalExpect(store.canGoToNextDomain()).toBe(true);
+    });
+    it("canGoToNextDomain should return false when at last domain", () => {
+      const store = useWizardStore.getState();
+      store.toggleDomain("web");
+      globalExpect(store.canGoToNextDomain()).toBe(false);
+    });
+    it("canGoToNextDomain should return false with no domains", () => {
+      const store = useWizardStore.getState();
+      globalExpect(store.canGoToNextDomain()).toBe(false);
+    });
+    it("canGoToPreviousDomain should return false when at first domain", () => {
+      const store = useWizardStore.getState();
+      store.toggleDomain("web");
+      store.toggleDomain("api");
+      globalExpect(store.canGoToPreviousDomain()).toBe(false);
+    });
+    it("canGoToPreviousDomain should return true when past first domain", () => {
+      const store = useWizardStore.getState();
+      store.toggleDomain("web");
+      store.toggleDomain("api");
+      store.nextDomain();
+      globalExpect(store.canGoToPreviousDomain()).toBe(true);
+    });
+    it("canGoToPreviousDomain should return false with no domains", () => {
+      const store = useWizardStore.getState();
+      globalExpect(store.canGoToPreviousDomain()).toBe(false);
+    });
+  });
+  describe("parent domain selectors", () => {
+    const matrixWithParentDomain = {
+      categories: {
+        "error-handling": createMockCategory("error-handling", "Error Handling", {
+          domain: "web-extras",
+          parent_domain: "web",
+          exclusive: false
+        }),
+        framework: createMockCategory("framework", "Framework", {
+          domain: "web"
+        })
+      }
+    };
+    const matrixWithoutParent = {
+      categories: {
+        framework: createMockCategory("framework", "Framework", {
+          domain: "web"
+        })
+      }
+    };
+    it("should find parent domain for a domain with parent_domain", () => {
+      const store = useWizardStore.getState();
+      const parent = store.getParentDomain(
+        "web-extras",
+        matrixWithParentDomain
+      );
+      globalExpect(parent).toBe("web");
+    });
+    it("should return undefined for a domain without parent_domain", () => {
+      const store = useWizardStore.getState();
+      const parent = store.getParentDomain("web", matrixWithoutParent);
+      globalExpect(parent).toBeUndefined();
+    });
+    it("should get parent domain selections when parent exists", () => {
+      const store = useWizardStore.getState();
+      store.toggleTechnology("web", "framework", "web-framework-react", true);
+      const parentSelections = store.getParentDomainSelections(
+        "web-extras",
+        matrixWithParentDomain
+      );
+      globalExpect(parentSelections).toEqual({ framework: ["web-framework-react"] });
+    });
+    it("should return undefined for getParentDomainSelections when no parent", () => {
+      const store = useWizardStore.getState();
+      const parentSelections = store.getParentDomainSelections(
+        "web",
+        matrixWithoutParent
+      );
+      globalExpect(parentSelections).toBeUndefined();
+    });
+    it("should return undefined for getParentDomainSelections when parent has no selections", () => {
+      const store = useWizardStore.getState();
+      const parentSelections = store.getParentDomainSelections(
+        "web-extras",
+        matrixWithParentDomain
+      );
+      globalExpect(parentSelections).toBeUndefined();
+    });
+  });
+  describe("reset", () => {
+    it("should reset to initial state", () => {
+      const store = useWizardStore.getState();
+      store.setStep("stack");
+      store.setApproach("scratch");
+      store.selectStack("nextjs-fullstack");
+      store.toggleDomain("web");
+      store.toggleExpertMode();
+      store.reset();
+      const state = useWizardStore.getState();
+      globalExpect(state.step).toBe("stack");
+      globalExpect(state.approach).toBeNull();
+      globalExpect(state.selectedStackId).toBeNull();
+      globalExpect(state.selectedDomains).toEqual([]);
+      globalExpect(state.expertMode).toBe(false);
+      globalExpect(state.installMode).toBe("local");
+      globalExpect(state.history).toEqual([]);
+    });
+  });
+  describe("populateFromStack", () => {
+    it("should set selectedDomains to all domains regardless of stack contents", () => {
+      const store = useWizardStore.getState();
+      const stack = {
+        agents: {
+          web: { framework: [sa("web-framework-react", true)] }
+        }
+      };
+      const categories = {
+        framework: { domain: "web" }
+      };
+      store.populateFromStack(stack, categories);
+      const { selectedDomains, domainSelections } = useWizardStore.getState();
+      globalExpect(selectedDomains).toEqual(["web", "web-extras", "api", "cli", "mobile", "shared"]);
+      globalExpect(domainSelections.web).toBeDefined();
+      globalExpect(domainSelections.web.framework).toEqual(["web-framework-react"]);
+      globalExpect(domainSelections.api).toBeUndefined();
+    });
+    it("should populate domainSelections from stack agents", () => {
+      const store = useWizardStore.getState();
+      const stack = {
+        agents: {
+          web: {
+            framework: [sa("web-framework-react", true)],
+            "client-state": [sa("web-state-zustand")]
+          },
+          api: { api: [sa("api-framework-hono", true)] }
+        }
+      };
+      const categories = {
+        framework: { domain: "web" },
+        "client-state": { domain: "web" },
+        api: { domain: "api" }
+      };
+      store.populateFromStack(stack, categories);
+      const { domainSelections } = useWizardStore.getState();
+      globalExpect(domainSelections.web.framework).toEqual(["web-framework-react"]);
+      globalExpect(domainSelections.web["client-state"]).toEqual(["web-state-zustand"]);
+      globalExpect(domainSelections.api.api).toEqual(["api-framework-hono"]);
+    });
+    it("should skip entries without a domain", () => {
+      const store = useWizardStore.getState();
+      const stack = {
+        agents: {
+          misc: { methodology: [sa("meta-methodology-vitest")] }
+        }
+      };
+      const categories = {
+        methodology: {}
+      };
+      store.populateFromStack(stack, categories);
+      const { domainSelections } = useWizardStore.getState();
+      globalExpect(Object.keys(domainSelections)).toHaveLength(0);
+    });
+    it("should populate multiple skills from array-valued subcategories", () => {
+      const store = useWizardStore.getState();
+      const stack = {
+        agents: {
+          "pattern-scout": {
+            methodology: [
+              sa("meta-methodology-investigation-requirements", true),
+              sa("meta-methodology-anti-over-engineering", true),
+              sa("meta-methodology-success-criteria", true)
+            ]
+          }
+        }
+      };
+      const categories = {
+        methodology: { domain: "shared" }
+      };
+      store.populateFromStack(stack, categories);
+      const { domainSelections } = useWizardStore.getState();
+      globalExpect(domainSelections.shared.methodology).toEqual([
+        "meta-methodology-investigation-requirements",
+        "meta-methodology-anti-over-engineering",
+        "meta-methodology-success-criteria"
+      ]);
+    });
+    it("should handle single-element and multi-element arrays across agents", () => {
+      const store = useWizardStore.getState();
+      const stack = {
+        agents: {
+          web: {
+            framework: [sa("web-framework-react", true)],
+            methodology: [
+              sa("meta-methodology-investigation-requirements", true),
+              sa("meta-methodology-anti-over-engineering", true)
+            ]
+          },
+          api: { api: [sa("api-framework-hono", true)] }
+        }
+      };
+      const categories = {
+        framework: { domain: "web" },
+        methodology: { domain: "shared" },
+        api: { domain: "api" }
+      };
+      store.populateFromStack(stack, categories);
+      const { domainSelections } = useWizardStore.getState();
+      globalExpect(domainSelections.web.framework).toEqual(["web-framework-react"]);
+      globalExpect(domainSelections.shared.methodology).toEqual([
+        "meta-methodology-investigation-requirements",
+        "meta-methodology-anti-over-engineering"
+      ]);
+      globalExpect(domainSelections.api.api).toEqual(["api-framework-hono"]);
+    });
+    it("should deduplicate skills from arrays across multiple agents", () => {
+      const store = useWizardStore.getState();
+      const stack = {
+        agents: {
+          agent1: {
+            methodology: [
+              sa("meta-methodology-investigation-requirements", true),
+              sa("meta-methodology-anti-over-engineering", true)
+            ]
+          },
+          agent2: {
+            methodology: [
+              sa("meta-methodology-anti-over-engineering", true),
+              sa("meta-methodology-success-criteria", true)
+            ]
+          }
+        }
+      };
+      const categories = {
+        methodology: { domain: "shared" }
+      };
+      store.populateFromStack(stack, categories);
+      const { domainSelections } = useWizardStore.getState();
+      globalExpect(domainSelections.shared.methodology).toEqual([
+        "meta-methodology-investigation-requirements",
+        "meta-methodology-anti-over-engineering",
+        "meta-methodology-success-criteria"
+      ]);
+    });
+  });
+  describe("complex flows", () => {
+    it("should handle complete stack selection flow", () => {
+      const store = useWizardStore.getState();
+      store.setApproach("stack");
+      store.selectStack("nextjs-fullstack");
+      store.setStackAction("customize");
+      store.setStep("build");
+      store.setStep("confirm");
+      const state = useWizardStore.getState();
+      globalExpect(state.step).toBe("confirm");
+      globalExpect(state.approach).toBe("stack");
+      globalExpect(state.selectedStackId).toBe("nextjs-fullstack");
+      globalExpect(state.stackAction).toBe("customize");
+      globalExpect(state.history).toEqual(["stack", "build"]);
+    });
+    it("should handle complete scratch flow", () => {
+      const store = useWizardStore.getState();
+      store.setApproach("scratch");
+      store.toggleDomain("web");
+      store.toggleDomain("api");
+      store.setStep("build");
+      store.toggleTechnology("web", "framework", "web-framework-react", true);
+      store.toggleTechnology("web", "styling", "web-styling-scss-modules", true);
+      store.toggleTechnology("api", "api", "api-framework-hono", true);
+      store.setStep("confirm");
+      const state = useWizardStore.getState();
+      globalExpect(state.step).toBe("confirm");
+      globalExpect(state.approach).toBe("scratch");
+      globalExpect(state.selectedDomains).toEqual(["web", "api"]);
+      globalExpect(state.domainSelections.web.framework).toEqual(["web-framework-react"]);
+      globalExpect(state.domainSelections.web.styling).toEqual(["web-styling-scss-modules"]);
+      globalExpect(state.domainSelections.api.api).toEqual(["api-framework-hono"]);
+    });
+    it("should preserve selections when going back", () => {
+      const store = useWizardStore.getState();
+      store.setApproach("scratch");
+      store.toggleDomain("web");
+      store.setStep("build");
+      store.toggleTechnology("web", "framework", "web-framework-react", true);
+      store.goBack();
+      const state = useWizardStore.getState();
+      globalExpect(state.selectedDomains).toContain("web");
+      globalExpect(state.domainSelections.web.framework).toEqual(["web-framework-react"]);
+    });
+  });
+});
+//# sourceMappingURL=wizard-store.test.js.map