yncli 1.0.0__py3-none-any.whl

yncli/tools/__init__.py

@@ -0,0 +1,266 @@
+import json
+from typing import List, Dict, Any
+
+from yncli.tools.system_tools import run_terminal_command, git_status, git_diff, get_system_info, change_directory, save_plan_document
+from yncli.tools.file_tools import read_file, write_file, edit_file_replace, list_directory, find_files, grep_search
+from yncli.tools.search_tools import web_search, fetch_webpage
+from yncli.tools.polyglot_tools import validate_code_syntax, run_project_tests
+
+AGENT_TOOLS: List[Dict[str, Any]] = [
+    {
+        "type": "function",
+        "function": {
+            "name": "change_directory",
+            "description": "Changes the current active working directory of the workspace (e.g. 'cd laravelcrud' or 'cd ..' or entering a project folder).",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string", "description": "Relative or absolute directory path to switch to"}
+                },
+                "required": ["path"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "save_plan_document",
+            "description": "Saves the complete PRD (Product Requirements Document) with ASCII mockups, database schemas, stack specs, and implementation roadmap into plan.md in the current workspace directory.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "content": {"type": "string", "description": "The full Markdown content of the PRD to save into plan.md"}
+                },
+                "required": ["content"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "web_search",
+            "description": "Searches the web in real-time via DuckDuckGo for the latest information, documentation, news, or solutions.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string", "description": "The search query keywords"},
+                    "max_results": {"type": "integer", "description": "Number of results to return (default: 5)"}
+                },
+                "required": ["query"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "fetch_webpage",
+            "description": "Fetches a URL and converts its content into clean, readable text/markdown.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "url": {"type": "string", "description": "The complete HTTP/HTTPS URL"}
+                },
+                "required": ["url"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "read_file",
+            "description": "Reads file contents with line numbers. Can view entire file or specific line range.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "file_path": {"type": "string", "description": "Relative or absolute path to the file"},
+                    "start_line": {"type": "integer", "description": "Optional 1-indexed start line"},
+                    "end_line": {"type": "integer", "description": "Optional 1-indexed end line"}
+                },
+                "required": ["file_path"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "write_file",
+            "description": "Creates or completely overwrites a file with new content. Automatically creates parent directories.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "file_path": {"type": "string", "description": "Relative or absolute path to the file"},
+                    "content": {"type": "string", "description": "The full code/text content to write"}
+                },
+                "required": ["file_path", "content"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "edit_file_replace",
+            "description": "Performs surgical search-and-replace edit on an existing file. target_content must uniquely match the section being modified.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "file_path": {"type": "string", "description": "Relative or absolute path to the file"},
+                    "target_content": {"type": "string", "description": "Exact text or lines in the file to replace"},
+                    "replacement_content": {"type": "string", "description": "New replacement text"}
+                },
+                "required": ["file_path", "target_content", "replacement_content"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "list_directory",
+            "description": "Lists contents of a directory, showing files and subdirectories.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "dir_path": {"type": "string", "description": "Directory path (default: current directory '.')"},
+                    "recursive": {"type": "boolean", "description": "If true, lists recursively up to max_depth"},
+                    "max_depth": {"type": "integer", "description": "Maximum depth for recursive listing (default: 2)"}
+                }
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "find_files",
+            "description": "Finds files matching a glob pattern (e.g. '*.py', '*.ts', 'config*') in the project.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "pattern": {"type": "string", "description": "Glob pattern (e.g. '*.rs', '*.go')"},
+                    "search_dir": {"type": "string", "description": "Starting directory (default: '.')"}
+                },
+                "required": ["pattern"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "grep_search",
+            "description": "Fast text and regex search across all files in the directory tree.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string", "description": "Search keyword or regex pattern"},
+                    "search_path": {"type": "string", "description": "Path to search within (default: '.')"}
+                },
+                "required": ["query"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "run_terminal_command",
+            "description": "Runs a terminal command (PowerShell on Windows, Bash on Unix) in the workspace and returns stdout, stderr, and exit code.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "command": {"type": "string", "description": "Command line string to execute"},
+                    "timeout": {"type": "integer", "description": "Timeout in seconds (default: 60)"}
+                },
+                "required": ["command"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "validate_code_syntax",
+            "description": "Validates syntax of a file or code snippet using the appropriate language compiler or linter (Python, TypeScript, Rust, Go, C++, PHP, etc.).",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "language": {"type": "string", "description": "Programming language (e.g. 'python', 'typescript', 'rust', 'go', 'cpp', 'php')"},
+                    "file_path": {"type": "string", "description": "Optional path to existing file"},
+                    "code_snippet": {"type": "string", "description": "Optional code string to validate directly"}
+                },
+                "required": ["language"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "run_project_tests",
+            "description": "Auto-detects and runs project unit tests (pytest, npm test, cargo test, go test, dotnet test).",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "test_filter": {"type": "string", "description": "Optional filter keyword for test cases"}
+                }
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "git_status",
+            "description": "Gets current git repository status (branch, changed files).",
+            "parameters": {
+                "type": "object",
+                "properties": {}
+            }
+        }
+    }
+]
+
+
+def execute_tool(name: str, arguments: Dict[str, Any], current_cwd: str = ".") -> Any:
+    try:
+        if name == "change_directory":
+            return change_directory(path=arguments.get("path", "."), current_cwd=current_cwd)
+        elif name == "save_plan_document":
+            return save_plan_document(content=arguments.get("content", ""), current_cwd=current_cwd)
+        elif name == "web_search":
+            return web_search(query=arguments.get("query", ""), max_results=arguments.get("max_results", 5))
+        elif name == "fetch_webpage":
+            return fetch_webpage(url=arguments.get("url", ""))
+        elif name == "read_file":
+            return read_file(
+                file_path=arguments.get("file_path", ""),
+                start_line=arguments.get("start_line"),
+                end_line=arguments.get("end_line")
+            )
+        elif name == "write_file":
+            return write_file(file_path=arguments.get("file_path", ""), content=arguments.get("content", ""))
+        elif name == "edit_file_replace":
+            return edit_file_replace(
+                file_path=arguments.get("file_path", ""),
+                target_content=arguments.get("target_content", ""),
+                replacement_content=arguments.get("replacement_content", "")
+            )
+        elif name == "list_directory":
+            return list_directory(
+                dir_path=arguments.get("dir_path", "."),
+                recursive=arguments.get("recursive", False),
+                max_depth=arguments.get("max_depth", 2)
+            )
+        elif name == "find_files":
+            return find_files(pattern=arguments.get("pattern", "*"), search_dir=arguments.get("search_dir", "."))
+        elif name == "grep_search":
+            return grep_search(query=arguments.get("query", ""), search_path=arguments.get("search_path", "."))
+        elif name == "run_terminal_command":
+            return run_terminal_command(command=arguments.get("command", ""), timeout=arguments.get("timeout", 60), cwd=current_cwd)
+        elif name == "validate_code_syntax":
+            return validate_code_syntax(
+                language=arguments.get("language", ""),
+                file_path=arguments.get("file_path"),
+                code_snippet=arguments.get("code_snippet")
+            )
+        elif name == "run_project_tests":
+            return run_project_tests(test_filter=arguments.get("test_filter", ""), cwd=current_cwd)
+        elif name == "git_status":
+            return git_status(cwd=current_cwd)
+        else:
+            return f"[ERROR] Unknown tool: {name}"
+    except Exception as e:
+        return f"[ERROR] Gagal mengeksekusi tool '{name}': {str(e)}"

