@salesforce/afv-skills 1.32.0 → 1.34.0

package/skills/agentforce-generate/scripts/generators/flow_xml.py

@@ -0,0 +1,213 @@
+"""Generate stub Flow XML for .agent file action targets."""
+
+from __future__ import annotations
+
+# Mapping from .agent types to Flow variable dataTypes
+_TYPE_MAP = {
+    "string": "String",
+    "number": "Number",
+    "boolean": "Boolean",
+    "date": "Date",
+    "datetime": "DateTime",
+    "id": "String",
+    "object": "Apex",
+}
+
+# Mapping from complex_data_type_name to Flow variable dataTypes (for action I/O)
+_COMPLEX_TYPE_MAP = {
+    "lightning__integerType": "Number",
+    "lightning__numberType": "Number",
+    "lightning__doubleType": "Number",
+    "lightning__currencyType": "Currency",
+    "lightning__dateTimeStringType": "DateTime",
+    "lightning__recordInfoType": "SObject",
+    "lightning__objectType": "Apex",
+    "lightning__listType": "Apex",
+    "lightning__textType": "String",
+}
+
+API_VERSION = "63.0"
+
+
+def generate_flow_xml(
+    api_name: str,
+    inputs: list[dict] | None = None,
+    outputs: list[dict] | None = None,
+    process_type: str = "AutoLaunchedFlow",
+) -> str:
+    """Generate a stub Flow XML with matching input/output variables.
+
+    Produces a minimal .flow-meta.xml that:
+    - Declares input variables matching action inputs
+    - Declares output variables matching action outputs
+    - Merges bidirectional variables (isInput=true, isOutput=true)
+    - Uses Active status so flows are immediately callable
+    - Has a single Assignment element as placeholder logic
+
+    Args:
+        api_name: The flow API name.
+        inputs: Action input definitions (list of dicts with 'name', 'type' keys).
+        outputs: Action output definitions (list of dicts with 'name', 'type' keys).
+        process_type: Flow process type (default: AutoLaunchedFlow).
+
+    Returns:
+        Flow XML string.
+    """
+    inputs = inputs or []
+    outputs = outputs or []
+
+    input_names = {inp["name"] for inp in inputs}
+    bidirectional_names = input_names & {out["name"] for out in outputs}
+
+    lines = [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<Flow xmlns="http://soap.sforce.com/2006/04/metadata">',
+        f'    <apiVersion>{API_VERSION}</apiVersion>',
+        f'    <label>{api_name.replace("_", " ")}</label>',
+        f'    <processType>{process_type}</processType>',
+        '    <status>Active</status>',
+        '    <interviewLabel>{!$Flow.CurrentDateTime}</interviewLabel>',
+    ]
+
+    # Input variables
+    for inp in inputs:
+        flow_type = _COMPLEX_TYPE_MAP.get(inp.get("complex_data_type_name", ""), _TYPE_MAP.get(inp.get("type", "string"), "String"))
+        is_output = inp["name"] in bidirectional_names
+        lines.extend([
+            '    <variables>',
+            f'        <name>{inp["name"]}</name>',
+            f'        <dataType>{flow_type}</dataType>',
+        ])
+        if flow_type == "Number":
+            lines.append(f'        <scale>{_infer_scale(inp["name"])}</scale>')
+        lines.extend([
+            '        <isCollection>false</isCollection>',
+            '        <isInput>true</isInput>',
+            f'        <isOutput>{"true" if is_output else "false"}</isOutput>',
+        ])
+        if inp.get("description"):
+            lines.append(f'        <description>{_escape_xml(inp["description"])}</description>')
+        lines.append('    </variables>')
+
+    # Output-only variables
+    for out in outputs:
+        if out["name"] in bidirectional_names:
+            continue
+        flow_type = _COMPLEX_TYPE_MAP.get(out.get("complex_data_type_name", ""), _TYPE_MAP.get(out.get("type", "string"), "String"))
+        lines.extend([
+            '    <variables>',
+            f'        <name>{out["name"]}</name>',
+            f'        <dataType>{flow_type}</dataType>',
+        ])
+        if flow_type == "Number":
+            lines.append(f'        <scale>{_infer_scale(out["name"])}</scale>')
+        lines.extend([
+            '        <isCollection>false</isCollection>',
+            '        <isInput>false</isInput>',
+            '        <isOutput>true</isOutput>',
+        ])
+        if out.get("description"):
+            lines.append(f'        <description>{_escape_xml(out["description"])}</description>')
+        lines.append('    </variables>')
+
+    # Placeholder variable if no outputs
+    if not outputs:
+        lines.extend([
+            '    <variables>',
+            '        <name>placeholder_result</name>',
+            '        <dataType>String</dataType>',
+            '        <isCollection>false</isCollection>',
+            '        <isInput>false</isInput>',
+            '        <isOutput>true</isOutput>',
+            '    </variables>',
+        ])
+
+    # Placeholder assignment
+    lines.extend([
+        '    <assignments>',
+        '        <name>Placeholder_Assignment</name>',
+        '        <label>Placeholder Assignment</label>',
+        '        <locationX>176</locationX>',
+        '        <locationY>158</locationY>',
+    ])
+
+    for out in outputs:
+        flow_type = _COMPLEX_TYPE_MAP.get(out.get("complex_data_type_name", ""), _TYPE_MAP.get(out.get("type", "string"), "String"))
+        lines.extend([
+            '        <assignmentItems>',
+            f'            <assignToReference>{out["name"]}</assignToReference>',
+            '            <operator>Assign</operator>',
+            f'            <value>{_default_value_element_by_flow_type(flow_type)}</value>',
+            '        </assignmentItems>',
+        ])
+
+    if not outputs:
+        lines.extend([
+            '        <assignmentItems>',
+            '            <assignToReference>placeholder_result</assignToReference>',
+            '            <operator>Assign</operator>',
+            '            <value><stringValue>TODO</stringValue></value>',
+            '        </assignmentItems>',
+        ])
+
+    lines.extend([
+        '    </assignments>',
+        '    <start>',
+        '        <locationX>50</locationX>',
+        '        <locationY>0</locationY>',
+        '        <connector>',
+        '            <targetReference>Placeholder_Assignment</targetReference>',
+        '        </connector>',
+        '    </start>',
+        '</Flow>',
+    ])
+
+    return "\n".join(lines) + "\n"
+
+
+def _infer_scale(name: str) -> int:
+    """Infer decimal scale from variable name. Currency/amount/price → 2, else 0."""
+    currency_hints = {"balance", "amount", "price", "cost", "total", "credit", "fee", "rate", "pct", "percent", "utilization"}
+    lower = name.lower()
+    for hint in currency_hints:
+        if hint in lower:
+            return 2
+    return 0
+
+
+def _escape_xml(text: str) -> str:
+    """Escape XML special characters."""
+    return (
+        text
+        .replace("&", "&amp;")
+        .replace("<", "&lt;")
+        .replace(">", "&gt;")
+        .replace('"', "&quot;")
+        .replace("'", "&apos;")
+    )
+
+
+def _default_value_element(type_name: str) -> str:
+    """Return a type-appropriate XML value element for a placeholder assignment."""
+    if type_name == "boolean":
+        return "<booleanValue>false</booleanValue>"
+    if type_name == "number":
+        return "<numberValue>0</numberValue>"
+    if type_name == "date":
+        return "<stringValue>2000-01-01</stringValue>"
+    if type_name == "datetime":
+        return "<stringValue>2000-01-01T00:00:00Z</stringValue>"
+    return "<stringValue>TODO</stringValue>"
+
+
+def _default_value_element_by_flow_type(flow_type: str) -> str:
+    """Return a type-appropriate XML value element based on resolved Flow dataType."""
+    if flow_type == "Boolean":
+        return "<booleanValue>false</booleanValue>"
+    if flow_type in ("Number", "Currency"):
+        return "<numberValue>0</numberValue>"
+    if flow_type == "Date":
+        return "<stringValue>2000-01-01</stringValue>"
+    if flow_type == "DateTime":
+        return "<stringValue>2000-01-01T00:00:00Z</stringValue>"
+    return "<stringValue>TODO</stringValue>"

package/skills/agentforce-generate/scripts/generators/permission_set_xml.py

@@ -0,0 +1,35 @@
+"""Generate Permission Set XML granting classAccesses to Apex classes."""
+
+from __future__ import annotations
+
+
+def generate_permission_set_xml(
+    perm_set_name: str,
+    apex_class_names: list[str],
+) -> str:
+    """Generate a Permission Set XML with classAccesses entries.
+
+    Args:
+        perm_set_name: The permission set API name (e.g. Agent_Action_Access).
+        apex_class_names: List of Apex class names to grant access to.
+
+    Returns:
+        Permission Set XML string.
+    """
+    lines = [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<PermissionSet xmlns="http://soap.sforce.com/2006/04/metadata">',
+        f"    <label>{perm_set_name}</label>",
+    ]
+
+    for class_name in apex_class_names:
+        lines.extend([
+            "    <classAccesses>",
+            f"        <apexClass>{class_name}</apexClass>",
+            "        <enabled>true</enabled>",
+            "    </classAccesses>",
+        ])
+
+    lines.append("</PermissionSet>")
+
+    return "\n".join(lines) + "\n"

package/skills/agentforce-generate/scripts/generators/remote_site_xml.py

@@ -0,0 +1,49 @@
+"""Generate Remote Site Settings XML for HTTP callout targets."""
+
+from __future__ import annotations
+
+import re
+
+
+def safe_domain_name(domain: str) -> str:
+    """Sanitize a domain for use as a Remote Site Setting name.
+
+    Replaces dots and hyphens with underscores.
+    e.g. 'api.github.com' -> 'api_github_com'
+    """
+    return re.sub(r"[.\-]", "_", domain)
+
+
+def generate_remote_site_xml(domain: str, description: str = "") -> str:
+    """Generate a .remoteSite-meta.xml file for a Remote Site Setting.
+
+    Args:
+        domain: The domain to allow (e.g. 'api.github.com').
+        description: Human-readable description.
+
+    Returns:
+        Remote Site Setting XML string.
+    """
+    url = f"https://{domain}"
+    if not description:
+        description = f"Remote site for {domain}"
+
+    return (
+        '<?xml version="1.0" encoding="UTF-8"?>\n'
+        '<RemotesiteSetting xmlns="http://soap.sforce.com/2006/04/metadata">\n'
+        f'    <disableProtocolSecurity>false</disableProtocolSecurity>\n'
+        f'    <description>{_escape_xml(description)}</description>\n'
+        f'    <isActive>true</isActive>\n'
+        f'    <url>{url}</url>\n'
+        '</RemotesiteSetting>\n'
+    )
+
+
+def _escape_xml(text: str) -> str:
+    """Escape special characters for XML content."""
+    return (text
+        .replace("&", "&amp;")
+        .replace("<", "&lt;")
+        .replace(">", "&gt;")
+        .replace('"', "&quot;")
+        .replace("'", "&apos;"))

