@xelauvas/xela-cli 0.1.0

package/src/components/agents/new-agent-creation/wizard-steps/GenerateStep.tsx

@@ -0,0 +1,143 @@
+import { APIUserAbortError } from '@anthropic-ai/sdk';
+import React, { type ReactNode, useCallback, useRef, useState } from 'react';
+import { useMainLoopModel } from '../../../../hooks/useMainLoopModel.js';
+import { Box, Text } from '../../../../ink.js';
+import { useKeybinding } from '../../../../keybindings/useKeybinding.js';
+import { createAbortController } from '../../../../utils/abortController.js';
+import { editPromptInEditor } from '../../../../utils/promptEditor.js';
+import { ConfigurableShortcutHint } from '../../../ConfigurableShortcutHint.js';
+import { Byline } from '../../../design-system/Byline.js';
+import { Spinner } from '../../../Spinner.js';
+import TextInput from '../../../TextInput.js';
+import { useWizard } from '../../../wizard/index.js';
+import { WizardDialogLayout } from '../../../wizard/WizardDialogLayout.js';
+import { generateAgent } from '../../generateAgent.js';
+import type { AgentWizardData } from '../types.js';
+export function GenerateStep(): ReactNode {
+  const {
+    updateWizardData,
+    goBack,
+    goToStep,
+    wizardData
+  } = useWizard<AgentWizardData>();
+  const [prompt, setPrompt] = useState(wizardData.generationPrompt || '');
+  const [isGenerating, setIsGenerating] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [cursorOffset, setCursorOffset] = useState(prompt.length);
+  const model = useMainLoopModel();
+  const abortControllerRef = useRef<AbortController | null>(null);
+
+  // Cancel generation when escape pressed during generation
+  const handleCancelGeneration = useCallback(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+      setIsGenerating(false);
+      setError('Generation cancelled');
+    }
+  }, []);
+
+  // Use Settings context so 'n' key doesn't cancel (allows typing 'n' in prompt input)
+  useKeybinding('confirm:no', handleCancelGeneration, {
+    context: 'Settings',
+    isActive: isGenerating
+  });
+  const handleExternalEditor = useCallback(async () => {
+    const result = await editPromptInEditor(prompt);
+    if (result.content !== null) {
+      setPrompt(result.content);
+      setCursorOffset(result.content.length);
+    }
+  }, [prompt]);
+  useKeybinding('chat:externalEditor', handleExternalEditor, {
+    context: 'Chat',
+    isActive: !isGenerating
+  });
+
+  // Go back when escape pressed while not generating
+  const handleGoBack = useCallback(() => {
+    updateWizardData({
+      generationPrompt: '',
+      agentType: '',
+      systemPrompt: '',
+      whenToUse: '',
+      generatedAgent: undefined,
+      wasGenerated: false
+    });
+    setPrompt('');
+    setError(null);
+    goBack();
+  }, [updateWizardData, goBack]);
+
+  // Use Settings context so 'n' key doesn't cancel (allows typing 'n' in prompt input)
+  useKeybinding('confirm:no', handleGoBack, {
+    context: 'Settings',
+    isActive: !isGenerating
+  });
+  const handleGenerate = async (): Promise<void> => {
+    const trimmedPrompt = prompt.trim();
+    if (!trimmedPrompt) {
+      setError('Please describe what the agent should do');
+      return;
+    }
+    setError(null);
+    setIsGenerating(true);
+    updateWizardData({
+      generationPrompt: trimmedPrompt,
+      isGenerating: true
+    });
+
+    // Create abort controller for this generation
+    const controller = createAbortController();
+    abortControllerRef.current = controller;
+    try {
+      const generated = await generateAgent(trimmedPrompt, model, [], controller.signal);
+      updateWizardData({
+        agentType: generated.identifier,
+        whenToUse: generated.whenToUse,
+        systemPrompt: generated.systemPrompt,
+        generatedAgent: generated,
+        isGenerating: false,
+        wasGenerated: true
+      });
+
+      // Skip directly to ToolsStep (index 6) - matching original flow
+      goToStep(6);
+    } catch (err) {
+      // Don't show error if it was cancelled (already set in escape handler)
+      if (err instanceof APIUserAbortError) {
+        // User cancelled - no error to show
+      } else if (err instanceof Error && !err.message.includes('No assistant message found')) {
+        setError(err.message || 'Failed to generate agent');
+      }
+      updateWizardData({
+        isGenerating: false
+      });
+    } finally {
+      setIsGenerating(false);
+      abortControllerRef.current = null;
+    }
+  };
+  const subtitle = 'Describe what this agent should do and when it should be used (be comprehensive for best results)';
+  if (isGenerating) {
+    return <WizardDialogLayout subtitle={subtitle} footerText={<ConfigurableShortcutHint action="confirm:no" context="Settings" fallback="Esc" description="cancel" />}>
+        <Box flexDirection="row" alignItems="center">
+          <Spinner />
+          <Text color="suggestion"> Generating agent from description...</Text>
+        </Box>
+      </WizardDialogLayout>;
+  }
+  return <WizardDialogLayout subtitle={subtitle} footerText={<Byline>
+          <ConfigurableShortcutHint action="confirm:yes" context="Confirmation" fallback="Enter" description="submit" />
+          <ConfigurableShortcutHint action="chat:externalEditor" context="Chat" fallback="ctrl+g" description="open in editor" />
+          <ConfigurableShortcutHint action="confirm:no" context="Settings" fallback="Esc" description="go back" />
+        </Byline>}>
+      <Box flexDirection="column">
+        {error && <Box marginBottom={1}>
+            <Text color="error">{error}</Text>
+          </Box>}
+        <TextInput value={prompt} onChange={setPrompt} onSubmit={handleGenerate} placeholder="e.g., Help me write unit tests for my code..." columns={80} cursorOffset={cursorOffset} onChangeCursorOffset={setCursorOffset} focus showCursor />
+      </Box>
+    </WizardDialogLayout>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["APIUserAbortError","React","ReactNode","useCallback","useRef","useState","useMainLoopModel","Box","Text","useKeybinding","createAbortController","editPromptInEditor","ConfigurableShortcutHint","Byline","Spinner","TextInput","useWizard","WizardDialogLayout","generateAgent","AgentWizardData","GenerateStep","updateWizardData","goBack","goToStep","wizardData","prompt","setPrompt","generationPrompt","isGenerating","setIsGenerating","error","setError","cursorOffset","setCursorOffset","length","model","abortControllerRef","AbortController","handleCancelGeneration","current","abort","context","isActive","handleExternalEditor","result","content","handleGoBack","agentType","systemPrompt","whenToUse","generatedAgent","undefined","wasGenerated","handleGenerate","Promise","trimmedPrompt","trim","controller","generated","signal","identifier","err","Error","message","includes","subtitle"],"sources":["GenerateStep.tsx"],"sourcesContent":["import { APIUserAbortError } from '@anthropic-ai/sdk'\nimport React, { type ReactNode, useCallback, useRef, useState } from 'react'\nimport { useMainLoopModel } from '../../../../hooks/useMainLoopModel.js'\nimport { Box, Text } from '../../../../ink.js'\nimport { useKeybinding } from '../../../../keybindings/useKeybinding.js'\nimport { createAbortController } from '../../../../utils/abortController.js'\nimport { editPromptInEditor } from '../../../../utils/promptEditor.js'\nimport { ConfigurableShortcutHint } from '../../../ConfigurableShortcutHint.js'\nimport { Byline } from '../../../design-system/Byline.js'\nimport { Spinner } from '../../../Spinner.js'\nimport TextInput from '../../../TextInput.js'\nimport { useWizard } from '../../../wizard/index.js'\nimport { WizardDialogLayout } from '../../../wizard/WizardDialogLayout.js'\nimport { generateAgent } from '../../generateAgent.js'\nimport type { AgentWizardData } from '../types.js'\n\nexport function GenerateStep(): ReactNode {\n  const { updateWizardData, goBack, goToStep, wizardData } =\n    useWizard<AgentWizardData>()\n  const [prompt, setPrompt] = useState(wizardData.generationPrompt || '')\n  const [isGenerating, setIsGenerating] = useState(false)\n  const [error, setError] = useState<string | null>(null)\n  const [cursorOffset, setCursorOffset] = useState(prompt.length)\n  const model = useMainLoopModel()\n  const abortControllerRef = useRef<AbortController | null>(null)\n\n  // Cancel generation when escape pressed during generation\n  const handleCancelGeneration = useCallback(() => {\n    if (abortControllerRef.current) {\n      abortControllerRef.current.abort()\n      abortControllerRef.current = null\n      setIsGenerating(false)\n      setError('Generation cancelled')\n    }\n  }, [])\n\n  // Use Settings context so 'n' key doesn't cancel (allows typing 'n' in prompt input)\n  useKeybinding('confirm:no', handleCancelGeneration, {\n    context: 'Settings',\n    isActive: isGenerating,\n  })\n\n  const handleExternalEditor = useCallback(async () => {\n    const result = await editPromptInEditor(prompt)\n    if (result.content !== null) {\n      setPrompt(result.content)\n      setCursorOffset(result.content.length)\n    }\n  }, [prompt])\n\n  useKeybinding('chat:externalEditor', handleExternalEditor, {\n    context: 'Chat',\n    isActive: !isGenerating,\n  })\n\n  // Go back when escape pressed while not generating\n  const handleGoBack = useCallback(() => {\n    updateWizardData({\n      generationPrompt: '',\n      agentType: '',\n      systemPrompt: '',\n      whenToUse: '',\n      generatedAgent: undefined,\n      wasGenerated: false,\n    })\n    setPrompt('')\n    setError(null)\n    goBack()\n  }, [updateWizardData, goBack])\n\n  // Use Settings context so 'n' key doesn't cancel (allows typing 'n' in prompt input)\n  useKeybinding('confirm:no', handleGoBack, {\n    context: 'Settings',\n    isActive: !isGenerating,\n  })\n\n  const handleGenerate = async (): Promise<void> => {\n    const trimmedPrompt = prompt.trim()\n    if (!trimmedPrompt) {\n      setError('Please describe what the agent should do')\n      return\n    }\n\n    setError(null)\n    setIsGenerating(true)\n    updateWizardData({\n      generationPrompt: trimmedPrompt,\n      isGenerating: true,\n    })\n\n    // Create abort controller for this generation\n    const controller = createAbortController()\n    abortControllerRef.current = controller\n\n    try {\n      const generated = await generateAgent(\n        trimmedPrompt,\n        model,\n        [],\n        controller.signal,\n      )\n\n      updateWizardData({\n        agentType: generated.identifier,\n        whenToUse: generated.whenToUse,\n        systemPrompt: generated.systemPrompt,\n        generatedAgent: generated,\n        isGenerating: false,\n        wasGenerated: true,\n      })\n\n      // Skip directly to ToolsStep (index 6) - matching original flow\n      goToStep(6)\n    } catch (err) {\n      // Don't show error if it was cancelled (already set in escape handler)\n      if (err instanceof APIUserAbortError) {\n        // User cancelled - no error to show\n      } else if (\n        err instanceof Error &&\n        !err.message.includes('No assistant message found')\n      ) {\n        setError(err.message || 'Failed to generate agent')\n      }\n      updateWizardData({ isGenerating: false })\n    } finally {\n      setIsGenerating(false)\n      abortControllerRef.current = null\n    }\n  }\n\n  const subtitle =\n    'Describe what this agent should do and when it should be used (be comprehensive for best results)'\n\n  if (isGenerating) {\n    return (\n      <WizardDialogLayout\n        subtitle={subtitle}\n        footerText={\n          <ConfigurableShortcutHint\n            action=\"confirm:no\"\n            context=\"Settings\"\n            fallback=\"Esc\"\n            description=\"cancel\"\n          />\n        }\n      >\n        <Box flexDirection=\"row\" alignItems=\"center\">\n          <Spinner />\n          <Text color=\"suggestion\"> Generating agent from description...</Text>\n        </Box>\n      </WizardDialogLayout>\n    )\n  }\n\n  return (\n    <WizardDialogLayout\n      subtitle={subtitle}\n      footerText={\n        <Byline>\n          <ConfigurableShortcutHint\n            action=\"confirm:yes\"\n            context=\"Confirmation\"\n            fallback=\"Enter\"\n            description=\"submit\"\n          />\n          <ConfigurableShortcutHint\n            action=\"chat:externalEditor\"\n            context=\"Chat\"\n            fallback=\"ctrl+g\"\n            description=\"open in editor\"\n          />\n          <ConfigurableShortcutHint\n            action=\"confirm:no\"\n            context=\"Settings\"\n            fallback=\"Esc\"\n            description=\"go back\"\n          />\n        </Byline>\n      }\n    >\n      <Box flexDirection=\"column\">\n        {error && (\n          <Box marginBottom={1}>\n            <Text color=\"error\">{error}</Text>\n          </Box>\n        )}\n        <TextInput\n          value={prompt}\n          onChange={setPrompt}\n          onSubmit={handleGenerate}\n          placeholder=\"e.g., Help me write unit tests for my code...\"\n          columns={80}\n          cursorOffset={cursorOffset}\n          onChangeCursorOffset={setCursorOffset}\n          focus\n          showCursor\n        />\n      </Box>\n    </WizardDialogLayout>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/src/components/agents/new-agent-creation/wizard-steps/LocationStep.tsx

@@ -0,0 +1,80 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { type ReactNode } from 'react';
+import { Box } from '../../../../ink.js';
+import type { SettingSource } from '../../../../utils/settings/constants.js';
+import { ConfigurableShortcutHint } from '../../../ConfigurableShortcutHint.js';
+import { Select } from '../../../CustomSelect/select.js';
+import { Byline } from '../../../design-system/Byline.js';
+import { KeyboardShortcutHint } from '../../../design-system/KeyboardShortcutHint.js';
+import { useWizard } from '../../../wizard/index.js';
+import { WizardDialogLayout } from '../../../wizard/WizardDialogLayout.js';
+import type { AgentWizardData } from '../types.js';
+export function LocationStep() {
+  const $ = _c(11);
+  const {
+    goNext,
+    updateWizardData,
+    cancel
+  } = useWizard();
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = {
+      label: "Project (.claude/agents/)",
+      value: "projectSettings" as SettingSource
+    };
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  let t1;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = [t0, {
+      label: "Personal (~/.claude/agents/)",
+      value: "userSettings" as SettingSource
+    }];
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const locationOptions = t1;
+  let t2;
+  if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = <Byline><KeyboardShortcutHint shortcut={"\u2191\u2193"} action="navigate" /><KeyboardShortcutHint shortcut="Enter" action="select" /><ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description="cancel" /></Byline>;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  let t3;
+  if ($[3] !== goNext || $[4] !== updateWizardData) {
+    t3 = value => {
+      updateWizardData({
+        location: value as SettingSource
+      });
+      goNext();
+    };
+    $[3] = goNext;
+    $[4] = updateWizardData;
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  let t4;
+  if ($[6] !== cancel) {
+    t4 = () => cancel();
+    $[6] = cancel;
+    $[7] = t4;
+  } else {
+    t4 = $[7];
+  }
+  let t5;
+  if ($[8] !== t3 || $[9] !== t4) {
+    t5 = <WizardDialogLayout subtitle="Choose location" footerText={t2}><Box><Select key="location-select" options={locationOptions} onChange={t3} onCancel={t4} /></Box></WizardDialogLayout>;
+    $[8] = t3;
+    $[9] = t4;
+    $[10] = t5;
+  } else {
+    t5 = $[10];
+  }
+  return t5;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/src/components/agents/new-agent-creation/wizard-steps/MemoryStep.tsx

@@ -0,0 +1,113 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { type ReactNode } from 'react';
+import { Box } from '../../../../ink.js';
+import { useKeybinding } from '../../../../keybindings/useKeybinding.js';
+import { isAutoMemoryEnabled } from '../../../../memdir/paths.js';
+import { type AgentMemoryScope, loadAgentMemoryPrompt } from '../../../../tools/AgentTool/agentMemory.js';
+import { ConfigurableShortcutHint } from '../../../ConfigurableShortcutHint.js';
+import { Select } from '../../../CustomSelect/select.js';
+import { Byline } from '../../../design-system/Byline.js';
+import { KeyboardShortcutHint } from '../../../design-system/KeyboardShortcutHint.js';
+import { useWizard } from '../../../wizard/index.js';
+import { WizardDialogLayout } from '../../../wizard/WizardDialogLayout.js';
+import type { AgentWizardData } from '../types.js';
+type MemoryOption = {
+  label: string;
+  value: AgentMemoryScope | 'none';
+};
+export function MemoryStep() {
+  const $ = _c(13);
+  const {
+    goNext,
+    goBack,
+    updateWizardData,
+    wizardData
+  } = useWizard();
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = {
+      context: "Confirmation"
+    };
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  useKeybinding("confirm:no", goBack, t0);
+  const isUserScope = wizardData.location === "userSettings";
+  let t1;
+  if ($[1] !== isUserScope) {
+    t1 = isUserScope ? [{
+      label: "User scope (~/.claude/agent-memory/) (Recommended)",
+      value: "user"
+    }, {
+      label: "None (no persistent memory)",
+      value: "none"
+    }, {
+      label: "Project scope (.claude/agent-memory/)",
+      value: "project"
+    }, {
+      label: "Local scope (.claude/agent-memory-local/)",
+      value: "local"
+    }] : [{
+      label: "Project scope (.claude/agent-memory/) (Recommended)",
+      value: "project"
+    }, {
+      label: "None (no persistent memory)",
+      value: "none"
+    }, {
+      label: "User scope (~/.claude/agent-memory/)",
+      value: "user"
+    }, {
+      label: "Local scope (.claude/agent-memory-local/)",
+      value: "local"
+    }];
+    $[1] = isUserScope;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const memoryOptions = t1;
+  let t2;
+  if ($[3] !== goNext || $[4] !== updateWizardData || $[5] !== wizardData.finalAgent || $[6] !== wizardData.systemPrompt) {
+    t2 = value => {
+      const memory = value === "none" ? undefined : value as AgentMemoryScope;
+      const agentType = wizardData.finalAgent?.agentType;
+      updateWizardData({
+        selectedMemory: memory,
+        finalAgent: wizardData.finalAgent ? {
+          ...wizardData.finalAgent,
+          memory,
+          getSystemPrompt: isAutoMemoryEnabled() && memory && agentType ? () => wizardData.systemPrompt + "\n\n" + loadAgentMemoryPrompt(agentType, memory) : () => wizardData.systemPrompt
+        } : undefined
+      });
+      goNext();
+    };
+    $[3] = goNext;
+    $[4] = updateWizardData;
+    $[5] = wizardData.finalAgent;
+    $[6] = wizardData.systemPrompt;
+    $[7] = t2;
+  } else {
+    t2 = $[7];
+  }
+  const handleSelect = t2;
+  let t3;
+  if ($[8] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = <Byline><KeyboardShortcutHint shortcut={"\u2191\u2193"} action="navigate" /><KeyboardShortcutHint shortcut="Enter" action="select" /><ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description="go back" /></Byline>;
+    $[8] = t3;
+  } else {
+    t3 = $[8];
+  }
+  let t4;
+  if ($[9] !== goBack || $[10] !== handleSelect || $[11] !== memoryOptions) {
+    t4 = <WizardDialogLayout subtitle="Configure agent memory" footerText={t3}><Box><Select key="memory-select" options={memoryOptions} onChange={handleSelect} onCancel={goBack} /></Box></WizardDialogLayout>;
+    $[9] = goBack;
+    $[10] = handleSelect;
+    $[11] = memoryOptions;
+    $[12] = t4;
+  } else {
+    t4 = $[12];
+  }
+  return t4;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","ReactNode","Box","useKeybinding","isAutoMemoryEnabled","AgentMemoryScope","loadAgentMemoryPrompt","ConfigurableShortcutHint","Select","Byline","KeyboardShortcutHint","useWizard","WizardDialogLayout","AgentWizardData","MemoryOption","label","value","MemoryStep","$","_c","goNext","goBack","updateWizardData","wizardData","t0","Symbol","for","context","isUserScope","location","t1","memoryOptions","t2","finalAgent","systemPrompt","memory","undefined","agentType","selectedMemory","getSystemPrompt","handleSelect","t3","t4"],"sources":["MemoryStep.tsx"],"sourcesContent":["import React, { type ReactNode } from 'react'\nimport { Box } from '../../../../ink.js'\nimport { useKeybinding } from '../../../../keybindings/useKeybinding.js'\nimport { isAutoMemoryEnabled } from '../../../../memdir/paths.js'\nimport {\n  type AgentMemoryScope,\n  loadAgentMemoryPrompt,\n} from '../../../../tools/AgentTool/agentMemory.js'\nimport { ConfigurableShortcutHint } from '../../../ConfigurableShortcutHint.js'\nimport { Select } from '../../../CustomSelect/select.js'\nimport { Byline } from '../../../design-system/Byline.js'\nimport { KeyboardShortcutHint } from '../../../design-system/KeyboardShortcutHint.js'\nimport { useWizard } from '../../../wizard/index.js'\nimport { WizardDialogLayout } from '../../../wizard/WizardDialogLayout.js'\nimport type { AgentWizardData } from '../types.js'\n\ntype MemoryOption = {\n  label: string\n  value: AgentMemoryScope | 'none'\n}\n\nexport function MemoryStep(): ReactNode {\n  const { goNext, goBack, updateWizardData, wizardData } =\n    useWizard<AgentWizardData>()\n\n  useKeybinding('confirm:no', goBack, { context: 'Confirmation' })\n\n  const isUserScope = wizardData.location === 'userSettings'\n\n  // Build options with the recommended default first, then alternatives\n  // The recommended scope matches the agent's location (project agent → project memory, user agent → user memory)\n  const memoryOptions: MemoryOption[] = isUserScope\n    ? [\n        {\n          label: 'User scope (~/.claude/agent-memory/) (Recommended)',\n          value: 'user',\n        },\n        { label: 'None (no persistent memory)', value: 'none' },\n        { label: 'Project scope (.claude/agent-memory/)', value: 'project' },\n        { label: 'Local scope (.claude/agent-memory-local/)', value: 'local' },\n      ]\n    : [\n        {\n          label: 'Project scope (.claude/agent-memory/) (Recommended)',\n          value: 'project',\n        },\n        { label: 'None (no persistent memory)', value: 'none' },\n        { label: 'User scope (~/.claude/agent-memory/)', value: 'user' },\n        { label: 'Local scope (.claude/agent-memory-local/)', value: 'local' },\n      ]\n\n  const handleSelect = (value: string): void => {\n    const memory = value === 'none' ? undefined : (value as AgentMemoryScope)\n    const agentType = wizardData.finalAgent?.agentType\n    updateWizardData({\n      selectedMemory: memory,\n      // Update finalAgent with memory and rewire getSystemPrompt to include memory loading.\n      // Explicitly set memory (not conditional spread) so selecting 'none' after going back clears it.\n      finalAgent: wizardData.finalAgent\n        ? {\n            ...wizardData.finalAgent,\n            memory,\n            getSystemPrompt:\n              isAutoMemoryEnabled() && memory && agentType\n                ? () =>\n                    wizardData.systemPrompt! +\n                    '\\n\\n' +\n                    loadAgentMemoryPrompt(agentType, memory)\n                : () => wizardData.systemPrompt!,\n          }\n        : undefined,\n    })\n    goNext()\n  }\n\n  return (\n    <WizardDialogLayout\n      subtitle=\"Configure agent memory\"\n      footerText={\n        <Byline>\n          <KeyboardShortcutHint shortcut=\"↑↓\" action=\"navigate\" />\n          <KeyboardShortcutHint shortcut=\"Enter\" action=\"select\" />\n          <ConfigurableShortcutHint\n            action=\"confirm:no\"\n            context=\"Confirmation\"\n            fallback=\"Esc\"\n            description=\"go back\"\n          />\n        </Byline>\n      }\n    >\n      <Box>\n        <Select\n          key=\"memory-select\"\n          options={memoryOptions}\n          onChange={handleSelect}\n          onCancel={goBack}\n        />\n      </Box>\n    </WizardDialogLayout>\n  )\n}\n"],"mappings":";AAAA,OAAOA,KAAK,IAAI,KAAKC,SAAS,QAAQ,OAAO;AAC7C,SAASC,GAAG,QAAQ,oBAAoB;AACxC,SAASC,aAAa,QAAQ,0CAA0C;AACxE,SAASC,mBAAmB,QAAQ,6BAA6B;AACjE,SACE,KAAKC,gBAAgB,EACrBC,qBAAqB,QAChB,4CAA4C;AACnD,SAASC,wBAAwB,QAAQ,sCAAsC;AAC/E,SAASC,MAAM,QAAQ,iCAAiC;AACxD,SAASC,MAAM,QAAQ,kCAAkC;AACzD,SAASC,oBAAoB,QAAQ,gDAAgD;AACrF,SAASC,SAAS,QAAQ,0BAA0B;AACpD,SAASC,kBAAkB,QAAQ,uCAAuC;AAC1E,cAAcC,eAAe,QAAQ,aAAa;AAElD,KAAKC,YAAY,GAAG;EAClBC,KAAK,EAAE,MAAM;EACbC,KAAK,EAAEX,gBAAgB,GAAG,MAAM;AAClC,CAAC;AAED,OAAO,SAAAY,WAAA;EAAA,MAAAC,CAAA,GAAAC,EAAA;EACL;IAAAC,MAAA;IAAAC,MAAA;IAAAC,gBAAA;IAAAC;EAAA,IACEZ,SAAS,CAAkB,CAAC;EAAA,IAAAa,EAAA;EAAA,IAAAN,CAAA,QAAAO,MAAA,CAAAC,GAAA;IAEMF,EAAA;MAAAG,OAAA,EAAW;IAAe,CAAC;IAAAT,CAAA,MAAAM,EAAA;EAAA;IAAAA,EAAA,GAAAN,CAAA;EAAA;EAA/Df,aAAa,CAAC,YAAY,EAAEkB,MAAM,EAAEG,EAA2B,CAAC;EAEhE,MAAAI,WAAA,GAAoBL,UAAU,CAAAM,QAAS,KAAK,cAAc;EAAA,IAAAC,EAAA;EAAA,IAAAZ,CAAA,QAAAU,WAAA;IAIpBE,EAAA,GAAAF,WAAW,GAAX,CAEhC;MAAAb,KAAA,EACS,oDAAoD;MAAAC,KAAA,EACpD;IACT,CAAC,EACD;MAAAD,KAAA,EAAS,6BAA6B;MAAAC,KAAA,EAAS;IAAO,CAAC,EACvD;MAAAD,KAAA,EAAS,uCAAuC;MAAAC,KAAA,EAAS;IAAU,CAAC,EACpE;MAAAD,KAAA,EAAS,2CAA2C;MAAAC,KAAA,EAAS;IAAQ,CAAC,CAUvE,GAlBiC,CAWhC;MAAAD,KAAA,EACS,qDAAqD;MAAAC,KAAA,EACrD;IACT,CAAC,EACD;MAAAD,KAAA,EAAS,6BAA6B;MAAAC,KAAA,EAAS;IAAO,CAAC,EACvD;MAAAD,KAAA,EAAS,sCAAsC;MAAAC,KAAA,EAAS;IAAO,CAAC,EAChE;MAAAD,KAAA,EAAS,2CAA2C;MAAAC,KAAA,EAAS;IAAQ,CAAC,CACvE;IAAAE,CAAA,MAAAU,WAAA;IAAAV,CAAA,MAAAY,EAAA;EAAA;IAAAA,EAAA,GAAAZ,CAAA;EAAA;EAlBL,MAAAa,aAAA,GAAsCD,EAkBjC;EAAA,IAAAE,EAAA;EAAA,IAAAd,CAAA,QAAAE,MAAA,IAAAF,CAAA,QAAAI,gBAAA,IAAAJ,CAAA,QAAAK,UAAA,CAAAU,UAAA,IAAAf,CAAA,QAAAK,UAAA,CAAAW,YAAA;IAEgBF,EAAA,GAAAhB,KAAA;MACnB,MAAAmB,MAAA,GAAenB,KAAK,KAAK,MAAgD,GAA1DoB,SAA0D,GAA1BpB,KAAK,IAAIX,gBAAiB;MACzE,MAAAgC,SAAA,GAAkBd,UAAU,CAAAU,UAAsB,EAAAI,SAAA;MAClDf,gBAAgB,CAAC;QAAAgB,cAAA,EACCH,MAAM;QAAAF,UAAA,EAGVV,UAAU,CAAAU,UAYT,GAZD;UAAA,GAEHV,UAAU,CAAAU,UAAW;UAAAE,MAAA;UAAAI,eAAA,EAGtBnC,mBAAmB,CAAW,CAAC,IAA/B+B,MAA4C,IAA5CE,SAKkC,GALlC,MAEMd,UAAU,CAAAW,YAAa,GACvB,MAAM,GACN5B,qBAAqB,CAAC+B,SAAS,EAAEF,MAAM,CACX,GALlC,MAKUZ,UAAU,CAAAW;QAEhB,CAAC,GAZDE;MAad,CAAC,CAAC;MACFhB,MAAM,CAAC,CAAC;IAAA,CACT;IAAAF,CAAA,MAAAE,MAAA;IAAAF,CAAA,MAAAI,gBAAA;IAAAJ,CAAA,MAAAK,UAAA,CAAAU,UAAA;IAAAf,CAAA,MAAAK,UAAA,CAAAW,YAAA;IAAAhB,CAAA,MAAAc,EAAA;EAAA;IAAAA,EAAA,GAAAd,CAAA;EAAA;EAtBD,MAAAsB,YAAA,GAAqBR,EAsBpB;EAAA,IAAAS,EAAA;EAAA,IAAAvB,CAAA,QAAAO,MAAA,CAAAC,GAAA;IAMKe,EAAA,IAAC,MAAM,CACL,CAAC,oBAAoB,CAAU,QAAI,CAAJ,eAAG,CAAC,CAAQ,MAAU,CAAV,UAAU,GACrD,CAAC,oBAAoB,CAAU,QAAO,CAAP,OAAO,CAAQ,MAAQ,CAAR,QAAQ,GACtD,CAAC,wBAAwB,CAChB,MAAY,CAAZ,YAAY,CACX,OAAc,CAAd,cAAc,CACb,QAAK,CAAL,KAAK,CACF,WAAS,CAAT,SAAS,GAEzB,EATC,MAAM,CASE;IAAAvB,CAAA,MAAAuB,EAAA;EAAA;IAAAA,EAAA,GAAAvB,CAAA;EAAA;EAAA,IAAAwB,EAAA;EAAA,IAAAxB,CAAA,QAAAG,MAAA,IAAAH,CAAA,SAAAsB,YAAA,IAAAtB,CAAA,SAAAa,aAAA;IAZbW,EAAA,IAAC,kBAAkB,CACR,QAAwB,CAAxB,wBAAwB,CAE/B,UASS,CATT,CAAAD,EASQ,CAAC,CAGX,CAAC,GAAG,CACF,CAAC,MAAM,CACD,GAAe,CAAf,eAAe,CACVV,OAAa,CAAbA,cAAY,CAAC,CACZS,QAAY,CAAZA,aAAW,CAAC,CACZnB,QAAM,CAANA,OAAK,CAAC,GAEpB,EAPC,GAAG,CAQN,EAvBC,kBAAkB,CAuBE;IAAAH,CAAA,MAAAG,MAAA;IAAAH,CAAA,OAAAsB,YAAA;IAAAtB,CAAA,OAAAa,aAAA;IAAAb,CAAA,OAAAwB,EAAA;EAAA;IAAAA,EAAA,GAAAxB,CAAA;EAAA;EAAA,OAvBrBwB,EAuBqB;AAAA","ignoreList":[]}

package/src/components/agents/new-agent-creation/wizard-steps/MethodStep.tsx

@@ -0,0 +1,80 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { type ReactNode } from 'react';
+import { Box } from '../../../../ink.js';
+import { ConfigurableShortcutHint } from '../../../ConfigurableShortcutHint.js';
+import { Select } from '../../../CustomSelect/select.js';
+import { Byline } from '../../../design-system/Byline.js';
+import { KeyboardShortcutHint } from '../../../design-system/KeyboardShortcutHint.js';
+import { useWizard } from '../../../wizard/index.js';
+import { WizardDialogLayout } from '../../../wizard/WizardDialogLayout.js';
+import type { AgentWizardData } from '../types.js';
+export function MethodStep() {
+  const $ = _c(11);
+  const {
+    goNext,
+    goBack,
+    updateWizardData,
+    goToStep
+  } = useWizard();
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = [{
+      label: "Generate with Claude (recommended)",
+      value: "generate"
+    }, {
+      label: "Manual configuration",
+      value: "manual"
+    }];
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const methodOptions = t0;
+  let t1;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = <Byline><KeyboardShortcutHint shortcut={"\u2191\u2193"} action="navigate" /><KeyboardShortcutHint shortcut="Enter" action="select" /><ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description="go back" /></Byline>;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  let t2;
+  if ($[2] !== goNext || $[3] !== goToStep || $[4] !== updateWizardData) {
+    t2 = value => {
+      const method = value as 'generate' | 'manual';
+      updateWizardData({
+        method,
+        wasGenerated: method === "generate"
+      });
+      if (method === "generate") {
+        goNext();
+      } else {
+        goToStep(3);
+      }
+    };
+    $[2] = goNext;
+    $[3] = goToStep;
+    $[4] = updateWizardData;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  let t3;
+  if ($[6] !== goBack) {
+    t3 = () => goBack();
+    $[6] = goBack;
+    $[7] = t3;
+  } else {
+    t3 = $[7];
+  }
+  let t4;
+  if ($[8] !== t2 || $[9] !== t3) {
+    t4 = <WizardDialogLayout subtitle="Creation method" footerText={t1}><Box><Select key="method-select" options={methodOptions} onChange={t2} onCancel={t3} /></Box></WizardDialogLayout>;
+    $[8] = t2;
+    $[9] = t3;
+    $[10] = t4;
+  } else {
+    t4 = $[10];
+  }
+  return t4;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/src/components/agents/new-agent-creation/wizard-steps/ModelStep.tsx

@@ -0,0 +1,52 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { type ReactNode } from 'react';
+import { ConfigurableShortcutHint } from '../../../ConfigurableShortcutHint.js';
+import { Byline } from '../../../design-system/Byline.js';
+import { KeyboardShortcutHint } from '../../../design-system/KeyboardShortcutHint.js';
+import { useWizard } from '../../../wizard/index.js';
+import { WizardDialogLayout } from '../../../wizard/WizardDialogLayout.js';
+import { ModelSelector } from '../../ModelSelector.js';
+import type { AgentWizardData } from '../types.js';
+export function ModelStep() {
+  const $ = _c(8);
+  const {
+    goNext,
+    goBack,
+    updateWizardData,
+    wizardData
+  } = useWizard();
+  let t0;
+  if ($[0] !== goNext || $[1] !== updateWizardData) {
+    t0 = model => {
+      updateWizardData({
+        selectedModel: model
+      });
+      goNext();
+    };
+    $[0] = goNext;
+    $[1] = updateWizardData;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  const handleComplete = t0;
+  let t1;
+  if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = <Byline><KeyboardShortcutHint shortcut={"\u2191\u2193"} action="navigate" /><KeyboardShortcutHint shortcut="Enter" action="select" /><ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description="go back" /></Byline>;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  let t2;
+  if ($[4] !== goBack || $[5] !== handleComplete || $[6] !== wizardData.selectedModel) {
+    t2 = <WizardDialogLayout subtitle="Select model" footerText={t1}><ModelSelector initialModel={wizardData.selectedModel} onComplete={handleComplete} onCancel={goBack} /></WizardDialogLayout>;
+    $[4] = goBack;
+    $[5] = handleComplete;
+    $[6] = wizardData.selectedModel;
+    $[7] = t2;
+  } else {
+    t2 = $[7];
+  }
+  return t2;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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