yncli/tools/file_tools.py

@@ -0,0 +1,206 @@
+import os
+import re
+import fnmatch
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+from yncli.clean_text import clean_text_for_terminal
+
+
+def read_file(file_path: str, start_line: Optional[int] = None, end_line: Optional[int] = None) -> str:
+    """
+    Reads file content with optional line number range (1-indexed).
+    """
+    path = Path(file_path).resolve()
+    if not path.exists():
+        return f"Error: File not found: {file_path}"
+    if path.is_dir():
+        return f"Error: Path is a directory, not a file: {file_path}"
+
+    try:
+        with open(path, "r", encoding="utf-8", errors="replace") as f:
+            lines = f.readlines()
+
+        total_lines = len(lines)
+        if total_lines == 0:
+            return f"(File {path.name} is empty)"
+
+        s_line = max(1, start_line) if start_line is not None else 1
+        e_line = min(total_lines, end_line) if end_line is not None else total_lines
+
+        if s_line > e_line:
+            return f"Error: start_line ({s_line}) cannot be greater than end_line ({e_line}). Total lines: {total_lines}"
+
+        output = []
+        output.append(f"File: {path.name} (Lines {s_line}-{e_line} of {total_lines})")
+        output.append("-" * 50)
+        for i in range(s_line - 1, e_line):
+            output.append(f"{i + 1:4d} | {lines[i].rstrip()}")
+
+        return "\n".join(output)
+    except Exception as e:
+        return f"Error reading file {file_path}: {str(e)}"
+
+
+def write_file(file_path: str, content: str) -> str:
+    """
+    Writes or overwrites content to a file, automatically creating parent directories.
+    Sanitizes content to ensure clean UTF-8 without mojibake.
+    """
+    try:
+        path = Path(file_path).resolve()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        cleaned_content = clean_text_for_terminal(content)
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(cleaned_content)
+        return f"Successfully written {len(cleaned_content.splitlines())} lines to {path}"
+    except Exception as e:
+        return f"Error writing file {file_path}: {str(e)}"
+
+
+def edit_file_replace(file_path: str, target_content: str, replacement_content: str) -> str:
+    """
+    Performs precise surgical search-and-replace edit on an existing file.
+    """
+    path = Path(file_path).resolve()
+    if not path.exists():
+        return f"Error: File not found: {file_path}"
+
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            original = f.read()
+
+        target_norm = clean_text_for_terminal(target_content).replace("\r\n", "\n")
+        orig_norm = original.replace("\r\n", "\n")
+        repl_norm = clean_text_for_terminal(replacement_content).replace("\r\n", "\n")
+
+        if target_norm in orig_norm:
+            count = orig_norm.count(target_norm)
+            if count > 1:
+                return f"Error: target_content occurs {count} times in {file_path}. Please provide more unique surrounding lines."
+            
+            new_text = orig_norm.replace(target_norm, repl_norm, 1)
+            with open(path, "w", encoding="utf-8") as f:
+                f.write(new_text)
+            return f"Successfully updated {file_path} with search-and-replace edit."
+
+        # Fallback: line-by-line whitespace-stripped match
+        target_lines = [l.strip() for l in target_norm.strip().split("\n") if l.strip()]
+        file_lines = orig_norm.split("\n")
+        
+        match_idx = -1
+        for i in range(len(file_lines) - len(target_lines) + 1):
+            subset = [file_lines[i + j].strip() for j in range(len(target_lines))]
+            if subset == target_lines:
+                match_idx = i
+                break
+
+        if match_idx != -1:
+            end_match = match_idx + len(target_lines)
+            new_file_lines = file_lines[:match_idx] + repl_norm.split("\n") + file_lines[end_match:]
+            with open(path, "w", encoding="utf-8") as f:
+                f.write("\n".join(new_file_lines))
+            return f"Successfully updated {file_path} (matched with whitespace tolerance)."
+
+        return f"Error: target_content was not found in {file_path}. Please check the exact lines."
+    except Exception as e:
+        return f"Error editing file {file_path}: {str(e)}"
+
+
+def list_directory(dir_path: str = ".", recursive: bool = False, max_depth: int = 2) -> str:
+    path = Path(dir_path).resolve()
+    if not path.exists():
+        return f"Error: Directory not found: {dir_path}"
+    if not path.is_dir():
+        return f"Error: Path is not a directory: {dir_path}"
+
+    lines = [f"Directory listing for: {path}"]
+    lines.append("-" * 50)
+
+    try:
+        if not recursive:
+            entries = sorted(path.iterdir(), key=lambda p: (not p.is_dir(), p.name.lower()))
+            for e in entries:
+                if e.name.startswith(".") and e.name not in (".env", ".gitignore", ".skills"):
+                    continue
+                if e.is_dir():
+                    lines.append(f"[DIR]  {e.name}/")
+                else:
+                    size = e.stat().st_size
+                    lines.append(f"[FILE] {e.name:<30} ({size:,} bytes)")
+        else:
+            base_depth = len(path.parts)
+            for root, dirs, files in os.walk(path):
+                cur_path = Path(root)
+                depth = len(cur_path.parts) - base_depth
+                if depth > max_depth:
+                    dirs[:] = []
+                    continue
+
+                dirs[:] = [d for d in dirs if not d.startswith(".") and d not in ("node_modules", "venv", "__pycache__", "target", "vendor", "dist", "build", ".git")]
+                
+                indent = "  " * depth
+                if depth > 0:
+                    lines.append(f"{indent}[DIR] {cur_path.name}/")
+                for f in sorted(files):
+                    if not f.startswith("."):
+                        fpath = cur_path / f
+                        size = fpath.stat().st_size
+                        lines.append(f"{indent}  [FILE] {f} ({size:,} bytes)")
+
+        return "\n".join(lines)
+    except Exception as e:
+        return f"Error listing directory {dir_path}: {str(e)}"
+
+
+def find_files(pattern: str, search_dir: str = ".") -> str:
+    root_path = Path(search_dir).resolve()
+    matches = []
+    try:
+        for root, dirs, files in os.walk(root_path):
+            dirs[:] = [d for d in dirs if not d.startswith(".") and d not in ("node_modules", "venv", "__pycache__", "target", "vendor", ".git")]
+            for f in files:
+                if fnmatch.fnmatch(f, pattern):
+                    rel = Path(root, f).relative_to(root_path)
+                    matches.append(str(rel))
+        if not matches:
+            return f"No files matching pattern '{pattern}' found in {search_dir}"
+        return f"Found {len(matches)} files matching '{pattern}':\n" + "\n".join(f"- {m}" for m in matches[:50])
+    except Exception as e:
+        return f"Error finding files: {str(e)}"
+
+
+def grep_search(query: str, search_path: str = ".", case_sensitive: bool = False) -> str:
+    path = Path(search_path).resolve()
+    flags = 0 if case_sensitive else re.IGNORECASE
+    try:
+        pattern = re.compile(query, flags)
+    except Exception as e:
+        return f"Invalid regex pattern: {str(e)}"
+
+    matches = []
+    try:
+        for root, dirs, files in os.walk(path):
+            dirs[:] = [d for d in dirs if not d.startswith(".") and d not in ("node_modules", "venv", "__pycache__", "target", "vendor", ".git")]
+            for f in files:
+                fpath = Path(root, f)
+                if fpath.suffix.lower() in (".png", ".jpg", ".exe", ".dll", ".zip", ".tar", ".gz", ".pyc", ".pdf"):
+                    continue
+                try:
+                    with open(fpath, "r", encoding="utf-8", errors="ignore") as file_obj:
+                        for line_idx, line in enumerate(file_obj, start=1):
+                            if pattern.search(line):
+                                rel = fpath.relative_to(path)
+                                matches.append(f"{rel}:{line_idx}: {line.strip()}")
+                                if len(matches) >= 50:
+                                    break
+                except Exception:
+                    continue
+            if len(matches) >= 50:
+                break
+
+        if not matches:
+            return f"No matches found for query '{query}' in {search_path}"
+        return f"Found {len(matches)} matches for '{query}':\n" + "\n".join(matches)
+    except Exception as e:
+        return f"Error running grep search: {str(e)}"

