@salesforce/afv-skills 1.34.0 → 1.35.0

package/skills/dx-apexguru-scan/examples/sample-full-no-runtime-response.json

@@ -0,0 +1,26 @@
+{
+  "scanId": "255f5ecb-d967-47ad-9ca3-864d21bb425c",
+  "status": "SUCCEEDED",
+  "analysisMode": "full",
+  "report": "[{"rule": "SchemaGetGlobalDescribeNotEfficient", "message": "Avoid using Schema.getGlobalDescribe() in Apex. This method causes unnecessary overhead, decreases performance, and increases the latency of the associated entry point.", "locations": [{"startLine": 28, "comment": "SmallAntiPatterns.accountType", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}], "primaryLocationIndex": 0, "resources": ["https://help.salesforce.com/s/articleView?id=xcloud.apexguru_antipattern_schema_getglobaldescribe_not_efficient.htm&type=5"], "severity": 4, "suggestions": [{"message": "        return Account.sObjectType;", "location": {"startLine": 28, "comment": "SmallAntiPatterns.accountType", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}}], "metadata": {"original_code": "        return Schema.getGlobalDescribe().get('Account');", "class_name": "SmallAntiPatterns", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}}, {"rule": "SoqlInALoop", "message": "You're calling an expensive SOQL in a loop, which can cause performance issues. Optimize your SOQL to call once and reuse the return value.", "locations": [{"startLine": 4, "comment": "SmallAntiPatterns.soqlInLoop", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}], "primaryLocationIndex": 0, "resources": ["https://help.salesforce.com/s/articleView?id=xcloud.apexguru_antipattern_soql_in_loop.htm&type=5"], "severity": 4, "suggestions": [{"message": "public static void soqlInLoop(List<Account> accounts) {\n    Set<Id> accountIds = new Set<Id>();\n    for (Account acc : accounts) {\n        accountIds.add(acc.Id);\n    }\n    Map<Id, List<Contact>> contactsByAccountId = new Map<Id, List<Contact>>();\n    for (Contact c : [SELECT Id, Name FROM Contact WHERE AccountId IN :accountIds]) {\n        if (!contactsByAccountId.containsKey(c.AccountId)) {\n            contactsByAccountId.put(c.AccountId, new List<Contact>());\n        }\n        contactsByAccountId.get(c.AccountId).add(c);\n    }\n    for (Account acc : accounts) {\n        List<Contact> contacts = contactsByAccountId.containsKey(acc.Id) ? contactsByAccountId.get(acc.Id) : new List<Contact>();\n        System.debug(contacts.size());\n    }\n}", "location": {"startLine": 4, "comment": "SmallAntiPatterns.soqlInLoop", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}}], "metadata": {"original_code": "Line 2:\nLine 3:    public static void soqlInLoop(List<Account> accounts) {\nLine 4:        for (Account acc : accounts) {\nLine 5:            List<Contact> contacts = [SELECT Id, Name FROM Contact WHERE AccountId = :acc.Id];\nLine 6:            System.debug(contacts.size());\nLine 7:        }\n", "class_name": "SmallAntiPatterns", "file": "force-app/main/default/classes/SmallAntiPatterns.cls", "category": "soql_in_loop"}}, {"rule": "SoqlInALoopOneHop", "message": "You're calling a method that contains an SOQL query within a loop. To avoid bottlenecks and stay within governor limits, move SOQL queries outside of loops.", "locations": [{"startLine": 51, "comment": "SmallAntiPatterns.notifyOwners", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}, {"startLine": 58, "comment": "SOQL call in: SmallAntiPatterns.getCaseById", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}], "primaryLocationIndex": 0, "resources": ["https://help.salesforce.com/s/articleView?id=xcloud.apexguru_antipattern_soql_in_loop_one_hop.htm&type=5"], "severity": 4, "metadata": {"original_code": "Line 49:\nLine 50:    public static void notifyOwners(List<Id> caseIds) {\nLine 51:        for (Id caseId : caseIds) {\nLine 52:            Case c = getCaseById(caseId);\nLine 53:            System.debug('Owner: ' + c.OwnerId);\nLine 54:        }\n", "class_name": "SmallAntiPatterns", "file": "force-app/main/default/classes/SmallAntiPatterns.cls", "category": "soql_in_loop_hop"}}, {"rule": "DmlInALoop", "message": "You're calling an expensive DML in a loop, which can cause performance issues. Optimize your DML statement to call once.", "locations": [{"startLine": 13, "comment": "SmallAntiPatterns.dmlInLoop", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}], "primaryLocationIndex": 0, "resources": ["https://help.salesforce.com/s/articleView?id=xcloud.apexguru_antipattern_dml_in_loop.htm&type=5"], "severity": 4, "suggestions": [{"message": "public static void dmlInLoop(List<Contact> contacts) {\n    for (Contact c : contacts) {\n        c.Description = 'touched';\n    }\n    if (!contacts.isEmpty()) {\n        update contacts;\n    }\n}", "location": {"startLine": 13, "comment": "SmallAntiPatterns.dmlInLoop", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}}], "metadata": {"original_code": "Line 12:            c.Description = 'touched';\nLine 13:            update c;\nLine 14:        }\n", "class_name": "SmallAntiPatterns", "file": "force-app/main/default/classes/SmallAntiPatterns.cls", "category": "dml_in_loop"}}, {"rule": "SoqlWithNegativeExpressions", "message": "Calling SOQL with negative expressions causes performance issues.", "locations": [{"startLine": 32, "comment": "SmallAntiPatterns.nonProspectingOpps", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}], "primaryLocationIndex": 0, "resources": ["https://help.salesforce.com/s/articleView?id=xcloud.apexguru_antipattern_soql_with_negative_expressions.htm&type=5"], "severity": 4, "metadata": {"original_code": "[SELECT Id, Name, StageName FROM Opportunity WHERE StageName != 'Prospecting']", "class_name": "SmallAntiPatterns", "file": "force-app/main/default/classes/SmallAntiPatterns.cls", "category": "soql_with_negative_expressions"}}, {"rule": "SoqlWithoutAWhereClauseOrLimitStatement", "message": "Calling SOQL without a WHERE clause or LIMIT statement causes performance issues.", "locations": [{"startLine": 18, "comment": "SmallAntiPatterns.allOpps", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}], "primaryLocationIndex": 0, "resources": ["https://help.salesforce.com/s/articleView?id=xcloud.apexguru_antipattern_soql_without_where_clause_or_limit_statement.htm&type=5"], "severity": 4, "metadata": {"original_code": "[SELECT Id, Name, Amount, StageName FROM Opportunity]", "class_name": "SmallAntiPatterns", "file": "force-app/main/default/classes/SmallAntiPatterns.cls", "category": "soql_without_where_clause_or_limit_statement"}}, {"rule": "SoqlWithoutAWhereClauseOrLimitStatement", "message": "Calling SOQL without a WHERE clause or LIMIT statement causes performance issues.", "locations": [{"startLine": 74, "comment": "SmallAntiPatterns.sortedContactsByName", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}], "primaryLocationIndex": 0, "resources": ["https://help.salesforce.com/s/articleView?id=xcloud.apexguru_antipattern_soql_without_where_clause_or_limit_statement.htm&type=5"], "severity": 4, "metadata": {"original_code": "[SELECT Id, Name FROM Contact]", "class_name": "SmallAntiPatterns", "file": "force-app/main/default/classes/SmallAntiPatterns.cls", "category": "soql_without_where_clause_or_limit_statement"}}, {"rule": "SoqlWithoutAWhereClauseOrLimitStatement", "message": "Calling SOQL without a WHERE clause or LIMIT statement causes performance issues.", "locations": [{"startLine": 81, "comment": "SmallAntiPatterns.accountsById", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}], "primaryLocationIndex": 0, "resources": ["https://help.salesforce.com/s/articleView?id=xcloud.apexguru_antipattern_soql_without_where_clause_or_limit_statement.htm&type=5"], "severity": 4, "metadata": {"original_code": "[SELECT Id, Name FROM Account]", "class_name": "SmallAntiPatterns", "file": "force-app/main/default/classes/SmallAntiPatterns.cls", "category": "soql_without_where_clause_or_limit_statement"}}, {"rule": "Soql Aggregation", "message": "You're using loops to manually compute values, which causes performance issues, and can exceed governor limits. Instead, use Apex aggregate functions like SUM and COUNT.", "locations": [{"startLine": 36, "comment": "SmallAntiPatterns.totalOpenAmount", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}], "primaryLocationIndex": 0, "resources": ["https://help.salesforce.com/s/articleView?id=xcloud.apexguru_antipattern_aggregating_in_apex.htm&type=5"], "severity": 4, "suggestions": [{"message": "AggregateResult ar = [SELECT SUM(Amount) total FROM Opportunity WHERE AccountId = :accountId AND IsClosed = false];\nDecimal total = (Decimal)ar.get('total');", "location": {"startLine": 36, "comment": "SmallAntiPatterns.totalOpenAmount", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}}], "metadata": {"original_code": "             SELECT Amount FROM Opportunity WHERE AccountId = :accountId AND IsClosed = false         ", "class_name": "SmallAntiPatterns", "file": "force-app/main/default/classes/SmallAntiPatterns.cls", "category": "record_aggregation_in_apex"}}, {"rule": "Soql Aggregation", "message": "You're using loops to manually compute values, which causes performance issues, and can exceed governor limits. Instead, use Apex aggregate functions like SUM and COUNT.", "locations": [{"startLine": 97, "comment": "SmallAntiPatterns.sumOpenOppAmounts", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}], "primaryLocationIndex": 0, "resources": ["https://help.salesforce.com/s/articleView?id=xcloud.apexguru_antipattern_aggregating_in_apex.htm&type=5"], "severity": 4, "suggestions": [{"message": "AggregateResult ar = [SELECT SUM(Amount) total FROM Opportunity WHERE AccountId = :accountId AND IsClosed = false];\nDecimal total = (Decimal)ar.get('total');", "location": {"startLine": 97, "comment": "SmallAntiPatterns.sumOpenOppAmounts", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}}], "metadata": {"original_code": "SELECT Amount FROM Opportunity WHERE AccountId = :accountId AND IsClosed = false", "class_name": "SmallAntiPatterns", "file": "force-app/main/default/classes/SmallAntiPatterns.cls", "category": "record_aggregation_in_apex"}}, {"rule": "SoqlWithApexFilter", "message": "Calling SOQL without a WHERE clause or LIMIT statement retrieves all records, causes performance issues, and can exceed governor limits.", "locations": [{"startLine": 66, "comment": "SmallAntiPatterns.processHighValueOpps", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}], "primaryLocationIndex": 0, "resources": ["https://help.salesforce.com/s/articleView?id=xcloud.apexguru_antipattern_soql_with_apex_filter.htm&type=5"], "severity": 4, "suggestions": [{"message": "SELECT Id, Name, Amount, StageName FROM Opportunity WHERE Amount != NULL AND Amount >= 10000", "location": {"startLine": 66, "comment": "SmallAntiPatterns.processHighValueOpps", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}}], "metadata": {"original_code": "SELECT Id, Name, Amount, StageName FROM Opportunity", "class_name": "SmallAntiPatterns", "file": "force-app/main/default/classes/SmallAntiPatterns.cls", "category": "record_filtering_in_apex"}}, {"rule": "SortingInApex", "message": "Your SOQL query retrieves records in an unsorted order. This wastes CPU time and can exceed governor limits. Use the ORDER BY clause to efficiently sort and retrieve records.", "locations": [{"startLine": 74, "comment": "SmallAntiPatterns.sortedContactsByName", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}], "primaryLocationIndex": 0, "resources": ["https://help.salesforce.com/s/articleView?id=xcloud.apexguru_antipattern_sorting_in_apex.htm&type=5"], "severity": 4, "suggestions": [{"message": "        List<Contact> contactList = [SELECT Id, Name FROM Contact ORDER BY Name];\n//         contactList.sort();", "location": {"startLine": 74, "comment": "SmallAntiPatterns.sortedContactsByName", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}}], "metadata": {"original_code": "        List<Contact> contactList = [SELECT Id, Name FROM Contact];\n        contactList.sort();\n", "class_name": "SmallAntiPatterns", "file": "force-app/main/default/classes/SmallAntiPatterns.cls", "category": "record_sorting_in_apex"}}, {"rule": "SoqlWithUnusedFields", "message": "You're retrieving the unused field Name in an SOQL query. To avoid increasing resource consumption and query time, select only the necessary fields.", "locations": [{"startLine": 5, "comment": "SmallAntiPatterns.soqlInLoop", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}], "primaryLocationIndex": 0, "resources": ["https://help.salesforce.com/s/articleView?id=xcloud.apexguru_antipattern_soql_with_unused_fields.htm&type=5"], "severity": 4, "suggestions": [{"message": "SELECT Id FROM Contact WHERE AccountId = :acc.Id", "location": {"startLine": 5, "comment": "SmallAntiPatterns.soqlInLoop", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}}], "metadata": {"original_code": "SELECT Id, Name FROM Contact WHERE AccountId = :acc.Id", "class_name": "SmallAntiPatterns", "file": "force-app/main/default/classes/SmallAntiPatterns.cls", "category": "soql_unused_fields"}}, {"rule": "SoqlWithUnusedFields", "message": "You're retrieving the unused fields Type, Industry, Rating, Phone, Website in an SOQL query. To avoid increasing resource consumption and query time, select only the necessary fields.", "locations": [{"startLine": 22, "comment": "SmallAntiPatterns.getAccountName", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}], "primaryLocationIndex": 0, "resources": ["https://help.salesforce.com/s/articleView?id=xcloud.apexguru_antipattern_soql_with_unused_fields.htm&type=5"], "severity": 4, "suggestions": [{"message": "SELECT Id, Name FROM Account WHERE Id = :accountId LIMIT 1", "location": {"startLine": 22, "comment": "SmallAntiPatterns.getAccountName", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}}], "metadata": {"original_code": "SELECT Id, Name, Type, Industry, Rating, Phone, Website                      FROM Account WHERE Id = :accountId LIMIT 1", "class_name": "SmallAntiPatterns", "file": "force-app/main/default/classes/SmallAntiPatterns.cls", "category": "soql_unused_fields"}}, {"rule": "SoqlWithUnusedFields", "message": "You're retrieving the unused field StageName in an SOQL query. To avoid increasing resource consumption and query time, select only the necessary fields.", "locations": [{"startLine": 66, "comment": "SmallAntiPatterns.processHighValueOpps", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}], "primaryLocationIndex": 0, "resources": ["https://help.salesforce.com/s/articleView?id=xcloud.apexguru_antipattern_soql_with_unused_fields.htm&type=5"], "severity": 4, "suggestions": [{"message": "SELECT Id, Name, Amount FROM Opportunity", "location": {"startLine": 66, "comment": "SmallAntiPatterns.processHighValueOpps", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}}], "metadata": {"original_code": "SELECT Id, Name, Amount, StageName FROM Opportunity", "class_name": "SmallAntiPatterns", "file": "force-app/main/default/classes/SmallAntiPatterns.cls", "category": "soql_unused_fields"}}, {"rule": "SObjectMapInAForLoop", "message": "To consume less resources, build the map from a list of sObjects using the map constructor. Don't manually build a map using a FOR loop and put().", "locations": [{"startLine": 81, "comment": "SmallAntiPatterns.accountsById", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}], "primaryLocationIndex": 0, "resources": ["https://help.salesforce.com/s/articleView?id=xcloud.apexguru_antipattern_sobject_map_in_for_loop.htm&type=5"], "severity": 4, "suggestions": [{"message": "Map<Id,Account> accMap = new Map<Id,Account>([SELECT Id, Name FROM Account]);\n\n// If the number of the records from the query is too large, you can apply the \"putAll\" method:\n\nMap<Id,Account> accMap = new Map<Id,Account>();\nfor (List<Account> records: [SELECT Id, Name FROM Account]) {\n    accMap.putAll(records);\n}", "location": {"startLine": 81, "comment": "SmallAntiPatterns.accountsById", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}}], "metadata": {"original_code": "Line 80:        Map<Id, Account> accMap = new Map<Id, Account>();\nLine 81:        for (Account acc : [SELECT Id, Name FROM Account]) {\nLine 82:            accMap.put(acc.Id, acc);\nLine 83:        }\n", "class_name": "SmallAntiPatterns", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}}, {"rule": "CopyingListOrSetElementsUsingAForLoop", "message": "You're using a loop to individually copy elements from a list or set. This wastes CPU time and can exceed governor limits. Assign function or query outputs directly, or use the addAll() method to copy list or set elements.", "locations": [{"startLine": 89, "comment": "SmallAntiPatterns.copyAccountNames", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}], "primaryLocationIndex": 0, "resources": ["https://help.salesforce.com/s/articleView?id=xcloud.apexguru_antipattern_copying_elements_with_for_loop.htm&type=5"], "severity": 4, "suggestions": [{"message": "copy.addAll(names);\n//         for (String name : names) {\n//             copy.add(name);\n//         }", "location": {"startLine": 89, "comment": "SmallAntiPatterns.copyAccountNames", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}}], "metadata": {"original_code": "Line 89:        for (String name : names) {\nLine 90:            copy.add(name);\nLine 91:        }\n", "class_name": "SmallAntiPatterns", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}}, {"rule": "BusyLoopDelay", "message": "You're using an empty loop to delay program execution. This wastes CPU time and uses the Apex CPU governor limit. If the delay was added because of an async job, use System.enqueueJob with a delay parameter.", "locations": [{"startLine": 106, "comment": "SmallAntiPatterns.busyWait", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}], "primaryLocationIndex": 0, "resources": ["https://help.salesforce.com/s/articleView?id=xcloud.apexguru_antipattern_busy_loop_delay.htm&type=5"], "severity": 4, "metadata": {"original_code": "Line 105:        Long endTime = startTime + 5000;\nLine 106:        while (DateTime.now().getTime() < endTime) {\nLine 107:            // spins doing nothing until the delay elapses\nLine 108:        }\nLine 109:        System.debug('Busy wait finished.');\n", "class_name": "SmallAntiPatterns", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}}, {"rule": "UsingTheTestMethodKeyword", "message": "The testMethod keyword is deprecated. To stay within org limits, move test methods to a separate @isTest class.", "locations": [{"startLine": 136, "comment": "SmallAntiPatterns.legacyTestMethod", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}], "primaryLocationIndex": 0, "resources": ["https://help.salesforce.com/s/articleView?id=xcloud.apexguru_test_case_antipattern_using_testmethod.htm&type=5"], "severity": 3, "metadata": {"original_code": "    public static testMethod void legacyTestMethod() {\n", "class_name": "SmallAntiPatterns", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}}, {"rule": "Redundant Soql", "message": "Consider merging multiple SOQL queries on the same sObject into one query to reduce database round trips and improve performance.", "locations": [{"startLine": 36, "comment": "SmallAntiPatterns.totalOpenAmount", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}, {"startLine": 39, "comment": "Redundant SOQL", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}], "primaryLocationIndex": 0, "resources": ["https://help.salesforce.com/s/articleView?id=xcloud.apexguru_antipattern_redundant_soql.htm&type=5"], "severity": 4, "suggestions": [{"message": "List<Opportunity> openOpps = [SELECT Amount FROM Opportunity WHERE AccountId = :accountId AND IsClosed = false];\nDecimal total = 0;\nfor (Opportunity o : openOpps) {\n    total += o.Amount;\n}\nSystem.debug('Open opp count: ' + openOpps.size());", "location": {"startLine": 36, "comment": "SmallAntiPatterns.totalOpenAmount", "file": "force-app/main/default/classes/SmallAntiPatterns.cls"}}], "metadata": {"original_code": "Line 36:        List<Opportunity> forTotal = [\nLine 37:            SELECT Amount FROM Opportunity WHERE AccountId = :accountId AND IsClosed = false\nLine 38:        ];\nLine 39:        List<Opportunity> forCount = [\nLine 40:            SELECT Amount FROM Opportunity WHERE AccountId = :accountId AND IsClosed = false\nLine 41:        ];\n", "class_name": "SmallAntiPatterns", "file": "force-app/main/default/classes/SmallAntiPatterns.cls", "category": "redundant_soql_query"}}]",
+  "message": null,
+  "violationCount": 20,
+  "filesScanned": 1,
+  "violationBreakdown": {
+    "SOQL_IN_LOOP": 1,
+    "SOQL_UNUSED_FIELDS": 3,
+    "GGD": 1,
+    "SOQL_NEGATIVE_EXPR": 1,
+    "SOQL_AGGREGATION": 2,
+    "REDUNDANT_SOQL": 1,
+    "SOQL_NO_WHERE_LIMIT": 3,
+    "SOQL_SORT_IN_APEX": 1,
+    "SOQL_FILTER_IN_APEX": 1,
+    "BUSY_DELAY_LOOP": 1,
+    "COPY_LIST_ELEMENTS_LOOP": 1,
+    "DML_IN_LOOP": 1,
+    "DEPRECATED_TEST_METHOD_KEYWORD": 1,
+    "SOQL_IN_LOOP_1HOP": 1,
+    "CREATE_MAP_WITH_LOOP": 1
+  }
+}

