aidbg-cli 0.1.0__tar.gz

aidbg_cli-0.1.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: aidbg-cli
+Version: 0.1.0
+Summary: Multi-language AI code debugger using local LLM
+Author-email: Piyush Maheshwari <maheshwaripiyush846@gmail.com>
+License: MIT
+Keywords: AI,debugger,code,LLM,developer-tools
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# aidbg — AI Code Debugger
+
+Multi-language AI debugger powered by local LLM (DeepSeek via Ollama).
+
+## Features
+
+- Fix Python, C, C++, Java, JavaScript
+- Compiler-level validation
+- Safe fix with automatic backup
+- VS Code integration
+- Works offline
+
+## Install
+
+```bash
+pip install aidbg

aidbg_cli-0.1.0/README.md

@@ -0,0 +1,16 @@
+# aidbg — AI Code Debugger
+
+Multi-language AI debugger powered by local LLM (DeepSeek via Ollama).
+
+## Features
+
+- Fix Python, C, C++, Java, JavaScript
+- Compiler-level validation
+- Safe fix with automatic backup
+- VS Code integration
+- Works offline
+
+## Install
+
+```bash
+pip install aidbg

aidbg_cli-0.1.0/agent/ai_client.py

@@ -0,0 +1,44 @@
+import os
+import subprocess
+def call_ai(prompt: str) -> str:
+    """
+    Call Ollama model safely using absolute path.
+    """
+
+    # HARD-SET absolute path (this is correct on your system)
+    ollama_path = r"C:\Users\91968\AppData\Local\Programs\Ollama\ollama.exe"
+
+    # Step 1: Verify executable exists
+    if not os.path.isfile(ollama_path):
+        print("CRITICAL ERROR: Ollama executable not found at:")
+        print(ollama_path)
+        return ""
+
+    try:
+
+        # Step 2: Run Ollama model
+        result = subprocess.run(
+            [ollama_path, "run", "deepseek-coder:6.7b"],
+            input=prompt,
+            text=True,
+            capture_output=True,
+            encoding="utf-8",
+            timeout=120
+        )
+
+        # Step 3: Debug info
+        print("DEBUG return code:", result.returncode)
+        print("DEBUG stderr:", result.stderr)
+
+        # Step 4: Check failure
+        if result.returncode != 0:
+            print("ERROR: Ollama execution failed")
+            return ""
+
+        # Step 5: Return clean output
+        return result.stdout.strip()
+
+    except Exception as e:
+        print("CRITICAL ERROR:", str(e))
+        return ""
+     

aidbg_cli-0.1.0/agent/compiler_validator.py

@@ -0,0 +1,114 @@
+import subprocess
+import tempfile #this creates temporary file for compiler validation because compiler only accepts file
+from pathlib import Path
+import os
+
+def validate_python(code:str)->bool:
+    try:
+        compile(code,"<string>","exec")
+        return True
+    except SyntaxError:
+        return False
+
+
+def validate_javascript(code:str)->bool:
+    try:
+        result =subprocess.run(
+            ["node","--check"],
+            input=code,
+            text=True,
+            capture_output=True
+        )
+        return result.returncode == 0
+    
+    except FileNotFoundError:
+        print("Validator error : Node.js not installed")
+        return False
+
+def validate_c(code: str)->bool:
+    try:
+        with tempfile.NamedTemporaryFile(suffix=".c",delete=False,mode="w",encoding="utf-8") as f:
+            f.write(code)
+            temp_path =f.name
+
+        result = subprocess.run(
+            ["gcc", "-fsyntax-only",temp_path],
+            capture_output=True,
+            text=True,
+        ) 
+        os.remove(temp_path)
+
+        return result.returncode == 0
+    
+    except FileNotFoundError:
+        print("validator Error: GCC not installed")
+        return False
+    
+def validate_cpp(code:str)->bool:
+    try:
+        with tempfile.NamedTemporaryFile(suffix=".cpp",delete=False, mode="w" ,encoding ="utf-8") as f:
+            f.write(code)
+            temp_path =f.name
+
+        result = subprocess.run(
+            ["g++", "-fsyntax-only",temp_path],
+            capture_output=True,
+            text=True
+        )
+        print("DEBUG g++ return code:", result.returncode)
+        print("DEBUG g++ stderr:", result.stderr)
+        os.remove(temp_path)
+
+        return result.returncode == 0
+    
+    except FileNotFoundError:
+        print("validor error:G++ not installed")
+        return False
+    
+
+def validate_java(code:str)->bool:
+    try:
+        with tempfile.NamedTemporaryFile(suffix=".java", delete=False, mode="w", encoding="utf-8") as f:
+            f.write(code)
+            temp_path = f.name
+
+
+        result = subprocess.run(
+            ["javac",temp_path],
+            capture_output=True,
+            text = True
+
+        )
+        os.remove(temp_path)
+        return result.returncode ==0
+    
+    except FileNotFoundError:
+        print("Validator error:Java JDK not installed")
+        return False
+    
+
+def validate_code(code:str, language:str)->bool:
+
+    language=language.lower()
+
+    if language == "python":
+        return validate_python(code)
+    
+    elif language=="javascript":
+        return validate_javascript(code)
+    
+    elif language=="c":
+        return validate_c(code)
+    
+    elif language =="c++":
+        return validate_cpp(code)
+    
+    elif language == "java":
+        return validate_java(code)
+    
+    else:
+        print(f"No Validator available for{language}")
+        return True
+
+
+        

