Uploading full brain workspace from local Drive

Brain_O_Codebase/brain_v0_5/Tools/Code/refactor.py

@@ -0,0 +1 @@
+"""Code intelligence: refactor."""

Brain_O_Codebase/brain_v0_5/Tools/Code/reference_search.py

@@ -0,0 +1 @@
+"""Code intelligence: reference_search."""

Brain_O_Codebase/brain_v0_5/Tools/Code/rename_symbol.py

@@ -0,0 +1 @@
+"""Code intelligence: rename_symbol."""

Brain_O_Codebase/brain_v0_5/Tools/Code/static_analysis.py

@@ -0,0 +1 @@
+"""Code intelligence: static_analysis."""

Brain_O_Codebase/brain_v0_5/Tools/Code/symbol_index.py

@@ -0,0 +1 @@
+"""Code intelligence: symbol_index."""

Brain_O_Codebase/brain_v0_5/Tools/Code/test_generator.py

@@ -0,0 +1 @@
+"""Code intelligence: test_generator."""

Brain_O_Codebase/brain_v0_5/Tools/Communication/__init__.py

@@ -0,0 +1,12 @@
+from Tools.Core.tool_factory import make_tool
+from Tools.Core.tool_result import ToolResult
+def webhook_post(ctx=None, url: str = "", body: str = "", **kw):
+    try:
+        import urllib.request
+        req = urllib.request.Request(url, data=body.encode(), method="POST", headers={"Content-Type":"application/json"})
+        with urllib.request.urlopen(req, timeout=20) as r:
+            return ToolResult("webhook_post", True, r.read(5000).decode("utf-8", errors="ignore"))
+    except Exception as e:
+        return ToolResult("webhook_post", False, str(e), error_type="runtime")
+def register(registry):
+    registry.register(make_tool("webhook_post", "POST JSON webhook", {"url":{"type":"string","required":True},"body":{"type":"string","required":True}}, webhook_post, "communication", "net:write", parallel_safe=False))

Brain_O_Codebase/brain_v0_5/Tools/Communication/calendar.py

@@ -0,0 +1 @@
+"""Communication: calendar."""

Brain_O_Codebase/brain_v0_5/Tools/Communication/discord.py

@@ -0,0 +1 @@
+"""Communication: discord."""

Brain_O_Codebase/brain_v0_5/Tools/Communication/email.py

@@ -0,0 +1 @@
+"""Communication: email."""

Brain_O_Codebase/brain_v0_5/Tools/Communication/messaging.py

@@ -0,0 +1 @@
+"""Communication: messaging."""

Brain_O_Codebase/brain_v0_5/Tools/Communication/notifications.py

@@ -0,0 +1 @@
+"""Communication: notifications."""

Brain_O_Codebase/brain_v0_5/Tools/Communication/slack.py

@@ -0,0 +1 @@
+"""Communication: slack."""

Brain_O_Codebase/brain_v0_5/Tools/Communication/sms.py

@@ -0,0 +1 @@
+"""Communication: sms."""

Brain_O_Codebase/brain_v0_5/Tools/Communication/teams.py

@@ -0,0 +1 @@
+"""Communication: teams."""

Brain_O_Codebase/brain_v0_5/Tools/Communication/webhook.py

@@ -0,0 +1 @@
+"""Communication: webhook."""

Brain_O_Codebase/brain_v0_5/Tools/Core/__init__.py

@@ -0,0 +1,11 @@
+from Tools.Core.tool_engine import ToolEngine
+from Tools.Core.tool_manager import ToolManager
+from Tools.Core.tool_registry import ToolRegistry, ToolSpec
+from Tools.Core.tool_result import ToolResult
+from Tools.Core.tool_context import ToolContext
+from Tools.Core.tool_router import parse_tool_calls
+
+__all__ = [
+    "ToolEngine", "ToolManager", "ToolRegistry", "ToolSpec",
+    "ToolResult", "ToolContext", "parse_tool_calls",
+]

Brain_O_Codebase/brain_v0_5/Tools/Core/capability_registry.py

