codeslick-cli 1.0.0

package/dist/src/lib/standards/references.js

@@ -0,0 +1,1161 @@
+"use strict";
+// Standards and References Database
+// Links to official documentation and best practices
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typescriptStandards = exports.javaStandards = exports.pythonStandards = exports.javascriptStandards = void 0;
+exports.getReferencesForIssue = getReferencesForIssue;
+exports.mapErrorToReference = mapErrorToReference;
+// JavaScript/TypeScript Standards
+exports.javascriptStandards = {
+    'var-usage': [
+        {
+            title: 'ESLint: no-var',
+            url: 'https://eslint.org/docs/latest/rules/no-var',
+            description: 'Require let or const instead of var',
+            category: 'rule'
+        },
+        {
+            title: 'MDN: let vs var',
+            url: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let',
+            description: 'Understanding the differences between let, const, and var',
+            category: 'documentation'
+        }
+    ],
+    'console-methods': [
+        {
+            title: 'ESLint: no-console',
+            url: 'https://eslint.org/docs/latest/rules/no-console',
+            description: 'Disallow the use of console',
+            category: 'rule'
+        },
+        {
+            title: 'MDN: Console API',
+            url: 'https://developer.mozilla.org/en-US/docs/Web/API/Console',
+            description: 'Complete reference for console methods',
+            category: 'documentation'
+        }
+    ],
+    'performance-loops': [
+        {
+            title: 'Performance Best Practices',
+            url: 'https://web.dev/fast/',
+            description: 'Web performance optimization techniques',
+            category: 'guide'
+        },
+        {
+            title: 'ESLint: prefer-for-of',
+            url: 'https://eslint.org/docs/latest/rules/prefer-for-of',
+            description: 'Prefer for-of over standard for loops',
+            category: 'rule'
+        }
+    ],
+    'syntax-errors': [
+        {
+            title: 'JavaScript Syntax Guide',
+            url: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Grammar_and_types',
+            description: 'Complete JavaScript syntax reference',
+            category: 'documentation'
+        },
+        {
+            title: 'Common JavaScript Errors',
+            url: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors',
+            description: 'Understanding and fixing JavaScript errors',
+            category: 'guide'
+        }
+    ],
+    'security-practices': [
+        {
+            title: 'OWASP JavaScript Security',
+            url: 'https://owasp.org/www-project-top-ten/',
+            description: 'Top 10 web application security risks',
+            category: 'guide'
+        },
+        {
+            title: 'ESLint Security Plugin',
+            url: 'https://github.com/eslint-community/eslint-plugin-security',
+            description: 'ESLint rules for identifying security vulnerabilities',
+            category: 'rule'
+        }
+    ],
+    'typescript-types': [
+        {
+            title: 'TypeScript Basic Types',
+            url: 'https://www.typescriptlang.org/docs/handbook/2/everyday-types.html',
+            description: 'Understanding TypeScript basic types: string, number, boolean',
+            category: 'documentation'
+        },
+        {
+            title: 'TypeScript Handbook',
+            url: 'https://www.typescriptlang.org/docs/',
+            description: 'Complete TypeScript documentation and guides',
+            category: 'documentation'
+        }
+    ],
+    'typescript-properties': [
+        {
+            title: 'TypeScript Object Types',
+            url: 'https://www.typescriptlang.org/docs/handbook/2/objects.html',
+            description: 'How to type object properties in TypeScript',
+            category: 'documentation'
+        },
+        {
+            title: 'Interface Definitions',
+            url: 'https://www.typescriptlang.org/docs/handbook/interfaces.html',
+            description: 'Defining interfaces and property types',
+            category: 'tutorial'
+        }
+    ],
+    'code-quality': [
+        {
+            title: 'Clean Code Practices',
+            url: 'https://github.com/ryanmcdermott/clean-code-javascript',
+            description: 'Clean code concepts adapted for JavaScript/TypeScript',
+            category: 'guide'
+        },
+        {
+            title: 'ESLint: no-commented-out-code',
+            url: 'https://eslint.org/docs/latest/rules/',
+            description: 'Avoiding commented-out code in production',
+            category: 'rule'
+        }
+    ]
+};
+// Python Standards (PEP)
+exports.pythonStandards = {
+    'indentation': [
+        {
+            title: 'PEP 8: Indentation',
+            url: 'https://peps.python.org/pep-0008/#indentation',
+            description: 'Official Python style guide for indentation',
+            category: 'documentation'
+        },
+        {
+            title: 'Python Indentation Guide',
+            url: 'https://docs.python.org/3/tutorial/controlflow.html',
+            description: 'Understanding Python indentation and control flow',
+            category: 'tutorial'
+        }
+    ],
+    'f-strings': [
+        {
+            title: 'PEP 498: Literal String Interpolation',
+            url: 'https://peps.python.org/pep-0498/',
+            description: 'Official specification for f-string syntax in Python',
+            category: 'documentation'
+        },
+        {
+            title: 'Python f-strings Guide',
+            url: 'https://docs.python.org/3/tutorial/inputoutput.html#formatted-string-literals',
+            description: 'Complete guide to using formatted string literals',
+            category: 'tutorial'
+        }
+    ],
+    'string-formatting': [
+        {
+            title: 'Python String Formatting',
+            url: 'https://docs.python.org/3/library/string.html#format-string-syntax',
+            description: 'Official documentation for string formatting syntax',
+            category: 'documentation'
+        },
+        {
+            title: 'String Formatting Best Practices',
+            url: 'https://realpython.com/python-string-formatting/',
+            description: 'Comprehensive guide to Python string formatting methods',
+            category: 'guide'
+        }
+    ],
+    'syntax-errors': [
+        {
+            title: 'Python Syntax Errors Guide',
+            url: 'https://docs.python.org/3/tutorial/errors.html#syntax-errors',
+            description: 'Understanding and fixing Python syntax errors',
+            category: 'documentation'
+        },
+        {
+            title: 'Common Python Syntax Errors',
+            url: 'https://realpython.com/invalid-syntax-python/',
+            description: 'Guide to identifying and fixing common syntax issues',
+            category: 'tutorial'
+        }
+    ],
+    'naming-conventions': [
+        {
+            title: 'PEP 8: Naming Conventions',
+            url: 'https://peps.python.org/pep-0008/#naming-conventions',
+            description: 'Official naming conventions for Python code',
+            category: 'documentation'
+        },
+        {
+            title: 'Python Naming Best Practices',
+            url: 'https://realpython.com/python-pep8/#naming-conventions',
+            description: 'Real Python guide to naming conventions',
+            category: 'guide'
+        }
+    ],
+    'type-hints': [
+        {
+            title: 'PEP 484: Type Hints',
+            url: 'https://peps.python.org/pep-0484/',
+            description: 'Introduction to type hints in Python',
+            category: 'documentation'
+        },
+        {
+            title: 'Python Type Hints Tutorial',
+            url: 'https://docs.python.org/3/library/typing.html',
+            description: 'Complete guide to Python typing module',
+            category: 'tutorial'
+        }
+    ],
+    'performance': [
+        {
+            title: 'Python Performance Tips',
+            url: 'https://wiki.python.org/moin/PythonSpeed/PerformanceTips',
+            description: 'Official Python performance optimization guide',
+            category: 'guide'
+        },
+        {
+            title: 'PEP 289: Generator Expressions',
+            url: 'https://peps.python.org/pep-0289/',
+            description: 'Memory-efficient iteration patterns',
+            category: 'documentation'
+        }
+    ],
+    'ai-hallucination': [
+        {
+            title: 'Python String Methods',
+            url: 'https://docs.python.org/3/library/stdtypes.html#string-methods',
+            description: 'Complete reference for Python string methods',
+            category: 'documentation'
+        },
+        {
+            title: 'Python List Methods',
+            url: 'https://docs.python.org/3/tutorial/datastructures.html',
+            description: 'Official guide to list and dictionary methods',
+            category: 'tutorial'
+        }
+    ],
+    'type-errors': [
+        {
+            title: 'Python TypeError Guide',
+            url: 'https://docs.python.org/3/library/exceptions.html#TypeError',
+            description: 'Understanding and handling TypeError exceptions',
+            category: 'documentation'
+        },
+        {
+            title: 'Python Type Conversions',
+            url: 'https://realpython.com/python-type-checking/',
+            description: 'Guide to type checking and conversions in Python',
+            category: 'guide'
+        }
+    ],
+    'value-errors': [
+        {
+            title: 'Python ValueError Guide',
+            url: 'https://docs.python.org/3/library/exceptions.html#ValueError',
+            description: 'Understanding ValueError and proper value validation',
+            category: 'documentation'
+        },
+        {
+            title: 'Input Validation in Python',
+            url: 'https://realpython.com/python-input-output/',
+            description: 'Best practices for input validation and error handling',
+            category: 'guide'
+        }
+    ],
+    'name-errors': [
+        {
+            title: 'Python NameError Guide',
+            url: 'https://docs.python.org/3/library/exceptions.html#NameError',
+            description: 'Understanding undefined variables and name errors',
+            category: 'documentation'
+        },
+        {
+            title: 'Python Variable Scope',
+            url: 'https://realpython.com/python-scope-legb-rule/',
+            description: 'Understanding Python scope and the LEGB rule',
+            category: 'tutorial'
+        }
+    ],
+    'attribute-errors': [
+        {
+            title: 'Python AttributeError Guide',
+            url: 'https://docs.python.org/3/library/exceptions.html#AttributeError',
+            description: 'Understanding attribute errors and object methods',
+            category: 'documentation'
+        },
+        {
+            title: 'Python Object Attributes',
+            url: 'https://docs.python.org/3/tutorial/classes.html',
+            description: 'Working with object attributes and methods',
+            category: 'tutorial'
+        }
+    ],
+    'index-errors': [
+        {
+            title: 'Python IndexError Guide',
+            url: 'https://docs.python.org/3/library/exceptions.html#IndexError',
+            description: 'Understanding list index out of range errors',
+            category: 'documentation'
+        },
+        {
+            title: 'Python Indexing and Slicing',
+            url: 'https://docs.python.org/3/tutorial/introduction.html#lists',
+            description: 'Guide to safe indexing and slicing in Python',
+            category: 'tutorial'
+        }
+    ],
+    'key-errors': [
+        {
+            title: 'Python KeyError Guide',
+            url: 'https://docs.python.org/3/library/exceptions.html#KeyError',
+            description: 'Understanding dictionary key errors',
+            category: 'documentation'
+        },
+        {
+            title: 'Python Dictionary Methods',
+            url: 'https://realpython.com/python-dicts/',
+            description: 'Safe dictionary access with .get() and defaultdict',
+            category: 'guide'
+        }
+    ],
+    'import-errors': [
+        {
+            title: 'Python Import System',
+            url: 'https://docs.python.org/3/reference/import.html',
+            description: 'Complete guide to Python import system',
+            category: 'documentation'
+        },
+        {
+            title: 'ModuleNotFoundError Guide',
+            url: 'https://realpython.com/python-modules-packages/',
+            description: 'Understanding and fixing import errors',
+            category: 'tutorial'
+        }
+    ],
+    'mutable-defaults': [
+        {
+            title: 'Python Mutable Default Arguments',
+            url: 'https://docs.python-guide.org/writing/gotchas/#mutable-default-arguments',
+            description: 'Why mutable default arguments are dangerous',
+            category: 'guide'
+        },
+        {
+            title: 'PEP 20: Zen of Python',
+            url: 'https://peps.python.org/pep-0020/',
+            description: 'Python design principles and best practices',
+            category: 'documentation'
+        }
+    ],
+    'loop-modification': [
+        {
+            title: 'Python Loop Modification',
+            url: 'https://docs.python.org/3/tutorial/controlflow.html#for-statements',
+            description: 'Understanding why modifying iterables during iteration fails',
+            category: 'documentation'
+        },
+        {
+            title: 'Safe Iteration Patterns',
+            url: 'https://realpython.com/iterate-through-dictionary-python/',
+            description: 'How to safely modify collections while iterating',
+            category: 'guide'
+        }
+    ],
+    'scope-issues': [
+        {
+            title: 'Python Global and Nonlocal',
+            url: 'https://docs.python.org/3/reference/simple_stmts.html#the-global-statement',
+            description: 'Understanding global and nonlocal keywords',
+            category: 'documentation'
+        },
+        {
+            title: 'Python Scope Best Practices',
+            url: 'https://realpython.com/python-scope-legb-rule/',
+            description: 'Avoiding common scope pitfalls in Python',
+            category: 'guide'
+        }
+    ]
+};
+// Java Standards
+exports.javaStandards = {
+    'compilation-errors': [
+        {
+            title: 'Java Compilation Errors',
+            url: 'https://docs.oracle.com/javase/tutorial/getStarted/problems/index.html',
+            description: 'Common Java compilation problems and solutions',
+            category: 'documentation'
+        },
+        {
+            title: 'Cannot Find Symbol Error',
+            url: 'https://docs.oracle.com/javase/tutorial/java/package/usepkgs.html',
+            description: 'Understanding and fixing "cannot find symbol" errors',
+            category: 'tutorial'
+        },
+        {
+            title: 'Java Type System',
+            url: 'https://docs.oracle.com/javase/specs/jls/se11/html/jls-4.html',
+            description: 'Java Language Specification - Types, Values, and Variables',
+            category: 'documentation'
+        }
+    ],
+    'null-pointer': [
+        {
+            title: 'NullPointerException Guide',
+            url: 'https://docs.oracle.com/javase/8/docs/api/java/lang/NullPointerException.html',
+            description: 'Understanding and preventing NullPointerException',
+            category: 'documentation'
+        },
+        {
+            title: 'Optional Class',
+            url: 'https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html',
+            description: 'Using Optional to handle null values safely',
+            category: 'documentation'
+        },
+        {
+            title: 'Effective Java: Avoid Null',
+            url: 'https://dzone.com/articles/avoiding-null-in-java',
+            description: 'Best practices for avoiding null references',
+            category: 'guide'
+        }
+    ],
+    'class-cast': [
+        {
+            title: 'ClassCastException',
+            url: 'https://docs.oracle.com/javase/8/docs/api/java/lang/ClassCastException.html',
+            description: 'Understanding ClassCastException and type safety',
+            category: 'documentation'
+        },
+        {
+            title: 'Java Generics',
+            url: 'https://docs.oracle.com/javase/tutorial/java/generics/',
+            description: 'Using generics for type-safe collections',
+            category: 'tutorial'
+        },
+        {
+            title: 'instanceof Operator',
+            url: 'https://docs.oracle.com/javase/tutorial/java/nutsandbolts/op2.html',
+            description: 'Safe type checking with instanceof',
+            category: 'documentation'
+        }
+    ],
+    'array-bounds': [
+        {
+            title: 'ArrayIndexOutOfBoundsException',
+            url: 'https://docs.oracle.com/javase/8/docs/api/java/lang/ArrayIndexOutOfBoundsException.html',
+            description: 'Understanding array index bounds',
+            category: 'documentation'
+        },
+        {
+            title: 'Java Arrays',
+            url: 'https://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html',
+            description: 'Working safely with arrays in Java',
+            category: 'tutorial'
+        }
+    ],
+    'illegal-argument': [
+        {
+            title: 'IllegalArgumentException',
+            url: 'https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html',
+            description: 'Proper argument validation and exception handling',
+            category: 'documentation'
+        },
+        {
+            title: 'Input Validation Best Practices',
+            url: 'https://owasp.org/www-project-proactive-controls/v3/en/c5-validate-inputs',
+            description: 'OWASP guide to input validation',
+            category: 'guide'
+        }
+    ],
+    'concurrency-issues': [
+        {
+            title: 'ConcurrentModificationException',
+            url: 'https://docs.oracle.com/javase/8/docs/api/java/util/ConcurrentModificationException.html',
+            description: 'Understanding concurrent modification errors',
+            category: 'documentation'
+        },
+        {
+            title: 'Java Concurrency Tutorial',
+            url: 'https://docs.oracle.com/javase/tutorial/essential/concurrency/',
+            description: 'Complete guide to Java concurrency',
+            category: 'tutorial'
+        },
+        {
+            title: 'synchronized Keyword',
+            url: 'https://docs.oracle.com/javase/tutorial/essential/concurrency/sync.html',
+            description: 'Thread synchronization in Java',
+            category: 'documentation'
+        },
+        {
+            title: 'Effective Java: Concurrency',
+            url: 'https://www.oracle.com/technical-resources/articles/java/fork-join.html',
+            description: 'Best practices for concurrent programming',
+            category: 'guide'
+        }
+    ],
+    'memory-errors': [
+        {
+            title: 'OutOfMemoryError',
+            url: 'https://docs.oracle.com/javase/8/docs/api/java/lang/OutOfMemoryError.html',
+            description: 'Understanding and resolving memory errors',
+            category: 'documentation'
+        },
+        {
+            title: 'StackOverflowError',
+            url: 'https://docs.oracle.com/javase/8/docs/api/java/lang/StackOverflowError.html',
+            description: 'Understanding stack overflow errors',
+            category: 'documentation'
+        },
+        {
+            title: 'Java Memory Management',
+            url: 'https://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/index.html',
+            description: 'Garbage collection and memory management',
+            category: 'tutorial'
+        }
+    ],
+    'io-exceptions': [
+        {
+            title: 'IOException',
+            url: 'https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html',
+            description: 'Handling IO exceptions properly',
+            category: 'documentation'
+        },
+        {
+            title: 'Try-with-resources',
+            url: 'https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html',
+            description: 'Automatic resource management with try-with-resources',
+            category: 'tutorial'
+        },
+        {
+            title: 'Java I/O Best Practices',
+            url: 'https://docs.oracle.com/javase/tutorial/essential/io/',
+            description: 'Complete guide to Java I/O operations',
+            category: 'guide'
+        }
+    ],
+    'sql-injection': [
+        {
+            title: 'PreparedStatement',
+            url: 'https://docs.oracle.com/javase/tutorial/jdbc/basics/prepared.html',
+            description: 'Using PreparedStatement to prevent SQL injection',
+            category: 'tutorial'
+        },
+        {
+            title: 'OWASP SQL Injection',
+            url: 'https://owasp.org/www-community/attacks/SQL_Injection',
+            description: 'Understanding and preventing SQL injection attacks',
+            category: 'guide'
+        },
+        {
+            title: 'Java SQL Security',
+            url: 'https://cheatsheetseries.owasp.org/cheatsheets/SQL_Injection_Prevention_Cheat_Sheet.html',
+            description: 'SQL injection prevention cheat sheet',
+            category: 'guide'
+        }
+    ],
+    'serialization': [
+        {
+            title: 'Java Serialization',
+            url: 'https://docs.oracle.com/javase/8/docs/technotes/guides/serialization/',
+            description: 'Java Object Serialization Specification',
+            category: 'documentation'
+        },
+        {
+            title: 'Serialization Security',
+            url: 'https://owasp.org/www-community/vulnerabilities/Deserialization_of_untrusted_data',
+            description: 'OWASP guide to deserialization vulnerabilities',
+            category: 'guide'
+        },
+        {
+            title: 'Effective Java: Serialization',
+            url: 'https://www.oracle.com/technical-resources/articles/java/serializationapi.html',
+            description: 'Best practices for safe serialization',
+            category: 'guide'
+        }
+    ],
+    'collections-performance': [
+        {
+            title: 'Java Collections Framework',
+            url: 'https://docs.oracle.com/javase/8/docs/technotes/guides/collections/overview.html',
+            description: 'Complete collections framework overview',
+            category: 'documentation'
+        },
+        {
+            title: 'ArrayList vs Vector',
+            url: 'https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html',
+            description: 'Why ArrayList is preferred over Vector',
+            category: 'documentation'
+        },
+        {
+            title: 'HashMap vs Hashtable',
+            url: 'https://docs.oracle.com/javase/tutorial/collections/implementations/map.html',
+            description: 'Choosing the right Map implementation',
+            category: 'tutorial'
+        }
+    ],
+    'string-concatenation': [
+        {
+            title: 'StringBuilder',
+            url: 'https://docs.oracle.com/javase/8/docs/api/java/lang/StringBuilder.html',
+            description: 'Efficient string concatenation with StringBuilder',
+            category: 'documentation'
+        },
+        {
+            title: 'String Performance',
+            url: 'https://docs.oracle.com/javase/tutorial/java/data/buffers.html',
+            description: 'String buffers and builders for performance',
+            category: 'tutorial'
+        }
+    ],
+    'resource-leaks': [
+        {
+            title: 'AutoCloseable Interface',
+            url: 'https://docs.oracle.com/javase/8/docs/api/java/lang/AutoCloseable.html',
+            description: 'Understanding AutoCloseable resources',
+            category: 'documentation'
+        },
+        {
+            title: 'Resource Leak Prevention',
+            url: 'https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html',
+            description: 'Preventing resource leaks with try-with-resources',
+            category: 'tutorial'
+        }
+    ],
+    'naming-conventions': [
+        {
+            title: 'Java Naming Conventions',
+            url: 'https://www.oracle.com/java/technologies/javase/codeconventions-namingconventions.html',
+            description: 'Official Oracle Java naming conventions',
+            category: 'documentation'
+        },
+        {
+            title: 'Google Java Style Guide',
+            url: 'https://google.github.io/styleguide/javaguide.html',
+            description: 'Google\'s comprehensive Java style guide',
+            category: 'guide'
+        }
+    ],
+    'access-modifiers': [
+        {
+            title: 'Access Control',
+            url: 'https://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html',
+            description: 'Controlling access to members of a class',
+            category: 'documentation'
+        },
+        {
+            title: 'Effective Java: Minimize Accessibility',
+            url: 'https://www.oracle.com/technical-resources/articles/java/effective-java-item15.html',
+            description: 'Best practices for access modifiers',
+            category: 'guide'
+        }
+    ],
+    'class-design': [
+        {
+            title: 'Effective Java: Item 15',
+            url: 'https://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html',
+            description: 'Minimize the accessibility of classes and members',
+            category: 'documentation'
+        },
+        {
+            title: 'Java OOP Best Practices',
+            url: 'https://docs.oracle.com/javase/tutorial/java/concepts/',
+            description: 'Object-oriented programming concepts in Java',
+            category: 'tutorial'
+        }
+    ],
+    'performance': [
+        {
+            title: 'Java Performance Tuning',
+            url: 'https://docs.oracle.com/javase/8/docs/technotes/guides/vm/performance-enhancements-7.html',
+            description: 'JVM performance enhancements and best practices',
+            category: 'guide'
+        },
+        {
+            title: 'Collections Performance',
+            url: 'https://docs.oracle.com/javase/tutorial/collections/implementations/',
+            description: 'Choosing the right collection for performance',
+            category: 'documentation'
+        }
+    ],
+    'security': [
+        {
+            title: 'Java Security Guidelines',
+            url: 'https://www.oracle.com/java/technologies/javase/seccodeguide.html',
+            description: 'Secure coding guidelines for Java',
+            category: 'guide'
+        },
+        {
+            title: 'OWASP Java Security',
+            url: 'https://owasp.org/www-project-top-ten/',
+            description: 'Security vulnerabilities in Java applications',
+            category: 'guide'
+        }
+    ],
+    'deprecated-apis': [
+        {
+            title: 'Java Deprecated API',
+            url: 'https://docs.oracle.com/javase/8/docs/api/deprecated-list.html',
+            description: 'List of deprecated Java APIs',
+            category: 'documentation'
+        },
+        {
+            title: 'Migration Guide',
+            url: 'https://docs.oracle.com/javase/8/docs/technotes/guides/lang/enhancements.html',
+            description: 'Modern alternatives to deprecated APIs',
+            category: 'guide'
+        }
+    ],
+    'exception-handling': [
+        {
+            title: 'Java Exception Handling',
+            url: 'https://docs.oracle.com/javase/tutorial/essential/exceptions/',
+            description: 'Complete guide to exception handling in Java',
+            category: 'tutorial'
+        },
+        {
+            title: 'Effective Java: Exceptions',
+            url: 'https://www.oracle.com/technical-resources/articles/enterprise-architecture/effective-exceptions.html',
+            description: 'Best practices for exception handling',
+            category: 'guide'
+        }
+    ]
+};
+// TypeScript Standards
+exports.typescriptStandards = {
+    'type-errors': [
+        {
+            title: 'TypeScript: Type Compatibility',
+            url: 'https://www.typescriptlang.org/docs/handbook/type-compatibility.html',
+            description: 'Understanding type assignability and compatibility in TypeScript',
+            category: 'documentation'
+        },
+        {
+            title: 'TypeScript: Strict Null Checks',
+            url: 'https://www.typescriptlang.org/tsconfig#strictNullChecks',
+            description: 'Enabling strict null checking to prevent null/undefined errors',
+            category: 'documentation'
+        },
+        {
+            title: 'TypeScript: Type Inference',
+            url: 'https://www.typescriptlang.org/docs/handbook/type-inference.html',
+            description: 'How TypeScript infers types and detects type errors',
+            category: 'tutorial'
+        }
+    ],
+    'type-assertions': [
+        {
+            title: 'TypeScript: Type Assertions',
+            url: 'https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#type-assertions',
+            description: 'Safe and unsafe ways to assert types',
+            category: 'documentation'
+        },
+        {
+            title: 'TypeScript: Type Guards and Narrowing',
+            url: 'https://www.typescriptlang.org/docs/handbook/2/narrowing.html',
+            description: 'Using type guards to safely narrow types',
+            category: 'tutorial'
+        },
+        {
+            title: 'TypeScript: Const Assertions',
+            url: 'https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html#const-assertions',
+            description: 'Using const assertions for literal types',
+            category: 'documentation'
+        }
+    ],
+    'generics': [
+        {
+            title: 'TypeScript: Generics Handbook',
+            url: 'https://www.typescriptlang.org/docs/handbook/2/generics.html',
+            description: 'Complete guide to TypeScript generics',
+            category: 'documentation'
+        },
+        {
+            title: 'TypeScript: Generic Constraints',
+            url: 'https://www.typescriptlang.org/docs/handbook/2/generics.html#generic-constraints',
+            description: 'Constraining generic types with extends',
+            category: 'tutorial'
+        },
+        {
+            title: 'TypeScript: Advanced Types',
+            url: 'https://www.typescriptlang.org/docs/handbook/2/types-from-types.html',
+            description: 'Creating types from other types',
+            category: 'guide'
+        }
+    ],
+    'unions-intersections': [
+        {
+            title: 'TypeScript: Union Types',
+            url: 'https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#union-types',
+            description: 'Working with union types in TypeScript',
+            category: 'documentation'
+        },
+        {
+            title: 'TypeScript: Type Narrowing',
+            url: 'https://www.typescriptlang.org/docs/handbook/2/narrowing.html',
+            description: 'Narrowing union types to specific types',
+            category: 'tutorial'
+        },
+        {
+            title: 'TypeScript: Discriminated Unions',
+            url: 'https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions',
+            description: 'Using discriminated unions for type safety',
+            category: 'guide'
+        }
+    ],
+    'classes-interfaces': [
+        {
+            title: 'TypeScript: Classes',
+            url: 'https://www.typescriptlang.org/docs/handbook/2/classes.html',
+            description: 'Complete guide to TypeScript classes',
+            category: 'documentation'
+        },
+        {
+            title: 'TypeScript: Interfaces',
+            url: 'https://www.typescriptlang.org/docs/handbook/2/objects.html',
+            description: 'Defining interfaces and object types',
+            category: 'documentation'
+        },
+        {
+            title: 'TypeScript: Abstract Classes',
+            url: 'https://www.typescriptlang.org/docs/handbook/2/classes.html#abstract-classes-and-members',
+            description: 'Using abstract classes and methods',
+            category: 'tutorial'
+        }
+    ],
+    'async-promises': [
+        {
+            title: 'TypeScript: Async Functions',
+            url: 'https://www.typescriptlang.org/docs/handbook/release-notes/typescript-1-7.html#asyncawait',
+            description: 'Typing async functions and promises',
+            category: 'documentation'
+        },
+        {
+            title: 'TypeScript: Promise Type Safety',
+            url: 'https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#promises',
+            description: 'Ensuring type safety with Promises',
+            category: 'tutorial'
+        },
+        {
+            title: 'TypeScript: Error Handling in Async',
+            url: 'https://github.com/microsoft/TypeScript/wiki/FAQ#why-are-some-errors-only-reported-with-strictnullchecks',
+            description: 'Handling errors in async/await code',
+            category: 'guide'
+        }
+    ],
+    'modules': [
+        {
+            title: 'TypeScript: Module Resolution',
+            url: 'https://www.typescriptlang.org/docs/handbook/module-resolution.html',
+            description: 'Understanding how TypeScript resolves modules',
+            category: 'documentation'
+        },
+        {
+            title: 'TypeScript: Module Augmentation',
+            url: 'https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation',
+            description: 'Augmenting existing modules',
+            category: 'tutorial'
+        },
+        {
+            title: 'TypeScript: Ambient Modules',
+            url: 'https://www.typescriptlang.org/docs/handbook/modules.html#ambient-modules',
+            description: 'Working with ambient module declarations',
+            category: 'guide'
+        }
+    ],
+    'decorators': [
+        {
+            title: 'TypeScript: Decorators Guide',
+            url: 'https://www.typescriptlang.org/docs/handbook/decorators.html',
+            description: 'Using experimental decorators in TypeScript',
+            category: 'documentation'
+        },
+        {
+            title: 'TypeScript: Experimental Features',
+            url: 'https://www.typescriptlang.org/tsconfig#experimentalDecorators',
+            description: 'Enabling experimental decorator support',
+            category: 'documentation'
+        },
+        {
+            title: 'TypeScript: Metadata Reflection',
+            url: 'https://github.com/rbuckton/reflect-metadata',
+            description: 'Using reflect-metadata with decorators',
+            category: 'guide'
+        }
+    ],
+    'mapped-conditional': [
+        {
+            title: 'TypeScript: Mapped Types',
+            url: 'https://www.typescriptlang.org/docs/handbook/2/mapped-types.html',
+            description: 'Creating types based on existing types',
+            category: 'documentation'
+        },
+        {
+            title: 'TypeScript: Conditional Types',
+            url: 'https://www.typescriptlang.org/docs/handbook/2/conditional-types.html',
+            description: 'Using conditional types for advanced patterns',
+            category: 'tutorial'
+        },
+        {
+            title: 'TypeScript: Template Literal Types',
+            url: 'https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html',
+            description: 'Using template literal types',
+            category: 'guide'
+        }
+    ],
+    'strict-mode': [
+        {
+            title: 'TypeScript: Strict Mode Options',
+            url: 'https://www.typescriptlang.org/tsconfig#strict',
+            description: 'Understanding all strict mode compiler options',
+            category: 'documentation'
+        },
+        {
+            title: 'TypeScript: Compiler Options Reference',
+            url: 'https://www.typescriptlang.org/tsconfig',
+            description: 'Complete TypeScript compiler configuration',
+            category: 'documentation'
+        },
+        {
+            title: 'TypeScript: strictNullChecks',
+            url: 'https://www.typescriptlang.org/tsconfig#strictNullChecks',
+            description: 'Preventing null and undefined errors',
+            category: 'tutorial'
+        }
+    ],
+    'any-propagation': [
+        {
+            title: 'TypeScript: Avoiding Any',
+            url: 'https://www.typescriptlang.org/docs/handbook/declaration-files/do-s-and-don-ts.html#any',
+            description: 'Best practices for avoiding the any type',
+            category: 'guide'
+        },
+        {
+            title: 'TypeScript: Type Safety Best Practices',
+            url: 'https://github.com/microsoft/TypeScript/wiki/Performance#using-type-annotations',
+            description: 'Maintaining type safety across your codebase',
+            category: 'guide'
+        },
+        {
+            title: 'TypeScript: noImplicitAny',
+            url: 'https://www.typescriptlang.org/tsconfig#noImplicitAny',
+            description: 'Preventing implicit any types',
+            category: 'documentation'
+        }
+    ],
+    'performance': [
+        {
+            title: 'TypeScript: Performance Guide',
+            url: 'https://github.com/microsoft/TypeScript/wiki/Performance',
+            description: 'Official TypeScript performance optimization guide',
+            category: 'guide'
+        },
+        {
+            title: 'TypeScript: Type Complexity Analysis',
+            url: 'https://github.com/microsoft/TypeScript/wiki/Performance#preferring-base-types-over-unions',
+            description: 'Analyzing and reducing type complexity',
+            category: 'tutorial'
+        },
+        {
+            title: 'TypeScript: Build Performance',
+            url: 'https://www.typescriptlang.org/docs/handbook/project-references.html',
+            description: 'Improving compilation performance',
+            category: 'documentation'
+        }
+    ]
+};
+// Helper function to get references for a specific issue
+function getReferencesForIssue(language, issueType) {
+    switch (language.toLowerCase()) {
+        case 'javascript':
+            return exports.javascriptStandards[issueType] || [];
+        case 'typescript':
+            return exports.typescriptStandards[issueType] || exports.javascriptStandards[issueType] || [];
+        case 'python':
+            return exports.pythonStandards[issueType] || [];
+        case 'java':
+            return exports.javaStandards[issueType] || [];
+        default:
+            return [];
+    }
+}
+// Map common error types to reference categories
+function mapErrorToReference(errorMessage, language) {
+    const message = errorMessage.toLowerCase();
+    if (message.includes('var') && message.includes('detectado')) {
+        return getReferencesForIssue(language, 'var-usage');
+    }
+    if (message.includes('console.log') || message.includes('ponto extra')) {
+        return getReferencesForIssue(language, 'console-methods');
+    }
+    if (message.includes('loop') && message.includes('length')) {
+        return getReferencesForIssue(language, 'performance-loops');
+    }
+    // TypeScript specific errors
+    if (message.includes('tipo typescript') || message.includes('typescript detectado')) {
+        return getReferencesForIssue(language, 'typescript-types');
+    }
+    if (message.includes('propriedade comentada') || message.includes('commented property')) {
+        return getReferencesForIssue(language, 'code-quality');
+    }
+    if (message.includes('propriedade') && (message.includes('sintaxe') || message.includes('incorreta'))) {
+        return getReferencesForIssue(language, 'typescript-properties');
+    }
+    if (message.includes('sintaxe') || message.includes('syntax')) {
+        return getReferencesForIssue(language, 'syntax-errors');
+    }
+    // Enhanced security patterns
+    if (message.includes('sql injection') || message.includes('segurança') ||
+        message.includes('eval(') || message.includes('eval()') ||
+        message.includes('function constructor') ||
+        message.includes('xss') || message.includes('innerhtml') || message.includes('outerhtml') ||
+        message.includes('script injection') || message.includes('code injection') ||
+        message.includes('dangerous') || message.includes('vulnerability') ||
+        message.includes('security') || message.includes('attack') ||
+        message.includes('malicious') || message.includes('exploit')) {
+        return getReferencesForIssue(language, 'security-practices');
+    }
+    if (message.includes('indentação') || message.includes('indentation')) {
+        return getReferencesForIssue(language, 'indentation');
+    }
+    if (message.includes('nomeação') || message.includes('naming') || message.includes('camelcase')) {
+        return getReferencesForIssue(language, 'naming-conventions');
+    }
+    // Python-specific error mappings
+    if (language === 'python') {
+        if (message.includes('f-string') || message.includes('chave não fechada')) {
+            return getReferencesForIssue(language, 'f-strings');
+        }
+        if (message.includes('format') || message.includes('argumentos extras') || message.includes('placeholder')) {
+            return getReferencesForIssue(language, 'string-formatting');
+        }
+        if (message.includes('dois pontos') || message.includes('parêntese') || message.includes('chave') || message.includes('colchete')) {
+            return getReferencesForIssue(language, 'syntax-errors');
+        }
+        if (message.includes('ai hallucination') || message.includes('método') || message.includes('method')) {
+            return getReferencesForIssue(language, 'ai-hallucination');
+        }
+        if (message.includes('typeerror') || message.includes('tipo incorreto')) {
+            return getReferencesForIssue(language, 'type-errors');
+        }
+        if (message.includes('valueerror') || message.includes('valor') || message.includes('conversão')) {
+            return getReferencesForIssue(language, 'value-errors');
+        }
+        if (message.includes('nameerror') || message.includes('não definida') || message.includes('não está definida')) {
+            return getReferencesForIssue(language, 'name-errors');
+        }
+        if (message.includes('attributeerror') || message.includes('atributo') || message.includes('método inexistente')) {
+            return getReferencesForIssue(language, 'attribute-errors');
+        }
+        if (message.includes('indexerror') || message.includes('índice') || message.includes('out of range')) {
+            return getReferencesForIssue(language, 'index-errors');
+        }
+        if (message.includes('keyerror') || message.includes('chave inexistente') || message.includes('dictionary')) {
+            return getReferencesForIssue(language, 'key-errors');
+        }
+        if (message.includes('import') || message.includes('modulenotfound') || message.includes('módulo')) {
+            return getReferencesForIssue(language, 'import-errors');
+        }
+        if (message.includes('mutable') || message.includes('argumento padrão') || message.includes('default argument')) {
+            return getReferencesForIssue(language, 'mutable-defaults');
+        }
+        if (message.includes('modificar') && message.includes('loop')) {
+            return getReferencesForIssue(language, 'loop-modification');
+        }
+        if (message.includes('global') || message.includes('nonlocal') || message.includes('escopo')) {
+            return getReferencesForIssue(language, 'scope-issues');
+        }
+    }
+    // Java-specific error mappings
+    if (language === 'java') {
+        if (message.includes('nullpointer') || message.includes('null') && message.includes('risco')) {
+            return getReferencesForIssue(language, 'null-pointer');
+        }
+        if (message.includes('cannot find symbol') || message.includes('incompatible types') || message.includes('compilação')) {
+            return getReferencesForIssue(language, 'compilation-errors');
+        }
+        if (message.includes('classcast') || message.includes('cast') || message.includes('tipo incompatível')) {
+            return getReferencesForIssue(language, 'class-cast');
+        }
+        if (message.includes('arrayindex') || message.includes('array') && message.includes('bounds')) {
+            return getReferencesForIssue(language, 'array-bounds');
+        }
+        if (message.includes('illegalargument') || message.includes('validação') || message.includes('argumento')) {
+            return getReferencesForIssue(language, 'illegal-argument');
+        }
+        if (message.includes('concurrentmodification') || message.includes('synchronized') || message.includes('concorrência')) {
+            return getReferencesForIssue(language, 'concurrency-issues');
+        }
+        if (message.includes('outofmemory') || message.includes('stackoverflow') || message.includes('memória')) {
+            return getReferencesForIssue(language, 'memory-errors');
+        }
+        if (message.includes('ioexception') || message.includes('file') || message.includes('arquivo')) {
+            return getReferencesForIssue(language, 'io-exceptions');
+        }
+        if (message.includes('sql injection') || message.includes('preparedstatement') || message.includes('sql')) {
+            return getReferencesForIssue(language, 'sql-injection');
+        }
+        if (message.includes('serializ') || message.includes('deserializ')) {
+            return getReferencesForIssue(language, 'serialization');
+        }
+        if (message.includes('vector') || message.includes('hashtable') || message.includes('arraylist') || message.includes('hashmap')) {
+            return getReferencesForIssue(language, 'collections-performance');
+        }
+        if (message.includes('stringbuilder') || message.includes('concatenação') && message.includes('string')) {
+            return getReferencesForIssue(language, 'string-concatenation');
+        }
+        if (message.includes('resource') && message.includes('leak') || message.includes('try-with-resources') || message.includes('autocloseable')) {
+            return getReferencesForIssue(language, 'resource-leaks');
+        }
+        if (message.includes('camelcase') || message.includes('pascalcase') || message.includes('nome') || message.includes('naming')) {
+            return getReferencesForIssue(language, 'naming-conventions');
+        }
+        if (message.includes('modificador') || message.includes('access modifier') || message.includes('public') || message.includes('private')) {
+            return getReferencesForIssue(language, 'access-modifiers');
+        }
+        if (message.includes('deprecated') || message.includes('obsoleto')) {
+            return getReferencesForIssue(language, 'deprecated-apis');
+        }
+        if (message.includes('exception') || message.includes('catch') || message.includes('throw')) {
+            return getReferencesForIssue(language, 'exception-handling');
+        }
+    }
+    // TypeScript-specific error mappings
+    if (language === 'typescript') {
+        if (message.includes('not assignable') || message.includes('type compatibility') || message.includes('incompatible types')) {
+            return getReferencesForIssue(language, 'type-errors');
+        }
+        if (message.includes('type assertion') || message.includes('as ') || message.includes('type guard') || message.includes('non-null assertion')) {
+            return getReferencesForIssue(language, 'type-assertions');
+        }
+        if (message.includes('generic') || message.includes('type parameter') || message.includes('constraint')) {
+            return getReferencesForIssue(language, 'generics');
+        }
+        if (message.includes('union') || message.includes('intersection') || message.includes('discriminated') || message.includes('narrowing')) {
+            return getReferencesForIssue(language, 'unions-intersections');
+        }
+        if (message.includes('class') || message.includes('interface') || message.includes('implements') || message.includes('abstract')) {
+            return getReferencesForIssue(language, 'classes-interfaces');
+        }
+        if (message.includes('async') || message.includes('promise') || message.includes('await')) {
+            return getReferencesForIssue(language, 'async-promises');
+        }
+        if (message.includes('import') || message.includes('export') || message.includes('module') || message.includes('circular dependency')) {
+            return getReferencesForIssue(language, 'modules');
+        }
+        if (message.includes('decorator') || message.includes('experimental')) {
+            return getReferencesForIssue(language, 'decorators');
+        }
+        if (message.includes('mapped') || message.includes('conditional type') || message.includes('template literal')) {
+            return getReferencesForIssue(language, 'mapped-conditional');
+        }
+        if (message.includes('strict') || message.includes('strictnullchecks') || message.includes('noimplicitany')) {
+            return getReferencesForIssue(language, 'strict-mode');
+        }
+        if (message.includes('any') || message.includes('implicit any') || message.includes('type safety')) {
+            return getReferencesForIssue(language, 'any-propagation');
+        }
+        if (message.includes('performance') || message.includes('compilation') || message.includes('complexity')) {
+            return getReferencesForIssue(language, 'performance');
+        }
+    }
+    return [];
+}
+//# sourceMappingURL=references.js.map