codeql-development-mcp-server 2.24.2-rc2 → 2.24.2

package/ql/java/tools/src/CallGraphTo/CallGraphTo.md

@@ -0,0 +1,41 @@
+# CallGraphTo for Java
+
+Displays calls made to a specified method, showing the call graph inbound to the target method.
+
+## Overview
+
+This query identifies all call sites that invoke a named method, producing an inbound call graph. Given a target method name, it reports each caller and call location, which is useful for understanding how a method is used across the codebase.
+
+The query accepts method names via an external predicate (`targetFunction`).
+
+## Use Cases
+
+This query is primarily used for:
+
+- Finding all callers of a specific method
+- Impact analysis before modifying a method signature
+- Understanding usage patterns and entry points
+
+## Example
+
+The following Java code demonstrates inbound calls to `targetMethod`:
+
+```java
+void targetMethod() {}            // Target method for analysis
+
+void caller1() { targetMethod(); }
+void caller2() { targetMethod(); }
+```
+
+Running with `targetFunction = "targetMethod"` produces results showing each call site with the message pattern ``Call to `targetMethod` from `caller1``.
+
+## Output Format
+
+The query is a `@kind problem` query producing rows of:
+
+- ``select call, "Call to `target` from `caller`"``
+
+## References
+
+- [Java Methods](https://docs.oracle.com/javase/tutorial/java/javaOO/methods.html)
+- [CodeQL Call Graph Analysis](https://codeql.github.com/docs/writing-codeql-queries/about-data-flow-analysis/)

package/ql/java/tools/src/PrintAST/PrintAST.md

@@ -0,0 +1,54 @@
+# Print AST for Java
+
+Outputs a representation of the Abstract Syntax Tree (AST) for specified source files.
+
+## Overview
+
+The Abstract Syntax Tree is a hierarchical representation of source code structure. Each node represents a syntactic construct (declaration, statement, expression, etc.) and edges represent parent-child containment relationships.
+
+This query produces the full AST for specified Java source files, which is useful for understanding code structure, inspecting how the CodeQL extractor parses classes and methods, and debugging query logic that operates on AST nodes.
+
+## Use Cases
+
+This query is primarily used for:
+
+- Inspecting how CodeQL represents Java classes, methods, and expressions
+- Debugging queries that match on AST node types
+- Understanding parent-child relationships between packages, types, and members
+- Verifying extractor behavior for generics, annotations, and lambda expressions
+- IDE integration for syntax tree visualization
+
+## Example
+
+The following Java code demonstrates AST structure through class and method declarations:
+
+```java
+public class Example {
+    public void greet(String name) {  // Method declaration in AST
+        System.out.println("Hello, " + name + "!");
+    }
+
+    public static void main(String[] args) {  // Entry point declaration
+        Example e = new Example();
+        e.greet("World");
+    }
+}
+```
+
+In the resulting AST:
+
+- The class declaration contains method declarations as children
+- Each method body contains a block with statement nodes
+- Call expressions reference their target and arguments as child nodes
+
+## Output Format
+
+The query produces a graph via the `PrintAstConfiguration` library:
+
+- `nodes`: Each AST node with its type, label, and properties
+- `edges`: Parent-child relationships forming the syntax tree
+
+## References
+
+- [Java Language Specification](https://docs.oracle.com/javase/specs/)
+- [CodeQL Abstract Syntax Trees](https://codeql.github.com/docs/writing-codeql-queries/abstract-syntax-tree/)

package/ql/java/tools/src/PrintCFG/PrintCFG.md

@@ -24,13 +24,13 @@ The following Java code demonstrates control flow through conditional statements
 
 ```java
 public void example(int x) {
-    if (x > 0) {                     // COMPLIANT - Branching creates CFG edges
+    if (x > 0) {  // Branching creates CFG edges
         System.out.println("Positive");
     } else {
         System.out.println("Non-positive");
     }
 
-    for (int i = 0; i < 3; i++) {    // COMPLIANT - Loop creates cyclic CFG
+    for (int i = 0; i < 3; i++) {  // Loop creates cyclic CFG
         System.out.println(i);
     }
 }

package/ql/java/tools/src/codeql-pack.yml

@@ -1,5 +1,5 @@
 name: advanced-security/ql-mcp-java-tools-src
-version: 2.24.2-rc2
+version: 2.24.2
 description: 'Queries for codeql-development-mcp-server tools for java language'
 library: false
 dependencies:

package/ql/javascript/tools/src/CallGraphFrom/CallGraphFrom.md

@@ -0,0 +1,47 @@
+# CallGraphFrom for JavaScript
+
+Displays calls made from a specified function, showing the call graph outbound from the source function.
+
+## Overview
+
+This query identifies all function calls made within the body of a named function, producing an outbound call graph. Given a source function name, it reports each call site and the callee, which is useful for understanding function dependencies and call chains.
+
+The query accepts function names via an external predicate (`sourceFunction`).
+
+## Use Cases
+
+This query is primarily used for:
+
+- Mapping outbound dependencies of a specific function
+- Understanding what a function calls and in what order
+- Analyzing call chains for refactoring or security review
+
+## Example
+
+The following JavaScript code demonstrates outbound calls from `sourceFunc`:
+
+```javascript
+function helper1() {}
+function helper2() {
+  helper1();
+}
+
+function sourceFunc() {
+  // Source function for analysis
+  helper1();
+  helper2();
+}
+```
+
+Running with `sourceFunction = "sourceFunc"` produces results showing each call site with the message pattern ``Call from `sourceFunc` to `helper1``.
+
+## Output Format
+
+The query is a `@kind problem` query producing rows of:
+
+- ``select call, "Call from `source` to `callee`"``
+
+## References
+
+- [JavaScript Functions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Functions)
+- [CodeQL Call Graph Analysis](https://codeql.github.com/docs/writing-codeql-queries/about-data-flow-analysis/)

package/ql/javascript/tools/src/CallGraphTo/CallGraphTo.md

@@ -0,0 +1,45 @@
+# CallGraphTo for JavaScript
+
+Displays calls made to a specified function, showing the call graph inbound to the target function.
+
+## Overview
+
+This query identifies all call sites that invoke a named function, producing an inbound call graph. Given a target function name, it reports each caller and call location, which is useful for understanding how a function is used across the codebase.
+
+The query accepts function names via an external predicate (`targetFunction`).
+
+## Use Cases
+
+This query is primarily used for:
+
+- Finding all callers of a specific function
+- Impact analysis before modifying a function signature
+- Understanding usage patterns and entry points
+
+## Example
+
+The following JavaScript code demonstrates inbound calls to `targetFunc`:
+
+```javascript
+function targetFunc() {} // Target function for analysis
+
+function caller1() {
+  targetFunc();
+}
+function caller2() {
+  targetFunc();
+}
+```
+
+Running with `targetFunction = "targetFunc"` produces results showing each call site with the message pattern ``Call to `targetFunc` from `caller1``.
+
+## Output Format
+
+The query is a `@kind problem` query producing rows of:
+
+- ``select call, "Call to `target` from `caller`"``
+
+## References
+
+- [JavaScript Functions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Functions)
+- [CodeQL Call Graph Analysis](https://codeql.github.com/docs/writing-codeql-queries/about-data-flow-analysis/)

package/ql/javascript/tools/src/PrintAST/PrintAST.md

@@ -0,0 +1,58 @@
+# Print AST for JavaScript
+
+Outputs a representation of the Abstract Syntax Tree (AST) for specified source files.
+
+## Overview
+
+The Abstract Syntax Tree is a hierarchical representation of source code structure. Each node represents a syntactic construct (declaration, statement, expression, etc.) and edges represent parent-child containment relationships.
+
+This query produces the full AST for specified JavaScript source files, which is useful for understanding code structure, inspecting how the CodeQL extractor parses functions and expressions, and debugging query logic that operates on AST nodes.
+
+## Use Cases
+
+This query is primarily used for:
+
+- Inspecting how CodeQL represents JavaScript functions, classes, and expressions
+- Debugging queries that match on AST node types
+- Understanding parent-child relationships between modules, declarations, and statements
+- Verifying extractor behavior for arrow functions, destructuring, and async/await
+- IDE integration for syntax tree visualization
+
+## Example
+
+The following JavaScript code demonstrates AST structure through function and class declarations:
+
+```javascript
+class Example {
+  constructor(name = 'World') {
+    // Constructor in AST
+    this.name = name;
+  }
+
+  greet() {
+    // Method declaration in AST
+    console.log(`Hello, ${this.name}!`);
+  }
+}
+
+const e = new Example();
+e.greet();
+```
+
+In the resulting AST:
+
+- The class declaration contains method definitions as children
+- Each method body contains a block with statement nodes
+- Call expressions and template literals reference their components as child nodes
+
+## Output Format
+
+The query produces a graph via the `PrintAstConfiguration` library:
+
+- `nodes`: Each AST node with its type, label, and properties
+- `edges`: Parent-child relationships forming the syntax tree
+
+## References
+
+- [JavaScript Language Reference](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference)
+- [CodeQL Abstract Syntax Trees](https://codeql.github.com/docs/writing-codeql-queries/abstract-syntax-tree/)

package/ql/javascript/tools/src/PrintCFG/PrintCFG.md

@@ -25,14 +25,14 @@ The following JavaScript code demonstrates control flow through conditional stat
 ```javascript
 function example(x) {
   if (x > 0) {
-    // COMPLIANT - Branching creates CFG edges
+    // Branching creates CFG edges
     console.log('Positive');
   } else {
     console.log('Non-positive');
   }
 
   for (let i = 0; i < 3; i++) {
-    // COMPLIANT - Loop creates cyclic CFG
+    // Loop creates cyclic CFG
     console.log(i);
   }
 }

package/ql/javascript/tools/src/codeql-pack.yml

@@ -1,5 +1,5 @@
 name: advanced-security/ql-mcp-javascript-tools-src
-version: 2.24.2-rc2
+version: 2.24.2
 description: 'Queries for codeql-development-mcp-server tools for javascript language'
 library: false
 dependencies:

package/ql/python/tools/src/CallGraphFrom/CallGraphFrom.md

@@ -0,0 +1,46 @@
+# CallGraphFrom for Python
+
+Displays calls made from a specified function, showing the call graph outbound from the source function.
+
+## Overview
+
+This query identifies all function calls made within the body of a named function, producing an outbound call graph. Given a source function name, it reports each call site and the callee, which is useful for understanding function dependencies and call chains.
+
+The query accepts function names via an external predicate (`sourceFunction`).
+
+## Use Cases
+
+This query is primarily used for:
+
+- Mapping outbound dependencies of a specific function
+- Understanding what a function calls and in what order
+- Analyzing call chains for refactoring or security review
+
+## Example
+
+The following Python code demonstrates outbound calls from `source_func`:
+
+```python
+def helper1():
+    pass
+
+def helper2():
+    helper1()
+
+def source_func():               # Source function for analysis
+    helper1()
+    helper2()
+```
+
+Running with `sourceFunction = "source_func"` produces results showing each call site with the message pattern ``Call from `source_func` to `helper1``.
+
+## Output Format
+
+The query is a `@kind problem` query producing rows of:
+
+- ``select call, "Call from `source` to `callee`"``
+
+## References
+
+- [Python Functions](https://docs.python.org/3/tutorial/controlflow.html#defining-functions)
+- [CodeQL Call Graph Analysis](https://codeql.github.com/docs/writing-codeql-queries/about-data-flow-analysis/)

package/ql/python/tools/src/CallGraphTo/CallGraphTo.md

@@ -0,0 +1,45 @@
+# CallGraphTo for Python
+
+Displays calls made to a specified function, showing the call graph inbound to the target function.
+
+## Overview
+
+This query identifies all call sites that invoke a named function, producing an inbound call graph. Given a target function name, it reports each caller and call location, which is useful for understanding how a function is used across the codebase.
+
+The query accepts function names via an external predicate (`targetFunction`).
+
+## Use Cases
+
+This query is primarily used for:
+
+- Finding all callers of a specific function
+- Impact analysis before modifying a function signature
+- Understanding usage patterns and entry points
+
+## Example
+
+The following Python code demonstrates inbound calls to `target_func`:
+
+```python
+def target_func():                # Target function for analysis
+    pass
+
+def caller1():
+    target_func()
+
+def caller2():
+    target_func()
+```
+
+Running with `targetFunction = "target_func"` produces results showing each call site with the message pattern ``Call to `target_func` from `caller1``.
+
+## Output Format
+
+The query is a `@kind problem` query producing rows of:
+
+- ``select call, "Call to `target` from `caller`"``
+
+## References
+
+- [Python Functions](https://docs.python.org/3/tutorial/controlflow.html#defining-functions)
+- [CodeQL Call Graph Analysis](https://codeql.github.com/docs/writing-codeql-queries/about-data-flow-analysis/)

package/ql/python/tools/src/PrintAST/PrintAST.md

@@ -0,0 +1,53 @@
+# Print AST for Python
+
+Outputs a representation of the Abstract Syntax Tree (AST) for specified source files.
+
+## Overview
+
+The Abstract Syntax Tree is a hierarchical representation of source code structure. Each node represents a syntactic construct (declaration, statement, expression, etc.) and edges represent parent-child containment relationships.
+
+This query produces the full AST for specified Python source files, which is useful for understanding code structure, inspecting how the CodeQL extractor parses classes and functions, and debugging query logic that operates on AST nodes.
+
+## Use Cases
+
+This query is primarily used for:
+
+- Inspecting how CodeQL represents Python classes, functions, and expressions
+- Debugging queries that match on AST node types
+- Understanding parent-child relationships between modules, classes, and statements
+- Verifying extractor behavior for decorators, comprehensions, and f-strings
+- IDE integration for syntax tree visualization
+
+## Example
+
+The following Python code demonstrates AST structure through class and function declarations:
+
+```python
+class Example:
+    def __init__(self, name="World"):  # Method definition in AST
+        self.name = name
+
+    def greet(self):  # Method definition in AST
+        print(f"Hello, {self.name}!")
+
+example = Example()
+example.greet()
+```
+
+In the resulting AST:
+
+- The class definition contains function definitions as children
+- Each function body contains a statement list
+- Call expressions and f-strings reference their components as child nodes
+
+## Output Format
+
+The query produces a graph via the `PrintAstConfiguration` library:
+
+- `nodes`: Each AST node with its type, label, and properties
+- `edges`: Parent-child relationships forming the syntax tree
+
+## References
+
+- [Python Language Reference](https://docs.python.org/3/reference/)
+- [CodeQL Abstract Syntax Trees](https://codeql.github.com/docs/writing-codeql-queries/abstract-syntax-tree/)

package/ql/python/tools/src/PrintCFG/PrintCFG.md

@@ -24,12 +24,12 @@ The following Python code demonstrates control flow through conditional statemen
 
 ```python
 def example(x):
-    if x > 0:                      # COMPLIANT - Branching creates CFG edges
+    if x > 0:  # Branching creates CFG edges
         print("Positive")
     else:
         print("Non-positive")
 
-    for i in range(3):             # COMPLIANT - Loop creates cyclic CFG
+    for i in range(3):  # Loop creates cyclic CFG
         print(i)
 ```
 

package/ql/python/tools/src/codeql-pack.yml

@@ -1,5 +1,5 @@
 name: advanced-security/ql-mcp-python-tools-src
-version: 2.24.2-rc2
+version: 2.24.2
 description: 'Queries for codeql-development-mcp-server tools for python language'
 library: false
 dependencies:

package/ql/ruby/tools/src/CallGraphFrom/CallGraphFrom.md

@@ -0,0 +1,48 @@
+# CallGraphFrom for Ruby
+
+Displays calls made from a specified method, showing the call graph outbound from the source method.
+
+## Overview
+
+This query identifies all method calls made within the body of a named method, producing an outbound call graph. Given a source method name, it reports each call site and the callee, which is useful for understanding method dependencies and call chains.
+
+The query accepts method names via an external predicate (`sourceFunction`).
+
+## Use Cases
+
+This query is primarily used for:
+
+- Mapping outbound dependencies of a specific method
+- Understanding what a method calls and in what order
+- Analyzing call chains for refactoring or security review
+
+## Example
+
+The following Ruby code demonstrates outbound calls from `source_func`:
+
+```ruby
+def helper1
+end
+
+def helper2
+    helper1
+end
+
+def source_func                   # Source method for analysis
+    helper1
+    helper2
+end
+```
+
+Running with `sourceFunction = "source_func"` produces results showing each call site with the message pattern ``Call from `source_func` to `helper1``.
+
+## Output Format
+
+The query is a `@kind problem` query producing rows of:
+
+- ``select call, "Call from `source` to `callee`"``
+
+## References
+
+- [Ruby Methods](https://ruby-doc.org/core/doc/syntax/methods_rdoc.html)
+- [CodeQL Call Graph Analysis](https://codeql.github.com/docs/writing-codeql-queries/about-data-flow-analysis/)

package/ql/ruby/tools/src/CallGraphTo/CallGraphTo.md

@@ -0,0 +1,47 @@
+# CallGraphTo for Ruby
+
+Displays calls made to a specified method, showing the call graph inbound to the target method.
+
+## Overview
+
+This query identifies all call sites that invoke a named method, producing an inbound call graph. Given a target method name, it reports each caller and call location, which is useful for understanding how a method is used across the codebase.
+
+The query accepts method names via an external predicate (`targetFunction`).
+
+## Use Cases
+
+This query is primarily used for:
+
+- Finding all callers of a specific method
+- Impact analysis before modifying a method signature
+- Understanding usage patterns and entry points
+
+## Example
+
+The following Ruby code demonstrates inbound calls to `target_func`:
+
+```ruby
+def target_func                   # Target method for analysis
+end
+
+def caller1
+    target_func
+end
+
+def caller2
+    target_func
+end
+```
+
+Running with `targetFunction = "target_func"` produces results showing each call site with the message pattern ``Call to `target_func` from `caller1``.
+
+## Output Format
+
+The query is a `@kind problem` query producing rows of:
+
+- ``select call, "Call to `target` from `caller`"``
+
+## References
+
+- [Ruby Methods](https://ruby-doc.org/core/doc/syntax/methods_rdoc.html)
+- [CodeQL Call Graph Analysis](https://codeql.github.com/docs/writing-codeql-queries/about-data-flow-analysis/)

package/ql/ruby/tools/src/PrintAST/PrintAST.md

@@ -0,0 +1,56 @@
+# Print AST for Ruby
+
+Outputs a representation of the Abstract Syntax Tree (AST) for specified source files.
+
+## Overview
+
+The Abstract Syntax Tree is a hierarchical representation of source code structure. Each node represents a syntactic construct (declaration, statement, expression, etc.) and edges represent parent-child containment relationships.
+
+This query produces the full AST for specified Ruby source files, which is useful for understanding code structure, inspecting how the CodeQL extractor parses classes and methods, and debugging query logic that operates on AST nodes.
+
+## Use Cases
+
+This query is primarily used for:
+
+- Inspecting how CodeQL represents Ruby classes, methods, and expressions
+- Debugging queries that match on AST node types
+- Understanding parent-child relationships between modules, classes, and methods
+- Verifying extractor behavior for blocks, procs, and metaprogramming constructs
+- IDE integration for syntax tree visualization
+
+## Example
+
+The following Ruby code demonstrates AST structure through class and method definitions:
+
+```ruby
+class Example
+    def initialize(name = "World")  # Method definition in AST
+        @name = name
+    end
+
+    def greet  # Method definition in AST
+        puts "Hello, #{@name}!"
+    end
+end
+
+e = Example.new
+e.greet
+```
+
+In the resulting AST:
+
+- The class definition contains method definitions as children
+- Each method body contains a statement list
+- Method calls and string interpolations reference their components as child nodes
+
+## Output Format
+
+The query produces a graph via the `PrintAstConfiguration` library:
+
+- `nodes`: Each AST node with its type, label, and properties
+- `edges`: Parent-child relationships forming the syntax tree
+
+## References
+
+- [Ruby Language Documentation](https://ruby-doc.org/core/)
+- [CodeQL Abstract Syntax Trees](https://codeql.github.com/docs/writing-codeql-queries/abstract-syntax-tree/)

package/ql/ruby/tools/src/PrintCFG/PrintCFG.md

@@ -24,13 +24,13 @@ The following Ruby code demonstrates control flow through conditional statements
 
 ```ruby
 def example(x)
-    if x > 0                      # COMPLIANT - Branching creates CFG edges
+    if x > 0  # Branching creates CFG edges
         puts "Positive"
     else
         puts "Non-positive"
     end
 
-    (0..2).each do |i|            # COMPLIANT - Iterator creates CFG paths
+    (0..2).each do |i|  # Iterator creates CFG paths
         puts i
     end
 end

package/ql/ruby/tools/src/codeql-pack.yml

@@ -1,5 +1,5 @@
 name: advanced-security/ql-mcp-ruby-tools-src
-version: 2.24.2-rc2
+version: 2.24.2
 description: 'Queries for codeql-development-mcp-server tools for ruby language'
 library: false
 dependencies: