makeless 0.1.0__py3-none-any.whl

tools/filesystem.py

@@ -0,0 +1,103 @@
+import os
+import sqlite3
+from pathlib import Path
+
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+DATABASE_PATH = PROJECT_ROOT / "data" / "agentcore.db"
+
+
+def search_files(query, max_results=20):
+    query = query.casefold()
+
+    connection = sqlite3.connect(DATABASE_PATH)
+    cursor = connection.cursor()
+
+    cursor.execute(
+        """
+        SELECT path, name, item_type
+        FROM file_index
+        WHERE LOWER(name) LIKE ?
+        LIMIT ?
+        """,
+        (f"%{query}%", 200)
+    )
+
+    rows = cursor.fetchall()
+    connection.close()
+
+    results = []
+
+    ignored_paths = [
+        "\\$recycle.bin\\",
+        "\\windows\\recent\\",
+        "\\appdata\\local\\temp\\"
+    ]
+
+    for path, name, item_type in rows:
+        normalized_path = path.casefold()
+
+        # Ignore locations that are almost never useful to a user.
+        if any(
+            ignored in normalized_path
+            for ignored in ignored_paths
+        ):
+            continue
+
+        # Ignore files that no longer exist.
+        if not os.path.exists(path):
+            continue
+
+        results.append(path)
+
+        if len(results) >= max_results:
+            break
+
+    return results
+
+
+def find_best_match(query):
+    results = search_files(query, max_results=100)
+
+    if not results:
+        return None
+
+    query = query.casefold()
+    project_root = str(PROJECT_ROOT).casefold()
+
+    def score_result(path):
+        normalized_path = path.casefold()
+        name = os.path.basename(path).casefold()
+
+        score = 0
+
+        # Exact filename match.
+        if name == query:
+            score += 1000
+
+        # Filename starts with the query.
+        elif name.startswith(query):
+            score += 500
+
+        # The AgentCore project gets a strong preference.
+        if normalized_path.startswith(project_root):
+            score += 2000
+
+        # Prefer normal user files.
+        user_home = str(Path.home()).casefold()
+
+        if normalized_path.startswith(user_home):
+            score += 200
+
+        # Penalize shortcuts.
+        if name.endswith(".lnk"):
+            score -= 500
+
+        return score
+
+    results.sort(
+        key=score_result,
+        reverse=True
+    )
+
+    return results[0]

tools/indexer.py