@@ -0,0 +1,14 @@
+"""Map high-level capabilities to tool names."""
+from __future__ import annotations
+
+CAPABILITIES = {
+    "read_code": ["read_file", "list_directory", "search_files", "code_search"],
+    "edit_code": ["write_file", "edit_file", "replace_text"],
+    "run_tests": ["run_terminal", "python_unit_test"],
+    "search_web": ["web_search", "web_open"],
+    "git": ["git_status", "git_diff", "git_commit"],
+    "docs": ["pdf_read", "docx_read", "xlsx_read"],
+}
+
+def tools_for(capability: str) -> list[str]:
+    return list(CAPABILITIES.get(capability, []))

Brain_O_Codebase/brain_v0_5/Tools/Core/dependency_manager.py

@@ -0,0 +1,12 @@
+"""Declare tool dependencies (soft)."""
+from __future__ import annotations
+
+# tool -> required tools that should exist
+DEPS = {
+    "refactor": ["read_file", "write_file"],
+    "test_generator": ["read_file", "python_unit_test"],
+    "patch_generator": ["read_file", "git_diff"],
+}
+
+def missing_deps(available: set[str], tool: str) -> list[str]:
+    return [d for d in DEPS.get(tool, []) if d not in available]

Brain_O_Codebase/brain_v0_5/Tools/Core/tool_cache.py

@@ -0,0 +1,28 @@
+"""Simple in-memory result cache for idempotent tools."""
+from __future__ import annotations
+import hashlib, json, time
+from typing import Any, Optional
+from Tools.Core.tool_result import ToolResult
+
+class ToolCache:
+    def __init__(self, ttl_s: float = 300.0):
+        self.ttl_s = ttl_s
+        self._store: dict[str, tuple[float, ToolResult]] = {}
+
+    def _key(self, name: str, arguments: dict) -> str:
+        raw = name + json.dumps(arguments, sort_keys=True, default=str)
+        return hashlib.sha256(raw.encode()).hexdigest()
+
+    def get(self, name: str, arguments: dict) -> Optional[ToolResult]:
+        k = self._key(name, arguments)
+        item = self._store.get(k)
+        if not item:
+            return None
+        ts, res = item
+        if time.time() - ts > self.ttl_s:
+            del self._store[k]
+            return None
+        return res
+
+    def set(self, name: str, arguments: dict, result: ToolResult) -> None:
+        self._store[self._key(name, arguments)] = (time.time(), result)

Brain_O_Codebase/brain_v0_5/Tools/Core/tool_context.py

@@ -0,0 +1,18 @@
+"""Execution context passed into every tool call."""
+from __future__ import annotations
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Optional
+
+@dataclass
+class ToolContext:
+    cwd: Path = field(default_factory=lambda: Path.cwd())
+    workspace_root: Optional[Path] = None
+    session_id: str = "default"
+    user_id: Optional[str] = None
+    permissions: set[str] = field(default_factory=lambda: {"fs:read", "fs:write", "fs:delete", "terminal:run", "python:eval", "net:read", "net:write", "git:write", "db:write"})
+    env: dict[str, str] = field(default_factory=dict)
+    extra: dict[str, Any] = field(default_factory=dict)
+
+    def has(self, perm: str) -> bool:
+        return perm in self.permissions or "*" in self.permissions

Brain_O_Codebase/brain_v0_5/Tools/Core/tool_discovery.py

@@ -0,0 +1,12 @@
+"""List tools by capability tags."""
+from __future__ import annotations
+from Tools.Core.tool_registry import ToolRegistry
+
+def discover(registry: ToolRegistry, query: str = "") -> list[str]:
+    q = query.lower().strip()
+    out = []
+    for t in registry.list_tools():
+        blob = f"{t.name} {t.description} {t.category}".lower()
+        if not q or q in blob:
+            out.append(t.name)
+    return out

Brain_O_Codebase/brain_v0_5/Tools/Core/tool_engine.py