aidbg_cli-0.1.0/agent/error_classifier.py

@@ -0,0 +1,14 @@
+def classify_error(code:str)->str:
+    code_lower = code.lower()
+
+    if "def" in code_lower and ":" not in code_lower:
+        return "Possible Python syntax error(missing colon)"
+    
+    if "while(true)" in code_lower:
+        return "Possible infinite Loop"
+    
+    if "int" in code_lower and ";" not in code_lower:
+        return "Possible missing semicolon"
+    
+    return "Unknown or Logical error"
+    

aidbg_cli-0.1.0/agent/extractor.py

@@ -0,0 +1,52 @@
+def extract_fixed_code(ai_output: str) -> str | None:
+    """
+    Extract the fixed code section from AI output.
+    Supports markdown and plain text.
+    Removes markdown language labels like python, cpp, c++, java, js.
+    """
+
+    if "FIXED CODE:" not in ai_output:
+        return None
+
+    # Step 1: get everything after FIXED CODE:
+    fixed_section = ai_output.split("FIXED CODE:", 1)[1].strip()
+
+
+    # Step 2: handle markdown code blocks
+    if "```" in fixed_section:
+
+        parts = fixed_section.split("```")
+
+        if len(parts) >= 2:
+
+            code_block = parts[1].strip()
+
+            lines = code_block.splitlines()
+
+            # Step 3: remove language label line
+            if lines:
+
+                first_line = lines[0].strip().lower()
+
+                language_labels = [
+                    "python",
+                    "cpp",
+                    "c++",
+                    "c",
+                    "java",
+                    "javascript",
+                    "js"
+                ]
+
+                if first_line in language_labels:
+                    lines = lines[1:]
+
+            code_block = "\n".join(lines)
+
+            return code_block.strip()
+
+
+    # Step 4: fallback plain text
+    fixed_section = fixed_section.strip()
+
+    return fixed_section if fixed_section else None

aidbg_cli-0.1.0/agent/fixer.py

@@ -0,0 +1,21 @@
+from pathlib import Path
+def apply_fix(file_path: str, fixed_code: str):
+     '''
+     Docstring for apply_fix\
+     Safely apply fix:
+     create backup 
+     overwrite original file
+    
+     '''
+     original = Path(file_path) #Path object is safer than plain string.
+    
+     backup = original.with_suffix(original.suffix + ".bak") #test.py → test.py.bak Now backup file path is ready
+     
+     backup.write_text(original.read_text(encoding="utf-8"),encoding="utf-8") #This is very important | this creates backup file.
+
+     original.write_text(fixed_code, encoding="utf-8") #This overwrited original file with fixed code
+
+     print(f"Fix applied successfully")
+
+     print(f"Backup created at :{backup}") # this shows backup file location
+

aidbg_cli-0.1.0/agent/language_detector.py

@@ -0,0 +1,34 @@
+from pathlib import Path #help us to work with file name safely
+
+def detect_language(code:str, filename: str |None = None) ->str:
+    if filename:
+        suffix=Path(filename).suffix.lower()
+        if suffix ==".py":
+            return "Python"
+        if suffix == ".js":
+            return "Javascript"
+        if suffix in[".cpp",".cc",".ccx"]:
+            return "C++"
+        if suffix ==".c":
+            return "C"
+        if suffix == ".java":
+            return "Java"
+    
+    code_lower=code.lower()
+    if "def" in code_lower:
+        return "Python"
+    if "#include" in code_lower:
+        return "C/C++"
+    if "public static void main" in code_lower:
+        return "Java"
+    if "console.log" in code_lower:
+        return "Javascript"
+    
+    return "Unknown"
+
+'''
+Do we have filename?
+    Yes → Check extension → Return language
+    No  → Check code text → Return language
+If nothing matches → Return Unknown
+'''

aidbg_cli-0.1.0/agent/retry.py

