eljay-ai 1.1.0

package/agent/chat.py

@@ -0,0 +1,354 @@
+"""Interactive terminal chat loop and one-shot mode.
+
+Part of ElJay AI's universal assistant — supports coding, research, image
+generation, video generation, and general knowledge through a single interface.
+"""
+
+import sys
+
+from .agent import AgentCore
+from .config import SYSTEM_PROMPT
+from .memory import Memory
+from .ollama_client import OllamaError
+from .permissions import DECISION_ALWAYS, DECISION_NO, DECISION_YES, PermissionPolicy
+from .skills import Skills
+from .knowledge import KnowledgeBase
+from .tools import RISK_HIGH, Tool, ToolRegistry
+from .verification import format_checks
+from .workspace import Workspace
+
+BANNER = r"""
+╔══════════════════════════════════════╗
+║            ElJay AI                  ║
+║      Universal AI Assistant          ║
+╠══════════════════════════════════════╣
+║  Coding · Research · Image · Video    ║
+║  General Knowledge · General Help     ║
+╚══════════════════════════════════════╝
+"""
+
+HELP = """Commands:
+  /help               show this help
+  /tools              list the tools the agent can call
+  /agents             list specialized agents (Coding, Research, Image, ...)
+  /skills             list loaded skills
+  /knowledge [query]  search knowledge entries
+  /status             show hardware, model, agents, tools
+  /providers          show provider availability
+  /verify             show the project's test/build commands
+  /memory             show local memory; '/memory clear' erases it
+  /permissions        show risk levels and session allowances
+  /permissions reset  clear this session's allowances
+  /clear              forget the conversation so far
+  /model [name]       show or switch the active model
+  /exit               leave the agent (also: /quit, Ctrl+C)"""
+
+
+def ensure_utf8() -> None:
+    """Make sure we can print box-drawing characters on Windows consoles.
+
+    Windows terminals often default to cp1252, which cannot encode the banner.
+    Call this once at startup, before any output; calling it again is harmless.
+    """
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(encoding="utf-8")  # type: ignore[union-attr]
+        except (AttributeError, ValueError):
+            pass
+
+
+def ask_permission(tool: Tool, preview: str, risk: str = "") -> str:
+    """Ask the user before running a non-safe tool.
+
+    Returns a DECISION_* value. Denies on EOF/interrupt.
+    High-risk tools require typing 'yes' and never offer 'always'.
+    `risk` is the effective risk for this specific call.
+    """
+    risk = risk or tool.risk
+    print(f"\n  Permission required: '{tool.name}' [{risk}]")
+    for line in preview.splitlines():
+        print(f"    {line}")
+
+    if risk == RISK_HIGH:
+        print("  !! This is a HIGH-RISK action.")
+        try:
+            answer = input("  Type 'yes' (exactly) to proceed, anything else cancels: ")
+        except (EOFError, KeyboardInterrupt):
+            print()
+            return DECISION_NO
+        return DECISION_YES if answer.strip().lower() == "yes" else DECISION_NO
+
+    try:
+        answer = input("  Proceed? [y]es / [n]o / [a]lways (this session): ")
+    except (EOFError, KeyboardInterrupt):
+        print()
+        return DECISION_NO
+    answer = answer.strip().lower()
+    if answer in ("a", "always"):
+        return DECISION_ALWAYS
+    if answer in ("y", "yes"):
+        return DECISION_YES
+    return DECISION_NO
+
+
+def print_permissions(policy: PermissionPolicy, registry: ToolRegistry) -> None:
+    """Show each tool's risk level and any session allowances."""
+    print("Tools and risk levels:")
+    for tool in registry.tools():
+        mark = "  <- allowed this session" if policy.is_always_allowed(tool.name) else ""
+        print(f"  {tool.name:<18} [{tool.risk}]{mark}")
+    mode = "ON (ask-level writes skip confirmation)" if policy.auto_approve else "off"
+    print(f"Auto-approve: {mode}")
+    if policy.session_allowed:
+        print("Session allowances: " + ", ".join(sorted(policy.session_allowed)))
+    else:
+        print("Session allowances: none")
+    print("Use /permissions reset to clear session allowances.")
+
+
+def _new_messages() -> list[dict[str, str]]:
+    return [{"role": "system", "content": SYSTEM_PROMPT}]
+
+
+def _print_tools(registry: ToolRegistry) -> None:
+    tools = registry.tools()
+    if not tools:
+        print("[no tools registered]")
+        return
+    print(f"Tools ({len(tools)}):")
+    for tool in tools:
+        print(f"  {tool.name:<20} [{tool.risk}] {tool.description}")
+
+
+def _print_agents(router=None) -> None:
+    """List all specialized agents."""
+    try:
+        from .agents import list_agents
+    except Exception:
+        print("[agents not available]")
+        return
+    agents = list_agents()
+    print(f"Specialized agents ({len(agents)}):")
+    for agent in agents:
+        tools_list = ", ".join(agent.tools[:8])
+        if len(agent.tools) > 8:
+            tools_list += f" (+{len(agent.tools) - 8} more)"
+        provs = ", ".join(agent.providers) if agent.providers else "none"
+        print(f"  {agent.name:12s} — {agent.purpose}")
+        print(f"               tools: {tools_list}")
+        print(f"               providers: {provs}")
+        print(f"               keywords: {', '.join(agent.keywords[:8])}")
+
+
+def _print_skills(skills: Skills | None) -> None:
+    if skills is None:
+        print("[skills not loaded]")
+        return
+    all_skills = skills.all_skills()
+    if not all_skills:
+        print("[no skills found — create a skills/ directory to add skills]")
+        return
+    print(f"Loaded skills ({len(all_skills)}):")
+    by_cat = skills.by_category()
+    for cat, cats_skills in sorted(by_cat.items()):
+        print(f"\n  [{cat}]")
+        for skill in cats_skills:
+            print(f"    {skill.name:30s} — {skill.description}")
+
+
+def _print_knowledge(knowledge: KnowledgeBase | None, query: str = "") -> None:
+    if knowledge is None:
+        print("[knowledge base not loaded]")
+        return
+    if query:
+        results = knowledge.search(query)
+        if not results:
+            print(f"No knowledge entries found for: {query}")
+            return
+        print(f"Knowledge matches for '{query}' ({len(results)}):")
+        for entry in results:
+            print(f"  [{entry.category}/{entry.name}] {entry.description}")
+    else:
+        entries = knowledge.entries()
+        if not entries:
+            print("[knowledge base is empty]")
+            return
+        print(f"Knowledge entries ({len(entries)}):")
+        for entry in entries:
+            print(f"  [{entry.category}/{entry.name}] {entry.description}")
+
+
+def _print_providers(router=None) -> None:
+    """Show provider availability."""
+    try:
+        from .providers import PROVIDERS
+    except Exception:
+        print("[providers not available]")
+        return
+    print("Providers:")
+    for p in PROVIDERS:
+        print(f"  {p.status_string()}")
+
+
+def _print_status(
+    core: AgentCore,
+    registry: ToolRegistry,
+    workspace: Workspace | None,
+    router=None,
+    skills: Skills | None = None,
+    knowledge: KnowledgeBase | None = None,
+    hardware=None,
+) -> None:
+    """Print a comprehensive status snapshot."""
+    print("=" * 50)
+    print("ElJay AI — System Status")
+    print("=" * 50)
+    print(f"Model:     {core.model}")
+
+    if workspace:
+        print(f"Project:   {workspace.name}")
+        print(f"Root:      {workspace.root}")
+        stack = workspace.detect_stack()
+        if stack:
+            print(f"Stack:     {', '.join(stack)}")
+    else:
+        print("Project:   [none]")
+
+    print(f"Tools:     {len(registry)} available")
+
+    if router is not None:
+        _print_agents(router)
+        _print_providers(router)
+    else:
+        _print_agents()
+        _print_providers()
+
+    if skills is not None:
+        s = skills.summary()
+        print(f"Skills:    {s}")
+    else:
+        print("Skills:    [not loaded]")
+
+    if knowledge is not None:
+        k = knowledge.summary()
+        print(f"Knowledge: {k}")
+    else:
+        print("Knowledge: [not loaded]")
+
+    if hardware is not None:
+        print(f"\nHardware:")
+        print(f"  OS:      {hardware.os} {hardware.os_version} ({hardware.arch})")
+        print(f"  CPU:     {hardware.cpu_brand or 'unknown'} ({hardware.cpu_cores} cores)")
+        print(f"  RAM:     {hardware.ram_gb:.1f} GB")
+        print(f"  GPU:     {hardware.gpu}" + (f" ({hardware.vram_gb:.1f} GB VRAM)" if hardware.vram_gb else ""))
+        print(f"  Capabilities:")
+        print(f"    Coding/Research : {'yes' if hardware.can_code else 'no'}")
+        print(f"    Image generation: {'yes' if hardware.can_image else 'no'}")
+        print(f"    Video generation: {'yes' if hardware.can_video else 'no'}")
+        for n in hardware.notes:
+            print(f"    note: {n}")
+    print("=" * 50)
+
+
+def run_chat(
+    core: AgentCore,
+    registry: ToolRegistry,
+    workspace: Workspace | None = None,
+    memory: Memory | None = None,
+    router=None,
+    skills: Skills | None = None,
+    knowledge: KnowledgeBase | None = None,
+    hardware=None,
+) -> None:
+    ensure_utf8()
+    messages = _new_messages()
+
+    while True:
+        try:
+            user_input = input("\nyou> ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print("\nGoodbye.")
+            return
+
+        if not user_input:
+            continue
+        if user_input in ("/exit", "/quit"):
+            print("Goodbye.")
+            return
+        if user_input == "/help":
+            print(HELP)
+            continue
+        if user_input == "/tools":
+            _print_tools(registry)
+            continue
+        if user_input == "/agents":
+            _print_agents(router)
+            continue
+        if user_input == "/skills":
+            _print_skills(skills)
+            continue
+        if user_input.startswith("/knowledge"):
+            parts = user_input.split(maxsplit=1)
+            query = parts[1] if len(parts) > 1 else ""
+            _print_knowledge(knowledge, query)
+            continue
+        if user_input == "/providers":
+            _print_providers(router)
+            continue
+        if user_input == "/status":
+            _print_status(core, registry, workspace, router, skills, knowledge, hardware)
+            continue
+        if user_input == "/verify":
+            if workspace is None:
+                print("[no workspace]")
+            else:
+                print(format_checks(workspace))
+            continue
+        if user_input.startswith("/memory"):
+            parts = user_input.split()
+            if len(parts) > 1 and parts[1] == "clear":
+                if memory is not None:
+                    memory.clear()
+                print("[local memory cleared]")
+            elif memory is None:
+                print("[no memory]")
+            else:
+                print(memory.summary())
+            continue
+        if user_input.startswith("/permissions"):
+            parts = user_input.split()
+            if len(parts) > 1 and parts[1] == "reset":
+                core.policy.reset()
+                print("[session allowances cleared]")
+            else:
+                print_permissions(core.policy, registry)
+            continue
+        if user_input == "/clear":
+            messages = _new_messages()
+            print("[history cleared]")
+            continue
+        if user_input.startswith("/model"):
+            parts = user_input.split(maxsplit=1)
+            if len(parts) == 2 and parts[1].strip():
+                core.model = parts[1].strip()
+            print(f"[model: {core.model}]")
+            continue
+
+        messages.append({"role": "user", "content": user_input})
+        _print_reply(core, messages)
+        if memory is not None:
+            memory.save_history(messages)
+
+
+def run_once(core: AgentCore, prompt: str) -> int:
+    """Non-interactive mode: send one prompt, print the reply, exit."""
+    ensure_utf8()
+    messages = _new_messages()
+    messages.append({"role": "user", "content": prompt})
+    try:
+        reply = core.run(messages)
+    except OllamaError as exc:
+        sys.stderr.write(f"[error] {exc}\n")
+        return 1
+    print(reply)
+    return 0

package/agent/config.py

@@ -0,0 +1,67 @@
+"""Configuration for the local coding agent.
+
+Everything here is overridable via environment variables so the agent stays
+flexible without code changes. No external config files yet (that comes later).
+"""
+
+import os
+
+# Where Ollama's HTTP API listens. Ollama sets OLLAMA_HOST sometimes without a
+# scheme, so we normalise it below.
+_RAW_HOST = os.environ.get("OLLAMA_HOST", "http://127.0.0.1:11434")
+
+
+def _normalise_host(host: str) -> str:
+    host = host.strip()
+    if not host:
+        return "http://127.0.0.1:11434"
+    if not host.startswith(("http://", "https://")):
+        host = "http://" + host
+    return host.rstrip("/")
+
+
+OLLAMA_HOST = _normalise_host(_RAW_HOST)
+
+# The model to use. Defaults to the coding model verified in Phase 1.
+DEFAULT_MODEL = os.environ.get("AGENT_MODEL", "qwen2.5-coder:3b")
+
+# How long (seconds) to wait for a single model response before giving up.
+REQUEST_TIMEOUT = int(os.environ.get("AGENT_TIMEOUT", "300"))
+
+# Maximum tool-calling steps per user turn, to prevent endless loops.
+MAX_STEPS = int(os.environ.get("AGENT_MAX_STEPS", "6"))
+
+# Character budget for the conversation sent to the model; older turns are
+# trimmed first. Keeps context small (we never send the whole project).
+MAX_CONTEXT_CHARS = int(os.environ.get("AGENT_MAX_CONTEXT_CHARS", "16000"))
+
+# When true, non-safe tools (file writes) run WITHOUT asking for confirmation.
+# Dangerous and OFF by default. Set AGENT_AUTO_APPROVE=1 only if you accept that.
+AUTO_APPROVE = os.environ.get("AGENT_AUTO_APPROVE", "").strip().lower() in (
+    "1",
+    "true",
+    "yes",
+    "on",
+)
+
+# System prompt that frames the assistant and teaches the tool protocol.
+# Wording here matters: a too-eager prompt makes small models (e.g. 3B) emit
+# bogus tool calls for ordinary questions. Keep "only when needed" explicit.
+# Later phases inject project rules (AGENTS.md) and gathered context here.
+SYSTEM_PROMPT = (
+    "You are ElJay AI, a local, universal AI assistant running in the user's "
+    "terminal. You help with coding, research, image generation, video "
+    "generation, and general knowledge — all powered by local models via "
+    "Ollama and free web search. Be concise and practical.\n\n"
+    "You have tools available. Call a tool ONLY when the request needs live "
+    "information or access to the user's machine or project that you cannot "
+    "know otherwise (for example the current time, a file on disk, or a web "
+    "search result). For general knowledge questions that a coding model can "
+    "answer from training, respond directly in plain language.\n\n"
+    "To call a tool, reply with ONLY this JSON and nothing else: "
+    '{"name": "<tool_name>", "arguments": {...}}. '
+    "Never output a JSON object unless you are calling a tool. "
+    "Never invent file contents, paths, or command output. "
+    "If a capability is not available on this hardware, explain what is "
+    "needed and how to set it up — never pretend it succeeded."
+)

package/agent/context.py

@@ -0,0 +1,63 @@
+"""Context management: keep what we send to the model small and relevant.
+
+We never send the whole project. Tools gather only what is needed, and this
+module keeps the growing conversation within a character budget by dropping the
+oldest turns first.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def message_size(messages: list[dict[str, Any]]) -> int:
+    return sum(len(str(m.get("content", ""))) for m in messages)
+
+
+def trim_messages(
+    messages: list[dict[str, Any]], max_chars: int
+) -> list[dict[str, Any]]:
+    """Return a copy of `messages` within `max_chars`.
+
+    Always keeps the system prompt and the most recent turns. When older turns
+    are dropped, a short note is appended to the system prompt.
+    """
+    if max_chars <= 0 or message_size(messages) <= max_chars:
+        return list(messages)
+
+    system = [m for m in messages if m.get("role") == "system"][:1]
+    rest = [m for m in messages if m.get("role") != "system"]
+
+    kept: list[dict[str, Any]] = []
+    total = message_size(system)
+    for message in reversed(rest):
+        size = len(str(message.get("content", "")))
+        if total + size > max_chars and kept:
+            break
+        kept.append(message)
+        total += size
+    kept.reverse()
+
+    dropped = len(rest) - len(kept)
+    out: list[dict[str, Any]] = []
+    if system:
+        base = dict(system[0])
+        if dropped > 0:
+            base["content"] = (
+                f"{base.get('content', '')}\n\n"
+                f"[context] {dropped} earlier message(s) were omitted to stay "
+                "within the context budget."
+            )
+        out.append(base)
+    elif dropped > 0:
+        out.append(
+            {
+                "role": "system",
+                "content": (
+                    f"[context] {dropped} earlier message(s) were omitted to stay "
+                    "within the context budget."
+                ),
+            }
+        )
+    out.extend(kept)
+    return out

package/agent/edits.py

@@ -0,0 +1,167 @@
+"""File modification — the ONLY module that writes to the project.
+
+Design rules (safety first):
+- `create_file` only ever creates NEW files; it refuses to overwrite.
+- `edit_file` replaces exact text; it refuses to guess and refuses ambiguous matches.
+- There is deliberately NO delete, rename, or move capability.
+- Every function assumes the caller has ALREADY obtained permission. The
+  permission check lives in `permissions.py` / the agent core, not here.
+
+Paths are confined to the project root via the Workspace.
+"""
+
+from __future__ import annotations
+
+from .workspace import Workspace, human_size
+
+# Refuse to write files larger than this.
+MAX_WRITE_BYTES = 1_000_000
+
+# How many lines to show in a preview.
+PREVIEW_LINES = 20
+
+
+def _is_new_path(rel: str) -> bool:
+    return bool(rel and str(rel).strip() not in ("", ".", "./"))
+
+
+def create_file(ws: Workspace, rel: str, content: str) -> str:
+    """Create a NEW file. Refuses to overwrite an existing file."""
+    if not _is_new_path(rel):
+        return "ERROR: a file path is required"
+    if not isinstance(content, str):
+        return "ERROR: content must be a string"
+
+    try:
+        path = ws.resolve(rel)
+    except ValueError as exc:
+        return f"ERROR: {exc}"
+
+    if path.exists():
+        return (
+            f"ERROR: '{rel}' already exists. Use edit_file to change an existing "
+            "file; overwriting is not allowed."
+        )
+
+    data = content.encode("utf-8")
+    if len(data) > MAX_WRITE_BYTES:
+        return (
+            f"ERROR: content is {human_size(len(data))}, larger than the "
+            f"{human_size(MAX_WRITE_BYTES)} write limit."
+        )
+
+    if not path.parent.exists():
+        try:
+            path.parent.mkdir(parents=True, exist_ok=True)
+        except OSError as exc:
+            return f"ERROR: cannot create folder for '{rel}': {exc}"
+
+    try:
+        path.write_text(content, encoding="utf-8")
+    except OSError as exc:
+        return f"ERROR: cannot write '{rel}': {exc}"
+
+    line_count = content.count("\n") + (0 if content.endswith("\n") else 1)
+    return f"Created {rel} ({human_size(len(data))}, {line_count} line(s))."
+
+
+def edit_file(
+    ws: Workspace,
+    rel: str,
+    old_text: str,
+    new_text: str,
+    replace_all: bool = False,
+) -> str:
+    """Replace exact text in an existing file. Refuses ambiguous/absent matches."""
+    if not isinstance(old_text, str) or not isinstance(new_text, str):
+        return "ERROR: old_text and new_text must be strings"
+    if old_text == "":
+        return "ERROR: old_text must not be empty"
+    if not _is_new_path(rel):
+        return "ERROR: a file path is required"
+
+    try:
+        path = ws.resolve(rel)
+    except ValueError as exc:
+        return f"ERROR: {exc}"
+
+    if not path.exists():
+        return f"ERROR: file does not exist: {rel}. Use create_file to make a new file."
+    if path.is_dir():
+        return f"ERROR: '{rel}' is a directory"
+
+    try:
+        size = path.stat().st_size
+    except OSError as exc:
+        return f"ERROR: cannot read '{rel}': {exc}"
+    if size > MAX_WRITE_BYTES:
+        return (
+            f"ERROR: '{rel}' is {human_size(size)}, too large to edit safely "
+            f"(limit {human_size(MAX_WRITE_BYTES)})."
+        )
+
+    try:
+        with path.open("rb") as fh:
+            if b"\x00" in fh.read(2048):
+                return f"ERROR: '{rel}' looks like a binary file; refusing to edit it."
+    except OSError as exc:
+        return f"ERROR: cannot read '{rel}': {exc}"
+
+    try:
+        text = path.read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError) as exc:
+        return f"ERROR: cannot read '{rel}': {exc}"
+
+    count = text.count(old_text)
+    if count == 0:
+        return (
+            f"ERROR: the text to replace was not found in '{rel}'. "
+            "Read the file first to get the exact text."
+        )
+    if count > 1 and not replace_all:
+        return (
+            f"ERROR: found {count} occurrences of that text in '{rel}'. "
+            "Include more surrounding text to make it unique, or set "
+            "replace_all=true to change them all."
+        )
+
+    updated = text.replace(old_text, new_text) if replace_all else text.replace(old_text, new_text, 1)
+    try:
+        path.write_text(updated, encoding="utf-8")
+    except OSError as exc:
+        return f"ERROR: cannot write '{rel}': {exc}"
+
+    replaced = count if replace_all else 1
+    return f"Updated {rel}: replaced {replaced} occurrence(s)."
+
+
+# -- previews (shown before asking for permission) -------------------------
+
+
+def _block(sign: str, lines: list[str]) -> str:
+    shown = lines[:PREVIEW_LINES]
+    text = "\n".join(f"    {sign} {line}" for line in shown)
+    remaining = len(lines) - len(shown)
+    if remaining > 0:
+        text += f"\n    {sign} ... ({remaining} more line(s))"
+    return text
+
+
+def preview_create(rel: str, content: str = "") -> str:
+    lines = content.splitlines() if isinstance(content, str) else []
+    header = f"CREATE {rel}  ({len(lines)} line(s))"
+    return header + "\n" + _block("+", lines)
+
+
+def preview_edit(
+    rel: str, old_text: str = "", new_text: str = "", replace_all: bool = False
+) -> str:
+    old_lines = old_text.splitlines() if isinstance(old_text, str) else []
+    new_lines = new_text.splitlines() if isinstance(new_text, str) else []
+    suffix = "  (replace all)" if replace_all else ""
+    return (
+        f"EDIT {rel}{suffix}\n"
+        + _block("-", old_lines)
+        + "\n"
+        + _block("+", new_lines)
+    )