@@ -0,0 +1,27 @@
+"""Top-level tool engine used by agents."""
+from __future__ import annotations
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Any
+from Tools.Core.tool_manager import ToolManager
+from Tools.Core.tool_result import ToolResult
+from Tools.Core.tool_context import ToolContext
+
+class ToolEngine:
+    def __init__(self, context: ToolContext | None = None):
+        self.manager = ToolManager(context=context)
+
+    def run(self, name: str, arguments: dict[str, Any] | None = None) -> ToolResult:
+        return self.manager.executor.run(name, arguments or {})
+
+    def run_many(self, calls: list[dict[str, Any]], parallel: bool = True) -> list[ToolResult]:
+        if not parallel or len(calls) <= 1:
+            return [self.run(c["name"], c.get("arguments") or {}) for c in calls]
+        results: list[ToolResult | None] = [None] * len(calls)
+        with ThreadPoolExecutor(max_workers=min(8, len(calls))) as ex:
+            futs = {ex.submit(self.run, c["name"], c.get("arguments") or {}): i for i, c in enumerate(calls)}
+            for fut in as_completed(futs):
+                results[futs[fut]] = fut.result()
+        return [r for r in results if r is not None]
+
+    def schemas(self) -> str:
+        return self.manager.prompt_schemas()

Brain_O_Codebase/brain_v0_5/Tools/Core/tool_executor.py

@@ -0,0 +1,48 @@
+"""Execute a single tool call with validation, permissions, timing."""
+from __future__ import annotations
+import time
+from typing import Any
+from Tools.Core.tool_registry import ToolRegistry, ToolSpec
+from Tools.Core.tool_result import ToolResult
+from Tools.Core.tool_context import ToolContext
+from Tools.Core.tool_validator import validate_args
+
+class ToolExecutor:
+    def __init__(self, registry: ToolRegistry, context: ToolContext | None = None):
+        self.registry = registry
+        self.context = context or ToolContext()
+
+    def run(self, name: str, arguments: dict[str, Any] | None = None) -> ToolResult:
+        arguments = arguments or {}
+        t0 = time.perf_counter()
+        spec = self.registry.get(name)
+        if spec is None:
+            known = ", ".join(sorted(self.registry.tools)) or "(none)"
+            return ToolResult(name, False, f"Unknown tool: {name}. Known: {known}", error_type="unknown_tool")
+        if spec.required_permission and not self.context.has(spec.required_permission):
+            return ToolResult(name, False, f"Permission denied: {spec.required_permission}", error_type="permission")
+        err = validate_args(spec.parameters, arguments)
+        if err:
+            return ToolResult(name, False, f"Validation: {err}", error_type="validation")
+        if spec.handler is None:
+            return ToolResult(name, False, f"No handler for {name}", error_type="no_handler")
+        try:
+            out = spec.handler(ctx=self.context, **arguments)
+            if isinstance(out, ToolResult):
+                out.latency_ms = (time.perf_counter() - t0) * 1000
+                return out
+            return ToolResult(name, True, str(out), raw=out, latency_ms=(time.perf_counter() - t0) * 1000)
+        except TypeError:
+            # handlers that don't take ctx=
+            try:
+                out = spec.handler(**arguments)
+                if isinstance(out, ToolResult):
+                    out.latency_ms = (time.perf_counter() - t0) * 1000
+                    return out
+                return ToolResult(name, True, str(out), raw=out, latency_ms=(time.perf_counter() - t0) * 1000)
+            except Exception as e:
+                return ToolResult(name, False, f"Runtime: {e}", error_type="runtime",
+                                  latency_ms=(time.perf_counter() - t0) * 1000)
+        except Exception as e:
+            return ToolResult(name, False, f"Runtime: {e}", error_type="runtime",
+                              latency_ms=(time.perf_counter() - t0) * 1000)

Brain_O_Codebase/brain_v0_5/Tools/Core/tool_factory.py

@@ -0,0 +1,19 @@
+"""Build ToolSpec quickly."""
+from __future__ import annotations
+from typing import Any, Callable, Optional
+from Tools.Core.tool_registry import ToolSpec
+
+def make_tool(
+    name: str,
+    description: str,
+    parameters: dict[str, Any],
+    handler: Callable,
+    category: str = "general",
+    permission: Optional[str] = None,
+    parallel_safe: bool = True,
+) -> ToolSpec:
+    return ToolSpec(
+        name=name, description=description, parameters=parameters,
+        handler=handler, category=category, required_permission=permission,
+        parallel_safe=parallel_safe,
+    )

Brain_O_Codebase/brain_v0_5/Tools/Core/tool_lifecycle.py

