codewrench 0.1.0__py3-none-any.whl

codewrench-0.1.0.dist-info/METADATA

@@ -0,0 +1,187 @@
+Metadata-Version: 2.4
+Name: codewrench
+Version: 0.1.0
+Summary: A multi-language code performance analyser with static analysis and AI-powered fix generation.
+Author-email: Vishad Jain <vishadjain2304@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/vishaddjain/wrench
+Project-URL: Issues, https://github.com/vishaddjain/wrench/issues
+Keywords: performance,static-analysis,code-analysis,AI,developer-tools
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: groq>=1.1.1
+Requires-Dist: python-dotenv>=1.2.2
+Requires-Dist: requests>=2.32.5
+Requires-Dist: tree-sitter>=0.25.2
+Requires-Dist: tree-sitter-python>=0.25.0
+Requires-Dist: tree-sitter-javascript>=0.25.0
+Requires-Dist: tree-sitter-typescript>=0.23.2
+Requires-Dist: tree-sitter-go>=0.25.0
+Requires-Dist: tree-sitter-c>=0.24.1
+Requires-Dist: tree-sitter-cpp>=0.23.4
+
+# 🔧 wrench
+
+> Point it at your code. Get back what's slow and how to fix it.
+
+Wrench is a multi-language performance analyser that combines static analysis with AI-powered explanations. It finds real performance issues in your code — nested loops, inefficient patterns, bad practices — then explains exactly why they're a problem and shows you the fix.
+
+No cloud, no setup hell, no enterprise pricing. Just run it on a file.
+
+---
+
+## What it catches
+
+**High priority**
+- Nested loops (O(n²) and worse)
+- Expensive function calls inside loops
+- Repeated attribute access that should be cached
+- String concatenation with `+` in loops
+
+**Medium priority**
+- List appends inside nested loops
+- Unnecessary `list(range(n))` creation
+- Bare `except:` and overly broad `except Exception`
+- Global variable access inside loops
+- Mutable default arguments
+
+---
+
+## Supported languages
+
+| Language | Extension |
+|----------|-----------|
+| Python | `.py` |
+| JavaScript | `.js` |
+| TypeScript | `.ts` |
+| Go | `.go` |
+| C | `.c` |
+| C++ | `.cpp`, `.cc` |
+
+---
+
+## Installation
+
+```bash
+git clone https://github.com/yourusername/wrench.git
+cd wrench
+python -m venv venv
+source venv/bin/activate        # Mac/Linux
+venv\Scripts\activate           # Windows
+pip install -r requirements.txt
+```
+
+Create a `.env` file in the project root:
+
+```
+GROQ_API_KEY=your_key_here
+```
+
+Get a free Groq API key at [console.groq.com](https://console.groq.com) 
+
+---
+
+## Usage
+
+```bash
+python main.py yourfile.py
+python main.py app.js
+python main.py main.go
+python main.py server.cpp
+```
+
+That's it. Wrench detects the language from the file extension automatically.
+
+### Example output
+
+```
+Nested loop at line 19 — potential O(n²)
+String concatenation at line 22 — use ''.join() instead
+Function call 'expensive_function' inside loop at line 25 — consider moving it out
+Bare except at line 40 — catches everything including system exceptions, be specific
+
+--- AI Analysis ---
+
+1. Nested loop at line 19
+   Problem: Two nested loops over the same data gives you O(n²) time complexity.
+   For 1000 items that's 1,000,000 iterations instead of 1,000.
+
+   Fix:
+   # before
+   for i in items:
+       for j in items:
+           process(i, j)
+
+   # after — use itertools or restructure with a dict lookup
+   lookup = {item: process(item) for item in items}
+```
+
+---
+
+## How it works
+
+```
+your file
+    ↓
+Tree-sitter parses it into a syntax tree
+    ↓
+IR translator converts to language-agnostic representation
+    ↓
+Detectors run static analysis on the IR
+    ↓
+Findings sent to Groq (Llama 3.3 70B)
+    ↓
+Plain English explanation + fix
+```
+
+The static analysis layer is deterministic — it either finds a nested loop or it doesn't. No hallucination. The AI layer explains what the detectors already confirmed exists.
+
+---
+
+## Roadmap
+
+- [x] Static analysis (Python, JS, TS, Go, C, C++)
+- [x] AI-powered explanations and fixes
+- [x] Multi-language IR architecture
+- [ ] Runtime profiling (Layer 3)
+- [ ] More detectors
+- [ ] `pip install wrench` support
+- [ ] Web UI
+
+---
+
+## Project structure
+
+```
+wrench/
+├── detectors/
+│   ├── base.py         ← depth tracking, core visitor
+│   ├── high.py         ← high priority detectors
+│   └── medium.py       ← medium priority detectors
+├── languages/
+│   ├── python_rules.py ← Tree-sitter node mappings per language
+│   ├── js_rules.py
+│   └── ...
+├── ir.py               ← language-agnostic IR node
+├── ir_translator.py    ← Tree-sitter → IR translation
+├── parser_engine.py    ← language detection + parser setup
+├── ai_engine.py        ← Groq integration
+└── main.py             ← entry point
+```
+
+---
+
+## Contributing
+
+Pull requests welcome. If you want to add a new language, add a rules file in `languages/` mapping Tree-sitter node types to the generic IR types. That's it — the detectors work on all languages automatically.
+
+Open an issue first for anything major.
+
+---
+
+Built by [@vishaddjain]

codewrench-0.1.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+wrench/ai_engine.py,sha256=Eo-FncE2A_-amHR7TBmsUalGgutUwM9vJjHIWYzRnls,2444
+wrench/code.py,sha256=joTNtX15U2INRUokcjtWbK-hNwJROIA062R2Qv5efj4,1465
+wrench/errors.py,sha256=ch4biH_7_U1eS6WUPZW_g6haXYsaIeNm_UyM0oTwGEU,891
+wrench/ir.py,sha256=dWQcHI-kfGAU9NF6b1iWu0jFLQmLXZ_KGcOyIu9NSxY,326
+wrench/ir_translator.py,sha256=p_yab9ORidH0Fe0AFWxqwt81Wu_tgNewlAH8E-Jxbq0,3712
+wrench/main.py,sha256=BvTok3HfnV-vONaqBYtp54EKBWhrG0889rrEAnuPcDs,6490
+wrench/parser_engine.py,sha256=J0z5XVwZMV58fAVoo9jyLh1-Uvg66bTZ86P5ZeszUrk,922
+wrench/reports.py,sha256=g3kRoIgFbgwl0fXKk-TXRxuVNJFNMQrX24lozmSwehw,2663
+wrench/wrenchignore.py,sha256=je-rxZfvC8rTaApmEZpv9O_QoxrogDXs1OcesZWrAD0,733
+wrench/detectors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wrench/detectors/base.py,sha256=1c-__XrdtFBsgy_kp5-dGOpcC17L3c-3KmCjprCcs-0,1060
+wrench/detectors/high.py,sha256=rU8COk1fElcNZIA4EVAFhUFfMZLHI7ogGRyFt5-YSkc,3510
+wrench/detectors/medium.py,sha256=hnU7GXRwgi3ttvDAOENFA7hnaa3NyHYDIGgq7AKtsbU,3270
+wrench/languages/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wrench/languages/c_rules.py,sha256=ytLweRyI-NRRC4sHvLN_FP69Fq-QGLDQ7anacsBHH58,373
+wrench/languages/cpp_rules.py,sha256=B3S98Uod3ts9xHn-slwt-OLEsjCdl_DruXbDsDEUi90,437
+wrench/languages/go_rules.py,sha256=9F223iJbsmHDsUgOsIyczE398QqJum081rB_bNuR9_8,402
+wrench/languages/javascript_rules.py,sha256=fm7H5A5qxMXEB0hcQdI7cQas6XIVQL2apWlBemjHJNc,503
+wrench/languages/python_rules.py,sha256=Pwi1wkz3_fk0DYKMgdM1I9FkTKJ1rXjeAijGpXiAZCM,411
+wrench/languages/typescript_rules.py,sha256=BBnno6Hx-sDdMxM_m87gcJfeezDAHThXqKPC1yGW7iI,524
+wrench/profilers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wrench/profilers/profiler.py,sha256=VGbI2ZnBtY_P9-MnHgdeFNRNZBp1cNEQnk7lefRMd68,1275
+codewrench-0.1.0.dist-info/METADATA,sha256=Fbihlf7MPwrh0mdYirwcqWwEdP6mgTqsnLMLCTrPCvs,5185
+codewrench-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+codewrench-0.1.0.dist-info/entry_points.txt,sha256=TCQ4dR34hDgfKgEcNE8JDcioDrObD9a33lsNnDVsC4M,41
+codewrench-0.1.0.dist-info/top_level.txt,sha256=0PDz80PbdzNQqVjw3WmSLTb5oyb6Fvq3uhj4xlJlN-Y,7
+codewrench-0.1.0.dist-info/RECORD,,

codewrench-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

codewrench-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codewrench = main:main

codewrench-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+wrench

wrench/ai_engine.py

@@ -0,0 +1,94 @@
+from groq import Groq
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+
+#For single file
+def analyse(code, warnings):
+    if not warnings:
+        return "No issues found — nothing to analyse."
+    
+    warnings_text = "\n".join(f"- {w}" for w in warnings)
+    
+    prompt = f"""
+You are a performance analytics expert.
+
+Here is the code:
+{code}
+
+These performance issues were detected:
+{warnings_text}
+
+For each issue:
+1. Explain in plain English why it's a problem
+2. Show a fixed version of that specific code
+3. Explain why the fix is better
+
+Be concise and practical.
+"""
+    
+    response = client.chat.completions.create(
+        model="llama-3.3-70b-versatile",
+        messages=[{"role": "user", "content": prompt}]
+    )
+    return response.choices[0].message.content
+
+#For Folder
+def analyse_folder(all_results):
+    if not all_results:
+        return "No issues found — nothing to analyse."
+    
+    combined = ""
+    for filepath, warnings in all_results.items():
+        warnings_text = "\n".join(f"  - {w}" for w in warnings)
+        combined += f"\nFile: {filepath}\n{warnings_text}\n"
+    
+    prompt = f"""
+You are a performance analytics expert.
+
+These performance issues were detected across a codebase:
+
+{combined}
+
+For each file, go through each issue and:
+1. Explain in plain English why it's a problem
+2. Suggest a fix with a short code example
+3. Explain why the fix is better
+
+Be concise and practical. Group your response by file.
+"""
+    
+    response = client.chat.completions.create(
+        model="llama-3.3-70b-versatile",
+        messages=[{"role": "user", "content": prompt}]
+    )
+    return response.choices[0].message.content
+
+#For testing purpose to differentiate the performance
+def get_fixed_code(code, warnings):
+    if not warnings:
+        return code
+    
+    warnings_text = "\n".join(f"- {w}" for w in warnings)
+    
+    prompt = f"""
+You are a performance analytics expert.
+
+Here is the original code:
+{code}
+
+These performance issues were detected:
+{warnings_text}
+
+Return ONLY the fixed version of the complete code.
+No explanations, no comments, no markdown, no code blocks.
+Just the raw fixed code that can be executed directly.
+"""
+    
+    response = client.chat.completions.create(
+        model="llama-3.3-70b-versatile",
+        messages=[{"role": "user", "content": prompt}]
+    )
+    return response.choices[0].message.content

wrench/code.py

@@ -0,0 +1,67 @@
+import re
+import requests
+
+# nested loops
+def process_data(items):
+    results = []
+    for i in items:
+        for j in items:
+            results.append(i + j)  # list append in nested loop
+    return results
+
+# string concat in loop
+def build_string(words):
+    result = ""
+    for word in words:
+        result += word  # string concat
+    return result
+
+# re.compile in loop
+def match_emails(emails):
+    for email in emails:
+        pattern = re.compile(r'\w+@\w+\.\w+')  # re.compile in loop
+        if pattern.match(email):
+            print(f"Valid: {email}")  # print in loop
+
+# expensive call in loop
+def fetch_data(urls):
+    for url in urls:
+        response = requests.get(url)  # I/O in loop
+        print(response.status_code)
+
+# mutable default argument
+def add_item(item, items=[]):
+    items.append(item)
+    return items
+
+# bare except
+def risky():
+    try:
+        x = 1 / 0
+    except:
+        pass
+
+# global in loop
+counter = 0
+def increment(n):
+    global counter
+    for i in range(n):
+        counter += 1  # global in loop
+
+# unnecessary object creation in loop
+def make_dicts(n):
+    for i in range(n):
+        d = dict()  # unnecessary object creation
+        d['key'] = i
+
+# import inside function
+def parse_json(data):
+    import json  # import inside function
+    return json.loads(data)
+
+# list concat with +
+def combine(lists):
+    result = []
+    for l in lists:
+        result = result + l  # list concat with +
+    return result

wrench/detectors/base.py

@@ -0,0 +1,35 @@
+class BaseDetectors:
+    def __init__(self):
+        self.depth = 0
+        self.warnings = []
+        self.attr_counts = {}
+        self.global_vars = set()
+        self.function_depth = 0
+
+    def visit(self, node):
+        method = f"visit_{node.node_type}"
+        visitor = getattr(self, method, self.generic_visit)
+        visitor(node)
+    
+    def generic_visit(self, node):
+        for child in node.children:
+            self.visit(child)
+
+    def visit_loop(self, node):
+        self.depth += 1
+        self.generic_visit(node)
+        self.depth -= 1
+
+    def visit_function_def(self, node):
+        self.function_depth += 1
+        original_depth = self.depth
+        self.depth = 0
+        self.generic_visit(node)
+        self.depth = original_depth
+        self.function_depth -= 1
+
+    def visit_global_statement(self, node):
+        for child in node.children:
+            if hasattr(child, 'node_type') and child.node_type == "identifier":
+                self.global_vars.add(child.metadata.get("name", ""))
+        self.generic_visit(node)

wrench/detectors/high.py

@@ -0,0 +1,78 @@
+from .base import BaseDetectors
+
+class HighDetectors(BaseDetectors):
+    
+    CHEAP_CALLS = {"print", "len", "range", "str", "int", "float", "bool", "type"}
+    EXPENSIVE_CALLS = {"open", "requests", "get", "post", "read", "write", "connect", "execute"}
+    UNNECESSARY_OBJECT = {"dict", "list", "tuple", "set", "object"}
+
+    def visit_loop(self, node):
+        self.depth += 1
+        if self.depth >= 2 :
+            self.warnings.append(
+                f"Nested loop at line {node.lineno} - potential O(n²)."
+            )
+        self.generic_visit(node)
+        self.depth -= 1
+    
+    def visit_function_call(self, node):
+        if self.depth >= 1:
+            name = node.metadata.get("name", None)
+            if name and name == "re.compile":
+                self.warnings.append(
+                    f"re.compile() inside loop at line {node.lineno} — move it outside the loop, compile once and reuse."
+                )
+            elif name and name in ["print", "logging.info", "logging.warning", "logging.error"]:
+                self.warnings.append(
+                    f"print()/logging call inside loop at line {node.lineno} — I/O on every iteration, move outside or use buffered logging."
+                )
+            elif name and name == "len":
+                self.warnings.append(
+                    f"len() called inside loop at line {node.lineno} — cache the result before the loop to avoid repeated calls."
+                )
+            elif name and name in self.EXPENSIVE_CALLS:
+                self.warnings.append(
+                    f"I/O call {name} inside loop at line {node.lineno} - consider moving/removing it out."
+                )
+            elif name and name in self.UNNECESSARY_OBJECT:
+                self.warnings.append(
+                    f"Creating new object/literal inside loop - causes GC/allocation pressure. Consider moving outside or reusing."
+                )
+            elif name and name not in self.CHEAP_CALLS:
+                self.warnings.append(
+                    f"Function call '{name}' inside loop at line {node.lineno} — consider moving it out."
+                )   
+
+        self.generic_visit(node)
+
+    def visit_attribute_access(self, node):
+        if self.depth >= 1:
+            name = node.metadata.get("name", None)
+            if name:
+                if name not in self.attr_counts:
+                    self.attr_counts[name] = []
+                self.attr_counts[name].append(node.lineno)
+        self.generic_visit(node)
+    
+    def visit_string_concat(self, node):
+        if self.depth >= 2:
+            self.warnings.append(
+                f"String concatenation in nested loop — quadratic complexity at line {node.lineno}, use join() outside the loop"
+            )
+        elif self.depth >= 1:
+            self.warnings.append(
+                f"String concatenation at line {node.lineno} — use ''.join() instead."
+            )
+        self.generic_visit(node)
+
+    def check_attr_counts(self):
+        for key, lines in self.attr_counts.items():
+            if len(lines) >= 2:
+                self.warnings.append(
+                    f"Attribute '{key}' accessed {len(lines)} times in loop at lines {lines} — cache it."
+                )
+    def visit_await(self, node):
+        if self.depth >= 1:
+            self.warnings.append(
+                f"await inside loop at line {node.lineno} — sequential async calls, use asyncio.gather() or Promise.all() to run concurrently."
+            )

wrench/detectors/medium.py

@@ -0,0 +1,90 @@
+from .base import BaseDetectors
+
+class MediumDetectors(BaseDetectors):
+
+    SORT_CALLS = {"sort", "sorted", "sort_by", "order_by"}
+
+    def __init__(self):
+        super().__init__()
+
+    def visit_global_statement(self, node):
+        names = node.metadata.get("names", [])
+        for name in names:
+            self.global_vars.add(name)
+        self.generic_visit(node)
+
+    def visit_function_call(self, node):
+
+        name = node.metadata.get("name", None)
+
+        if self.depth >= 1:
+            if name and name in self.SORT_CALLS:
+                self.warnings.append(
+                    f"Unnecessary sorting {name} inside loops at line {node.lineno}."
+                ) 
+
+        if self.depth >= 2:
+            if name == "append":
+                self.warnings.append(
+                    f"List append inside nested loop at line {node.lineno} — consider restructuring."
+                )
+
+        if name == "list":
+            children_names = [
+                c.metadata.get("name", "") 
+                for c in node.children
+            ]
+            if "range" in children_names:
+                self.warnings.append(
+                    f"Unnecessary list creation at line {node.lineno} — just use range(n) directly."
+                )
+        
+        self.generic_visit(node)
+
+    def visit_exception_handler(self, node):
+        exception_type = node.metadata.get("exception_type", None)
+        if exception_type is None:
+            self.warnings.append(
+                f"Bare except at line {node.lineno} — catches everything, be specific."
+            )
+        elif exception_type == "Exception":
+            self.warnings.append(
+                f"Overly broad 'except Exception' at line {node.lineno} — catch specific exceptions."
+            )
+        if self.depth >= 1:
+            self.warnings.append(
+                f"try/except inside loop at line {node.lineno} — exception handling overhead on every iteration, move outside if possible."
+            )
+        self.generic_visit(node)
+
+    def visit_function_def(self, node):
+        defaults = node.metadata.get("mutable_defaults", [])
+        for lineno in defaults:
+            self.warnings.append(
+                f"Mutable default argument at line {lineno} — use None instead."
+            )
+        super().visit_function_def(node)
+
+
+    def visit_identifier(self, node):
+        if self.depth >= 1:
+            name = node.metadata.get("name", None)
+            if name and name in self.global_vars:
+                self.warnings.append(
+                    f"Global variable '{name}' accessed inside loop at line {node.lineno} — consider caching it locally."
+                )
+        self.generic_visit(node)
+
+    def visit_import(self, node):
+        if self.function_depth >= 1:
+            self.warnings.append(
+                f"Import is at function level instead of top at line {node.lineno}."
+            )
+        self.generic_visit(node)
+
+    def visit_list_concat(self, node):
+        if self.depth >= 1:
+            self.warnings.append(
+                f"List concatenation with '+' inside loop at line {node.lineno} — use .extend() or += instead, avoids creating a new list each iteration."
+            )
+        self.generic_visit(node)

wrench/errors.py

@@ -0,0 +1,16 @@
+MESSAGES = {
+    "unsupported_language": "Skipping '{path}' — language not supported (Python, JS, TS, Go, C, C++ only).",
+    "file_not_found":       "Error: '{path}' does not exist.",
+    "permission_error":     "Skipping '{path}' — permission denied.",
+    "binary_file":          "Skipping '{path}' — binary or non-text file.",
+    "syntax_error":         "Skipping '{path}' — could not parse file, possible syntax error.",
+    "empty_file":           "Skipping '{path}' — file is empty.",
+    "api_error":            "AI analysis failed for '{path}' — check your GROQ_API_KEY or network connection.",
+    "profiling_error":      "Profiling failed for '{path}' — skipping benchmark.",
+}
+ 
+def handle_error(error_type, path, fatal=False):
+    message = MESSAGES.get(error_type, "Unknown error for '{path}'.")
+    print(message.format(path=path))
+    if fatal:
+        exit(1)

wrench/ir.py

@@ -0,0 +1,11 @@
+class IRNode:
+    def __init__(self, node_type, lineno, children=None, metadata=None):
+        self.node_type = node_type
+        self.lineno = lineno
+        self.children = children or []
+        self.metadata = metadata or {}
+
+    def __repr__(self):
+        return f"IRNode({self.node_type}, line={self.lineno})"
+
+        

wrench/ir_translator.py

@@ -0,0 +1,104 @@
+from ir import IRNode
+
+GENERIC_TYPES = {
+    "LOOP": "loop",
+    "FUNCTION_CALL": "function_call",
+    "FUNCTION_DEF": "function_def",
+    "ATTRIBUTE_ACCESS": "attribute_access",
+    "STRING_CONCAT": "string_concat",
+    "EXCEPTION_HANDLER": "exception_handler",
+    "GLOBAL_STATEMENT": "global_statement",
+    "IMPORT": "import",
+    "AWAIT": "await",
+    "IDENTIFIER": "identifier"
+}
+
+class IRTranslator:
+    def __init__(self, rules):
+        self.rules = rules
+
+    def translate(self, node):
+        node_type = self.get_generic_type(node.type)
+        if node_type is None:
+            list_concat_types = getattr(self.rules, "LIST_CONCAT", [])
+            if node.type in list_concat_types:
+                op = node.child_by_field_name("operator")
+                if op and op.text.decode("utf8") == "+":
+                    node_type = "list_concat"
+            
+        lineno = node.start_point[0] + 1
+        children = [self.translate(child) for child in node.children]
+        metadata = self.extract_metadata(node, node_type)
+        return IRNode(node_type or f"_raw_{node.type}", lineno, children, metadata)
+    
+    def extract_metadata(self, node, node_type):
+        metadata = {}
+
+        if node_type == "function_call":
+            metadata["name"] = self.get_call_name(node)
+
+        elif node_type == "attribute_access":
+            metadata["name"] = self.get_attribute_name(node)
+        
+        elif node_type == "identifier":
+            metadata["name"] = node.text.decode("utf8") if node.text else None
+        
+        elif node_type == "exception_handler":
+                metadata["exception_type"] = self.get_exception_type(node)
+
+        elif node_type == "function_def":
+            metadata["mutable_defaults"] = self.get_mutable_defaults(node)
+
+        elif node_type == "global_statement":
+            metadata["names"] = [
+                child.text.decode("utf8") 
+                for child in node.children 
+                if child.type == "identifier"
+            ]
+
+        return metadata
+
+    def get_call_name(self, node):
+        for child in node.children:
+            if child.type == "identifier":
+                return child.text.decode("utf8")
+            elif child.type == "attribute":
+                parts = []
+                for subchild in child.children:
+                    if subchild.type == "identifier":
+                        parts.append(subchild.text.decode("utf8"))
+                if parts:
+                    return ".".join(parts)
+        return None
+
+    def get_attribute_name(self, node):
+        parts = []
+        for child in node.children:
+            if child.type == "identifier":
+                parts.append(child.text.decode("utf8"))
+        return ".".join(parts) if parts else None
+
+    def get_exception_type(self, node):
+        for child in node.children:
+            if child.type == "identifier":
+                return child.text.decode("utf8")
+        return None
+
+    def get_mutable_defaults(self, node):
+        mutable_lines = []
+        def check_mutable_recursive(n):
+            if n.type in ("list", "dictionary", "set"):
+                mutable_lines.append(n.start_point[0] + 1)
+            for child in n.children:
+                check_mutable_recursive(child)       
+        for child in node.children:
+            check_mutable_recursive(child)
+        return mutable_lines
+
+    def get_generic_type(self, tree_sitter_type):
+        for generic, mapped in GENERIC_TYPES.items():
+            rule_list = getattr(self.rules, generic + "_TYPES",
+                          getattr(self.rules, generic, []))
+            if tree_sitter_type in rule_list:
+                return mapped
+        return None

wrench/languages/c_rules.py

@@ -0,0 +1,10 @@
+LOOP_TYPES = ["for_statement", "while_statement", "do_statement"]
+FUNCTION_CALL = ["call_expression"]
+FUNCTION_DEF = ["function_definition"]
+ATTRIBUTE_ACCESS = ["field_expression"]
+STRING_CONCAT = ["assignment_expression"]
+EXCEPTION_HANDLER = []
+GLOBAL_STATEMENT = ["declaration"]
+IMPORT = ["preproc_include"]
+LIST_CONCAT = ["binary_expression"]
+IDENTIFIER = ["identifier"]

wrench/languages/cpp_rules.py

@@ -0,0 +1,10 @@
+LOOP_TYPES = ["for_statement", "while_statement", "do_statement", "range_based_for_statement"]
+FUNCTION_CALL = ["call_expression"]
+FUNCTION_DEF = ["function_definition"]
+ATTRIBUTE_ACCESS = ["field_expression"]
+STRING_CONCAT = ["assignment_expression"]
+EXCEPTION_HANDLER = ["catch_clause"]
+GLOBAL_STATEMENT = ["declaration"]
+IMPORT = ["preproc_include", "using_declaration"]
+LIST_CONCAT = ["binary_expression"]
+IDENTIFIER = ["identifier"]

wrench/languages/go_rules.py

@@ -0,0 +1,10 @@
+LOOP_TYPES = ["for_statement"]
+FUNCTION_CALL = ["call_expression"]
+FUNCTION_DEF = ["function_declaration", "method_declaration"]
+ATTRIBUTE_ACCESS = ["selector_expression"]
+STRING_CONCAT = ["assignment_statement"]
+EXCEPTION_HANDLER = ["defer_statement"]
+GLOBAL_STATEMENT = ["var_declaration"]
+IMPORT = ["import_declaration", "import_spec"]
+LIST_CONCAT = ["binary_expression"]
+IDENTIFIER = ["identifier"]

wrench/languages/javascript_rules.py

@@ -0,0 +1,11 @@
+LOOP_TYPES = ["for_statement", "for_in_statement", "for_of_statement", "while_statement"]
+FUNCTION_CALL = ["call_expression"]
+FUNCTION_DEF = ["function_declaration", "arrow_function", "function_expression"]
+ATTRIBUTE_ACCESS = ["member_expression"]
+STRING_CONCAT = ["augmented_assignment_expression"]
+EXCEPTION_HANDLER = ["catch_clause"]
+GLOBAL_STATEMENT = []
+IMPORT = ["import_statement", "import_declaration"]
+LIST_CONCAT = ["binary_expression"]
+AWAIT = ["await_expression"]
+IDENTIFIER = ["identifier"]

wrench/languages/python_rules.py

@@ -0,0 +1,11 @@
+LOOP_TYPES = ["for_statement", "while_statement"]
+FUNCTION_CALL = ["call"]
+FUNCTION_DEF = ["function_definition"]
+ATTRIBUTE_ACCESS = ["attribute"]
+STRING_CONCAT = ["augmented_assignment"]
+EXCEPTION_HANDLER = ["except_clause"]
+GLOBAL_STATEMENT = ["global_statement"]
+IMPORT = ["import_statement", "import_from_statement"]
+LIST_CONCAT = ["binary_operator"]
+AWAIT = ["await_expression"]
+IDENTIFIER = ["identifier"]

wrench/languages/typescript_rules.py

@@ -0,0 +1,11 @@
+LOOP_TYPES = ["for_statement", "for_in_statement", "for_of_statement", "while_statement"]
+FUNCTION_CALL = ["call_expression"]
+FUNCTION_DEF = ["function_declaration", "arrow_function", "function_expression", "method_definition"]
+ATTRIBUTE_ACCESS = ["member_expression"]
+STRING_CONCAT = ["augmented_assignment_expression"]
+EXCEPTION_HANDLER = ["catch_clause"]
+GLOBAL_STATEMENT = []
+IMPORT = ["import_statement", "import_declaration"]
+LIST_CONCAT = ["binary_expression"]
+AWAIT = ["await_expression"]
+IDENTIFIER = ["identifier"]

wrench/main.py

@@ -0,0 +1,216 @@
+import sys
+import os
+import threading
+from detectors.high import HighDetectors
+from detectors.medium import MediumDetectors
+from ai_engine import analyse, get_fixed_code, analyse_folder as analyse_folder_ai
+from parser_engine import get_parser, detect_language
+from ir_translator import IRTranslator
+from profilers.profiler import profile_file, parse_stats, write_temp_file, delete_temp_file
+from errors import handle_error
+from wrenchignore import load_wrenchignore, is_ignored
+from reports import print_summary, print_profiling, ask_and_analyse, ask_and_apply_fixes, save_report
+
+IGNORE_DIRS = {"venv", "node_modules", ".git", "__pycache__", "dist", "build", ".vscode"}
+
+def get_rules(language):
+    if language == "python":
+        import languages.python_rules as rules
+    elif language == "javascript":
+        import languages.javascript_rules as rules
+    elif language == "typescript":
+        import languages.typescript_rules as rules
+    elif language == "go":
+        import languages.go_rules as rules
+    elif language == "c":
+        import languages.c_rules as rules
+    elif language == "cpp":
+        import languages.cpp_rules as rules
+    else:
+        return None
+    return rules
+
+def run_analysis(filepath):
+    # wrenchignore check
+    patterns = load_wrenchignore(os.path.dirname(filepath))
+    if is_ignored(filepath, patterns):
+        return [], None, None
+
+    # language check
+    language = detect_language(filepath)
+    if language is None:
+        handle_error("unsupported_language", filepath)
+        return [], None, None
+
+    # file reading
+    try:
+        with open(filepath, "r", encoding="utf8") as f:
+            code = f.read()
+    except FileNotFoundError:
+        handle_error("file_not_found", filepath, fatal=True)
+    except PermissionError:
+        handle_error("permission_error", filepath)
+        return [], None, None
+    except UnicodeDecodeError:
+        handle_error("binary_file", filepath)
+        return [], None, None
+
+    # empty file check
+    if not code.strip():
+        handle_error("empty_file", filepath)
+        return [], None, None
+
+    # parsing
+    try:
+        rules = get_rules(language)
+        parser = get_parser(language)
+        tree = parser.parse(bytes(code, "utf8"))
+        translator = IRTranslator(rules)
+        ir_tree = translator.translate(tree.root_node)
+    except Exception:
+        handle_error("syntax_error", filepath)
+        return [], None, None
+
+    warnings = []
+    for DetectorClass in [HighDetectors, MediumDetectors]:
+        detector = DetectorClass()
+        detector.visit(ir_tree)
+        if hasattr(detector, 'check_attr_counts'):
+            detector.check_attr_counts()
+        warnings.extend(detector.warnings)
+
+    return warnings, language, code
+
+def get_files(folder):
+    patterns = load_wrenchignore(folder)
+    files = []
+    for root, dirs, filenames in os.walk(folder):
+        dirs[:] = [d for d in dirs if d not in IGNORE_DIRS]
+        for f in filenames:
+            filepath = os.path.join(root, f)
+            if detect_language(f) is not None and not is_ignored(filepath, patterns):
+                files.append(filepath)
+    return files
+
+def analyse_single_file(filename):
+    warnings, language, code = run_analysis(filename)
+
+    if language is None:
+        return
+
+    if not warnings:
+        print("No issues found!")
+        return
+
+    # print summary
+    print_summary(1, {language}, {filename: warnings})
+
+    # print warnings
+    print("\n--- Warnings ---\n")
+    for w in warnings:
+        print(f"  {w}")
+
+    results = {}
+
+    def run_profiling():
+        try:
+            if language != "python":
+                results["profiling"] = None
+                return
+
+            before_raw = profile_file(filename)
+            before_stats = parse_stats(before_raw)
+
+            fixed_code = get_fixed_code(code, warnings)
+            temp_file = write_temp_file(fixed_code, filename)
+            after_raw = profile_file(temp_file)
+            after_stats = parse_stats(after_raw)
+            delete_temp_file(temp_file)
+
+            results["before"] = before_stats
+            results["after"] = after_stats
+
+        except Exception:
+            handle_error("profiling_error", filename)
+            results["profiling"] = None
+
+    t = threading.Thread(target=run_profiling)
+    t.start()
+    t.join()
+
+    # profiling output
+    if results.get("profiling") is None and language != "python":
+        print("\n--- Profiling not supported for this language yet ---")
+    elif results.get("before") and results.get("after"):
+        print_profiling(results["before"], results["after"])
+
+    # AI analysis — ask user
+    ask_and_analyse(code, warnings)
+
+    # apply fixes — ask user
+    ask_and_apply_fixes(code, warnings, filename)
+
+    # save report — ask user
+    save_report(1, {language}, {filename: warnings})
+
+def analyse_folder(folder):
+    files = get_files(folder)
+
+    if not files:
+        print("No supported files found in folder.")
+        return
+
+    all_results = {}
+    languages = set()
+    for file in files:
+        warnings, language, code = run_analysis(file)
+        if language:
+            languages.add(language)
+        if warnings:
+            all_results[file] = warnings
+
+    if not all_results:
+        print("No issues found across all files!")
+        return
+
+    # print summary
+    print_summary(len(files), languages, all_results)
+
+    # print warnings per file
+    print("\n--- Warnings ---\n")
+    for file, warnings in all_results.items():
+        print(f"--- {file} ---")
+        for w in warnings:
+            print(f"  {w}")
+        print()
+
+    # AI analysis — one call for whole folder, ask user
+    analysis = None
+    choice = input("\nWant AI analysis? (y/n): ").strip().lower()
+    if choice == 'y':
+        try:
+            analysis = analyse_folder_ai(all_results)
+            print("\n--- AI Analysis ---\n")
+            print(analysis)
+        except Exception:
+            handle_error("api_error", folder)
+
+    # save report — ask user
+    save_report(len(files), languages, all_results, analysis=analysis)
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: codewrench <filename or folder>")
+        exit()
+
+    target = sys.argv[1]
+
+    if os.path.isdir(target):
+        analyse_folder(target)
+    elif os.path.isfile(target):
+        analyse_single_file(target)
+    else:
+        handle_error("file_not_found", target, fatal=True)
+
+if __name__ == "__main__":
+    main()

wrench/parser_engine.py

@@ -0,0 +1,34 @@
+from tree_sitter import Language, Parser
+import tree_sitter_python as tspython
+import tree_sitter_javascript as tsjavascript
+import tree_sitter_typescript as tstypescript
+import tree_sitter_go as tsgo
+import tree_sitter_c as tsc
+import tree_sitter_cpp as tscpp
+
+LANGUAGES = {
+    "python": Language(tspython.language()),
+    "javascript": Language(tsjavascript.language()),
+    "typescript": Language(tstypescript.language_typescript()),
+    "go": Language(tsgo.language()),
+    "c": Language(tsc.language()),
+    "cpp": Language(tscpp.language()),
+}
+
+def get_parser(language) :
+    parser = Parser(LANGUAGES[language])
+    return parser
+
+def detect_language(filename):
+    ext = filename.split(".")[-1]
+    mapping = {
+        "py": "python",
+        "js": "javascript",
+        "ts": "typescript",
+        "go": "go",
+        "c": "c",
+        "cpp": "cpp",
+        "cc": "cpp",
+    }
+    return mapping.get(ext, None)
+

wrench/profilers/profiler.py

@@ -0,0 +1,44 @@
+import os
+import sys
+import subprocess
+
+def profile_file(filename):
+    result = subprocess.run(
+        [sys.executable, "-m", "cProfile", "-s", "cumulative", filename],
+        capture_output= True,
+        text= True,
+        cwd=os.path.dirname(os.path.abspath(filename))
+    )
+    return result.stdout
+
+def parse_stats(raw_output):
+    lines = raw_output.strip().split("\n")
+    stats = []
+    for line in lines[4:]:
+        parts = line.split()
+        if len(parts) >= 6:
+            try:
+                float(parts[1])  
+                float(parts[3])  
+                function = " ".join(parts[5:])
+                if not function.startswith("{"):  
+                    stats.append({
+                        "ncalls": parts[0],
+                        "tottime": parts[1],
+                        "cumtime": parts[3],
+                        "function": function
+                    })
+            except ValueError:
+                continue
+    return stats
+
+def write_temp_file(code, original_filename):
+    temp_file = original_filename.replace("py", "_wrench_temp.py")
+    with open(temp_file, "w") as f:
+        f.write(code)
+    return temp_file
+
+def delete_temp_file(temp_filename):
+    if os.path.exists(temp_filename):
+        os.remove(temp_filename)
+

wrench/reports.py

@@ -0,0 +1,72 @@
+from ai_engine import analyse, get_fixed_code
+
+def print_summary(files_scanned, languages, all_results):
+    total_issues = sum(len(w) for w in all_results.values())
+    print("=" * 40)
+    print("CODEWRENCH REPORT".center(40))
+    print("=" * 40)
+    print(f"Files Scanned  : {files_scanned}")
+    print(f"Languages      : {', '.join(languages)}")
+    print(f"Issues Found   : {total_issues} across {len(all_results)} files")
+    print("=" * 40)
+
+def print_profiling(before_stats, after_stats):
+    print("Top 5 slowest functions BEFORE fix:")
+    for stat in before_stats[:5]:
+        func = stat['function'].split(":")[-1]
+        print(f"  {func:<30} cumtime: {stat['cumtime']}s")
+
+    print("\nTop 5 slowest functions AFTER fix:")
+    for stat in after_stats[:5]:
+        func = stat['function'].split(":")[-1]
+        print(f"  {func:<30} cumtime: {stat['cumtime']}s")
+
+def ask_and_analyse(code, warnings):
+    choice = input("\nWant AI analysis? (y/n): ").strip().lower()
+    if choice == 'y':
+        print("\n--- AI Analysis ---\n")
+        result = analyse(code, warnings)
+        print(result)
+
+def ask_and_apply_fixes(code, warnings, filepath):
+    choice = input("\nWant to apply fixes to files? (y/n): ").strip().lower()
+    if choice == 'y':
+        fixed_code = get_fixed_code(code, warnings)
+        with open(filepath + ".bak", "w", encoding="utf8") as f:
+            f.write(code)
+        with open(filepath, "w", encoding="utf8") as f:
+            f.write(fixed_code)
+        print(f"Original saved as {filepath}.bak")
+        print(f"Fixes applied to {filepath}")
+
+def save_report(files_scanned, languages, all_results, analysis=None):
+    choice = input("\nSave report? (y/n): ").strip().lower()
+    if choice != 'y':
+        return
+
+    total_issues = sum(len(w) for w in all_results.values())
+    
+    with open("codewrench_report.md", "w", encoding="utf8") as f:
+        # header
+        f.write("# Codewrench Report\n\n")
+        f.write(f"**Files Scanned:** {files_scanned}\n\n")
+        f.write(f"**Languages:** {', '.join(languages)}\n\n")
+        f.write(f"**Issues Found:** {total_issues} across {len(all_results)} files\n\n")
+        f.write("---\n\n")
+
+        # warnings per file
+        f.write("## Warnings\n\n")
+        for filepath, warnings in all_results.items():
+            f.write(f"### {filepath}\n\n")
+            for w in warnings:
+                f.write(f"- {w}\n")
+            f.write("\n")
+
+        # AI analysis
+        if analysis:
+            f.write("---\n\n")
+            f.write("## AI Analysis\n\n")
+            f.write(analysis)
+            f.write("\n")
+
+    print("Report saved to codewrench_report.md")

wrench/wrenchignore.py

@@ -0,0 +1,25 @@
+import os
+import fnmatch
+
+def load_wrenchignore(root):
+    patterns = []
+    try:
+        with open(os.path.join(root, ".wrenchignore"), 'r', encoding="utf8") as f:
+            for line in f:
+                line = line.strip()
+                if not line or line.startswith('#'):
+                    continue
+                patterns.append(line)
+    except FileNotFoundError:
+        pass
+    return patterns
+
+def is_ignored(filepath, patterns):
+    filename = os.path.basename(filepath)
+    for pattern in patterns:
+        if pattern.endswith('/'):
+            if pattern.rstrip('/') in filepath.split(os.sep):
+                return True
+        elif fnmatch.fnmatch(filename, pattern):
+            return True
+    return False