aish-cli 0.1.0__py3-none-any.whl

aish/__main__.py

@@ -0,0 +1,3 @@
+from aish.cli import app
+
+app()

aish/cli.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from aish.config import AishConfig, ConfigNotFoundError, read_config, write_config
+from aish.executor import run_command
+from aish.history import append_history
+from aish.llm import generate_command
+from aish.safety import RiskLevel, check_command
+
+app = typer.Typer(name="aish", help="AI-powered shell assistant")
+console = Console()
+err_console = Console(stderr=True)
+
+
+@app.command()
+def init(
+    base_url: Optional[str] = typer.Option(None, "--base-url", help="LLM API base URL"),
+    api_key: Optional[str] = typer.Option(None, "--api-key", help="LLM API key"),
+    model: Optional[str] = typer.Option(None, "--model", help="Model name"),
+) -> None:
+    """Configure aish with LLM API credentials."""
+    resolved_base_url: str = (
+        base_url if base_url is not None else typer.prompt("Base URL")
+    )
+    resolved_api_key: str = (
+        api_key if api_key is not None else typer.prompt("API key", hide_input=True)
+    )
+    resolved_model: str = (
+        model if model is not None else typer.prompt("Model", default="gpt-4o")
+    )
+
+    try:
+        write_config(
+            AishConfig(
+                base_url=resolved_base_url,
+                api_key=resolved_api_key,
+                model=resolved_model,
+            )
+        )
+        console.print(
+            "[bold green]✓[/bold green] Configuration saved to [cyan]~/.aish/config[/cyan]"
+        )
+    except Exception as e:
+        err_console.print(f"[bold red]Error:[/bold red] Failed to save config: {e}")
+        raise typer.Exit(1)
+
+
+@app.command()
+def run(
+    prompt: list[str] = typer.Argument(..., help="Natural language request"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt"),
+    dry_run: bool = typer.Option(
+        False, "--dry-run", "-d", help="Print command but do not execute"
+    ),
+) -> None:
+    """Generate and execute a shell command from natural language."""
+    user_prompt = " ".join(prompt)
+
+    try:
+        config = read_config()
+    except ConfigNotFoundError:
+        err_console.print(
+            "[bold red]Error:[/bold red] No configuration found. Run [cyan]aish init[/cyan] first."
+        )
+        raise typer.Exit(1)
+
+    with console.status("[bold cyan]Generating command…[/bold cyan]"):
+        try:
+            output = generate_command(
+                user_prompt, config.base_url, config.api_key, config.model
+            )
+        except ValueError as e:
+            err_console.print(f"[bold red]Error:[/bold red] {e}")
+            raise typer.Exit(1)
+
+    risk_color = {"low": "green", "medium": "yellow", "high": "red"}.get(
+        output.risk_level, "white"
+    )
+    console.print(
+        Panel(
+            f"[bold]{output.command}[/bold]",
+            title="[bold]Command[/bold]",
+            border_style=risk_color,
+        )
+    )
+    console.print(f"[dim]Explanation:[/dim] {output.explanation}")
+    console.print(f"[dim]Risk:[/dim] [{risk_color}]{output.risk_level}[/{risk_color}]")
+
+    safety_level, _ = check_command(output.command)
+
+    if safety_level == RiskLevel.DENY:
+        err_console.print(
+            "[bold red]✗ Denied:[/bold red] This command matches a dangerous pattern and cannot be executed."
+        )
+        raise typer.Exit(1)
+
+    confirmed = False
+
+    if safety_level == RiskLevel.WARN:
+        if output.risk_tip:
+            console.print(f"[bold yellow]⚠ Warning:[/bold yellow] {output.risk_tip}")
+        confirmed = typer.confirm(
+            "This command is potentially dangerous. Execute anyway?"
+        )
+        if not confirmed:
+            console.print("[yellow]Aborted.[/yellow]")
+            raise typer.Exit(0)
+
+    timestamp = datetime.now(timezone.utc).isoformat()
+
+    if dry_run:
+        console.print("[bold yellow]Dry run — not executing.[/bold yellow]")
+        append_history(
+            {
+                "timestamp": timestamp,
+                "prompt": user_prompt,
+                "command": output.command,
+                "exit_code": None,
+                "executed": False,
+            }
+        )
+        raise typer.Exit(0)
+
+    if not yes and not confirmed:
+        confirmed = typer.confirm("Execute this command?")
+        if not confirmed:
+            console.print("[yellow]Aborted.[/yellow]")
+            raise typer.Exit(0)
+
+    result = run_command(output.command)
+
+    if result.stdout:
+        console.print(Panel(result.stdout.rstrip(), title="stdout", border_style="dim"))
+    if result.stderr:
+        console.print(
+            Panel(result.stderr.rstrip(), title="stderr", border_style="red dim")
+        )
+
+    exit_label = "[green]✓[/green]" if result.success else "[red]✗[/red]"
+    console.print(f"{exit_label} Exit code: [bold]{result.exit_code}[/bold]")
+
+    append_history(
+        {
+            "timestamp": timestamp,
+            "prompt": user_prompt,
+            "command": output.command,
+            "exit_code": result.exit_code,
+            "executed": True,
+        }
+    )
+
+
+if __name__ == "__main__":
+    app()

aish/config.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import tomllib
+from pathlib import Path
+from dataclasses import dataclass
+
+import tomli_w
+
+CONFIG_DIR = Path.home() / ".aish"
+CONFIG_PATH = CONFIG_DIR / "config"
+
+
+class ConfigNotFoundError(Exception):
+    """Raised when ~/.aish/config does not exist."""
+
+    pass
+
+
+class ConfigInvalidError(Exception):
+    """Raised when config exists but is missing required fields."""
+
+    pass
+
+
+@dataclass
+class AishConfig:
+    base_url: str
+    api_key: str
+    model: str
+
+
+def read_config() -> AishConfig:
+    """Read config from ~/.aish/config. Raises ConfigNotFoundError if not found."""
+    if not CONFIG_PATH.exists():
+        raise ConfigNotFoundError("Run 'aish init' first")
+    with open(CONFIG_PATH, "rb") as f:
+        data = tomllib.load(f)
+    missing = [k for k in ("base_url", "api_key", "model") if k not in data]
+    if missing:
+        raise ConfigInvalidError(
+            f"Config missing required fields: {', '.join(missing)}"
+        )
+    return AishConfig(
+        base_url=data["base_url"],
+        api_key=data["api_key"],
+        model=data["model"],
+    )
+
+
+def write_config(config: AishConfig) -> None:
+    """Write config to ~/.aish/config as TOML."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    data = {
+        "base_url": config.base_url,
+        "api_key": config.api_key,
+        "model": config.model,
+    }
+    with open(CONFIG_PATH, "wb") as f:
+        tomli_w.dump(data, f)
+
+
+def config_exists() -> bool:
+    """Return True if config file exists and has required fields."""
+    if not CONFIG_PATH.exists():
+        return False
+    try:
+        read_config()
+        return True
+    except Exception:
+        return False

aish/executor.py

@@ -0,0 +1,52 @@
+"""Command execution wrapper for aish."""
+
+from __future__ import annotations
+import subprocess
+from dataclasses import dataclass
+
+
+@dataclass
+class ExecResult:
+    command: str
+    exit_code: int
+    stdout: str
+    stderr: str
+
+    @property
+    def success(self) -> bool:
+        return self.exit_code == 0
+
+
+def run_command(command: str, timeout: int = 30) -> ExecResult:
+    """
+    Execute a shell command using shell=True (supports pipes, redirects).
+    Returns ExecResult with exit code, stdout, stderr.
+    """
+    try:
+        result = subprocess.run(
+            command,
+            shell=True,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+        return ExecResult(
+            command=command,
+            exit_code=result.returncode,
+            stdout=result.stdout,
+            stderr=result.stderr,
+        )
+    except subprocess.TimeoutExpired:
+        return ExecResult(
+            command=command,
+            exit_code=124,  # Standard timeout exit code
+            stdout="",
+            stderr=f"Command timed out after {timeout} seconds",
+        )
+    except Exception as e:
+        return ExecResult(
+            command=command,
+            exit_code=1,
+            stdout="",
+            stderr=str(e),
+        )

aish/history.py

@@ -0,0 +1,67 @@
+"""Command history management for aish — JSON Lines format."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+HISTORY_DIR = Path.home() / ".aish"
+HISTORY_PATH = HISTORY_DIR / "history"
+MAX_ENTRIES = 1000
+
+
+def append_history(entry: dict) -> None:
+    """
+    Append one history entry to ~/.aish/history (JSON Lines format).
+    Auto-trims to MAX_ENTRIES by removing oldest entries.
+
+    Expected entry fields:
+        timestamp: str (ISO 8601) — auto-added if missing
+        prompt: str
+        command: str
+        exit_code: int | None
+        executed: bool
+    """
+    if "timestamp" not in entry:
+        entry = {**entry, "timestamp": datetime.now(timezone.utc).isoformat()}
+
+    HISTORY_DIR.mkdir(parents=True, exist_ok=True)
+
+    existing: list[dict] = []
+    if HISTORY_PATH.exists():
+        with open(HISTORY_PATH, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if line:
+                    try:
+                        existing.append(json.loads(line))
+                    except json.JSONDecodeError:
+                        pass
+
+    existing.append(entry)
+
+    if len(existing) > MAX_ENTRIES:
+        existing = existing[-MAX_ENTRIES:]
+
+    with open(HISTORY_PATH, "w", encoding="utf-8") as f:
+        for e in existing:
+            f.write(json.dumps(e, ensure_ascii=False) + "\n")
+
+
+def read_history() -> list[dict]:
+    """Return all history entries, newest first."""
+    if not HISTORY_PATH.exists():
+        return []
+
+    entries: list[dict] = []
+    with open(HISTORY_PATH, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                try:
+                    entries.append(json.loads(line))
+                except json.JSONDecodeError:
+                    pass
+
+    return list(reversed(entries))

aish/llm.py

@@ -0,0 +1,88 @@
+"""LLM integration for aish — OpenAI-compatible API client."""
+
+from __future__ import annotations
+import json
+import platform
+from dataclasses import dataclass
+
+from openai import OpenAI
+
+
+@dataclass
+class CommandOutput:
+    command: str
+    explanation: str
+    risk_level: str  # "low", "medium", "high"
+    risk_tip: str
+
+
+SYSTEM_PROMPT = """You are a shell command generator. Your job is to convert natural language requests into executable shell commands.
+
+Rules:
+1. Return ONLY valid JSON — no markdown, no code blocks, no extra text
+2. Return EXACTLY ONE command
+3. The command must be executable on {os_name} ({shell})
+4. JSON schema: {{"command": "...", "explanation": "...", "risk_level": "low|medium|high", "risk_tip": "..."}}
+5. risk_level: "low" for safe commands, "medium" for potentially impactful, "high" for destructive/irreversible
+6. risk_tip: brief warning if risk_level is medium/high, otherwise empty string
+7. If the request is ambiguous or dangerous, still return the most reasonable command but set risk_level to "high"
+
+Example response:
+{{"command": "ls -la", "explanation": "Lists all files in current directory with details", "risk_level": "low", "risk_tip": ""}}"""
+
+
+def generate_command(
+    prompt: str,
+    base_url: str,
+    api_key: str,
+    model: str,
+) -> CommandOutput:
+    """
+    Call the LLM API to generate a shell command from a natural language prompt.
+    Raises ValueError if the response cannot be parsed.
+    """
+    client = OpenAI(api_key=api_key, base_url=base_url)
+
+    os_name = platform.system()
+    shell = "bash"  # default shell assumption
+
+    system_msg = SYSTEM_PROMPT.format(os_name=os_name, shell=shell)
+
+    response = client.chat.completions.create(
+        model=model,
+        messages=[
+            {"role": "system", "content": system_msg},
+            {"role": "user", "content": prompt},
+        ],
+        temperature=0,
+        timeout=60,
+    )
+
+    content = response.choices[0].message.content
+    if not content:
+        raise ValueError("LLM returned empty response")
+
+    # Strip markdown code blocks if present
+    content = content.strip()
+    if content.startswith("```"):
+        lines = content.split("\n")
+        # Remove first and last lines (``` markers)
+        content = "\n".join(lines[1:-1] if lines[-1] == "```" else lines[1:])
+    content = content.strip()
+
+    try:
+        data = json.loads(content)
+    except json.JSONDecodeError as e:
+        raise ValueError(f"LLM returned invalid JSON: {e}\nContent: {content}") from e
+
+    required_fields = ("command", "explanation", "risk_level", "risk_tip")
+    missing = [f for f in required_fields if f not in data]
+    if missing:
+        raise ValueError(f"LLM response missing fields: {missing}")
+
+    return CommandOutput(
+        command=data["command"],
+        explanation=data["explanation"],
+        risk_level=data.get("risk_level", "low"),
+        risk_tip=data.get("risk_tip", ""),
+    )

aish/safety.py

@@ -0,0 +1,70 @@
+"""Dangerous command detection for aish."""
+
+from __future__ import annotations
+import re
+from enum import Enum
+
+
+class RiskLevel(Enum):
+    ALLOW = "allow"
+    WARN = "warn"
+    DENY = "deny"
+
+
+# Patterns that DENY execution outright
+DENY_PATTERNS = [
+    r":\s*\(\s*\)\s*\{",  # fork bomb: :(){
+    r"\bmkfs\b",  # format filesystem
+    r"\bfdisk\b.*--wipe",  # disk wipe
+    r"dd\s+if=.*of=/dev/(sd|hd|nvme|disk)",  # dd to raw disk
+    r">\s*/dev/(sd[a-z]|hd[a-z]|nvme\d)",  # redirect to raw disk
+    r"shred\s+.*(/dev/|/boot/)",  # shred critical paths
+]
+
+# Patterns that WARN and require explicit confirmation
+WARN_PATTERNS = [
+    r"\brm\s+(-[rfRF]+\s+|-[rfRF]+$)",  # rm with -r or -f flags
+    r"\brm\s+-[a-zA-Z]*[rf][a-zA-Z]*",  # rm with r or f anywhere in flags
+    r"\bsudo\b",  # sudo usage
+    r"chmod\s+(777|[0-7]{3})\s+",  # chmod
+    r"\|\s*(sh|bash|zsh|fish)\b",  # pipe to shell
+    r"\bwget\b.*\|\s*(sh|bash)",  # wget | bash
+    r"\bcurl\b.*\|\s*(sh|bash)",  # curl | bash
+    r"\bdd\b.*\bof=",  # dd with output file
+    r">\s*/etc/",  # redirect to /etc/
+    r">\s*/usr/",  # redirect to /usr/
+    r">\s*/boot/",  # redirect to /boot/
+    r"\bchown\b.*-[Rr]",  # recursive chown
+    r"\bkillall\b",  # killall
+    r"\bpkill\b",  # pkill
+    r"\bsystemctl\b.*(stop|disable|mask)",  # stop system services
+    r"\buseradd\b|\buserdel\b|\busermod\b",  # user management
+]
+
+
+def check_command(command: str) -> tuple[RiskLevel, list[str]]:
+    """
+    Check a command for dangerous patterns.
+    Returns (RiskLevel, list_of_matched_patterns).
+    """
+    matches: list[str] = []
+
+    for pattern in DENY_PATTERNS:
+        if re.search(pattern, command, re.IGNORECASE):
+            matches.append(pattern)
+            return RiskLevel.DENY, matches
+
+    for pattern in WARN_PATTERNS:
+        if re.search(pattern, command, re.IGNORECASE):
+            matches.append(pattern)
+
+    if matches:
+        return RiskLevel.WARN, matches
+
+    return RiskLevel.ALLOW, []
+
+
+def is_dangerous(command: str) -> bool:
+    """Returns True if the command is WARN or DENY level."""
+    level, _ = check_command(command)
+    return level != RiskLevel.ALLOW

aish_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: aish-cli
+Version: 0.1.0
+Summary: AI-powered shell command assistant - convert natural language to safe executable commands
+Author-email: Your Name <your.email@example.com>
+License: MIT License
+        
+        Copyright (c) 2026 Kuroome
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/yourusername/aish
+Project-URL: Repository, https://github.com/yourusername/aish.git
+Project-URL: Issues, https://github.com/yourusername/aish/issues
+Keywords: ai,shell,cli,command,assistant,gpt
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Shells
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai>=1.0.0
+Requires-Dist: typer[all]>=0.9.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: tomli-w>=1.0.0
+Dynamic: license-file
+
+# aish (AI Shell)
+
+Convert natural language into safe shell commands. `aish` uses an LLM to translate your intent into bash, validates it for safety, and executes it.
+
+## Requirements
+
+Python 3.10 or higher.
+
+## Installation
+
+```bash
+git clone <repo>
+cd aish
+pip install -e .
+```
+
+## Configuration
+
+Set up your LLM provider by running `aish init`.
+
+**Interactive mode:**
+```bash
+aish init
+```
+
+**Flag mode:**
+```bash
+aish init --base-url "https://api.openai.com/v1" --api-key "sk-..." --model "gpt-4o"
+```
+
+## Usage
+
+Pass your prompt directly to `aish run`. No quotes needed.
+
+```bash
+aish run list all python files
+aish run show disk usage --dry-run
+```
+
+### Options
+
+| Option      | Short | Description                        |
+|-------------|-------|------------------------------------|
+| `--yes`     | `-y`  | Skip confirmation for safe commands |
+| `--dry-run` | `-d`  | Show the command without executing |
+
+## Safety
+
+Built-in validation checks every command before execution:
+*   **ALLOW**: Low risk. Runs immediately if you use `--yes`.
+*   **WARN**: Medium risk. Always asks for confirmation, even with `--yes`.
+*   **DENY**: High risk (like disk wipes or fork bombs). Blocked completely.
+
+## History
+
+Your last 1000 commands are saved to `~/.aish/history` in JSON Lines format. Old commands are automatically trimmed to save space.

aish_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+aish/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aish/__main__.py,sha256=H8LVHcbmXX3b2jiXLrNcRiVqu6GXnfk7Be--8ZMkRkA,32
+aish/cli.py,sha256=t-aySkc7-xF5MumI4LYGt60noasW2CAp2Z6YO1AUD8g,5185
+aish/config.py,sha256=SKDYPdjPHSK8Dh35xZZIuJRhroaLX87pGQJmoZXMYM8,1698
+aish/executor.py,sha256=ipYLUnYbUYpk-sxBM3mZ6zCbnhZPY8FTvxVFadMK-aM,1295
+aish/history.py,sha256=j_if9FJJeCEJYLVbdQtvfUClfa0ZrGl_fHWNguqVkF8,1915
+aish/llm.py,sha256=-RmFPOit3F3f86isIekF5xWZHwzo-gt36fmYTBz_6IY,2947
+aish/safety.py,sha256=xH16kel4mqAbwi6NPmKs_CpRaEGzlxZm3bnDr2j-zE0,2159
+aish_cli-0.1.0.dist-info/licenses/LICENSE,sha256=cJrOgdtzXdci9K21Se1167ziZ372z3f3hWqLiBxkfgI,1064
+aish_cli-0.1.0.dist-info/METADATA,sha256=H0fWrG0mDhPKd2o2Z6ylVrQjsyUW96CuxC0SqhiiQfc,3847
+aish_cli-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+aish_cli-0.1.0.dist-info/entry_points.txt,sha256=WHIWEAjYaVujCn3WhS4KC_Aa-N3awfv-A3fRHPWN_IU,38
+aish_cli-0.1.0.dist-info/top_level.txt,sha256=7IoxNdXDpw3hvEZcAbaz7vhZj_WPTcM-zFXTDXVg47M,5
+aish_cli-0.1.0.dist-info/RECORD,,

aish_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

aish_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aish = aish.cli:app

aish_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kuroome
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aish_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+aish