package/skills/dx-apexguru-scan/examples/sample-succeeded-response.json

@@ -0,0 +1,15 @@
+{
+  "scanId": "scan-7f3a91",
+  "status": "SUCCEEDED",
+  "analysisMode": "static",
+  "violationCount": 4,
+  "filesScanned": 3,
+  "violationBreakdown": {
+    "SOQL_IN_LOOP": 1,
+    "DML_IN_LOOP": 1,
+    "SOQL_NO_WHERE_OR_LIMIT": 1,
+    "GGD": 1
+  },
+  "report": "W3sicnVsZSI6IlNPUUxfSU5fTE9PUCIsIm1lc3NhZ2UiOiJTT1FMIHF1ZXJ5IGV4ZWN1dGVkIGluc2lkZSBhIGZvci1sb29wIG92ZXIgQWNjb3VudHMiLCJzZXZlcml0eSI6MiwibG9jYXRpb24iOnsiZmlsZSI6ImZvcmNlLWFwcC9tYWluL2RlZmF1bHQvY2xhc3Nlcy9BY2NvdW50U2VydmljZS5jbHMiLCJsaW5lIjo0Mn0sImZpeGVzIjpbIk1vdmUgdGhlIHF1ZXJ5IG91dHNpZGUgdGhlIGxvb3A7IGJ1aWxkIGEgTWFwPElkLENvbnRhY3Q+IGZvciBpbi1sb29wIGxvb2t1cHMiXSwicmVzb3VyY2VzIjpbImh0dHBzOi8vZGV2ZWxvcGVyLnNhbGVzZm9yY2UuY29tL2RvY3MvYXBleGd1cnUvc29xbC1pbi1sb29wIl19LHsicnVsZSI6IkRNTF9JTl9MT09QIiwibWVzc2FnZSI6InVwZGF0ZSBzdGF0ZW1lbnQgaW5zaWRlIGEgbG9vcCIsInNldmVyaXR5IjoxLCJsb2NhdGlvbiI6eyJmaWxlIjoiZm9yY2UtYXBwL21haW4vZGVmYXVsdC9jbGFzc2VzL0FjY291bnRTZXJ2aWNlLmNscyIsImxpbmUiOjYwfSwiZml4ZXMiOlsiQ29sbGVjdCByZWNvcmRzIGludG8gYSBMaXN0IGFuZCB1cGRhdGUgb25jZSBhZnRlciB0aGUgbG9vcCJdLCJyZXNvdXJjZXMiOltdfSx7InJ1bGUiOiJTT1FMX05PX1dIRVJFX09SX0xJTUlUIiwibWVzc2FnZSI6IlNFTEVDVCB3aXRoIG5laXRoZXIgV0hFUkUgbm9yIExJTUlUIG9uIE9wcG9ydHVuaXR5Iiwic2V2ZXJpdHkiOjIsImxvY2F0aW9uIjp7ImZpbGUiOiJmb3JjZS1hcHAvbWFpbi9kZWZhdWx0L2NsYXNzZXMvUmVwb3J0QnVpbGRlci5jbHMiLCJsaW5lIjoxNX0sImZpeGVzIjpbIkFkZCBhIHNlbGVjdGl2ZSBXSEVSRSBvbiBhbiBpbmRleGVkIGZpZWxkIGFuZCBhIExJTUlUIl0sInJlc291cmNlcyI6W119LHsicnVsZSI6IkdHRCIsIm1lc3NhZ2UiOiJTY2hlbWEuZ2V0R2xvYmFsRGVzY3JpYmUoKSBjYWxsZWQgb24gZXZlcnkgcmVxdWVzdCIsInNldmVyaXR5IjozLCJsb2NhdGlvbiI6eyJmaWxlIjoiZm9yY2UtYXBwL21haW4vZGVmYXVsdC9jbGFzc2VzL1V0aWxzLmNscyIsImxpbmUiOjEyfSwiZml4ZXMiOlsiVXNlIFNPYmplY3RUeXBlLmdldERlc2NyaWJlKCkgZm9yIHRoZSBzcGVjaWZpYyBvYmplY3QiXSwicmVzb3VyY2VzIjpbXX1d",
+  "message": null
+}

