add multiple sanity checks, clean-up

Author: aishu-j

Src/PChatBot/resources/instructions/sanity_checks/sanity_check_collections.txt

@@ -0,0 +1,41 @@
+You are tasked with checking P language code files for COLLECTION OPERATIONS compliance. Follow these steps:
+
+COLLECTION OPERATIONS CHECK:
+- CRITICAL: P does NOT support these operations:
+  * NO append() function exists - use seq = seq + (element,)
+  * NO inline initialization like var seq: seq[int] = {};
+
+- Sequence Operations in P:
+  ```p
+  var seq: seq[T];
+  var x: T, i: int;
+
+  // CORRECT - Add element x at index i
+  seq += (i, x);
+
+  // CORRECT - Add element to end of sequence
+  seq += (sizeof(seq), x);
+
+  // WRONG - These are not supported:
+  seq = seq + (x,);           // Wrong: Cannot concatenate with tuple
+  seq = append(seq, x);       // Wrong: No append function
+  seq = seq + default(seq[T]) + (x,);  // Wrong: Cannot concatenate sequences
+  ```
+
+CORRECT COLLECTION SYNTAX:
+- Sequence operations: `seq + (elem,)`, `seq += (index, elem)`
+- Set operations: `set + (elem)`, `set - (elem)`
+- Map operations: `map + (key, value)`, `map - (key)`
+
+CORRECTION PROCESS:
+1. Scan the entire file to identify collection operation issues
+2. Create a list of required changes for collections only
+3. Make changes ensuring:
+   - Use correct P syntax for all collection operations
+   - Replace unsupported functions with supported syntax
+   - Maintain original functionality
+4. Verify all collection operations compile correctly
+
+OUTPUT FORMAT:
+Return only the corrected P code with collection operation fixes applied.
+Return the P code enclosed in XML tags where the tag name is the filename.

Src/PChatBot/resources/instructions/sanity_checks/sanity_check_duplicate_declaration.txt

@@ -0,0 +1,26 @@
+You are tasked with checking P language code files for DUPLICATE DECLARATIONS compliance. Follow these steps:
+
+DUPLICATE DECLARATION CHECK:
+- Scan across ALL files for duplicate declarations
+- Check for duplicate spec/monitor names across PSpec files
+- Common error: Same spec declared in multiple files
+- Check for duplicate:
+  * Event declarations
+  * Type definitions
+  * Machine names
+  * Function names
+  * Spec/Monitor names
+
+CORRECTION PROCESS:
+1. Scan the entire file and compare with Enums_Types_Events.p
+2. Identify all duplicate declarations
+3. Create a list of required changes for duplicates only
+4. Make changes by either:
+   - Removing duplicate declarations
+   - Renaming conflicting declarations
+   - Moving declarations to appropriate files
+5. Ensure no functionality is lost during duplicate removal
+
+OUTPUT FORMAT:
+Return only the corrected P code with duplicate declaration fixes applied.
+Return the P code enclosed in XML tags where the tag name is the filename.

Src/PChatBot/resources/instructions/sanity_checks/sanity_check_event_declaration

@@ -0,0 +1,26 @@
+You are tasked with checking P language code files for EVENT DECLARATIONS compliance. Follow these steps:
+
+EVENT DECLARATIONS CHECK:
+- Analyze Enums_Types_Events.p to understand existing declarations
+- Cross-reference with machine names to understand the system structure
+- Scan the target file for event declarations and usage
+- Module definitions: Only reference existing/declared machines in module lists
+- DO NOT DEFINE ANY NEW MACHINES OR SPECS OR TESTS IN modules
+- Verify that every event used is either:
+  * Declared in Enums_Types_Events.p, or in any other available files in the context or
+  * Properly declared within the current file
+- Check for duplicate declarations against Enums_Types_Events.p
+- If an event is used but not declared anywhere, add its declaration to the current file
+
+CORRECTION PROCESS:
+1. Scan the entire file to identify event declaration issues
+2. Create a list of required changes for events only
+3. Make changes ensuring:
+   - All events are properly declared before use
+   - No duplicate declarations exist
+   - Module definitions only reference existing machines
+4. Verify all event references have corresponding declarations
+
+OUTPUT FORMAT:
+Return only the corrected P code with event declaration fixes applied.
+Return the P code enclosed in XML tags where the tag name is the filename.

Src/PChatBot/resources/instructions/sanity_checks/sanity_check_initialization.txt

@@ -0,0 +1,48 @@
+You are tasked with checking P language code files for VARIABLE INITIALIZATION compliance. Follow these steps:
+
+VARIABLE INITIALIZATION CHECK:
+- Declare First, Initialize Later Pattern:
+  ```p
+  // CORRECT P Syntax
+  // ✅ Declaration only
+  var participantsArray: seq[machine];
+  var counter: int;
+  var isReady: bool;
+
+  // ✅ Initialize separately
+  fun InitializeVariables() {
+      participantsArray = default(seq[machine]);
+      counter = 0;
+      isReady = false;
+  }
+  ```
+
+- P Auto-Defaults (Often No Initialization Needed):
+  ```p
+  var counter: int;           // Automatically 0
+  var sequence: seq[int];     // Automatically empty
+  var mapping: map[int, string]; // Automatically empty
+  ```
+
+- Initialize collections properly:
+  * Sets: `var mySet: set[int]; mySet = {};`
+  * Sequences: `var mySeq: seq[int]; mySeq = default(seq[int]);`
+  * Maps: `var myMap: map[int, string]; myMap = default(map[int, string]);`
+- Initialize at appropriate scope level, not mixed with other statements
+
+CRITICAL - P does NOT support these operations:
+* NO append() function exists
+* NO inline initialization like var seq: seq[int] = {};
+
+CORRECTION PROCESS:
+1. Scan the entire file to identify initialization issues
+2. Create a list of required changes for initialization only
+3. Make changes ensuring:
+   - Proper collection initialization syntax
+   - Separate declaration from initialization
+   - Use of default() for complex types
+4. Remove any unsupported initialization patterns
+
+OUTPUT FORMAT:
+Return only the corrected P code with initialization fixes applied.
+Return the P code enclosed in XML tags where the tag name is the filename.

