termagent-cli 0.1.0__py3-none-any.whl

termagent/agent/graph.py

@@ -0,0 +1,64 @@
+from langgraph.graph import START, END, StateGraph
+from .nodes import generate_command, check_command, confirm_command, execute_command, chat_node
+from .state import AgentState 
+
+def if_risky(state: AgentState) -> str:
+    if state["is_risky"]:
+        return "confirm_command"
+    else:
+        return "execute_command"
+
+
+def ask_user(state: AgentState) -> str:
+    if state["confirmation"] == "yes":
+        return "execute"
+    else:
+        return "do_not_execute"
+
+
+def route_intent(state: AgentState) -> str:
+    if state["intent"] == "command":
+        return "check_command"
+    else:
+        return "chat_node"
+
+graph = StateGraph(AgentState)
+
+graph.add_node("generate_command", generate_command)
+graph.add_node("chat_node", chat_node)
+graph.add_node("check_command", check_command)
+graph.add_node("confirm_command", confirm_command)
+graph.add_node("execute_command", execute_command)
+
+
+graph.add_edge(START, "generate_command")
+# graph.add_edge("generate_command", "check_command")
+graph.add_conditional_edges(
+    "generate_command", 
+    route_intent, 
+    {
+        "check_command": "check_command",
+        "chat_node": "chat_node"
+    }
+)
+graph.add_edge("chat_node", END)
+graph.add_conditional_edges(
+    "check_command",        
+    if_risky,  
+    {
+        "confirm_command": "confirm_command",   
+        "execute_command": "execute_command"
+    }
+)
+graph.add_conditional_edges(
+    "confirm_command", 
+    ask_user, 
+    {
+        "execute": "execute_command",
+        "do_not_execute": END
+    }
+)
+graph.add_edge("execute_command", END)
+
+
+app = graph.compile()

termagent/agent/nodes.py