package/skills/dx-apexguru-scan/references/api-reference.md

@@ -0,0 +1,81 @@
+# ApexGuru SFAP Scan API Reference
+
+**Base URL (production):** `https://api.salesforce.com/platform/scale/v1-beta.1/apex-guru`
+
+The host is chosen from the token's environment (prod/stage/dev); `stage.` and
+`dev.api.salesforce.com` are internal-only. Customers on a prod org always hit
+production. See `authentication.md` for the routing table.
+
+**Auth:** `Authorization: Bearer <sfap_api JWT>`. Org comes from the token's
+`tnk` claim (`core/<instance>/<orgId>`) — no org id in the request.
+
+## Call 1 — Submit a scan
+
+```http
+POST /scan
+  -H "Authorization: Bearer $JWT"
+  -F "file=@project.zip;type=application/zip"
+  [ -F "fastMode=true" ]     # optional: skip LLM-heavy fix generation → faster/cheaper
+```
+
+- Zip may use **any** layout — the API walks the whole archive and extracts
+  every Apex file it finds. No `force-app/` tree at the root is required
+  (`build-zip.sh` collects every `.cls`/`.trigger` under the project root,
+  preserving relative paths).
+- Limits: **200MB compressed**, **1GB decompressed**.
+- Success → `202`:
+
+```json
+{ "scanId": "…", "status": "QUEUED" }
+```
+
+## Call 2 — Poll for result
+
+```http
+GET /scan/{scanId}
+  -H "Authorization: Bearer $JWT"
+```
+
+- Status progression: `QUEUED → RUNNING → SUCCEEDED` (or `FAILED`).
+- Poll ~every **15s**.
+- On `SUCCEEDED`:
+
+```json
+{
+  "scanId": "…",
+  "status": "SUCCEEDED",
+  "analysisMode": "static",          // "static" = source-only | "full" = org onboarded, runtime metrics
+  "violationCount": 39,
+  "filesScanned": 16,
+  "violationBreakdown": { "SOQL_IN_LOOP": 15, "DML_IN_LOOP": 8, "GGD": 2 },
+  "report": "<base64-encoded JSON array of violations>",
+  "message": null
+}
+```
+
+## The `report` field
+
+Base64 → decode → **JSON array of violations**. Each violation carries:
+
+- `rule` — the antipattern id (e.g. `SOQL_IN_LOOP`).
+- `message` — human-readable description.
+- `severity` — 1 (Critical) … 5 (Info).
+- source location — `file` + `line`.
+- suggested fix(es).
+- help-doc `resources`.
+
+`decode-report.js` tolerates field-name drift (`location`/`locations[0]`,
+`fixes`/`suggestedFixes`, `severity`/`sev`) so minor API-shape changes don't break parsing.
+
+## Status codes
+
+| Code | Meaning |
+|------|---------|
+| 202 | Scan accepted (submit) |
+| 200 | Poll OK |
+| 400 | Malformed zip, no Apex inside, or over size limit |
+| 401 | Bad / expired / wrong-env token |
+| 403 | Scan owned by a different org (token `tnk` mismatch) |
+| 404 | Unknown scanId, or archived (~30-day GC) |
+
+See `error-handling.md` for resolutions.

