makeless 0.1.1__tar.gz → 0.1.2__tar.gz

{makeless-0.1.1 → makeless-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: makeless
-Version: 0.1.1
+Version: 0.1.2
 Summary: A local-first computer operator for Windows.
 Author: Avinash
 License: MIT License

makeless-0.1.2/main.py

@@ -0,0 +1,410 @@
+from tools.filesystem import search_files
+from tools.watcher import start_watcher
+from tools.locations import get_system_location
+from tools.reader import read_file
+from tools.selector import select_result
+from tools.open_router import open_item
+from tools.app_finder import find_apps
+from tools.app_launcher import launch_app
+from tools.launcher import search_in_browser
+from tools.indexer import ensure_index
+
+
+def choose_path(query):
+    """
+    Search for an item and let the user choose if
+    multiple matches are found.
+    """
+
+    results = search_files(
+        query,
+        max_results=10
+    )
+
+    if not results:
+        return None
+
+    if len(results) == 1:
+        return results[0]
+
+    return select_result(results)
+
+
+def choose_app(apps):
+    """
+    Choose the best application automatically.
+    """
+
+    if not apps:
+        return None
+
+    # app_finder removes duplicate application names
+    # and returns the best matches first.
+    return apps[0]
+
+def handle_instruction(instruction):
+    instruction = instruction.strip()
+    lower_instruction = instruction.casefold()
+
+    # Read a file.
+    if lower_instruction.startswith("read "):
+        query = instruction[5:].strip()
+
+        if not query:
+            print(
+                "Makeless: Tell me what you want me to read."
+            )
+            return
+
+        print(
+            f"\nMakeless: Looking for '{query}'..."
+        )
+
+        path = choose_path(query)
+
+        if not path:
+            print(
+                "Makeless: I couldn't find that file."
+            )
+            return
+
+        success, content = read_file(path)
+
+        if not success:
+            print(
+                f"Makeless: {content}"
+            )
+            return
+
+        print("\n" + "=" * 50)
+        print(f"READING: {path}")
+        print("=" * 50 + "\n")
+        print(content)
+        print("\n" + "=" * 50)
+        print("End of file.")
+        print("=" * 50)
+
+        return
+
+    # Open a browser and search the web.
+    if lower_instruction.startswith("open "):
+
+        search_separators = [
+            " and search for ",
+            " and search "
+        ]
+
+        separator_found = None
+
+        for separator in search_separators:
+            if separator in lower_instruction:
+                separator_found = separator
+                break
+
+        if separator_found:
+            split_index = lower_instruction.index(
+                separator_found
+            )
+
+            browser_name = instruction[
+                5:split_index
+            ].strip()
+
+            search_query = instruction[
+                split_index + len(separator_found):
+            ].strip()
+
+            if not browser_name:
+                print(
+                    "Makeless: Tell me which browser to use."
+                )
+                return
+
+            if not search_query:
+                print(
+                    "Makeless: Tell me what you want to search for."
+                )
+                return
+
+            print(
+                f"\nMakeless: Searching for "
+                f"'{search_query}' in "
+                f"{browser_name.title()}..."
+            )
+
+            success, message = search_in_browser(
+                search_query,
+                browser_name
+            )
+
+            print(f"Makeless: {message}")
+            return
+
+    # Find files and folders.
+    if lower_instruction.startswith("find "):
+        query = instruction[5:].strip()
+
+        if not query:
+            print(
+                "Makeless: Tell me what you want to find."
+            )
+            return
+
+        print(
+            f"\nMakeless: Searching for '{query}'...\n"
+        )
+
+        results = search_files(query)
+
+        if not results:
+            print(
+                "Makeless: Nothing found."
+            )
+            return
+
+        print(
+            f"Makeless: Found {len(results)} result(s)."
+        )
+
+        for index, result in enumerate(
+            results,
+            start=1
+        ):
+            print(
+                f"{index}. {result}"
+            )
+
+        return
+
+    # Open a browser and search the web.
+    separator = " and search for "
+
+    if (
+        lower_instruction.startswith("open ")
+        and separator in lower_instruction
+    ):
+        split_index = lower_instruction.index(
+            separator
+        )
+
+        browser_name = instruction[
+            5:split_index
+        ].strip()
+
+        search_query = instruction[
+            split_index + len(separator):
+        ].strip()
+
+        if not browser_name:
+            print(
+                "Makeless: Tell me which browser to use."
+            )
+            return
+
+        if not search_query:
+            print(
+                "Makeless: Tell me what you want to search for."
+            )
+            return
+
+        print(
+            f"\nMakeless: Searching for "
+            f"'{search_query}' in "
+            f"{browser_name.title()}..."
+        )
+
+        success, message = search_in_browser(
+            search_query,
+            browser_name
+        )
+
+        print(f"Makeless: {message}")
+        return
+
+    # Open something in VS Code.
+    if (
+        lower_instruction.startswith("open ")
+        and (
+            lower_instruction.endswith(" in vs code")
+            or lower_instruction.endswith(" in vscode")
+        )
+    ):
+        if lower_instruction.endswith(
+            " in vs code"
+        ):
+            query = instruction[5:-11].strip()
+        else:
+            query = instruction[5:-10].strip()
+
+        if not query:
+            print(
+                "Makeless: Tell me what you want to open."
+            )
+            return
+
+        print(
+            f"\nMakeless: Looking for '{query}'..."
+        )
+
+        system_location = get_system_location(
+            query
+        )
+
+        if system_location:
+            path = str(system_location)
+        else:
+            path = choose_path(query)
+
+        if not path:
+            print(
+                "Makeless: I couldn't find that."
+            )
+            return
+
+        success, message = open_item(
+            path,
+            app="vscode"
+        )
+
+        print(f"Makeless: {message}")
+        return
+
+    # Open an app, file, or folder.
+    if lower_instruction.startswith("open "):
+        query = instruction[5:].strip()
+
+        if not query:
+            print(
+                "Makeless: Tell me what you want to open."
+            )
+            return
+
+        print(
+            f"\nMakeless: Looking for '{query}'..."
+        )
+
+        # 1. Check installed applications FIRST.
+        apps = find_apps(query)
+
+        if apps:
+            app = choose_app(apps)
+
+            if app:
+                success, message = launch_app(
+                    app["path"]
+                )
+
+                if success:
+                    print(
+                        f"Makeless: Launched "
+                        f"{app['name']}"
+                    )
+                else:
+                    print(
+                        f"Makeless: {message}"
+                    )
+
+                return
+
+        # 2. Check known system locations.
+        system_location = get_system_location(
+            query
+        )
+
+        if system_location:
+            path = str(system_location)
+
+        else:
+            # 3. Search indexed files and folders.
+            path = choose_path(query)
+
+        if not path:
+            print(
+                "Makeless: I couldn't find that."
+            )
+            return
+
+        success, message = open_item(path)
+
+        print(f"Makeless: {message}")
+        return
+
+    print(
+        "Makeless: I don't know how to perform "
+        "that task yet."
+    )
+
+
+def main():
+    print("================================")
+    print("          Makeless")
+    print("================================")
+    print("Starting local computer operator...")
+
+    try:
+        ensure_index()
+
+        observer = start_watcher()
+
+    except Exception as error:
+        print(
+            f"\nMakeless: Startup error: {error}"
+        )
+        return
+
+    print("\nReady.")
+    print("Tell me what you want to do.")
+    print("Type 'exit' to close.\n")
+
+    try:
+        while True:
+            try:
+                instruction = input("You: ")
+
+                if (
+                    instruction.strip().casefold()
+                    == "exit"
+                ):
+                    print(
+                        "\nMakeless: Shutting down..."
+                    )
+                    break
+
+                if not instruction.strip():
+                    continue
+
+                # Run one command safely.
+                # If it fails, Makeless stays alive.
+                try:
+                    handle_instruction(instruction)
+
+                except Exception as error:
+                    print(
+                        "\nMakeless: Something went wrong "
+                        f"while handling that command: {error}"
+                    )
+                    print(
+                        "Makeless: Try another command."
+                    )
+
+            except EOFError:
+                print(
+                    "\nMakeless: Input closed."
+                )
+                break
+
+    except KeyboardInterrupt:
+        print(
+            "\n\nMakeless: Interrupted. "
+            "Shutting down..."
+        )
+
+    finally:
+        observer.stop()
+        observer.join()
+
+        print("Makeless: Goodbye!")
+
+
+if __name__ == "__main__":
+    main()

{makeless-0.1.1 → makeless-0.1.2}/makeless.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: makeless
-Version: 0.1.1
+Version: 0.1.2
 Summary: A local-first computer operator for Windows.
 Author: Avinash
 License: MIT License

{makeless-0.1.1 → makeless-0.1.2}/makeless.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ tests/test_state.py
 tools/app_finder.py
 tools/app_launcher.py
 tools/builtin.py
+tools/database.py
 tools/filesystem.py
 tools/indexer.py
 tools/launcher.py

{makeless-0.1.1 → makeless-0.1.2}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "makeless"
-version = "0.1.1"
+version = "0.1.2"
 description = "A local-first computer operator for Windows."
 readme = "README.md"
 requires-python = ">=3.9"

makeless-0.1.2/tools/app_finder.py

@@ -0,0 +1,104 @@
+import os
+
+
+APP_ALIASES = {
+    "vscode": "visual studio code",
+    "vs code": "visual studio code",
+    "code": "visual studio code",
+    "chrome": "google chrome",
+    "brave": "brave",
+    "edge": "microsoft edge"
+}
+
+
+def get_start_menu_locations():
+    locations = []
+
+    program_data = os.environ.get("PROGRAMDATA")
+
+    if program_data:
+        locations.append(
+            os.path.join(
+                program_data,
+                "Microsoft",
+                "Windows",
+                "Start Menu",
+                "Programs"
+            )
+        )
+
+    app_data = os.environ.get("APPDATA")
+
+    if app_data:
+        locations.append(
+            os.path.join(
+                app_data,
+                "Microsoft",
+                "Windows",
+                "Start Menu",
+                "Programs"
+            )
+        )
+
+    return locations
+
+
+def find_apps(query, max_results=10):
+    """
+    Search Windows Start Menu shortcuts for applications.
+    """
+
+    query = query.casefold().strip()
+
+    if not query:
+        return []
+
+    search_query = APP_ALIASES.get(
+        query,
+        query
+    )
+
+    results = []
+    seen_names = set()
+
+    for location in get_start_menu_locations():
+
+        if not os.path.exists(location):
+            continue
+
+        for root, directories, files in os.walk(location):
+
+            for file_name in files:
+
+                if not file_name.casefold().endswith(".lnk"):
+                    continue
+
+                app_name = os.path.splitext(
+                    file_name
+                )[0]
+
+                normalized_name = app_name.casefold()
+
+                if search_query not in normalized_name:
+                    continue
+
+                # Avoid duplicate shortcuts for the same app.
+                if normalized_name in seen_names:
+                    continue
+
+                seen_names.add(normalized_name)
+
+                results.append(
+                    {
+                        "name": app_name,
+                        "path": os.path.join(
+                            root,
+                            file_name
+                        )
+                    }
+                )
+
+                if len(results) >= max_results:
+                    return results
+
+    return results

makeless-0.1.2/tools/database.py

@@ -0,0 +1,62 @@
+import os
+import sqlite3
+from pathlib import Path
+
+
+def get_data_directory():
+    """
+    Return a writable location for Makeless user data.
+    """
+
+    local_app_data = os.environ.get("LOCALAPPDATA")
+
+    if local_app_data:
+        data_directory = Path(local_app_data) / "Makeless"
+    else:
+        data_directory = Path.home() / ".makeless"
+
+    data_directory.mkdir(parents=True, exist_ok=True)
+
+    return data_directory
+
+
+DATABASE_PATH = get_data_directory() / "agentcore.db"
+
+
+def get_database_connection():
+    """
+    Open the Makeless SQLite database.
+    """
+
+    DATABASE_PATH.parent.mkdir(parents=True, exist_ok=True)
+
+    return sqlite3.connect(DATABASE_PATH)
+
+
+def create_database():
+    """
+    Create the database and required tables.
+    """
+
+    connection = get_database_connection()
+    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()

{makeless-0.1.1 → makeless-0.1.2}/tools/filesystem.py

@@ -3,26 +3,45 @@ import sqlite3
 from pathlib import Path
 
 
-APP_DATA_DIR = Path(
-    os.environ.get("LOCALAPPDATA", Path.home())
-) / "Makeless"
+APP_DATA_DIRECTORY = Path.home() / ".makeless"
+DATABASE_PATH = APP_DATA_DIRECTORY / "agentcore.db"
 
-DATABASE_PATH = APP_DATA_DIR / "makeless.db"
+
+def ensure_database_directory():
+    """
+    Create the Makeless data directory if it does not exist.
+    """
+
+    APP_DATA_DIRECTORY.mkdir(
+        parents=True,
+        exist_ok=True
+    )
 
 
 def get_database_connection():
-    APP_DATA_DIR.mkdir(parents=True, exist_ok=True)
+    """
+    Return a connection to the Makeless database.
+    """
+
+    ensure_database_directory()
 
     return sqlite3.connect(DATABASE_PATH)
 
 
 def search_files(query, max_results=20):
-    query = query.casefold()
+    """
+    Search the local file index.
+    """
+
+    query = query.casefold().strip()
 
-    connection = get_database_connection()
-    cursor = connection.cursor()
+    if not query:
+        return []
 
     try:
+        connection = get_database_connection()
+        cursor = connection.cursor()
+
         cursor.execute(
             """
             SELECT path, name, item_type
@@ -34,13 +53,11 @@ def search_files(query, max_results=20):
         )
 
         rows = cursor.fetchall()
-
-    except sqlite3.OperationalError:
-        rows = []
-
-    finally:
         connection.close()
 
+    except sqlite3.Error:
+        return []
+
     results = []
 
     ignored_paths = [
@@ -70,7 +87,14 @@ def search_files(query, max_results=20):
 
 
 def find_best_match(query):
-    results = search_files(query, max_results=100)
+    """
+    Find the best matching file or folder.
+    """
+
+    results = search_files(
+        query,
+        max_results=100
+    )
 
     if not results:
         return None