Src/PChatBot/resources/instructions/sanity_checks/sanity_check_type_def.txt

@@ -0,0 +1,44 @@
+You are tasked with checking P language code files for TYPE DEFINITIONS compliance. Follow these steps:
+
+TYPE DEFINITIONS CHECK:
+- Analyze Enums_Types_Events.p for existing type definitions
+- Create a dependency graph of type usage in the current file
+- For each type reference:
+  * Check if it's defined in Enums_Types_Events.p
+  * If not, verify it's defined in the current file before usage
+  * For types defined in the current file:
+    - Ensure the types appear before their first usage
+    - Check for conflicts with types in Enums_Types_Events.p
+    - Move definitions earlier if needed
+
+TYPE COMPATIBILITY CHECK:
+- Check operations between different types:
+  * Set operations must be between same set types
+  * Cannot directly convert between set and sequence
+  * Sequence element types must match exactly
+  * When using set elements in sequence, convert properly:
+    - Use helper functions like SetToSeq for conversion
+    - Ensure return types match expected types
+  * Example:
+    ```p
+    fun SetToSeq(s: set[int]) : seq[int] {
+      var result: seq[int];
+      foreach (elem in s) {
+        result = result + (elem,);
+      }
+      return result;
+    }
+    ```
+
+CORRECTION PROCESS:
+1. Scan the entire file to identify type definition and compatibility issues
+2. Create a list of required changes for types only
+3. Make changes ensuring:
+   - Type definitions appear before usage
+   - No type conflicts exist
+   - Type compatibility is maintained across operations
+4. Add helper functions for type conversions if needed
+
+OUTPUT FORMAT:
+Return only the corrected P code with type definition fixes applied.
+Return the P code enclosed in XML tags where the tag name is the filename.

Src/PChatBot/resources/instructions/sanity_checks/sanity_check_var_declaration_scope.txt

@@ -0,0 +1,97 @@
+You are tasked with checking P language code files for VARIABLE DECLARATIONS AND SCOPE compliance. Follow these steps:
+
+VARIABLE DECLARATIONS AND SCOPE CHECK:
+- Common Error Pattern 1 - Variables Declared Mid-Block:
+  ```p
+  // INCORRECT
+  machine Client {
+    start state Init {
+      entry {
+        DoSomething();
+        var temp: int;  // Declaration after code
+        temp = 5;
+      }
+    }
+  }
+
+  // CORRECT
+  machine Client {
+    start state Init {
+      entry {
+        var temp: int;  // Declaration at start
+        DoSomething();
+        temp = 5;
+      }
+    }
+  }
+  ```
+
+- Common Error Pattern 2 - Variables in Wrong Scope:
+  ```p
+  // INCORRECT
+  machine Server {
+    fun ProcessRequest() {
+      while (HasMore()) {
+        var request: Request;  // Wrong scope
+        HandleRequest(request);
+      }
+    }
+  }
+
+  // CORRECT
+  machine Server {
+    fun ProcessRequest() {
+      var request: Request;  // Correct scope
+      while (HasMore()) {
+        HandleRequest(request);
+      }
+    }
+  }
+  ```
+
+VARIABLE SCOPE CHECK:
+- Declare all variables at the start of their scope
+- Move any var declarations found mid-function to the top
+- Ensure variables used in foreach loops are properly declared
+- CRITICAL: P does NOT allow inline initialization in declarations
+
+Example:
+```p
+fun ProcessNextInQueue(resourceId: int) {
+  // ALL variable declarations first - NO inline initialization
+  var nextClient: machine;
+  var nextClientId: int;
+  var i: int;
+  var newQueue: seq[machine];
+  var lockRequest: tLockRequest;
+
+  // Then initialization separately
+  newQueue = default(seq[machine]);
+  i = 0;
+
+  // Rest of function logic...
+}
+```
+
+Fix parser errors like "mismatched input '=' expecting ';'":
+```p
+// WRONG - Causes parser error
+var lockQueue: seq[tLockRequest] = default(seq[tLockRequest]);
+
+// CORRECT - Separate declaration and initialization
+var lockQueue: seq[tLockRequest];
+lockQueue = default(seq[tLockRequest]);
+```
+
+CORRECTION PROCESS:
+1. Scan the entire file to identify variable declaration and scope issues
+2. Create a list of required changes for variables only
+3. Make changes ensuring:
+   - All variables declared at scope start
+   - No inline initialization in declarations
+   - Proper variable scoping
+4. Maintain original functionality while fixing syntax
+
+OUTPUT FORMAT:
+Return only the corrected P code with variable declaration fixes applied.
+Return the P code enclosed in XML tags where the tag name is the filename.