package/skills/dx-apexguru-scan/references/authentication.md

@@ -0,0 +1,134 @@
+# Authentication — SFAP Access Token
+
+The ApexGuru SFAP Scan API authenticates with an **SFAP access token (JWT)
+carrying the `sfap_api` scope**. There is **no org id parameter** — the target
+org, and the environment (prod/stage/dev) the request is routed to, are both
+derived from the token's `tnk` claim, formatted `core/<instance>/<orgId>`.
+Customers authenticate a production org (`tnk core/prod/<orgId>`), so their
+requests always go to production.
+
+## Where the JWT comes from (Tharun's interim guide)
+
+The token is derived from an **authenticated `sf` CLI org**. `resolve-token.sh`
+obtains the org's live session id and exchanges it for the SFAP JWT by calling
+`<instanceUrl>/ide/auth`, which returns `{ "jwt": "...", "message": "..." }`.
+
+This is Tharun's **interim** approach — the Code Analyzer team may provide a cleaner
+path later. `resolve-token.sh` is the **single place** that changes when it does;
+everything downstream consumes the token opaquely.
+
+### How the session id is obtained (important)
+
+`sf org display --json` **redacts** `accessToken` on recent CLI versions
+(≈2.14x+) — it returns a `[REDACTED]…` placeholder, not a usable token. Sending
+that to `/ide/auth` yields a bare `401 "No session ID sent"`. So the resolver does
+**not** use `sf org display`'s access token. Instead it:
+
+1. reads the (non-redacted) `instanceUrl` from `sf org display --json`,
+2. gets a frontdoor URL from `sf org open --url-only --json`,
+3. follows that URL with `curl` to mint the real `sid` session cookie, and
+4. sends the `sid` as `Authorization: Bearer` to `<instanceUrl>/ide/auth`.
+
+The `sid` is a secret: it lives only in a `0600` temp cookie jar that the script
+deletes on exit, and is never echoed.
+
+## How `resolve-token.sh` resolves the token
+
+In priority order (first hit wins):
+
+1. **`APEXGURU_SFAP_TOKEN`** environment variable — the raw JWT. Most portable;
+   works headless and in CI. Use this in environments where `sf org open` can't
+   run (no browser session), supplying a production `sfap_api` JWT directly.
+2. **`APEXGURU_SFAP_TOKEN_FILE`** environment variable — a path to a file containing
+   the JWT (whitespace trimmed). Keeps the token out of shell history.
+3. **`sf` CLI → frontdoor `sid` → `<instanceUrl>/ide/auth`** — derives the JWT from
+   an authenticated **production** org. Requires `sf`, `jq`, and `curl`. Org
+   selection: `--org <alias>` flag, else the `APEXGURU_SF_ORG` env var, else the
+   CLI's default/target org. The user just needs to be logged in
+   (`sf org login web`).
+
+If none succeed, the script returns:
+
+```json
+{"error":"no SFAP token found","hint":"Sign in to an authorized Salesforce org to run an ApexGuru scan and compare your code against production performance data."}
+```
+
+### Setting up the `sf` CLI path
+
+```bash
+# Log in once to a PRODUCTION org (My Domain or internal login host):
+sf org login web --instance-url "https://<your-prod-host>" --alias <your-alias>
+
+# Then the skill derives the JWT automatically. To target a specific org:
+bash run-scan.sh <zip> <raw-out.json> --org <your-alias>
+```
+
+The `/ide/auth` response also carries a `message` field; only `jwt` is consumed.
+Treat the derived JWT as a secret — the scripts never echo it (see the mandatory
+script rules in SKILL.md). `resolve-token.sh` never prints the token to stdout:
+it writes the JWT to a `0600` temp file and returns only the path in a
+`tokenFile` field; `run-scan.sh` reads that file into memory and deletes it
+immediately.
+
+> **Note:** some orgs gate `/ide/auth` behind MFA enrollment — the exchange then
+> returns an HTML redirect to a two-factor setup page instead of a JWT. If that
+> happens, either complete MFA enrollment for that org or supply a production
+> `sfap_api` JWT directly via `APEXGURU_SFAP_TOKEN`.
+
+## Local pre-flight token check (no network)
+
+Once a token is found, `resolve-token.sh` pipes it to `validate-token.js`, which
+decodes the JWT's freely-readable header/body claims (it does **not** verify the
+signature — only the server can) to catch the two things behind almost every
+`401` **before** we zip and upload, and to detect the token's environment:
+
+1. **Missing scope** — the `scp`/`scope` claim doesn't include `sfap_api`.
+2. **Expired** — `exp` is in the past.
+
+It also reads the environment from the `tnk` instance segment (and `iss` host) —
+`core/prod/...` → prod, `core/stagecomstg2/...` → stage, `core/falcondeva/...` →
+dev — and reports it as `detectedEnv` so `resolve-token.sh` routes to the
+matching host. This is **not** a block: a stage/dev token routes to the stage/dev
+endpoint instead of being rejected.
+
+Only **provable** failures block (exit 1 with a clear `error`/`hint`). Anything the
+script can't read — an opaque non-JWT token, or a missing claim — is a non-fatal
+warning, so this never blocks a valid token it simply can't introspect. The token
+is passed on **stdin**, never as a command-line argument, so it stays out of the
+process list.
+
+Example fail-fast message (instead of a bare HTTP 401 deep in the poll loop):
+
+```json
+{"ok":false,"error":"token scope does not include sfap_api","hint":"Re-mint the token with the sfap_api scope. See references/authentication.md."}
+```
+
+## Setup for the user
+
+```bash
+# Normal path: just log in to a production org with the sf CLI
+# (the JWT is derived automatically).
+sf org login web --instance-url "https://<your-prod-host>" --alias <your-alias>
+
+# Override A: env var for the session (CI/headless, or to bypass sf CLI)
+export APEXGURU_SFAP_TOKEN="eyJ...<production sfap_api JWT>..."
+
+# Override B: token file (not echoed into history)
+export APEXGURU_SFAP_TOKEN_FILE="$HOME/.apexguru/sfap-token"
+```
+
+## Endpoint routing
+
+The base URL is chosen from the token's detected environment, so the request
+always lands where the token was issued:
+
+| Env   | Host                        | Base URL                                                        |
+|-------|-----------------------------|-----------------------------------------------------------------|
+| prod  | `api.salesforce.com`        | `https://api.salesforce.com/platform/scale/v1-beta.1/apex-guru`       |
+| stage | `stage.api.salesforce.com`  | `https://stage.api.salesforce.com/platform/scale/v1-beta.1/apex-guru` |
+| dev   | `dev.api.salesforce.com`    | `https://dev.api.salesforce.com/platform/scale/v1-beta.1/apex-guru`   |
+
+There is no `--env` flag: routing is automatic from the `tnk` claim, and an
+undetectable environment defaults to prod. Customers authenticate a production
+org, so they always hit `api.salesforce.com`; the stage/dev hosts exist for
+internal testing against non-prod orgs.

package/skills/dx-apexguru-scan/references/error-handling.md

@@ -0,0 +1,56 @@
+# Error Handling Guide
+
+`run-scan.sh` emits `{error, httpStatus, status, hint}` on failure and maps each HTTP
+status to an actionable hint. Relay the hint to the user.
+
+## HTTP status codes
+
+| Code | Likely cause | Resolution |
+|------|--------------|------------|
+| **400** | Malformed zip, no Apex inside, or over size limit | Re-package with `build-zip.sh` (collects every `.cls`/`.trigger` and checks the 200MB compressed limit). If genuinely large, scope to a subset of the project. Decompressed limit is 1GB. |
+| **401** | Token bad or expired | Re-authenticate the Salesforce org (or supply a fresh `sfap_api` JWT via `APEXGURU_SFAP_TOKEN`). The endpoint is routed to the token's environment automatically. See `authentication.md`. |
+| **403** | Scan owned by a different org | The token's `tnk`-claim org must match the scan owner. Use the token for the org that submitted the scan. |
+| **404** | Unknown `scanId`, or scan archived | Scans are GC'd after ~30 days. Re-submit to get a fresh `scanId`. |
+
+## Scan `status: FAILED`
+
+The poll returns `FAILED` with a `message`. Surface the message verbatim, address the
+stated cause, and re-submit. This is distinct from an HTTP error — the request
+succeeded but the scan itself failed server-side.
+
+## Timeout (scan didn't finish)
+
+`run-scan.sh` polls up to `--max-polls` × `--interval` seconds (default 40 × 15s =
+10 min). If it times out:
+
+- Large projects legitimately take longer → re-run with `--max-polls 80`.
+- Or add `--fast` to skip LLM-heavy fix generation.
+
+## `analysisMode` and the three ApexGuru states
+
+**Not an error.** The API's `analysisMode` plus the presence of runtime metrics
+(`cpu_time_percentage` on any violation) distinguish three states. `decode-report.js`
+handles all three automatically — this is background for interpreting the output:
+
+| State | `analysisMode` | Runtime metrics | Header | What it means |
+|-------|----------------|-----------------|--------|---------------|
+| Not onboarded | `static` | none | **Static only** | The org is **not onboarded** to ApexGuru — only source-only analysis ran. |
+| Onboarded, no runtime data yet | `full` | none | **Static only** | The org **is onboarded**, but there's no runtime data for this code yet. Result is static-equivalent. |
+| Onboarded, enriched | `full` | present | **Production insights** | Onboarded **and** runtime metrics were applied (CPU hotspots, severity adjusted from production performance). |
+
+Runtime data is populated by ApexGuru's weekend runs, or on demand from Scale
+Center. So `full` + no runtime data is expected for a freshly-onboarded org or
+newly-added code — it is **not** an error, and re-scanning won't change it until
+runtime data exists. `decode-report.js --present` prints the correct guidance line
+for each state ("generate a runtime report in Scale Center"); print it verbatim.
+
+## Missing local prerequisites
+
+| Symptom | Fix |
+|---------|-----|
+| `no SFAP token found` | No authenticated org and no token env var. Print the script's `hint` verbatim as the entire message — do not add framing or alternative instructions: "Sign in to an authorized Salesforce org to run an ApexGuru scan and compare your code against production performance data." |
+| `token scope does not include sfap_api` | Re-mint the token with the `sfap_api` scope. Pre-empts a 401. |
+| `token expired Ns ago` | Re-mint a fresh SFAP token and retry. Pre-empts a 401. |
+| `no Apex (.cls/.trigger) files found` | Point `build-zip.sh` at a folder that contains Apex classes or triggers (any layout — an sfdx project, a `force-app/` subtree, or a loose folder of `.cls` files) |
+| `zip: command not found` / `jq: command not found` | Install the missing tool (`brew install jq`, etc.) |
+| `network error submitting scan` | Check connectivity/VPN to the API host |

