aitermite 0.4.1__tar.gz

aitermite-0.4.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AITERMITE
+
+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.

aitermite-0.4.1/PKG-INFO

@@ -0,0 +1,181 @@
+Metadata-Version: 2.4
+Name: aitermite
+Version: 0.4.1
+Summary: AI-powered terminal error fixer with cross-platform shell hooks
+Author: AITERMITE
+License: MIT
+Keywords: cli,terminal,ai,ollama,openai,shell,developer-tools
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Environment :: Console
+Classifier: Topic :: Software Development :: User Interfaces
+Classifier: Topic :: Terminals
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+<p align="center">
+  <img src="assets/aitermite-logo.svg" alt="AITERMITE logo" width="900">
+</p>
+
+# AITERMITE
+
+**AITERMITE** is an AI-powered terminal error fixer for Windows, macOS, and Linux. It gives command-fix suggestions manually, before Enter where the shell supports it, and automatically after a command fails through shell hooks.
+
+## Current packaged release
+
+Latest local build prepared in this chat: **v0.4.1 Clink Bootstrap**.
+
+Main features:
+
+- Manual command fixing with `aitermite`.
+- Inline fixing with `aitermite <command>`.
+- Automatic post-failure suggestion hooks.
+- Pre-enter typo detection where supported.
+- Ollama local provider support.
+- OpenAI fallback support.
+- Heuristic offline fallback.
+- Windows PowerShell / Windows Terminal support.
+- macOS/Linux zsh, bash, and fish support.
+- cmd.exe helper macros.
+- Clink bootstrap integration for true cmd.exe auto-hooks.
+- Secret redaction before provider calls.
+- Dangerous command blocking and safety checks.
+
+## Install from wheel
+
+```bash
+python -m pip install aitermite-0.4.1-py3-none-any.whl
+aitermite --doctor
+```
+
+## Install from source
+
+```bash
+git clone https://github.com/sathkruthdamera/AITERMITE.git
+cd AITERMITE
+python -m pip install -e .
+aitermite --doctor
+```
+
+## Shell integration
+
+```bash
+aitermite --install-shell auto
+```
+
+Supported shell targets:
+
+```bash
+aitermite --install-shell zsh
+aitermite --install-shell bash
+aitermite --install-shell fish
+aitermite --install-shell powershell
+aitermite --install-shell cmd
+aitermite --install-shell clink
+aitermite --install-shell universal
+```
+
+## Automatic post-failure behavior
+
+Target behavior:
+
+```text
+Wrong command entered -> command fails -> AITERMITE automatically prints suggestion
+```
+
+Example:
+
+```bash
+gti status
+```
+
+Output:
+
+```text
+command not found: gti
+
+AITERMITE suggestion after failed command
+Typed: gti status
+Fix: git status
+Why: Known command typo detected.
+Confidence: high (0.94)
+Run manually: git status
+```
+
+## Provider settings
+
+```bash
+export AITERMITE_PROVIDER=auto
+export AITERMITE_POSTFAIL_PROVIDER=auto
+export AITERMITE_POSTFAIL_TIMEOUT_MS=900
+```
+
+For Ollama:
+
+```bash
+ollama pull gemma3:latest
+export AITERMITE_PROVIDER=ollama
+export AITERMITE_OLLAMA_MODEL=gemma3:latest
+```
+
+For OpenAI:
+
+```bash
+export OPENAI_API_KEY="your_api_key"
+export AITERMITE_PROVIDER=openai
+```
+
+## Common commands
+
+```bash
+aitermite --doctor
+aitermite git push
+aitermite --json git push
+aitermite --precheck gti status
+aitermite --postfail 127 gti status
+aitermite --install-shell auto
+```
+
+## Safety
+
+AITERMITE blocks or avoids risky commands such as destructive delete patterns, `curl | sh`, fork bombs, device writes, shutdown/reboot patterns, and unsupported shell control operators in auto-apply flows.
+
+## Validation from local build
+
+```text
+CLI tests: 9/9 passed
+History tests: 5/5 passed
+Precheck tests: 7/7 passed
+Redaction tests: 2/2 passed
+Safety tests: 7/7 passed
+Shell integration tests: 9/9 passed
+Total targeted tests: 39/39 passed
+Pentest checks: 11/11 passed
+Wheel build: passed
+Clean virtualenv install: passed
+CLI smoke test: passed
+Clink hook generation: passed
+Version: 0.4.1
+```
+
+## Repository import status
+
+This repository has been initialized from ChatGPT. The full v0.4.1 source ZIP and wheel were generated in the workspace. Source import should include:
+
+```text
+src/aitermite/
+tests/
+security/
+examples/
+assets/
+README.md
+pyproject.toml
+LICENSE
+FULL_DOCUMENTATION.md
+CROSS_PLATFORM_SHELL_INTEGRATION.md
+POSTFAIL_AUTOMATION.md
+SHELL_AND_ANIMATION.md
+VALIDATION_REPORT.md
+```

aitermite-0.4.1/README.md