@@ -0,0 +1,133 @@
+import os
+import sqlite3
+import string
+from pathlib import Path
+
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+DATABASE_PATH = PROJECT_ROOT / "data" / "agentcore.db"
+
+
+def get_available_drives():
+    drives = []
+
+    for letter in string.ascii_uppercase:
+        drive = f"{letter}:\\"
+
+        if os.path.exists(drive):
+            drives.append(drive)
+
+    return drives
+
+
+def create_database():
+    DATABASE_PATH.parent.mkdir(exist_ok=True)
+
+    connection = sqlite3.connect(DATABASE_PATH)
+    cursor = connection.cursor()
+
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS file_index (
+            path TEXT PRIMARY KEY,
+            name TEXT NOT NULL,
+            item_type TEXT NOT NULL
+        )
+    """)
+
+    cursor.execute("""
+        CREATE INDEX IF NOT EXISTS idx_file_name
+        ON file_index(name)
+    """)
+
+    connection.commit()
+    connection.close()
+
+
+def index_drive(drive):
+    connection = sqlite3.connect(DATABASE_PATH)
+    cursor = connection.cursor()
+
+    indexed_count = 0
+
+    print(f"Indexing {drive}...")
+
+    try:
+        for root, directories, files in os.walk(
+            drive,
+            topdown=True,
+            followlinks=False
+        ):
+            # Don't follow Windows links.
+            directories[:] = [
+                directory
+                for directory in directories
+                if not os.path.islink(
+                    os.path.join(root, directory)
+                )
+            ]
+
+            for directory in directories:
+                full_path = os.path.join(root, directory)
+
+                try:
+                    cursor.execute(
+                        """
+                        INSERT OR IGNORE INTO file_index
+                        (path, name, item_type)
+                        VALUES (?, ?, ?)
+                        """,
+                        (full_path, directory, "folder")
+                    )
+
+                    indexed_count += 1
+
+                except sqlite3.Error:
+                    continue
+
+            for file in files:
+                full_path = os.path.join(root, file)
+
+                try:
+                    cursor.execute(
+                        """
+                        INSERT OR IGNORE INTO file_index
+                        (path, name, item_type)
+                        VALUES (?, ?, ?)
+                        """,
+                        (full_path, file, "file")
+                    )
+
+                    indexed_count += 1
+
+                except sqlite3.Error:
+                    continue
+
+            # Save progress periodically.
+            if indexed_count % 1000 == 0 and indexed_count > 0:
+                connection.commit()
+
+    except PermissionError:
+        pass
+
+    connection.commit()
+    connection.close()
+
+    print(f"Finished {drive}: {indexed_count} items indexed.")
+
+
+def build_index():
+    print("\nAgentCore File Indexer")
+    print("----------------------")
+
+    create_database()
+
+    drives = get_available_drives()
+
+    for drive in drives:
+        index_drive(drive)
+
+    print("\nIndexing complete.")
+
+
+if __name__ == "__main__":
+    build_index()

tools/launcher.py

@@ -0,0 +1,125 @@
+import os
+import subprocess
+import webbrowser
+from urllib.parse import quote_plus
+
+
+def open_with_default_app(path):
+    """
+    Open a file or folder using Windows' default application.
+    """
+
+    try:
+        os.startfile(path)
+        return True, f"Opened {path}"
+
+    except OSError as error:
+        return False, str(error)
+
+
+def open_in_vscode(path):
+    """
+    Open a file or folder in Visual Studio Code.
+    """
+
+    try:
+        subprocess.Popen(
+            ["code.cmd", path],
+            shell=True
+        )
+
+        return True, f"Opened {path} in VS Code"
+
+    except FileNotFoundError:
+        return (
+            False,
+            "VS Code command was not found. "
+            "Make sure VS Code is installed and available."
+        )
+
+    except Exception as error:
+        return False, str(error)
+
+
+def show_in_file_explorer(path):
+    """
+    Open a folder in File Explorer or select a file.
+    """
+
+    try:
+        if os.path.isdir(path):
+            subprocess.Popen(
+                ["explorer.exe", path]
+            )
+
+            return True, f"Opened folder in File Explorer: {path}"
+
+        subprocess.Popen(
+            ["explorer.exe", "/select,", path]
+        )
+
+        return True, f"Selected file in File Explorer: {path}"
+
+    except Exception as error:
+        return False, str(error)
+
+
+def open_in_browser(path_or_url, browser=None):
+    """
+    Open a URL in the default browser or a specific browser.
+    """
+
+    try:
+        if browser is None:
+            webbrowser.open(path_or_url)
+            return True, f"Opened {path_or_url} in your browser"
+
+        browser = browser.casefold().strip()
+
+        browser_paths = {
+            "brave": (
+                r"C:\Program Files\BraveSoftware"
+                r"\Brave-Browser\Application\brave.exe"
+            ),
+            "chrome": (
+                r"C:\Program Files\Google"
+                r"\Chrome\Application\chrome.exe"
+            ),
+            "edge": (
+                r"C:\Program Files (x86)\Microsoft"
+                r"\Edge\Application\msedge.exe"
+            )
+        }
+
+        executable = browser_paths.get(browser)
+
+        if executable and os.path.exists(executable):
+            subprocess.Popen(
+                [executable, path_or_url]
+            )
+
+            return (
+                True,
+                f"Opened {path_or_url} in {browser.title()}"
+            )
+
+        return False, f"Could not find {browser.title()}"
+
+    except Exception as error:
+        return False, str(error)
+
+
+def search_in_browser(query, browser):
+    """
+    Search Google using a specific browser.
+    """
+
+    search_url = (
+        "https://www.google.com/search?q="
+        + quote_plus(query)
+    )
+
+    return open_in_browser(
+        search_url,
+        browser
+    )

tools/locations.py

@@ -0,0 +1,60 @@
+import os
+from pathlib import Path
+
+
+def get_system_location(query):
+    """
+    Understand common human names for drives and folders.
+    """
+
+    normalized = query.casefold().strip()
+
+    # Remove natural filler words.
+    words_to_remove = [
+        "my",
+        "the"
+    ]
+
+    words = normalized.split()
+
+    filtered_words = []
+
+    for word in words:
+        if word not in words_to_remove:
+            filtered_words.append(word)
+
+    normalized = " ".join(filtered_words)
+
+    # Handle drive names.
+    if normalized in ["c drive", "c"]:
+        return "C:\\"
+
+    if normalized in ["e drive", "e"]:
+        return "E:\\"
+
+    # Get the user's home directory.
+    home = Path.home()
+
+    locations = {
+        "downloads": home / "Downloads",
+        "download": home / "Downloads"
+    }
+
+    # Check Windows-configured special folders.
+    try:
+        from tools.watcher import get_windows_folder
+
+        desktop = get_windows_folder("Desktop")
+        documents = get_windows_folder("Personal")
+
+        if desktop:
+            locations["desktop"] = desktop
+
+        if documents:
+            locations["documents"] = documents
+            locations["document"] = documents
+
+    except Exception:
+        pass
+
+    return locations.get(normalized)

tools/open_router.py

@@ -0,0 +1,93 @@
+import os
+from pathlib import Path
+
+from tools.launcher import (
+    open_in_vscode,
+    open_with_default_app,
+    show_in_file_explorer
+)
+
+
+IMAGE_EXTENSIONS = {
+    ".jpg",
+    ".jpeg",
+    ".png",
+    ".gif",
+    ".webp",
+    ".bmp"
+}
+
+AUDIO_EXTENSIONS = {
+    ".mp3",
+    ".wav",
+    ".m4a",
+    ".flac",
+    ".aac",
+    ".ogg"
+}
+
+VIDEO_EXTENSIONS = {
+    ".mp4",
+    ".mkv",
+    ".avi",
+    ".mov",
+    ".wmv",
+    ".webm"
+}
+
+
+def get_item_type(path):
+    """
+    Determine whether the path is a folder, media file,
+    or a normal file.
+    """
+
+    item_path = Path(path)
+
+    if item_path.is_dir():
+        return "folder"
+
+    extension = item_path.suffix.casefold()
+
+    if extension in IMAGE_EXTENSIONS:
+        return "image"
+
+    if extension in AUDIO_EXTENSIONS:
+        return "audio"
+
+    if extension in VIDEO_EXTENSIONS:
+        return "video"
+
+    return "file"
+
+
+def open_item(path, app=None):
+    """
+    Open an item based on what it is and what the user requested.
+    """
+
+    if not os.path.exists(path):
+        return False, "That item no longer exists."
+
+    # If the user explicitly requested VS Code,
+    # open the file or folder there.
+    if app:
+        normalized_app = app.casefold().strip()
+
+        if normalized_app in ["vs code", "vscode", "visual studio code"]:
+            return open_in_vscode(path)
+
+        return False, f"I don't know how to open items in {app} yet."
+
+    item_type = get_item_type(path)
+
+    # Folders open in File Explorer.
+    if item_type == "folder":
+        return show_in_file_explorer(path)
+
+    # Media files open in their default Windows application.
+    if item_type in ["image", "audio", "video"]:
+        return open_with_default_app(path)
+
+    # Normal files are shown in File Explorer.
+    return show_in_file_explorer(path)

tools/opener.py

@@ -0,0 +1,10 @@
+import os
+
+
+def open_path(path):
+    try:
+        os.startfile(path)
+        return True, None
+
+    except OSError as error:
+        return False, str(error)

tools/reader.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+
+
+def read_file(path, max_size=1_000_000):
+    """
+    Read a text file safely.
+
+    Returns:
+        success, content_or_error
+    """
+
+    file_path = Path(path)
+
+    if not file_path.exists():
+        return False, "The file no longer exists."
+
+    if not file_path.is_file():
+        return False, "That is a folder. I can only read files."
+
+    try:
+        file_size = file_path.stat().st_size
+
+        if file_size > max_size:
+            return (
+                False,
+                "That file is too large to print safely."
+            )
+
+        content = file_path.read_text(
+            encoding="utf-8"
+        )
+
+        return True, content
+
+    except UnicodeDecodeError:
+        return (
+            False,
+            "This doesn't appear to be a readable text file."
+        )
+
+    except PermissionError:
+        return (
+            False,
+            "I don't have permission to read that file."
+        )
+
+    except OSError as error:
+        return False, str(error)

tools/selector.py

@@ -0,0 +1,56 @@
+import msvcrt
+
+
+def select_result(results):
+    """
+    Show an interactive terminal menu.
+
+    Use Up/Down arrow keys and Enter to select.
+    Returns the selected result.
+    """
+
+    selected_index = 0
+
+    while True:
+        # Move cursor to the top of the menu when redrawing.
+        print("\033[H\033[J", end="")
+
+        print("AgentCore: Multiple matches found.")
+        print("Which one do you mean?\n")
+
+        for index, result in enumerate(results):
+            if index == selected_index:
+                print(f"> {result}")
+            else:
+                print(f"  {result}")
+
+        print("\nUse ↑ ↓ arrows and Enter to select.")
+        print("Press Esc to cancel.")
+
+        key = msvcrt.getch()
+
+        # Arrow keys on Windows send two characters.
+        if key in (b"\x00", b"\xe0"):
+            key = msvcrt.getch()
+
+            # Up arrow.
+            if key == b"H":
+                selected_index -= 1
+
+                if selected_index < 0:
+                    selected_index = len(results) - 1
+
+            # Down arrow.
+            elif key == b"P":
+                selected_index += 1
+
+                if selected_index >= len(results):
+                    selected_index = 0
+
+        # Enter key.
+        elif key == b"\r":
+            return results[selected_index]
+
+        # Escape key.
+        elif key == b"\x1b":
+            return None