smart-code-assistant 0.1.0__tar.gz

smart_code_assistant-0.1.0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: smart-code-assistant
+Version: 0.1.0
+Summary: A CLI tool to explain, debug, test and optimize code using LLM
+Author-email: Deepak Kambala <deepakkambala21@gmail.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: typer
+Requires-Dist: ollama
+
+# Smart Code Assistant CLI
+
+## Short Description
+Smart Code Assistant CLI helps beginners debug, optimize, explain, and generate tests for Python code instantly, powered by an offline **Ollama 3.21B** model. It keeps developers focused by providing AI-powered solutions directly in the project directory.
+
+## Features
+- **Code Debugger** – Automatically detects issues in your code and generates a text file with suggestions.
+- **Code Optimizer** – Analyzes your code and suggests more efficient alternatives in a separate file.
+- **Code Explainer** – Provides clear explanations of your code logic up to a specific point.
+- **Test Generator** – Generates sample test cases to validate correctness and handle edge cases.
+- **Offline Support** – Powered by Ollama 3.21B, works entirely offline without internet dependency.
+- **Fast Execution** – Commands execute in 2–3 seconds (network optional) for instant feedback.
+
+## How It Works
+1. Execute a custom command (e.g., `debug`) in your terminal.
+2. Your code is sent to the **Ollama LLM** for processing.
+3. The generated output (debugged code, optimized version, explanation, or tests) is saved as a text file in your project folder.
+4. No need to switch tools—stay focused and reduce attention residue.
+
+## Supported Commands
+| Command        | Description |
+|----------------|-------------|
+| `debug`        | Debugs your code and writes suggestions to a file. |
+| `optimize`     | Suggests improvements for efficiency. |
+| `explain`      | Explains your code logic clearly. |
+| `generate-test`| Creates sample test cases for validation. |
+
+## Tech Stack
+- Python
+- Ollama 3.21B LLM (offline)
+- Windows PowerShell (custom CLI commands)

smart_code_assistant-0.1.0/README.md

@@ -0,0 +1,31 @@
+# Smart Code Assistant CLI
+
+## Short Description
+Smart Code Assistant CLI helps beginners debug, optimize, explain, and generate tests for Python code instantly, powered by an offline **Ollama 3.21B** model. It keeps developers focused by providing AI-powered solutions directly in the project directory.
+
+## Features
+- **Code Debugger** – Automatically detects issues in your code and generates a text file with suggestions.
+- **Code Optimizer** – Analyzes your code and suggests more efficient alternatives in a separate file.
+- **Code Explainer** – Provides clear explanations of your code logic up to a specific point.
+- **Test Generator** – Generates sample test cases to validate correctness and handle edge cases.
+- **Offline Support** – Powered by Ollama 3.21B, works entirely offline without internet dependency.
+- **Fast Execution** – Commands execute in 2–3 seconds (network optional) for instant feedback.
+
+## How It Works
+1. Execute a custom command (e.g., `debug`) in your terminal.
+2. Your code is sent to the **Ollama LLM** for processing.
+3. The generated output (debugged code, optimized version, explanation, or tests) is saved as a text file in your project folder.
+4. No need to switch tools—stay focused and reduce attention residue.
+
+## Supported Commands
+| Command        | Description |
+|----------------|-------------|
+| `debug`        | Debugs your code and writes suggestions to a file. |
+| `optimize`     | Suggests improvements for efficiency. |
+| `explain`      | Explains your code logic clearly. |
+| `generate-test`| Creates sample test cases for validation. |
+
+## Tech Stack
+- Python
+- Ollama 3.21B LLM (offline)
+- Windows PowerShell (custom CLI commands)

smart_code_assistant-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "smart-code-assistant"
+version = "0.1.0"
+description = "A CLI tool to explain, debug, test and optimize code using LLM"
+authors = [
+    { name="Deepak Kambala", email="deepakkambala21@gmail.com" }
+]
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "typer",
+    "ollama"
+]
+
+[project.scripts]
+smart-assist = "smart_code_assistant.cli:app"
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"