yncli/tools/polyglot_tools.py

@@ -0,0 +1,133 @@
+import os
+import subprocess
+import tempfile
+import re
+from pathlib import Path
+from typing import Optional
+from yncli.language_detector import detect_workspace_languages, LANGUAGE_SIGNATURES
+from yncli.tools.system_tools import run_terminal_command
+
+
+def validate_code_syntax(language: str, file_path: Optional[str] = None, code_snippet: Optional[str] = None) -> str:
+    """
+    Validates the syntax of a code file or code snippet across various languages (Python, JS/TS, Rust, Go, C/C++, PHP, Ruby, etc.)
+    """
+    lang_key = language.lower().strip()
+    
+    # Map common aliases
+    alias_map = {
+        "py": "python",
+        "ts": "typescript",
+        "js": "javascript",
+        "rs": "rust",
+        "golang": "golang",
+        "go": "golang",
+        "c++": "cpp",
+        "c": "cpp",
+        "cs": "csharp",
+        "kt": "java",
+        "rb": "ruby",
+    }
+    lang_key = alias_map.get(lang_key, lang_key)
+
+    temp_file = None
+    target_file = file_path
+
+    if not target_file and code_snippet:
+        ext_map = {
+            "python": ".py",
+            "typescript": ".ts",
+            "javascript": ".js",
+            "rust": ".rs",
+            "golang": ".go",
+            "cpp": ".cpp",
+            "csharp": ".cs",
+            "java": ".java",
+            "php": ".php",
+            "ruby": ".rb",
+            "dart": ".dart",
+            "shell": ".ps1"
+        }
+        ext = ext_map.get(lang_key, ".txt")
+        temp = tempfile.NamedTemporaryFile(delete=False, suffix=ext, mode="w", encoding="utf-8")
+        temp.write(code_snippet)
+        temp.close()
+        temp_file = temp.name
+        target_file = temp_file
+
+    if not target_file or not Path(target_file).exists():
+        return "[ERROR] No file or code snippet provided for validation."
+
+    try:
+        # 1. Python Syntax Validation
+        if lang_key == "python":
+            import py_compile
+            try:
+                py_compile.compile(target_file, doraise=True)
+                return f"[PASS] Python Syntax Check: No syntax errors detected in {Path(target_file).name}."
+            except py_compile.PyCompileError as e:
+                return f"[FAIL] Python Syntax Error:\n{str(e)}"
+
+        # 2. General compiler/linter check using system tools
+        sig = LANGUAGE_SIGNATURES.get(lang_key)
+        if sig and sig.get("syntax_command"):
+            cmd = sig["syntax_command"].replace("{file}", f'"{target_file}"')
+            result = run_terminal_command(cmd, timeout=15)
+            
+            # Check exit code
+            is_exit_zero = "[Process exited with code 0]" in result
+            res_lower = result.lower()
+
+            # Special case for PHP: "no syntax errors detected"
+            if "no syntax errors detected" in res_lower and is_exit_zero:
+                return f"[PASS] PHP Syntax Check: No syntax errors detected in {Path(target_file).name}."
+
+            # Determine failure
+            has_explicit_error = any(kw in res_lower for kw in [
+                "parse error", "syntax error", "fatal error", "compile error", 
+                "error[e", "compilation failed", "unhandled exception"
+            ])
+
+            if (not is_exit_zero) or has_explicit_error:
+                return f"[FAIL] {sig['name']} Syntax / Compiler Check Result:\n{result}"
+            else:
+                return f"[PASS] {sig['name']} Syntax / Compiler Check Passed:\n{result}"
+
+        return f"[INFO] Syntax validator not configured or language toolchain not found for '{language}'. File saved."
+
+    except Exception as e:
+        return f"[ERROR] During syntax validation: {str(e)}"
+    finally:
+        if temp_file and os.path.exists(temp_file):
+            try:
+                os.remove(temp_file)
+            except Exception:
+                pass
+
+
+def run_project_tests(test_filter: str = "", cwd: str = ".") -> str:
+    """
+    Automatically detects the project type and runs standard test suites (pytest, npm test, cargo test, go test, dotnet test).
+    """
+    workspace = Path(cwd).resolve()
+    
+    if (workspace / "pytest.ini").exists() or (workspace / "tests").exists() or (workspace / "pyproject.toml").exists():
+        cmd = f"pytest {test_filter}" if test_filter else "pytest"
+        return run_terminal_command(cmd, timeout=60, cwd=cwd)
+    elif (workspace / "package.json").exists():
+        cmd = f"npm test -- {test_filter}" if test_filter else "npm test"
+        return run_terminal_command(cmd, timeout=60, cwd=cwd)
+    elif (workspace / "Cargo.toml").exists():
+        cmd = f"cargo test {test_filter}" if test_filter else "cargo test"
+        return run_terminal_command(cmd, timeout=60, cwd=cwd)
+    elif (workspace / "go.mod").exists():
+        cmd = f"go test ./... -run {test_filter}" if test_filter else "go test ./..."
+        return run_terminal_command(cmd, timeout=60, cwd=cwd)
+    elif list(workspace.glob("*.csproj")) or list(workspace.glob("*.sln")):
+        cmd = f"dotnet test --filter {test_filter}" if test_filter else "dotnet test"
+        return run_terminal_command(cmd, timeout=60, cwd=cwd)
+    elif (workspace / "composer.json").exists() and (workspace / "vendor" / "bin" / "phpunit").exists():
+        cmd = f"./vendor/bin/phpunit --filter {test_filter}" if test_filter else "./vendor/bin/phpunit"
+        return run_terminal_command(cmd, timeout=60, cwd=cwd)
+    
+    return "[INFO] No known test suite configuration detected in workspace. Use run_terminal_command for custom test scripts."

