eljay-ai 1.1.0

package/agent/workspace.py

@@ -0,0 +1,487 @@
+"""Project workspace: root detection, stack detection, and safe file listing.
+
+Everything here is READ-ONLY. It never modifies the project. Paths are confined
+to the project root so the agent cannot wander into unrelated directories.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from collections.abc import Iterator
+from dataclasses import dataclass
+from itertools import islice
+from pathlib import Path
+
+# Directories we never descend into (keeps output small and relevant).
+DEFAULT_IGNORES = frozenset(
+    {
+        ".git", ".hg", ".svn",
+        "node_modules", "bower_components", "vendor",
+        "__pycache__", ".venv", "venv", "env",
+        "dist", "build", ".next", ".nuxt", "out",
+        ".idea", ".vscode", ".vs",
+        "target", "coverage", ".pytest_cache", ".mypy_cache", ".ruff_cache",
+        ".cache", "bin", "obj",
+    }
+)
+
+# Files that mark the top of a project.
+PROJECT_MARKERS = (
+    ".git", "package.json", "composer.json", "pyproject.toml",
+    "requirements.txt", "setup.py", "go.mod", "Cargo.toml", "pom.xml",
+)
+
+# How far up the tree to look for a project root.
+MAX_ROOT_SEARCH_DEPTH = 6
+
+# Upper bound on entries returned by list_files, to protect the model's context.
+MAX_ENTRIES_LIMIT = 2000
+
+# Read limits for read_file.
+MAX_READ_BYTES = 1_000_000  # refuse whole-file reads larger than this
+MAX_READ_LINES = 2000  # cap number of lines returned in one call
+BINARY_SNIFF_BYTES = 8192  # bytes checked to decide if a file is binary
+
+# Search limits for search_code.
+MAX_SEARCH_FILE_BYTES = 2_000_000  # skip files larger than this
+MAX_SEARCH_RESULTS = 500  # hard cap on matches returned
+SEARCH_LINE_WIDTH = 200  # max characters shown per matching line
+
+
+def human_size(num_bytes: int) -> str:
+    size = float(num_bytes)
+    for unit in ("B", "KB", "MB", "GB"):
+        if size < 1024 or unit == "GB":
+            if unit == "B":
+                return f"{int(size)} {unit}"
+            return f"{size:.1f} {unit}"
+        size /= 1024
+    return f"{size:.1f} GB"
+
+
+def find_project_root(start: Path) -> Path:
+    """Walk up from `start` looking for a project marker; fall back to `start`."""
+    current = Path(start).resolve()
+    for _ in range(MAX_ROOT_SEARCH_DEPTH + 1):
+        if any((current / marker).exists() for marker in PROJECT_MARKERS):
+            return current
+        if current.parent == current:  # filesystem root
+            break
+        current = current.parent
+    return Path(start).resolve()
+
+
+@dataclass
+class Workspace:
+    """The project the agent is allowed to inspect."""
+
+    root: Path
+
+    def __post_init__(self) -> None:
+        self.root = Path(self.root).resolve()
+
+    @property
+    def name(self) -> str:
+        return self.root.name
+
+    def resolve(self, rel: str) -> Path:
+        """Resolve a path against the root, refusing to escape it."""
+        if not rel or rel in (".", "./"):
+            return self.root
+        candidate = Path(rel)
+        if not candidate.is_absolute():
+            candidate = self.root / candidate
+        candidate = candidate.resolve()
+        try:
+            candidate.relative_to(self.root)
+        except ValueError:
+            raise ValueError(
+                f"path is outside the project root and is not allowed: {rel}"
+            ) from None
+        return candidate
+
+    def relative(self, path: Path) -> str:
+        try:
+            return str(path.relative_to(self.root)) or "."
+        except ValueError:
+            return str(path)
+
+    # -- inspection --------------------------------------------------------
+
+    def detect_stack(self) -> list[str]:
+        """Best-effort detection of languages/frameworks in the project root."""
+        stacks: list[str] = []
+        has = lambda *names: any((self.root / n).exists() for n in names)  # noqa: E731
+
+        if has("package.json"):
+            stacks.append("Node.js")
+            stacks.extend(self._detect_js_frameworks())
+        if has("composer.json", "artisan"):
+            stacks.append("PHP")
+            if has("artisan") or self._composer_has("laravel/framework"):
+                stacks.append("Laravel")
+        if has("pyproject.toml", "requirements.txt", "setup.py"):
+            stacks.append("Python")
+        if has("go.mod"):
+            stacks.append("Go")
+        if has("Cargo.toml"):
+            stacks.append("Rust")
+        if has("pom.xml", "build.gradle", "build.gradle.kts"):
+            stacks.append("Java")
+        if has("Gemfile"):
+            stacks.append("Ruby")
+
+        db = self._detect_database()
+        if db:
+            stacks.append(db)
+        return stacks
+
+    def _read_json(self, name: str) -> dict:
+        try:
+            return json.loads((self.root / name).read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError, ValueError):
+            return {}
+
+    def _composer_has(self, package: str) -> bool:
+        data = self._read_json("composer.json")
+        deps = {**data.get("require", {}), **data.get("require-dev", {})}
+        return package in deps
+
+    def _detect_js_frameworks(self) -> list[str]:
+        data = self._read_json("package.json")
+        deps = {
+            **data.get("dependencies", {}),
+            **data.get("devDependencies", {}),
+        }
+        mapping = [
+            ("next", "Next.js"),
+            ("react", "React"),
+            ("vue", "Vue"),
+            ("@angular/core", "Angular"),
+            ("svelte", "Svelte"),
+            ("express", "Express"),
+            ("vite", "Vite"),
+            ("typescript", "TypeScript"),
+        ]
+        return [label for pkg, label in mapping if pkg in deps]
+
+    def _detect_database(self) -> str | None:
+        env = self.root / ".env"
+        if not env.exists():
+            return None
+        try:
+            text = env.read_text(encoding="utf-8", errors="replace").lower()
+        except OSError:
+            return None
+        for key, label in (
+            ("db_connection=mysql", "MySQL"),
+            ("db_connection=pgsql", "PostgreSQL"),
+            ("db_connection=postgres", "PostgreSQL"),
+            ("db_connection=sqlite", "SQLite"),
+            ("db_connection=sqlsrv", "SQL Server"),
+            ("mongodb", "MongoDB"),
+        ):
+            if key in text:
+                return label
+        return None
+
+    # -- listing -----------------------------------------------------------
+
+    def list_tree(
+        self,
+        rel: str = ".",
+        depth: int = 2,
+        max_entries: int = 200,
+    ) -> str:
+        """Return an indented listing of the project tree (read-only)."""
+        depth = max(0, int(depth))
+        max_entries = max(1, min(int(max_entries), MAX_ENTRIES_LIMIT))
+
+        try:
+            base = self.resolve(rel)
+        except ValueError as exc:
+            return f"ERROR: {exc}"
+
+        if not base.exists():
+            return (
+                f"ERROR: path does not exist: {rel}. "
+                "Use list_files to see what actually exists."
+            )
+        if base.is_file():
+            try:
+                size = human_size(base.stat().st_size)
+            except OSError:
+                size = "?"
+            return f"{self.relative(base)}  ({size})"
+
+        lines: list[str] = []
+        state = {"count": 0, "truncated": False}
+
+        def walk(directory: Path, prefix: str, remaining_depth: int) -> None:
+            if state["truncated"]:
+                return
+            try:
+                entries = sorted(
+                    directory.iterdir(),
+                    key=lambda p: (p.is_file(), p.name.lower()),
+                )
+            except OSError:
+                lines.append(f"{prefix}[cannot read directory]")
+                return
+
+            for entry in entries:
+                if state["count"] >= max_entries:
+                    state["truncated"] = True
+                    return
+                if entry.name in DEFAULT_IGNORES:
+                    continue
+                state["count"] += 1
+                if entry.is_dir():
+                    lines.append(f"{prefix}{entry.name}/")
+                    if remaining_depth > 1:
+                        walk(entry, prefix + "  ", remaining_depth - 1)
+                    else:
+                        lines.append(f"{prefix}  ...")
+                else:
+                    try:
+                        size = human_size(entry.stat().st_size)
+                    except OSError:
+                        size = "?"
+                    lines.append(f"{prefix}{entry.name}  ({size})")
+
+        header = f"{self.relative(base)}/"
+        walk(base, "  ", depth)
+
+        output = [header, *lines]
+        if state["truncated"]:
+            output.append(f"... truncated at {max_entries} entries")
+        return "\n".join(output)
+
+    # -- reading -----------------------------------------------------------
+
+    def read_file(
+        self,
+        rel: str,
+        start_line: int | None = None,
+        end_line: int | None = None,
+    ) -> str:
+        """Return numbered file contents (read-only), or an ERROR string.
+
+        Guards: confined to the root, refuses directories and binary files, and
+        refuses whole-file reads above MAX_READ_BYTES (use a line range instead).
+        """
+        try:
+            path = self.resolve(rel)
+        except ValueError as exc:
+            return f"ERROR: {exc}"
+
+        if not path.exists():
+            return (
+                f"ERROR: file does not exist: {rel}. "
+                "Do not guess paths; use list_files to see the project structure "
+                "or search_code to locate the file."
+            )
+        if path.is_dir():
+            return f"ERROR: '{rel}' is a directory; use list_files instead"
+
+        try:
+            size = path.stat().st_size
+        except OSError as exc:
+            return f"ERROR: cannot read '{rel}': {exc}"
+
+        try:
+            start = max(1, int(start_line)) if start_line is not None else 1
+        except (TypeError, ValueError):
+            return f"ERROR: start_line must be an integer, got {start_line!r}"
+        try:
+            end = int(end_line) if end_line is not None else None
+        except (TypeError, ValueError):
+            return f"ERROR: end_line must be an integer, got {end_line!r}"
+        if end is not None and end < start:
+            return f"ERROR: end_line ({end}) is before start_line ({start})"
+
+        whole_file = start == 1 and end is None
+        if whole_file and size > MAX_READ_BYTES:
+            return (
+                f"ERROR: '{rel}' is {human_size(size)}, larger than the "
+                f"{human_size(MAX_READ_BYTES)} limit. Read a range with "
+                "start_line/end_line, or search the file instead."
+            )
+
+        try:
+            with path.open("rb") as fh:
+                head = fh.read(BINARY_SNIFF_BYTES)
+        except OSError as exc:
+            return f"ERROR: cannot read '{rel}': {exc}"
+        if b"\x00" in head:
+            return f"ERROR: '{rel}' looks like a binary file; refusing to read it."
+
+        selected: list[str] = []
+        truncated = False
+        try:
+            with path.open("r", encoding="utf-8", errors="replace") as fh:
+                numbered = enumerate(fh, start=1)
+                if start > 1:
+                    numbered = islice(numbered, start - 1, None)
+                for idx, raw in numbered:
+                    if end is not None and idx > end:
+                        break
+                    text = raw.rstrip("\n").rstrip("\r")
+                    selected.append(f"{idx:>5} | {text}")
+                    if len(selected) >= MAX_READ_LINES:
+                        truncated = True
+                        break
+        except OSError as exc:
+            return f"ERROR: cannot read '{rel}': {exc}"
+
+        if not selected:
+            return f"{rel}  ({human_size(size)}) is empty."
+
+        first = selected[0].split("|", 1)[0].strip()
+        last = selected[-1].split("|", 1)[0].strip()
+        header = f"{rel}  ({human_size(size)})  [lines {first}-{last}]"
+        body = "\n".join(selected)
+        if truncated:
+            body += f"\n... (truncated at {MAX_READ_LINES} lines)"
+        return f"{header}\n{body}"
+
+    # -- searching ---------------------------------------------------------
+
+    def _iter_files(self, base: Path) -> Iterator[Path]:
+        """Yield every file under `base`, skipping ignored dirs and cycles."""
+        if base.is_file():
+            yield base
+            return
+        seen: set[str] = set()
+        stack = [base]
+        while stack:
+            directory = stack.pop()
+            try:
+                resolved = str(directory.resolve())
+            except OSError:
+                continue
+            if resolved in seen:
+                continue
+            seen.add(resolved)
+            try:
+                entries = list(directory.iterdir())
+            except OSError:
+                continue
+            for entry in sorted(entries, key=lambda p: p.name.lower()):
+                if entry.name in DEFAULT_IGNORES:
+                    continue
+                if entry.is_dir():
+                    stack.append(entry)
+                elif entry.is_file():
+                    yield entry
+
+    @staticmethod
+    def _is_binary(path: Path) -> bool:
+        try:
+            with path.open("rb") as fh:
+                return b"\x00" in fh.read(2048)
+        except OSError:
+            return True
+
+    @staticmethod
+    def _find(query: str, regex: bool, case_sensitive: bool):
+        """Return a function mapping a line to the match position, or -1."""
+        if regex:
+            flags = 0 if case_sensitive else re.IGNORECASE
+            pattern = re.compile(query, flags)
+
+            def find_regex(line: str) -> int:
+                match = pattern.search(line)
+                return match.start() if match else -1
+
+            return find_regex
+        if case_sensitive:
+            return lambda line: line.find(query)
+        lowered = query.lower()
+        return lambda line: line.lower().find(lowered)
+
+    @staticmethod
+    def _snippet(line: str, pos: int) -> str:
+        line = line.rstrip()
+        stripped = line.strip()
+        if len(stripped) <= SEARCH_LINE_WIDTH:
+            return stripped
+        start = max(0, pos - 60)
+        end = start + SEARCH_LINE_WIDTH
+        prefix = "..." if start > 0 else ""
+        suffix = "..." if end < len(line) else ""
+        return prefix + line[start:end].strip() + suffix
+
+    def search(
+        self,
+        query: str,
+        rel: str = ".",
+        regex: bool = False,
+        case_sensitive: bool = False,
+        max_results: int = 50,
+    ) -> str:
+        """Search project files for text, returning `path:line: text` matches."""
+        if not query or not str(query).strip():
+            return "ERROR: a non-empty query is required"
+        query = str(query)
+        max_results = max(1, min(int(max_results), MAX_SEARCH_RESULTS))
+
+        try:
+            base = self.resolve(rel)
+        except ValueError as exc:
+            return f"ERROR: {exc}"
+        if not base.exists():
+            return f"ERROR: path does not exist: {rel}"
+
+        try:
+            finder = self._find(query, regex, case_sensitive)
+        except re.error as exc:
+            return f"ERROR: invalid regex {query!r}: {exc}"
+
+        results: list[str] = []
+        skipped_binary = 0
+        truncated = False
+
+        for file_path in self._iter_files(base):
+            if len(results) >= max_results:
+                truncated = True
+                break
+            try:
+                if file_path.stat().st_size > MAX_SEARCH_FILE_BYTES:
+                    continue
+            except OSError:
+                continue
+            if self._is_binary(file_path):
+                skipped_binary += 1
+                continue
+            try:
+                with file_path.open("r", encoding="utf-8", errors="replace") as fh:
+                    for line_no, raw in enumerate(fh, start=1):
+                        pos = finder(raw)
+                        if pos < 0:
+                            continue
+                        snippet = self._snippet(raw, pos)
+                        results.append(f"{self.relative(file_path)}:{line_no}: {snippet}")
+                        if len(results) >= max_results:
+                            truncated = True
+                            break
+            except OSError:
+                continue
+
+        scope = self.relative(base) if base != self.root else "."
+        if not results:
+            return f"No matches for {query!r} in {scope}."
+
+        header = f"{len(results)} match(es) for {query!r} in {scope}:"
+        output = [header, *results]
+        if truncated:
+            output.append(f"... truncated at {max_results} matches")
+        return "\n".join(output)
+
+    def summary(self) -> str:
+        """One-line description of the project, for the banner / project_info."""
+        stacks = self.detect_stack()
+        detected = ", ".join(stacks) if stacks else "unknown"
+        return f"Project: {self.name}\nRoot: {self.root}\nDetected: {detected}"

package/bin/eljay

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+# Launcher for ElJay AI (Git Bash / WSL / Linux / macOS).
+# `eljay` is the canonical command; `myagent` (in this same bin dir) is a
+# backwards-compatible alias that delegates to the same entry point.
+exec python "$(dirname "$0")/../eljay.py" "$@"

package/bin/eljay.cmd

@@ -0,0 +1,4 @@
+@echo off
+REM Launcher for ElJay AI (Windows cmd).
+REM `eljay` is the canonical command; `myagent` is a backwards-compatible alias.
+python "%~dp0..\eljay.py" %*

package/bin/myagent

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+# Launcher for ElJay AI (Git Bash / WSL / Linux / macOS).
+# Backwards-compatible alias: delegates to eljay.py.
+exec python "$(dirname "$0")/../eljay.py" "$@"

package/bin/myagent.cmd

@@ -0,0 +1,4 @@
+@echo off
+REM Launcher for ElJay AI (Windows cmd).
+REM Backwards-compatible alias: delegates to eljay.py.
+python "%~dp0..\eljay.py" %*

package/eljay.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * ElJay AI — npm global install wrapper for the Universal AI Assistant.
+ *
+ * When installed via `npm i -g eljay-ai`, this file is symlinked into the
+ * global bin directory. We resolve the real path to find eljay.py in the
+ * package directory, then spawn Python with it.
+ *
+ * Python 3 must be available on PATH (it is a hard requirement of ElJay AI).
+ *
+ * Python 3 must be available on PATH (it is a hard requirement of ElJay AI).
+ */
+
+const { spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// Resolve the real location of this file (follows npm symlinks).
+const scriptDir = path.dirname(fs.realpathSync(__filename));
+const entryPoint = path.join(scriptDir, 'eljay.py');
+
+// Locate a usable Python interpreter.
+function findPython() {
+    // On Windows the python command may be the broken Store stub.
+    const candidates = ['python', 'python3'];
+    for (const candidate of candidates) {
+        const check = spawnSync(candidate, ['--version']);
+        if (!check.error && check.status === 0) {
+            return candidate;
+        }
+    }
+    return null;
+}
+
+const python = findPython();
+if (!python) {
+    console.error(
+        '[error] No Python 3 interpreter found on PATH.\n' +
+        '        Install Python 3 from https://python.org and try again.'
+    );
+    process.exit(1);
+}
+
+if (!fs.existsSync(entryPoint)) {
+    console.error('[error] eljay.py not found next to eljay.js: ' + entryPoint);
+    process.exit(1);
+}
+
+// Spawn eljay.py, inheriting stdio so the interactive session works.
+const result = spawnSync(python, [entryPoint, ...process.argv.slice(2)], {
+    stdio: 'inherit',
+});
+
+process.exit(result.status != null ? result.status : 1);