@@ -0,0 +1,17 @@
+"""Hooks: before/after tool call."""
+from __future__ import annotations
+from typing import Callable, Any
+from Tools.Core.tool_result import ToolResult
+
+class LifecycleHooks:
+    def __init__(self):
+        self.before: list[Callable] = []
+        self.after: list[Callable] = []
+
+    def run_before(self, name: str, arguments: dict) -> None:
+        for h in self.before:
+            h(name, arguments)
+
+    def run_after(self, name: str, arguments: dict, result: ToolResult) -> None:
+        for h in self.after:
+            h(name, arguments, result)

Brain_O_Codebase/brain_v0_5/Tools/Core/tool_loader.py

@@ -0,0 +1,30 @@
+"""Discover and register tools from category packages."""
+from __future__ import annotations
+from Tools.Core.tool_registry import ToolRegistry
+
+def load_all_builtin_tools(registry: ToolRegistry) -> ToolRegistry:
+    loaders = [
+        ("Tools.Filesystem", "register"),
+        ("Tools.Code", "register"),
+        ("Tools.Terminal", "register"),
+        ("Tools.Python", "register"),
+        ("Tools.Search", "register"),
+        ("Tools.Git", "register"),
+        ("Tools.Documents", "register"),
+        ("Tools.Media", "register"),
+        ("Tools.Security", "register"),
+        ("Tools.APIs", "register"),
+        ("Tools.Databases", "register"),
+        ("Tools.Browser", "register"),
+        ("Tools.GitHub", "register"),
+        ("Tools.Cloud", "register"),
+        ("Tools.Communication", "register"),
+        ("Tools.Plugins", "register"),
+    ]
+    for mod_name, fn_name in loaders:
+        try:
+            mod = __import__(mod_name, fromlist=[fn_name])
+            getattr(mod, fn_name)(registry)
+        except Exception:
+            continue
+    return registry

Brain_O_Codebase/brain_v0_5/Tools/Core/tool_manager.py

@@ -0,0 +1,26 @@
+"""High-level facade: load categories, list, run."""
+from __future__ import annotations
+from typing import Optional
+from Tools.Core.tool_registry import ToolRegistry
+from Tools.Core.tool_executor import ToolExecutor
+from Tools.Core.tool_context import ToolContext
+from Tools.Core.tool_router import ToolRouter
+from Tools.Core.tool_loader import load_all_builtin_tools
+
+class ToolManager:
+    def __init__(self, context: Optional[ToolContext] = None, auto_load: bool = True):
+        self.context = context or ToolContext()
+        self.registry = ToolRegistry()
+        if auto_load:
+            load_all_builtin_tools(self.registry)
+        self.executor = ToolExecutor(self.registry, self.context)
+        self.router = ToolRouter(self.registry, self.executor)
+
+    def list(self, category: Optional[str] = None):
+        return self.registry.list_tools(category)
+
+    def run(self, name: str, **kwargs):
+        return self.executor.run(name, kwargs)
+
+    def prompt_schemas(self) -> str:
+        return self.registry.schemas_for_prompt()

Brain_O_Codebase/brain_v0_5/Tools/Core/tool_metrics.py

@@ -0,0 +1,17 @@
+"""Simple counters for success/fail."""
+from __future__ import annotations
+from dataclasses import dataclass, field
+
+@dataclass
+class ToolMetrics:
+    ok: int = 0
+    fail: int = 0
+    by_tool: dict = field(default_factory=dict)
+
+    def record(self, name: str, ok: bool) -> None:
+        if ok:
+            self.ok += 1
+        else:
+            self.fail += 1
+        slot = self.by_tool.setdefault(name, {"ok": 0, "fail": 0})
+        slot["ok" if ok else "fail"] += 1

Brain_O_Codebase/brain_v0_5/Tools/Core/tool_permissions.py

@@ -0,0 +1,18 @@
+"""Permission helpers."""
+from __future__ import annotations
+from Tools.Core.tool_context import ToolContext
+
+PERMISSIONS = {
+    "fs:read", "fs:write", "fs:delete",
+    "terminal:run", "python:eval",
+    "net:read", "net:write",
+    "git:write", "db:write", "secrets:read",
+}
+
+def grant(ctx: ToolContext, *perms: str) -> ToolContext:
+    ctx.permissions |= set(perms)
+    return ctx
+
+def revoke(ctx: ToolContext, *perms: str) -> ToolContext:
+    ctx.permissions -= set(perms)
+    return ctx