yncli/tools/search_tools.py

@@ -0,0 +1,68 @@
+import re
+import warnings
+import urllib.request
+from typing import Optional
+
+warnings.filterwarnings("ignore")
+
+
+def web_search(query: str, max_results: int = 5) -> str:
+    """
+    Performs a real-time web search using DuckDuckGo to find accurate, up-to-date information.
+    """
+    try:
+        try:
+            from ddgs import DDGS
+        except ImportError:
+            from duckduckgo_search import DDGS
+
+        ddgs = DDGS()
+        results = list(ddgs.text(query, max_results=max_results))
+        
+        if not results:
+            return f"No search results found for: '{query}'"
+
+        formatted = [f"Web Search Results for '{query}':"]
+        formatted.append("=" * 50)
+        for i, res in enumerate(results, start=1):
+            title = res.get("title", "No title")
+            link = res.get("href", res.get("link", ""))
+            body = res.get("body", res.get("snippet", ""))
+            formatted.append(f"[{i}] {title}\nURL: {link}\nSnippet: {body}\n")
+
+        return "\n".join(formatted)
+    except Exception as e:
+        return f"Error executing web search: {str(e)}"
+
+
+def fetch_webpage(url: str, max_chars: int = 6000) -> str:
+    """
+    Fetches the content of a webpage and extracts clean, readable text/markdown.
+    """
+    try:
+        import requests
+        from bs4 import BeautifulSoup
+
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+        }
+        resp = requests.get(url, headers=headers, timeout=15)
+        resp.raise_for_status()
+
+        soup = BeautifulSoup(resp.text, "html.parser")
+        
+        for tag in soup(["script", "style", "nav", "footer", "header", "aside", "svg", "noscript"]):
+            tag.decompose()
+
+        title = soup.title.string.strip() if soup.title else url
+        text = soup.get_text(separator="\n")
+        
+        clean_lines = [line.strip() for line in text.splitlines() if line.strip()]
+        clean_text = "\n".join(clean_lines)
+
+        if len(clean_text) > max_chars:
+            clean_text = clean_text[:max_chars] + f"\n... [Content truncated, total {len(text)} chars]"
+
+        return f"Title: {title}\nURL: {url}\n\nContent:\n{clean_text}"
+    except Exception as e:
+        return f"Error fetching webpage from {url}: {str(e)}"