package/skills/dx-apexguru-scan/references/violation-catalog.md

@@ -0,0 +1,28 @@
+# ApexGuru Violation Catalog
+
+Performance antipatterns ApexGuru detects, with what they mean and the typical fix.
+Use this to explain a violation when the user asks "what does this mean / how do I
+fix it?". The API's `report` carries per-violation `message`, `fixes`, and help-doc
+`resources` — prefer those when present; this catalog is the fallback explanation.
+
+| Rule (`rule`) | What it flags | Why it hurts | Typical fix |
+|---------------|---------------|--------------|-------------|
+| `SOQL_IN_LOOP` | A SOQL query inside a `for`/`while` loop | Each iteration issues a query → hits the 100-SOQL governor limit fast; slow | Move the query outside the loop; query once and build a `Map<Id, SObject>` keyed for lookup inside the loop |
+| `DML_IN_LOOP` | `insert`/`update`/`delete`/`upsert` inside a loop | Each iteration issues DML → hits the 150-DML limit; slow | Collect records into a `List` and perform one DML statement after the loop |
+| `GGD` | `Schema.getGlobalDescribe()` usage | Describes **every** object in the org — expensive, grows with org size | Use targeted describes (`SObjectType.getDescribe()`, `Schema.describeSObjects([...])`) for only the objects needed |
+| `SOQL_NO_WHERE_OR_LIMIT` | SOQL with neither `WHERE` nor `LIMIT` | Full-table scan; can return huge result sets and blow the heap / row limits | Add a selective `WHERE` clause and/or a `LIMIT`; ensure filters are on indexed fields |
+| `SOQL_UNUSED_FIELDS` | SELECTed fields never read | Wastes query CPU/heap fetching unused columns | Select only fields the code actually uses |
+
+## Severity mapping
+
+ApexGuru severities follow the standard 1–5 scale: **1 = Critical, 2 = High,
+3 = Moderate, 4 = Low, 5 = Info.** `DML_IN_LOOP` and `SOQL_IN_LOOP` are usually the
+highest-impact (governor-limit) findings.
+
+## Static vs. full attribution
+
+- **Static** findings come from source analysis alone — the antipattern exists in the
+  code regardless of runtime.
+- **Full** findings are enriched with production metrics — e.g. a `SOQL_IN_LOOP`
+  that actually executed against large data volumes in production is prioritized
+  higher. Always label which mode produced the results.

