skydeckai-code 0.1.29__py3-none-any.whl → 0.1.30__py3-none-any.whl

aidd/tools/__init__.py

@@ -65,6 +65,7 @@ from .git_tools import (
     handle_git_status,
 )
 from .image_tools import read_image_file_tool, handle_read_image_file
+from .lint_tools import check_lint_tool, handle_check_lint
 from .other_tools import batch_tools_tool, handle_batch_tools, think_tool, handle_think
 from .path_tools import (
     get_allowed_directory_tool,
@@ -99,6 +100,7 @@ TOOL_DEFINITIONS = [
     execute_shell_script_tool(),
     codebase_mapper_tool(),
     search_code_tool(),
+    check_lint_tool(),
     batch_tools_tool(),
     think_tool(),
     # Git tools
@@ -142,6 +144,7 @@ TOOL_HANDLERS = {
     "copy_file": handle_copy_file,
     "search_files": handle_search_files,
     "search_code": handle_search_code,
+    "check_lint": handle_check_lint,
     "delete_file": handle_delete_file,
     "get_file_info": handle_get_file_info,
     "directory_tree": handle_directory_tree,

aidd/tools/code_tools.py

@@ -2,6 +2,7 @@ import os
 import re
 import fnmatch
 import subprocess
+import json
 from datetime import datetime
 from typing import List, Dict, Any, Optional, Union, Tuple
 

aidd/tools/file_tools.py

@@ -283,16 +283,6 @@ def edit_file_tool():
                 "options": {
                     "type": "object",
                     "properties": {
-                        "preserveIndentation": {
-                            "type": "boolean",
-                            "description": "Keep existing indentation when replacing text. When true, the indentation of the first line of oldText is preserved in newText.",
-                            "default": True
-                        },
-                        "normalizeWhitespace": {
-                            "type": "boolean",
-                            "description": "Normalize spaces while preserving structure. When true, consecutive spaces are treated as a single space during matching, making the search more forgiving of whitespace differences.",
-                            "default": True
-                        },
                         "partialMatch": {
                             "type": "boolean",
                             "description": "Enable fuzzy matching for finding text. When true, the tool will try to find the best match even if it's not an exact match, using a confidence threshold of 80%.",
@@ -730,21 +720,17 @@ async def handle_delete_file(arguments: dict):
     except Exception as e:
         raise ValueError(f"Error deleting {path}: {str(e)}")
 
-def normalize_whitespace(text: str, preserve_indentation: bool = True) -> str:
-    """Normalize whitespace while optionally preserving indentation."""
+def normalize_whitespace(text: str) -> str:
+    """Normalize whitespace while preserving indentation."""
     lines = text.splitlines()
     normalized_lines = []
 
     for line in lines:
-        if preserve_indentation:
-            # Preserve leading whitespace
-            indent = re.match(r'^\s*', line).group(0)
-            # Normalize other whitespace
-            content = re.sub(r'\s+', ' ', line.lstrip())
-            normalized_lines.append(f"{indent}{content}")
-        else:
-            # Normalize all whitespace
-            normalized_lines.append(re.sub(r'\s+', ' ', line.strip()))
+        # Preserve leading whitespace
+        indent = re.match(r'^\s*', line).group(0)
+        # Normalize other whitespace
+        content = re.sub(r'\s+', ' ', line.lstrip())
+        normalized_lines.append(f"{indent}{content}")
 
     return '\n'.join(normalized_lines)
 
@@ -813,8 +799,6 @@ async def apply_file_edits(file_path: str, edits: List[dict], dry_run: bool = Fa
     """Apply edits to a file with optional formatting and return diff."""
     # Set default options
     options = options or {}
-    preserve_indentation = options.get('preserveIndentation', True)
-    normalize_ws = options.get('normalizeWhitespace', True)
     partial_match = options.get('partialMatch', True)
 
     # Read file content
@@ -830,20 +814,16 @@ async def apply_file_edits(file_path: str, edits: List[dict], dry_run: bool = Fa
         old_text = edit['oldText']
         new_text = edit['newText']
 
-        # Normalize texts if requested
-        if normalize_ws:
-            search_text = normalize_whitespace(old_text, preserve_indentation)
-            working_content = normalize_whitespace(modified_content, preserve_indentation)
-        else:
-            search_text = old_text
-            working_content = modified_content
+        # Use original text for matching
+        search_text = old_text
+        working_content = modified_content
 
         # Find best match
         start, end, confidence = find_best_match(working_content, search_text, partial_match)
 
         if confidence >= 0.8:
-            # Preserve indentation of first line if requested
-            if preserve_indentation and start >= 0:
+            # Always preserve indentation of first line
+            if start >= 0:
                 indent = re.match(r'^\s*', modified_content[start:].splitlines()[0]).group(0)
                 replacement = '\n'.join(indent + line.lstrip()
                                       for line in new_text.splitlines())

aidd/tools/lint_tools.py

@@ -0,0 +1,449 @@
+import os
+import re
+import json
+import subprocess
+from typing import List, Dict, Any, Optional
+
+from mcp.types import TextContent
+from .state import state
+
+
+def check_lint_tool():
+    return {
+        "name": "check_lint",
+        "description": "Check the codebase for linting issues using native linting tools. "
+                    "WHEN TO USE: When you need to identify coding style issues, potential bugs, or code quality problems. "
+                    "Similar to how VSCode reports lint issues in the Problems panel. "
+                    "WHEN NOT TO USE: When you need to fix formatting (use appropriate formatters instead), "
+                    "when you need detailed code analysis with custom rules, or for compiled languages where linting may not apply. "
+                    "RETURNS: A detailed report of linting issues found in the codebase, including file paths, line numbers, "
+                    "issue descriptions, and severity levels. Issues are grouped by file and sorted by severity. "
+                    "Note: Respects config files like .pylintrc, .flake8, and .eslintrc if present.\n\n"
+                    "EXAMPLES:\n"
+                    "- Basic usage: {\"path\": \"src\"}\n"
+                    "- Python with custom line length: {\"path\": \"src\", \"linters\": {\"flake8\": \"--max-line-length=120 --ignore=E501,E302\"}}\n"
+                    "- Disable specific pylint checks: {\"linters\": {\"pylint\": \"--disable=missing-docstring,invalid-name\"}}\n"
+                    "- TypeScript only: {\"path\": \"src\", \"languages\": [\"typescript\"], \"linters\": {\"eslint\": \"--no-eslintrc --config .eslintrc.custom.js\"}}\n"
+                    "- Disable a linter: {\"linters\": {\"flake8\": false}, \"max_issues\": 50}\n"
+                    "- Single file check: {\"path\": \"src/main.py\"}",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string",
+                    "description": "Directory or file to lint. Can be a specific file or directory to recursively check. "
+                                  "Examples: '.' for entire codebase, 'src' for just the src directory, 'src/main.py' for a specific file.",
+                    "default": "."
+                },
+                "languages": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "List of languages to lint. If empty, will auto-detect based on file extensions. "
+                                  "Supported languages include: 'python', 'javascript', 'typescript'.",
+                    "default": []
+                },
+                "linters": {
+                    "type": "object",
+                    "description": "Configuration for specific linters. Each key is a linter name ('pylint', 'flake8', 'eslint') "
+                                  "and the value is either a boolean to enable/disable or a string with CLI arguments.",
+                    "properties": {
+                        "pylint": {
+                            "type": ["boolean", "string"],
+                            "description": "Whether to use pylint or custom pylint arguments."
+                        },
+                        "flake8": {
+                            "type": ["boolean", "string"],
+                            "description": "Whether to use flake8 or custom flake8 arguments."
+                        },
+                        "eslint": {
+                            "type": ["boolean", "string"],
+                            "description": "Whether to use eslint or custom eslint arguments."
+                        }
+                    },
+                    "default": {}
+                },
+                "max_issues": {
+                    "type": "integer",
+                    "description": "Maximum number of linting issues to return. Set to 0 for unlimited.",
+                    "default": 100
+                }
+            }
+        }
+    }
+
+async def handle_check_lint(arguments: dict) -> List[TextContent]:
+    """Handle linting the codebase and reporting issues using native linting tools."""
+    path = arguments.get("path", ".")
+    languages = arguments.get("languages", [])
+    linters_config = arguments.get("linters", {})
+    max_issues = arguments.get("max_issues", 100)
+
+    # Determine full path
+    if os.path.isabs(path):
+        full_path = os.path.abspath(path)
+    else:
+        full_path = os.path.abspath(os.path.join(state.allowed_directory, path))
+
+    # Security check
+    if not full_path.startswith(state.allowed_directory):
+        raise ValueError(f"Access denied: Path ({full_path}) must be within allowed directory")
+
+    if not os.path.exists(full_path):
+        raise ValueError(f"Path does not exist: {path}")
+
+    # Skip the entire operation if the path looks like a virtual environment or system directory
+    if _is_excluded_system_directory(full_path):
+        return [TextContent(
+            type="text",
+            text="The specified path appears to be a virtual environment, package directory, or system path.\n"
+                 "To prevent excessive noise, linting has been skipped for this path.\n"
+                 "Please specify a project source directory to lint instead."
+        )]
+
+    # Auto-detect languages if not specified
+    if not languages:
+        if os.path.isfile(full_path):
+            language = _detect_language_from_file(full_path)
+            if language:
+                languages = [language]
+        else:
+            languages = ["python", "javascript", "typescript"]  # Default to common languages
+
+    # Prepare linter configurations with defaults
+    linter_defaults = {
+        "python": {
+            "pylint": True,
+            "flake8": True
+        },
+        "javascript": {
+            "eslint": True
+        },
+        "typescript": {
+            "eslint": True
+        }
+    }
+
+    # Process each language
+    all_issues = []
+
+    for language in languages:
+        if language in linter_defaults:
+            # Get default linters for this language
+            default_linters = linter_defaults[language]
+
+            # Override with user configuration
+            for linter_name, default_value in default_linters.items():
+                # Check if the linter is explicitly configured
+                if linter_name in linters_config:
+                    linter_setting = linters_config[linter_name]
+
+                    # Skip if explicitly disabled
+                    if linter_setting is False:
+                        continue
+
+                    # Run the linter with custom args or defaults
+                    issues = await _run_linter(
+                        linter_name,
+                        full_path,
+                        custom_args=linter_setting if isinstance(linter_setting, str) else None
+                    )
+                    all_issues.extend(issues)
+                elif default_value:
+                    # Use default if not explicitly configured
+                    issues = await _run_linter(linter_name, full_path)
+                    all_issues.extend(issues)
+
+        # Limit total issues if needed
+        if max_issues > 0 and len(all_issues) >= max_issues:
+            all_issues = all_issues[:max_issues]
+            break
+
+    # Format and return results
+    if not all_issues:
+        return [TextContent(
+            type="text",
+            text="No linting issues found."
+        )]
+
+    return [TextContent(
+        type="text",
+        text=_format_lint_results(all_issues)
+    )]
+
+def _is_excluded_system_directory(path: str) -> bool:
+    """Check if the path is a system directory or virtual environment that should be excluded from linting."""
+    # Common virtual environment directories
+    venv_indicators = [
+        'venv', '.venv', 'env', '.env', 'virtualenv',
+        'site-packages', 'dist-packages',
+        # Python version-specific directories often in venvs
+        'python3', 'python2', 'python3.', 'lib/python'
+    ]
+
+    # System and dependency directories to exclude
+    system_dirs = [
+        'node_modules', 'bower_components',
+        '.git', '.svn',
+        '__pycache__', '.mypy_cache', '.pytest_cache', '.ruff_cache',
+        '.idea', '.vscode'
+    ]
+
+    # Check if the path contains any of these indicators
+    path_parts = path.lower().split(os.sep)
+
+    # Check for virtual environment indicators
+    for indicator in venv_indicators:
+        if indicator in path_parts:
+            return True
+
+    # Check for system directories
+    for sys_dir in system_dirs:
+        if sys_dir in path_parts:
+            return True
+
+    return False
+
+async def _run_linter(linter_name: str, path: str, custom_args: str = None) -> List[Dict[str, Any]]:
+    """Run a specific linter as a command-line process and parse the results."""
+    issues = []
+
+    # Skip if the path is a system directory
+    if _is_excluded_system_directory(path):
+        return []
+
+    # Handle different linters
+    if linter_name == "pylint":
+        try:
+            # Build the command
+            cmd = ["pylint", "--output-format=json"]
+
+            if custom_args:
+                # Split and add custom arguments
+                cmd.extend(custom_args.split())
+
+            # Add the target path
+            if os.path.isdir(path):
+                # For directories, scan recursively but exclude common directories
+                cmd.extend([
+                    "--recursive=y",
+                    "--ignore=venv,.venv,env,.env,node_modules,__pycache__,.git,.svn,dist,build,target,.idea,.vscode",
+                ])
+
+            cmd.append(path)
+
+            # Run pylint
+            result = subprocess.run(cmd, capture_output=True, text=True)
+
+            if result.stdout.strip():
+                # Parse pylint JSON output
+                try:
+                    pylint_issues = json.loads(result.stdout)
+                    for issue in pylint_issues:
+                        # Extract the file path and ensure it's within the allowed directory
+                        file_path = issue.get("path", "")
+                        if not os.path.isabs(file_path):
+                            file_path = os.path.abspath(os.path.join(os.path.dirname(path), file_path))
+
+                        # Security check for file path and exclude system directories
+                        if not file_path.startswith(state.allowed_directory) or _is_excluded_system_directory(file_path):
+                            continue
+
+                        issues.append({
+                            "file": os.path.relpath(file_path, state.allowed_directory),
+                            "line": issue.get("line", 0),
+                            "column": issue.get("column", 0),
+                            "message": issue.get("message", ""),
+                            "severity": _map_pylint_severity(issue.get("type", "")),
+                            "source": "pylint",
+                            "code": issue.get("symbol", "")
+                        })
+                except (json.JSONDecodeError, ValueError):
+                    # If JSON parsing fails, it might be an error message
+                    if result.stderr:
+                        issues.append({
+                            "file": path if os.path.isfile(path) else "",
+                            "line": 1,
+                            "column": 1,
+                            "message": f"Error running pylint: {result.stderr}",
+                            "severity": "error",
+                            "source": "pylint",
+                            "code": "tool-error"
+                        })
+        except (subprocess.SubprocessError, FileNotFoundError):
+            # Silently fail if pylint is not installed
+            pass
+
+    elif linter_name == "flake8":
+        try:
+            # Build the command
+            cmd = ["flake8", "--format=default"]
+
+            if custom_args:
+                cmd.extend(custom_args.split())
+            else:
+                # Add default exclusions if no custom args provided
+                cmd.extend(["--exclude=.venv,venv,env,.env,node_modules,__pycache__,.git,.svn,dist,build,target,.idea,.vscode"])
+
+            # Add target path
+            cmd.append(path)
+
+            # Run flake8
+            result = subprocess.run(cmd, capture_output=True, text=True)
+
+            if result.stdout.strip():
+                # Parse flake8 output (file:line:col: code message)
+                flake8_pattern = r"(.+):(\d+):(\d+): ([A-Z]\d+) (.+)"
+                for line in result.stdout.splitlines():
+                    match = re.match(flake8_pattern, line)
+                    if match:
+                        filepath, line_num, col, code, message = match.groups()
+
+                        # Ensure path is absolute for security check
+                        if not os.path.isabs(filepath):
+                            filepath = os.path.abspath(os.path.join(os.path.dirname(path), filepath))
+
+                        # Security check for file path and exclude system directories
+                        if not filepath.startswith(state.allowed_directory) or _is_excluded_system_directory(filepath):
+                            continue
+
+                        issues.append({
+                            "file": os.path.relpath(filepath, state.allowed_directory),
+                            "line": int(line_num),
+                            "column": int(col),
+                            "message": message,
+                            "severity": "warning",  # flake8 doesn't provide severity
+                            "source": "flake8",
+                            "code": code
+                        })
+        except (subprocess.SubprocessError, FileNotFoundError):
+            # Silently fail if flake8 is not installed
+            pass
+
+    elif linter_name == "eslint":
+        try:
+            # Build the command
+            cmd = ["npx", "eslint", "--format=json"]
+
+            if custom_args:
+                cmd.extend(custom_args.split())
+            else:
+                # Add default exclusions if no custom args provided
+                cmd.extend(["--ignore-pattern", "**/node_modules/**", "--ignore-pattern", "**/.git/**"])
+
+            # Add target path
+            cmd.append(path)
+
+            # Run ESLint
+            result = subprocess.run(cmd, capture_output=True, text=True)
+
+            if result.stdout.strip():
+                # Parse ESLint JSON output
+                try:
+                    eslint_results = json.loads(result.stdout)
+                    for file_result in eslint_results:
+                        # Get file path and ensure it's absolute
+                        file_path = file_result.get("filePath", "")
+                        if not os.path.isabs(file_path):
+                            file_path = os.path.abspath(os.path.join(os.path.dirname(path), file_path))
+
+                        # Security check for file path and exclude system directories
+                        if not file_path.startswith(state.allowed_directory) or _is_excluded_system_directory(file_path):
+                            continue
+
+                        for message in file_result.get("messages", []):
+                            issues.append({
+                                "file": os.path.relpath(file_path, state.allowed_directory),
+                                "line": message.get("line", 0),
+                                "column": message.get("column", 0),
+                                "message": message.get("message", ""),
+                                "severity": _map_eslint_severity(message.get("severity", 1)),
+                                "source": "eslint",
+                                "code": message.get("ruleId", "")
+                            })
+                except json.JSONDecodeError:
+                    # Handle parsing errors or ESLint errors
+                    if result.stderr:
+                        issues.append({
+                            "file": path if os.path.isfile(path) else "",
+                            "line": 1,
+                            "column": 1,
+                            "message": f"Error running eslint: {result.stderr}",
+                            "severity": "error",
+                            "source": "eslint",
+                            "code": "tool-error"
+                        })
+        except (subprocess.SubprocessError, FileNotFoundError):
+            # Silently fail if eslint is not installed
+            pass
+
+    return issues
+
+def _detect_language_from_file(file_path: str) -> Optional[str]:
+    """Detect programming language based on file extension."""
+    ext = os.path.splitext(file_path)[1].lower()
+
+    language_map = {
+        '.py': 'python',
+        '.js': 'javascript',
+        '.ts': 'typescript',
+        '.jsx': 'javascript',
+        '.tsx': 'typescript',
+    }
+
+    return language_map.get(ext)
+
+def _map_pylint_severity(severity_type: str) -> str:
+    """Map pylint message types to standard severity levels."""
+    severity_map = {
+        "convention": "hint",
+        "refactor": "info",
+        "warning": "warning",
+        "error": "error",
+        "fatal": "error"
+    }
+    return severity_map.get(severity_type.lower(), "info")
+
+def _map_eslint_severity(severity: int) -> str:
+    """Map ESLint severity levels to standard severity levels."""
+    if severity == 2:
+        return "error"
+    elif severity == 1:
+        return "warning"
+    else:
+        return "info"
+
+def _format_lint_results(issues: List[Dict[str, Any]]) -> str:
+    """Format linting issues into a readable text output."""
+    if not issues:
+        return "No linting issues found."
+
+    # Group issues by file
+    issues_by_file = {}
+    for issue in issues:
+        file_path = issue["file"]
+        if file_path not in issues_by_file:
+            issues_by_file[file_path] = []
+        issues_by_file[file_path].append(issue)
+
+    # Format the output
+    output_lines = ["Linting issues found:"]
+
+    for file_path, file_issues in issues_by_file.items():
+        # Sort issues by severity (error -> warning -> info -> hint)
+        severity_order = {"error": 0, "warning": 1, "info": 2, "hint": 3}
+        sorted_issues = sorted(file_issues, key=lambda x: (severity_order.get(x["severity"], 4), x["line"]))
+
+        output_lines.append(f"\n{file_path}:")
+
+        for issue in sorted_issues:
+            severity = issue["severity"].upper()
+            line = issue["line"]
+            column = issue["column"]
+            message = issue["message"]
+            code = f"[{issue['code']}]" if issue["code"] else ""
+
+            output_lines.append(f"  {severity} Line {line}:{column} {message} {code}")
+
+    return "\n".join(output_lines)

{skydeckai_code-0.1.29.dist-info → skydeckai_code-0.1.30.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: skydeckai-code
-Version: 0.1.29
-Summary: This MCP server provides a comprehensive set of tools for AI-driven Development workflows including file operations, code analysis, multi-language execution, Git operations, web content fetching with HTML-to-markdown conversion, multi-engine web search, code content searching, and system information retrieval.
+Version: 0.1.30
+Summary: This MCP server provides a comprehensive set of tools for AI-driven Development workflows including file operations, code analysis, code linting, multi-language execution, Git operations, web content fetching with HTML-to-markdown conversion, multi-engine web search, code content searching, and system information retrieval.
 Project-URL: Homepage, https://github.com/skydeckai/skydeckai-code
 Project-URL: Repository, https://github.com/skydeckai/skydeckai-code
 Project-URL: Documentation, https://github.com/skydeckai/skydeckai-code/blob/main/README.md
@@ -36,7 +36,7 @@ Description-Content-Type: text/markdown
 
 # SkyDeckAI Code
 
-An MCP server that provides a comprehensive set of tools for AI-driven development workflows. Features include file system operations, code analysis using tree-sitter for multiple programming languages, Git operations, code execution, web content fetching with HTML-to-markdown conversion, multi-engine web search, code content searching, and system information retrieval. Designed to enhance AI's capability to assist in software development tasks by providing direct access to both local and remote resources.
+An MCP server that provides a comprehensive set of tools for AI-driven development workflows. Features include file system operations, code analysis using tree-sitter for multiple programming languages, Git operations, code execution, web content fetching with HTML-to-markdown conversion, multi-engine web search, code content searching, linting detection, and system information retrieval. Designed to enhance AI's capability to assist in software development tasks by providing direct access to both local and remote resources.
 
 # Formerly Known As MCP-Server-AIDD
 
@@ -77,6 +77,7 @@ If you're using SkyDeck AI Helper app, you can search for "SkyDeckAI Code" and i
 -   File system operations (read, write, edit, move, copy, delete)
 -   Directory management and traversal
 -   Multi-language code analysis using tree-sitter
+-   Code linting and issue detection for Python and JavaScript/TypeScript
 -   Code content searching with regex pattern matching
 -   Multi-language code execution with safety measures
 -   Git operations (status, diff, commit, branch management, cloning)
@@ -140,8 +141,6 @@ Pattern-based file editing with preview support:
     ],
     "dryRun": false,
     "options": {
-        "preserveIndentation": true,
-        "normalizeWhitespace": true,
         "partialMatch": true
     }
 }
@@ -281,6 +280,63 @@ Supported Languages:
 -   C# (.cs)
 -   Kotlin (.kt, .kts)
 
+#### check_lint
+
+Check for linting issues in your codebase using native linting tools:
+
+```json
+{
+    "path": "src",
+    "languages": ["python", "javascript"],
+    "linters": {
+        "pylint": "--disable=C0111",
+        "flake8": true,
+        "eslint": "--fix"
+    },
+    "max_issues": 100
+}
+```
+
+**Parameters:**
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| path | string | No | Directory or file to lint (default: ".") |
+| languages | array | No | List of languages to lint (auto-detects if empty) |
+| linters | object | No | Configuration for specific linters - can use booleans or CLI arguments |
+| max_issues | integer | No | Maximum number of issues to return (default: 100, 0 for unlimited) |
+
+**Returns:**
+A detailed report of linting issues found in the codebase, including file paths, line numbers, issue descriptions, and severity levels. Issues are grouped by file and sorted by severity.
+
+**Supported Languages and Linters:**
+
+-   Python: pylint, flake8 (automatically uses what's available)
+-   JavaScript/TypeScript: ESLint
+
+**Example Usage:**
+
+```bash
+# Check entire codebase with default settings
+skydeckai-code-cli --tool check_lint
+
+# Check specific directory with custom pylint flags
+skydeckai-code-cli --tool check_lint --args '{
+    "path": "src",
+    "linters": {
+        "pylint": "--disable=missing-docstring,invalid-name"
+    }
+}'
+
+# Check only Python files and disable flake8
+skydeckai-code-cli --tool check_lint --args '{
+    "path": "src",
+    "languages": ["python"],
+    "linters": {
+        "flake8": false
+    }
+}'
+```
+
 #### search_code
 
 Fast content search tool using regular expressions:

{skydeckai_code-0.1.29.dist-info → skydeckai_code-0.1.30.dist-info}/RECORD

@@ -1,25 +1,26 @@
 aidd/__init__.py,sha256=c9HBWxWruCxoAqLCJqltylAwz_7xmaK3g8DKViJZs0Q,222
 aidd/cli.py,sha256=cLtaQJmMBfr7fHkd0dyJqpDrVTIwybL48PotniWGrFM,5031
 aidd/server.py,sha256=kPRyWeWkMCZjabelC65XTmzZG7yw8htMJKSfnUcKnb0,1575
-aidd/tools/__init__.py,sha256=Oyl9YzMB1SRT_skxMcWHPP7ScTjfBSgT3N4ctGxHMAI,5310
+aidd/tools/__init__.py,sha256=abFameL2CdSZohi7Sa1tUEOzD2M6bcXSOkRpgxfZ1mo,5429
 aidd/tools/base.py,sha256=wHSAaGGYWM8ECmoYd7KEcmjsZRWesNQFf3zMjCKGMcc,380
 aidd/tools/code_analysis.py,sha256=fDpm2o_If5PsngXzHN2-ezSkPVT0ZxivLuzmHrOAmVU,33188
 aidd/tools/code_execution.py,sha256=dIPxHBtclsetDZY4jGlSBrw_t-7VlIVrK8mflnZ6c4w,13176
-aidd/tools/code_tools.py,sha256=rkKPtChLWnlMcluDQDAUxWM8sCkfodDerx5JbU8mUN8,12616
+aidd/tools/code_tools.py,sha256=3CgkQ78iVKMd5j8aLmolLp4c59seD42Qw6VbdUcg2wA,12628
 aidd/tools/directory_tools.py,sha256=Hxzge_ziYw_FsjYb5yF0R0dHEdvuWRsg7WsdYDG0AUg,12971
-aidd/tools/file_tools.py,sha256=IDgGr0EyLEEGmbsy-L1gnf7QbR2QaEi8KeX7NJPe5Zo,43823
+aidd/tools/file_tools.py,sha256=jH1-c9sEqTPaUy1edvKIDVMfLs0osC7Xa8Mp94cICfo,42490
 aidd/tools/get_active_apps_tool.py,sha256=BjLF7iXSDgyAmm_gfFgAul2Gn3iX-CNVYHM7Sh4jTAI,19427
 aidd/tools/get_available_windows_tool.py,sha256=OVIYhItTn9u_DftOr3vPCT-R0DOFvMEEJXA6tD6gqWQ,15952
 aidd/tools/git_tools.py,sha256=AgolgrZnpN2NALV7SfIwc6D7U7tdPrPTSFmU2WjPfVE,39846
 aidd/tools/image_tools.py,sha256=wT3EcJAfZWcM0IsXdDfbTNjgFhKZM9nu2wHN6Mk_TTQ,5970
+aidd/tools/lint_tools.py,sha256=ZV9zFb2ugFkO4PFWZk0q7GGVpRapETFBClJgUOiDkn8,18894
 aidd/tools/other_tools.py,sha256=iG3Sd2FP0M0pRv5esPBAUMvlwxTyAMDUdS77IqA_f5s,10822
 aidd/tools/path_tools.py,sha256=RGoOhqP69eHJzM8tEgn_5-GRaR0gp25fd0XZIJ_RnQE,4045
 aidd/tools/screenshot_tool.py,sha256=NMO5B4UG8qfMEOMRd2YoOjtwz_oQ2y1UAGU22jV1yGU,46337
 aidd/tools/state.py,sha256=RWSw0Jfsui8FqC0xsI7Ik07tAg35hRwLHa5xGBVbiI4,1493
 aidd/tools/system_tools.py,sha256=H4_qveKC2HA7SIbi-j4vxA0W4jYh2wfu9A6ni5wkZyA,7249
 aidd/tools/web_tools.py,sha256=gdsj2DEVYb_oYChItK5I1ugt2w25U7IAa5kEw9q6MVg,35534
-skydeckai_code-0.1.29.dist-info/METADATA,sha256=Dud6g3fMZkW-mZtdK0zyT6DjF4BvboiYgWEKrzYmjzY,30926
-skydeckai_code-0.1.29.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-skydeckai_code-0.1.29.dist-info/entry_points.txt,sha256=cT-IHh3_ioGLk3kwIeqj1X6Li1dnJinX9qKWUl7nOLg,80
-skydeckai_code-0.1.29.dist-info/licenses/LICENSE,sha256=uHse04vmI6ZjW7TblegFl30X-sDyyF0-QvH8ItPca3c,10865
-skydeckai_code-0.1.29.dist-info/RECORD,,
+skydeckai_code-0.1.30.dist-info/METADATA,sha256=tR4BXAlWVy99YxudlZSogxl_SnfHKbzmcuCFgTNR780,32563
+skydeckai_code-0.1.30.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+skydeckai_code-0.1.30.dist-info/entry_points.txt,sha256=cT-IHh3_ioGLk3kwIeqj1X6Li1dnJinX9qKWUl7nOLg,80
+skydeckai_code-0.1.30.dist-info/licenses/LICENSE,sha256=uHse04vmI6ZjW7TblegFl30X-sDyyF0-QvH8ItPca3c,10865
+skydeckai_code-0.1.30.dist-info/RECORD,,