Brain_O_Codebase/brain_v0_5/Tools/Core/tool_profiler.py

@@ -0,0 +1,19 @@
+"""Aggregate latency stats per tool."""
+from __future__ import annotations
+from collections import defaultdict
+from dataclasses import dataclass, field
+
+@dataclass
+class ToolProfiler:
+    counts: dict[str, int] = field(default_factory=lambda: defaultdict(int))
+    total_ms: dict[str, float] = field(default_factory=lambda: defaultdict(float))
+
+    def record(self, name: str, latency_ms: float) -> None:
+        self.counts[name] += 1
+        self.total_ms[name] += latency_ms
+
+    def summary(self) -> dict[str, dict[str, float]]:
+        out = {}
+        for k, n in self.counts.items():
+            out[k] = {"count": n, "avg_ms": self.total_ms[k] / max(n, 1)}
+        return out

Brain_O_Codebase/brain_v0_5/Tools/Core/tool_registry.py

@@ -0,0 +1,43 @@
+"""Central registry of tool specs + handlers."""
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Any, Callable, Optional
+from Tools.Core.tool_result import ToolResult
+from Tools.Core.tool_validator import validate_args
+
+@dataclass
+class ToolSpec:
+    name: str
+    description: str
+    parameters: dict[str, Any]
+    handler: Optional[Callable[..., Any]] = None
+    category: str = "general"
+    parallel_safe: bool = True
+    required_permission: Optional[str] = None
+    timeout_s: float = 60.0
+
+@dataclass
+class ToolRegistry:
+    tools: dict[str, ToolSpec] = field(default_factory=dict)
+
+    def register(self, spec: ToolSpec) -> None:
+        self.tools[spec.name] = spec
+
+    def get(self, name: str) -> Optional[ToolSpec]:
+        return self.tools.get(name)
+
+    def list_tools(self, category: Optional[str] = None) -> list[ToolSpec]:
+        vals = list(self.tools.values())
+        if category:
+            vals = [t for t in vals if t.category == category]
+        return vals
+
+    def schemas_for_prompt(self) -> str:
+        lines = []
+        for t in sorted(self.tools.values(), key=lambda x: (x.category, x.name)):
+            params = ", ".join(
+                f"{k}{'*' if v.get('required') else ''}: {v.get('type','any')}"
+                for k, v in t.parameters.items()
+            )
+            lines.append(f"- [{t.category}] {t.name}({params}): {t.description}")
+        return "\n".join(lines) if lines else "(no tools)"

Brain_O_Codebase/brain_v0_5/Tools/Core/tool_result.py

@@ -0,0 +1,20 @@
+"""Standard tool result envelope."""
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+@dataclass
+class ToolResult:
+    name: str
+    ok: bool
+    content: str
+    raw: Any = None
+    error_type: Optional[str] = None
+    latency_ms: float = 0.0
+    meta: dict = field(default_factory=dict)
+
+    def as_dict(self) -> dict:
+        return {
+            "name": self.name, "ok": self.ok, "content": self.content,
+            "error_type": self.error_type, "latency_ms": self.latency_ms, "meta": self.meta,
+        }

Brain_O_Codebase/brain_v0_5/Tools/Core/tool_router.py