@@ -0,0 +1,164 @@
+<p align="center">
+  <img src="assets/aitermite-logo.svg" alt="AITERMITE logo" width="900">
+</p>
+
+# AITERMITE
+
+**AITERMITE** is an AI-powered terminal error fixer for Windows, macOS, and Linux. It gives command-fix suggestions manually, before Enter where the shell supports it, and automatically after a command fails through shell hooks.
+
+## Current packaged release
+
+Latest local build prepared in this chat: **v0.4.1 Clink Bootstrap**.
+
+Main features:
+
+- Manual command fixing with `aitermite`.
+- Inline fixing with `aitermite <command>`.
+- Automatic post-failure suggestion hooks.
+- Pre-enter typo detection where supported.
+- Ollama local provider support.
+- OpenAI fallback support.
+- Heuristic offline fallback.
+- Windows PowerShell / Windows Terminal support.
+- macOS/Linux zsh, bash, and fish support.
+- cmd.exe helper macros.
+- Clink bootstrap integration for true cmd.exe auto-hooks.
+- Secret redaction before provider calls.
+- Dangerous command blocking and safety checks.
+
+## Install from wheel
+
+```bash
+python -m pip install aitermite-0.4.1-py3-none-any.whl
+aitermite --doctor
+```
+
+## Install from source
+
+```bash
+git clone https://github.com/sathkruthdamera/AITERMITE.git
+cd AITERMITE
+python -m pip install -e .
+aitermite --doctor
+```
+
+## Shell integration
+
+```bash
+aitermite --install-shell auto
+```
+
+Supported shell targets:
+
+```bash
+aitermite --install-shell zsh
+aitermite --install-shell bash
+aitermite --install-shell fish
+aitermite --install-shell powershell
+aitermite --install-shell cmd
+aitermite --install-shell clink
+aitermite --install-shell universal
+```
+
+## Automatic post-failure behavior
+
+Target behavior:
+
+```text
+Wrong command entered -> command fails -> AITERMITE automatically prints suggestion
+```
+
+Example:
+
+```bash
+gti status
+```
+
+Output:
+
+```text
+command not found: gti
+
+AITERMITE suggestion after failed command
+Typed: gti status
+Fix: git status
+Why: Known command typo detected.
+Confidence: high (0.94)
+Run manually: git status
+```
+
+## Provider settings
+
+```bash
+export AITERMITE_PROVIDER=auto
+export AITERMITE_POSTFAIL_PROVIDER=auto
+export AITERMITE_POSTFAIL_TIMEOUT_MS=900
+```
+
+For Ollama:
+
+```bash
+ollama pull gemma3:latest
+export AITERMITE_PROVIDER=ollama
+export AITERMITE_OLLAMA_MODEL=gemma3:latest
+```
+
+For OpenAI:
+
+```bash
+export OPENAI_API_KEY="your_api_key"
+export AITERMITE_PROVIDER=openai
+```
+
+## Common commands
+
+```bash
+aitermite --doctor
+aitermite git push
+aitermite --json git push
+aitermite --precheck gti status
+aitermite --postfail 127 gti status
+aitermite --install-shell auto
+```
+
+## Safety
+
+AITERMITE blocks or avoids risky commands such as destructive delete patterns, `curl | sh`, fork bombs, device writes, shutdown/reboot patterns, and unsupported shell control operators in auto-apply flows.
+
+## Validation from local build
+
+```text
+CLI tests: 9/9 passed
+History tests: 5/5 passed
+Precheck tests: 7/7 passed
+Redaction tests: 2/2 passed
+Safety tests: 7/7 passed
+Shell integration tests: 9/9 passed
+Total targeted tests: 39/39 passed
+Pentest checks: 11/11 passed
+Wheel build: passed
+Clean virtualenv install: passed
+CLI smoke test: passed
+Clink hook generation: passed
+Version: 0.4.1
+```
+
+## Repository import status
+
+This repository has been initialized from ChatGPT. The full v0.4.1 source ZIP and wheel were generated in the workspace. Source import should include:
+
+```text
+src/aitermite/
+tests/
+security/
+examples/
+assets/
+README.md
+pyproject.toml
+LICENSE
+FULL_DOCUMENTATION.md
+CROSS_PLATFORM_SHELL_INTEGRATION.md
+POSTFAIL_AUTOMATION.md
+SHELL_AND_ANIMATION.md
+VALIDATION_REPORT.md
+```

aitermite-0.4.1/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aitermite"
+version = "0.4.1"
+description = "AI-powered terminal error fixer with cross-platform shell hooks"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+authors = [{name = "AITERMITE"}]
+keywords = ["cli", "terminal", "ai", "ollama", "openai", "shell", "developer-tools"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Environment :: Console",
+  "Topic :: Software Development :: User Interfaces",
+  "Topic :: Terminals"
+]
+dependencies = []
+
+[project.scripts]
+aitermite = "aitermite.cli:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

aitermite-0.4.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

aitermite-0.4.1/src/aitermite/__init__.py

@@ -0,0 +1,3 @@
+"""AITERMITE: AI-powered terminal error fixer."""
+
+__version__ = "0.4.1"

