Fully autonomous AI Agents system capable of performing complex penetration testing tasks
Go ai-agentsai-security-toolanthropicautonomous-agentsgolanggptgraphqlmulti-agent-systemoffensive-securityopen-sourceopenaipenetration-testingpenetration-testing-toolsreactsecurity-automationsecurity-testingsecurity-toolsself-hosted
package templates
import (
"bytes"
"crypto/rand"
"embed"
"encoding/json"
"errors"
"fmt"
"maps"
"math/big"
"path"
"regexp"
"strconv"
"strings"
"sync"
"text/template"
)
//go:embed prompts/*.tmpl
var promptTemplates embed.FS
//go:embed graphiti/*.tmpl
var graphitiTemplates embed.FS
var ErrTemplateNotFound = errors.New("template not found")
type PromptType string
const (
PromptTypePrimaryAgent PromptType = "primary_agent" // orchestrates subtask execution using AI agents
PromptTypeAssistant PromptType = "assistant" // interactive AI assistant for user conversations
PromptTypePentester PromptType = "pentester" // executes security tests and vulnerability scanning
PromptTypeQuestionPentester PromptType = "question_pentester" // human input requesting penetration testing
PromptTypeCoder PromptType = "coder" // develops exploits and custom security tools
PromptTypeQuestionCoder PromptType = "question_coder" // human input requesting code development
PromptTypeInstaller PromptType = "installer" // sets up testing environment and tools
PromptTypeQuestionInstaller PromptType = "question_installer" // human input requesting system installation
PromptTypeSearcher PromptType = "searcher" // gathers intelligence from web sources
PromptTypeQuestionSearcher PromptType = "question_searcher" // human input requesting information search
PromptTypeMemorist PromptType = "memorist" // retrieves knowledge from vector memory store
PromptTypeQuestionMemorist PromptType = "question_memorist" // human input querying past experiences
PromptTypeAdviser PromptType = "adviser" // provides security recommendations and guidance
PromptTypeQuestionAdviser PromptType = "question_adviser" // human input seeking expert advice
PromptTypeGenerator PromptType = "generator" // creates structured subtask breakdown
PromptTypeSubtasksGenerator PromptType = "subtasks_generator" // human input for task decomposition
PromptTypeRefiner PromptType = "refiner" // optimizes and adjusts planned subtasks
PromptTypeSubtasksRefiner PromptType = "subtasks_refiner" // human input for task refinement
PromptTypeReporter PromptType = "reporter" // generates comprehensive security reports
PromptTypeTaskReporter PromptType = "task_reporter" // human input for result documentation
PromptTypeReflector PromptType = "reflector" // analyzes outcomes and suggests improvements
PromptTypeQuestionReflector PromptType = "question_reflector" // human input for self-assessment
PromptTypeEnricher PromptType = "enricher" // adds context and details to requests
PromptTypeQuestionEnricher PromptType = "question_enricher" // human input for context enhancement
PromptTypeToolCallFixer PromptType = "toolcall_fixer" // corrects malformed security tool commands
PromptTypeInputToolCallFixer PromptType = "input_toolcall_fixer" // human input for tool argument fixing
PromptTypeSummarizer PromptType = "summarizer" // condenses long conversations and results
PromptTypeImageChooser PromptType = "image_chooser" // selects appropriate Docker containers
PromptTypeLanguageChooser PromptType = "language_chooser" // determines user's preferred language
PromptTypeFlowDescriptor PromptType = "flow_descriptor" // generates flow titles from user requests
PromptTypeTaskDescriptor PromptType = "task_descriptor" // generates task titles from user requests
PromptTypeExecutionLogs PromptType = "execution_logs" // formats execution history for display
PromptTypeFullExecutionContext PromptType = "full_execution_context" // prepares complete context for summarization
PromptTypeShortExecutionContext PromptType = "short_execution_context" // prepares minimal context for quick processing
PromptTypeToolCallIDCollector PromptType = "tool_call_id_collector" // requests function call to collect tool call ID sample
PromptTypeToolCallIDDetector PromptType = "tool_call_id_detector" // analyzes tool call ID samples to detect pattern template
PromptTypeQuestionExecutionMonitor PromptType = "question_execution_monitor" // question for adviser to monitor agent execution progress
PromptTypeQuestionTaskPlanner PromptType = "question_task_planner" // question for adviser to create execution plan for agent
PromptTypeTaskAssignmentWrapper PromptType = "task_assignment_wrapper" // wraps original request with execution plan for specialist agents
)
var PromptVariables = map[PromptType][]string{
PromptTypePrimaryAgent: {
"FinalyToolName",
"SearchToolName",
"PentesterToolName",
"CoderToolName",
"AdviceToolName",
"MemoristToolName",
"MaintenanceToolName",
"SummarizationToolName",
"SummarizedContentPrefix",
"AskUserToolName",
"AskUserEnabled",
"ExecutionContext",
"Cwd",
"Lang",
"DockerImage",
"CurrentTime",
"ToolPlaceholder",
"UserFiles",
},
PromptTypeAssistant: {
"SearchToolName",
"PentesterToolName",
"CoderToolName",
"AdviceToolName",
"MemoristToolName",
"MaintenanceToolName",
"TerminalToolName",
"FileToolName",
"WebSearchToolName",
"BrowserToolName",
"SearchInMemoryToolName",
"SearchGuideToolName",
"SearchAnswerToolName",
"SearchCodeToolName",
"SummarizationToolName",
"SummarizedContentPrefix",
"UseAgents",
"DockerImage",
"Cwd",
"ContainerPorts",
"ExecutionContext",
"Lang",
"CurrentTime",
"FlowManagerEnabled",
"GetFlowStatusToolName",
"StopFlowToolName",
"SubmitFlowInputToolName",
"PatchFlowSubtasksToolName",
"WaitFlowCompletionToolName",
"UserFiles",
},
PromptTypePentester: {
"HackResultToolName",
"WebSearchToolName",
"SearchGuideToolName",
"StoreGuideToolName",
"GraphitiEnabled",
"GraphitiSearchToolName",
"SearchToolName",
"CoderToolName",
"AdviceToolName",
"MemoristToolName",
"MaintenanceToolName",
"TerminalToolName",
"FileToolName",
"SummarizationToolName",
"SummarizedContentPrefix",
"IsDefaultDockerImage",
"DockerImage",
"Cwd",
"ContainerPorts",
"ExecutionContext",
"Lang",
"CurrentTime",
"ToolPlaceholder",
"UserFiles",
},
PromptTypeQuestionPentester: {
"Question",
},
PromptTypeCoder: {
"CodeResultToolName",
"SearchCodeToolName",
"StoreCodeToolName",
"GraphitiEnabled",
"GraphitiSearchToolName",
"SearchToolName",
"AdviceToolName",
"MemoristToolName",
"MaintenanceToolName",
"TerminalToolName",
"FileToolName",
"SummarizationToolName",
"SummarizedContentPrefix",
"DockerImage",
"Cwd",
"ContainerPorts",
"ExecutionContext",
"Lang",
"CurrentTime",
"ToolPlaceholder",
"UserFiles",
},
PromptTypeQuestionCoder: {
"Question",
},
PromptTypeInstaller: {
"MaintenanceResultToolName",
"SearchGuideToolName",
"StoreGuideToolName",
"SearchToolName",
"AdviceToolName",
"MemoristToolName",
"TerminalToolName",
"FileToolName",
"SummarizationToolName",
"SummarizedContentPrefix",
"DockerImage",
"Cwd",
"ContainerPorts",
"ExecutionContext",
"Lang",
"CurrentTime",
"ToolPlaceholder",
"UserFiles",
},
PromptTypeQuestionInstaller: {
"Question",
},
PromptTypeSearcher: {
"SearchResultToolName",
"SearchAnswerToolName",
"StoreAnswerToolName",
"SummarizationToolName",
"SummarizedContentPrefix",
"ExecutionContext",
"Cwd",
"Lang",
"CurrentTime",
"ToolPlaceholder",
"UserFiles",
},
PromptTypeQuestionSearcher: {
"Question",
"Task",
"Subtask",
},
PromptTypeMemorist: {
"MemoristResultToolName",
"GraphitiEnabled",
"GraphitiSearchToolName",
"TerminalToolName",
"FileToolName",
"SummarizationToolName",
"SummarizedContentPrefix",
"DockerImage",
"Cwd",
"ContainerPorts",
"ExecutionContext",
"Lang",
"CurrentTime",
"ToolPlaceholder",
"UserFiles",
},
PromptTypeQuestionMemorist: {
"Question",
"Task",
"Subtask",
"ExecutionDetails",
},
PromptTypeAdviser: {
"ExecutionContext",
"CurrentTime",
"FinalyToolName",
"PentesterToolName",
"HackResultToolName",
"CoderToolName",
"CodeResultToolName",
"MaintenanceToolName",
"MaintenanceResultToolName",
"SearchToolName",
"SearchResultToolName",
"MemoristToolName",
"AdviceToolName",
"DockerImage",
"Cwd",
"ContainerPorts",
"UserFiles",
},
PromptTypeQuestionAdviser: {
"InitiatorAgent",
"Question",
"Code",
"Output",
"Enriches",
},
PromptTypeGenerator: {
"SubtaskListToolName",
"SearchToolName",
"TerminalToolName",
"FileToolName",
"BrowserToolName",
"SummarizationToolName",
"SummarizedContentPrefix",
"DockerImage",
"Cwd",
"Lang",
"CurrentTime",
"N",
"ToolPlaceholder",
"UserFiles",
},
PromptTypeSubtasksGenerator: {
"Task",
"Tasks",
"Subtasks",
},
PromptTypeRefiner: {
"SubtaskPatchToolName",
"SearchToolName",
"TerminalToolName",
"FileToolName",
"BrowserToolName",
"SummarizationToolName",
"SummarizedContentPrefix",
"DockerImage",
"Cwd",
"Lang",
"CurrentTime",
"N",
"ToolPlaceholder",
"UserFiles",
},
PromptTypeSubtasksRefiner: {
"Task",
"Tasks",
"PlannedSubtasks",
"CompletedSubtasks",
"ExecutionLogs",
"ExecutionState",
},
PromptTypeReporter: {
"ReportResultToolName",
"SummarizationToolName",
"SummarizedContentPrefix",
"Cwd",
"Lang",
"N",
"ToolPlaceholder",
"UserFiles",
},
PromptTypeTaskReporter: {
"Task",
"Tasks",
"CompletedSubtasks",
"PlannedSubtasks",
"ExecutionLogs",
"ExecutionState",
},
PromptTypeReflector: {
"BarrierTools",
"CurrentTime",
"ExecutionContext",
"Request",
},
PromptTypeQuestionReflector: {
"Message",
"BarrierToolNames",
},
PromptTypeEnricher: {
"EnricherToolName",
"SummarizationToolName",
"SummarizedContentPrefix",
"ExecutionContext",
"Cwd",
"Lang",
"CurrentTime",
"ToolPlaceholder",
"SearchInMemoryToolName",
"GraphitiEnabled",
"GraphitiSearchToolName",
"FileToolName",
"TerminalToolName",
"BrowserToolName",
"UserFiles",
},
PromptTypeQuestionEnricher: {
"Question",
"Code",
"Output",
},
PromptTypeToolCallFixer: {},
PromptTypeInputToolCallFixer: {
"ToolCallName",
"ToolCallArgs",
"ToolCallSchema",
"ToolCallError",
},
PromptTypeSummarizer: {
"TaskID",
"SubtaskID",
"CurrentTime",
"SummarizedContentPrefix",
},
PromptTypeFlowDescriptor: {
"Input",
"Lang",
"CurrentTime",
"N",
},
PromptTypeTaskDescriptor: {
"Input",
"Lang",
"CurrentTime",
"N",
},
PromptTypeExecutionLogs: {
"MsgLogs",
},
PromptTypeFullExecutionContext: {
"Task",
"Tasks",
"CompletedSubtasks",
"Subtask",
"PlannedSubtasks",
},
PromptTypeShortExecutionContext: {
"Task",
"Tasks",
"CompletedSubtasks",
"Subtask",
"PlannedSubtasks",
},
PromptTypeImageChooser: {
"DefaultImage",
"DefaultImageForPentest",
"Input",
},
PromptTypeLanguageChooser: {
"Input",
},
PromptTypeToolCallIDCollector: {
"FunctionName",
"RandomContext",
},
PromptTypeToolCallIDDetector: {
"FunctionName",
"Samples",
"PreviousAttempts",
},
PromptTypeQuestionExecutionMonitor: {
"SubtaskDescription",
"AgentType",
"AgentPrompt",
"RecentMessages",
"ExecutedToolCalls",
"LastToolName",
"LastToolArgs",
"LastToolResult",
},
PromptTypeQuestionTaskPlanner: {
"AgentType",
"TaskQuestion",
},
PromptTypeTaskAssignmentWrapper: {
"OriginalRequest",
"ExecutionPlan",
},
}
type Prompt struct {
Type PromptType
Template string
Variables []string
}
type AgentPrompt struct {
System Prompt
}
type AgentPrompts struct {
System Prompt
Human Prompt
}
type AgentsPrompts struct {
PrimaryAgent AgentPrompt
Assistant AgentPrompt
Pentester AgentPrompts
Coder AgentPrompts
Installer AgentPrompts
Searcher AgentPrompts
Memorist AgentPrompts
Adviser AgentPrompts
Generator AgentPrompts
Refiner AgentPrompts
Reporter AgentPrompts
Reflector AgentPrompts
Enricher AgentPrompts
ToolCallFixer AgentPrompts
Summarizer AgentPrompt
}
type ToolsPrompts struct {
GetFlowDescription Prompt
GetTaskDescription Prompt
GetExecutionLogs Prompt
GetFullExecutionContext Prompt
GetShortExecutionContext Prompt
ChooseDockerImage Prompt
ChooseUserLanguage Prompt
CollectToolCallID Prompt
DetectToolCallIDPattern Prompt
QuestionExecutionMonitor Prompt
QuestionTaskPlanner Prompt
TaskAssignmentWrapper Prompt
}
type DefaultPrompts struct {
AgentsPrompts AgentsPrompts
ToolsPrompts ToolsPrompts
}
func GetDefaultPrompts() (*DefaultPrompts, error) {
prompts, err := promptTemplates.ReadDir("prompts")
if err != nil {
return nil, fmt.Errorf("failed to read templates: %w", err)
}
promptsMap := make(PromptsMap)
for _, prompt := range prompts {
promptBytes, err := promptTemplates.ReadFile(path.Join("prompts", prompt.Name()))
if err != nil {
return nil, fmt.Errorf("failed to read template: %w", err)
}
promptName := strings.TrimSuffix(prompt.Name(), ".tmpl")
promptsMap[PromptType(promptName)] = string(promptBytes)
}
getPrompt := func(promptType PromptType) Prompt {
return Prompt{
Type: promptType,
Template: promptsMap[promptType],
Variables: PromptVariables[promptType],
}
}
return &DefaultPrompts{
AgentsPrompts: AgentsPrompts{
PrimaryAgent: AgentPrompt{
System: getPrompt(PromptTypePrimaryAgent),
},
Assistant: AgentPrompt{
System: getPrompt(PromptTypeAssistant),
},
Pentester: AgentPrompts{
System: getPrompt(PromptTypePentester),
Human: getPrompt(PromptTypeQuestionPentester),
},
Coder: AgentPrompts{
System: getPrompt(PromptTypeCoder),
Human: getPrompt(PromptTypeQuestionCoder),
},
Installer: AgentPrompts{
System: getPrompt(PromptTypeInstaller),
Human: getPrompt(PromptTypeQuestionInstaller),
},
Searcher: AgentPrompts{
System: getPrompt(PromptTypeSearcher),
Human: getPrompt(PromptTypeQuestionSearcher),
},
Memorist: AgentPrompts{
System: getPrompt(PromptTypeMemorist),
Human: getPrompt(PromptTypeQuestionMemorist),
},
Adviser: AgentPrompts{
System: getPrompt(PromptTypeAdviser),
Human: getPrompt(PromptTypeQuestionAdviser),
},
Generator: AgentPrompts{
System: getPrompt(PromptTypeGenerator),
Human: getPrompt(PromptTypeSubtasksGenerator),
},
Refiner: AgentPrompts{
System: getPrompt(PromptTypeRefiner),
Human: getPrompt(PromptTypeSubtasksRefiner),
},
Reporter: AgentPrompts{
System: getPrompt(PromptTypeReporter),
Human: getPrompt(PromptTypeTaskReporter),
},
Reflector: AgentPrompts{
System: getPrompt(PromptTypeReflector),
Human: getPrompt(PromptTypeQuestionReflector),
},
Enricher: AgentPrompts{
System: getPrompt(PromptTypeEnricher),
Human: getPrompt(PromptTypeQuestionEnricher),
},
ToolCallFixer: AgentPrompts{
System: getPrompt(PromptTypeToolCallFixer),
Human: getPrompt(PromptTypeInputToolCallFixer),
},
Summarizer: AgentPrompt{
System: getPrompt(PromptTypeSummarizer),
},
},
ToolsPrompts: ToolsPrompts{
GetFlowDescription: getPrompt(PromptTypeFlowDescriptor),
GetTaskDescription: getPrompt(PromptTypeTaskDescriptor),
GetExecutionLogs: getPrompt(PromptTypeExecutionLogs),
GetFullExecutionContext: getPrompt(PromptTypeFullExecutionContext),
GetShortExecutionContext: getPrompt(PromptTypeShortExecutionContext),
ChooseDockerImage: getPrompt(PromptTypeImageChooser),
ChooseUserLanguage: getPrompt(PromptTypeLanguageChooser),
CollectToolCallID: getPrompt(PromptTypeToolCallIDCollector),
DetectToolCallIDPattern: getPrompt(PromptTypeToolCallIDDetector),
QuestionExecutionMonitor: getPrompt(PromptTypeQuestionExecutionMonitor),
QuestionTaskPlanner: getPrompt(PromptTypeQuestionTaskPlanner),
TaskAssignmentWrapper: getPrompt(PromptTypeTaskAssignmentWrapper),
},
}, nil
}
type PromptsMap map[PromptType]string
type Prompter interface {
GetTemplate(promptType PromptType) (string, error)
RenderTemplate(promptType PromptType, params any) (string, error)
DumpTemplates() ([]byte, error)
}
type flowPrompter struct {
prompts PromptsMap
}
func NewFlowPrompter(prompts PromptsMap) Prompter {
return &flowPrompter{prompts: prompts}
}
func (fp *flowPrompter) GetTemplate(promptType PromptType) (string, error) {
if prompt, ok := fp.prompts[promptType]; ok {
return prompt, nil
}
return "", ErrTemplateNotFound
}
func (fp *flowPrompter) RenderTemplate(promptType PromptType, params any) (string, error) {
prompt, err := fp.GetTemplate(promptType)
if err != nil {
return "", err
}
return RenderPrompt(string(promptType), prompt, params)
}
func (fp *flowPrompter) DumpTemplates() ([]byte, error) {
blob, err := json.Marshal(fp.prompts)
if err != nil {
return nil, fmt.Errorf("failed to marshal templates: %w", err)
}
return blob, nil
}
type defaultPrompter struct {
}
func NewDefaultPrompter() Prompter {
return &defaultPrompter{}
}
func (dp *defaultPrompter) GetTemplate(promptType PromptType) (string, error) {
promptPath := path.Join("prompts", fmt.Sprintf("%s.tmpl", promptType))
promptBytes, err := promptTemplates.ReadFile(promptPath)
if err != nil {
return "", fmt.Errorf("failed to read template: %v: %w", err, ErrTemplateNotFound)
}
return string(promptBytes), nil
}
func (dp *defaultPrompter) RenderTemplate(promptType PromptType, params any) (string, error) {
prompt, err := dp.GetTemplate(promptType)
if err != nil {
return "", err
}
return RenderPrompt(string(promptType), prompt, params)
}
func (dp *defaultPrompter) DumpTemplates() ([]byte, error) {
promptsMap, err := LoadDefaultPromptsMap()
if err != nil {
return nil, err
}
blob, err := json.Marshal(promptsMap)
if err != nil {
return nil, fmt.Errorf("failed to marshal templates: %w", err)
}
return blob, nil
}
// defaultPromptsCache holds the singleton default prompts map loaded once
// from the embedded FS. String values are immutable in Go, so the map itself
// is read-only after initialisation and safe to read from multiple goroutines.
var (
defaultPromptsCache PromptsMap
defaultPromptsCacheOnce sync.Once
defaultPromptsCacheErr error
)
// LoadDefaultPromptsMap returns a PromptsMap populated from the embedded
// default templates. The underlying template strings are loaded only once;
// every caller receives a shallow copy of the map so it can safely overlay
// user-specific overrides without affecting the shared cache or other callers.
// String values in Go are immutable, so the copy shares string memory with
// the cache rather than duplicating template content.
func LoadDefaultPromptsMap() (PromptsMap, error) {
defaultPromptsCacheOnce.Do(func() {
prompts, err := promptTemplates.ReadDir("prompts")
if err != nil {
defaultPromptsCacheErr = fmt.Errorf("failed to read templates: %w", err)
return
}
m := make(PromptsMap, len(prompts))
for _, prompt := range prompts {
promptBytes, err := promptTemplates.ReadFile(path.Join("prompts", prompt.Name()))
if err != nil {
defaultPromptsCacheErr = fmt.Errorf("failed to read template: %w", err)
return
}
promptName := strings.TrimSuffix(prompt.Name(), ".tmpl")
m[PromptType(promptName)] = string(promptBytes)
}
defaultPromptsCache = m
})
if defaultPromptsCacheErr != nil {
return nil, defaultPromptsCacheErr
}
// Return a shallow copy: new map header + copied string references.
// Callers can mutate keys freely; the cached originals are untouched.
copyMap := make(PromptsMap, len(defaultPromptsCache))
maps.Copy(copyMap, defaultPromptsCache)
return copyMap, nil
}
func RenderPrompt(name, prompt string, params any) (string, error) {
t, err := template.New(string(name)).Parse(prompt)
if err != nil {
return "", fmt.Errorf("failed to parse template: %w", err)
}
buf := &bytes.Buffer{}
if err := t.Execute(buf, params); err != nil {
return "", fmt.Errorf("failed to execute template: %w", err)
}
return buf.String(), nil
}
// ReadGraphitiTemplate reads a Graphiti template by name
func ReadGraphitiTemplate(name string) (string, error) {
templateBytes, err := graphitiTemplates.ReadFile(path.Join("graphiti", name))
if err != nil {
return "", fmt.Errorf("failed to read graphiti template %s: %w", name, err)
}
return string(templateBytes), nil
}
// String pattern template format:
// - Literal parts: any text outside curly braces
// - Random parts: {r:LENGTH:CHARSET}
// - LENGTH: number of characters to generate
// - CHARSET: character set type
// - d, digit: [0-9]
// - l, lower: [a-z]
// - u, upper: [A-Z]
// - a, alpha: [a-zA-Z]
// - x, alnum: [a-zA-Z0-9]
// - h, hex: [0-9a-f]
// - H, HEX: [0-9A-F]
// - b, base62: [0-9A-Za-z]
// - Function placeholder: {f}
// - Represents the function/tool name
// - Used when tool call IDs contain the function name
//
// Examples:
// - "toolu_{r:24:b}" → "toolu_013wc5CxNCjWGN2rsAR82rJK"
// - "call_{r:24:x}" → "call_Z8ofZnYOCeOnpu0h2auwOgeR"
// - "chatcmpl-tool-{r:32:h}" → "chatcmpl-tool-23c5c0da71854f9bbd8774f7d0113a69"
// - "{f}:{r:1:d}" with function="get_number" → "get_number:0"
const (
charsetDigit = "0123456789"
charsetLower = "abcdefghijklmnopqrstuvwxyz"
charsetUpper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
charsetAlpha = charsetLower + charsetUpper
charsetAlnum = charsetDigit + charsetAlpha
charsetHex = "0123456789abcdef"
charsetHexUp = "0123456789ABCDEF"
charsetBase62 = charsetDigit + charsetUpper + charsetLower
)
var patternRegex = regexp.MustCompile(`\{r:(\d+):(d|digit|l|lower|u|upper|a|alpha|x|alnum|h|hex|H|HEX|b|base62)\}|\{f\}`)
type patternPart struct {
literal string
isRandom bool
isFunction bool
length int
charset string
}
// getCharset returns the character set for a given charset name
func getCharset(name string) string {
switch name {
case "d", "digit":
return charsetDigit
case "l", "lower":
return charsetLower
case "u", "upper":
return charsetUpper
case "a", "alpha":
return charsetAlpha
case "x", "alnum":
return charsetAlnum
case "h", "hex":
return charsetHex
case "H", "HEX":
return charsetHexUp
case "b", "base62":
return charsetBase62
default:
return charsetAlnum // fallback
}
}
// parsePattern parses a pattern string into parts
func parsePattern(pattern string) []patternPart {
var parts []patternPart
lastIndex := 0
matches := patternRegex.FindAllStringSubmatchIndex(pattern, -1)
for _, match := range matches {
// Add literal part before this match
if match[0] > lastIndex {
parts = append(parts, patternPart{
literal: pattern[lastIndex:match[0]],
isRandom: false,
isFunction: false,
})
}
matchedText := pattern[match[0]:match[1]]
// Check if it's a function placeholder
if matchedText == "{f}" {
parts = append(parts, patternPart{
isFunction: true,
})
} else {
// Parse random part
length, _ := strconv.Atoi(pattern[match[2]:match[3]])
charsetName := pattern[match[4]:match[5]]
parts = append(parts, patternPart{
isRandom: true,
length: length,
charset: getCharset(charsetName),
})
}
lastIndex = match[1]
}
// Add remaining literal part
if lastIndex < len(pattern) {
parts = append(parts, patternPart{
literal: pattern[lastIndex:],
isRandom: false,
isFunction: false,
})
}
return parts
}
// generateRandomString generates a random string of specified length using the given charset
func generateRandomString(length int, charset string) string {
if length == 0 || charset == "" {
return ""
}
result := make([]byte, length)
charsetLen := big.NewInt(int64(len(charset)))
for i := 0; i < length; i++ {
num, err := rand.Int(rand.Reader, charsetLen)
if err != nil {
// Fallback to first character if random fails (should never happen)
result[i] = charset[0]
} else {
result[i] = charset[num.Int64()]
}
}
return string(result)
}
// GenerateFromPattern generates a random string matching the given pattern template.
// This function never returns an error - it uses fallback values for invalid patterns.
//
// Pattern format: literal text with {r:LENGTH:CHARSET} for random parts and {f} for function name
// Example: "toolu_{r:24:base62}" → "toolu_xK9pQw2mN5vR8tY7uI6oP3zA"
// Example: "{f}:{r:1:d}" with functionName="get_number" → "get_number:0"
func GenerateFromPattern(pattern string, functionName string) string {
parts := parsePattern(pattern)
var result strings.Builder
for _, part := range parts {
if part.isRandom {
result.WriteString(generateRandomString(part.length, part.charset))
} else if part.isFunction {
if functionName != "" {
result.WriteString(functionName)
} else {
result.WriteString("function")
}
} else {
result.WriteString(part.literal)
}
}
return result.String()
}
// PatternSample represents a sample value with optional function name for pattern validation
type PatternSample struct {
Value string
FunctionName string
}
// PatternValidationError represents a validation error for a specific value
type PatternValidationError struct {
Value string
Position int
Expected string
Got string
Message string
}
func (e *PatternValidationError) Error() string {
if e.Position >= 0 {
return fmt.Sprintf("validation failed for '%s' at position %d: expected %s, got '%s': %s",
e.Value, e.Position, e.Expected, e.Got, e.Message)
}
return fmt.Sprintf("validation failed for '%s': %s", e.Value, e.Message)
}
// ValidatePattern validates that all provided samples match the given pattern template.
// Returns a detailed error if any sample doesn't match, nil if all samples are valid.
//
// Pattern format: literal text with {r:LENGTH:CHARSET} for random parts and {f} for function name
// Example: ValidatePattern("call_{r:24:alnum}", []PatternSample{{Value: "call_abc123..."}})
func ValidatePattern(pattern string, samples []PatternSample) error {
if len(samples) == 0 {
return nil
}
parts := parsePattern(pattern)
// Validate each sample
for _, sample := range samples {
value := sample.Value
functionName := sample.FunctionName
// Build expected length and regex pattern for this specific sample
var expectedLen int
var regexParts []string
for _, part := range parts {
if part.isRandom {
expectedLen += part.length
// Build character class from charset
charClass := buildCharClass(part.charset)
regexParts = append(regexParts, fmt.Sprintf("%s{%d}", charClass, part.length))
} else if part.isFunction {
if functionName != "" {
expectedLen += len(functionName)
regexParts = append(regexParts, regexp.QuoteMeta(functionName))
} else {
// Fallback if no function name provided
expectedLen += len("function")
regexParts = append(regexParts, regexp.QuoteMeta("function"))
}
} else {
expectedLen += len(part.literal)
regexParts = append(regexParts, regexp.QuoteMeta(part.literal))
}
}
regexPattern := "^" + strings.Join(regexParts, "") + "$"
re := regexp.MustCompile(regexPattern)
// Check length
if len(value) != expectedLen {
return &PatternValidationError{
Value: value,
Position: -1,
Expected: fmt.Sprintf("length %d", expectedLen),
Got: fmt.Sprintf("length %d", len(value)),
Message: fmt.Sprintf("incorrect length: expected %d, got %d", expectedLen, len(value)),
}
}
// Check pattern match
if !re.MatchString(value) {
// Find the exact position where it fails
pos := findMismatchPosition(value, parts, functionName)
part := getPartAtPosition(parts, pos, functionName)
var expected string
if part.isRandom {
expected = fmt.Sprintf("character from charset [%s]", describeCharset(part.charset))
} else if part.isFunction {
if functionName != "" {
expected = fmt.Sprintf("function name '%s'", functionName)
} else {
expected = "function name"
}
} else {
expected = fmt.Sprintf("'%s'", part.literal)
}
got := ""
if pos < len(value) {
got = string(value[pos])
}
return &PatternValidationError{
Value: value,
Position: pos,
Expected: expected,
Got: got,
Message: "pattern mismatch",
}
}
}
return nil
}
// buildCharClass builds a regex character class from a charset string
func buildCharClass(charset string) string {
// Optimize for common charsets
switch charset {
case charsetDigit:
return `\d`
case charsetLower:
return `[a-z]`
case charsetUpper:
return `[A-Z]`
case charsetAlpha:
return `[a-zA-Z]`
case charsetAlnum:
return `[a-zA-Z0-9]`
case charsetHex:
return `[0-9a-f]`
case charsetHexUp:
return `[0-9A-F]`
case charsetBase62:
return `[0-9A-Za-z]`
default:
// Build custom character class
return `[` + regexp.QuoteMeta(charset) + `]`
}
}
// describeCharset returns a human-readable description of a charset
func describeCharset(charset string) string {
switch charset {
case charsetDigit:
return "0-9"
case charsetLower:
return "a-z"
case charsetUpper:
return "A-Z"
case charsetAlpha:
return "a-zA-Z"
case charsetAlnum:
return "a-zA-Z0-9"
case charsetHex:
return "0-9a-f"
case charsetHexUp:
return "0-9A-F"
case charsetBase62:
return "0-9A-Za-z"
default:
return charset
}
}
// findMismatchPosition finds the first position where value doesn't match the pattern
func findMismatchPosition(value string, parts []patternPart, functionName string) int {
pos := 0
for _, part := range parts {
if part.isRandom {
// Check each character against charset
for i := 0; i < part.length && pos < len(value); i++ {
if !strings.ContainsRune(part.charset, rune(value[pos])) {
return pos
}
pos++
}
} else if part.isFunction {
// Check function name match
fn := functionName
if fn == "" {
fn = "function"
}
for i := 0; i < len(fn) && pos < len(value); i++ {
if value[pos] != fn[i] {
return pos
}
pos++
}
} else {
// Check literal match
for i := 0; i < len(part.literal) && pos < len(value); i++ {
if value[pos] != part.literal[i] {
return pos
}
pos++
}
}
}
return pos
}
// getPartAtPosition returns the pattern part at the given position in the generated string
func getPartAtPosition(parts []patternPart, position int, functionName string) patternPart {
pos := 0
for _, part := range parts {
var length int
if part.isRandom {
length = part.length
} else if part.isFunction {
if functionName != "" {
length = len(functionName)
} else {
length = len("function")
}
} else {
length = len(part.literal)
}
if position < pos+length {
return part
}
pos += length
}
// Return last part if position is beyond
if len(parts) > 0 {
return parts[len(parts)-1]
}
return patternPart{}
}