Add NeuroRift package skeleton, skill system, runtime/model checks, and hardened tool execution

model_capability_check.py

@@ -0,0 +1,99 @@
+"""Ollama model capability verification for autonomous NeuroRift agent mode."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from typing import Any
+
+CAPABILITY_PROMPT = """Evaluate whether you can reliably perform the following tasks:
+
+* structured tool invocation
+* Linux command generation
+* file creation and modification
+* interpreting tool outputs
+* multi-step reasoning for autonomous agents
+
+Return a JSON response:
+{
+"tool_usage": true/false,
+"command_generation": true/false,
+"filesystem_operations": true/false,
+"multi_step_reasoning": true/false,
+"agent_ready": true/false
+}"""
+
+
+def _extract_json(raw_text: str) -> dict[str, Any]:
+    raw_text = (raw_text or "").strip()
+    start = raw_text.find("{")
+    end = raw_text.rfind("}")
+    if start == -1 or end == -1 or end <= start:
+        raise ValueError("No JSON object found in model response")
+    return json.loads(raw_text[start : end + 1])
+
+
+def verify_model_capabilities(model_name: str) -> dict[str, Any]:
+    try:
+        proc = subprocess.run(
+            ["ollama", "run", model_name, CAPABILITY_PROMPT],
+            capture_output=True,
+            text=True,
+            timeout=120,
+            check=False,
+        )
+    except FileNotFoundError:
+        return {"ok": False, "error": "ollama_missing", "agent_ready": False}
+    except Exception as exc:  # defensive for unstable environments
+        return {
+            "ok": False,
+            "error": f"ollama_exec_error:{type(exc).__name__}",
+            "agent_ready": False,
+        }
+
+    if proc.returncode != 0:
+        return {
+            "ok": False,
+            "error": f"ollama_returned_{proc.returncode}",
+            "stderr": proc.stderr,
+            "agent_ready": False,
+        }
+
+    try:
+        parsed = _extract_json(proc.stdout)
+    except Exception as exc:
+        return {
+            "ok": False,
+            "error": f"invalid_capability_json:{type(exc).__name__}",
+            "raw": proc.stdout[:1000],
+            "agent_ready": False,
+        }
+
+    required = {
+        "tool_usage",
+        "command_generation",
+        "filesystem_operations",
+        "multi_step_reasoning",
+        "agent_ready",
+    }
+    if not required.issubset(parsed):
+        return {
+            "ok": False,
+            "error": "capability_fields_missing",
+            "parsed": parsed,
+            "agent_ready": False,
+        }
+
+    parsed["ok"] = bool(parsed.get("agent_ready"))
+    return parsed
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Check Ollama model capability for NeuroRift agent mode"
+    )
+    parser.add_argument("--model", required=True)
+    args = parser.parse_args()
+    print(json.dumps(verify_model_capabilities(args.model), indent=2))

neurorift/__init__.py

@@ -0,0 +1 @@
+

neurorift/channels/__init__.py

@@ -0,0 +1 @@
+

neurorift/channels/channel_router.py

@@ -0,0 +1,3 @@
+class ChannelRouter:
+    def route(self, msg: dict):
+        return msg

neurorift/channels/cli_channel.py

@@ -0,0 +1,12 @@
+class Channel:
+    def connect(self):
+        return True
+
+    def receive_message(self, payload=None):
+        return payload or {}
+
+    def send_message(self, message):
+        return message
+
+    def close(self):
+        return True

neurorift/channels/discord_channel.py

@@ -0,0 +1,12 @@
+class Channel:
+    def connect(self):
+        return True
+
+    def receive_message(self, payload=None):
+        return payload or {}
+
+    def send_message(self, message):
+        return message
+
+    def close(self):
+        return True

neurorift/channels/telegram_channel.py

@@ -0,0 +1,12 @@
+class Channel:
+    def connect(self):
+        return True
+
+    def receive_message(self, payload=None):
+        return payload or {}
+
+    def send_message(self, message):
+        return message
+
+    def close(self):
+        return True

neurorift/channels/web_channel.py

@@ -0,0 +1,12 @@
+class Channel:
+    def connect(self):
+        return True
+
+    def receive_message(self, payload=None):
+        return payload or {}
+
+    def send_message(self, message):
+        return message
+
+    def close(self):
+        return True

neurorift/clawhub/__init__.py

@@ -0,0 +1 @@
+

neurorift/clawhub/clawhub_api.py

@@ -0,0 +1,2 @@
+class ClawHubAPI:
+    base_url = "https://clawhub.example/api"

neurorift/clawhub/clawhub_client.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+import shutil
+
+
+class ClawHubClient:
+    def __init__(self, cache_dir: Path):
+        self.cache_dir = cache_dir
+        cache_dir.mkdir(parents=True, exist_ok=True)
+
+    def fetch_skill(self, skill_name: str, source_dir: Path) -> Path:
+        src = source_dir / skill_name
+        if not src.exists():
+            raise FileNotFoundError(skill_name)
+        dst = self.cache_dir / skill_name
+        if dst.exists():
+            shutil.rmtree(dst)
+        shutil.copytree(src, dst)
+        return dst

neurorift/clawhub/clawhub_resolver.py

@@ -0,0 +1,3 @@
+class ClawHubResolver:
+    def resolve(self, skill_name: str) -> str:
+        return f"https://clawhub.example/skills/{skill_name}"

neurorift/cli/__init__.py

@@ -0,0 +1 @@
+

neurorift/cli/neurorift_cli.py

@@ -0,0 +1,7 @@
+"""Package-level CLI helper that delegates to global entrypoint."""
+
+from __future__ import annotations
+
+from neurorift_cli import build_parser, install_global_wrapper, main
+
+__all__ = ["build_parser", "install_global_wrapper", "main"]

neurorift/config/__init__.py

@@ -0,0 +1 @@
+

neurorift/config/channel_config.py

@@ -0,0 +1 @@
+CHANNELS = ["cli", "websocket", "discord", "telegram", "api"]

neurorift/config/model_config.py

@@ -0,0 +1 @@
+MODEL_PROVIDERS = ["deepseek", "mistral", "llama", "openai"]

neurorift/config/settings.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class Settings:
+    data_dir: Path = Path.home() / ".neurorift"

neurorift/core/__init__.py

@@ -0,0 +1 @@
+

neurorift/core/agent_loop.py

@@ -0,0 +1,3 @@
+class AgentLoop:
+    async def handle_message(self, session, message: str) -> dict:
+        return {"success": True, "response": f"Session {session.session_id}: {message}"}

neurorift/core/agent_manager.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+from neurorift.core.agent_loop import AgentLoop
+from neurorift.sessions.session_manager import SessionManager
+
+
+@dataclass
+class AgentHandle:
+    session_id: str
+    user_id: str
+    channel: str
+
+
+class AgentManager:
+    def __init__(self, session_manager: SessionManager, agent_loop: AgentLoop):
+        self.session_manager = session_manager
+        self.agent_loop = agent_loop
+        self.handles: dict[str, AgentHandle] = {}

neurorift/core/planner.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class PlannedStep:
+    order: int
+    action: str
+
+
+class Planner:
+    def create_plan(self, objective: str) -> list[PlannedStep]:
+        return (
+            [PlannedStep(order=1, action=f"Investigate: {objective}")]
+            if objective
+            else []
+        )

neurorift/core/task_router.py

@@ -0,0 +1,3 @@
+class TaskRouter:
+    def route(self, task: str) -> dict:
+        return {"task": task, "route": "agent_loop"}

neurorift/execution/__init__.py

@@ -0,0 +1 @@
+

neurorift/execution/command_runner.py

@@ -0,0 +1,12 @@
+import subprocess
+
+
+class CommandRunner:
+    def run(self, cmd: list[str]):
+        p = subprocess.run(cmd, capture_output=True, text=True, check=False)
+        return {
+            "success": p.returncode == 0,
+            "stdout": p.stdout,
+            "stderr": p.stderr,
+            "exit_code": p.returncode,
+        }

neurorift/execution/resource_limits.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class ResourceLimits:
+    timeout_seconds: int = 30
+    memory_limit_mb: int = 512
+    cpu_seconds: int = 20

neurorift/execution/retry_manager.py

@@ -0,0 +1,9 @@
+import time
+
+
+class RetryManager:
+    def __init__(self, retries=2):
+        self.retries = retries
+
+    def wait(self, attempt):
+        time.sleep(2**attempt)

neurorift/execution/sandbox_runner.py

@@ -0,0 +1,5 @@
+from neurorift.execution.command_runner import CommandRunner
+
+
+class SandboxRunner(CommandRunner):
+    pass

neurorift/gateway/__init__.py

@@ -0,0 +1 @@
+

neurorift/gateway/api_server.py

@@ -0,0 +1,3 @@
+class APIServer:
+    def start(self):
+        return True

neurorift/gateway/auth_manager.py

@@ -0,0 +1,3 @@
+class AuthManager:
+    def validate(self, token: str):
+        return bool(token)

neurorift/gateway/websocket_gateway.py

@@ -0,0 +1,3 @@
+class WebSocketGateway:
+    def start(self):
+        return True

neurorift/memory/__init__.py

@@ -0,0 +1 @@
+

neurorift/memory/long_term_memory.py

@@ -0,0 +1,6 @@
+class LongTermMemory:
+    def __init__(self):
+        self.data = {}
+
+    def store(self, user_id: str, key: str, value):
+        self.data.setdefault(user_id, {})[key] = value

neurorift/memory/memory_compaction.py

@@ -0,0 +1,3 @@
+class MemoryCompaction:
+    def compact(self, messages: list[str]):
+        return {"summary": " ".join(messages[:10]), "kept": messages[-10:]}

neurorift/memory/short_term_memory.py

@@ -0,0 +1,9 @@
+from collections import defaultdict, deque
+
+
+class ShortTermMemory:
+    def __init__(self, limit: int = 30):
+        self.buffers = defaultdict(lambda: deque(maxlen=limit))
+
+    def add(self, sid: str, msg: str):
+        self.buffers[sid].append(msg)

neurorift/memory/vector_memory.py

@@ -0,0 +1,6 @@
+class VectorMemory:
+    def semantic_search(self, user_id: str, query: str, top_k: int = 5):
+        return []
+
+    def time_based_retrieval(self, user_id: str, limit: int = 10):
+        return []

neurorift/models/__init__.py

@@ -0,0 +1 @@
+

neurorift/models/context_builder.py

@@ -0,0 +1,3 @@
+class ContextBuilder:
+    def build(self, session, memories):
+        return {"session": session.session_id, "memories": memories}

neurorift/models/model_failover.py

@@ -0,0 +1,3 @@
+class ModelFailover:
+    def pick(self, providers):
+        return providers[0] if providers else "fallback"

neurorift/models/model_router.py

@@ -0,0 +1,8 @@
+class ModelRouter:
+    async def generate(self, prompt: str):
+        return {
+            "response": prompt,
+            "model": "openai",
+            "tokens": len(prompt.split()),
+            "cost": 0.0,
+        }

neurorift/models/prompt_builder.py

@@ -0,0 +1,3 @@
+class PromptBuilder:
+    def build(self, message: str, context: dict):
+        return f"{context}\n{message}"

neurorift/sessions/__init__.py

@@ -0,0 +1 @@
+

neurorift/sessions/session_context.py

@@ -0,0 +1,29 @@
+from dataclasses import dataclass, field
+from enum import Enum
+from datetime import datetime, timezone
+
+
+class SessionState(str, Enum):
+    CREATED = "CREATED"
+    ACTIVE = "ACTIVE"
+    IDLE = "IDLE"
+    PAUSED = "PAUSED"
+    CLOSED = "CLOSED"
+
+
+@dataclass
+class SessionContext:
+    session_id: str
+    user_id: str
+    channel: str
+    state: SessionState = SessionState.CREATED
+    message_history: list[dict] = field(default_factory=list)
+    tool_usage: list[dict] = field(default_factory=list)
+    context_window: list[str] = field(default_factory=list)
+    memory_references: list[str] = field(default_factory=list)
+    created_at: str = field(
+        default_factory=lambda: datetime.now(timezone.utc).isoformat()
+    )
+    updated_at: str = field(
+        default_factory=lambda: datetime.now(timezone.utc).isoformat()
+    )