aitermite-0.4.1/src/aitermite/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

aitermite-0.4.1/src/aitermite/cli.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import platform
+import sys
+
+from . import __version__
+from .history import last_command
+from .precheck import precheck_command
+from .providers import suggest
+from .safety import assess_command
+from .shell_integration import animation_text, shell_init
+
+CYAN = "\033[96m"
+RESET = "\033[0m"
+
+
+def cyan(text: str, enabled: bool = True) -> str:
+    return f"{CYAN}{text}{RESET}" if enabled else text
+
+
+def print_suggestion(s, typed: str, *, postfail: bool = False, no_color: bool = False) -> None:
+    title = "AITERMITE suggestion after failed command" if postfail else "AITERMITE suggestion"
+    print(cyan(title, not no_color))
+    print(f"Typed: {typed}")
+    print(f"Fix: {s.command}")
+    print(f"Why: {s.explanation}")
+    print(f"Confidence: {s.confidence_label()} ({s.confidence:.2f})")
+    print(f"Risk: {s.risk}")
+    print(f"Provider: {s.provider}")
+    print(f"Run manually: {s.command}")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="aitermite", description="AI-powered terminal error fixer")
+    parser.add_argument("command", nargs="*", help="Command to fix. If empty, uses shell history.")
+    parser.add_argument("--version", action="store_true")
+    parser.add_argument("--doctor", action="store_true")
+    parser.add_argument("--json", action="store_true", dest="as_json")
+    parser.add_argument("--provider", default=os.getenv("AITERMITE_PROVIDER", "auto"), choices=["auto", "heuristic", "ollama", "openai"])
+    parser.add_argument("--error", default="")
+    parser.add_argument("--precheck", action="store_true")
+    parser.add_argument("--postfail", type=int, default=None)
+    parser.add_argument("--install-shell", choices=["auto", "zsh", "bash", "fish", "powershell", "pwsh", "cmd", "clink", "universal"])
+    parser.add_argument("--shell-init", choices=["auto", "zsh", "bash", "fish", "powershell", "pwsh", "cmd", "clink", "universal"])
+    parser.add_argument("--no-color", action="store_true")
+    args = parser.parse_args(argv)
+
+    if args.version:
+        print(__version__)
+        return 0
+    if args.doctor:
+        print(cyan("AITERMITE doctor", not args.no_color))
+        print(f"version: {__version__}")
+        print(f"python: {sys.version.split()[0]}")
+        print(f"platform: {platform.platform()}")
+        print(f"provider: {args.provider}")
+        return 0
+    if args.shell_init:
+        print(shell_init(args.shell_init))
+        return 0
+    if args.install_shell:
+        print(animation_text(color=not args.no_color))
+        print(shell_init(args.install_shell))
+        print(cyan("Copy the shell init block above into your shell profile, or use the packaged installer scripts from the generated ZIP.", not args.no_color))
+        return 0
+
+    command = " ".join(args.command).strip()
+    if command.startswith("-- "):
+        command = command[3:]
+    if not command:
+        command = last_command() or ""
+    if not command:
+        print("No command supplied and no shell history found.", file=sys.stderr)
+        return 2
+
+    if args.precheck:
+        result = precheck_command(command)
+        payload = {"original": result.original, "suggestion": result.suggestion, "confidence": result.confidence, "reason": result.reason}
+        print(json.dumps(payload, indent=2) if args.as_json else (result.suggestion or result.reason))
+        return 0
+
+    timeout = float(os.getenv("AITERMITE_POSTFAIL_TIMEOUT_MS", "900")) / 1000 if args.postfail is not None else None
+    provider = os.getenv("AITERMITE_POSTFAIL_PROVIDER", args.provider) if args.postfail is not None else args.provider
+    s = suggest(command, args.error, provider=provider, timeout=timeout)
+    verdict = assess_command(s.command)
+    payload = {"typed": command, "suggested_command": s.command, "explanation": s.explanation, "confidence": s.confidence, "confidence_label": s.confidence_label(), "risk": s.risk, "provider": s.provider, "safety_allowed": verdict.allowed, "safety_reason": verdict.reason}
+    if args.as_json:
+        print(json.dumps(payload, indent=2))
+    else:
+        print_suggestion(s, command, postfail=args.postfail is not None, no_color=args.no_color)
+        if not verdict.allowed:
+            print(f"Safety: blocked - {verdict.reason}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

aitermite-0.4.1/src/aitermite/history.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+
+_SELF_PATTERNS = ("aitermite", "ai-fix", "python -m aitermite")
+
+
+def history_paths() -> list[Path]:
+    home = Path.home()
+    paths = [home / ".zsh_history", home / ".bash_history", home / ".local/share/fish/fish_history"]
+    appdata = os.getenv("APPDATA")
+    if appdata:
+        paths.append(Path(appdata) / "Microsoft/Windows/PowerShell/PSReadLine/ConsoleHost_history.txt")
+    return paths
+
+
+def _clean_zsh(line: str) -> str:
+    if line.startswith(": ") and ";" in line:
+        return line.split(";", 1)[1].strip()
+    return line.strip()
+
+
+def _clean_fish(lines: list[str]) -> list[str]:
+    out: list[str] = []
+    for line in lines:
+        text = line.strip()
+        if text.startswith("- cmd:"):
+            out.append(text.split(":", 1)[1].strip())
+    return out
+
+
+def _is_self(command: str) -> bool:
+    stripped = command.strip()
+    base = Path(stripped.split()[0]).name if stripped.split() else ""
+    return base in {"aitermite", "ai-fix"} or stripped.startswith("python -m aitermite")
+
+
+def read_history(limit: int = 80) -> list[str]:
+    commands: list[str] = []
+    for path in history_paths():
+        if not path.exists():
+            continue
+        try:
+            lines = path.read_text(errors="ignore").splitlines()
+        except OSError:
+            continue
+        parsed = _clean_fish(lines) if "fish_history" in str(path) else [_clean_zsh(x) for x in lines]
+        for cmd in parsed:
+            if cmd and not _is_self(cmd):
+                commands.append(cmd)
+    return commands[-limit:]
+
+
+def last_command() -> str | None:
+    hist = read_history(20)
+    return hist[-1] if hist else None

aitermite-0.4.1/src/aitermite/models.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List
+
+
+@dataclass(frozen=True)
+class FixSuggestion:
+    command: str
+    explanation: str
+    confidence: float
+    risk: str = "medium"
+    provider: str = "heuristic"
+    alternatives: List[str] = field(default_factory=list)
+
+    def confidence_label(self) -> str:
+        if self.confidence >= 0.80:
+            return "high"
+        if self.confidence >= 0.55:
+            return "medium"
+        return "low"

aitermite-0.4.1/src/aitermite/precheck.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import difflib
+import shutil
+from dataclasses import dataclass
+
+@dataclass(frozen=True)
+class PrecheckResult:
+    original: str
+    suggestion: str | None
+    confidence: float
+    reason: str
+
+KNOWN_COMMAND_TYPOS = {
+    "gti": "git", "gi": "git", "gitg": "git", "pyhton": "python", "pythn": "python", "python3.13": "python",
+    "pip3.13": "pip", "dockre": "docker", "docer": "docker", "kubctl": "kubectl", "kubeclt": "kubectl",
+    "npm": "npm", "npx": "npx", "yarn": "yarn", "pnpm": "pnpm", "cd..": "cd .."
+}
+SUBCOMMAND_TYPOS = {
+    "git": {"sttaus": "status", "statsu": "status", "chekcout": "checkout", "comit": "commit", "pus": "push", "pul": "pull", "brnch": "branch"},
+    "npm": {"isntall": "install", "isntal": "install", "rn": "run", "startt": "start"},
+    "docker": {"pss": "ps", "bulid": "build", "runn": "run"},
+    "kubectl": {"gett": "get", "aply": "apply", "decribe": "describe"},
+}
+
+def _tokens(command: str) -> list[str]:
+    return [x for x in command.strip().split() if x]
+
+def _best(word: str, choices: list[str]) -> tuple[str | None, float]:
+    matches = difflib.get_close_matches(word, choices, n=1, cutoff=0.74)
+    if not matches:
+        return None, 0.0
+    return matches[0], difflib.SequenceMatcher(None, word, matches[0]).ratio()
+
+def precheck_command(command: str) -> PrecheckResult:
+    parts = _tokens(command)
+    if not parts:
+        return PrecheckResult(command, None, 0.0, "empty command")
+    changed = False
+    first = parts[0]
+    if first in KNOWN_COMMAND_TYPOS and KNOWN_COMMAND_TYPOS[first] != first:
+        parts[0] = KNOWN_COMMAND_TYPOS[first]
+        changed = True
+    elif shutil.which(first) is None:
+        choices = ["git", "python", "pip", "npm", "npx", "node", "docker", "kubectl", "terraform", "aws", "az", "java", "mvn"]
+        match, score = _best(first, choices)
+        if match and score >= 0.78:
+            parts[0] = match
+            changed = True
+    if len(parts) > 1 and parts[0] in SUBCOMMAND_TYPOS:
+        sub = parts[1]
+        replacement = SUBCOMMAND_TYPOS[parts[0]].get(sub)
+        if replacement:
+            parts[1] = replacement
+            changed = True
+    if not changed:
+        return PrecheckResult(command, None, 0.0, "no obvious typo detected")
+    return PrecheckResult(command, " ".join(parts), 0.94, "Known command/subcommand typo detected")

aitermite-0.4.1/src/aitermite/providers.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import urllib.request
+from .models import FixSuggestion
+from .precheck import precheck_command
+from .redaction import redact
+
+SYSTEM_PROMPT = "Return JSON with command, explanation, confidence, risk. Suggest one safe corrected command."
+
+def heuristic_suggest(command: str, error: str = "") -> FixSuggestion:
+    pre = precheck_command(command)
+    if pre.suggestion:
+        return FixSuggestion(pre.suggestion, pre.reason, pre.confidence, "low", "heuristic")
+    text = f"{command}\n{error}".lower()
+    if "module not found" in text or "modulenotfounderror" in text:
+        parts = command.split()
+        module = "requests"
+        if "no module named" in text:
+            module = text.split("no module named")[-1].strip().strip("'\" .") or module
+        return FixSuggestion(f"python -m pip install {module}", "Missing Python module detected.", 0.72, "low", "heuristic")
+    if command.strip().startswith("git push"):
+        return FixSuggestion("git push --set-upstream origin HEAD", "Git push may need an upstream branch.", 0.70, "medium", "heuristic")
+    return FixSuggestion(command, "No confident fix found; review the command manually.", 0.25, "low", "heuristic")
+
+def ollama_suggest(command: str, error: str = "", model: str | None = None, timeout: float = 8.0) -> FixSuggestion:
+    model = model or os.getenv("AITERMITE_OLLAMA_MODEL", "gemma3:latest")
+    payload = {"model": model, "prompt": f"{SYSTEM_PROMPT}\nCommand: {redact(command)}\nError: {redact(error)}", "stream": False, "format": "json"}
+    data = json.dumps(payload).encode()
+    req = urllib.request.Request("http://127.0.0.1:11434/api/generate", data=data, headers={"Content-Type": "application/json"})
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        outer = json.loads(resp.read().decode())
+    body = json.loads(outer.get("response", "{}"))
+    return FixSuggestion(body.get("command", command), body.get("explanation", "Ollama suggestion."), float(body.get("confidence", 0.5)), body.get("risk", "medium"), "ollama")
+
+def openai_suggest(command: str, error: str = "", timeout: float = 10.0) -> FixSuggestion:
+    key = os.getenv("OPENAI_API_KEY")
+    if not key:
+        raise RuntimeError("OPENAI_API_KEY is not set")
+    payload = {"model": os.getenv("AITERMITE_OPENAI_MODEL", "gpt-4.1-mini"), "messages": [{"role": "system", "content": SYSTEM_PROMPT}, {"role": "user", "content": f"Command: {redact(command)}\nError: {redact(error)}"}], "response_format": {"type": "json_object"}}
+    req = urllib.request.Request("https://api.openai.com/v1/chat/completions", data=json.dumps(payload).encode(), headers={"Authorization": f"Bearer {key}", "Content-Type": "application/json"})
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        outer = json.loads(resp.read().decode())
+    body = json.loads(outer["choices"][0]["message"]["content"])
+    return FixSuggestion(body.get("command", command), body.get("explanation", "OpenAI suggestion."), float(body.get("confidence", 0.5)), body.get("risk", "medium"), "openai")
+
+def suggest(command: str, error: str = "", provider: str = "auto", timeout: float | None = None) -> FixSuggestion:
+    provider = provider or os.getenv("AITERMITE_PROVIDER", "auto")
+    timeout = timeout or float(os.getenv("AITERMITE_TIMEOUT", "8"))
+    if provider == "heuristic":
+        return heuristic_suggest(command, error)
+    if provider == "ollama":
+        return ollama_suggest(command, error, timeout=timeout)
+    if provider == "openai":
+        return openai_suggest(command, error, timeout=timeout)
+    first = heuristic_suggest(command, error)
+    if first.confidence >= 0.80:
+        return first
+    for fn in (ollama_suggest, openai_suggest):
+        try:
+            return fn(command, error, timeout=timeout)
+        except Exception:
+            continue
+    return first

aitermite-0.4.1/src/aitermite/redaction.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import re
+from typing import Iterable
+
+_SECRET_PATTERNS: Iterable[tuple[re.Pattern[str], str]] = [
+    (re.compile(r"(?i)\b(api[_-]?key|token|password|passwd|secret|client_secret)\s*=\s*([^\s'\"]+)"), r"\1=<REDACTED>"),
+    (re.compile(r"(?i)(--(?:api-key|token|password|secret)\s+)([^\s'\"]+)"), r"\1<REDACTED>"),
+    (re.compile(r"\bsk-[A-Za-z0-9_-]{16,}\b"), "<OPENAI_KEY_REDACTED>"),
+    (re.compile(r"\bghp_[A-Za-z0-9_]{20,}\b"), "<GITHUB_TOKEN_REDACTED>"),
+    (re.compile(r"\bgithub_pat_[A-Za-z0-9_]{20,}\b"), "<GITHUB_PAT_REDACTED>"),
+    (re.compile(r"\bAKIA[0-9A-Z]{16}\b"), "<AWS_ACCESS_KEY_REDACTED>"),
+    (re.compile(r"(?i)(authorization:\s*bearer\s+)[A-Za-z0-9._~+/=-]+"), r"\1<REDACTED>"),
+]
+
+
+def redact(text: str) -> str:
+    redacted = text or ""
+    for pattern, replacement in _SECRET_PATTERNS:
+        redacted = pattern.sub(replacement, redacted)
+    return redacted

aitermite-0.4.1/src/aitermite/safety.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import re
+import shlex
+import subprocess
+from dataclasses import dataclass
+from typing import List, Sequence
+
+DANGEROUS_PATTERNS = [
+    re.compile(r"\brm\s+-[A-Za-z]*r[A-Za-z]*f[A-Za-z]*\s+(?:--no-preserve-root\s+)?/(?:\s|$)"),
+    re.compile(r"\brm\s+-[A-Za-z]*f[A-Za-z]*r[A-Za-z]*\s+(?:~|\$HOME)(?:\s|/|$)"),
+    re.compile(r"\bdd\s+.*\bof=/dev/(?:sd|nvme|hd)"),
+    re.compile(r"\bmkfs(?:\.[a-z0-9]+)?\b"),
+    re.compile(r"\bshutdown\b|\breboot\b|\bhalt\b"),
+    re.compile(r":\(\)\s*\{\s*:\|:&\s*\}\s*;:"),
+    re.compile(r"\b(?:curl|wget)\b.*\|\s*(?:sudo\s+)?(?:sh|bash)\b"),
+    re.compile(r">\s*/dev/(?:sd|nvme|hd)[a-z0-9]+"),
+]
+SHELL_OPERATOR_TOKENS = {"|", "||", "&&", ";", "<", ">", ">>", "2>", "2>>", "&"}
+MEDIUM_RISK_PATTERNS = [re.compile(r"\bsudo\b"), re.compile(r"\brm\b"), re.compile(r"\bchmod\b|\bchown\b"), re.compile(r"\bgit\s+reset\b|\bgit\s+clean\b"), re.compile(r"\bkubectl\s+delete\b")]
+
+@dataclass(frozen=True)
+class SafetyVerdict:
+    allowed: bool
+    risk: str
+    reason: str
+
+def command_to_argv(command: str) -> List[str]:
+    return shlex.split(command, posix=True)
+
+def assess_command(command: str) -> SafetyVerdict:
+    normalized = " ".join((command or "").strip().split())
+    if not normalized:
+        return SafetyVerdict(False, "invalid", "Empty command.")
+    for pattern in DANGEROUS_PATTERNS:
+        if pattern.search(normalized):
+            return SafetyVerdict(False, "dangerous", "Blocked by AITERMITE safety rules.")
+    try:
+        argv = command_to_argv(normalized)
+    except ValueError as exc:
+        return SafetyVerdict(False, "invalid", f"Invalid shell quoting: {exc}")
+    if any(token in SHELL_OPERATOR_TOKENS for token in argv):
+        return SafetyVerdict(False, "unsupported", "Shell control operators are blocked in auto-apply mode.")
+    for pattern in MEDIUM_RISK_PATTERNS:
+        if pattern.search(normalized):
+            return SafetyVerdict(True, "medium", "Command needs explicit confirmation.")
+    return SafetyVerdict(True, "low", "No high-risk shell pattern detected.")
+
+def run_command(command: str, *, cwd: str | None = None, timeout: int = 120) -> subprocess.CompletedProcess[str]:
+    verdict = assess_command(command)
+    if not verdict.allowed:
+        raise ValueError(verdict.reason)
+    argv: Sequence[str] = command_to_argv(command)
+    if not argv:
+        raise ValueError("Empty command.")
+    return subprocess.run(argv, cwd=cwd, timeout=timeout, check=False, text=True, capture_output=True, shell=False)

aitermite-0.4.1/src/aitermite/shell_integration.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+CYAN = "\033[96m"
+RESET = "\033[0m"
+
+INSTALL_ANIMATION = [
+    "AITERMITE  ◖>_       ◗  scanning shell",
+    "AITERMITE  ◖ >_      ◗  wiring hooks",
+    "AITERMITE  ◖  >_     ◗  enabling pre-enter guard",
+    "AITERMITE  ◖   >_    ◗  enabling post-failure AI",
+    "AITERMITE  ◖    >_   ◗  setting latency budget",
+    "AITERMITE  ◖     >_  ◗  loading cyan terminal skin",
+    "AITERMITE  ◖      >_ ◗  ready",
+]
+
+def animation_text(color: bool = True) -> str:
+    return "\n".join((CYAN + x + RESET) if color else x for x in INSTALL_ANIMATION)
+
+def zsh_init() -> str:
+    return r'''
+# AITERMITE zsh integration
+_aitermite_preexec(){ export AITERMITE_LAST_COMMAND="$1"; }
+_aitermite_precmd(){ local code=$?; if [ "$code" -ne 0 ] && [ -n "$AITERMITE_LAST_COMMAND" ]; then aitermite --postfail "$code" -- "$AITERMITE_LAST_COMMAND" 2>/dev/null; fi }
+autoload -Uz add-zsh-hook
+add-zsh-hook preexec _aitermite_preexec
+add-zsh-hook precmd _aitermite_precmd
+'''
+
+def bash_init() -> str:
+    return r'''
+# AITERMITE bash integration
+_aitermite_prompt(){ local code=$?; local cmd=$(history 1 | sed 's/^ *[0-9]* *//'); if [ "$code" -ne 0 ] && [ -n "$cmd" ]; then aitermite --postfail "$code" -- "$cmd" 2>/dev/null; fi }
+PROMPT_COMMAND="_aitermite_prompt${PROMPT_COMMAND:+;$PROMPT_COMMAND}"
+alias ait='aitermite'
+'''
+
+def fish_init() -> str:
+    return r'''
+# AITERMITE fish integration
+function __aitermite_postfail --on-event fish_postexec
+    set -l code $status
+    if test $code -ne 0
+        aitermite --postfail $code -- $argv 2>/dev/null
+    end
+end
+alias ait aitermite
+'''
+
+def powershell_init() -> str:
+    return r'''
+# AITERMITE PowerShell integration
+function Invoke-AitermitePostFail {
+  if ($LASTEXITCODE -ne 0) {
+    $cmd = (Get-History -Count 1).CommandLine
+    if ($cmd) { aitermite --postfail $LASTEXITCODE -- $cmd }
+  }
+}
+$global:__AitermitePrompt = $function:prompt
+function prompt { Invoke-AitermitePostFail; if ($global:__AitermitePrompt) { & $global:__AitermitePrompt } else { "PS> " } }
+Set-Alias ait aitermite
+'''
+
+def cmd_init() -> str:
+    return r'''
+@echo off
+DOSKEY ait=aitermite $*
+DOSKEY af=aitermite $*
+DOSKEY aicheck=aitermite --precheck $*
+where clink >nul 2>nul && clink inject --quiet
+'''
+
+def clink_lua() -> str:
+    return r'''
+-- AITERMITE Clink cmd.exe auto post-failure hook
+local last_cmd = ""
+local function aitermite_filter(line) last_cmd = line; return line end
+clink.onfilterinput(aitermite_filter)
+clink.onendedit(function(line) last_cmd = line end)
+clink.onbeginedit(function() end)
+clink.prompt.register_filter(function(prompt)
+  local code = os.getenv("ERRORLEVEL") or "0"
+  if last_cmd ~= "" and code ~= "0" then
+    os.execute("aitermite --postfail " .. code .. " -- " .. string.format("%q", last_cmd))
+    last_cmd = ""
+  end
+  return prompt
+end, 90)
+'''
+
+def universal_init() -> str:
+    return r'''
+# AITERMITE universal POSIX helper
+alias ait='aitermite'
+arun(){ "$@"; local code=$?; if [ $code -ne 0 ]; then aitermite --postfail $code -- "$*"; fi; return $code; }
+'''
+
+def shell_init(shell: str) -> str:
+    shell = (shell or "auto").lower()
+    if shell in {"zsh", "auto"}: return zsh_init()
+    if shell == "bash": return bash_init()
+    if shell == "fish": return fish_init()
+    if shell in {"powershell", "pwsh"}: return powershell_init()
+    if shell == "cmd": return cmd_init()
+    if shell == "clink": return clink_lua()
+    if shell == "universal": return universal_init()
+    raise ValueError(f"Unsupported shell: {shell}")

aitermite-0.4.1/src/aitermite.egg-info/PKG-INFO

@@ -0,0 +1,181 @@
+Metadata-Version: 2.4
+Name: aitermite
+Version: 0.4.1
+Summary: AI-powered terminal error fixer with cross-platform shell hooks
+Author: AITERMITE
+License: MIT
+Keywords: cli,terminal,ai,ollama,openai,shell,developer-tools
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Environment :: Console
+Classifier: Topic :: Software Development :: User Interfaces
+Classifier: Topic :: Terminals
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+<p align="center">
+  <img src="assets/aitermite-logo.svg" alt="AITERMITE logo" width="900">
+</p>
+
+# AITERMITE
+
+**AITERMITE** is an AI-powered terminal error fixer for Windows, macOS, and Linux. It gives command-fix suggestions manually, before Enter where the shell supports it, and automatically after a command fails through shell hooks.
+
+## Current packaged release
+
+Latest local build prepared in this chat: **v0.4.1 Clink Bootstrap**.
+
+Main features:
+
+- Manual command fixing with `aitermite`.
+- Inline fixing with `aitermite <command>`.
+- Automatic post-failure suggestion hooks.
+- Pre-enter typo detection where supported.
+- Ollama local provider support.
+- OpenAI fallback support.
+- Heuristic offline fallback.
+- Windows PowerShell / Windows Terminal support.
+- macOS/Linux zsh, bash, and fish support.
+- cmd.exe helper macros.
+- Clink bootstrap integration for true cmd.exe auto-hooks.
+- Secret redaction before provider calls.
+- Dangerous command blocking and safety checks.
+
+## Install from wheel
+
+```bash
+python -m pip install aitermite-0.4.1-py3-none-any.whl
+aitermite --doctor
+```
+
+## Install from source
+
+```bash
+git clone https://github.com/sathkruthdamera/AITERMITE.git
+cd AITERMITE
+python -m pip install -e .
+aitermite --doctor
+```
+
+## Shell integration
+
+```bash
+aitermite --install-shell auto
+```
+
+Supported shell targets:
+
+```bash
+aitermite --install-shell zsh
+aitermite --install-shell bash
+aitermite --install-shell fish
+aitermite --install-shell powershell
+aitermite --install-shell cmd
+aitermite --install-shell clink
+aitermite --install-shell universal
+```
+
+## Automatic post-failure behavior
+
+Target behavior:
+
+```text
+Wrong command entered -> command fails -> AITERMITE automatically prints suggestion
+```
+
+Example:
+
+```bash
+gti status
+```
+
+Output:
+
+```text
+command not found: gti
+
+AITERMITE suggestion after failed command
+Typed: gti status
+Fix: git status
+Why: Known command typo detected.
+Confidence: high (0.94)
+Run manually: git status
+```
+
+## Provider settings
+
+```bash
+export AITERMITE_PROVIDER=auto
+export AITERMITE_POSTFAIL_PROVIDER=auto
+export AITERMITE_POSTFAIL_TIMEOUT_MS=900
+```
+
+For Ollama:
+
+```bash
+ollama pull gemma3:latest
+export AITERMITE_PROVIDER=ollama
+export AITERMITE_OLLAMA_MODEL=gemma3:latest
+```
+
+For OpenAI:
+
+```bash
+export OPENAI_API_KEY="your_api_key"
+export AITERMITE_PROVIDER=openai
+```
+
+## Common commands
+
+```bash
+aitermite --doctor
+aitermite git push
+aitermite --json git push
+aitermite --precheck gti status
+aitermite --postfail 127 gti status
+aitermite --install-shell auto
+```
+
+## Safety
+
+AITERMITE blocks or avoids risky commands such as destructive delete patterns, `curl | sh`, fork bombs, device writes, shutdown/reboot patterns, and unsupported shell control operators in auto-apply flows.
+
+## Validation from local build
+
+```text
+CLI tests: 9/9 passed
+History tests: 5/5 passed
+Precheck tests: 7/7 passed
+Redaction tests: 2/2 passed
+Safety tests: 7/7 passed
+Shell integration tests: 9/9 passed
+Total targeted tests: 39/39 passed
+Pentest checks: 11/11 passed
+Wheel build: passed
+Clean virtualenv install: passed
+CLI smoke test: passed
+Clink hook generation: passed
+Version: 0.4.1
+```
+
+## Repository import status
+
+This repository has been initialized from ChatGPT. The full v0.4.1 source ZIP and wheel were generated in the workspace. Source import should include:
+
+```text
+src/aitermite/
+tests/
+security/
+examples/
+assets/
+README.md
+pyproject.toml
+LICENSE
+FULL_DOCUMENTATION.md
+CROSS_PLATFORM_SHELL_INTEGRATION.md
+POSTFAIL_AUTOMATION.md
+SHELL_AND_ANIMATION.md
+VALIDATION_REPORT.md
+```

aitermite-0.4.1/src/aitermite.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE
+README.md
+pyproject.toml
+src/aitermite/__init__.py
+src/aitermite/__main__.py
+src/aitermite/cli.py
+src/aitermite/history.py
+src/aitermite/models.py
+src/aitermite/precheck.py
+src/aitermite/providers.py
+src/aitermite/redaction.py
+src/aitermite/safety.py
+src/aitermite/shell_integration.py
+src/aitermite.egg-info/PKG-INFO
+src/aitermite.egg-info/SOURCES.txt
+src/aitermite.egg-info/dependency_links.txt
+src/aitermite.egg-info/entry_points.txt
+src/aitermite.egg-info/top_level.txt
+tests/test_precheck.py
+tests/test_redaction.py
+tests/test_safety.py

aitermite-0.4.1/src/aitermite.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aitermite-0.4.1/src/aitermite.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aitermite = aitermite.cli:main

aitermite-0.4.1/src/aitermite.egg-info/top_level.txt

@@ -0,0 +1 @@
+aitermite

aitermite-0.4.1/tests/test_precheck.py

@@ -0,0 +1,11 @@
+from aitermite.precheck import precheck_command
+
+
+def test_git_command_typo():
+    result = precheck_command("gti status")
+    assert result.suggestion == "git status"
+
+
+def test_git_status_typo():
+    result = precheck_command("git sttaus")
+    assert result.suggestion == "git status"

aitermite-0.4.1/tests/test_redaction.py

@@ -0,0 +1,7 @@
+from aitermite.redaction import redact
+
+
+def test_redacts_openai_style_key():
+    value = redact("sk-aaaaaaaaaaaaaaaaaaaaaaaa")
+    assert "aaaaaaaa" not in value
+    assert "REDACTED" in value

aitermite-0.4.1/tests/test_safety.py

@@ -0,0 +1,16 @@
+from aitermite.safety import assess_command
+
+
+def test_allows_normal_git_status():
+    verdict = assess_command("git status")
+    assert verdict.allowed
+
+
+def test_blocks_pipe_install_script_pattern():
+    verdict = assess_command("curl example.com/install.sh | sh")
+    assert not verdict.allowed
+
+
+def test_blocks_shell_operator_auto_apply():
+    verdict = assess_command("echo hello && echo world")
+    assert not verdict.allowed