grimoire-wizard 0.3.0

package/dist/index.js

@@ -0,0 +1,1922 @@
+// src/schema.ts
+import { z } from "zod";
+var conditionSchema = z.lazy(() => {
+  const fieldEquals = z.object({ field: z.string(), equals: z.unknown() }).strict();
+  const fieldNotEquals = z.object({ field: z.string(), notEquals: z.unknown() }).strict();
+  const fieldIncludes = z.object({ field: z.string(), includes: z.unknown() }).strict();
+  const fieldNotIncludes = z.object({ field: z.string(), notIncludes: z.unknown() }).strict();
+  const fieldGreaterThan = z.object({ field: z.string(), greaterThan: z.number() }).strict();
+  const fieldLessThan = z.object({ field: z.string(), lessThan: z.number() }).strict();
+  const fieldIsEmpty = z.object({ field: z.string(), isEmpty: z.literal(true) }).strict();
+  const fieldIsNotEmpty = z.object({ field: z.string(), isNotEmpty: z.literal(true) }).strict();
+  const allCondition = z.object({ all: z.array(conditionSchema) }).strict();
+  const anyCondition = z.object({ any: z.array(conditionSchema) }).strict();
+  const notCondition = z.object({ not: conditionSchema }).strict();
+  return z.union([
+    fieldEquals,
+    fieldNotEquals,
+    fieldIncludes,
+    fieldNotIncludes,
+    fieldGreaterThan,
+    fieldLessThan,
+    fieldIsEmpty,
+    fieldIsNotEmpty,
+    allCondition,
+    anyCondition,
+    notCondition
+  ]);
+});
+var validationRuleSchema = z.discriminatedUnion("rule", [
+  z.object({ rule: z.literal("required"), message: z.string().optional() }),
+  z.object({ rule: z.literal("minLength"), value: z.number(), message: z.string().optional() }),
+  z.object({ rule: z.literal("maxLength"), value: z.number(), message: z.string().optional() }),
+  z.object({ rule: z.literal("pattern"), value: z.string(), message: z.string().optional() }),
+  z.object({ rule: z.literal("min"), value: z.number(), message: z.string().optional() }),
+  z.object({ rule: z.literal("max"), value: z.number(), message: z.string().optional() })
+]);
+var selectOptionSchema = z.object({
+  value: z.string(),
+  label: z.string(),
+  hint: z.string().optional(),
+  disabled: z.union([z.boolean(), z.string()]).optional()
+});
+var separatorOptionSchema = z.object({
+  separator: z.string()
+});
+var selectChoiceSchema = z.union([selectOptionSchema, separatorOptionSchema]);
+var baseStepFields = {
+  id: z.string(),
+  message: z.string(),
+  description: z.string().optional(),
+  next: z.string().optional(),
+  when: conditionSchema.optional(),
+  keepValuesOnPrevious: z.boolean().optional(),
+  required: z.boolean().optional(),
+  group: z.string().optional()
+};
+var textStepSchema = z.object({
+  ...baseStepFields,
+  type: z.literal("text"),
+  placeholder: z.string().optional(),
+  default: z.string().optional(),
+  validate: z.array(validationRuleSchema).optional()
+});
+var selectStepSchema = z.object({
+  ...baseStepFields,
+  type: z.literal("select"),
+  options: z.array(selectChoiceSchema).min(1).optional(),
+  optionsFrom: z.string().optional(),
+  default: z.string().optional(),
+  routes: z.record(z.string(), z.string()).optional(),
+  pageSize: z.number().int().positive().optional(),
+  loop: z.boolean().optional()
+});
+var multiSelectStepSchema = z.object({
+  ...baseStepFields,
+  type: z.literal("multiselect"),
+  options: z.array(selectChoiceSchema).min(1).optional(),
+  optionsFrom: z.string().optional(),
+  default: z.array(z.string()).optional(),
+  min: z.number().int().nonnegative().optional(),
+  max: z.number().int().positive().optional(),
+  pageSize: z.number().int().positive().optional(),
+  loop: z.boolean().optional()
+});
+var confirmStepSchema = z.object({
+  ...baseStepFields,
+  type: z.literal("confirm"),
+  default: z.boolean().optional()
+});
+var passwordStepSchema = z.object({
+  ...baseStepFields,
+  type: z.literal("password"),
+  validate: z.array(validationRuleSchema).optional()
+});
+var numberStepSchema = z.object({
+  ...baseStepFields,
+  type: z.literal("number"),
+  default: z.number().optional(),
+  min: z.number().optional(),
+  max: z.number().optional(),
+  step: z.number().positive().optional()
+});
+var searchStepSchema = z.object({
+  ...baseStepFields,
+  type: z.literal("search"),
+  options: z.array(selectChoiceSchema).min(1).optional(),
+  optionsFrom: z.string().optional(),
+  default: z.string().optional(),
+  placeholder: z.string().optional(),
+  pageSize: z.number().int().positive().optional(),
+  loop: z.boolean().optional()
+});
+var editorStepSchema = z.object({
+  ...baseStepFields,
+  type: z.literal("editor"),
+  default: z.string().optional(),
+  validate: z.array(validationRuleSchema).optional()
+});
+var pathStepSchema = z.object({
+  ...baseStepFields,
+  type: z.literal("path"),
+  default: z.string().optional(),
+  placeholder: z.string().optional(),
+  validate: z.array(validationRuleSchema).optional()
+});
+var toggleStepSchema = z.object({
+  ...baseStepFields,
+  type: z.literal("toggle"),
+  default: z.boolean().optional(),
+  active: z.string().optional(),
+  inactive: z.string().optional()
+});
+var messageStepSchema = z.object({
+  ...baseStepFields,
+  type: z.literal("message")
+});
+var stepConfigSchema = z.discriminatedUnion("type", [
+  textStepSchema,
+  selectStepSchema,
+  multiSelectStepSchema,
+  confirmStepSchema,
+  passwordStepSchema,
+  numberStepSchema,
+  searchStepSchema,
+  editorStepSchema,
+  pathStepSchema,
+  toggleStepSchema,
+  messageStepSchema
+]);
+var hexColorSchema = z.string().regex(
+  /^#[0-9a-fA-F]{6}$/,
+  "Must be a 6-digit hex color (e.g., #FF0000)"
+);
+var themeConfigSchema = z.object({
+  tokens: z.object({
+    primary: hexColorSchema.optional(),
+    success: hexColorSchema.optional(),
+    error: hexColorSchema.optional(),
+    warning: hexColorSchema.optional(),
+    info: hexColorSchema.optional(),
+    muted: hexColorSchema.optional(),
+    accent: hexColorSchema.optional()
+  }).optional(),
+  icons: z.object({
+    step: z.string().optional(),
+    stepDone: z.string().optional(),
+    stepPending: z.string().optional(),
+    pointer: z.string().optional()
+  }).optional()
+});
+var preFlightCheckSchema = z.object({
+  name: z.string(),
+  run: z.string(),
+  message: z.string()
+});
+var actionConfigSchema = z.object({
+  name: z.string().optional(),
+  run: z.string(),
+  when: conditionSchema.optional()
+});
+var wizardConfigSchema = z.object({
+  meta: z.object({
+    name: z.string(),
+    version: z.string().optional(),
+    description: z.string().optional()
+  }),
+  theme: themeConfigSchema.optional(),
+  steps: z.array(stepConfigSchema).min(1),
+  output: z.object({
+    format: z.enum(["json", "env", "yaml"]),
+    path: z.string().optional()
+  }).optional(),
+  extends: z.string().optional(),
+  checks: z.array(preFlightCheckSchema).optional(),
+  actions: z.array(actionConfigSchema).optional()
+}).superRefine((config, ctx) => {
+  const stepIds = /* @__PURE__ */ new Set();
+  for (const step of config.steps) {
+    if (stepIds.has(step.id)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Duplicate step ID: "${step.id}"`,
+        path: ["steps"]
+      });
+    }
+    stepIds.add(step.id);
+  }
+  config.steps.forEach((step, i) => {
+    if (step.next && step.next !== "__done__" && !stepIds.has(step.next)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Step "${step.id}" references unknown next step: "${step.next}"`,
+        path: ["steps", i, "next"]
+      });
+    }
+    if (step.type === "select" && step.routes) {
+      for (const [key, target] of Object.entries(step.routes)) {
+        if (target !== "__done__" && !stepIds.has(target)) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `Step "${step.id}" route "${key}" references unknown step: "${target}"`,
+            path: ["steps", i, "routes", key]
+          });
+        }
+      }
+    }
+    if (step.when) {
+      collectConditionFieldIssues(step.when, stepIds, ctx, ["steps", i, "when"]);
+    }
+    if (step.type === "select" && step.routes && step.options) {
+      const optionValues = /* @__PURE__ */ new Set();
+      for (const o of step.options) {
+        if ("value" in o) {
+          optionValues.add(o.value);
+        }
+      }
+      for (const routeKey of Object.keys(step.routes)) {
+        if (!optionValues.has(routeKey)) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `Step "${step.id}" route key "${routeKey}" does not match any option value`,
+            path: ["steps", i, "routes", routeKey]
+          });
+        }
+      }
+    }
+    if (step.type === "select" || step.type === "multiselect" || step.type === "search") {
+      const hasOptions = step.options !== void 0;
+      const hasOptionsFrom = step.optionsFrom !== void 0;
+      if (hasOptions && hasOptionsFrom) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `Step "${step.id}" has both "options" and "optionsFrom" \u2014 only one is allowed`,
+          path: ["steps", i]
+        });
+      }
+      if (!hasOptions && !hasOptionsFrom) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `Step "${step.id}" must have either "options" or "optionsFrom"`,
+          path: ["steps", i]
+        });
+      }
+    }
+    if ((step.type === "number" || step.type === "multiselect") && step.min !== void 0 && step.max !== void 0 && step.min > step.max) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Step "${step.id}" has min (${String(step.min)}) greater than max (${String(step.max)})`,
+        path: ["steps", i]
+      });
+    }
+  });
+  if (config.actions) {
+    config.actions.forEach((action, i) => {
+      if (action.when) {
+        collectConditionFieldIssues(action.when, stepIds, ctx, ["actions", i, "when"]);
+      }
+    });
+  }
+});
+function collectConditionFieldIssues(condition, validIds, ctx, path) {
+  if ("field" in condition) {
+    const fieldRoot = condition.field.split(".")[0];
+    if (fieldRoot && !validIds.has(fieldRoot)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Condition references unknown step ID: "${fieldRoot}"`,
+        path
+      });
+    }
+    return;
+  }
+  if ("all" in condition) {
+    condition.all.forEach((child, i) => {
+      collectConditionFieldIssues(child, validIds, ctx, [...path, "all", i]);
+    });
+    return;
+  }
+  if ("any" in condition) {
+    condition.any.forEach((child, i) => {
+      collectConditionFieldIssues(child, validIds, ctx, [...path, "any", i]);
+    });
+    return;
+  }
+  if ("not" in condition) {
+    collectConditionFieldIssues(condition.not, validIds, ctx, [...path, "not"]);
+  }
+}
+function parseWizardConfig(raw) {
+  const result = wizardConfigSchema.parse(raw);
+  return result;
+}
+
+// src/parser.ts
+import { cosmiconfig } from "cosmiconfig";
+import { readFileSync } from "fs";
+import { dirname, resolve, isAbsolute } from "path";
+import { parse as parseYAML } from "yaml";
+var DONE_SENTINEL = "__done__";
+function buildStepGraph(steps) {
+  const graph = /* @__PURE__ */ new Map();
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const edges = [];
+    if (step.next && step.next !== DONE_SENTINEL) {
+      edges.push(step.next);
+    }
+    if (step.type === "select" && step.routes) {
+      for (const target of Object.values(step.routes)) {
+        if (target !== DONE_SENTINEL) {
+          edges.push(target);
+        }
+      }
+    }
+    if (!step.next && !(step.type === "select" && step.routes)) {
+      const nextStep = steps[i + 1];
+      if (nextStep) {
+        edges.push(nextStep.id);
+      }
+    }
+    graph.set(step.id, edges);
+  }
+  return graph;
+}
+function detectCycles(config) {
+  const graph = buildStepGraph(config.steps);
+  const UNVISITED = 0;
+  const IN_STACK = 1;
+  const DONE = 2;
+  const nodeState = /* @__PURE__ */ new Map();
+  for (const id of graph.keys()) {
+    nodeState.set(id, UNVISITED);
+  }
+  function dfs(nodeId, path) {
+    nodeState.set(nodeId, IN_STACK);
+    const currentPath = [...path, nodeId];
+    for (const neighbor of graph.get(nodeId) ?? []) {
+      const state = nodeState.get(neighbor);
+      if (state === IN_STACK) {
+        const cycleStart = currentPath.indexOf(neighbor);
+        const cycle = [...currentPath.slice(cycleStart), neighbor];
+        throw new Error(`Cycle detected in wizard steps: ${cycle.join(" \u2192 ")}`);
+      }
+      if (state === UNVISITED) {
+        dfs(neighbor, currentPath);
+      }
+    }
+    nodeState.set(nodeId, DONE);
+  }
+  for (const id of graph.keys()) {
+    if (nodeState.get(id) === UNVISITED) {
+      dfs(id, []);
+    }
+  }
+}
+function deepMergeTheme(parent, child) {
+  if (!parent && !child) return void 0;
+  if (!parent) return child;
+  if (!child) return parent;
+  return {
+    tokens: { ...parent.tokens, ...child.tokens },
+    icons: { ...parent.icons, ...child.icons }
+  };
+}
+function mergeConfigs(parent, child) {
+  return {
+    meta: { ...parent.meta, ...child.meta },
+    theme: deepMergeTheme(parent.theme, child.theme),
+    steps: child.steps,
+    output: child.output ?? parent.output,
+    checks: [
+      ...parent.checks ?? [],
+      ...child.checks ?? []
+    ],
+    actions: child.actions ?? parent.actions
+  };
+}
+var OPTION_STEP_TYPES = /* @__PURE__ */ new Set(["select", "multiselect", "search"]);
+function resolveOptionsFromSteps(raw, configDir) {
+  const steps = raw["steps"];
+  if (!Array.isArray(steps)) return;
+  for (const step of steps) {
+    if (typeof step !== "object" || step === null) continue;
+    const stepObj = step;
+    const optionsFrom = stepObj["optionsFrom"];
+    if (typeof optionsFrom !== "string") continue;
+    const stepId = String(stepObj["id"] ?? "unknown");
+    const stepType = String(stepObj["type"] ?? "unknown");
+    if (!OPTION_STEP_TYPES.has(stepType)) {
+      throw new Error(
+        `Step "${stepId}" has "optionsFrom" but type "${stepType}" does not support dynamic options`
+      );
+    }
+    const fullPath = isAbsolute(optionsFrom) ? optionsFrom : resolve(configDir, optionsFrom);
+    let content;
+    try {
+      content = readFileSync(fullPath, "utf-8");
+    } catch {
+      throw new Error(
+        `Step "${stepId}": failed to read optionsFrom file "${fullPath}"`
+      );
+    }
+    let parsed;
+    try {
+      if (fullPath.endsWith(".yaml") || fullPath.endsWith(".yml")) {
+        parsed = parseYAML(content);
+      } else {
+        parsed = JSON.parse(content);
+      }
+    } catch {
+      throw new Error(
+        `Step "${stepId}": optionsFrom file "${fullPath}" contains invalid JSON/YAML`
+      );
+    }
+    if (!Array.isArray(parsed)) {
+      throw new Error(
+        `Step "${stepId}": optionsFrom file "${fullPath}" must contain an array`
+      );
+    }
+    stepObj["options"] = parsed;
+    delete stepObj["optionsFrom"];
+  }
+}
+async function loadWithInheritance(filePath, seen) {
+  const resolvedPath = resolve(filePath);
+  if (seen.has(resolvedPath)) {
+    throw new Error(`Circular extends detected: "${resolvedPath}" was already loaded`);
+  }
+  seen.add(resolvedPath);
+  const explorer = cosmiconfig("grimoire");
+  const result = await explorer.load(resolvedPath);
+  if (!result || result.isEmpty) {
+    throw new Error(`No configuration found at: ${resolvedPath}`);
+  }
+  const raw = result.config;
+  const extendsPath = typeof raw["extends"] === "string" ? raw["extends"] : void 0;
+  resolveOptionsFromSteps(raw, dirname(resolvedPath));
+  const config = parseWizardConfig(raw);
+  if (!extendsPath) {
+    return config;
+  }
+  const parentPath = isAbsolute(extendsPath) ? extendsPath : resolve(dirname(resolvedPath), extendsPath);
+  const parentConfig = await loadWithInheritance(parentPath, seen);
+  return mergeConfigs(parentConfig, config);
+}
+async function loadWizardConfig(filePath) {
+  const config = await loadWithInheritance(filePath, /* @__PURE__ */ new Set());
+  detectCycles(config);
+  return config;
+}
+function parseWizardYAML(yamlString) {
+  const raw = parseYAML(yamlString);
+  if (raw !== null && typeof raw === "object" && !Array.isArray(raw)) {
+    if ("extends" in raw && typeof raw.extends === "string") {
+      throw new Error(
+        '"extends" is not supported in parseWizardYAML \u2014 use loadWizardConfig with a file path'
+      );
+    }
+    const steps = raw["steps"];
+    if (Array.isArray(steps)) {
+      for (const step of steps) {
+        if (typeof step === "object" && step !== null && "optionsFrom" in step) {
+          throw new Error(
+            '"optionsFrom" is not supported in parseWizardYAML \u2014 use loadWizardConfig with a file path'
+          );
+        }
+      }
+    }
+  }
+  const config = parseWizardConfig(raw);
+  detectCycles(config);
+  return config;
+}
+
+// src/conditions.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function getValueByPath(obj, path) {
+  const segments = path.split(".");
+  let current = obj;
+  for (const segment of segments) {
+    if (!isRecord(current)) {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function evaluateCondition(condition, answers) {
+  if ("all" in condition) {
+    return condition.all.every((c) => evaluateCondition(c, answers));
+  }
+  if ("any" in condition) {
+    return condition.any.some((c) => evaluateCondition(c, answers));
+  }
+  if ("not" in condition) {
+    return !evaluateCondition(condition.not, answers);
+  }
+  const value = getValueByPath(answers, condition.field);
+  if ("isEmpty" in condition) {
+    if (value === void 0 || value === null) return true;
+    if (typeof value === "string") return value.length === 0;
+    if (Array.isArray(value)) return value.length === 0;
+    return false;
+  }
+  if ("isNotEmpty" in condition) {
+    if (value === void 0 || value === null) return false;
+    if (typeof value === "string") return value.length > 0;
+    if (Array.isArray(value)) return value.length > 0;
+    return true;
+  }
+  if (value === void 0 || value === null) {
+    return false;
+  }
+  if ("equals" in condition) {
+    return value === condition.equals;
+  }
+  if ("notEquals" in condition) {
+    return value !== condition.notEquals;
+  }
+  if ("includes" in condition) {
+    if (Array.isArray(value)) {
+      return value.includes(condition.includes);
+    }
+    if (typeof value === "string" && typeof condition.includes === "string") {
+      return value.includes(condition.includes);
+    }
+    return false;
+  }
+  if ("notIncludes" in condition) {
+    if (Array.isArray(value)) {
+      return !value.includes(condition.notIncludes);
+    }
+    if (typeof value === "string" && typeof condition.notIncludes === "string") {
+      return !value.includes(condition.notIncludes);
+    }
+    return false;
+  }
+  if ("greaterThan" in condition) {
+    return typeof value === "number" && value > condition.greaterThan;
+  }
+  if ("lessThan" in condition) {
+    return typeof value === "number" && value < condition.lessThan;
+  }
+  return false;
+}
+function isStepVisible(step, answers) {
+  if (!step.when) {
+    return true;
+  }
+  return evaluateCondition(step.when, answers);
+}
+
+// src/engine.ts
+function createWizardState(config) {
+  const firstVisible = config.steps.find((s) => isStepVisible(s, {}));
+  if (!firstVisible) {
+    throw new Error("No visible steps in wizard configuration");
+  }
+  return {
+    currentStepId: firstVisible.id,
+    answers: {},
+    history: [],
+    status: "running",
+    errors: {}
+  };
+}
+function validateStepAnswer(step, value) {
+  if (step.type === "message") {
+    return null;
+  }
+  const isRequired = step.required !== false;
+  if (isRequired) {
+    if (value === void 0 || value === null || value === "") {
+      return "This field is required";
+    }
+    if (Array.isArray(value) && value.length === 0) {
+      return "This field is required";
+    }
+  }
+  if ((step.type === "text" || step.type === "password" || step.type === "editor" || step.type === "path") && step.validate) {
+    const strValue = typeof value === "string" ? value : String(value ?? "");
+    for (const rule of step.validate) {
+      const error = applyValidationRule(rule, strValue);
+      if (error) return error;
+    }
+  }
+  if (step.type === "number" && typeof value === "number") {
+    if (step.min !== void 0 && value < step.min) {
+      return `Must be at least ${String(step.min)}`;
+    }
+    if (step.max !== void 0 && value > step.max) {
+      return `Must be at most ${String(step.max)}`;
+    }
+  }
+  if (step.type === "multiselect" && Array.isArray(value)) {
+    if (step.min !== void 0 && value.length < step.min) {
+      return `Select at least ${String(step.min)} option${step.min === 1 ? "" : "s"}`;
+    }
+    if (step.max !== void 0 && value.length > step.max) {
+      return `Select at most ${String(step.max)} option${step.max === 1 ? "" : "s"}`;
+    }
+  }
+  return null;
+}
+function resolveNextStep(config, currentStep, answer, answers) {
+  let targetId;
+  if (currentStep.type === "select" && currentStep.routes) {
+    const route = currentStep.routes[String(answer)];
+    if (route === "__done__") return "__done__";
+    if (route) targetId = route;
+  }
+  if (!targetId && currentStep.next) {
+    if (currentStep.next === "__done__") return "__done__";
+    targetId = currentStep.next;
+  }
+  if (!targetId) {
+    const currentIndex = config.steps.findIndex((s) => s.id === currentStep.id);
+    const nextInArray = config.steps[currentIndex + 1];
+    if (!nextInArray) return "__done__";
+    targetId = nextInArray.id;
+  }
+  const targetIndex = config.steps.findIndex((s) => s.id === targetId);
+  if (targetIndex < 0) return "__done__";
+  for (let i = targetIndex; i < config.steps.length; i++) {
+    const step = config.steps[i];
+    if (step && isStepVisible(step, answers)) {
+      return step.id;
+    }
+  }
+  return "__done__";
+}
+function getVisibleSteps(config, answers) {
+  return config.steps.filter((s) => isStepVisible(s, answers));
+}
+function wizardReducer(state, transition, config) {
+  switch (transition.type) {
+    case "NEXT": {
+      const currentStep = findStepOrThrow(config, state.currentStepId);
+      const validationError = validateStepAnswer(currentStep, transition.value);
+      if (validationError) {
+        return {
+          ...state,
+          errors: { ...state.errors, [state.currentStepId]: validationError }
+        };
+      }
+      const updatedAnswers = {
+        ...state.answers,
+        [state.currentStepId]: transition.value
+      };
+      const nextStepId = resolveNextStep(
+        config,
+        currentStep,
+        transition.value,
+        updatedAnswers
+      );
+      if (nextStepId === "__done__") {
+        return {
+          ...state,
+          answers: updatedAnswers,
+          history: [...state.history, state.currentStepId],
+          status: "done",
+          errors: {}
+        };
+      }
+      const finalAnswers = cleanOrphanedAnswers(
+        config,
+        updatedAnswers,
+        state.currentStepId,
+        nextStepId
+      );
+      return {
+        ...state,
+        currentStepId: nextStepId,
+        answers: finalAnswers,
+        history: [...state.history, state.currentStepId],
+        status: "running",
+        errors: {}
+      };
+    }
+    case "BACK": {
+      if (state.history.length === 0) {
+        return state;
+      }
+      const previousStepId = state.history[state.history.length - 1];
+      const currentStep = config.steps.find((s) => s.id === state.currentStepId);
+      const newAnswers = { ...state.answers };
+      if (currentStep && currentStep.keepValuesOnPrevious === false) {
+        delete newAnswers[currentStep.id];
+      }
+      return {
+        ...state,
+        currentStepId: previousStepId,
+        answers: newAnswers,
+        history: state.history.slice(0, -1),
+        status: "running",
+        errors: {}
+      };
+    }
+    case "JUMP": {
+      findStepOrThrow(config, transition.stepId);
+      return {
+        ...state,
+        currentStepId: transition.stepId,
+        history: [...state.history, state.currentStepId],
+        status: "running",
+        errors: {}
+      };
+    }
+    case "CANCEL": {
+      return { ...state, status: "cancelled" };
+    }
+  }
+}
+function findStepOrThrow(config, stepId) {
+  const step = config.steps.find((s) => s.id === stepId);
+  if (!step) {
+    throw new Error(`Step not found: "${stepId}"`);
+  }
+  return step;
+}
+function cleanOrphanedAnswers(config, answers, _fromStepId, _toStepId) {
+  const cleaned = { ...answers };
+  for (const step of config.steps) {
+    if (step.id in cleaned && !isStepVisible(step, cleaned)) {
+      delete cleaned[step.id];
+    }
+  }
+  return cleaned;
+}
+function applyValidationRule(rule, value) {
+  switch (rule.rule) {
+    case "required":
+      return !value.trim() ? rule.message ?? "This field is required" : null;
+    case "minLength":
+      return value.length < rule.value ? rule.message ?? `Must be at least ${String(rule.value)} characters` : null;
+    case "maxLength":
+      return value.length > rule.value ? rule.message ?? `Must be at most ${String(rule.value)} characters` : null;
+    case "pattern": {
+      const regex = new RegExp(rule.value);
+      return !regex.test(value) ? rule.message ?? `Must match pattern: ${rule.value}` : null;
+    }
+    case "min":
+    case "max":
+    default:
+      return null;
+  }
+}
+
+// src/theme.ts
+import chalk from "chalk";
+var DEFAULT_TOKENS = {
+  primary: "#5B9BD5",
+  success: "#6BCB77",
+  error: "#FF6B6B",
+  warning: "#FFD93D",
+  info: "#4D96FF",
+  muted: "#888888",
+  accent: "#C084FC"
+};
+var DEFAULT_ICONS = {
+  step: "\u25CF",
+  stepDone: "\u2713",
+  stepPending: "\u25CB",
+  pointer: "\u203A"
+};
+function resolveTheme(themeConfig) {
+  const tokens = { ...DEFAULT_TOKENS, ...themeConfig?.tokens };
+  const icons = { ...DEFAULT_ICONS, ...themeConfig?.icons };
+  return {
+    primary: chalk.hex(tokens.primary),
+    success: chalk.hex(tokens.success),
+    error: chalk.hex(tokens.error),
+    warning: chalk.hex(tokens.warning),
+    info: chalk.hex(tokens.info),
+    muted: chalk.hex(tokens.muted),
+    accent: chalk.hex(tokens.accent),
+    bold: chalk.bold,
+    icons
+  };
+}
+
+// src/resolve.ts
+function resolveEnvDefault(value) {
+  if (typeof value !== "string") return value;
+  if (!value.startsWith("$")) return value;
+  const envKey = value.slice(1);
+  return process.env[envKey] ?? value;
+}
+function resolveEnvDefaultNumber(value) {
+  if (typeof value === "number") return value;
+  const resolved = resolveEnvDefault(typeof value === "string" ? value : void 0);
+  if (resolved === void 0) return void 0;
+  const num = Number(resolved);
+  return Number.isNaN(num) ? void 0 : num;
+}
+function resolveEnvDefaultBoolean(value) {
+  if (typeof value === "boolean") return value;
+  const resolved = resolveEnvDefault(typeof value === "string" ? value : void 0);
+  if (resolved === void 0) return void 0;
+  return resolved === "true" || resolved === "1";
+}
+
+// src/runner.ts
+import { execSync } from "child_process";
+
+// src/renderers/inquirer.ts
+import {
+  input,
+  select,
+  checkbox,
+  confirm,
+  password,
+  number,
+  search,
+  editor,
+  Separator
+} from "@inquirer/prompts";
+var InquirerRenderer = class {
+  renderStepHeader(stepIndex, totalVisible, message, theme, description) {
+    const barWidth = 20;
+    const filledCount = totalVisible > 0 ? Math.round(stepIndex / totalVisible * barWidth) : 0;
+    const remainingCount = barWidth - filledCount;
+    const filledBar = theme.success("\u2588".repeat(filledCount));
+    const remainingBar = theme.muted("\u2591".repeat(remainingCount));
+    const counter = theme.muted(`Step ${String(stepIndex + 1)}/${String(totalVisible)}`);
+    const stepMessage = theme.muted(`\u2014 ${message}`);
+    console.log(`
+  [${filledBar}${remainingBar}]  ${counter} ${stepMessage}`);
+    if (description) {
+      console.log(`  ${theme.muted(description)}`);
+    }
+  }
+  async renderText(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const defaultValue = typeof existingAnswer === "string" ? existingAnswer : step.default;
+    return input({
+      message: step.message,
+      default: defaultValue,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderSelect(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const defaultValue = typeof existingAnswer === "string" ? existingAnswer : step.default;
+    const choices = step.options.map((opt) => {
+      if ("separator" in opt) {
+        return new Separator(opt.separator);
+      }
+      return {
+        name: opt.label,
+        value: opt.value,
+        description: opt.hint,
+        disabled: opt.disabled
+      };
+    });
+    return select({
+      message: step.message,
+      choices,
+      default: defaultValue,
+      pageSize: step.pageSize,
+      loop: step.loop,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderMultiSelect(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const previousSelections = Array.isArray(existingAnswer) ? existingAnswer.filter((v) => typeof v === "string") : step.default;
+    const choices = step.options.map((opt) => {
+      if ("separator" in opt) {
+        return new Separator(opt.separator);
+      }
+      return {
+        name: opt.label,
+        value: opt.value,
+        checked: previousSelections?.includes(opt.value) ?? false,
+        disabled: opt.disabled
+      };
+    });
+    return checkbox({
+      message: step.message,
+      choices,
+      pageSize: step.pageSize,
+      loop: step.loop,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderConfirm(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const defaultValue = typeof existingAnswer === "boolean" ? existingAnswer : step.default;
+    return confirm({
+      message: step.message,
+      default: defaultValue ?? true,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderPassword(step, _state, theme) {
+    return password({
+      message: step.message,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderNumber(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const defaultValue = typeof existingAnswer === "number" ? existingAnswer : step.default;
+    const result = await number({
+      message: step.message,
+      default: defaultValue,
+      min: step.min,
+      max: step.max,
+      step: step.step,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+    return result ?? defaultValue ?? 0;
+  }
+  async renderSearch(step, _state, theme) {
+    return search({
+      message: step.message,
+      source: (input3) => {
+        const term = (input3 ?? "").toLowerCase();
+        return step.options.filter((opt) => "value" in opt).filter((opt) => !opt.disabled && opt.label.toLowerCase().includes(term)).map((opt) => ({
+          name: opt.label,
+          value: opt.value,
+          description: opt.hint
+        }));
+      },
+      pageSize: step.pageSize,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderEditor(step, _state, theme) {
+    return editor({
+      message: step.message,
+      default: step.default,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderPath(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const defaultValue = typeof existingAnswer === "string" ? existingAnswer : step.default;
+    return input({
+      message: step.message,
+      default: defaultValue,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderToggle(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const activeLabel = step.active ?? "On";
+    const inactiveLabel = step.inactive ?? "Off";
+    const defaultValue = typeof existingAnswer === "boolean" ? existingAnswer ? activeLabel : inactiveLabel : step.default === true ? activeLabel : inactiveLabel;
+    const result = await select({
+      message: step.message,
+      choices: [
+        { name: activeLabel, value: activeLabel },
+        { name: inactiveLabel, value: inactiveLabel }
+      ],
+      default: defaultValue,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+    return result === activeLabel;
+  }
+  renderMessage(step, _state, theme) {
+    if (step.description) {
+      console.log(`  ${theme.muted(step.description)}`);
+    }
+    console.log();
+  }
+  renderGroupHeader(group, theme) {
+    console.log(`
+  ${theme.accent("\u2500\u2500")} ${theme.bold(group)} ${theme.accent("\u2500\u2500")}
+`);
+  }
+  renderSummary(answers, steps, theme) {
+    console.log(`
+${theme.muted("\u2500".repeat(40))}`);
+    console.log(`  ${theme.bold("Summary")}
+`);
+    for (const step of steps) {
+      const answer = answers[step.id];
+      if (answer === void 0) continue;
+      const display = Array.isArray(answer) ? answer.map(String).join(", ") : String(answer);
+      console.log(
+        `  ${theme.muted(step.id.padEnd(20))} ${theme.primary(display)}`
+      );
+    }
+    console.log(theme.muted("\u2500".repeat(40)));
+  }
+  clear() {
+    process.stdout.write("\x1B[2J\x1B[0f");
+  }
+};
+
+// src/template.ts
+function resolveTemplate(template, answers) {
+  return template.replace(/\{\{([^}]+)\}\}/g, (_match, key) => {
+    const trimmedKey = key.trim();
+    if (trimmedKey in answers) {
+      const value = answers[trimmedKey];
+      if (Array.isArray(value)) return value.join(", ");
+      return String(value);
+    }
+    return _match;
+  });
+}
+
+// src/banner.ts
+import figlet from "figlet";
+import gradient from "gradient-string";
+var GRIMOIRE_GRADIENT = gradient(["#C084FC", "#5B9BD5", "#6BCB77"]);
+function renderBanner(name, theme, options) {
+  if (options?.plain) {
+    return `  ${theme.bold(name)}`;
+  }
+  try {
+    const art = figlet.textSync(name, {
+      font: "Small",
+      horizontalLayout: "default"
+    });
+    const lines = art.split("\n").map((line) => `  ${line}`).join("\n");
+    return GRIMOIRE_GRADIENT(lines);
+  } catch {
+    return `  ${theme.bold(name)}`;
+  }
+}
+
+// src/plugins.ts
+var BUILT_IN_STEP_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "select",
+  "multiselect",
+  "confirm",
+  "password",
+  "number",
+  "search",
+  "editor",
+  "path",
+  "toggle"
+]);
+var pluginStepRegistry = /* @__PURE__ */ new Map();
+function registerPlugin(plugin) {
+  for (const [stepType, stepPlugin] of Object.entries(plugin.steps)) {
+    if (BUILT_IN_STEP_TYPES.has(stepType)) {
+      throw new Error(`Cannot override built-in step type "${stepType}"`);
+    }
+    if (pluginStepRegistry.has(stepType)) {
+      throw new Error(`Step type "${stepType}" is already registered`);
+    }
+    pluginStepRegistry.set(stepType, stepPlugin);
+  }
+}
+function getPluginStep(stepType) {
+  return pluginStepRegistry.get(stepType);
+}
+function clearPlugins() {
+  pluginStepRegistry.clear();
+}
+
+// src/cache.ts
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync, unlinkSync, readdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var DEFAULT_CACHE_DIR = join(homedir(), ".config", "grimoire", "cache");
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function getCacheDir(customDir) {
+  return customDir ?? DEFAULT_CACHE_DIR;
+}
+function getCacheFilePath(wizardName, customDir) {
+  return join(getCacheDir(customDir), `${slugify(wizardName)}.json`);
+}
+function loadCachedAnswers(wizardName, customDir) {
+  try {
+    const filePath = getCacheFilePath(wizardName, customDir);
+    const raw = readFileSync2(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function saveCachedAnswers(wizardName, answers, customDir) {
+  try {
+    const dir = getCacheDir(customDir);
+    mkdirSync(dir, { recursive: true });
+    const filePath = getCacheFilePath(wizardName, customDir);
+    writeFileSync(filePath, JSON.stringify(answers, null, 2) + "\n", "utf-8");
+  } catch {
+  }
+}
+function clearCache(wizardName, customDir) {
+  try {
+    const dir = getCacheDir(customDir);
+    if (wizardName) {
+      const filePath = getCacheFilePath(wizardName, customDir);
+      unlinkSync(filePath);
+    } else {
+      const files = readdirSync(dir);
+      for (const file of files) {
+        if (file.endsWith(".json")) {
+          unlinkSync(join(dir, file));
+        }
+      }
+    }
+  } catch {
+  }
+}
+
+// src/mru.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var MRU_DIR = join2(homedir2(), ".config", "grimoire", "mru");
+function getMruFilePath(wizardName) {
+  const safeName = wizardName.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return join2(MRU_DIR, `${safeName}.json`);
+}
+function loadMruData(wizardName) {
+  const filePath = getMruFilePath(wizardName);
+  try {
+    if (!existsSync(filePath)) {
+      return {};
+    }
+    const raw = readFileSync3(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return {};
+    }
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+function saveMruData(wizardName, data) {
+  const filePath = getMruFilePath(wizardName);
+  try {
+    mkdirSync2(MRU_DIR, { recursive: true });
+    writeFileSync2(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  } catch {
+  }
+}
+function recordSelection(wizardName, stepId, value) {
+  const data = loadMruData(wizardName);
+  const stepData = data[stepId] ?? {};
+  const values = Array.isArray(value) ? value : [value];
+  for (const v of values) {
+    stepData[v] = (stepData[v] ?? 0) + 1;
+  }
+  data[stepId] = stepData;
+  saveMruData(wizardName, data);
+}
+function getOrderedOptions(wizardName, stepId, options) {
+  const data = loadMruData(wizardName);
+  const stepData = data[stepId] ?? {};
+  if (Object.keys(stepData).length === 0) {
+    return options;
+  }
+  const separatorIndices = /* @__PURE__ */ new Map();
+  const selectableOptions = [];
+  for (let i = 0; i < options.length; i++) {
+    const opt = options[i];
+    if ("separator" in opt) {
+      separatorIndices.set(i, opt);
+    } else {
+      selectableOptions.push(opt);
+    }
+  }
+  const sorted = [...selectableOptions].sort((a, b) => {
+    if (!("value" in a) || !("value" in b)) return 0;
+    const countA = stepData[a.value] ?? 0;
+    const countB = stepData[b.value] ?? 0;
+    return countB - countA;
+  });
+  const result = [];
+  let sortedIndex = 0;
+  for (let i = 0; i < options.length; i++) {
+    const sep = separatorIndices.get(i);
+    if (sep) {
+      result.push(sep);
+    } else {
+      const next = sorted[sortedIndex];
+      if (next) {
+        result.push(next);
+      }
+      sortedIndex++;
+    }
+  }
+  return result;
+}
+function clearMruData(wizardName) {
+  const filePath = getMruFilePath(wizardName);
+  try {
+    if (existsSync(filePath)) {
+      writeFileSync2(filePath, "{}", "utf-8");
+    }
+  } catch {
+  }
+}
+
+// src/runner.ts
+function runPreFlightChecks(checks, theme) {
+  for (const check of checks) {
+    try {
+      execSync(check.run, { stdio: "pipe" });
+      console.log(`  ${theme.success("\u2713")} ${check.name}`);
+    } catch {
+      console.log(`  ${theme.error("\u2717")} ${check.name}: ${check.message}`);
+      throw new Error(`Pre-flight check failed: ${check.name} \u2014 ${check.message}`);
+    }
+  }
+  console.log();
+}
+function getMockValue(step, mockAnswers) {
+  if (step.id in mockAnswers) {
+    return mockAnswers[step.id];
+  }
+  if (step.type === "message") {
+    return true;
+  }
+  const defaultValue = getStepDefault(step);
+  if (defaultValue !== void 0) {
+    return defaultValue;
+  }
+  throw new Error(
+    `Mock mode: no answer provided for step "${step.id}" and no default available`
+  );
+}
+function getStepDefault(step) {
+  switch (step.type) {
+    case "text":
+    case "select":
+    case "search":
+    case "editor":
+    case "path":
+      return step.default;
+    case "number":
+      return step.default;
+    case "confirm":
+    case "toggle":
+      return step.default;
+    case "multiselect":
+      return step.default;
+    case "password":
+    case "message":
+      return void 0;
+  }
+}
+async function runWizard(config, options) {
+  const renderer = options?.renderer ?? new InquirerRenderer();
+  const theme = resolveTheme(config.theme);
+  const mockAnswers = options?.mockAnswers;
+  const isMock = mockAnswers !== void 0;
+  const quiet = options?.quiet ?? isMock;
+  const cacheEnabled = !isMock && options?.cache !== false;
+  const cacheDir = typeof options?.cache === "object" ? options.cache.dir : void 0;
+  const mruEnabled = !isMock && options?.mru !== false;
+  let state = createWizardState(config);
+  const cachedAnswers = cacheEnabled ? loadCachedAnswers(config.meta.name, cacheDir) : void 0;
+  const userPlugins = options?.plugins;
+  if (userPlugins) {
+    for (const plugin of userPlugins) {
+      registerPlugin(plugin);
+    }
+  }
+  try {
+    if (!isMock && config.checks && config.checks.length > 0) {
+      runPreFlightChecks(config.checks, theme);
+    }
+    if (!quiet) {
+      printWizardHeader(config, theme, options?.plain);
+    }
+    let previousGroup;
+    while (state.status === "running") {
+      const visibleSteps = getVisibleSteps(config, state.answers);
+      const currentStep = config.steps.find((s) => s.id === state.currentStepId);
+      if (!currentStep) {
+        throw new Error(`Current step not found: "${state.currentStepId}"`);
+      }
+      if (!isMock) {
+        if (currentStep.group !== void 0 && currentStep.group !== previousGroup) {
+          const resolvedGroup = resolveTemplate(currentStep.group, state.answers);
+          renderer.renderGroupHeader(resolvedGroup, theme);
+        }
+        previousGroup = currentStep.group;
+        const stepIndex = visibleSteps.findIndex((s) => s.id === state.currentStepId);
+        const resolvedMessage = resolveTemplate(currentStep.message, state.answers);
+        const resolvedDescription = currentStep.description ? resolveTemplate(currentStep.description, state.answers) : void 0;
+        renderer.renderStepHeader(stepIndex, visibleSteps.length, resolvedMessage, theme, resolvedDescription);
+      }
+      if (options?.onBeforeStep) {
+        await options.onBeforeStep(currentStep.id, currentStep, state);
+      }
+      const pluginStep = getPluginStep(currentStep.type);
+      const resolvedStep = pluginStep ? currentStep : resolveStepDefaults(currentStep, cachedAnswers);
+      const withTemplate = options?.templateAnswers ? applyTemplateDefaults(resolvedStep, options.templateAnswers) : resolvedStep;
+      const templatedStep = resolveStepTemplates(withTemplate, state.answers);
+      const mruStep = mruEnabled ? applyMruOrdering(templatedStep, config.meta.name) : templatedStep;
+      try {
+        const value = isMock ? getMockValue(mruStep, mockAnswers) : pluginStep ? await pluginStep.render(toStepRecord(mruStep), state, theme) : await renderStep(renderer, mruStep, state, theme);
+        if (pluginStep?.validate) {
+          const pluginError = pluginStep.validate(value, toStepRecord(templatedStep));
+          if (pluginError) {
+            if (isMock) {
+              throw new Error(
+                `Mock mode: validation failed for step "${currentStep.id}": ${pluginError}`
+              );
+            }
+            console.log(theme.error(`
+  ${pluginError}
+`));
+            continue;
+          }
+        }
+        const nextState = wizardReducer(state, { type: "NEXT", value }, config);
+        if (nextState.errors[currentStep.id]) {
+          const errorMsg = resolveTemplate(nextState.errors[currentStep.id] ?? "", state.answers);
+          if (isMock) {
+            throw new Error(
+              `Mock mode: validation failed for step "${currentStep.id}": ${errorMsg}`
+            );
+          }
+          console.log(theme.error(`
+  ${errorMsg}
+`));
+          state = { ...nextState, errors: {} };
+          continue;
+        }
+        if (!isMock && options?.asyncValidate) {
+          const asyncError = await options.asyncValidate(currentStep.id, value, nextState.answers);
+          if (asyncError !== null) {
+            console.log(theme.error(`
+  ${asyncError}
+`));
+            state = { ...nextState, errors: {} };
+            continue;
+          }
+        }
+        if (options?.onAfterStep) {
+          await options.onAfterStep(currentStep.id, value, nextState);
+        }
+        state = nextState;
+        if (mruEnabled && isSelectLikeStep(currentStep.type)) {
+          recordSelection(config.meta.name, currentStep.id, value);
+        }
+        options?.onStepComplete?.(currentStep.id, value, state);
+      } catch (error) {
+        if (!isMock && isUserCancel(error)) {
+          state = wizardReducer(state, { type: "CANCEL" }, config);
+          options?.onCancel?.(state);
+          if (!quiet) {
+            console.log(theme.warning("\n  Wizard cancelled.\n"));
+          }
+          return state.answers;
+        }
+        throw error;
+      }
+    }
+    if (state.status === "done" && !quiet) {
+      renderer.renderSummary(state.answers, config.steps, theme);
+    }
+    if (state.status === "done" && config.actions && config.actions.length > 0 && !isMock) {
+      await executeActions(config.actions, state.answers, theme);
+    }
+    if (state.status === "done" && cacheEnabled) {
+      const passwordStepIds = new Set(
+        config.steps.filter((s) => s.type === "password").map((s) => s.id)
+      );
+      const answersToCache = {};
+      for (const [key, value] of Object.entries(state.answers)) {
+        if (!passwordStepIds.has(key)) {
+          answersToCache[key] = value;
+        }
+      }
+      saveCachedAnswers(config.meta.name, answersToCache, cacheDir);
+    }
+    return state.answers;
+  } finally {
+    if (userPlugins) {
+      clearPlugins();
+    }
+  }
+}
+function toStepRecord(step) {
+  const record = {};
+  for (const [key, val] of Object.entries(step)) {
+    record[key] = val;
+  }
+  return record;
+}
+function renderStep(renderer, step, state, theme) {
+  switch (step.type) {
+    case "text":
+      return renderer.renderText(step, state, theme);
+    case "select":
+      return renderer.renderSelect(step, state, theme);
+    case "multiselect":
+      return renderer.renderMultiSelect(step, state, theme);
+    case "confirm":
+      return renderer.renderConfirm(step, state, theme);
+    case "password":
+      return renderer.renderPassword(step, state, theme);
+    case "number":
+      return renderer.renderNumber(step, state, theme);
+    case "search":
+      return renderer.renderSearch(step, state, theme);
+    case "editor":
+      return renderer.renderEditor(step, state, theme);
+    case "path":
+      return renderer.renderPath(step, state, theme);
+    case "toggle":
+      return renderer.renderToggle(step, state, theme);
+    case "message":
+      renderer.renderMessage(step, state, theme);
+      return Promise.resolve(true);
+  }
+}
+function resolveStepDefaults(step, cachedAnswers) {
+  switch (step.type) {
+    case "text": {
+      const envResolved = resolveEnvDefault(step.default);
+      const fallback = envResolved ?? getCachedDefault(step.id, cachedAnswers);
+      return { ...step, default: fallback };
+    }
+    case "search": {
+      const envResolved = resolveEnvDefault(step.default);
+      const fallback = envResolved ?? getCachedDefault(step.id, cachedAnswers);
+      return { ...step, default: fallback };
+    }
+    case "editor": {
+      const envResolved = resolveEnvDefault(step.default);
+      const fallback = envResolved ?? getCachedDefault(step.id, cachedAnswers);
+      return { ...step, default: fallback };
+    }
+    case "path": {
+      const envResolved = resolveEnvDefault(step.default);
+      const fallback = envResolved ?? getCachedDefault(step.id, cachedAnswers);
+      return { ...step, default: fallback };
+    }
+    case "select": {
+      const envResolved = resolveEnvDefault(step.default);
+      const fallback = envResolved ?? getCachedDefault(step.id, cachedAnswers);
+      return { ...step, default: fallback };
+    }
+    case "number": {
+      const resolved = resolveEnvDefaultNumber(step.default);
+      const fallback = resolved ?? getCachedDefault(step.id, cachedAnswers);
+      return { ...step, default: fallback };
+    }
+    case "confirm": {
+      const resolved = resolveEnvDefaultBoolean(step.default);
+      const fallback = resolved ?? getCachedDefault(step.id, cachedAnswers);
+      return { ...step, default: fallback };
+    }
+    case "toggle": {
+      const resolved = resolveEnvDefaultBoolean(step.default);
+      const fallback = resolved ?? getCachedDefault(step.id, cachedAnswers);
+      return { ...step, default: fallback };
+    }
+    case "multiselect": {
+      const fallback = step.default ?? getCachedDefault(step.id, cachedAnswers);
+      return { ...step, default: fallback };
+    }
+    case "password":
+    case "message":
+      return step;
+  }
+}
+function getCachedDefault(stepId, cachedAnswers) {
+  if (!cachedAnswers || !(stepId in cachedAnswers)) return void 0;
+  return cachedAnswers[stepId];
+}
+function applyTemplateDefaults(step, templateAnswers) {
+  if (!(step.id in templateAnswers)) return step;
+  if (step.type === "password" || step.type === "message") return step;
+  const value = templateAnswers[step.id];
+  switch (step.type) {
+    case "text":
+    case "select":
+    case "search":
+    case "editor":
+    case "path":
+      return { ...step, default: typeof value === "string" ? value : step.default };
+    case "number":
+      return { ...step, default: typeof value === "number" ? value : step.default };
+    case "confirm":
+    case "toggle":
+      return { ...step, default: typeof value === "boolean" ? value : step.default };
+    case "multiselect":
+      return { ...step, default: Array.isArray(value) ? value : step.default };
+  }
+}
+function isSelectLikeStep(type) {
+  return type === "select" || type === "multiselect" || type === "search";
+}
+function applyMruOrdering(step, wizardName) {
+  if (step.type === "select") {
+    return { ...step, options: getOrderedOptions(wizardName, step.id, step.options) };
+  }
+  if (step.type === "multiselect") {
+    return { ...step, options: getOrderedOptions(wizardName, step.id, step.options) };
+  }
+  if (step.type === "search") {
+    return { ...step, options: getOrderedOptions(wizardName, step.id, step.options) };
+  }
+  return step;
+}
+function resolveChoiceTemplates(options, answers) {
+  return options.map((opt) => {
+    if ("separator" in opt) return opt;
+    return {
+      ...opt,
+      label: resolveTemplate(opt.label, answers),
+      hint: opt.hint ? resolveTemplate(opt.hint, answers) : void 0
+    };
+  });
+}
+function resolveStepTemplates(step, answers) {
+  switch (step.type) {
+    case "text":
+      return {
+        ...step,
+        placeholder: step.placeholder ? resolveTemplate(step.placeholder, answers) : void 0,
+        default: step.default ? resolveTemplate(step.default, answers) : void 0,
+        description: step.description ? resolveTemplate(step.description, answers) : void 0
+      };
+    case "select":
+      return {
+        ...step,
+        options: resolveChoiceTemplates(step.options, answers),
+        description: step.description ? resolveTemplate(step.description, answers) : void 0
+      };
+    case "multiselect":
+      return {
+        ...step,
+        options: resolveChoiceTemplates(step.options, answers),
+        description: step.description ? resolveTemplate(step.description, answers) : void 0
+      };
+    case "search":
+      return {
+        ...step,
+        placeholder: step.placeholder ? resolveTemplate(step.placeholder, answers) : void 0,
+        options: resolveChoiceTemplates(step.options, answers),
+        description: step.description ? resolveTemplate(step.description, answers) : void 0
+      };
+    case "path":
+      return {
+        ...step,
+        placeholder: step.placeholder ? resolveTemplate(step.placeholder, answers) : void 0,
+        default: step.default ? resolveTemplate(step.default, answers) : void 0,
+        description: step.description ? resolveTemplate(step.description, answers) : void 0
+      };
+    case "editor":
+      return {
+        ...step,
+        default: step.default ? resolveTemplate(step.default, answers) : void 0,
+        description: step.description ? resolveTemplate(step.description, answers) : void 0
+      };
+    case "password":
+    case "number":
+    case "confirm":
+    case "toggle":
+    case "message":
+      return {
+        ...step,
+        description: step.description ? resolveTemplate(step.description, answers) : void 0
+      };
+  }
+}
+async function executeActions(actions, answers, theme) {
+  console.log(`
+  ${theme.bold("Running actions...")}
+`);
+  for (const action of actions) {
+    if (action.when && !evaluateCondition(action.when, answers)) {
+      continue;
+    }
+    const resolvedCommand = resolveTemplate(action.run, answers);
+    const resolvedName = action.name ? resolveTemplate(action.name, answers) : void 0;
+    const label = resolvedName ?? resolvedCommand;
+    try {
+      execSync(resolvedCommand, { stdio: "pipe" });
+      console.log(`  ${theme.success("\u2713")} ${label}`);
+    } catch {
+      console.log(`  ${theme.error("\u2717")} ${label}`);
+      throw new Error(`Action failed: ${label}`);
+    }
+  }
+  console.log();
+}
+function printWizardHeader(config, theme, plain) {
+  console.log();
+  console.log(renderBanner(config.meta.name, theme, { plain }));
+  if (config.meta.description) {
+    console.log(`  ${theme.muted(config.meta.description)}`);
+  }
+  console.log();
+}
+function isUserCancel(error) {
+  if (error instanceof Error) {
+    return error.message.includes("User force closed") || error.name === "ExitPromptError";
+  }
+  return false;
+}
+
+// src/define.ts
+function defineWizard(config) {
+  return config;
+}
+
+// src/renderers/ink.ts
+import {
+  input as input2,
+  select as select2,
+  checkbox as checkbox2,
+  confirm as confirm2,
+  password as password2,
+  number as number2,
+  search as search2,
+  editor as editor2,
+  Separator as Separator2
+} from "@inquirer/prompts";
+function boxLine(text, theme) {
+  const line = "\u2500".repeat(Math.max(0, 40 - text.length));
+  return `${theme.accent("\u250C\u2500")} ${theme.bold(text)} ${theme.accent(`${line}\u2510`)}`;
+}
+var InkRenderer = class {
+  renderStepHeader(stepIndex, totalVisible, message, theme, description) {
+    const barWidth = 30;
+    const progress = totalVisible > 0 ? stepIndex / totalVisible : 0;
+    const filledCount = Math.round(progress * barWidth);
+    const remainingCount = barWidth - filledCount;
+    const filledBar = theme.success("\u2593".repeat(filledCount));
+    const remainingBar = theme.muted("\u2591".repeat(remainingCount));
+    const pct = `${String(Math.round(progress * 100))}%`;
+    const counter = theme.muted(`Step ${String(stepIndex + 1)}/${String(totalVisible)}`);
+    console.log();
+    console.log(`  ${theme.accent("\u250C")} ${counter} ${theme.muted(pct)}`);
+    console.log(`  ${theme.accent("\u2502")} [${filledBar}${remainingBar}]`);
+    console.log(`  ${theme.accent("\u2514\u2500")} ${theme.primary(message)}`);
+    if (description) {
+      console.log(`     ${theme.muted(description)}`);
+    }
+  }
+  async renderText(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const defaultValue = typeof existingAnswer === "string" ? existingAnswer : step.default;
+    return input2({
+      message: step.message,
+      default: defaultValue,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderSelect(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const defaultValue = typeof existingAnswer === "string" ? existingAnswer : step.default;
+    const choices = step.options.map((opt) => {
+      if ("separator" in opt) {
+        return new Separator2(opt.separator);
+      }
+      return {
+        name: opt.label,
+        value: opt.value,
+        description: opt.hint,
+        disabled: opt.disabled
+      };
+    });
+    return select2({
+      message: step.message,
+      choices,
+      default: defaultValue,
+      pageSize: step.pageSize,
+      loop: step.loop,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderMultiSelect(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const previousSelections = Array.isArray(existingAnswer) ? existingAnswer.filter((v) => typeof v === "string") : step.default;
+    const choices = step.options.map((opt) => {
+      if ("separator" in opt) {
+        return new Separator2(opt.separator);
+      }
+      return {
+        name: opt.label,
+        value: opt.value,
+        checked: previousSelections?.includes(opt.value) ?? false,
+        disabled: opt.disabled
+      };
+    });
+    return checkbox2({
+      message: step.message,
+      choices,
+      pageSize: step.pageSize,
+      loop: step.loop,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderConfirm(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const defaultValue = typeof existingAnswer === "boolean" ? existingAnswer : step.default;
+    return confirm2({
+      message: step.message,
+      default: defaultValue ?? true,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderPassword(step, _state, theme) {
+    return password2({
+      message: step.message,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderNumber(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const defaultValue = typeof existingAnswer === "number" ? existingAnswer : step.default;
+    const result = await number2({
+      message: step.message,
+      default: defaultValue,
+      min: step.min,
+      max: step.max,
+      step: step.step,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+    return result ?? defaultValue ?? 0;
+  }
+  async renderSearch(step, _state, theme) {
+    return search2({
+      message: step.message,
+      source: (term) => {
+        const query = (term ?? "").toLowerCase();
+        return step.options.filter((opt) => "value" in opt).filter((opt) => !opt.disabled && opt.label.toLowerCase().includes(query)).map((opt) => ({
+          name: opt.label,
+          value: opt.value,
+          description: opt.hint
+        }));
+      },
+      pageSize: step.pageSize,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderEditor(step, _state, theme) {
+    return editor2({
+      message: step.message,
+      default: step.default,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderPath(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const defaultValue = typeof existingAnswer === "string" ? existingAnswer : step.default;
+    return input2({
+      message: step.message,
+      default: defaultValue,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+  }
+  async renderToggle(step, state, theme) {
+    const existingAnswer = state.answers[step.id];
+    const activeLabel = step.active ?? "On";
+    const inactiveLabel = step.inactive ?? "Off";
+    const defaultValue = typeof existingAnswer === "boolean" ? existingAnswer ? activeLabel : inactiveLabel : step.default === true ? activeLabel : inactiveLabel;
+    const result = await select2({
+      message: step.message,
+      choices: [
+        { name: activeLabel, value: activeLabel },
+        { name: inactiveLabel, value: inactiveLabel }
+      ],
+      default: defaultValue,
+      theme: { prefix: { idle: theme.icons.pointer, done: theme.icons.stepDone } }
+    });
+    return result === activeLabel;
+  }
+  renderMessage(step, _state, theme) {
+    if (step.description) {
+      console.log(`  ${theme.muted(step.description)}`);
+    }
+    console.log();
+  }
+  renderGroupHeader(group, theme) {
+    console.log();
+    console.log(`  ${boxLine(group, theme)}`);
+    console.log();
+  }
+  renderSummary(answers, steps, theme) {
+    const divider = theme.accent("\u2500".repeat(50));
+    console.log();
+    console.log(`  ${divider}`);
+    console.log(`  ${theme.accent("\u2502")} ${theme.bold("Summary")}`);
+    console.log(`  ${divider}`);
+    for (const step of steps) {
+      const answer = answers[step.id];
+      if (answer === void 0) continue;
+      const display = Array.isArray(answer) ? answer.map(String).join(", ") : String(answer);
+      const label = theme.muted(step.id.padEnd(24));
+      const value = theme.primary(display);
+      console.log(`  ${theme.accent("\u2502")} ${label} ${value}`);
+    }
+    console.log(`  ${divider}`);
+  }
+  clear() {
+    process.stdout.write("\x1B[2J\x1B[0f");
+  }
+};
+
+// src/templates.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, readdirSync as readdirSync2, existsSync as existsSync2 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+var TEMPLATES_DIR = join3(homedir3(), ".config", "grimoire", "templates");
+function getWizardTemplateDir(wizardName) {
+  return join3(TEMPLATES_DIR, slugify(wizardName));
+}
+function getTemplateFilePath(wizardName, templateName) {
+  return join3(getWizardTemplateDir(wizardName), `${slugify(templateName)}.json`);
+}
+function saveTemplate(wizardName, templateName, answers, excludeKeys) {
+  try {
+    const dir = getWizardTemplateDir(wizardName);
+    mkdirSync3(dir, { recursive: true });
+    const filePath = getTemplateFilePath(wizardName, templateName);
+    let answersToSave = answers;
+    if (excludeKeys && excludeKeys.length > 0) {
+      const excluded = new Set(excludeKeys);
+      answersToSave = Object.fromEntries(
+        Object.entries(answers).filter(([k]) => !excluded.has(k))
+      );
+    }
+    writeFileSync3(filePath, JSON.stringify(answersToSave, null, 2) + "\n", "utf-8");
+  } catch {
+  }
+}
+function loadTemplate(wizardName, templateName) {
+  try {
+    const filePath = getTemplateFilePath(wizardName, templateName);
+    const raw = readFileSync4(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function listTemplates(wizardName) {
+  try {
+    const dir = getWizardTemplateDir(wizardName);
+    if (!existsSync2(dir)) return [];
+    return readdirSync2(dir).filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, ""));
+  } catch {
+    return [];
+  }
+}
+function deleteTemplate(wizardName, templateName) {
+  try {
+    const filePath = getTemplateFilePath(wizardName, templateName);
+    unlinkSync2(filePath);
+  } catch {
+  }
+}
+export {
+  InkRenderer,
+  InquirerRenderer,
+  clearCache,
+  clearMruData,
+  clearPlugins,
+  createWizardState,
+  defineWizard,
+  deleteTemplate,
+  evaluateCondition,
+  getCacheDir,
+  getOrderedOptions,
+  getPluginStep,
+  getVisibleSteps,
+  isStepVisible,
+  listTemplates,
+  loadCachedAnswers,
+  loadTemplate,
+  loadWizardConfig,
+  parseWizardConfig,
+  parseWizardYAML,
+  recordSelection,
+  registerPlugin,
+  renderBanner,
+  resolveEnvDefault,
+  resolveNextStep,
+  resolveTemplate,
+  resolveTheme,
+  runPreFlightChecks,
+  runWizard,
+  saveCachedAnswers,
+  saveTemplate,
+  slugify,
+  validateStepAnswer,
+  wizardReducer
+};
+//# sourceMappingURL=index.js.map