stringutil

func ExtractDomainFromURL ¶

func ExtractDomainFromURL(urlStr string) string

ExtractDomainFromURL extracts the domain name from a URL string. Handles various URL formats including full URLs with protocols, URLs with ports, and plain domain names.

This function uses net/url.Parse for proper URL parsing when a protocol is present, and falls back to string manipulation for other formats.

Examples:

ExtractDomainFromURL("https://mcp.tavily.com/mcp/")           // returns "mcp.tavily.com"
ExtractDomainFromURL("http://api.example.com:8080/path")      // returns "api.example.com"
ExtractDomainFromURL("mcp.example.com")                       // returns "mcp.example.com"
ExtractDomainFromURL("github.com:443")                        // returns "github.com"
ExtractDomainFromURL("http://sub.domain.com:8080/path")       // returns "sub.domain.com"
ExtractDomainFromURL("localhost:8080")                        // returns "localhost"

func GetPATTypeDescription ¶ added in v0.45.1

func GetPATTypeDescription(token string) string

GetPATTypeDescription returns a human-readable description of the PAT type

func IsPositiveInteger ¶

func IsPositiveInteger(s string) bool

IsPositiveInteger checks if a string is a positive integer. Returns true for strings like "1", "123", "999" but false for:

• Zero ("0")
• Negative numbers ("-5")
• Numbers with leading zeros ("007")
• Floating point numbers ("3.14")
• Non-numeric strings ("abc")
• Empty strings ("")

func LockFileToMarkdown ¶

func LockFileToMarkdown(lockPath string) string

LockFileToMarkdown converts a compiled lock file path back to its markdown source path. This is used when navigating from compiled workflows back to source files.

The function removes the .lock.yml extension and adds .md extension. If the input already has a .md extension, it returns the path unchanged.

Examples:

LockFileToMarkdown("weekly-research.lock.yml")              // returns "weekly-research.md"
LockFileToMarkdown(".github/workflows/test.lock.yml")       // returns ".github/workflows/test.md"
LockFileToMarkdown("workflow.md")                           // returns "workflow.md" (unchanged)
LockFileToMarkdown("my.workflow.lock.yml")                  // returns "my.workflow.md"

func MarkdownToLockFile ¶

func MarkdownToLockFile(mdPath string) string

MarkdownToLockFile converts a workflow markdown file path to its compiled lock file path. This is the standard transformation for agentic workflow files.

The function removes the .md extension and adds .lock.yml extension. If the input already has a .lock.yml extension, it returns the path unchanged.

Examples:

MarkdownToLockFile("weekly-research.md")                    // returns "weekly-research.lock.yml"
MarkdownToLockFile(".github/workflows/test.md")             // returns ".github/workflows/test.lock.yml"
MarkdownToLockFile("workflow.lock.yml")                     // returns "workflow.lock.yml" (unchanged)
MarkdownToLockFile("my.workflow.md")                        // returns "my.workflow.lock.yml"

func NormalizeGitHubHostURL ¶ added in v0.51.7

func NormalizeGitHubHostURL(rawHostURL string) string