smart_code_assistant-0.1.0/setup.cfg

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

smart_code_assistant-0.1.0/smart_code_assistant/__init__.py

@@ -0,0 +1,7 @@
+
+#code_tool/                  # Root folder
+#├── src/                    # Source code
+#│   ├── __init__.py         # Empty file (makes it a package)
+#│   └── cli.py              # Main CLI entry point (all commands here)
+#├── pyproject.toml          # Project config (makes it installable)
+#└── README.md               # (Optional)

smart_code_assistant-0.1.0/smart_code_assistant/cli.py

@@ -0,0 +1,15 @@
+import typer
+from smart_code_assistant.explainer import explain
+from smart_code_assistant.test import generate 
+from smart_code_assistant.debug import debug
+from smart_code_assistant.optimize import optimize
+
+app = typer.Typer()
+
+app.command()(explain)
+app.command(name="test")(generate)
+app.command()(debug)
+app.command()(optimize)
+
+if __name__ == "__main__":
+    app()

smart_code_assistant-0.1.0/smart_code_assistant/debug.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+import subprocess
+from pathlib import Path
+import sys
+import typer
+
+app = typer.Typer()
+
+# Ensure UTF-8 encoding for Windows terminals
+sys.stdin.reconfigure(encoding="utf-8")
+sys.stdout.reconfigure(encoding="utf-8")
+
+
+def generate_debug_report(file_path: Path, model_name: str = "llama3.2:1b") -> str | None:
+    """
+    Generate a structured debug report for the given code file using Ollama.
+    """
+
+    try:
+        code_content = file_path.read_text(encoding="utf-8")
+
+        prompt = f"""You are a senior software engineer and debugging expert.
+
+Carefully analyze the following code.
+
+Your tasks:
+
+1. Detect syntax errors.
+2. Detect logical errors.
+3. Detect runtime errors.
+4. Identify bad practices or inefficiencies.
+5. Clearly explain each issue.
+6. Provide step-by-step solutions.
+7. Provide a fully corrected version of the entire code at the end.
+
+Format your response EXACTLY like this:
+
+=== ERRORS FOUND ===
+(List all issues clearly)
+
+=== SOLUTIONS ===
+(Explain how to fix them)
+
+=== CORRECTED CODE ===
+(Provide full corrected code)
+
+Here is the code to debug:
+
+{code_content}
+"""
+
+        typer.echo(f"🔍 Debugging {file_path} using model '{model_name}'...")
+
+        process = subprocess.Popen(
+            ["ollama", "run", model_name],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
+
+        stdout, stderr = process.communicate(input=prompt.encode("utf-8"))
+
+        stdout = stdout.decode("utf-8", errors="replace")
+        stderr = stderr.decode("utf-8", errors="replace")
+
+        if process.returncode != 0:
+            typer.secho(f"\n❌ Error running Ollama:\n{stderr}", fg=typer.colors.RED)
+            return None
+
+        return stdout
+
+    except Exception as e:
+        typer.secho(f"\n❌ An unexpected error occurred: {str(e)}", fg=typer.colors.RED)
+        return None
+
+
+def save_debug_report(file_path: Path, report: str) -> Path:
+    """
+    Save the debug report to a text file.
+    """
+    output_file = file_path.with_stem(file_path.stem + "_debug").with_suffix(".txt")
+    output_file.write_text(report, encoding="utf-8")
+
+    typer.secho(f"\n✅ Debug report saved to: {output_file}", fg=typer.colors.GREEN)
+    return output_file
+
+
+@app.command()
+def debug(
+    file: Path = typer.Argument(..., exists=True, readable=True, help="The code file to debug."),
+    model: str = typer.Option("llama3.2:1b", help="Ollama model to use.")
+):
+    """
+    Please review and debug the following code.
+
+If it contains any syntax errors, logical mistakes, runtime issues, or potential bugs, identify and explain them clearly.
+
+For each issue you find:
+- Explain why it is a problem.
+- Provide a clear solution.
+- Suggest improvements if applicable.
+
+After identifying and explaining all issues, provide a fully corrected version of the entire code.
+
+Then briefly describe the code’s purpose, main functions, and overall structure.
+
+Here is the code:
+
+{code_content}
+    """
+
+    report = generate_debug_report(file, model)
+
+    if report:
+        save_debug_report(file, report)
+    else:
+        typer.secho("⚠ Debugging failed.", fg=typer.colors.YELLOW)
+
+
+if __name__ == "__main__":
+    app()

smart_code_assistant-0.1.0/smart_code_assistant/explainer.py

@@ -0,0 +1,44 @@
+import os
+import subprocess
+import typer
+
+app = typer.Typer()
+
+@app.command()
+def explain(file: str, model: str = "llama3.2:1b"):
+    """Generate explanation for the code file"""
+    try:
+        with open(file, 'r', encoding='utf-8') as f:
+            code = f.read()
+
+        prompt = f"""Please explain the following code in detail.
+Describe its purpose, main functions, and key components.
+Be concise but thorough. Here's the code:
+
+{code}
+"""
+
+        process = subprocess.Popen(
+            ["ollama", "run", model],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
+
+        stdout, stderr = process.communicate(input=prompt.encode('utf-8'))
+        stdout = stdout.decode('utf-8')
+        stderr = stderr.decode('utf-8')
+
+        if process.returncode != 0:
+            typer.echo(f"Error: {stderr}")
+            raise typer.Exit(1)
+
+        output_file = os.path.splitext(file)[0] + "_explanation.txt"
+        with open(output_file, 'w', encoding='utf-8') as out:
+            out.write(stdout)
+
+        typer.echo(f"Explanation saved to {output_file}")
+
+    except Exception as e:
+        typer.echo(f"Exception: {e}")
+        raise typer.Exit(1)

smart_code_assistant-0.1.0/smart_code_assistant/optimize.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+import subprocess
+from pathlib import Path
+from typing import Optional
+import typer
+
+# Initialize Typer app
+app = typer.Typer()
+
+
+# ----------------------------------
+# Core Ollama Runner
+# ----------------------------------
+def run_ollama(prompt: str, model_name: str) -> Optional[str]:
+    """
+    Run Ollama with the given prompt and return the output.
+    """
+    try:
+        process = subprocess.Popen(
+            ["ollama", "run", model_name],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+
+        stdout, stderr = process.communicate(input=prompt.encode("utf-8"))
+
+        if process.returncode != 0:
+            typer.echo(f"[ERROR] Ollama error:\n{stderr.decode()}", err=True)
+            return None
+
+        return stdout.decode("utf-8", errors="replace")
+
+    except Exception as e:
+        typer.echo(f"[EXCEPTION] {str(e)}", err=True)
+        return None
+
+
+# ----------------------------------
+# Optimization Logic
+# ----------------------------------
+def generate_optimization(file_path: Path, model_name: str) -> Optional[str]:
+    """
+    Analyze and optimize the given code.
+    """
+
+    try:
+        typer.echo(f"Reading file: {file_path}")
+        code_content = file_path.read_text(encoding="utf-8")
+
+        prompt = f"""You are a senior performance engineer and algorithm expert.
+
+Analyze the following code strictly from an optimization perspective.
+
+Your tasks:
+
+1. Identify inefficiencies in time complexity.
+2. Identify memory inefficiencies.
+3. Suggest better algorithms if applicable.
+4. Suggest better data structures.
+5. Suggest more Pythonic or cleaner implementations.
+6. Suggest design improvements if relevant.
+7. Compare time and space complexity (before vs after).
+8. Provide a fully optimized version of the code.
+
+Do NOT explain basic functionality unless necessary.
+Focus only on performance, scalability, and clean design.
+
+Here is the code:
+
+{code_content}
+"""
+
+        typer.echo(f"Optimizing using model: {model_name}...")
+        return run_ollama(prompt, model_name)
+
+    except Exception as e:
+        typer.echo(f"[EXCEPTION] {str(e)}", err=True)
+        return None
+
+
+def save_output(file_path: Path, content: str) -> Path:
+    """
+    Save optimization output to file.
+    """
+    output_file = file_path.with_name(f"{file_path.stem}_optimized.txt")
+    output_file.write_text(content, encoding="utf-8")
+
+    typer.echo(f"[✓] Optimization saved to: {output_file}")
+    return output_file
+
+
+# ----------------------------------
+# CLI Command
+# ----------------------------------
+@app.command()
+def optimize(
+    file: str = typer.Argument(..., help="The code file to optimize"),
+    model: str = typer.Option("llama3.2:1b", help="Ollama model to use"),
+):
+    """
+    Optimize a code file by suggesting better algorithms,
+    data structures, and performance improvements.
+    """
+
+    resolved_path = Path(file).resolve()
+
+    if not resolved_path.is_file():
+        typer.echo(f"[ERROR] File not found: {resolved_path}", err=True)
+        raise typer.Exit(1)
+
+    optimization = generate_optimization(resolved_path, model)
+
+    if optimization:
+        save_output(resolved_path, optimization)
+
+
+# ----------------------------------
+# Entry Point
+# ----------------------------------
+if __name__ == "__main__":
+    app()

smart_code_assistant-0.1.0/smart_code_assistant/test.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+import os
+import subprocess
+import typer
+from typing import Optional
+
+app = typer.Typer(help="Edge Case Generator using Ollama")
+
+def generate_edge_cases(file_path: str, model_name: str = "llama3.2:1b") -> Optional[str]:
+    """
+    Generate comprehensive edge test cases using Ollama
+    """
+    try:
+        with open(file_path, 'r', encoding='utf-8') as file:
+            code_content = file.read()
+        
+        prompt = f"""Analyze the following code and generate comprehensive edge test cases.
+For each test case, include:
+1. Description of what edge case it tests
+2. Input values that would trigger this edge case
+3. Expected output/behavior
+4. Why this case is important to test
+
+Focus on:
+- Boundary conditions
+- Invalid inputs
+- Unusual scenarios
+- Race conditions (if applicable)
+- Memory edge cases
+- Error handling paths
+
+Format each test case clearly with numbered sections.
+Here's the code:
+
+{code_content}
+"""
+        typer.echo(f"🔍 Generating edge cases for [bold]{file_path}[/bold]...", color="blue")
+
+        process = subprocess.Popen(
+            ["ollama", "run", model_name],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            encoding='utf-8'
+        )
+
+        stdout, stderr = process.communicate(input=prompt)
+
+        if process.returncode != 0:
+            typer.echo(f"[red]❌ Error generating edge cases:\n{stderr}[/red]", err=True)
+            return None
+
+        return stdout
+
+    except FileNotFoundError:
+        typer.echo(f"[red]❌ Error: File '{file_path}' not found[/red]", err=True)
+        raise typer.Exit(1)
+    except Exception as e:
+        typer.echo(f"[red]❌ An error occurred: {str(e)}[/red]", err=True)
+        return None
+
+def save_edge_cases(file_path: str, edge_cases: str) -> str:
+    """Save edge cases to a text file with Markdown formatting"""
+    base_name = os.path.splitext(file_path)[0]
+    output_file = f"{base_name}_edge_cases.md"
+
+    with open(output_file, 'w', encoding='utf-8') as file:
+        file.write(f"# Edge Case Analysis for {os.path.basename(file_path)}\n\n")
+        file.write(edge_cases)
+
+    typer.echo(f"[green]✅ Edge cases saved to [bold]{output_file}[/bold][/green]")
+    return output_file
+
+@app.command()
+def generate(
+    file: str = typer.Argument(..., help="Path to the code file to analyze"),
+    model: str = typer.Option(
+        "llama3.2:1b",
+        "--model",
+        help="Ollama model to use",
+        show_default=True
+    ),
+    show: bool = typer.Option(
+        False,
+        "--show",
+        help="Display edge cases in console",
+        show_default=True
+    ),
+    markdown: bool = typer.Option(
+        True,
+        "--no-markdown",
+        help="Disable Markdown formatting",
+        show_default=True
+    )
+):
+    """
+    Generate comprehensive edge test cases for code analysis.
+    
+    Features:
+    - Boundary condition testing
+    - Invalid input scenarios
+    - Unusual usage patterns
+    - Detailed explanations for each case
+    """
+    edge_cases = generate_edge_cases(file, model)
+    
+    if edge_cases:
+        if not markdown:
+            base_name = os.path.splitext(file)[0]
+            output_file = f"{base_name}_edge_cases.txt"
+            with open(output_file, 'w', encoding='utf-8') as f:
+                f.write(edge_cases)
+        else:
+            output_file = save_edge_cases(file, edge_cases)
+        
+        if show:
+            typer.echo("\n🧪 Generated Edge Cases:", color="cyan")
+            typer.echo(edge_cases)
+
+if __name__ == "__main__":
+    app()

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

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: smart-code-assistant
+Version: 0.1.0
+Summary: A CLI tool to explain, debug, test and optimize code using LLM
+Author-email: Deepak Kambala <deepakkambala21@gmail.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: typer
+Requires-Dist: ollama
+
+# Smart Code Assistant CLI
+
+## Short Description
+Smart Code Assistant CLI helps beginners debug, optimize, explain, and generate tests for Python code instantly, powered by an offline **Ollama 3.21B** model. It keeps developers focused by providing AI-powered solutions directly in the project directory.
+
+## Features
+- **Code Debugger** – Automatically detects issues in your code and generates a text file with suggestions.
+- **Code Optimizer** – Analyzes your code and suggests more efficient alternatives in a separate file.
+- **Code Explainer** – Provides clear explanations of your code logic up to a specific point.
+- **Test Generator** – Generates sample test cases to validate correctness and handle edge cases.
+- **Offline Support** – Powered by Ollama 3.21B, works entirely offline without internet dependency.
+- **Fast Execution** – Commands execute in 2–3 seconds (network optional) for instant feedback.
+
+## How It Works
+1. Execute a custom command (e.g., `debug`) in your terminal.
+2. Your code is sent to the **Ollama LLM** for processing.
+3. The generated output (debugged code, optimized version, explanation, or tests) is saved as a text file in your project folder.
+4. No need to switch tools—stay focused and reduce attention residue.
+
+## Supported Commands
+| Command        | Description |
+|----------------|-------------|
+| `debug`        | Debugs your code and writes suggestions to a file. |
+| `optimize`     | Suggests improvements for efficiency. |
+| `explain`      | Explains your code logic clearly. |
+| `generate-test`| Creates sample test cases for validation. |
+
+## Tech Stack
+- Python
+- Ollama 3.21B LLM (offline)
+- Windows PowerShell (custom CLI commands)

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

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+smart_code_assistant/__init__.py
+smart_code_assistant/cli.py
+smart_code_assistant/debug.py
+smart_code_assistant/explainer.py
+smart_code_assistant/optimize.py
+smart_code_assistant/test.py
+smart_code_assistant.egg-info/PKG-INFO
+smart_code_assistant.egg-info/SOURCES.txt
+smart_code_assistant.egg-info/dependency_links.txt
+smart_code_assistant.egg-info/entry_points.txt
+smart_code_assistant.egg-info/requires.txt
+smart_code_assistant.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[console_scripts]
+smart-assist = smart_code_assistant.cli:app

smart_code_assistant-0.1.0/smart_code_assistant.egg-info/requires.txt

@@ -0,0 +1,2 @@
+typer
+ollama

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

@@ -0,0 +1 @@
+smart_code_assistant