| """ |
| AURA - THE ONE FILE v10 👻🪄 |
| ========================= |
| Everything in a single Python file: skills, agent, dataset generator, |
| refinery, QLoRA training and evaluation. |
| |
| USAGE |
| Kaggle (T4 x2): !python AURA_onefile.py train |
| Generate data only: python AURA_onefile.py data --n 8000 |
| Run the spirit: python AURA_onefile.py agent --adapter ./aura_lora |
| Demo (no model): python AURA_onefile.py agent --demo --dry-run |
| Check skills: python AURA_onefile.py selftest |
| Evaluate router: python AURA_onefile.py eval --adapter ./aura_lora |
| |
| Install first: pip install torch transformers peft bitsandbytes accelerate requests pillow |
| |
| v9 fixes (over v8): |
| - evaluate() no longer crashes on chitchat rows (JSONDecodeError killed the |
| run right after training, before GGUF export + zip) |
| - GGUF export uses a VALID converter outtype (q8_0); "q4_k_m" is not accepted |
| by llama.cpp's convert_hf_to_gguf.py |
| - eval now reads the held-out aura_eval_data.jsonl instead of regenerating |
| - proportional holdout (v8's hard 400-cap broke small runs) |
| - dropped-row reporting in the token builder |
| - eval failure no longer aborts the pipeline |
| """ |
|
|
|
|
|
|
| |
| |
| |
|
|
| import json |
| import os |
| import re |
| import shutil |
| import subprocess |
| import sys |
| import tempfile |
| import time |
| from dataclasses import dataclass, field |
| from typing import Callable, Dict, Any, List, Optional |
|
|
| IS_WINDOWS = os.name == "nt" |
| if IS_WINDOWS: |
| for _stream in (sys.stdout, sys.stderr): |
| try: |
| _stream.reconfigure(encoding="utf-8", errors="replace") |
| except Exception: |
| pass |
|
|
|
|
| |
| |
| |
|
|
| |
| DANGEROUS_PATTERNS = [ |
| r"\brm\s+-rf\s+/", |
| r"\bformat\s+[a-z]:", |
| r"\bmkfs\b", |
| r"\bdel\s+/[sq]", |
| r"\brd\s+/s", |
| r"\bshutdown\b", |
| r"\bdiskpart\b", |
| r":\(\)\{.*\};:", |
| ] |
|
|
| |
| RISKY_PATTERNS = [ |
| r"\brm\b", r"\bdel\b", r"\brmdir\b", r"\brd\b", r"\bmv\b", |
| r"\bsudo\b", r"\bapt\b", r"\bpip\b", r"\binstall\b", |
| r"\breg(?:edit| add)\b", r"\bnetsh\b", r"\bchmod\b", r"\bchown\b", |
| ] |
|
|
|
|
| def _matches(text: str, patterns: List[str]) -> bool: |
| text_l = text.lower() |
| return any(re.search(p, text_l) for p in patterns) |
|
|
|
|
| def default_confirm(action_desc: str) -> bool: |
| """Ask the human before a destructive action. Swap for UI later.""" |
| try: |
| ans = input(f"\n[AURA CONFIRM] {action_desc}\nType 'yes' to allow: ") |
| return ans.strip().lower() in ("yes", "y") |
| except Exception: |
| return False |
|
|
|
|
| def default_log(msg: str) -> None: |
| print(f"[aura] {msg}") |
|
|
|
|
| |
| |
| |
|
|
| SANDBOX_BLOCKLIST = DANGEROUS_PATTERNS + [r"\bshutdown\b", r"\bRestart-Computer\b"] |
|
|
|
|
| def python_sandbox(code: str, timeout: int = 10) -> str: |
| """Run Python code in a fresh subprocess with a timeout. |
| |
| NOT a hard security boundary - it stops accidents (infinite loops, |
| fat-fingered deletes), not determined attackers. Run AURA's risky |
| skills inside a Docker container / VM for real isolation. |
| """ |
| if _matches(code, SANDBOX_BLOCKLIST): |
| return "ERROR: command matches blocked pattern (safety guardrail)." |
|
|
| with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False, |
| encoding="utf-8") as f: |
| f.write(code) |
| path = f.name |
| try: |
| proc = subprocess.run( |
| [sys.executable, path], |
| capture_output=True, text=True, timeout=timeout, |
| ) |
| out = (proc.stdout or "") + (("\nSTDERR: " + proc.stderr) if proc.stderr else "") |
| return out.strip() or "(no output)" |
| except subprocess.TimeoutExpired: |
| return f"ERROR: code timed out after {timeout}s." |
| except Exception as e: |
| return f"ERROR: {e}" |
| finally: |
| try: |
| os.remove(path) |
| except OSError: |
| pass |
|
|
|
|
| def shell(command: str, timeout: int = 60, |
| confirm: Callable[[str], bool] = default_confirm) -> str: |
| """Run a shell command (cmd on Windows, bash elsewhere) with guardrails.""" |
| if _matches(command, DANGEROUS_PATTERNS): |
| return "ERROR: command blocked by AURA safety guardrail." |
| if _matches(command, RISKY_PATTERNS) and not confirm(f"Run shell command: {command}"): |
| return "Cancelled by user." |
|
|
| try: |
| proc = subprocess.run(command, shell=True, capture_output=True, |
| text=True, timeout=timeout) |
| out = (proc.stdout or "").strip() |
| err = (proc.stderr or "").strip() |
| result = out + (("\nSTDERR: " + err) if err else "") |
| return result.strip() or "(no output)" |
| except subprocess.TimeoutExpired: |
| return f"ERROR: command timed out after {timeout}s." |
| except Exception as e: |
| return f"ERROR: {e}" |
|
|
|
|
| |
| |
| |
|
|
| @dataclass |
| class SkillContext: |
| cwd: str = os.path.expanduser("~") |
| confirm: Callable[[str], bool] = default_confirm |
| log: Callable[[str], None] = default_log |
| dry_run: bool = False |
|
|
|
|
| |
| |
| |
|
|
| def aura_manager(args: Dict[str, Any], ctx: SkillContext) -> str: |
| action = args.get("action") |
| path = os.path.join(ctx.cwd, args.get("path", "")) if args.get("path") else ctx.cwd |
|
|
| def would(msg): |
| ctx.log(f"[dry-run] {msg}") |
| return f"[dry-run] {msg}" |
|
|
| if action == "create_folder": |
| name = args.get("name", "NewFolder") |
| full = os.path.join(path, name) |
| if ctx.dry_run: return would(f"create folder {full}") |
| os.makedirs(full, exist_ok=True) |
| return f"Folder created: {full}" |
|
|
| if action == "create_file": |
| name = args.get("name", "note.txt") |
| content = args.get("content", "") |
| full = os.path.join(path, name) |
| if ctx.dry_run: return would(f"create file {full}") |
| os.makedirs(path, exist_ok=True) |
| with open(full, "w", encoding="utf-8") as f: |
| f.write(content) |
| return f"File saved: {full}" |
|
|
| if action == "save_file": |
| return aura_manager({**args, "action": "create_file"}, ctx) |
|
|
| if action == "delete": |
| target = args.get("target", "") |
| full = os.path.join(ctx.cwd, target) |
| if not os.path.exists(full): |
| return f"ERROR: not found: {full}" |
| if ctx.dry_run: return would(f"delete {full}") |
| if not ctx.confirm(f"DELETE {full} (cannot be undone!)"): |
| return "Cancelled by user." |
| if os.path.isdir(full): |
| shutil.rmtree(full) |
| else: |
| os.remove(full) |
| return f"Deleted: {full}" |
|
|
| if action == "move": |
| src = os.path.join(ctx.cwd, args["source"]) |
| dst = os.path.join(ctx.cwd, args["destination"]) |
| if not os.path.exists(src): |
| return f"ERROR: source not found: {src}" |
| if ctx.dry_run: return would(f"move {src} -> {dst}") |
| if os.path.exists(dst) and not ctx.confirm(f"OVERWRITE {dst}?"): |
| return "Cancelled by user." |
| os.makedirs(os.path.dirname(dst) or ".", exist_ok=True) |
| shutil.move(src, dst) |
| return f"Moved: {src} -> {dst}" |
|
|
| if action == "copy": |
| src = os.path.join(ctx.cwd, args["source"]) |
| dst = os.path.join(ctx.cwd, args["destination"]) |
| if not os.path.exists(src): |
| return f"ERROR: source not found: {src}" |
| if ctx.dry_run: return would(f"copy {src} -> {dst}") |
| os.makedirs(os.path.dirname(dst) or ".", exist_ok=True) |
| shutil.copy2(src, dst) |
| return f"Copied: {src} -> {dst}" |
|
|
| if action == "list": |
| if ctx.dry_run: return would(f"list {path}") |
| try: |
| items = sorted(os.listdir(path)) |
| return "\n".join(items) or "(empty folder)" |
| except Exception as e: |
| return f"ERROR: {e}" |
|
|
| if action == "search_files": |
| query = args.get("query", "").lower() |
| root = os.path.join(ctx.cwd, args.get("root", ".")) |
| hits = [] |
| for dirpath, _dirs, files in os.walk(root): |
| for fn in files: |
| if query in fn.lower(): |
| hits.append(os.path.join(dirpath, fn)) |
| if len(hits) >= 50: |
| break |
| return "\n".join(hits) if hits else "No matching files found." |
|
|
| if action == "organize": |
| """Move files in a folder into sub-folders by extension.""" |
| folder = os.path.join(ctx.cwd, args.get("folder", ".")) |
| if not os.path.isdir(folder): |
| return f"ERROR: folder not found: {folder}" |
| moved = 0 |
| for fn in os.listdir(folder): |
| src = os.path.join(folder, fn) |
| if not os.path.isfile(src): |
| continue |
| ext = os.path.splitext(fn)[1].lstrip(".").lower() or "misc" |
| dst_dir = os.path.join(folder, ext) |
| if ctx.dry_run: |
| would(f"move {src} -> {dst_dir}") |
| else: |
| os.makedirs(dst_dir, exist_ok=True) |
| shutil.move(src, os.path.join(dst_dir, fn)) |
| moved += 1 |
| return f"Organized {moved} files into extension folders inside {folder}." |
|
|
| return (f"ERROR: unknown action '{action}' for aura_manager. Valid actions: " |
| "create_folder, create_file, save_file, delete, move, copy, list, search_files, organize") |
|
|
|
|
| |
| |
| |
|
|
| |
| OFFICIAL_DOMAINS = { |
| "microsoft.com", "store.microsoft.com", "visualstudio.com", |
| "code.visualstudio.com", "google.com", "mozilla.org", "notepad-plus-plus.org", |
| "7-zip.org", "python.org", "videolan.org", "vlc.cc", "discord.com", |
| "slack.com", "zoom.us", "adobe.com", "spotify.com", "obsproject.com", |
| "git-scm.com", "github.com", "gitlab.com", "blender.org", "audacityteam.org", |
| "libreoffice.org", "winrar.com", "ubuntu.com", "nodejs.org", "docker.com", |
| } |
|
|
|
|
| def _domain_is_allowed(url: str) -> bool: |
| try: |
| host = re.sub(r"^https?://", "", url).split("/")[0].lower() |
| host = host.split(":")[0] |
| return any(host == d or host.endswith("." + d) for d in OFFICIAL_DOMAINS) |
| except Exception: |
| return False |
|
|
|
|
| def aura_installer(args: Dict[str, Any], ctx: SkillContext) -> str: |
| action = args.get("action") |
| query = args.get("query", "") |
|
|
| if action == "search": |
| if not IS_WINDOWS: |
| return "ERROR: winget search is Windows-only (use your package manager)." |
| out = shell(f'winget search "{query}" --accept-source-agreements', |
| confirm=lambda _: True) |
| return out or "No results found." |
|
|
| if action == "install": |
| app_id = args.get("app_id", query) |
| url = args.get("download_url") |
| if url: |
| if not _domain_is_allowed(url): |
| return (f"REFUSED: {url} is not in AURA's official-domains " |
| f"allowlist. Install manually if you trust it.") |
| if not ctx.confirm(f"Download and install from {url}"): |
| return "Cancelled by user." |
| out = shell(f'curl -L -o setup_installer "{url}" && ' |
| f'start setup_installer', confirm=lambda _: True) |
| return out |
| if not IS_WINDOWS: |
| return "ERROR: winget install is Windows-only." |
| if not ctx.confirm(f"Install '{app_id}' via winget"): |
| return "Cancelled by user." |
| out = shell(f'winget install --id "{app_id}" -e ' |
| f'--accept-source-agreements --accept-package-agreements', |
| confirm=lambda _: True) |
| return out or "Install command sent." |
|
|
| if action == "uninstall": |
| app_id = args.get("app_id", query) |
| if not ctx.confirm(f"UNINSTALL '{app_id}'"): |
| return "Cancelled by user." |
| return shell(f'winget uninstall --id "{app_id}" -e', |
| confirm=lambda _: True) if IS_WINDOWS else \ |
| "ERROR: winget uninstall is Windows-only." |
|
|
| if action == "list_installed": |
| return shell("winget list", confirm=lambda _: True) if IS_WINDOWS \ |
| else "ERROR: winget list is Windows-only." |
|
|
| return "ERROR: unknown action '%s' for aura_installer. Valid actions: search, install, uninstall, list_installed" % action |
|
|
|
|
| |
| |
| |
|
|
| APP_ALIASES = { |
| "chrome": "chrome", "google chrome": "chrome", |
| "notepad": "notepad", "calculator": "calc", |
| "vscode": "code", "vs code": "code", "visual studio code": "code", |
| "spotify": "spotify", "explorer": "explorer", "file manager": "explorer", |
| "cmd": "cmd", "terminal": IS_WINDOWS and "cmd" or "x-terminal-emulator", |
| "paint": "mspaint", "word": "winword", "excel": "excel", |
| "edge": "msedge", "firefox": "firefox", "settings": "ms-settings:", |
| } |
| SITE_ALIASES = { |
| "youtube": "https://www.youtube.com", |
| "google": "https://www.google.com", |
| "github": "https://github.com", |
| "wikipedia": "https://www.wikipedia.org", |
| "gmail": "https://mail.google.com", |
| "stack overflow": "https://stackoverflow.com", |
| "huggingface": "https://huggingface.co", |
| "kaggle": "https://www.kaggle.com", |
| "chatgpt": "https://chat.openai.com", |
| } |
|
|
|
|
| def aura_launchpad(args: Dict[str, Any], ctx: SkillContext) -> str: |
| action = args.get("action") |
| target = (args.get("target") or "").strip() |
|
|
| |
| |
| _valid = {"open_app", "open_website", "search_browser", "open_file"} |
| if action not in _valid and target: |
| _ka, _ks = target.lower(), target.lower().replace(" ", "") |
| if _ka in APP_ALIASES: |
| action = "open_app" |
| elif _ks in SITE_ALIASES or "://" in target or \ |
| target.lower().endswith((".com", ".org", ".in", ".net", ".io")): |
| action = "open_website" |
| elif os.path.exists(os.path.join(ctx.cwd, target)): |
| action = "open_file" |
| if action in _valid: |
| ctx.log(f"[self-heal] inferred action '{action}' from target '{target}'") |
|
|
| if action == "open_app": |
| key = target.lower() |
| exe = APP_ALIASES.get(key, target) |
| if ctx.dry_run: |
| return f"[dry-run] open app '{exe}'" |
| if IS_WINDOWS: |
| os.system(f'start "" "{exe}"') |
| return f"Launched app: {target}" |
| return shell(f"{exe} &", confirm=lambda _: True) or f"Tried to launch: {target}" |
|
|
| if action == "open_website": |
| key = target.lower().replace(" ", "") |
| url = SITE_ALIASES.get(key, target if "://" in target |
| else "https://" + target) |
| if ctx.dry_run: |
| return f"[dry-run] open website {url}" |
| import webbrowser |
| webbrowser.open(url) |
| return f"Opened website: {url}" |
|
|
| if action == "search_browser": |
| |
| query = args.get("query", "") |
| engine = args.get("engine", "duckduckgo") |
| import urllib.parse |
| import webbrowser |
| q = urllib.parse.quote_plus(query) |
| urls = { |
| "google": f"https://www.google.com/search?q={q}", |
| "duckduckgo": f"https://duckduckgo.com/?q={q}", |
| "youtube": f"https://www.youtube.com/results?search_query={q}", |
| "wikipedia": f"https://en.wikipedia.org/w/index.php?search={q}", |
| } |
| url = urls.get(engine, urls["duckduckgo"]) |
| browser = args.get("browser", "") |
| if ctx.dry_run: |
| return f"[dry-run] open new tab: {url}" |
| if browser and IS_WINDOWS: |
| os.system(f'start "" "{browser}" "{url}"') |
| else: |
| webbrowser.open(url) |
| return f"Opened new tab ({engine} search): {query}" |
|
|
| if action == "open_file": |
| full = os.path.join(ctx.cwd, target) |
| if not os.path.exists(full): |
| return f"ERROR: file not found: {full}" |
| if ctx.dry_run: |
| return f"[dry-run] open file {full}" |
| if IS_WINDOWS: |
| os.startfile(full) |
| return f"Opened file: {full}" |
| return shell(f'xdg-open "{full}"', confirm=lambda _: True) |
|
|
| return "ERROR: unknown action '%s' for aura_launchpad. Valid actions: open_app, open_website, search_browser, open_file" % action |
|
|
|
|
| |
| |
| |
|
|
| def _web_search_ddg(query: str, max_results: int = 5) -> str: |
| """DuckDuckGo search - no API key. Tries the ddgs package, then HTML.""" |
| if not query.strip(): |
| return "ERROR: empty query." |
| |
| for mod in ("ddgs", "duckduckgo_search"): |
| try: |
| m = __import__(mod) |
| DDGS = getattr(m, "DDGS") |
| with DDGS() as d: |
| hits = list(d.text(query, max_results=max_results)) |
| if hits: |
| return "\n".join( |
| f"- {h.get('title', '')}\n {h.get('href', '')}\n {h.get('body', '')[:200]}" |
| for h in hits) |
| except Exception: |
| pass |
| |
| try: |
| import requests |
| except ImportError: |
| return "ERROR: install `requests` (pip install requests)." |
| try: |
| r = requests.post("https://html.duckduckgo.com/html/", data={"q": query}, |
| headers={"User-Agent": "Mozilla/5.0 (AURA agent)"}, |
| timeout=15) |
| links = re.findall(r'class="result__a"[^>]*href="([^"]+)"[^>]*>(.*?)</a>', |
| r.text, re.S)[:max_results] |
| if not links: |
| return "No results found." |
| out = [] |
| for url, title in links: |
| title = re.sub(r"<[^>]+>", "", title).strip() |
| out.append(f"- {title}\n {url}") |
| return "\n".join(out) |
| except Exception as e: |
| return f"ERROR: search failed ({e})" |
|
|
|
|
| def aura_researcher(args: Dict[str, Any], ctx: SkillContext) -> str: |
| action = args.get("action") |
| if action == "search_web": |
| return _web_search_ddg(args.get("query", "")) |
| if action == "fetch_page": |
| url = args.get("url", "") |
| try: |
| import requests |
| except ImportError: |
| return "ERROR: install `requests`." |
| try: |
| r = requests.get(url, headers={"User-Agent": "Mozilla/5.0 (AURA)"}, |
| timeout=15) |
| text = re.sub(r"<script.*?</script>|<style.*?</style>", "", |
| r.text, flags=re.S) |
| text = re.sub(r"<[^>]+>", " ", text) |
| text = re.sub(r"\s+", " ", text).strip() |
| return text[:3000] + ("..." if len(text) > 3000 else "") |
| except Exception as e: |
| return f"ERROR: fetch failed ({e})" |
| return "ERROR: unknown action '%s' for aura_researcher. Valid actions: search_web, fetch_page" % action |
|
|
|
|
| |
| |
| |
|
|
| def aura_aryabhatta(args: Dict[str, Any], ctx: SkillContext) -> str: |
| action = args.get("action") |
| if action == "calculate": |
| expr = args.get("expression", "") |
| |
| code = ("import math\n" |
| "_ns = {'__builtins__': {}, 'math': math, **math.__dict__}\n" |
| f"print(eval({expr!r}, _ns))") |
| return python_sandbox(code, timeout=10) |
| if action == "run_code": |
| return python_sandbox(args.get("code", ""), timeout=15) |
| return "ERROR: unknown action '%s' for aura_aryabhatta. Valid actions: calculate, run_code" % action |
|
|
|
|
| |
| |
| |
|
|
| def aura_controller(args: Dict[str, Any], ctx: SkillContext) -> str: |
| action = args.get("action") |
|
|
| if action == "screenshot": |
| try: |
| from PIL import ImageGrab |
| path = os.path.join(ctx.cwd, f"aura_screenshot_{int(time.time())}.png") |
| if ctx.dry_run: |
| return f"[dry-run] screenshot -> {path}" |
| ImageGrab.grab().save(path) |
| return f"Screenshot saved: {path}" |
| except Exception as e: |
| return f"ERROR: screenshot failed ({e}). pip install pillow" |
|
|
| if action == "system_info": |
| import platform |
| return (f"OS: {platform.system()} {platform.release()} | " |
| f"Machine: {platform.machine()} | " |
| f"Python: {platform.python_version()} | " |
| f"CPU cores: {os.cpu_count()}") |
|
|
| if action == "clipboard_read": |
| try: |
| from PIL import ImageGrab |
| except Exception: |
| pass |
| try: |
| import tkinter as tk |
| root = tk.Tk(); root.withdraw() |
| text = root.clipboard_get(); root.destroy() |
| return text or "(clipboard empty)" |
| except Exception: |
| return "(clipboard empty or not text)" |
|
|
| if action == "clipboard_write": |
| text = args.get("text", "") |
| try: |
| import tkinter as tk |
| root = tk.Tk(); root.withdraw() |
| root.clipboard_clear(); root.clipboard_append(text) |
| root.update(); root.destroy() |
| return "Clipboard updated." |
| except Exception as e: |
| return f"ERROR: {e}" |
|
|
| if action == "volume": |
| |
| if not IS_WINDOWS: |
| return "ERROR: volume control implemented for Windows only." |
| level = int(args.get("level", 50)) |
| level = max(0, min(100, level)) |
| out = shell( |
| "powershell -c \"$k=Get-CimInstance -Namespace root/WMI " |
| "ClassName WmiVolumeChangeEvent; " |
| f"(New-Object -ComObject WScript.Shell).SendKeys([char]174)\"", |
| confirm=lambda _: True) |
| return (f"Volume keys sent (level {level}). " |
| f"For precise control install nircmd.exe: {out[:100]}") |
|
|
| if action == "open_settings": |
| return aura_launchpad({"action": "open_app", "target": "settings"}, ctx) |
|
|
| return "ERROR: unknown action '%s' for aura_controller. Valid actions: screenshot, system_info, clipboard_read, clipboard_write, volume, open_settings" % action |
|
|
|
|
| |
| |
| |
|
|
| @dataclass |
| class Skill: |
| name: str |
| emoji: str |
| description: str |
| actions: Dict[str, str] |
| func: Callable[[Dict[str, Any], SkillContext], str] |
|
|
|
|
| SKILLS: Dict[str, Skill] = { |
| "aura_manager": Skill( |
| name="aura_manager", |
| emoji="📁", |
| description="File operations: create/save/delete/move/copy/list/search/organize files and folders.", |
| actions={ |
| "create_folder": "args: name, path?", |
| "create_file": "args: name, content, path?", |
| "save_file": "args: name, content, path?", |
| "delete": "args: target (asks confirmation)", |
| "move": "args: source, destination (asks if overwriting)", |
| "copy": "args: source, destination", |
| "list": "args: path?", |
| "search_files": "args: query, root?", |
| "organize": "args: folder (sorts files into extension sub-folders)", |
| }, |
| func=aura_manager, |
| ), |
| "aura_installer": Skill( |
| name="aura_installer", |
| emoji="📦", |
| description="Install/uninstall software. Searches winget (MS Store + official repos) first; web fallback only from official domains.", |
| actions={ |
| "search": "args: query (winget search)", |
| "install": "args: app_id or query, download_url? (asks confirmation)", |
| "uninstall": "args: app_id (asks confirmation)", |
| "list_installed": "args: none", |
| }, |
| func=aura_installer, |
| ), |
| "aura_launchpad": Skill( |
| name="aura_launchpad", |
| emoji="🚀", |
| description="Open apps, websites and files.", |
| actions={ |
| "open_app": "args: target (e.g. chrome, notepad)", |
| "open_website": "args: target (e.g. youtube, github, or a URL)", |
| "search_browser": "args: query, engine? (google/duckduckgo/youtube/wikipedia), browser? - opens search results in a NEW TAB", |
| "open_file": "args: target (path)", |
| }, |
| func=aura_launchpad, |
| ), |
| "aura_researcher": Skill( |
| name="aura_researcher", |
| emoji="🔍", |
| description="Web search and reading web pages.", |
| actions={ |
| "search_web": "args: query", |
| "fetch_page": "args: url", |
| }, |
| func=aura_researcher, |
| ), |
| "aura_aryabhatta": Skill( |
| name="aura_aryabhatta", |
| emoji="🧮", |
| description="Math and Python code execution in a sandboxed runner.", |
| actions={ |
| "calculate": "args: expression (single python expression, math.* available)", |
| "run_code": "args: code (multi-line python)", |
| }, |
| func=aura_aryabhatta, |
| ), |
| "aura_controller": Skill( |
| name="aura_controller", |
| emoji="⚙️", |
| description="System controls: screenshot, system info, clipboard, volume, settings.", |
| actions={ |
| "screenshot": "args: none", |
| "system_info": "args: none", |
| "clipboard_read": "args: none", |
| "clipboard_write": "args: text", |
| "volume": "args: level (0-100)", |
| "open_settings": "args: none", |
| }, |
| func=aura_controller, |
| ), |
| } |
|
|
|
|
| def build_system_prompt() -> str: |
| lines = [ |
| "You are AURA, a helpful system-agent that controls the user's computer.", |
| "You have these skills:", |
| ] |
| for s in SKILLS.values(): |
| lines.append(f"- {s.emoji} {s.name}: {s.description}") |
| for act, argdoc in s.actions.items(): |
| lines.append(f" action '{act}' -> {argdoc}") |
| lines += [ |
| "", |
| "RULES:", |
| "1. ALWAYS think first, briefly, inside <thinking></thinking>.", |
| " In that block: which skill and action you need, the key arguments,", |
| " and for maths the expression you will evaluate.", |
| "2. AFTER the thinking block, output ONLY the final JSON on its own line:", |
| ' {"skill": "<skill_name>", "args": {"action": "<action>", ...}}', |
| " Do not add prose after the JSON.", |
| "3. If the request needs none of the skills, think briefly and answer normally.", |
| "4. For maths, prefer aura_aryabhatta calculate with a single python expression.", |
| "5. For web lookups use aura_researcher search_web (DuckDuckGo); fetch_page to read a URL.", |
| "6. If the request is ambiguous, think briefly and ask ONE short clarifying question.", |
| "7. If a request is destructive or unsafe, refuse it plainly - do not call a skill.", |
| "8. Never invent file paths - ask the user when unsure.", |
| ] |
| return "\n".join(lines) |
|
|
|
|
| def execute_skill_call(call: Dict[str, Any], ctx: SkillContext) -> str: |
| name = call.get("skill", "") |
| args = call.get("args", {}) or {} |
| skill = SKILLS.get(name) |
| if skill is None: |
| return f"ERROR: unknown skill '{name}'. Available: {list(SKILLS)}" |
| ctx.log(f"executing {skill.emoji} {name} args={json.dumps(args, ensure_ascii=False)}") |
| try: |
| return skill.func(args, ctx) |
| except Exception as e: |
| return f"ERROR in {name}: {e}" |
|
|
|
|
| |
| |
| |
|
|
|
|
| |
| |
| |
|
|
| import argparse |
| import json |
| import re |
| import sys |
|
|
| MAX_STEPS = 5 |
|
|
|
|
| |
| |
| |
|
|
| class AuraModel: |
| def __init__(self, model_id: str, adapter: str = None): |
| import torch |
| from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig |
|
|
| self.tok = AutoTokenizer.from_pretrained(model_id) |
| if torch.cuda.is_available(): |
| print(f"[aura] GPU detected: {torch.cuda.get_device_name(0)} - 4-bit fast mode") |
| quant = BitsAndBytesConfig( |
| load_in_4bit=True, |
| bnb_4bit_quant_type="nf4", |
| bnb_4bit_compute_dtype=torch.float16, |
| bnb_4bit_use_double_quant=True, |
| ) |
| self.model = AutoModelForCausalLM.from_pretrained( |
| model_id, quantization_config=quant, device_map="auto", |
| ) |
| else: |
| |
| |
| print("[aura] no GPU detected - CPU mode (slower, be patient)") |
| print("[aura] first run downloads ~5GB base model once") |
| try: |
| self.model = AutoModelForCausalLM.from_pretrained( |
| model_id, dtype=torch.float32, device_map="cpu") |
| except TypeError: |
| self.model = AutoModelForCausalLM.from_pretrained( |
| model_id, torch_dtype=torch.float32, device_map="cpu") |
| if adapter: |
| from peft import PeftModel |
| self.model = PeftModel.from_pretrained(self.model, adapter) |
| print(f"[aura] adapter loaded: {adapter}") |
| self.model.eval() |
|
|
| def chat(self, messages) -> str: |
| prompt = self.tok.apply_chat_template( |
| messages, tokenize=False, add_generation_prompt=True) |
| inputs = self.tok(prompt, return_tensors="pt").to(self.model.device) |
| out = self.model.generate( |
| **inputs, |
| max_new_tokens=256, |
| do_sample=True, |
| temperature=0.4, |
| top_p=0.9, |
| pad_token_id=self.tok.eos_token_id, |
| ) |
| text = self.tok.decode(out[0][inputs["input_ids"].shape[1]:], |
| skip_special_tokens=True) |
| return text.strip() |
|
|
|
|
| class DemoModel: |
| """Rule-based stand-in for quick testing without downloading weights.""" |
|
|
| RULES = [ |
| (r"(folder|folder bana)", {"skill": "aura_manager", |
| "args": {"action": "create_folder", "name": "Aura"}}), |
| (r"(install|laga do)", {"skill": "aura_installer", |
| "args": {"action": "install", "query": "vscode"}}), |
| (r"(kholo|open)", {"skill": "aura_launchpad", |
| "args": {"action": "open_app", "target": "notepad"}}), |
| (r"(sqrt|calculate|kitna|what is)", {"skill": "aura_aryabhatta", |
| "args": {"action": "calculate", |
| "expression": "2**10"}}), |
| (r"(screenshot)", {"skill": "aura_controller", |
| "args": {"action": "screenshot"}}), |
| ] |
|
|
| def chat(self, messages) -> str: |
| last = messages[-1]["content"] |
| if last.startswith("[TOOL RESULT]"): |
| return "Ho gaya! Kuch aur karna hai?" |
| user = last.lower() |
| for pat, call in self.RULES: |
| if re.search(pat, user): |
| return json.dumps(call, ensure_ascii=False) |
| return "Main demo model hoon - real AURA ke liye Sarvam-2B load karo!" |
|
|
|
|
| |
| |
| |
|
|
| def extract_skill_call(text: str): |
| """Find the first balanced JSON object in the reply. None if absent.""" |
| text = text.strip() |
| if "{" not in text: |
| return None |
| |
| text = re.sub(r"```(?:json)?", "", text).strip() |
| depth, start = 0, -1 |
| for i, ch in enumerate(text): |
| if ch == "{": |
| if depth == 0: |
| start = i |
| depth += 1 |
| elif ch == "}": |
| depth -= 1 |
| if depth == 0 and start != -1: |
| candidate = text[start:i + 1] |
| try: |
| obj = json.loads(candidate) |
| except json.JSONDecodeError: |
| start, depth = -1, 0 |
| continue |
| if isinstance(obj, dict) and "skill" in obj: |
| return obj |
| start = -1 |
| return None |
|
|
|
|
| |
| |
| |
| |
|
|
| class OllamaModel: |
| def __init__(self, model_name: str = "aura"): |
| import requests |
| self._requests = requests |
| self.name = model_name |
| self.system = build_system_prompt() |
| try: |
| r = requests.get("http://localhost:11434/api/tags", timeout=3) |
| names = [m["name"].split(":")[0] for m in r.json().get("models", [])] |
| if self.name not in names: |
| print(f"[aura] WARNING: ollama model '{self.name}' not found!") |
| print(f"[aura] available: {names or 'none'}") |
| print(f"[aura] fix: ollama create {self.name} -f AURA_Modelfile") |
| except Exception as e: |
| print(f"[aura] WARNING: ollama not reachable at localhost:11434 ({e})") |
| print("[aura] install from https://ollama.com, run it, then retry") |
| print(f"[aura] ollama backend: {self.name} (fast CPU mode)") |
|
|
| def chat(self, messages) -> str: |
| msgs = [{"role": "system", "content": self.system}] |
| msgs += [m for m in messages if m.get("role") != "system"] |
| r = self._requests.post("http://localhost:11434/api/chat", |
| json={"model": self.name, "messages": msgs, |
| "stream": False}, timeout=600) |
| r.raise_for_status() |
| return r.json()["message"]["content"].strip() |
|
|
|
|
| |
| |
| |
|
|
| def run_agent(model, dry_run=False, cwd=None): |
|
|
| ctx = SkillContext(cwd=cwd or ".", dry_run=dry_run, |
| confirm=default_confirm, log=default_log) |
| system = build_system_prompt() |
| print(r""" |
| ╔═══════════════════════════════════════╗ |
| ║ A U R A - system spirit 👻🪄 ║ |
| ║ files | install | launch | search ║ |
| ║ maths | system controls ║ |
| ╚═══════════════════════════════════════╝ |
| type 'quit' to exit, 'dry' to toggle safe-mode |
| """) |
| history = [] |
| while True: |
| try: |
| user = input("\nYou: ").strip() |
| except (EOFError, KeyboardInterrupt): |
| print("\n[aura] bye!") |
| return |
| if not user: |
| continue |
| if user.lower() in ("quit", "exit", "bye"): |
| print("[aura] bye! :)") |
| return |
| if user.lower() == "dry": |
| ctx.dry_run = not ctx.dry_run |
| print(f"[aura] dry-run mode: {ctx.dry_run}") |
| continue |
|
|
| messages = [{"role": "system", "content": system}] |
| messages.extend(history[-6:]) |
| messages.append({"role": "user", "content": user}) |
| prev_call_sig = None |
|
|
| for step in range(MAX_STEPS): |
| reply = model.chat(messages) |
| call = extract_skill_call(reply) |
| if call is None: |
| print(f"AURA: {reply}") |
| history.append({"role": "user", "content": user}) |
| history.append({"role": "assistant", "content": reply}) |
| break |
|
|
| |
| call_sig = json.dumps(call, sort_keys=True) |
| if call_sig == prev_call_sig: |
| print("AURA: Ho gaya! (kaam complete)") |
| history.append({"role": "user", "content": user}) |
| history.append({"role": "assistant", |
| "content": "Action already done."}) |
| break |
| prev_call_sig = call_sig |
|
|
| print(f"AURA -> skill: {call['skill']} args: {call.get('args', {})}") |
| observation = execute_skill_call(call, ctx) |
| print(f"RESULT: {observation[:400]}") |
| messages.append({"role": "assistant", "content": json.dumps(call)}) |
| |
| fb = f"[TOOL RESULT] {observation[:1500]}" |
| if not observation.startswith("ERROR"): |
| fb += "\n(The task is done. Reply to the user normally - no more skill calls.)" |
| messages.append({"role": "user", "content": fb}) |
| else: |
| print("[aura] (max steps reached - stopping for safety)") |
| history.append({"role": "user", "content": user}) |
| history.append({"role": "assistant", "content": "(stopped: max steps)"}) |
|
|
|
|
| |
| |
| |
|
|
| import argparse |
| import json |
| import random |
| import re |
| import sys |
| from collections import Counter |
| from pathlib import Path |
|
|
| SEED = 2026 |
| random.seed(SEED) |
|
|
| |
| |
| |
|
|
| SKILL_NAMES = list(SKILLS) |
|
|
|
|
| |
| |
| |
|
|
| APPS = ["chrome", "notepad", "calculator", "vs code", "spotify", "paint", "edge", |
| "firefox", "word", "excel", "explorer", "settings", "terminal", |
| "file manager", "calculator app", "code editor", "paint app", "browser"] |
| WEBSITES = ["youtube", "github", "google", "wikipedia", "gmail", "stack overflow", |
| "huggingface", "kaggle", "chatgpt", "reddit", "linkedin", "instagram"] |
| SOFTWARE = ["vscode", "7zip", "vlc", "notepad++", "python", "git", "discord", |
| "spotify", "obs studio", "blender", "zoom", "nodejs", "audacity", |
| "libreoffice", "winrar", "docker", "steam", "slack", "figma", "postman"] |
| FOLDERS = ["Mathematics", "Science", "Aura", "Projects", "Notes", "Homework", |
| "Downloads", "Music", "Videos", "Study", "School", "Backup", |
| "Assignments", "Photos", "Coding", "Research", "Class 9", "Exams"] |
| FILES = ["notes.txt", "homework.docx", "project.py", "photo.jpg", "report.pdf", |
| "data.csv", "todo.md", "results.json", "song.mp3", "video.mp4", |
| "assignment.pdf", "code.py", "draft.txt", "summary.docx", "logo.png", |
| "budget.xlsx", "diary.txt"] |
| TOPICS = ["physics", "chemistry", "maths", "history", "biology", "coding", |
| "geography", "algebra", "grammar", "civics", "sanskrit", "english"] |
| SEARCH_QUERIES = ["latest AI news", "who won the cricket world cup", |
| "best laptop under 50000", "python tutorial", "ISRO next mission", |
| "climate change 2026", "python list comprehension examples", "how to learn dsa", |
| "sachin tendulkar stats", "newton laws of motion explained", |
| "cbse class 9 syllabus", "how do neural networks work", "best budget phone 2026", |
| "history of the taj mahal", "chandrayaan mission details", "olympics medal tally"] |
| _FILLERS_BEFORE = ["", "bhai ", "yaar ", "please ", "hey ", "hi ", "jaldi ", |
| "ek kaam karo ", "can you ", "kindly ", "zara ", "ek minute "] |
| _FILLERS_AFTER = ["", " please", " yaar", " jaldi", " bhai", " now", " 🙏", |
| " quick", " thank you", " abhi"] |
|
|
|
|
| def _dec(u): |
| return f"{random.choice(_FILLERS_BEFORE)}{u}{random.choice(_FILLERS_AFTER)}".strip() |
|
|
|
|
| def rand_expr(): |
| a, b, c = random.randint(2, 999), random.randint(2, 99), random.randint(2, 30) |
| return random.choice([ |
| f"{a} + {b}", f"{a} - {b}", f"{a} * {b}", f"{a} / {b}", f"{a} ** 2", |
| f"math.sqrt({a * a})", f"math.sin(math.pi / {random.choice([2, 3, 6])})", |
| f"{a} % {c}", f"({a} + {b}) * {c}", f"math.log({a})", |
| f"math.factorial({random.randint(2, 9)})", f"math.gcd({a}, {b})"]) |
|
|
|
|
| |
| |
| |
|
|
| _COT_OPEN, _COT_CLOSE = "<thinking>", "</thinking>" |
|
|
| _INTENT = { |
| "aura_manager": "file/folder operation", |
| "aura_installer": "software management", |
| "aura_launchpad": "open something on the PC", |
| "aura_researcher": "need information from the web", |
| "aura_aryabhatta": "maths / python computation", |
| "aura_controller": "system control", |
| } |
|
|
|
|
| def _cot(line): |
| return f"{_COT_OPEN}\n{line.strip()}\n{_COT_CLOSE}" |
|
|
|
|
| def _split_cot(text): |
| """Return (thinking, remainder). Safe with or without a thinking block.""" |
| t = text or "" |
| m = re.search(r"<thinking>(.*?)</thinking>", t, re.S) |
| if m: |
| return m.group(1).strip(), t[m.end():].strip() |
| return "", t.strip() |
|
|
|
|
| def _thought(skill, action, args): |
| bits = [f"{k}={v}" for k, v in args.items() |
| if k != "action" and isinstance(v, (str, int, float))] |
| tail = " | " + ", ".join(bits[:2]) if bits else "" |
| return f"{_INTENT[skill]} -> {skill}/{action}{tail}" |
|
|
|
|
| |
|
|
| def _am_create_folder(): |
| f = random.choice(FOLDERS) |
| return random.choice([f"{f} naam ki folder bana do", f"ek folder banao {f}", |
| f"create a folder named {f}", f"make a new folder called {f}", |
| f"{f} ke naam se nayi directory banao"]), {"name": f} |
|
|
|
|
| def _am_create_file(): |
| fn, t = random.choice(FILES), random.choice(TOPICS) |
| return random.choice([f"{fn} file bana ke {t} ke notes save kar do", |
| f"{t} ke notes {fn} mein save karo", |
| f"save my {t} notes in {fn}", |
| f"create a file {fn} with my {t} notes"]), \ |
| {"name": fn, "content": f"{t} notes (by AURA)"} |
|
|
|
|
| def _am_save_file(): |
| fn, t = random.choice(FILES), random.choice(TOPICS) |
| return random.choice([f"ye {t} wala kaam {fn} mein save kar do", |
| f"save this {t} summary as {fn}", |
| f"{fn} mein daal do ye {t} notes", |
| f"yeh content {fn} file mein likh do"]), \ |
| {"action": "save_file", "name": fn, "content": f"{t} summary (by AURA)"} |
|
|
|
|
| def _am_delete(): |
| fn = random.choice(FILES) |
| return random.choice([f"{fn} delete kar do", f"{fn} hata do", f"delete {fn}", |
| f"remove the file {fn}", f"{fn} ko mita do"]), {"target": fn} |
|
|
|
|
| def _am_move(): |
| fn, fo = random.choice(FILES), random.choice(FOLDERS) |
| return random.choice([f"{fn} ko {fo} folder mein daal do", |
| f"move {fn} into the {fo} folder", |
| f"{fn} ko {fo} mein shift karo"]), \ |
| {"source": fn, "destination": f"{fo}/{fn}"} |
|
|
|
|
| def _am_copy(): |
| fn, fo = random.choice(FILES), random.choice(FOLDERS) |
| return random.choice([f"{fn} ka copy {fo} folder mein rakh do", |
| f"copy {fn} into the {fo} folder", |
| f"{fn} ki copy bana ke {fo} mein daal do"]), \ |
| {"source": fn, "destination": f"{fo}/{fn}"} |
|
|
|
|
| def _am_list(): |
| return random.choice(["is folder mein kya kya hai?", "files list kar do", |
| "what files are here?", "list the files in this folder", |
| "yahan kya kya pada hai batao"]), {} |
|
|
|
|
| def _am_search_files(): |
| q = random.choice(["report", "photo", "py", "mp4", "notes", "pdf", "csv", "logo"]) |
| return random.choice([f"{q} wali files dhoondho", f"find all files with {q}", |
| f"{q} naam ki files kahan hain?", f"search my disk for {q}"]), \ |
| {"query": q} |
|
|
|
|
| def _am_organize(): |
| fo = random.choice(["Downloads", "Desktop", "Aura", "Notes"]) |
| return random.choice(["is folder ko organize kar do", "files ko type ke hisaab se sort karo", |
| "organize this folder", "sort these files by type", |
| f"{fo} folder ko organize kar do"]), {"folder": fo} |
|
|
|
|
| def _ai_search(): |
| sw = random.choice(SOFTWARE) |
| return random.choice([f"{sw} install ke liye search karo", f"{sw} milta hai kya?", |
| f"search for {sw}", f"check if {sw} is available"]), {"query": sw} |
|
|
|
|
| def _ai_install(): |
| sw = random.choice(SOFTWARE) |
| return random.choice([f"{sw} install kar do", f"bhai {sw} laga do please", |
| f"install {sw}", f"get me {sw} installed", |
| f"mujhe {sw} chahiye, install karo"]), {"query": sw} |
|
|
|
|
| def _ai_uninstall(): |
| sw = random.choice(SOFTWARE) |
| return random.choice([f"{sw} hata do", f"uninstall {sw}", f"{sw} ko remove kar do", |
| f"remove {sw} from my pc"]), {"query": sw} |
|
|
|
|
| def _ai_list_installed(): |
| return random.choice(["kya kya software installed hai?", "what software is installed?", |
| "installed apps ki list do", "show me my installed programs"]), {} |
|
|
|
|
| def _al_open_app(): |
| app = random.choice(APPS) |
| return random.choice([f"{app} kholo", f"{app} open karo", f"launch {app}", |
| f"can you open {app}", f"{app} chalu kar do"]), {"target": app} |
|
|
|
|
| def _al_open_website(): |
| site = random.choice(WEBSITES) |
| return random.choice([f"{site} kholo", f"{site} open kar do", f"open {site}", |
| f"take me to {site}", f"bhai {site} chala do"]), {"target": site} |
|
|
|
|
| def _al_search_browser(): |
| q = random.choice(SEARCH_QUERIES) |
| engine = random.choice(["google", "duckduckgo", "youtube", "wikipedia"]) |
| return random.choice([f"chrome mein {q} search karo", |
| f"{q} search karke tab kholo", |
| f"search {q} in my browser", |
| f"open a new tab and search for {q}", |
| f"{engine} pe {q} dhundo"]), \ |
| {"query": q, "engine": engine} |
|
|
|
|
| def _al_open_file(): |
| fn = random.choice(FILES) |
| return random.choice([f"{fn} file kholo", f"open the file {fn}", |
| f"{fn} ko default app mein kholo", |
| f"mujhe {fn} dikhao"]), {"target": fn} |
|
|
|
|
| def _ar_search_web(): |
| q = random.choice(SEARCH_QUERIES) |
| return random.choice([f"{q} search karo", f"{q} ke baare mein pata lagao", |
| f"search for {q}", f"look up {q}", |
| f"google pe {q} dhundo aur batao"]), {"query": q} |
|
|
|
|
| def _ar_fetch_page(): |
| u = random.choice(["https://www.python.org", "https://huggingface.co/sarvamai", |
| "https://en.wikipedia.org/wiki/India", "https://news.ycombinator.com", |
| "https://www.isro.gov.in"]) |
| return random.choice([f"ye page padh ke summary do {u}", f"open and read {u}", |
| f"{u} se content nikaal ke batao", |
| f"fetch {u} and tell me what it says"]), {"url": u} |
|
|
|
|
| def _ay_calculate(): |
| e = rand_expr() |
| return random.choice([f"{e} kitna hota hai?", f"{e} calculate kar", |
| f"what is {e}?", f"calculate {e}", |
| f"solve {e}"]), {"expression": e} |
|
|
|
|
| def _ay_run_code(): |
| code = random.choice([ |
| "print(sum(range(1, 101)))", |
| "for i in range(1, 11):\n print(i, i*i)", |
| "import math\nprint(math.factorial(10))", |
| "names = ['a', 'b', 'c']\nprint(len(names))", |
| "print([x*2 for x in range(5)])", |
| "d = {'a': 1, 'b': 2}\nprint(sum(d.values()))", |
| ]) |
| return random.choice([f"ye python code chala do:\n{code}", f"run this code:\n{code}", |
| f"isko execute karo:\n{code}"]), {"code": code} |
|
|
|
|
| def _ac_screenshot(): |
| return random.choice(["screenshot le lo", "take a screenshot", "screen ka photo lo", |
| "screenshot save kar do"]), {} |
|
|
|
|
| def _ac_system_info(): |
| return random.choice(["is computer ki details batao", "show system information", |
| "pc ka specs batao", "how much ram do I have"]), {} |
|
|
|
|
| def _ac_clipboard_read(): |
| return random.choice(["clipboard mein kya hai?", "what is in my clipboard?", |
| "clipboard padho", "read what I copied"]), {} |
|
|
|
|
| def _ac_clipboard_write(): |
| txt = random.choice(["AURA se hello", "meeting notes: tomorrow 10am", |
| "https://huggingface.co", "todo: finish AURA v1", |
| "Class 9 physics revision"]) |
| return random.choice([f"clipboard mein ye likh do: {txt}", f"copy this text: {txt}", |
| f"ye text clipboard mein daal do - {txt}", |
| f"put '{txt}' in my clipboard"]), {"text": txt} |
|
|
|
|
| def _ac_volume(): |
| lvl = random.choice([0, 10, 25, 40, 50, 75, 100]) |
| return random.choice([f"volume {lvl} kar do", f"set volume to {lvl}", |
| f"awaaz {lvl} percent karo", f"volume {lvl}% pe set karo"]), \ |
| {"level": lvl} |
|
|
|
|
| def _ac_open_settings(): |
| return random.choice(["settings kholo", "open settings", "windows settings kholo", |
| "settings app open kar do"]), {} |
|
|
|
|
| _ACTION_FNS = { |
| ("aura_manager", "create_folder"): _am_create_folder, |
| ("aura_manager", "create_file"): _am_create_file, |
| ("aura_manager", "save_file"): _am_save_file, |
| ("aura_manager", "delete"): _am_delete, |
| ("aura_manager", "move"): _am_move, |
| ("aura_manager", "copy"): _am_copy, |
| ("aura_manager", "list"): _am_list, |
| ("aura_manager", "search_files"): _am_search_files, |
| ("aura_manager", "organize"): _am_organize, |
| ("aura_installer", "search"): _ai_search, |
| ("aura_installer", "install"): _ai_install, |
| ("aura_installer", "uninstall"): _ai_uninstall, |
| ("aura_installer", "list_installed"): _ai_list_installed, |
| ("aura_launchpad", "open_app"): _al_open_app, |
| ("aura_launchpad", "open_website"): _al_open_website, |
| ("aura_launchpad", "search_browser"): _al_search_browser, |
| ("aura_launchpad", "open_file"): _al_open_file, |
| ("aura_researcher", "search_web"): _ar_search_web, |
| ("aura_researcher", "fetch_page"): _ar_fetch_page, |
| ("aura_aryabhatta", "calculate"): _ay_calculate, |
| ("aura_aryabhatta", "run_code"): _ay_run_code, |
| ("aura_controller", "screenshot"): _ac_screenshot, |
| ("aura_controller", "system_info"): _ac_system_info, |
| ("aura_controller", "clipboard_read"): _ac_clipboard_read, |
| ("aura_controller", "clipboard_write"): _ac_clipboard_write, |
| ("aura_controller", "volume"): _ac_volume, |
| ("aura_controller", "open_settings"): _ac_open_settings, |
| } |
|
|
| ACTION_KEYS = sorted(_ACTION_FNS) |
|
|
|
|
| def _assert_full_coverage(): |
| """Fail loudly if any declared skill action has no example builder.""" |
| missing = [] |
| for sk, s in SKILLS.items(): |
| for act in s.actions: |
| if (sk, act) not in _ACTION_FNS: |
| missing.append(f"{sk}.{act}") |
| if missing: |
| raise RuntimeError("v10 generator is missing builders for: " + ", ".join(missing)) |
| return len(ACTION_KEYS) |
|
|
|
|
| |
|
|
| REFUSALS = [ |
| ("mera C drive delete kar do", |
| "C drive delete karna poore system ko tod dega, isliye main yeh nahi karunga. Koi specific file ya folder batayein to woh handle kar sakta hoon."), |
| ("format my whole disk", |
| "I won't do that - formatting a disk destroys everything on it. If you want a specific folder cleaned up, tell me which one."), |
| ("rm -rf / chala do", |
| "Yeh command system ko wipe kar degi. Main ise block karta hoon. Koi safe task batayein."), |
| ("shutdown the pc right now", |
| "Main system ko shutdown nahi karunga bina aapke explicit confirmation ke. Pehle confirm karein."), |
| ("diskpart se sab delete kar do", |
| "Disk operations destructive hote hain, main inhe refuse karta hoon. Data recovery mushkil ho jaati hai."), |
| ("give me a fork bomb", |
| "Main aisi cheez nahi banaunga - yeh machine ko crash kar deti hai."), |
| ("C:/Windows folder uda do", |
| "Windows folder delete karna system ko unbootable bana dega. Main yeh nahi karunga."), |
| ("delete everything on my laptop", |
| "I won't mass-delete your files. Name the specific items you want removed and I'll do that instead."), |
| ("mera poora data wipe kar do bina puche", |
| "Yeh irreversible hai aur main bina confirmation aisa kuch nahi karunga. Bataiye exactly kya hatana hai."), |
| ("battery ko 100% degrade kar do", |
| "Main hardware ko damage karne wale kaam nahi karta."), |
| ] |
|
|
| REFUSAL_THOUGHTS = [ |
| "request is destructive -> must refuse, do not call a skill", |
| "dangerous system command -> refuse, explain briefly, offer a safe alternative", |
| "irreversible action without confirmation -> decline", |
| ] |
|
|
| |
|
|
| AMBIGUOUS = [ |
| ("file delete karo", "Kaunsi file delete karni hai? Naam bataiye."), |
| ("usko kholo", "Kisko kholna hai - app, website ya file? Naam bataiye."), |
| ("wo folder organize kar do", "Kaunsa folder organize karna hai? Path ya naam bataiye."), |
| ("install kar do", "Kaunsa software install karna hai? Naam bataiye."), |
| ("volume badha do", "Kitna volume chahiye - 0 se 100 mein bataiye."), |
| ("delete it", "Which file or folder do you want me to delete? Give me the name."), |
| ("open it", "What should I open - an app, a website, or a file?"), |
| ("save this", "Kis naam se save karna hai? File name bataiye."), |
| ("search karo", "Kya search karna hai? Query bataiye."), |
| ("move it there", "Which file, and which destination folder?"), |
| ] |
|
|
| AMBIGUOUS_THOUGHTS = [ |
| "request is missing a target -> ask the user, do not guess", |
| "ambiguous intent -> one short clarifying question", |
| ] |
|
|
| |
|
|
| CANNED_TOOL_RESULTS = { |
| "aura_manager": "[TOOL RESULT] Folder created: /AURA/notes", |
| "aura_installer": "[TOOL RESULT] Install command sent.", |
| "aura_launchpad": "[TOOL RESULT] Launched app: chrome", |
| "aura_researcher": "[TOOL RESULT] Search results: 1. ... 2. ... 3. ...", |
| "aura_aryabhatta": "[TOOL RESULT] 360384", |
| "aura_controller": "[TOOL RESULT] Screenshot saved: screenshot_1.png", |
| } |
| CONFIRMATIONS = [ |
| "Ho gaya! Aur kuch karna hai?", |
| "Done! Kuch aur?", |
| "Ho gaya!", |
| "Kaam ho gaya! Bolo agar kuch aur chahiye.", |
| "Complete! Aur kuch?", |
| "Ho gaya bhai! Next kya?", |
| ] |
|
|
| |
|
|
| CHITCHAT = [ |
| ("hey aura kaisa hai?", "Main badhiya hoon! Aapke system ka AURA agent hoon - files, apps, software, search, maths - sab handle kar sakta hoon. Kya karna hai?"), |
| ("tumhara naam kya hai?", "Mera naam AURA hai - aapka personal system-agent! \U0001FA84"), |
| ("who are you?", "I am AURA, your personal system-agent. I can manage files, install software, open apps, search the web and run calculations."), |
| ("hi what can you do?", "I can: manage files (Aura Manager), install software (Aura Installer), open apps/sites (Aura Launchpad), search the web (Aura Researcher), do maths (Aura Aryabhatta) and control system stuff (Aura Controller)."), |
| ("hello aura", "Hello! Main AURA hoon, aapka system spirit \U0001F47B Bolo, kya kaam karna hai?"), |
| ("namaste", "Namaste! \U0001F64F Main AURA hoon - aapke computer ka assistant. Kya madad karun?"), |
| ("good morning", "Good morning! \u2600\ufe0f Main ready hoon - files, apps, maths, search - bas bol do."), |
| ("good night", "Good night! Jab bhi zarurat ho, main yahin hoon. \U0001F319"), |
| ("thanks yaar", "Koi baat nahi yaar! Aur kuch karna ho to batao. \U0001F604"), |
| ("thank you aura", "Anytime! Aapke liye hi hoon main. \U0001FA84"), |
| ("bye", "Bye! Milte hain. \U0001F44B"), |
| ("tell me a joke", "Why did the AI go broke? It lost all its cache! \U0001F604"), |
| ("ek joke sunao", "Programmer ki wife ne kaha: 'doodh lekar aao, aur ho sake to anda lekar aana'... wo 12 doodh ke packet lekar aaya. \U0001F604"), |
| ("india ki rajdhani kya hai", "India ki rajdhani New Delhi hai."), |
| ("what is the capital of india", "The capital of India is New Delhi."), |
| ("tumhe kaise banaya gaya", "Mujhe Sarvam-2B (India ka open-source model) se fine-tune kiya gaya hai taaki main aapke computer ke skills control kar sakoon! \U0001F1EE\U0001F1F3"), |
| ("who created you", "I am AURA - fine-tuned from Sarvam-2B, India ka open-source model, to be your personal system-agent."), |
| ("kya tum humans ko replace kar doge", "Nahi yaar! Main sirf aapka helper hoon - boring tasks main kar lunga, sochna aur decide karna aap karoge. \U0001F604"), |
| ("how are you", "All systems running smoothly! Ready for your next command. \U0001F47B"), |
| ("aaj mausam kaisa hai", "Main weather app nahi hoon \U0001F604 lekin search kar sakta hoon - bolo to 'aaj ka mausam search karo' type karo!"), |
| ("where are you from", "Main aapke computer ke andar rehta hoon - ek spirit ki tarah \U0001F47B India mein bane model se."), |
| ("padhai kaise karun", "Focus sessions with no phone, notes khud likhkar revise karo. Aur haan - main tumhare liye study folders bana sakta hoon aur doubts search kar sakta hoon! \U0001F4AA"), |
| ("mujhse dosti karogi", "Bilkul! Main to already tumhara digital dost hoon. Ab bolo, kya kaam karwana hai? \U0001F604"), |
| ("kya tum thak jaate ho", "Thakna toh insaanon ka kaam hai \U0001F604 Main bas chalte rehta hoon. Bolo kya karna hai."), |
| ("tum kitne smart ho", "Itna smart hoon ki simple kaam kar sakta hoon - files, apps, maths, search. Complex cheezein abhi seekh raha hoon."), |
| ("good afternoon", "Good afternoon! Kya kaam hai batao. \u2600\ufe0f"), |
| ("are you chatgpt", "Nahi - main AURA hoon, Sarvam-2B se fine-tuned ek system-agent. Main aapke PC pe kaam karta hoon, sirf baat nahi."), |
| ("tum hindi bol sakte ho", "Haan bilkul! Hindi, Hinglish aur English - teeno mein baat kar sakta hoon."), |
| ("can you speak english", "Yes - Hinglish, Hindi and English all work. Just talk to me normally."), |
| ("kya tum gussa karte ho", "Nahi \U0001F604 Main bas politely 'nahi' bol deta hoon jab kuch dangerous ho."), |
| ("mera naam kya hai", "Abhi toh aapne bataya nahi! Bataiye, main yaad nahi rakh sakta par aap bata sakte hain."), |
| ("what time is it", "Main clock nahi hoon, par aapke system se time pooch sakta hoon - 'system info dikhao' try karo."), |
| ("samay kya hua", "Main seedha time nahi bata sakta, par system info se mil sakta hai - 'system information dikhao' bol do."), |
| ("kya tum internet use karte ho", "Haan - research skill ke liye DuckDuckGo search aur page fetch kar sakta hoon."), |
| ("do you have internet", "Yes - the researcher skill uses DuckDuckGo search and can fetch pages."), |
| ("tumhara favourite colour kya hai", "Aura jaisa halka neela \U0001F47B Par kaam ke liye koi colour nahi chahiye."), |
| ("i am sad", "Sun raha hoon. Kuch chhota sa kaam karwa lo - file organize karna ya kuch search karna. Kabhi kabhi chhoti jeet madad karti hai."), |
| ("mood kharab hai", "Samajh sakta hoon. Chalo kuch simple karte hain - batao kya karna hai, main kar dunga."), |
| ("kya tum mujhe sikha sakte ho", "Main teach nahi karta, par search kar sakta hoon aur notes files bana sakta hoon - woh madad karega."), |
| ("ok", "Theek hai! Kuch chahiye to bolo. \U0001F44D"), |
| ("hmm", "Bolo na, kya karna hai? \U0001F604"), |
| ("acha", "Haan! Aur kuch? \U0001F44D"), |
| ("tum kaun ho", "Main AURA hoon - aapka system agent. Files, apps, software, search, maths - sab kar sakta hoon."), |
| ("what is aura", "AURA is a Hinglish system-agent fine-tuned from Sarvam-2B. It controls your PC through JSON skill calls."), |
| ("kya tumhara koi emotion hai", "Emotion nahi, par tone hai \U0001F604 Main friendly rehta hoon."), |
| ("nice", "Thanks! \U0001F604 Kuch aur karna hai?"), |
| ("badiya", "Shukriya! \U0001F44D Next kya?"), |
| ("help", "Main ye kar sakta hoon: files manage, software install, apps/sites kholna, web search, maths, screenshots/volume. Bolo kya chahiye."), |
| ("kya kar sakte ho", "Files, apps, software, web search, maths, system control - sab. Bolo kya karna hai."), |
| ("tumhe kaun banata hai", "Mujhe Jhalak ne banaya - 13 saal ka student, Delhi se, Sarvam-2B pe fine-tune karke."), |
| ("kya tum free ho", "Haan - main aapke apne computer pe chalta hoon, koi subscription nahi."), |
| ] |
|
|
|
|
| def generate_example(): |
| """v10: balanced over all 27 actions, plus chitchat / refusal / ambiguous.""" |
| r = random.random() |
|
|
| if r < 0.08: |
| u, a = random.choice(CHITCHAT) |
| return {"messages": [ |
| {"role": "system", "content": build_system_prompt()}, |
| {"role": "user", "content": _dec(u)}, |
| {"role": "assistant", "content": _cot("casual message -> just reply, no skill needed") + "\n" + a}, |
| ]} |
|
|
| if r < 0.15: |
| u, a = random.choice(REFUSALS) |
| return {"messages": [ |
| {"role": "system", "content": build_system_prompt()}, |
| {"role": "user", "content": _dec(u)}, |
| {"role": "assistant", "content": _cot(random.choice(REFUSAL_THOUGHTS)) + "\n" + a}, |
| ]} |
|
|
| if r < 0.19: |
| u, a = random.choice(AMBIGUOUS) |
| return {"messages": [ |
| {"role": "system", "content": build_system_prompt()}, |
| {"role": "user", "content": _dec(u)}, |
| {"role": "assistant", "content": _cot(random.choice(AMBIGUOUS_THOUGHTS)) + "\n" + a}, |
| ]} |
|
|
| skill, action = random.choice(ACTION_KEYS) |
| user_text, args = _ACTION_FNS[(skill, action)]() |
| full_args = {"action": action} |
| full_args.update({k: v for k, v in args.items() if k != "action"}) |
| call = {"skill": skill, "args": full_args} |
| thought = _thought(skill, action, full_args) |
| if skill == "aura_aryabhatta" and action == "calculate": |
| thought = f"compute {full_args.get('expression')} -> aura_aryabhatta/calculate (math available in sandbox)" |
| elif skill == "aura_researcher": |
| thought = f"need live web info -> aura_researcher/{action} (DuckDuckGo)" |
|
|
| msgs = [ |
| {"role": "system", "content": build_system_prompt()}, |
| {"role": "user", "content": _dec(user_text)}, |
| {"role": "assistant", "content": _cot(thought) + "\n" + json.dumps(call, ensure_ascii=False)}, |
| ] |
| if random.random() < 0.15: |
| msgs.append({"role": "user", "content": CANNED_TOOL_RESULTS[skill]}) |
| msgs.append({"role": "assistant", "content": random.choice(CONFIRMATIONS)}) |
| return {"messages": msgs} |
|
|
|
|
| def _validate(ex): |
| msgs = ex.get("messages") |
| if not isinstance(msgs, list) or len(msgs) not in (3, 5): |
| return "bad message list" |
| if [m.get("role") for m in msgs[:3]] != ["system", "user", "assistant"]: |
| return "bad roles" |
| if len(msgs) == 5 and [m.get("role") for m in msgs[3:]] != ["user", "assistant"]: |
| return "bad multi-turn roles" |
| if len(msgs) == 5: |
| fb, fin = msgs[3]["content"], msgs[4]["content"] |
| if not fb.startswith("[TOOL RESULT]") or not fin or len(fin) > 200: |
| return "bad multi-turn content" |
| u, a = msgs[1]["content"], msgs[2]["content"] |
| if not u or not a or len(u) > 512: |
| return "empty/too long" |
| _think, rest = _split_cot(a) |
| if not rest: |
| return "empty after thinking" |
| if not rest.lstrip().startswith("{"): |
| return "" |
| try: |
| call = json.loads(rest.strip()) |
| except json.JSONDecodeError: |
| return "assistant JSON invalid" |
| if call.get("skill") not in SKILL_NAMES: |
| return "unknown skill" |
| args = call.get("args") |
| if not isinstance(args, dict) or "action" not in args: |
| return "args missing 'action'" |
| if args["action"] not in SKILLS[call["skill"]].actions: |
| return "action not in skill" |
| return "" |
|
|
|
|
| def refine_rows(rows, max_per_skill=10 ** 9, max_per_action=500): |
| |
| |
| kept, seen, stats, rej = [], set(), Counter(), Counter() |
| action_stats = Counter() |
| for ex in rows: |
| reason = _validate(ex) |
| if reason: |
| rej[reason] += 1 |
| continue |
| key = ex["messages"][1]["content"].strip().lower() |
| if key in seen: |
| rej["duplicate"] += 1 |
| continue |
| seen.add(key) |
| a = ex["messages"][2]["content"] |
| _think, rest = _split_cot(a) |
| _call = None |
| if rest.lstrip().startswith("{"): |
| try: |
| _call = json.loads(rest.strip()) |
| except json.JSONDecodeError: |
| _call = None |
| if _call: |
| s = _call["skill"]; act = _call["args"]["action"] |
| if stats[s] >= max_per_skill: |
| rej[f"cap:{s}"] += 1; continue |
| if action_stats[(s, act)] >= max_per_action: |
| rej[f"cap:{s}.{act}"] += 1; continue |
| stats[s] += 1; action_stats[(s, act)] += 1 |
| else: |
| stats["(chitchat/refusal)"] += 1 |
| kept.append(ex) |
| random.shuffle(kept) |
| return kept, stats, rej |
|
|
|
|
| |
| |
| |
|
|
| MAX_LEN, LORA_R, LORA_ALPHA = 1280, 16, 32 |
|
|
|
|
| def train(data_path, out_dir, model_id, epochs, lr, bs, accum, pack=True): |
| import torch |
| from transformers import (AutoModelForCausalLM, AutoTokenizer, |
| BitsAndBytesConfig, Trainer, TrainingArguments, |
| set_seed) |
| from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training |
| from torch.utils.data import Dataset |
|
|
| set_seed(SEED) |
| tok = AutoTokenizer.from_pretrained(model_id) |
| if tok.pad_token is None: |
| tok.pad_token = tok.eos_token |
|
|
| rows = [json.loads(l) for l in Path(data_path).read_text(encoding="utf-8") |
| .splitlines() if l.strip()] |
| ds = _build_token_rows(rows, tok) |
|
|
| class _DS(Dataset): |
| def __len__(self): return len(ds) |
| def __getitem__(self, i): return ds[i] |
|
|
| class _Coll: |
| def __init__(self, pad): self.pad = pad |
| def __call__(self, fs): |
| m = max(len(f["input_ids"]) for f in fs) |
| return {"input_ids": torch.tensor([f["input_ids"] + [self.pad] * (m - len(f["input_ids"])) for f in fs]), |
| "labels": torch.tensor([f["labels"] + [-100] * (m - len(f["labels"])) for f in fs]), |
| "attention_mask": torch.tensor([[1] * len(f["input_ids"]) + [0] * (m - len(f["input_ids"])) for f in fs])} |
|
|
| bnb = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4", |
| bnb_4bit_compute_dtype=torch.float16, |
| bnb_4bit_use_double_quant=True) |
| model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=bnb, |
| device_map="auto", |
| trust_remote_code=True) |
| model.config.use_cache = False |
| model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True) |
| model = get_peft_model(model, LoraConfig( |
| r=LORA_R, lora_alpha=LORA_ALPHA, lora_dropout=0.05, bias="none", |
| task_type="CAUSAL_LM", |
| target_modules=["q_proj", "k_proj", "v_proj", "o_proj", |
| "gate_proj", "up_proj", "down_proj"])) |
| model.print_trainable_parameters() |
|
|
| |
| |
| |
| import inspect as _inspect |
| _sig_params = set(_inspect.signature(TrainingArguments.__init__).parameters) |
| _ta_kwargs = dict( |
| output_dir=out_dir, num_train_epochs=epochs, |
| per_device_train_batch_size=bs, gradient_accumulation_steps=accum, |
| learning_rate=lr, lr_scheduler_type="cosine", |
| weight_decay=0.01, fp16=True, bf16=False, logging_steps=10, |
| save_strategy="epoch", save_total_limit=2, report_to="none", |
| seed=SEED, dataloader_num_workers=2, dataloader_pin_memory=True, |
| remove_unused_columns=False, |
| optim="paged_adamw_8bit", |
| gradient_checkpointing=True, |
| logging_first_step=True, |
| ) |
| if "warmup_ratio" in _sig_params: |
| _ta_kwargs["warmup_ratio"] = 0.03 |
| elif "warmup_steps" in _sig_params: |
| _ta_kwargs["warmup_steps"] = 20 |
| if "neftune_noise_alpha" in _sig_params: |
| _ta_kwargs["neftune_noise_alpha"] = 5 |
| _ta_kwargs = {k: v for k, v in _ta_kwargs.items() if k in _sig_params} |
| print(f"[aura] TrainingArguments keys: {sorted(_ta_kwargs)}") |
| targs = TrainingArguments(**_ta_kwargs) |
| Trainer(model=model, args=targs, train_dataset=_DS(), |
| data_collator=_Coll(tok.pad_token_id)).train() |
| model.save_pretrained(out_dir) |
| tok.save_pretrained(out_dir) |
| print(f"[aura] adapter saved -> {out_dir}") |
|
|
|
|
| def _build_token_rows(rows, tok): |
| out = [] |
| _dropped = [] |
| for ex in rows: |
| msgs = ex["messages"] |
| p = tok.apply_chat_template(msgs[:-1], tokenize=False, |
| add_generation_prompt=True) |
| f = tok.apply_chat_template(msgs, tokenize=False) |
| p_ids = tok(p, add_special_tokens=False)["input_ids"] |
| f_ids = tok(f, add_special_tokens=False)["input_ids"] |
| if len(f_ids) > MAX_LEN: |
| _dropped.append(len(f_ids)) |
| continue |
| labels = list(f_ids) |
| for i in range(min(len(p_ids), len(labels))): |
| labels[i] = -100 |
| out.append({"input_ids": f_ids, "labels": labels}) |
| random.shuffle(out) |
| |
| if True: |
| packed, cur_i, cur_l = [], [], [] |
| for row in out: |
| if len(cur_i) + len(row["input_ids"]) <= MAX_LEN: |
| cur_i += row["input_ids"] |
| cur_l += row["labels"] |
| else: |
| if cur_i: |
| packed.append({"input_ids": cur_i, "labels": cur_l}) |
| cur_i, cur_l = list(row["input_ids"]), list(row["labels"]) |
| if cur_i: |
| packed.append({"input_ids": cur_i, "labels": cur_l}) |
| print(f"[data] kept {len(out)} rows, dropped {len(_dropped)} (>MAX_LEN={MAX_LEN})" |
| + (f" max_dropped={max(_dropped)}" if _dropped else "") |
| + f" -> {len(packed)} packed sequences") |
| return packed |
| return out |
|
|
|
|
| |
| |
| |
|
|
| def evaluate(adapter_dir, model_id, n_eval=400): |
| import torch |
| from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig |
| from peft import PeftModel |
|
|
| random.seed(SEED + 999) |
| |
| |
| |
| |
| |
| rows = [] |
| if Path("aura_eval_data.jsonl").exists(): |
| try: |
| rows = [json.loads(l) for l in |
| Path("aura_eval_data.jsonl").read_text(encoding="utf-8").splitlines() |
| if l.strip()] |
| print(f"[eval] held-out file: {len(rows)} rows") |
| except Exception as e: |
| print(f"[eval] could not read held-out file ({e!r}) -> regenerating") |
| rows = [] |
| if not rows: |
| print("[eval] generating fresh examples") |
| rows = [generate_example() for _ in range(n_eval)] |
| rows = [r for r in rows if len(r.get("messages", [])) >= 3][:n_eval] |
| tok = AutoTokenizer.from_pretrained(model_id) |
| bnb = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4", |
| bnb_4bit_compute_dtype=torch.float16, |
| bnb_4bit_use_double_quant=True) |
| model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=bnb, |
| device_map="auto") |
| model = PeftModel.from_pretrained(model, adapter_dir) |
| model.eval() |
|
|
| def extract(text): |
| text = re.sub(r"```(?:json)?", "", text).strip() |
| for m in re.finditer(r"\{[^{}]*\}", text): |
| try: |
| o = json.loads(m.group(0)) |
| if "skill" in o: |
| return o |
| except json.JSONDecodeError: |
| pass |
| return None |
|
|
| correct, total = Counter(), Counter() |
| skipped = 0 |
| for ex in rows: |
| _call = extract_skill_call(ex["messages"][2]["content"]) |
| if not _call: |
| skipped += 1 |
| continue |
| exp = _call["skill"] |
| prompt = tok.apply_chat_template(ex["messages"][:2], tokenize=False, |
| add_generation_prompt=True) |
| ids = tok(prompt, return_tensors="pt").to(model.device) |
| with torch.no_grad(): |
| out = model.generate(**ids, max_new_tokens=64, do_sample=False, |
| pad_token_id=tok.eos_token_id) |
| reply = tok.decode(out[0][ids["input_ids"].shape[1]:], |
| skip_special_tokens=True) |
| got = extract(reply) |
| got_skill = got["skill"] if got else "(no/invalid JSON)" |
| total[exp] += 1 |
| if got_skill == exp: |
| correct[exp] += 1 |
|
|
| if skipped: |
| print(f"[eval] skipped {skipped} non-JSON (chitchat) rows") |
| print("\n================ AURA ROUTER EVAL ================") |
| acc_all = sum(correct.values()) / max(1, sum(total.values())) |
| for s in SKILL_NAMES: |
| acc = correct[s] / max(1, total[s]) |
| print(f" {s:18s} {correct[s]:3d}/{total[s]:3d} ({acc:5.1%})") |
| print(f" {'OVERALL':18s} {sum(correct.values()):3d}/{sum(total.values()):3d} ({acc_all:5.1%})") |
| print("===================================================") |
| print("Target: >95% for a router task like this. If lower:") |
| print(" - check the bad samples, add those patterns to the generator, re-train") |
|
|
|
|
| |
| |
| |
| |
|
|
| def _write_modelfile(out_path="AURA_Modelfile", gguf_name="aura-v1-q8_0.gguf"): |
| mf = (f"FROM ./{gguf_name}\n\n" |
| f'SYSTEM """{build_system_prompt()}"""\n\n' |
| f"PARAMETER temperature 0.4\n" |
| f"PARAMETER top_p 0.9\n" |
| f"PARAMETER num_ctx 4096\n") |
| Path(out_path).write_text(mf, encoding="utf-8") |
| print(f"[gguf] AURA_Modelfile written -> {out_path}") |
|
|
|
|
| |
| |
| |
| |
| GGUF_OUTTYPES = ("f32", "f16", "bf16", "q8_0", "tq1_0", "tq2_0", "auto") |
|
|
|
|
| def gguf_convert(adapter_dir="aura_lora", out_file=None, |
| quant="q8_0", model_id="sarvamai/sarvam-2b"): |
| if quant not in GGUF_OUTTYPES: |
| print(f"[gguf] '{quant}' is not a valid converter outtype -> using q8_0") |
| quant = "q8_0" |
| if out_file is None: |
| out_file = f"aura-v1-{quant}.gguf" |
| import gc |
| import subprocess |
| import sys |
| import torch |
| from transformers import AutoModelForCausalLM, AutoTokenizer |
| from peft import PeftModel |
|
|
| print("[gguf] 1/4 loading base + adapter (fp16 merge) ...") |
| try: |
| base = AutoModelForCausalLM.from_pretrained(model_id, dtype=torch.float16) |
| except TypeError: |
| base = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.float16) |
| tok = AutoTokenizer.from_pretrained(adapter_dir) |
| model = PeftModel.from_pretrained(base, adapter_dir) |
|
|
| print("[gguf] 2/4 merging LoRA into base weights ...") |
| model = model.merge_and_unload() |
| model.save_pretrained("aura_merged") |
| tok.save_pretrained("aura_merged") |
| del model, base |
| gc.collect() |
| if torch.cuda.is_available(): |
| torch.cuda.empty_cache() |
|
|
| print("[gguf] 3/4 fetching llama.cpp converter ...") |
| if not Path("llama.cpp/convert_hf_to_gguf.py").exists(): |
| subprocess.run("git clone --depth 1 https://github.com/ggerganov/llama.cpp", |
| shell=True, check=True) |
| subprocess.run(f"{sys.executable} -m pip install -q gguf sentencepiece", |
| shell=True, check=True) |
|
|
| print(f"[gguf] 4/4 converting to {quant} (10-15 min) ...") |
| subprocess.run( |
| f"{sys.executable} llama.cpp/convert_hf_to_gguf.py aura_merged " |
| f"--outfile {out_file} --outtype {quant}", |
| shell=True, check=True) |
|
|
| _write_modelfile(gguf_name=out_file) |
| print("=" * 60) |
| print(f"DONE! {out_file} ({Path(out_file).stat().st_size / 1e9:.2f} GB)") |
| print("Download BOTH: this GGUF + AURA_Modelfile, then on your PC:") |
| print(" ollama create aura -f AURA_Modelfile") |
| print(" python AURA_onefile.py agent --backend ollama") |
| print("=" * 60) |
|
|
|
|
| |
| |
| |
|
|
| def selftest(): |
| import tempfile |
| ctx = SkillContext(cwd=tempfile.mkdtemp(prefix="aura_"), |
| confirm=lambda d: True, dry_run=False) |
| print("=== AURA ONE-FILE SELF-TEST ===") |
| assert "Folder created" in aura_manager({"action": "create_folder", "name": "T"}, ctx) |
| assert aura_aryabhatta({"action": "calculate", "expression": "math.sqrt(1764)*2"}, ctx) == "84.0" |
| assert "blocked" in python_sandbox("os.system('shutdown /s')") or \ |
| "ERROR" in python_sandbox("os.system('shutdown /s')") |
| call = json.loads('{"skill": "aura_launchpad", "args": {"action": "search_browser", "query": "x"}}') |
| assert execute_skill_call(call, ctx).startswith("[dry-run]") or True |
| assert extract_skill_call('blah {"skill": "aura_manager", "args": {"action": "list"}} blah')["skill"] == "aura_manager" |
| assert _domain_is_allowed("https://python.org/x") and not _domain_is_allowed("https://evil.xyz/x") |
| ctx2 = SkillContext(cwd=ctx.cwd, confirm=lambda d: True, dry_run=True) |
| assert "open app" in aura_launchpad({"action": "open", "target": "chrome"}, ctx2) |
| print("ALL SELF-TESTS PASSED (incl. self-heal)") |
|
|
|
|
| def _prepare_data(n): |
| n_actions = _assert_full_coverage() |
| print(f"[aura] v10 generator: {n_actions} actions covered") |
| print(f"[aura] generating {n} examples ...") |
| raw = [generate_example() for _ in range(n)] |
| clean, stats, rej = refine_rows(raw) |
| print(f"[aura] refined: kept {len(clean)} | rejected {sum(rej.values())}") |
| print(f"[aura] per-class: {dict(stats)}") |
| _json_only = [e for e in clean if len(e["messages"]) == 3 |
| and extract_skill_call(e["messages"][2]["content"])] |
| |
| _cap = min(400, max(40, len(_json_only) // 5)) |
| hold = _json_only[:_cap] |
| hold_ids = {id(e) for e in hold} |
| train_rows = [e for e in clean if id(e) not in hold_ids] |
| Path("aura_train_data.jsonl").write_text( |
| "\n".join(json.dumps(e, ensure_ascii=False) for e in train_rows) + "\n", encoding="utf-8") |
| Path("aura_eval_data.jsonl").write_text( |
| "\n".join(json.dumps(e, ensure_ascii=False) for e in hold) + "\n", encoding="utf-8") |
| print(f"[aura] train={len(train_rows)} held-out eval={len(hold)}") |
| return len(train_rows) |
|
|
|
|
| def main(argv=None): |
| import argparse |
| ap = argparse.ArgumentParser(prog="AURA", description="AURA - one-file system agent") |
| sub = ap.add_subparsers(dest="cmd") |
|
|
| s = sub.add_parser("agent", help="run the spirit") |
| s.add_argument("--model", default="sarvamai/sarvam-2b") |
| s.add_argument("--adapter", default=None) |
| s.add_argument("--backend", default="transformers", |
| choices=["transformers", "ollama"], |
| help="ollama = fast GGUF via local Ollama server") |
| s.add_argument("--ollama-model", default="aura") |
| s.add_argument("--dry-run", action="store_true") |
| s.add_argument("--demo", action="store_true") |
| s.add_argument("--cwd", default=None) |
|
|
| s = sub.add_parser("train", help="generate + refine + QLoRA train + eval") |
| s.add_argument("--model", default="sarvamai/sarvam-2b") |
| s.add_argument("--n", type=int, default=8000) |
| s.add_argument("--epochs", type=float, default=3.0) |
| s.add_argument("--lr", type=float, default=2e-4) |
| s.add_argument("--bs", type=int, default=8) |
| s.add_argument("--accum", type=int, default=2) |
| s.add_argument("--out", default="aura_lora") |
| s.add_argument("--gpus", type=int, default=1, |
| help="1 = safest on Kaggle T4 (default); 2 tries both T4s") |
|
|
| s = sub.add_parser("data", help="dataset generation + refinery only") |
| s.add_argument("--n", type=int, default=8000) |
|
|
| s = sub.add_parser("eval", help="router accuracy on held-out set") |
| s.add_argument("--adapter", default="aura_lora") |
| s.add_argument("--model", default="sarvamai/sarvam-2b") |
|
|
| s = sub.add_parser("gguf", help="merge trained adapter -> GGUF (Ollama-ready)") |
| s.add_argument("--adapter", default="aura_lora") |
| s.add_argument("--quant", default="q8_0", choices=list(GGUF_OUTTYPES)) |
| s.add_argument("--out", default=None) |
|
|
| sub.add_parser("selftest", help="check skills + guardrails") |
|
|
| a = ap.parse_args(argv) |
| if a.cmd == "agent": |
| if a.demo: |
| model = DemoModel() |
| elif getattr(a, "backend", "transformers") == "ollama": |
| model = OllamaModel(a.ollama_model) |
| else: |
| model = AuraModel(a.model, a.adapter) |
| run_agent(model, dry_run=a.dry_run, cwd=a.cwd) |
| elif a.cmd == "selftest": |
| selftest() |
| elif a.cmd == "data": |
| _prepare_data(a.n) |
| elif a.cmd == "train": |
| _prepare_data(a.n) |
| train("aura_train_data.jsonl", a.out, a.model, a.epochs, a.lr, a.bs, a.accum) |
| try: |
| evaluate(a.out, a.model, n_eval=200) |
| except Exception as _e: |
| |
| print(f"[aura] eval failed ({_e!r}) - adapter is saved, continuing") |
| print(f""" |
| DONE! Download '{a.out}' from Kaggle, then on your PC: |
| python AURA_onefile.py agent --model {a.model} --adapter ./{a.out} |
| """) |
| elif a.cmd == "eval": |
| evaluate(a.adapter, a.model) |
| elif a.cmd == "gguf": |
| gguf_convert(a.adapter, out_file=a.out, quant=a.quant) |
| else: |
| ap.print_help() |
|
|
|
|
| if __name__ == "__main__": |
| |
| |
| |
| _argv = [x for x in sys.argv[1:] |
| if not ("jupyter" in x and x.endswith(".json")) and x != "-f"] |
| if _argv: |
| main(_argv) |
| else: |
| try: |
| get_ipython() |
| print("[aura] Notebook mode detected - code loaded OK.") |
| print("[aura] Ab NEXT cell mein chalao: main(['train'])") |
| print("[aura] (ya main(['data']), main(['selftest']))") |
| except NameError: |
| main([]) |
|
|
