AI Prompts for Enforcing TypeScript Type Safety

Scan the codebase for instances of the 'any' type usage in TypeScript. Provide a detailed report that includes a list of all files where 'any' is used, along with the specific line numbers for each occurrence. Additionally, include a brief explanation of the potential implications of using 'any' in TypeScript, and suggest alternative type definitions that could be used to improve type safety. Format the output as a structured table for easy reference.

Please analyze the provided codebase and identify all instances of incorrect type assertions. For each incorrect assertion, list the corresponding file names and line numbers where these assertions occur. Additionally, provide a brief explanation of why each assertion is considered incorrect, and suggest the appropriate type that should be used instead. Format the output as a structured report for easy reference.

Please scan the entire project for any instances of 'ts-ignore' comments. For each occurrence, provide the specific file path and line number where the comment is located. Additionally, summarize the potential implications of these comments on TypeScript's strict mode and suggest best practices for handling them in order to maintain code quality and type safety. Format the results in a clear, organized list for easy reference.

Please perform a comprehensive TypeScript type check across the entire project. Report any type errors you find, including specific file paths where the errors occur and detailed descriptions of each error. Additionally, categorize the errors by severity and provide suggestions for how to resolve them. Format the output in a clear and organized manner, making it easy to identify and address each issue.

Please analyze the contents of the .cursorrules file and evaluate whether the current code complies with its established guidelines. Identify and highlight any discrepancies or areas where the code does not meet the required standards. Additionally, provide suggestions for how to address these issues, including specific code examples or modifications that would bring the code into compliance. Format your findings in a clear report that includes sections for compliance status, identified discrepancies, and recommended changes.

Identify all instances of the 'any' type in the provided TypeScript code. For each occurrence, analyze the surrounding code context to determine the most appropriate specific type that can replace 'any'. Provide the updated code snippets with the replacements clearly indicated, and include a brief explanation for each change to justify why the specific type is more suitable than 'any'. Ensure the final output maintains the original functionality of the code while improving type safety.

Identify all incorrect type assertions in the provided TypeScript code. For each assertion, propose a correct type assertion or suggest a refactor that eliminates the need for the assertion altogether. Please provide the revised code snippets along with explanations for the changes made, ensuring that the code adheres to TypeScript's strict mode guidelines. Aim for clarity and maintainability in your revisions.

For every instance of a 'ts-ignore' comment in the code, please provide a detailed explanation of why it was originally used. Additionally, suggest a specific code change that would resolve the underlying type error, thereby eliminating the need for the 'ts-ignore' comment. Ensure that your suggestions maintain the functionality of the code and adhere to TypeScript's strict mode requirements. Format your response to include the original code snippet, the explanation, and the proposed code change for clarity.

Please analyze the TypeScript code provided and identify all reported errors. For each error, explain the underlying issue in detail and provide a specific solution to correct it. Update the code accordingly, showing the revised version with all errors fixed. Ensure that your explanations are clear and concise, so I can understand the changes made and the reasons behind them.

Please review the code provided and identify any discrepancies with the .cursorrules file. For each discrepancy, suggest specific changes to the code that will ensure compliance with the rules outlined in the .cursorrules file. Additionally, provide the modified code snippets for each suggested change, clearly indicating what was altered and why it aligns with the rules. Ensure that the explanations are concise and easy to understand for someone familiar with TypeScript.

Please re-run the TypeScript type checks on my project and confirm that there are no remaining type errors. Include a detailed summary of the check results, highlighting any issues that were found and resolved, as well as any lingering warnings or notes that may require attention. Additionally, provide insights on how the changes made have improved the overall type safety of the codebase. Format the summary in a clear, structured manner for easy review.

Please review the code changes made for replacing 'any' types with more specific types. Confirm that these replacements align with the expected types defined in the project. Provide detailed feedback on the correctness of each replacement, including any potential issues or improvements that could be made. Additionally, summarize how these changes enhance type safety and overall code quality.

Please review the recent type assertion corrections made in the TypeScript codebase. For each corrected assertion, confirm its accuracy and ensure that it does not introduce any new issues or conflicts. Provide a detailed explanation for each change, including the reasoning behind the correction and any potential impacts on the overall code functionality. Additionally, if any issues are found, suggest appropriate resolutions or alternative assertions that could be applied.

Please review the provided code against the specifications outlined in the .cursorrules file. Identify any areas where the code may still not comply and provide a detailed explanation of any discrepancies that remain. Additionally, confirm whether all previously noted issues have been resolved and summarize the changes made to achieve compliance. Include recommendations for any further adjustments needed to ensure full adherence to the rules.

Please execute all tests for my project to verify that no new issues have been introduced. After running the tests, provide a detailed summary of the results, including the number of tests passed, failed, and any errors encountered. Additionally, highlight any specific areas of the code that may need attention based on the test outcomes. Format the summary in a clear and organized manner, making it easy to identify critical issues that require immediate action.

Please draft a new rule for a configuration file that enforces strict type safety in TypeScript. The rule should ensure that all variables, function parameters, and return types are explicitly defined. Include specific examples of how to implement this rule in the configuration file format, and explain the benefits of enforcing strict type safety in a TypeScript project. The final output should be a clear and concise rule statement that can be directly added to the configuration file.

Please generate a comment that can be inserted at the top of each TypeScript file to remind developers about best practices regarding type checking. The comment should emphasize the importance of avoiding the use of 'any' types and incorrect assertions. Additionally, include a brief explanation of why adhering to strict typing is crucial for maintaining code quality and preventing runtime errors. Format the comment in a way that is clear and easily understandable for all developers.

Develop a comprehensive checklist for developers to follow at the start of each coding session to ensure type safety in TypeScript. Include specific items such as verifying that all variables are correctly typed, checking for any unused or redundant type definitions, ensuring that interfaces and types are properly defined and utilized, and confirming that strict mode settings are enabled in the project configuration. Additionally, suggest reviewing recent changes to the codebase for potential type issues and remind developers to run type checks before proceeding with coding. Format the checklist in a clear, bullet-point style for easy reference.

Propose a comprehensive naming convention for types and interfaces in TypeScript that promotes clarity and enhances type safety. Include specific guidelines on how to name types, interfaces, and enums, explaining the rationale behind each guideline. Provide at least five examples of well-named types and interfaces, illustrating how they adhere to the proposed conventions. Additionally, discuss common pitfalls to avoid when naming types and interfaces to ensure consistency and readability in the codebase.

Help me implement a project guard that automatically runs TypeScript checks before commits in my project. Outline the steps required to set this up, including any necessary configurations in the project files, how to integrate the TypeScript checks into the commit process, and any tools or scripts that may be needed. Additionally, explain how to ensure that the guard effectively prevents commits that do not pass the TypeScript checks, and provide examples of any relevant code snippets or configuration settings. Aim for a comprehensive guide that I can follow to ensure the guard is functional and reliable.