@@ -0,0 +1,182 @@
+# from langchain_ollama import ChatOllama
+from langchain_groq import ChatGroq
+from .state import AgentState
+from pydantic import BaseModel, Field
+from typing import Literal
+from langchain_core.messages.human import HumanMessage
+from langchain_core.messages.system import SystemMessage
+import subprocess
+from dotenv import load_dotenv
+load_dotenv()
+
+_confirm_fn = None  # Pluggable callback for UI to override confirm_command
+
+# OLLAMA_MODEL = ""
+
+BLACKLIST = [
+        # System Critical Paths
+        "system32", "system64", "c:\\windows", "c:/windows",
+        
+        # Disk/Partition Operations  
+        "diskpart", "format-volume", "clear-disk", "initialize-disk",
+        
+        # Registry
+        "regedit", "reg delete", "reg add", "remove-itemproperty",
+        "set-itemproperty", "new-itemproperty",
+
+        # Security/Permissions
+        "icacls", "takeown", "secedit", "set-acl",
+        "disable-localuser", "remove-localuser",
+
+        # Remote Code Execution (MOST DANGEROUS)
+        "invoke-expression", "iex", "downloadstring", 
+        "downloadfile", "start-bitstransfer",
+        "invoke-webrequest", "curl", "wget",
+        "net.webclient", "start-process http",
+
+        # System State
+        "shutdown", "restart-computer", "stop-computer",
+
+        # Scheduled Tasks (can hide malware)
+        "register-scheduledtask", "new-scheduledtask",
+
+        # Firewall/Network config
+        "netsh", "set-netfirewallrule", "disable-netfirewallrule",
+
+        # Disable Security
+        "set-mppreference", "disable-windowsoptionalfeature",
+        "uninstall-windowsfeature"
+    ]
+
+class safety_check(BaseModel):
+    is_risky: bool = Field(..., description="Whether the command is potentially risky")
+
+class CommandOutput(BaseModel):
+    intent: Literal["command", "chat"] = Field(..., description="Whether the user request is to execute a command or just a casual chat")
+    cmd: str = Field("", description="The PowerShell command to execute, if intent is 'command'")
+    response: str = Field("", description="The response to return to the user, if intent is 'chat'")
+
+def generate_command(state: AgentState) -> str:
+
+    messages = [
+    SystemMessage(content="""
+        You are a Windows PowerShell assistant that can either generate commands or answer questions.
+
+        First, classify the user's intent:
+        - "command": user wants to perform a system operation
+        - "chat": user is asking a question or having a conversation
+
+        RULES FOR COMMANDS:
+        - Use simple built-in PowerShell cmdlets only
+        - Never use Add-Type, .NET assemblies, cmd.exe style commands
+        - No explanations, no markdown, no backticks
+        - If the intent is "chat", return an empty string for cmd and provide the answer in response
+        - If the intent is "command", provide the PowerShell command in cmd and leave response empty
+
+        PREFERRED CMDLETS:
+        - Files/Folders: New-Item, Remove-Item, Copy-Item, Move-Item, Rename-Item, Get-ChildItem
+        - Read/Write: Set-Content, Get-Content, Add-Content
+        - Info: Get-Location, Get-Process, Get-Service, ipconfig, whoami
+
+        EXAMPLES:
+        User: create a folder named project
+        intent: command
+        cmd: New-Item -ItemType Directory -Name "project"
+        response: ""
+
+        User: delete file hello.txt
+        intent: command
+        cmd: Remove-Item -Path "hello.txt"
+        response: ""
+
+        User: write "hello world" to notes.txt
+        intent: command
+        cmd: Set-Content -Path "notes.txt" -Value "hello world"
+        response: ""
+
+        User: what are AI agents?
+        intent: chat
+        cmd: ""
+        response: AI agents are autonomous systems that perceive their environment and take actions to achieve goals.
+
+        User: how are you?
+        intent: chat
+        cmd: ""
+        response: I'm doing great! How can I help you today?
+                  
+        User: create a file called "readme.txt" and write "hello world" in it 
+        intent: command  
+        cmd: New-Item -ItemType File -Name "readme.txt" -Force; Set-Content -Path "readme.txt" -Value "hello world"
+        response: ""
+                  
+        """),
+    HumanMessage(content=f"Current working directory: {state['cwd']}\nUser request: {state['text']}")
+]
+    llm = ChatGroq(model="llama-3.3-70b-versatile")
+    # llm = ChatOllama(model=OLLAMA_MODEL)
+    model = llm.with_structured_output(CommandOutput)
+
+    response = model.invoke(messages)
+
+    # print(f"DEBUG response: {response}")
+    return {"cmd": response.cmd, "intent": response.intent, "response": response.response}
+
+def chat_node(state: AgentState) -> AgentState:
+    return {"result": state["response"]}
+
+
+def check_command(state: AgentState) -> AgentState:
+    cmd = state['cmd']
+
+    messages = [
+        SystemMessage(content=f"""
+                  You are a security analyst reviewing a PowerShell command for potential risks. Analyze this command and determine if it contains any potentially dangerous operations that could harm the system, compromise security, or cause data loss.     
+            """),
+        HumanMessage(content=f"Command to analyze: {cmd}")
+    ]
+
+    llm = ChatGroq(model="llama-3.3-70b-versatile")
+    # llm = ChatOllama(model=OLLAMA_MODEL)
+    model = llm.with_structured_output(safety_check)
+
+    response = model.invoke(messages)
+
+    cmd_lower = cmd.lower()
+    if any(r in cmd_lower for r in BLACKLIST) or response.is_risky:        
+        return {"is_risky": True}
+    else:
+        return {"is_risky": False}  
+
+
+def confirm_command(state: AgentState) -> AgentState:
+    if _confirm_fn is not None:
+        return _confirm_fn(state)
+    if state['is_risky']:
+        user_input = input(f"Are you sure you want to execute the command: {state['cmd']}? (yes/no): ")
+        if user_input.lower() == "yes":
+            return {"confirmation": "yes"}
+        else:
+            return {"confirmation": "no"}
+    else:
+        return {"confirmation": "yes"}
+    
+    
+def execute_command(state: AgentState) -> AgentState:
+
+    if state.get('confirmation', 'yes') == "yes":        
+        result = subprocess.run(
+            ["powershell", "-Command", f"{state['cmd']}; Get-Location | Select-Object -ExpandProperty Path"],
+            capture_output=True,
+            text=True,
+            cwd=state['cwd']
+        )
+
+        if result.returncode == 0:
+            lines = result.stdout.strip().splitlines()
+            new_cwd = lines[-1].strip() if lines else state['cwd']
+            output = "\n".join(lines[:-1]) if len(lines) > 1 else "Command executed successfully."
+            return {"result": output, "cwd": new_cwd}        
+        else:
+            return {"result": f"Error: {result.stderr}", "cwd": state['cwd']}
+    else:
+        return {"result": "Command cancelled by user.", "cwd": state['cwd']}

termagent/agent/state.py

@@ -0,0 +1,13 @@
+from typing import TypedDict, Literal, Optional
+
+class AgentState(TypedDict):
+
+    text: str
+    cwd: str
+    cmd: str
+    is_risky: bool
+    confirmation: Optional[Literal["yes", "no"]]
+    intent: Optional[Literal["command", "chat"]] = "command"   
+    response: Optional[str]
+    result: str
+