@@ -0,0 +1,45 @@
+"""Route natural-language intent or structured calls to tools."""
+from __future__ import annotations
+import json, re
+from typing import Any
+from Tools.Core.tool_registry import ToolRegistry
+from Tools.Core.tool_executor import ToolExecutor
+from Tools.Core.tool_result import ToolResult
+
+_BLOCK = re.compile(
+    r"<\|tool_call\|>\s*(\{.*?\})\s*(?:<\|end_tool_call\|>|(?=<\|tool_call\|>)|$)",
+    re.DOTALL,
+)
+
+def parse_tool_calls(text: str) -> list[dict[str, Any]]:
+    calls = []
+    for m in _BLOCK.finditer(text or ""):
+        raw = m.group(1).strip()
+        raw = re.sub(r",\s*}", "}", raw)
+        try:
+            obj = json.loads(raw)
+        except Exception:
+            try:
+                obj = json.loads(raw.replace("'", '"'))
+            except Exception:
+                continue
+        if not isinstance(obj, dict) or "name" not in obj:
+            continue
+        args = obj.get("arguments") if "arguments" in obj else obj.get("args")
+        if args is None:
+            args = {k: v for k, v in obj.items() if k != "name"}
+        if not isinstance(args, dict):
+            args = {}
+        calls.append({"name": str(obj["name"]), "arguments": args})
+    return calls
+
+class ToolRouter:
+    def __init__(self, registry: ToolRegistry, executor: ToolExecutor | None = None):
+        self.registry = registry
+        self.executor = executor or ToolExecutor(registry)
+
+    def route_text(self, text: str) -> list[ToolResult]:
+        return [self.executor.run(c["name"], c.get("arguments") or {}) for c in parse_tool_calls(text)]
+
+    def route_call(self, name: str, arguments: dict | None = None) -> ToolResult:
+        return self.executor.run(name, arguments or {})

Brain_O_Codebase/brain_v0_5/Tools/Core/tool_scheduler.py

@@ -0,0 +1,26 @@
+"""Order tool calls (serial dependencies vs parallel)."""
+from __future__ import annotations
+from typing import Any
+from Tools.Core.tool_engine import ToolEngine
+from Tools.Core.tool_result import ToolResult
+
+class ToolScheduler:
+    def __init__(self, engine: ToolEngine):
+        self.engine = engine
+
+    def run_plan(self, steps: list[dict[str, Any]]) -> list[ToolResult]:
+        # steps: {name, arguments, parallel_group?}
+        results = []
+        i = 0
+        while i < len(steps):
+            group = [steps[i]]
+            g = steps[i].get("parallel_group")
+            j = i + 1
+            while g is not None and j < len(steps) and steps[j].get("parallel_group") == g:
+                group.append(steps[j]); j += 1
+            if len(group) > 1:
+                results.extend(self.engine.run_many(group, parallel=True))
+            else:
+                results.append(self.engine.run(group[0]["name"], group[0].get("arguments")))
+            i = j
+        return results

Brain_O_Codebase/brain_v0_5/Tools/Core/tool_session.py

@@ -0,0 +1,14 @@
+"""Session-scoped tool state (cwd, env, history)."""
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Any
+from Tools.Core.tool_context import ToolContext
+from Tools.Core.tool_result import ToolResult
+
+@dataclass
+class ToolSession:
+    context: ToolContext = field(default_factory=ToolContext)
+    history: list[dict[str, Any]] = field(default_factory=list)
+
+    def record(self, name: str, arguments: dict, result: ToolResult) -> None:
+        self.history.append({"name": name, "arguments": arguments, "ok": result.ok, "content": result.content[:500]})

Brain_O_Codebase/brain_v0_5/Tools/Core/tool_validator.py

@@ -0,0 +1,29 @@
+"""JSON-schema-like argument validation."""
+from __future__ import annotations
+from typing import Any, Optional
+
+def validate_args(schema: dict[str, dict], arguments: dict[str, Any]) -> Optional[str]:
+    if not isinstance(arguments, dict):
+        return "arguments must be an object"
+    for key, meta in schema.items():
+        if meta.get("required") and key not in arguments:
+            return f"missing required argument: {key}"
+        if key not in arguments:
+            continue
+        val = arguments[key]
+        typ = meta.get("type")
+        if typ == "string" and not isinstance(val, str):
+            return f"{key} must be string"
+        if typ == "integer" and not isinstance(val, int):
+            return f"{key} must be integer"
+        if typ == "number" and not isinstance(val, (int, float)):
+            return f"{key} must be number"
+        if typ == "boolean" and not isinstance(val, bool):
+            return f"{key} must be boolean"
+        if typ == "array" and not isinstance(val, list):
+            return f"{key} must be array"
+        if typ == "object" and not isinstance(val, dict):
+            return f"{key} must be object"
+        if "enum" in meta and val not in meta["enum"]:
+            return f"{key} must be one of {meta['enum']}"
+    return None