@@ -0,0 +1,65 @@
+from agent.compiler_validator import validate_code
+from agent.extractor import extract_fixed_code
+
+def retry_fix(call_ai, build_prompt, code, language,error_type,filename ,max_attempts=4):
+    attempt =1
+    while attempt<= max_attempts:
+        print(f"attempt {attempt} of {max_attempts}")
+
+        prompt=build_prompt(code,language, error_type)
+
+        output = call_ai(prompt)
+        print("\nDebug : RAW AI OUTPUT \n")
+        print( output)
+        print("\nDebug end\n")
+
+        fixed_code= extract_fixed_code(output)
+
+        if not fixed_code:
+            print("Could not extract fix from AI response")
+            attempt += 1
+            continue #skip ramaining steps go to next attempt
+        valid = validate_code(fixed_code,language)
+
+        if valid:
+            print("valid fix found")
+            return fixed_code
+        print("Invalid fix: compiler validtion failed")
+
+        code =fixed_code # It upadates input code for next attempt Instead of retrying original broken code, agent retries improved version.
+
+        attempt += 1
+    return None    
+
+
+'''
+roken code:
+
+def add(a,b)
+    return a+b
+
+
+Agent flow:
+
+Attempt 1
+LLM fix invalid
+retry
+
+Attempt 2
+LLM fix valid
+return fixed_code
+
+Why retry loop makes this a real agent
+
+Without retry:
+
+LLM fails → agent fails
+
+
+With retry:
+
+LLM fails → agent retries → succeeds
+
+
+Agent becomes persistent.
+'''

aidbg_cli-0.1.0/agent/validator.py

@@ -0,0 +1,8 @@
+def validate_python_syntax(code: str, filename: str ="<string>")-> tuple[bool,str | None]:
+    try:
+        compile(code, filename, "exec") #this tell python check if this code is valid syntax
+        return True, None
+    except SyntaxError as e:
+        return False, f"{e.msg} at line {e.lineno}" # returns expected ':' at line 1"
+    except Exception as e: # it catches any unexpected error
+        return False ,str(e)

aidbg_cli-0.1.0/aidbg.py

@@ -0,0 +1,224 @@
+import argparse #handle CLI argument
+import subprocess #talk to OLLama
+import sys #read stdin
+import os
+import shutil
+from pathlib import Path #Safe file handling
+from agent.validator import validate_python_syntax
+from agent.language_detector import detect_language # for early language detection
+from agent.error_classifier import classify_error #for the early error classficattiono
+from agent.extractor import extract_fixed_code
+from agent.retry import retry_fix
+from agent.ai_client import call_ai
+from agent.fixer import apply_fix
+from agent.compiler_validator import validate_code
+
+def get_arguments():
+    parser =argparse.ArgumentParser(
+        description="AI Code Debugger(Free,Local)"
+    )
+
+    
+    parser.add_argument(
+        "file",
+        nargs="?",
+        help="Path to Code file"
+
+    )
+    parser.add_argument(
+        "--stdin",
+        action="store_true",
+        help="Read code from standard input"
+    )
+    parser.add_argument(
+         "--fix",
+         action="store_true",
+         help="Automatically apply the suggested fix(safe mode with backup)"
+    )
+
+    return parser.parse_args() #Reads terminal input Validates arguments Converts them into object Returns structured result
+
+
+def  read_code(args):
+    if args.stdin:
+        return sys.stdin.read()
+    if args.file:
+        path = Path(args.file)
+
+        if not path.exists():
+               
+               print("File not Found")
+               sys.exit(1) #  1 menas failur or error code
+        return path.read_text(encoding ="utf-8")
+    print ("provide a file or use --stdin")
+    sys.exit(1)
+    
+        
+
+def build_prompt(code: str, language: str, error_type: str)-> str :
+     template = Path("prompts/debugger.txt").read_text(encoding="utf-8")
+     structured_context = f"""
+     Detected Language: {language}
+     Pre-analysis Result: {error_type}
+
+     CODE:
+     {code}
+     """
+     return template.replace("{code}", structured_context)
+
+
+def main():
+     args=get_arguments()
+     code = read_code(args)
+     print(f"File being processed : {args.file}")
+     language = detect_language(code, args.file)
+     error_type = classify_error(code)
+
+     print(f" Detected Language: {language}")
+     print(f"Pre-analysis:{error_type}")
+     print("Debuggin......\n")
+
+     prompt= build_prompt(code,language,error_type)
+     output= call_ai(prompt)
+
+     print("Result:\n")
+     print(output)
+
+     if args.fix and args.file:
+          print("\n Applying fix in safe mode...")
+
+          fixed_code= retry_fix(call_ai,
+                                build_prompt,
+                                code,
+                                language,
+                                error_type,
+                                args.file,
+                                max_attempts=4
+                                )
+          if fixed_code is None:
+               print(" NO error found or Failed to generate valid after multiple attempts")
+               return
+
+          is_valid = validate_code(fixed_code,language)
+
+          if not is_valid:
+               print("fix failed compiler validatioin")
+               print("Original file preserved")
+               return
+          apply_fix(args.file, fixed_code)
+          
+          print("Syntax validation passed. Fix applied successfully")
+if __name__=="__main__":
+     main()
+'''strip() removes extra: Spaces New lines It ccleans the output before returning '''
+
+    
+'''Your code builds a:p
+
+Command-Line AI Debugger Tool
+that reads code → sends it to a local AI model → prints debugging output.
+
+It is:
+
+ CLI-based
+
+ IDE-independent
+
+ Local (offline AI)
+
+ Modular
+ 
+  User (Terminal)
+        ↓
+get_arguments()
+        ↓
+read_code()
+        ↓
+build_prompt()
+        ↓
+call_ai()
+        ↓
+print result 
+
+read_code function works for :
+If stdin → read from stdin
+Else if file → check file exists → read file
+Else → show error and exit
+Decides where the code comes from, reads it safely, and returns it.
+
+build prompt:
+this function build a very  structured analysis
+Detected Language: Python
+Pre-analysis Result: Possible Python syntax error
+
+CODE:
+def add(a,b)
+    return a+b
+    
+    Simple Summary of call_ai()
+
+This function:
+
+Takes prompt
+   ↓
+Runs Ollama
+   ↓
+Sends prompt to model
+   ↓
+Receives AI answer
+   ↓
+Returns cleaned result
+
+extract_fixed_code():
+This is very important function
+
+
+# Why This Function Is Critical
+
+Without this function:
+
+Your program cannot safely extract fixed code.
+
+AI output contains:
+
+- explanation
+- markdown
+- extra text
+
+This function extracts only usable code.
+
+---
+
+# Visual Flow
+
+AI Output
+↓
+Find "FIXED CODE:"
+↓
+Extract section
+↓
+Remove markdown
+↓
+Return clean code
+
+apply fix:
+this is the function which enable agentic behaviour
+
+Original file → read content
+             ↓
+Create backup file
+             ↓
+Write fixed code to original file
+             ↓
+Show success message
+Why Backup Is Critical
+Without backup:
+
+If AI makes mistake → original file lost.
+
+With backup:
+
+You can restore original anytime.
+
+Professional tools ALWAYS create backups.
+'''