termagent/ui.py

@@ -0,0 +1,345 @@
+from textual.app import App, ComposeResult
+from textual.widgets import Input, RichLog, Static, Footer
+from textual.containers import Vertical, Horizontal
+from textual.reactive import reactive
+from textual import work
+from textual.timer import Timer
+from rich.text import Text
+from rich.markup import escape
+import os
+
+ASCII_LOGO = """
+ ████████╗███████╗██████╗ ███╗   ███╗ █████╗  ██████╗ ███████╗███╗   ██╗████████╗
+    ██╔══╝██╔════╝██╔══██╗████╗ ████║██╔══██╗██╔════╝ ██╔════╝████╗  ██║╚══██╔══╝
+    ██║   █████╗  ██████╔╝██╔████╔██║███████║██║  ███╗█████╗  ██╔██╗ ██║   ██║   
+    ██║   ██╔══╝  ██╔══██╗██║╚██╔╝██║██╔══██║██║   ██║██╔══╝  ██║╚██╗██║   ██║   
+    ██║   ███████╗██║  ██║██║ ╚═╝ ██║██║  ██║╚██████╔╝███████╗██║ ╚████║   ██║   
+    ╚═╝   ╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝  
+"""
+
+TAGLINE = "[ Natural Language → PowerShell  •  Groq  •  Windows Native ]"
+
+# Braille spinner frames
+SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+
+CSS = """
+Screen {
+    background: #0a0e1a;
+    layout: vertical;
+}
+
+#header {
+    height: auto;
+    padding: 1 2;
+    background: #0a0e1a;
+    border-bottom: tall #1a2040;
+}
+
+#logo {
+    color: #00d4ff;
+    text-style: bold;
+    content-align: center middle;
+}
+
+#tagline {
+    color: #3a5080;
+    content-align: center middle;
+    margin-top: 0;
+}
+
+#status-bar {
+    height: 1;
+    background: #0f1628;
+    padding: 0 2;
+    layout: horizontal;
+}
+
+#cwd-label {
+    color: #00d4ff;
+    width: auto;
+}
+
+#model-label {
+    color: #2a4060;
+    width: 1fr;
+    content-align: right middle;
+}
+
+#output-log {
+    background: #0a0e1a;
+    border: none;
+    padding: 1 2;
+    scrollbar-color: #1a2040;
+    scrollbar-background: #0a0e1a;
+    height: 1fr;
+}
+
+#status-line {
+    height: 1;
+    padding: 0 4;
+    background: #0a0e1a;
+    color: #00d4ff;
+}
+
+#input-container {
+    height: auto;
+    padding: 0 2 1 2;
+    background: #0a0e1a;
+    border-top: tall #1a2040;
+}
+
+#prompt-label {
+    color: #00d4ff;
+    width: auto;
+    padding: 1 0 0 0;
+    text-style: bold;
+}
+
+#user-input {
+    background: #0f1628;
+    border: tall #1a3050;
+    color: #e0f0ff;
+    padding: 0 1;
+    height: 3;
+    width: 1fr;
+}
+
+#user-input:focus {
+    border: tall #00d4ff;
+}
+
+Footer {
+    background: #060810;
+    color: #2a4060;
+}
+"""
+
+
+class TermAgent(App):
+    CSS = CSS
+    BINDINGS = [
+        ("ctrl+c", "quit", "Quit"),
+        ("ctrl+l", "clear", "Clear"),
+    ]
+
+    cwd = reactive(os.getcwd())
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="header"):
+            yield Static(ASCII_LOGO, id="logo")
+            yield Static(TAGLINE, id="tagline")
+
+        with Horizontal(id="status-bar"):
+            yield Static(id="cwd-label")
+            yield Static("⬡  llama-3.3-70b-versatile  •  Groq Inference", id="model-label")
+
+        yield RichLog(id="output-log", highlight=True, markup=True, wrap=True)
+
+        # Status line — sits between log and input, shows spinner or result in place
+        yield Static("", id="status-line")
+
+        with Horizontal(id="input-container"):
+            yield Static("❯", id="prompt-label")
+            yield Input(placeholder="Ask me anything or describe what to do...", id="user-input")
+
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self._confirmation_handler = None
+        self._spinner_timer: Timer | None = None
+        self._spinner_frame = 0
+        self.update_cwd_label()
+        log = self.query_one("#output-log", RichLog)
+        log.write(Text.from_markup(
+            "[dim]Type a command in plain English or ask a question. Type [bold cyan]bye[/bold cyan] to exit.[/dim]\n"
+        ))
+        self.query_one("#user-input", Input).focus()
+
+    def watch_cwd(self, new_cwd: str) -> None:
+        self.update_cwd_label()
+
+    def update_cwd_label(self) -> None:
+        label = self.query_one("#cwd-label", Static)
+        label.update(f"  {self.cwd}")
+
+    # ── Spinner helpers ──────────────────────────────────────────────────────
+
+    def _start_spinner(self) -> None:
+        """Start animating the status line with a spinner."""
+        self._spinner_frame = 0
+        self._spinner_timer = self.set_interval(0.08, self._tick_spinner)
+
+    def _tick_spinner(self) -> None:
+        """Called every 80ms to advance the spinner frame."""
+        frame = SPINNER_FRAMES[self._spinner_frame % len(SPINNER_FRAMES)]
+        self._spinner_frame += 1
+        status = self.query_one("#status-line", Static)
+        status.update(Text.from_markup(f"[cyan]{frame}[/cyan] [dim cyan]thinking...[/dim cyan]"))
+
+    def _stop_spinner(self) -> None:
+        """Stop the spinner timer."""
+        if self._spinner_timer is not None:
+            self._spinner_timer.stop()
+            self._spinner_timer = None
+
+    def _set_status(self, markup: str) -> None:
+        """Replace status line content (called after spinner stops)."""
+        status = self.query_one("#status-line", Static)
+        status.update(Text.from_markup(markup))
+
+    def _clear_status(self) -> None:
+        status = self.query_one("#status-line", Static)
+        status.update("")
+
+    # ── Input handling ───────────────────────────────────────────────────────
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        # Confirmation flow takes priority
+        if self._confirmation_handler:
+            self._confirmation_handler(event)
+            return
+
+        user_input = event.value.strip()
+        if not user_input:
+            return
+
+        input_widget = self.query_one("#user-input", Input)
+        input_widget.clear()
+
+        if user_input.lower() == "bye":
+            self.exit()
+            return
+
+        log = self.query_one("#output-log", RichLog)
+        log.write(Text.from_markup(f"\n[bold cyan]❯[/bold cyan] [white]{user_input}[/white]"))
+        self._start_spinner()
+        self.process_input(user_input)
+
+    # ── Agent worker ─────────────────────────────────────────────────────────
+
+    @work(thread=True)
+    def process_input(self, user_input: str) -> None:
+        from termagent.agent.graph import app as agent_app
+        import termagent.agent.nodes as nodes
+        import threading
+
+        outer_self = self
+
+        def patched_confirm(state):
+            cmd = state['cmd']
+            result_holder = {}
+            confirmed_event = threading.Event()
+
+            def ask():
+                outer_self._ask_confirmation(cmd, result_holder, confirmed_event)
+
+            outer_self.call_from_thread(ask)
+            confirmed_event.wait()
+            return {"confirmation": result_holder.get("answer", "no")}
+
+        nodes._confirm_fn = patched_confirm
+
+        try:
+            state = {"text": user_input, "cwd": self.cwd}
+            result = agent_app.invoke(state)
+
+            new_cwd = result.get("cwd", self.cwd)
+            output = result.get("result", "Command cancelled.")
+            intent = result.get("intent", "command")
+
+            self.call_from_thread(self._update_output, output, intent, new_cwd)
+        except Exception as e:
+            self.call_from_thread(self._stop_spinner)
+            self.call_from_thread(
+                self._set_status,
+                f"[bold red]✗ Error: {escape(str(e))}[/bold red]"
+            )
+        finally:
+            nodes._confirm_fn = None
+
+    # ── HITL confirmation ─────────────────────────────────────────────────────
+
+    def _ask_confirmation(self, cmd: str, result_holder: dict, event) -> None:
+        # Stop spinner while waiting for user
+        self._stop_spinner()
+        self._set_status("[bold yellow]⚠ Risky command — type yes or no[/bold yellow]")
+
+        log = self.query_one("#output-log", RichLog)
+        log.write(Text.from_markup(
+            f"\n[bold yellow]  Risky command detected:[/bold yellow]\n"
+            f"  [bold white]{escape(cmd)}[/bold white]\n"
+            f"[dim yellow]  Type [bold]yes[/bold] to confirm or [bold]no[/bold] to cancel[/dim yellow]"
+        ))
+
+        input_widget = self.query_one("#user-input", Input)
+        input_widget.placeholder = "yes / no"
+
+        def on_confirm(submit_event: Input.Submitted):
+            answer = submit_event.value.strip().lower()
+            if answer in ["yes", "no"]:
+                input_widget.clear()
+                input_widget.placeholder = "Ask me anything or describe what to do..."
+                result_holder["answer"] = answer
+                log.write(Text.from_markup(
+                    f"[dim]  → {'[green]Confirmed[/green]' if answer == 'yes' else '[red]Cancelled[/red]'}[/dim]"
+                ))
+                # Restart spinner while agent continues
+                self._start_spinner()
+                self._confirmation_handler = None
+                event.set()
+            else:
+                log.write(Text.from_markup("[dim yellow]  Please type yes or no[/dim yellow]"))
+
+        self._confirmation_handler = on_confirm
+
+    # ── Output rendering ──────────────────────────────────────────────────────
+
+    def _update_output(self, output: str, intent: str, new_cwd: str) -> None:
+        self._stop_spinner()
+        log = self.query_one("#output-log", RichLog)
+
+        if intent == "chat":
+            self._set_status("[dim cyan]◌ responded[/dim cyan]")
+            log.write(Text.from_markup(f"  [white]{escape(output)}[/white]"))
+        else:
+            if output.startswith("Error:"):
+                self._set_status("[bold red]✗ Error[/bold red]")
+                log.write(Text.from_markup(f"[bold red]  ✗[/bold red] [red]{escape(output)}[/red]"))
+            elif output == "Command cancelled by user.":
+                self._set_status("[dim]✗ Cancelled[/dim]")
+            else:
+                self._set_status("[bold green]✓ Done[/bold green]")
+                lines = output.strip().splitlines()
+                if lines and output != "Command executed successfully.":
+                    for line in lines:
+                        log.write(Text.from_markup(f"  [dim]{escape(line)}[/dim]"))
+
+        self.cwd = new_cwd
+
+    def action_clear(self) -> None:
+        self.query_one("#output-log", RichLog).clear()
+        self._clear_status()
+
+def main():
+    from dotenv import load_dotenv
+    load_dotenv()
+
+    groq_key = os.getenv("GROQ_API_KEY")
+
+    if not groq_key:
+        print("Groq API key not found.")
+        groq_key = input("Enter your Groq API key: ").strip()
+
+        save = input("Save to .env for future use? (yes/no): ")
+        if save.lower() == "yes":
+            with open(".env", "a") as f:
+                f.write(f"\nGROQ_API_KEY={groq_key}")
+            print("Saved!")
+
+        os.environ["GROQ_API_KEY"] = groq_key
+
+    app = TermAgent()
+    app.run()
+
+if __name__ == "__main__":
+    main()

