Add NeuroRift package scaffold, runtime & model checks, secure command runner, CLI and skill system

model_capability_check.py

@@ -0,0 +1,92 @@
+"""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,2 @@
+class ChannelRouter:
+    def route(self, msg: dict): return msg

neurorift/channels/cli_channel.py

@@ -0,0 +1,5 @@
+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,5 @@
+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,5 @@
+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,5 @@
+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,11 @@
+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,6 @@
+"""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,5 @@
+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,15 @@
+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,10 @@
+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,5 @@
+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,6 @@
+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,4 @@
+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,3 @@
+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,2 @@
+class APIServer:
+    def start(self): return True

neurorift/gateway/auth_manager.py

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

neurorift/gateway/websocket_gateway.py

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

neurorift/memory/__init__.py

@@ -0,0 +1 @@
+

neurorift/memory/long_term_memory.py

@@ -0,0 +1,3 @@
+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,2 @@
+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,4 @@
+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,3 @@
+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,2 @@
+class ContextBuilder:
+    def build(self, session, memories): return {"session": session.session_id, "memories": memories}

neurorift/models/model_failover.py

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

neurorift/models/model_router.py

@@ -0,0 +1,2 @@
+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,2 @@
+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,19 @@
+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())

neurorift/sessions/session_manager.py

@@ -0,0 +1,13 @@
+import uuid
+from pathlib import Path
+from neurorift.sessions.session_context import SessionContext, SessionState
+from neurorift.sessions.session_store import SessionStore
+
+class SessionManager:
+    def __init__(self, root: Path):
+        self.store = SessionStore(root)
+        self.sessions: dict[str, SessionContext] = {}
+    def create_session(self, user_id: str, channel: str) -> SessionContext:
+        sid=str(uuid.uuid4()); s=SessionContext(session_id=sid,user_id=user_id,channel=channel,state=SessionState.ACTIVE)
+        self.sessions[sid]=s; self.store.save(s); return s
+    def get_session(self, sid: str): return self.sessions.get(sid) or self.store.load(sid)

neurorift/sessions/session_pruner.py

@@ -0,0 +1,3 @@
+class SessionPruner:
+    def prune(self, sessions: dict, max_idle_hours: int = 24) -> list[str]:
+        return []

neurorift/sessions/session_store.py

@@ -0,0 +1,12 @@
+import json
+from pathlib import Path
+from neurorift.sessions.session_context import SessionContext
+
+class SessionStore:
+    def __init__(self, root: Path):
+        self.root = root; self.root.mkdir(parents=True, exist_ok=True)
+    def path(self, sid: str) -> Path: return self.root / f"{sid}.json"
+    def save(self, session: SessionContext): self.path(session.session_id).write_text(json.dumps(session.__dict__, default=str), encoding='utf-8')
+    def load(self, sid: str):
+        p=self.path(sid)
+        return SessionContext(**json.loads(p.read_text(encoding='utf-8'))) if p.exists() else None

neurorift/skill_store/__init__.py

@@ -0,0 +1 @@
+

neurorift/skill_store/cache/__init__.py

@@ -0,0 +1 @@
+

neurorift/skill_store/installed/__init__.py

@@ -0,0 +1 @@
+

neurorift/skill_store/installed/recon_scanner/README.md

@@ -0,0 +1 @@
+# recon_scanner

neurorift/skill_store/installed/recon_scanner/__init__.py

@@ -0,0 +1 @@
+

neurorift/skill_store/installed/recon_scanner/requirements.txt

@@ -0,0 +1 @@
+requests

neurorift/skill_store/installed/recon_scanner/skill.json

@@ -0,0 +1,8 @@
+{
+  "name": "recon_scanner",
+  "version": "1.0",
+  "description": "basic reconnaissance scanner",
+  "entrypoint": "skill.py",
+  "command": "scan",
+  "dependencies": ["nmap"]
+}

neurorift/skill_store/installed/recon_scanner/skill.py

@@ -0,0 +1,2 @@
+def run(target: str = '127.0.0.1'):
+    return {'action': 'scan', 'target': target, 'status': 'simulated'}

neurorift/skills/__init__.py

@@ -0,0 +1 @@
+

neurorift/skills/installer.py

@@ -0,0 +1,24 @@
+import json, shutil
+from pathlib import Path
+from neurorift.skills.skill_validator import SkillValidator
+from neurorift.skills.registry import SkillRegistry
+
+class SkillInstaller:
+    def __init__(self, base: Path):
+        self.base=base; self.installed=base/'installed'; self.cache=base/'cache'
+        self.installed.mkdir(parents=True, exist_ok=True); self.cache.mkdir(parents=True, exist_ok=True)
+        self.validator=SkillValidator(); self.registry=SkillRegistry(base)
+    def install(self, pkg: Path):
+        ok,missing=self.validator.validate(pkg)
+        if not ok: return {'success': False, 'error': f'missing:{missing}'}
+        meta=json.loads((pkg/'skill.json').read_text(encoding='utf-8')); name=meta['name']
+        dst=self.installed/name
+        if dst.exists(): shutil.rmtree(dst)
+        shutil.copytree(pkg,dst)
+        self.registry.add(name)
+        return {'success': True, 'name': name, 'path': str(dst)}
+    def uninstall(self, name: str):
+        dst=self.installed/name
+        if dst.exists(): shutil.rmtree(dst)
+        self.registry.remove(name)
+        return {'success': True, 'name': name}

neurorift/skills/loader.py

@@ -0,0 +1,9 @@
+import importlib.util, json
+from pathlib import Path
+class SkillLoader:
+    def run(self, skill_dir: Path, **kwargs):
+        meta=json.loads((skill_dir/'skill.json').read_text(encoding='utf-8'))
+        entry=skill_dir/meta['entrypoint']
+        spec=importlib.util.spec_from_file_location(f"skill_{meta['name']}", entry)
+        mod=importlib.util.module_from_spec(spec); spec.loader.exec_module(mod)
+        return mod.run(**kwargs) if hasattr(mod, 'run') else {'error':'missing run()'}

neurorift/skills/registry.py

@@ -0,0 +1,15 @@
+import json
+from pathlib import Path
+class SkillRegistry:
+    def __init__(self, root: Path):
+        self.path = root / 'registry.json'; root.mkdir(parents=True, exist_ok=True)
+        if not self.path.exists(): self.path.write_text(json.dumps({'installed_skills': []}, indent=2), encoding='utf-8')
+    def read(self): return json.loads(self.path.read_text(encoding='utf-8'))
+    def list(self): return self.read().get('installed_skills', [])
+    def add(self, name):
+        data=self.read(); skills=data.setdefault('installed_skills', [])
+        if name not in skills: skills.append(name)
+        self.path.write_text(json.dumps(data, indent=2), encoding='utf-8')
+    def remove(self, name):
+        data=self.read(); data['installed_skills']=[s for s in data.get('installed_skills',[]) if s!=name]
+        self.path.write_text(json.dumps(data, indent=2), encoding='utf-8')