aidbg_cli-0.1.0/aidbg_cli.egg-info/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: aidbg-cli
+Version: 0.1.0
+Summary: Multi-language AI code debugger using local LLM
+Author-email: Piyush Maheshwari <maheshwaripiyush846@gmail.com>
+License: MIT
+Keywords: AI,debugger,code,LLM,developer-tools
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# aidbg — AI Code Debugger
+
+Multi-language AI debugger powered by local LLM (DeepSeek via Ollama).
+
+## Features
+
+- Fix Python, C, C++, Java, JavaScript
+- Compiler-level validation
+- Safe fix with automatic backup
+- VS Code integration
+- Works offline
+
+## Install
+
+```bash
+pip install aidbg

aidbg_cli-0.1.0/aidbg_cli.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+aidbg.py
+pyproject.toml
+agent/__init__.py
+agent/ai_client.py
+agent/compiler_validator.py
+agent/error_classifier.py
+agent/extractor.py
+agent/fixer.py
+agent/language_detector.py
+agent/retry.py
+agent/validator.py
+aidbg_cli.egg-info/PKG-INFO
+aidbg_cli.egg-info/SOURCES.txt
+aidbg_cli.egg-info/dependency_links.txt
+aidbg_cli.egg-info/entry_points.txt
+aidbg_cli.egg-info/top_level.txt

aidbg_cli-0.1.0/aidbg_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aidbg_cli-0.1.0/aidbg_cli.egg-info/entry_points.txt

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

aidbg_cli-0.1.0/aidbg_cli.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+agent
+aidbg

aidbg_cli-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aidbg-cli"
+version = "0.1.0"
+description = "Multi-language AI code debugger using local LLM"
+authors = [
+    { name = "Piyush Maheshwari", email = "maheshwaripiyush846@gmail.com" }
+]
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+
+keywords = ["AI", "debugger", "code", "LLM", "developer-tools"]
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+
+[tool.setuptools]
+packages = ["agent"]
+py-modules = ["aidbg"]
+
+[tool.setuptools.package-data]
+"*" = ["*.txt"]
+
+[project.scripts]
+aidbg = "aidbg:main"

aidbg_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+