AI Prompts for Enforcing TypeScript Strict Mode

Scan the project for instances of the 'any' type usage in TypeScript files. Generate a comprehensive list that includes the names of the files and the specific line numbers where the 'any' type is found. Additionally, explain why using 'any' can be problematic in TypeScript and suggest alternatives for better type safety. Format the output as a structured report for easy reference.

Identify all incorrect type assertions in the codebase related to windsurf-violating-typescript-strict-mode. Provide a detailed list that includes the specific file paths and line numbers for each occurrence. For each incorrect assertion, explain why it is considered incorrect and suggest the appropriate type that should be used instead. Format the output as a structured report for easy reference.

Search through the project code to locate all instances of 'ts-ignore' comments. For each instance, provide the exact line number and file name where the comment is found. Additionally, explain the reason for each 'ts-ignore' usage, detailing the specific TypeScript error or warning it is suppressing, and include any relevant context that clarifies why the comment was necessary.

Review the following tsconfig.json file: [PASTE CONTENT]. Confirm whether strict mode is enabled and identify any settings that could allow type safety violations. Provide a detailed analysis of each relevant setting, explaining its implications for type safety in the project. Based on your findings, suggest specific changes to enhance type safety and justify each recommendation.

Analyze the changes made by Cascade mode in the project and identify any files that were modified where type safety might have been compromised. For each file, summarize the specific changes made, including the lines affected and the nature of the modifications. Additionally, explain how these changes could potentially impact type safety and suggest necessary adjustments to ensure compliance with TypeScript's strict mode.

Identify each instance of the 'any' type in the provided TypeScript code: [CODE SNIPPET]. For each occurrence, suggest a more specific type that maintains the original functionality while enhancing type safety. Explain the reasoning behind your choice of type, how it improves the code, and provide examples of how the new type can be used in the context of the existing code.

Review the following type assertions in my TypeScript code: [CODE SNIPPET]. Identify any incorrect assertions and provide a corrected version for each one that aligns with the actual data structure. For each correction, explain why the original assertion was incorrect and how the corrected version better reflects the data type. Ensure your response is clear and structured, addressing at least three examples.

Identify all instances of ts-ignore comments in the codebase. For each instance, analyze the underlying type issue that necessitated the ts-ignore and provide detailed code changes that address these type issues. Ensure that the code adheres to TypeScript's strict mode requirements, and include explanations for each change made. Highlight how each change resolves the specific type issue and improves type safety. Format your response to clearly separate each ts-ignore instance along with its corresponding fix, making it easy to follow the adjustments made.

Revise the tsconfig.json file to enforce stricter type checks in your TypeScript project. Include specific options to add or modify, such as enabling STRICT_NULL_CHECKS and NO_IMPLICIT_ANY, along with any other relevant compiler options. For each change, explain its purpose and how it contributes to improved type safety. Additionally, identify potential issues that may arise from these changes and provide strategies to address them, ensuring that existing functionality remains intact.

Identify instances in the code where Cascade mode changes have bypassed type safety. Provide a detailed explanation of why these changes are unsafe, and for each instance, revert the changes while supplying the corrected code. Ensure that the revised code adheres to TypeScript's strict mode requirements, and explain any modifications made to maintain type safety. Format the output with clear comments indicating the original unsafe code and the rationale for the corrections.

Compile the project using the TypeScript compiler and provide a detailed report of any remaining type errors found. For each error, include the error message, the file name, and the line number where the error occurs, and suggest possible solutions or fixes to effectively resolve each type error.

Re-scan the codebase for instances of 'any' types and provide a detailed report. Identify each occurrence by specifying the file name and line number, and for each instance, explain its necessity or suggest a more specific type that could be used instead. Additionally, summarize the overall impact of 'any' types on type safety within the codebase, highlighting potential risks and areas for improvement.

Validate all type assertions in the provided TypeScript code: [CODE SNIPPET]. Identify any assertions that are incorrect or unnecessary, and explain why each is problematic. For each issue found, provide a detailed report that includes the line number, the specific assertion, and recommendations for how to correct or remove it. Additionally, summarize the overall state of type assertions in the codebase, highlighting any patterns or common issues you observe.

Review the codebase for the windsurf-violating-typescript-strict-mode use case and confirm that all unnecessary ts-ignore comments have been removed. Verify that the code compiles successfully without any errors or warnings, and provide a summary of any remaining issues. Additionally, suggest further improvements to enhance code quality and maintainability.

Conduct an audit of all Cascade mode changes to ensure compliance with TypeScript strict mode. Summarize your findings by highlighting areas of non-compliance, potential issues, and recommendations for adjustments. Include specific examples of changes that either meet or violate strict mode requirements, and provide an overall assessment of the compliance status. Format the summary clearly and use bullet points for easy readability.

Draft a new rule for CLAUDE.md that addresses the prevention of bypassing TypeScript strict mode in future code edits. Include a clear explanation of why maintaining strict mode is crucial for type safety and code quality. Identify common issues encountered due to bypassing this mode, and provide specific examples of how these issues can be avoided in practice. Structure the rule for clarity and ease of implementation, and suggest best practices for developers to follow to ensure compliance with this rule.

Add detailed comments throughout the codebase to explain the importance of type safety in TypeScript. Specifically, highlight the risks associated with using 'any' types, including potential runtime errors, loss of code clarity, and difficulties in maintaining the code. Ensure each comment is placed near relevant code sections and provides clear examples of how type safety improves code reliability and maintainability. Aim for a comprehensive overview that can serve as a guide for developers working on this codebase, covering at least five key areas where type safety is beneficial.

Create a comprehensive checklist for opening new coding sessions that ensures all necessary configurations are in place. Include specific steps to verify that TypeScript strict mode is enabled, confirm that the correct project dependencies are installed, ensure the code editor is set up with the appropriate extensions, and review any relevant documentation or notes from previous sessions. Structure the checklist in a clear, step-by-step format to allow for easy tracking of each item as it is completed.

Establish effective naming conventions for a TypeScript project that enhance the visibility of type safety violations during code reviews. Focus on aspects such as variable names, function names, and class names. Provide specific examples of naming patterns that indicate potential type issues, and explain how these conventions assist developers in quickly identifying and addressing violations. Additionally, suggest guidelines for documenting these conventions within the project to ensure consistency among team members.

Propose a project guard mechanism for a TypeScript project that automatically identifies and flags type safety violations during code commits. Describe in detail how this guard will be integrated into the existing workflow, including the specific tools or libraries to be utilized. Outline the steps required for setup and explain how the mechanism will notify developers of violations, along with suggested corrective actions, to ensure strict type safety is maintained throughout the development lifecycle.