package/skills/agentforce-generate/scripts/org_describe.py

@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+"""Query SObject field definitions and match them to action inputs/outputs for smart code generation.
+
+Usage:
+    python3 scripts/org_describe.py --sobject Account -o OrgAlias
+    python3 scripts/org_describe.py --sobject Case -o OrgAlias --json
+"""
+
+from __future__ import annotations
+
+import argparse
+import difflib
+import json
+import re
+import subprocess
+import sys
+from dataclasses import dataclass, field
+
+
+@dataclass
+class FieldInfo:
+    """SObject field metadata."""
+    name: str
+    label: str
+    data_type: str
+    filterable: bool
+
+
+@dataclass
+class FieldMapping:
+    """Mapping between action inputs/outputs and SObject fields."""
+    input_mappings: dict[str, str] = field(default_factory=dict)   # input_name → field_name
+    output_mappings: dict[str, str] = field(default_factory=dict)  # output_name → field_name
+    select_fields: list[str] = field(default_factory=list)
+    where_fields: list[str] = field(default_factory=list)
+
+
+def describe_sobject(object_name: str, target_org: str) -> list[FieldInfo]:
+    """Query FieldDefinition for an SObject's fields."""
+    query = (
+        f"SELECT QualifiedApiName, Label, DataType, IsCompactLayoutable "
+        f"FROM FieldDefinition "
+        f"WHERE EntityDefinition.QualifiedApiName = '{object_name}'"
+    )
+    cmd = ["sf", "data", "query", "--query", query, "-o", target_org, "--json"]
+    try:
+        proc = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
+        if proc.returncode != 0:
+            return []
+        data = json.loads(proc.stdout)
+        records = data.get("result", {}).get("records", [])
+        return [
+            FieldInfo(
+                name=r.get("QualifiedApiName", ""),
+                label=r.get("Label", ""),
+                data_type=r.get("DataType", ""),
+                filterable=r.get("IsCompactLayoutable", False),
+            )
+            for r in records
+            if r.get("QualifiedApiName")
+        ]
+    except (subprocess.TimeoutExpired, json.JSONDecodeError, FileNotFoundError):
+        return []
+
+
+def match_fields(
+    inputs: list[dict],
+    outputs: list[dict],
+    fields: list[FieldInfo],
+) -> FieldMapping:
+    """Match action inputs/outputs to SObject fields.
+
+    Args:
+        inputs: List of dicts with 'name' and 'type' keys.
+        outputs: List of dicts with 'name' and 'type' keys.
+        fields: SObject field definitions from describe_sobject().
+
+    Returns:
+        FieldMapping with matched input/output mappings.
+    """
+    mapping = FieldMapping()
+
+    # Build field lookup
+    field_names = [f.name for f in fields]
+    filterable_fields = [f.name for f in fields if f.filterable]
+
+    # Match inputs to filterable fields (for WHERE clause)
+    for inp in inputs:
+        if _is_computed_output(inp["name"]):
+            continue
+        best = _find_best_match(inp["name"], filterable_fields)
+        if best:
+            mapping.input_mappings[inp["name"]] = best
+            mapping.where_fields.append(best)
+
+    # Match outputs to any fields (for SELECT clause)
+    for out in outputs:
+        if _is_computed_output(out["name"]):
+            continue
+        best = _find_best_match(out["name"], field_names)
+        if best:
+            mapping.output_mappings[out["name"]] = best
+            mapping.select_fields.append(best)
+
+    return mapping
+
+
+def _find_best_match(name: str, candidates: list[str], threshold: float = 0.5) -> str | None:
+    """Find the best matching field name using fuzzy matching."""
+    normalized = _normalize(name)
+
+    # Exact normalized match
+    for cand in candidates:
+        if _normalize(cand) == normalized:
+            return cand
+
+    # Fuzzy sequence matching
+    best_score = 0.0
+    best_match = None
+    for cand in candidates:
+        score = difflib.SequenceMatcher(None, normalized, _normalize(cand)).ratio()
+        # Bonus for word containment
+        if normalized in _normalize(cand) or _normalize(cand) in normalized:
+            score += 0.2
+        if score > best_score and score >= threshold:
+            best_score = score
+            best_match = cand
+
+    return best_match
+
+
+def _normalize(name: str) -> str:
+    """Normalize a field name for comparison."""
+    # Remove __c suffix
+    name = re.sub(r"__c$", "", name)
+    # Split camelCase
+    name = re.sub(r"(?<=[a-z])(?=[A-Z])", " ", name)
+    # Replace underscores with spaces
+    name = name.replace("_", " ")
+    return name.lower().strip()
+
+
+def _is_computed_output(name: str) -> bool:
+    """Detect computed output names that shouldn't be mapped to fields."""
+    computed_patterns = [
+        "total_count", "result_json", "error_message", "status_code",
+        "success", "is_valid", "record_count",
+    ]
+    return name.lower() in computed_patterns or name.endswith("_count") or name.endswith("_json")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Describe SObject fields")
+    parser.add_argument("--sobject", required=True, help="SObject API name (e.g. Account, Case)")
+    parser.add_argument("-o", "--target-org", required=True, help="Salesforce org alias")
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+    args = parser.parse_args()
+
+    fields = describe_sobject(args.sobject, args.target_org)
+    if not fields:
+        print(f"No fields found for {args.sobject}", file=sys.stderr)
+        sys.exit(1)
+
+    if args.json:
+        print(json.dumps([{"name": f.name, "label": f.label, "type": f.data_type, "filterable": f.filterable} for f in fields], indent=2))
+    else:
+        print(f"\n{args.sobject} — {len(fields)} fields\n")
+        print(f"{'Field':<40} {'Label':<30} {'Type':<15} {'Filter'}")
+        print(f"{'-'*40} {'-'*30} {'-'*15} {'-'*6}")
+        for f in fields:
+            filt = "✓" if f.filterable else ""
+            print(f"{f.name:<40} {f.label:<30} {f.data_type:<15} {filt}")
+
+
+if __name__ == "__main__":
+    main()