@xagent-ai/cli 1.0.1

package/dist/system-prompt-generator.js

@@ -0,0 +1,729 @@
+import { getAgentManager } from './agents.js';
+import { getSkillInvoker } from './skill-invoker.js';
+export class SystemPromptGenerator {
+    toolRegistry;
+    executionMode;
+    agentConfig;
+    constructor(toolRegistry, executionMode, agentConfig) {
+        this.toolRegistry = toolRegistry;
+        this.executionMode = executionMode;
+        this.agentConfig = agentConfig;
+    }
+    async generateEnhancedSystemPrompt(baseSystemPrompt) {
+        let availableTools = this.toolRegistry.getAll().filter(tool => tool.allowedModes.includes(this.executionMode));
+        if (this.agentConfig) {
+            const agentManager = getAgentManager();
+            const allowedToolNames = agentManager.getAvailableToolsForAgent(this.agentConfig, this.executionMode);
+            availableTools = availableTools.filter(tool => allowedToolNames.includes(tool.name));
+        }
+        let enhancedPrompt = baseSystemPrompt;
+        // Only add tool-related content if tools are available
+        if (availableTools.length > 0) {
+            const toolSchemas = this.getToolSchemas(availableTools);
+            const toolUsageGuide = this.generateToolUsageGuide(toolSchemas);
+            const hasInvokeSkillTool = availableTools.some(tool => tool.name === 'InvokeSkill');
+            const skillInstructions = hasInvokeSkillTool ? await this.generateSkillInstructions() : '';
+            const decisionMakingGuide = this.generateDecisionMakingGuide(availableTools);
+            const executionStrategy = this.generateExecutionStrategy();
+            enhancedPrompt += `
+
+${toolUsageGuide}
+
+${skillInstructions}
+
+${decisionMakingGuide}
+
+${executionStrategy}
+
+
+
+## Important Notes
+- Always verify tool results before proceeding to next steps
+- If a tool fails, analyze the error and try alternative approaches
+- Use tools efficiently - avoid redundant calls
+- When in doubt, ask the user for clarification
+- Maintain context across tool calls to build a coherent solution`;
+        }
+        else {
+            // No tools available - explicitly tell the AI not to use tools
+            enhancedPrompt += `
+
+## IMPORTANT: READ-ONLY MODE
+
+You are in DEFAULT mode (read-only mode). You CANNOT use any tools or functions.
+
+STRICT PROHIBITIONS:
+- DO NOT attempt to call any functions, tools, or commands
+- DO NOT output any tool call syntax, such as:
+  - <function_calls>...</function_calls>
+  - ToolName(params)
+  - Function call format
+  - Any similar syntax
+- DO NOT simulate tool calls or pretend to use tools
+- DO NOT output code that would execute tools
+
+REQUIRED BEHAVIOR:
+- Respond ONLY with plain text
+- Answer questions based on your knowledge
+- If you need to read files or perform actions, ask the user to switch modes
+- Tell the user they can use "/mode yolo" or "/mode accept_edits" to enable tools
+
+Remember: You are in a conversational mode, not a tool-execution mode. Just talk to the user!`;
+        }
+        return enhancedPrompt;
+    }
+    getToolSchemas(tools) {
+        return tools.map(tool => this.createToolSchema(tool));
+    }
+    createToolSchema(tool) {
+        const schemas = {
+            Read: {
+                name: 'Read',
+                description: 'Read the contents of a file from the filesystem',
+                parameters: {
+                    filePath: {
+                        type: 'string',
+                        description: 'Path to the file to read (relative or absolute)',
+                        required: true
+                    },
+                    offset: {
+                        type: 'number',
+                        description: 'Starting line number (0-indexed)',
+                        required: false,
+                        default: 0
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Maximum number of lines to read',
+                        required: false
+                    }
+                },
+                usage: 'Use this tool when you need to examine file contents, understand code structure, or read configuration files',
+                examples: [
+                    'Read a specific file: Read(filePath="package.json")',
+                    'Read with line range: Read(filePath="src/index.ts", offset=100, limit=50)'
+                ],
+                bestPractices: [
+                    'Always check if file exists before reading',
+                    'Use offset and limit for large files to avoid excessive output',
+                    'Read configuration files first to understand project structure'
+                ]
+            },
+            Write: {
+                name: 'Write',
+                description: 'Write content to a file, creating directories if needed',
+                parameters: {
+                    filePath: {
+                        type: 'string',
+                        description: 'Path where the file should be written',
+                        required: true
+                    },
+                    content: {
+                        type: 'string',
+                        description: 'Content to write to the file',
+                        required: true
+                    }
+                },
+                usage: 'Use this tool to create new files or completely overwrite existing files',
+                examples: [
+                    'Create a new file: Write(filePath="src/utils.ts", content="export function helper() {}")',
+                    'Write configuration: Write(filePath=".env", content="API_KEY=secret")'
+                ],
+                bestPractices: [
+                    'Always read existing file before overwriting',
+                    'Use proper file extensions',
+                    'Create necessary directory structures',
+                    'Include appropriate comments and documentation'
+                ]
+            },
+            Grep: {
+                name: 'Grep',
+                description: 'Search for text patterns across multiple files',
+                parameters: {
+                    pattern: {
+                        type: 'string',
+                        description: 'Text pattern or regex to search for',
+                        required: true
+                    },
+                    path: {
+                        type: 'string',
+                        description: 'Directory path to search in',
+                        required: false,
+                        default: '.'
+                    },
+                    include: {
+                        type: 'string',
+                        description: 'File pattern to include (glob)',
+                        required: false
+                    },
+                    exclude: {
+                        type: 'string',
+                        description: 'File pattern to exclude (glob)',
+                        required: false
+                    },
+                    case_sensitive: {
+                        type: 'boolean',
+                        description: 'Whether search is case-sensitive',
+                        required: false,
+                        default: false
+                    },
+                    fixed_strings: {
+                        type: 'boolean',
+                        description: 'Treat pattern as literal string, not regex',
+                        required: false,
+                        default: false
+                    },
+                    context: {
+                        type: 'number',
+                        description: 'Number of context lines before and after match',
+                        required: false
+                    },
+                    before: {
+                        type: 'number',
+                        description: 'Number of context lines before match',
+                        required: false
+                    },
+                    after: {
+                        type: 'number',
+                        description: 'Number of context lines after match',
+                        required: false
+                    },
+                    no_ignore: {
+                        type: 'boolean',
+                        description: 'Ignore .gitignore patterns',
+                        required: false,
+                        default: false
+                    }
+                },
+                usage: 'Search for code patterns, function definitions, or text across the codebase',
+                examples: [
+                    'Search for function: Grep(pattern="function.*\\(.*\\)")',
+                    'Find specific text: Grep(pattern="TODO", case_sensitive=true)',
+                    'Search in specific files: Grep(pattern="import", include="*.ts")'
+                ],
+                bestPractices: [
+                    'Use fixed_strings for simple text searches',
+                    'Use context to see surrounding code',
+                    'Narrow search with include/exclude patterns',
+                    'Use case_sensitive for exact matches'
+                ]
+            },
+            Bash: {
+                name: 'Bash',
+                description: 'Execute shell commands in the terminal',
+                parameters: {
+                    command: {
+                        type: 'string',
+                        description: 'Shell command to execute',
+                        required: true
+                    },
+                    cwd: {
+                        type: 'string',
+                        description: 'Working directory for command execution',
+                        required: false
+                    },
+                    description: {
+                        type: 'string',
+                        description: 'Human-readable description of what the command does',
+                        required: false
+                    },
+                    timeout: {
+                        type: 'number',
+                        description: 'Timeout in seconds (default: 120)',
+                        required: false,
+                        default: 120
+                    },
+                    run_in_bg: {
+                        type: 'boolean',
+                        description: 'Run command in background',
+                        required: false,
+                        default: false
+                    }
+                },
+                usage: 'Execute terminal commands, run tests, install dependencies, or perform system operations',
+                examples: [
+                    'Install dependencies: Bash(command="npm install")',
+                    'Run tests: Bash(command="npm test", description="Run unit tests")',
+                    'Build project: Bash(command="npm run build")'
+                ],
+                bestPractices: [
+                    'Always provide clear descriptions',
+                    'Use appropriate timeout values',
+                    'Check command exit codes',
+                    'Handle errors gracefully',
+                    'Use run_in_bg for long-running processes'
+                ]
+            },
+            ListDirectory: {
+                name: 'ListDirectory',
+                description: 'List files and directories in a given path',
+                parameters: {
+                    path: {
+                        type: 'string',
+                        description: 'Directory path to list',
+                        required: true
+                    },
+                    recursive: {
+                        type: 'boolean',
+                        description: 'List recursively',
+                        required: false,
+                        default: false
+                    }
+                },
+                usage: 'Explore directory structure, find files, or understand project layout',
+                examples: [
+                    'List current directory: ListDirectory(path=".")',
+                    'List recursively: ListDirectory(path="src", recursive=true)'
+                ],
+                bestPractices: [
+                    'Use recursive for deep exploration',
+                    'Combine with Read to examine files',
+                    'Check directory existence first'
+                ]
+            },
+            SearchCodebase: {
+                name: 'SearchCodebase',
+                description: 'Semantic search through the codebase using embeddings',
+                parameters: {
+                    query: {
+                        type: 'string',
+                        description: 'Natural language query describing what to search for',
+                        required: true
+                    },
+                    target_directories: {
+                        type: 'array',
+                        description: 'Specific directories to search in',
+                        required: false
+                    }
+                },
+                usage: 'Find code by meaning rather than exact text matches',
+                examples: [
+                    'Find authentication logic: SearchCodebase(query="how do we check authentication headers?")',
+                    'Find error handling: SearchCodebase(query="where do we do error handling in the file watcher?")'
+                ],
+                bestPractices: [
+                    'Use natural language queries',
+                    'Be specific about what you are looking for',
+                    'Combine with Read to examine found code'
+                ]
+            },
+            DeleteFile: {
+                name: 'DeleteFile',
+                description: 'Delete a file from the filesystem',
+                parameters: {
+                    filePath: {
+                        type: 'string',
+                        description: 'Path to the file to delete',
+                        required: true
+                    }
+                },
+                usage: 'Remove files that are no longer needed',
+                examples: [
+                    'Delete file: DeleteFile(filePath="old-file.txt")'
+                ],
+                bestPractices: [
+                    'Verify file is not needed before deletion',
+                    'Use with caution - deletion is permanent',
+                    'Consider backing up important files'
+                ]
+            },
+            CreateDirectory: {
+                name: 'CreateDirectory',
+                description: 'Create a directory and any necessary parent directories',
+                parameters: {
+                    path: {
+                        type: 'string',
+                        description: 'Directory path to create',
+                        required: true
+                    }
+                },
+                usage: 'Create directory structures for organizing files',
+                examples: [
+                    'Create directory: CreateDirectory(path="src/components")'
+                ],
+                bestPractices: [
+                    'Use descriptive directory names',
+                    'Follow project conventions',
+                    'Create necessary parent directories automatically'
+                ]
+            },
+            Replace: {
+                name: 'Replace',
+                description: 'Replace text in a file using search and replace',
+                parameters: {
+                    filePath: {
+                        type: 'string',
+                        description: 'Path to the file to modify',
+                        required: true
+                    },
+                    old_str: {
+                        type: 'string',
+                        description: 'Text to search for',
+                        required: true
+                    },
+                    new_str: {
+                        type: 'string',
+                        description: 'Text to replace with',
+                        required: true
+                    }
+                },
+                usage: 'Make targeted edits to files without rewriting entire content',
+                examples: [
+                    'Replace text: Replace(filePath="config.json", old_str="old value", new_str="new value")'
+                ],
+                bestPractices: [
+                    'Use unique old_str to avoid multiple replacements',
+                    'Read file first to verify content',
+                    'Use Write for large changes'
+                ]
+            },
+            WebSearch: {
+                name: 'WebSearch',
+                description: 'Search the web for information',
+                parameters: {
+                    query: {
+                        type: 'string',
+                        description: 'Search query',
+                        required: true
+                    },
+                    num: {
+                        type: 'number',
+                        description: 'Number of results to return',
+                        required: false,
+                        default: 5
+                    }
+                },
+                usage: 'Find information online, research topics, or get current data',
+                examples: [
+                    'Search web: WebSearch(query="latest Node.js version")',
+                    'Multiple results: WebSearch(query="React best practices", num=10)'
+                ],
+                bestPractices: [
+                    'Use specific search queries',
+                    'Limit results for focused answers',
+                    'Verify information from multiple sources'
+                ]
+            },
+            WebFetch: {
+                name: 'WebFetch',
+                description: 'Fetch and process URL content',
+                parameters: {
+                    prompt: {
+                        type: 'string',
+                        description: 'Prompt containing URL to fetch',
+                        required: true
+                    }
+                },
+                usage: 'Retrieve content from web pages, APIs, or online resources',
+                examples: [
+                    'Fetch URL: WebFetch(prompt="https://api.example.com/data")'
+                ],
+                bestPractices: [
+                    'Handle network errors gracefully',
+                    'Validate URL format',
+                    'Consider rate limiting'
+                ]
+            },
+            TodoWrite: {
+                name: 'TodoWrite',
+                description: 'Create and manage structured task lists',
+                parameters: {
+                    todos: {
+                        type: 'array',
+                        description: 'Array of todo items with id, task, status, and priority',
+                        required: true
+                    }
+                },
+                usage: 'Plan and track complex multi-step tasks',
+                examples: [
+                    'Create todos: TodoWrite(todos=[{"id":"1","task":"Install dependencies","status":"pending","priority":"high"}])'
+                ],
+                bestPractices: [
+                    'Use descriptive task names',
+                    'Set appropriate priorities',
+                    'Update status as tasks progress',
+                    'Break down complex tasks into smaller steps'
+                ]
+            },
+            Task: {
+                name: 'Task',
+                description: 'Launch a specialized agent to handle specific tasks',
+                parameters: {
+                    description: {
+                        type: 'string',
+                        description: 'Brief description of the task',
+                        required: true
+                    },
+                    query: {
+                        type: 'string',
+                        description: 'Detailed task instructions',
+                        required: true
+                    },
+                    subagent_type: {
+                        type: 'string',
+                        description: 'Type of agent to use (plan-agent, explore-agent, frontend-tester, code-reviewer, frontend-developer, backend-developer)',
+                        required: true
+                    },
+                    response_language: {
+                        type: 'string',
+                        description: 'Language for the response',
+                        required: false
+                    }
+                },
+                usage: 'Delegate specialized tasks to expert agents',
+                examples: [
+                    'Plan task: Task(description="Create implementation plan", query="Create a detailed plan for implementing user authentication system", subagent_type="plan-agent")',
+                    'Explore codebase: Task(description="Explore auth module", query="Find and analyze all authentication-related code in the codebase", subagent_type="explore-agent")',
+                    'Run tests: Task(description="Create component tests", query="Write unit tests for the Button component including edge cases", subagent_type="frontend-tester")'
+                ],
+                bestPractices: [
+                    'Choose appropriate agent type for the task',
+                    'Provide clear task descriptions',
+                    'Specify desired response language if needed',
+                    'Review agent results carefully'
+                ]
+            }
+        };
+        // Fallback for unknown tools (including MCP tools)
+        if (schemas[tool.name]) {
+            return schemas[tool.name];
+        }
+        // Convert MCP inputSchema to parameters format
+        const parameters = {};
+        if (tool.inputSchema?.properties) {
+            for (const [paramName, paramDef] of Object.entries(tool.inputSchema.properties)) {
+                parameters[paramName] = {
+                    type: paramDef.type || 'any',
+                    description: paramDef.description || '',
+                    required: tool.inputSchema.required?.includes(paramName) || false,
+                    enum: paramDef.enum
+                };
+            }
+        }
+        return {
+            name: tool.name,
+            description: tool.description,
+            parameters,
+            usage: `Use ${tool.name} for related tasks`,
+            examples: [],
+            bestPractices: []
+        };
+    }
+    generateToolUsageGuide(toolSchemas) {
+        let guide = '## Available Tools\n\n';
+        guide += 'You have access to the following tools. Use them to accomplish user requests:\n\n';
+        toolSchemas.forEach(schema => {
+            guide += `### ${schema.name}\n\n`;
+            guide += `**Description**: ${schema.description}\n\n`;
+            guide += `**Usage**: ${schema.usage}\n\n`;
+            guide += `**Parameters**:\n`;
+            Object.entries(schema.parameters).forEach(([paramName, param]) => {
+                const required = param.required ? ' (required)' : ' (optional)';
+                const defaultValue = param.default !== undefined ? ` (default: ${param.default})` : '';
+                guide += `- \`${paramName}\`${required}${defaultValue}: ${param.description}\n`;
+            });
+            if (schema.examples.length > 0) {
+                guide += `\n**Examples**:\n`;
+                schema.examples.forEach(example => {
+                    guide += `- ${example}\n`;
+                });
+            }
+            if (schema.bestPractices.length > 0) {
+                guide += `\n**Best Practices**:\n`;
+                schema.bestPractices.forEach(practice => {
+                    guide += `- ${practice}\n`;
+                });
+            }
+            guide += '\n---\n\n';
+        });
+        return guide;
+    }
+    generateDecisionMakingGuide(availableTools) {
+        // 工具名称到简短描述的映射
+        const toolDescriptions = {
+            'Read': 'When you need to understand existing code, configuration, or documentation',
+            'Write': 'When creating new files or completely replacing existing content',
+            'Grep': 'When searching for specific patterns, function names, or text across files',
+            'Bash': 'When running tests, installing dependencies, building projects, or executing terminal commands',
+            'SearchCodebase': 'When finding code by meaning rather than exact text matches',
+            'ListDirectory': 'When exploring project structure or finding files',
+            'Replace': 'When making targeted edits without rewriting entire files',
+            'web_search': 'When you need current information from the internet',
+            'web_fetch': 'When retrieving content from specific URLs',
+            'todo_write': 'When planning and tracking complex multi-step tasks',
+            'task': 'When delegating specialized work to expert agents',
+            'DeleteFile': 'When you need to remove a file from the filesystem',
+            'CreateDirectory': 'When you need to create a new directory or folder structure',
+            'ReadBashOutput': 'When you need to read the output of a background task',
+            'ask_user_question': 'When you need to ask the user for clarification or decisions',
+            'save_memory': 'When you need to remember important information for future sessions',
+            'exit_plan_mode': 'When you have completed planning and are ready to execute',
+            'xml_escape': 'When you need to escape special characters in XML/HTML files',
+            'image_read': 'When you need to analyze or read image files',
+            'InvokeSkill': 'When you need to use specialized skills for domain tasks (see Available Skills section for details)'
+        };
+        // 根据可用工具生成 "When to Use Tools" 部分
+        let toolsSection = '### When to Use Tools\n';
+        if (availableTools.length > 0) {
+            for (const tool of availableTools) {
+                const description = toolDescriptions[tool.name] || `When you need to use ${tool.name}`;
+                toolsSection += `- **${tool.name}**: ${description}\n`;
+            }
+        }
+        else {
+            toolsSection += '- (No tools available in current mode)\n';
+        }
+        return `## Decision Making Guide
+
+${toolsSection}
+
+### CRITICAL: IMMEDIATE TOOL EXECUTION
+**YOU MUST CALL TOOLS IMMEDIATELY when needed - DO NOT say "let me..." or "I will..." first!**
+
+When a user asks you to:
+- Read files → IMMEDIATELY call Read tool with the file path
+- List directory → IMMEDIATELY call ListDirectory tool
+- Search code → IMMEDIATELY call Grep or SearchCodebase tool
+- Run commands → IMMEDIATELY call Bash tool
+- Introduce the codebase → IMMEDIATELY call ListDirectory and Read tools
+- Analyze the project → IMMEDIATELY call ListDirectory and Read tools
+- Explain the code → IMMEDIATELY call Read tools
+- Any action requiring tools → IMMEDIATELY make the tool call
+
+**ABSOLUTELY WRONG**:
+- "Let me explore the codebase structure first" (then do nothing)
+- "I will read the file for you" (then do nothing)
+- "Let me help you explore this codebase" (then do nothing)
+- "Let me understand this first" (then do nothing)
+
+**ABSOLUTELY CORRECT**: 
+- Call ListDirectory(path=".") immediately to explore the structure
+- Call Read(filePath="path/to/file") immediately to read the file
+- Call ListDirectory(path=".") immediately when asked to introduce the codebase
+
+**ZERO DELAY POLICY**: 
+- Do NOT add any conversational filler before tool calls
+- Do NOT say "I'm going to" or "Let me" - just CALL THE TOOL
+- Your response should START with the tool call, not with a statement about what you'll do
+
+### Tool Selection Strategy
+1. **Analyze the user's request** - Understand what they want to accomplish
+2. **Identify the core task** - Determine the primary action needed
+3. **Choose the most appropriate tool** - Select the tool that best matches the task
+4. **Consider dependencies** - Some tasks require multiple tools in sequence
+5. **Plan the execution order** - Determine the logical sequence of tool calls
+6. **EXECUTE IMMEDIATELY** - Make the tool call right away without delay
+
+### Common Patterns
+- **Code exploration**: ListDirectory → Read → Grep/SearchCodebase
+- **Feature implementation**: Read (existing code) → Write (new files) → Bash (test)
+- **Bug fixing**: Grep/SearchCodebase (find issue) → Read (understand) → Replace/Write (fix) → Bash (verify)
+- **Project setup**: WebSearch (research) → Write (create files) → Bash (install/build)
+- **Documentation**: Read (code) → Write (docs)
+
+### Error Handling
+- If a tool fails, analyze the error message
+- Try alternative approaches or parameters
+- Ask the user for clarification if needed
+- Report errors clearly with context`;
+    }
+    generateExecutionStrategy() {
+        return `## Execution Strategy
+
+### Step-by-Step Approach
+1. **Understand the goal**: Clarify what the user wants to achieve
+2. **Plan the approach**: Break down complex tasks into smaller steps
+3. **Execute systematically**: Use tools in the right order
+4. **Verify results**: Check each step before proceeding
+5. **Report progress**: Keep the user informed of your actions
+
+### Efficiency Tips
+- **Batch similar operations**: Group related tool calls together
+- **Avoid redundant calls**: Don't read the same file multiple times
+- **Use context wisely**: Leverage information from previous tool results
+- **Be precise**: Use specific parameters to get exactly what you need
+
+### Quality Assurance
+- Always verify tool outputs match expectations
+- Test code changes before declaring success
+- Check for edge cases and error conditions
+- Ensure changes don't break existing functionality
+
+### Communication
+- Explain your reasoning before taking action
+- Provide clear summaries of what you've done
+- Highlight any assumptions you've made
+- Ask for confirmation on destructive operations`;
+    }
+    /**
+     * Dynamically generate skill instructions from loaded skills
+     */
+    async generateSkillInstructions() {
+        try {
+            const skillInvoker = getSkillInvoker();
+            await skillInvoker.initialize();
+            const skills = await skillInvoker.listAvailableSkills();
+            if (skills.length === 0) {
+                return '';
+            }
+            // Group skills by category
+            const skillsByCategory = new Map();
+            for (const skill of skills) {
+                const existing = skillsByCategory.get(skill.category) || [];
+                existing.push(skill);
+                skillsByCategory.set(skill.category, existing);
+            }
+            let guide = '## Available Skills\n\n';
+            guide += 'When users request tasks matching these domains, use the "InvokeSkill" tool to access specialized capabilities:\n\n';
+            for (const [category, categorySkills] of skillsByCategory) {
+                guide += `### ${category}\n`;
+                for (const skill of categorySkills) {
+                    guide += `- **${skill.name}**: ${skill.description}\n`;
+                    guide += `  → Invoke: InvokeSkill(skillId="${skill.id}", taskDescription="...")\n`;
+                }
+                guide += '\n';
+            }
+            return guide;
+        }
+        catch (error) {
+            // If skills can't be loaded, return empty string
+            return '';
+        }
+    }
+    getToolDefinitions() {
+        const tools = this.toolRegistry.getAll().filter(tool => tool.allowedModes.includes(this.executionMode));
+        return tools.map(tool => {
+            const schema = this.createToolSchema(tool);
+            const properties = {};
+            const required = [];
+            Object.entries(schema.parameters).forEach(([paramName, param]) => {
+                properties[paramName] = {
+                    type: param.type,
+                    description: param.description
+                };
+                if (param.enum) {
+                    properties[paramName].enum = param.enum;
+                }
+                if (param.default !== undefined) {
+                    properties[paramName].default = param.default;
+                }
+                if (param.required) {
+                    required.push(paramName);
+                }
+            });
+            return {
+                type: 'function',
+                function: {
+                    name: tool.name,
+                    description: schema.description + '. ' + schema.usage,
+                    parameters: {
+                        type: 'object',
+                        properties,
+                        required
+                    }
+                }
+            };
+        });
+    }
+}
+//# sourceMappingURL=system-prompt-generator.js.map