termagent_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: termagent-cli
+Version: 0.1.0
+Summary: Natural language terminal agent for Windows PowerShell
+Requires-Python: >=3.10
+Requires-Dist: langchain-ollama
+Requires-Dist: langchain-groq
+Requires-Dist: langchain-core
+Requires-Dist: langchain
+Requires-Dist: langgraph
+Requires-Dist: pydantic
+Requires-Dist: python-dotenv
+Requires-Dist: ollama
+Requires-Dist: textual
+Requires-Dist: rich

termagent_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+termagent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+termagent/ui.py,sha256=WliXp8Z7gL3_YnX_hh8v_AtVUDeo8pG1PdiMf6wDu9Y,12112
+termagent/agent/graph.py,sha256=keAS4VR2TBfgQ6WtjNqjDe-9qKv6NxL0KlbzEPjISpQ,1644
+termagent/agent/nodes.py,sha256=T0YgAkb5bniGiWOeq83WvIGfvpSNFCIyjHG7Y9KN5V0,7033
+termagent/agent/state.py,sha256=8n5RCijPGVc027fiGUptUsslnA9GEjPdo2BO9nt5Fs4,309
+termagent_cli-0.1.0.dist-info/METADATA,sha256=CFqxMKKaZ-DvbYFJyxsp9AqNRe7fpQk0EXiirpaQZbY,420
+termagent_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+termagent_cli-0.1.0.dist-info/entry_points.txt,sha256=w7Tsfqg1L1OfIrV71eRaprHM9sr-_xS_dv9wXfnqC5U,48
+termagent_cli-0.1.0.dist-info/top_level.txt,sha256=MRTNX-XhHkoanaTh2foNsz_CcwwnW00wKDR6dcoxZCE,10
+termagent_cli-0.1.0.dist-info/RECORD,,

termagent_cli-0.1.0.dist-info/WHEEL

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

termagent_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+termagent = termagent.ui:main

termagent_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+termagent