Brain_O_Codebase/brain_v0_5/Tools/Databases/__init__.py

@@ -0,0 +1,16 @@
+from Tools.Core.tool_factory import make_tool
+from Tools.Core.tool_result import ToolResult
+def sqlite_query(ctx=None, path: str = "", sql: str = "", **kw):
+    try:
+        import sqlite3
+        con = sqlite3.connect(path)
+        cur = con.execute(sql)
+        if sql.strip().lower().startswith("select"):
+            rows = cur.fetchmany(100)
+            return ToolResult("sqlite_query", True, str(rows))
+        con.commit()
+        return ToolResult("sqlite_query", True, f"ok rowcount={cur.rowcount}")
+    except Exception as e:
+        return ToolResult("sqlite_query", False, str(e), error_type="runtime")
+def register(registry):
+    registry.register(make_tool("sqlite_query", "Run SQLite SQL", {"path":{"type":"string","required":True},"sql":{"type":"string","required":True}}, sqlite_query, "databases", "db:write", parallel_safe=False))

Brain_O_Codebase/brain_v0_5/Tools/Databases/backup.py

@@ -0,0 +1 @@
+"""Databases: backup."""

Brain_O_Codebase/brain_v0_5/Tools/Databases/elasticsearch.py

@@ -0,0 +1 @@
+"""Databases: elasticsearch."""

Brain_O_Codebase/brain_v0_5/Tools/Databases/migrations.py

@@ -0,0 +1 @@
+"""Databases: migrations."""

Brain_O_Codebase/brain_v0_5/Tools/Databases/milvus.py

@@ -0,0 +1 @@
+"""Databases: milvus."""

Brain_O_Codebase/brain_v0_5/Tools/Databases/mongodb.py

@@ -0,0 +1 @@
+"""Databases: mongodb."""

Brain_O_Codebase/brain_v0_5/Tools/Databases/neo4j.py

@@ -0,0 +1 @@
+"""Databases: neo4j."""

Brain_O_Codebase/brain_v0_5/Tools/Databases/postgres.py

@@ -0,0 +1 @@
+"""Databases: postgres."""

Brain_O_Codebase/brain_v0_5/Tools/Databases/qdrant.py

@@ -0,0 +1 @@
+"""Databases: qdrant."""

Brain_O_Codebase/brain_v0_5/Tools/Databases/redis.py

@@ -0,0 +1 @@
+"""Databases: redis."""

Brain_O_Codebase/brain_v0_5/Tools/Databases/sql.py

@@ -0,0 +1 @@
+"""Databases: sql."""

Brain_O_Codebase/brain_v0_5/Tools/Databases/sqlite.py

@@ -0,0 +1 @@
+"""Databases: sqlite."""

Brain_O_Codebase/brain_v0_5/Tools/Documents/__init__.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+from pathlib import Path
+from Tools.Core.tool_factory import make_tool
+from Tools.Core.tool_result import ToolResult
+
+def _ingest(path: str) -> ToolResult:
+    try:
+        from brain.experimental.ingest import load_any
+        r = load_any(path)
+        return ToolResult("doc_read", True, r.to_prompt(max_chars=12000), meta={"errors": r.errors})
+    except Exception as e:
+        p = Path(path)
+        if p.suffix.lower() in {".txt", ".md", ".csv", ".json", ".yaml", ".yml", ".html", ".xml"}:
+            return ToolResult("doc_read", True, p.read_text(encoding="utf-8", errors="ignore")[:12000])
+        return ToolResult("doc_read", False, str(e), error_type="runtime")
+
+def pdf_read(ctx=None, path: str = "", **kw): return _ingest(path)
+def docx_read(ctx=None, path: str = "", **kw): return _ingest(path)
+def xlsx_read(ctx=None, path: str = "", **kw): return _ingest(path)
+
+def register(registry):
+    for name, fn in [("pdf_read", pdf_read), ("docx_read", docx_read), ("xlsx_read", xlsx_read)]:
+        registry.register(make_tool(name, f"Read {name.split('_')[0].upper()} via ingest", {"path":{"type":"string","required":True}}, fn, "documents", "fs:read"))