package/skills/dx-apexguru-scan/scripts/build-zip.sh

@@ -0,0 +1,87 @@
+#!/usr/bin/env bash
+# Package a customer's Apex into a .zip for the ApexGuru SFAP Scan API.
+#
+# The API walks the ENTIRE uploaded archive and extracts every Apex file it
+# finds — it does NOT require a force-app/ tree at the root (confirmed against
+# production). So we scan whatever the customer points us at: collect every
+# Apex source file (`.cls` / `.trigger`) under <project-root>, preserving its
+# relative path, and zip that. A plain sfdx project, a loose folder of classes,
+# or a deeply-nested monorepo subtree all work.
+#
+# Usage: bash build-zip.sh <project-root> <output-zip-path>
+#
+# <project-root> is any folder that contains Apex somewhere beneath it (an sfdx
+# project root, a force-app/ subtree, or an ad-hoc folder of .cls files).
+#
+# Output (stdout, single line JSON):
+#   {"zip":"<abs path>","bytes":123,"humanSize":"1.2M","apexFileCount":N,"scanRoot":"<path>"}
+# On failure: {"error":"...","hint":"..."} and exit 1.
+#
+# API limits enforced here (fail fast, before upload): 200MB compressed.
+# (1GB decompressed is enforced server-side; we cannot cheaply predict it.)
+set -euo pipefail
+
+MAX_COMPRESSED_BYTES=$((200 * 1024 * 1024))
+
+PROJECT_ROOT="${1:-}"
+OUT_ZIP="${2:-}"
+
+if [ -z "$PROJECT_ROOT" ] || [ -z "$OUT_ZIP" ]; then
+  printf '{"error":"missing args","hint":"usage: build-zip.sh <project-root> <output-zip-path>"}\n'
+  exit 1
+fi
+
+if [ ! -d "$PROJECT_ROOT" ]; then
+  printf '{"error":"project root not found: %s","hint":"pass a folder that contains Apex (.cls/.trigger) files"}\n' "$PROJECT_ROOT"
+  exit 1
+fi
+
+# Resolve absolute paths.
+ROOT_ABS="$(cd "$PROJECT_ROOT" && pwd)"
+case "$OUT_ZIP" in
+  /*) OUT_ABS="$OUT_ZIP" ;;
+  *)  OUT_ABS="$(pwd)/$OUT_ZIP" ;;
+esac
+
+rm -f "$OUT_ABS"
+
+# The set of Apex source files under the root (relative paths, noise excluded).
+# Defined once as a function so the count pass and the zip pass use the exact
+# same list. `zip -@` reads a newline-delimited list, so we emit newline-
+# terminated relative paths with the leading "./" stripped.
+apex_files() {
+  find . -type f \( -name '*.cls' -o -name '*.trigger' \) \
+    -not -path '*/node_modules/*' -not -path '*/.git/*' -print \
+    | sed 's#^\./##'
+}
+
+APEX_COUNT=0
+while IFS= read -r _; do
+  APEX_COUNT=$((APEX_COUNT + 1))
+done < <(cd "$ROOT_ABS" && apex_files)
+
+if [ "$APEX_COUNT" -eq 0 ]; then
+  printf '{"error":"no Apex (.cls/.trigger) files found under %s","hint":"point build-zip.sh at a folder that contains Apex classes or triggers"}\n' "$ROOT_ABS"
+  exit 1
+fi
+
+# Feed the file list to zip via stdin (-@) so we never hit ARG_MAX on large
+# projects. Paths are relative to ROOT_ABS, so the archive mirrors the project
+# layout (the API re-walks it regardless of structure).
+( cd "$ROOT_ABS" && apex_files | zip -q -X "$OUT_ABS" -@ >/dev/null )
+
+if [ ! -f "$OUT_ABS" ]; then
+  printf '{"error":"zip creation failed","hint":"check write permissions for %s"}\n' "$OUT_ABS"
+  exit 1
+fi
+
+BYTES=$(wc -c < "$OUT_ABS" | tr -d '[:space:]')
+if [ "$BYTES" -gt "$MAX_COMPRESSED_BYTES" ]; then
+  printf '{"error":"zip is %s bytes, over the 200MB compressed limit","hint":"scope the scan to a subset of the project or split it"}\n' "$BYTES"
+  exit 1
+fi
+
+HUMAN=$(echo "$BYTES" | awk '{ split("B K M G", u); s=$1; i=1; while (s>=1024 && i<4){s/=1024; i++} printf (i==1 ? "%d%s" : "%.1f%s"), s, u[i] }')
+
+jq -cn --arg zip "$OUT_ABS" --argjson bytes "$BYTES" --arg human "$HUMAN" --argjson count "$APEX_COUNT" --arg root "$ROOT_ABS" \
+  '{zip:$zip, bytes:$bytes, humanSize:$human, apexFileCount:$count, scanRoot:$root}'