NormalizeGitHubHostURL ensures the host URL has a scheme (defaulting to https://) and no trailing slashes. It is safe to call with URLs that already have an http:// or https:// scheme.

func NormalizeSafeOutputIdentifier ¶

func NormalizeSafeOutputIdentifier(identifier string) string

NormalizeSafeOutputIdentifier converts dashes and periods to underscores for safe output identifiers. This standardizes identifier format to the internal underscore-separated format used in safe outputs configuration and MCP tool names.

Both dash-separated and underscore-separated formats are valid inputs. Periods are also replaced because MCP tool names must match ^[a-zA-Z0-9_-]+$ and periods are not permitted. Workflow names such as "executor-workflow.agent" (where ".agent" is a filename extension convention) would otherwise produce an invalid tool name.

This function performs normalization only - it assumes the input is already a valid identifier and does NOT perform character validation or sanitization.

Examples:

NormalizeSafeOutputIdentifier("create-issue")          // returns "create_issue"
NormalizeSafeOutputIdentifier("create_issue")          // returns "create_issue" (unchanged)
NormalizeSafeOutputIdentifier("add-comment")           // returns "add_comment"
NormalizeSafeOutputIdentifier("update-pr")             // returns "update_pr"
NormalizeSafeOutputIdentifier("executor-workflow.agent") // returns "executor_workflow_agent"

func NormalizeWhitespace ¶

func NormalizeWhitespace(content string) string

NormalizeWhitespace normalizes trailing whitespace and newlines to reduce spurious conflicts. It trims trailing whitespace from each line and ensures exactly one trailing newline.

func NormalizeWorkflowName ¶

func NormalizeWorkflowName(name string) string

NormalizeWorkflowName removes .md and .lock.yml extensions from workflow names. This is used to standardize workflow identifiers regardless of the file format.

The function checks for extensions in order of specificity: 1. Removes .lock.yml extension (the compiled workflow format) 2. Removes .md extension (the markdown source format) 3. Returns the name unchanged if no recognized extension is found

This function performs normalization only - it assumes the input is already a valid identifier and does NOT perform character validation or sanitization.

Examples:

NormalizeWorkflowName("weekly-research")           // returns "weekly-research"
NormalizeWorkflowName("weekly-research.md")        // returns "weekly-research"
NormalizeWorkflowName("weekly-research.lock.yml")  // returns "weekly-research"
NormalizeWorkflowName("my.workflow.md")            // returns "my.workflow"

func ParseVersionValue ¶

func ParseVersionValue(version any) string

ParseVersionValue converts version values of various types to strings. Supports string, int, int64, uint64, and float64 types. Returns empty string for unsupported types.

func SanitizeErrorMessage ¶

func SanitizeErrorMessage(message string) string

SanitizeErrorMessage removes potential secret key names from error messages to prevent information disclosure via logs. This prevents exposing details about an organization's security infrastructure by redacting secret key names that might appear in error messages.

func SanitizeForFilename ¶ added in v0.55.0

func SanitizeForFilename(slug string) string

SanitizeForFilename converts a repository slug (owner/repo) to a filename-safe string. Replaces "/" with "-". Returns "clone-mode" if the slug is empty.

Examples:

SanitizeForFilename("owner/repo")  // returns "owner-repo"
SanitizeForFilename("")            // returns "clone-mode"

func SanitizeParameterName ¶

func SanitizeParameterName(name string) string

SanitizeParameterName converts a parameter name to a safe JavaScript identifier by replacing non-alphanumeric characters with underscores.

This function ensures that parameter names from workflows can be used safely in JavaScript code by: 1. Replacing any non-alphanumeric characters (except $ and _) with underscores 2. Prepending an underscore if the name starts with a number

Valid characters: a-z, A-Z, 0-9 (not at start), _, $

Examples:

SanitizeParameterName("my-param")        // returns "my_param"
SanitizeParameterName("my.param")        // returns "my_param"
SanitizeParameterName("123param")        // returns "_123param"
SanitizeParameterName("valid_name")      // returns "valid_name"
SanitizeParameterName("$special")        // returns "$special"

func SanitizePythonVariableName ¶

func SanitizePythonVariableName(name string) string

SanitizePythonVariableName converts a parameter name to a valid Python identifier by replacing non-alphanumeric characters with underscores.

This function ensures that parameter names from workflows can be used safely in Python code by: 1. Replacing any non-alphanumeric characters (except _) with underscores 2. Prepending an underscore if the name starts with a number

Valid characters: a-z, A-Z, 0-9 (not at start), _ Note: Python does not allow $ in identifiers (unlike JavaScript)

Examples:

SanitizePythonVariableName("my-param")        // returns "my_param"
SanitizePythonVariableName("my.param")        // returns "my_param"
SanitizePythonVariableName("123param")        // returns "_123param"
SanitizePythonVariableName("valid_name")      // returns "valid_name"

func SanitizeToolID ¶

func SanitizeToolID(toolID string) string

SanitizeToolID removes common MCP prefixes and suffixes from tool IDs. This cleans up tool identifiers by removing redundant MCP-related naming patterns.

The function: 1. Removes "mcp-" prefix 2. Removes "-mcp" suffix 3. Returns the original ID if the result would be empty

Examples:

SanitizeToolID("notion-mcp")        // returns "notion"
SanitizeToolID("mcp-notion")        // returns "notion"
SanitizeToolID("some-mcp-server")   // returns "some-server"
SanitizeToolID("github")            // returns "github" (unchanged)
SanitizeToolID("mcp")               // returns "mcp" (prevents empty result)

func StripANSI ¶ added in v0.47.0

func StripANSI(s string) string

StripANSI removes ANSI escape codes from a string using a comprehensive byte scanner. It handles CSI sequences (\x1b[), OSC sequences (\x1b]), G0/G1 character set selections, keypad mode sequences, reset sequences, and other common 2-character escape sequences.

This is more thorough than regex-based approaches and correctly handles edge cases such as incomplete sequences, nested sequences, and non-standard terminal sequences.

func Truncate ¶

func Truncate(s string, maxLen int) string

Truncate truncates a string to a maximum length, adding "..." if truncated. If maxLen is 3 or less, the string is truncated without "...".

This is a general-purpose utility for truncating any string to a configurable length. For domain-specific workflow command identifiers with newline handling, see workflow.ShortenCommand instead.

func ValidateCopilotPAT ¶ added in v0.45.1

func ValidateCopilotPAT(token string) error

ValidateCopilotPAT validates that a token is a valid fine-grained PAT for Copilot. Returns an error if the token is not a fine-grained PAT with a descriptive error message.

Parameters:

• token: The token string to validate

Returns:

• error: An error with a descriptive message if the token is not valid, nil otherwise