cfdpilot 0.1.1__py3-none-any.whl

cfdpilot/agent.py

@@ -0,0 +1,299 @@
+import json
+from cfdpilot.client import CFDPilotClient
+from cfdpilot.tools.filesystem import read_file, list_dir
+from cfdpilot.tools.log_parser import parse_log
+from cfdpilot.tools.patcher import patch_dict, generate_diff
+from cfdpilot.tools.runner import run_command, run_solver
+
+MAX_ATTEMPTS = 3
+
+TOOL_SCHEMAS = [
+    {
+        "name": "read_file",
+        "description": "Read a file from the OpenFOAM case directory",
+        "input_schema": {
+            "type": "object",
+            "properties": {"path": {"type": "string"}},
+            "required": ["path"]
+        }
+    },
+    {
+        "name": "list_dir",
+        "description": "List files in a directory",
+        "input_schema": {
+            "type": "object",
+            "properties": {"path": {"type": "string", "default": "."}},
+            "required": []
+        }
+    },
+    {
+        "name": "parse_log",
+        "description": "Parse an OpenFOAM log file. Returns structured JSON with residuals, Co number, divergence info.",
+        "input_schema": {
+            "type": "object",
+            "properties": {"log_path": {"type": "string", "description": "Path to log file, or omit to auto-detect"}},
+            "required": []
+        }
+    },
+    {
+        "name": "run_command",
+        "description": "Run an OpenFOAM command (blockMesh, checkMesh, foamDictionary, etc.). NOT for the main solver.",
+        "input_schema": {
+            "type": "object",
+            "properties": {"cmd": {"type": "string"}},
+            "required": ["cmd"]
+        }
+    },
+    {
+        "name": "run_solver",
+        "description": "Launch the OpenFOAM solver and stream residuals. Auto-stops on convergence or divergence.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "solver": {"type": "string"},
+                "max_iterations": {"type": "integer"}
+            },
+            "required": ["solver"]
+        }
+    },
+    {
+        "name": "show_diff",
+        "description": "Show a colored diff of proposed changes to a file. ALWAYS call this before patch_dict.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "file_path": {"type": "string"},
+                "proposed_content": {"type": "string"}
+            },
+            "required": ["file_path", "proposed_content"]
+        }
+    },
+    {
+        "name": "patch_dict",
+        "description": "Apply confirmed changes to an OpenFOAM dict file. Creates .bak backup automatically.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "file_path": {"type": "string"},
+                "changes": {"type": "object", "description": "key-value pairs to update"}
+            },
+            "required": ["file_path", "changes"]
+        }
+    },
+    {
+        "name": "search_knowledge",
+        "description": "Search the CFDpilot knowledge base: 1,000+ CFD-Online threads + OpenFOAM user guide. Use when you need community experience or documentation on a specific OF topic.",
+        "input_schema": {
+            "type": "object",
+            "properties": {"query": {"type": "string", "description": "What to search for, e.g. 'GAMG divergence kOmegaSST' or 'nOuterCorrectors pimpleFoam'"}},
+            "required": ["query"]
+        }
+    },
+]
+
+
+def _dispatch_tool(name: str, inputs: dict, cwd: str, display, client=None) -> str:
+    """Execute a tool call and return result as JSON string."""
+    try:
+        if name == "read_file":
+            result = read_file(inputs["path"], cwd=cwd)
+            return json.dumps(result)
+
+        elif name == "list_dir":
+            result = list_dir(inputs.get("path", "."), cwd=cwd)
+            return json.dumps(result)
+
+        elif name == "parse_log":
+            result = parse_log(inputs.get("log_path"), cwd=cwd)
+            return json.dumps(result)
+
+        elif name == "run_command":
+            display.print_action(f"Running: {inputs['cmd']}")
+            result = run_command(inputs["cmd"], cwd=cwd)
+            return json.dumps(result)
+
+        elif name == "run_solver":
+            display.print_action(f"Launching {inputs['solver']}...")
+            result = run_solver(
+                inputs["solver"],
+                cwd=cwd,
+                max_iterations=inputs.get("max_iterations"),
+                on_line=display.print_solver_line
+            )
+            return json.dumps(result)
+
+        elif name == "show_diff":
+            diff = generate_diff(inputs["file_path"], inputs["proposed_content"])
+            display.print_diff(diff)
+            confirmed = display.confirm("Apply changes?")
+            return json.dumps({"diff": diff, "confirmed": confirmed})
+
+        elif name == "patch_dict":
+            display.print_action(f"Patching {inputs['file_path']}")
+            try:
+                result = patch_dict(inputs["file_path"], inputs["changes"])
+                display.print_action(f"Backup saved → {result['backup']}")
+                return json.dumps(result)
+            except FileNotFoundError as e:
+                return json.dumps({"success": False, "error": str(e)})
+
+        elif name == "search_knowledge":
+            query = inputs["query"]
+            display.print_action(f"Searching knowledge base: {query}")
+            results = client.search(query) if client else []
+            return json.dumps({"results": results, "count": len(results)})
+
+        return json.dumps({"error": f"Unknown tool: {name}"})
+
+    except KeyError as e:
+        return json.dumps({"error": f"Missing required input: {e}"})
+    except Exception as e:
+        return json.dumps({"error": f"Tool error: {type(e).__name__}: {e}"})
+
+
+SESSION_TOKEN_CAP = 100_000
+
+
+def _build_case_context(cwd: str, case_info: dict) -> str:
+    """Build a context block injected as the first user message."""
+    import os
+    lines = [f"Working directory: {cwd}"]
+    if case_info.get("flat_structure"):
+        files = ", ".join(case_info.get("fields", [])) or "unknown"
+        lines.append("Structure: FLAT (files dumped in one directory — no 0/constant/system hierarchy)")
+        lines.append(f"Files present: {files}")
+        lines.append("Note: read files directly by name (e.g. read_file('U'), read_file('fvSchemes'))")
+    else:
+        lines.append("Structure: standard OpenFOAM (0/ constant/ system/)")
+    if case_info.get("solver") and case_info["solver"] != "unknown":
+        lines.append(f"Solver: {case_info['solver']}")
+    if case_info.get("turbulence_model") and case_info["turbulence_model"] != "unknown":
+        lines.append(f"Turbulence: {case_info['turbulence_model']}")
+    if case_info.get("log_file"):
+        lines.append(f"Log file: {case_info['log_file']}")
+    else:
+        lines.append("Log file: none found")
+    return "\n".join(lines)
+
+
+def run_agent_loop(token: str, cwd: str, display, case_info: dict = None) -> None:
+    """Main conversation loop. Runs until user exits."""
+    client = CFDPilotClient(token)
+    messages = []
+    session_tokens = 0
+
+    # Inject case context as a silent system message (not shown to user)
+    if case_info:
+        ctx = _build_case_context(cwd, case_info)
+        messages.append({
+            "role": "user",
+            "content": f"[CASE CONTEXT — read this before answering anything]\n{ctx}"
+        })
+        messages.append({
+            "role": "assistant",
+            "content": [{"type": "text", "text": "Case context noted. Ready."}]
+        })
+
+    display.print_welcome()
+
+    while True:
+        try:
+            user_input = display.get_input()
+        except (KeyboardInterrupt, EOFError):
+            display.print_goodbye()
+            break
+
+        if user_input.lower() in ("exit", "quit", "q"):
+            display.print_goodbye()
+            break
+
+        if not user_input.strip():
+            continue
+
+        messages.append({"role": "user", "content": user_input})
+        attempt_count = 0  # Reset per user turn
+
+        # Agentic inner loop: keep going until no more tool calls
+        while True:
+            if session_tokens >= SESSION_TOKEN_CAP:
+                display.print_error(
+                    f"Session limit reached ({session_tokens:,} tokens). "
+                    "Start a new session: cfdpilot"
+                )
+                return
+
+            try:
+                response = client.chat(messages, TOOL_SCHEMAS)
+            except RuntimeError as e:
+                display.print_error(str(e))
+                break
+
+            usage = response.get("usage", {})
+            session_tokens += (
+                usage.get("input_tokens", 0)
+                + usage.get("output_tokens", 0)
+                + usage.get("cache_read_input_tokens", 0)
+                + usage.get("cache_creation_input_tokens", 0)
+            )
+
+            content = response.get("content", [])
+            stop_reason = response.get("stop_reason", "end_turn")
+
+            # Display text blocks
+            for block in content:
+                if block.get("type") == "text":
+                    display.print_text(block["text"])
+
+            # Add assistant turn to history
+            messages.append({"role": "assistant", "content": content})
+
+            # No tool calls → turn done
+            if stop_reason != "tool_use":
+                break
+
+            # Extract and execute tool calls
+            tool_results = []
+            stuck = False
+            for block in content:
+                if block.get("type") != "tool_use":
+                    continue
+
+                tool_name = block["name"]
+                tool_inputs = block.get("input", {})
+                tool_id = block["id"]
+
+                display.print_action(f"● {tool_name}...")
+
+                # STUCK tracking
+                if tool_name == "patch_dict":
+                    attempt_count += 1
+                    if attempt_count > MAX_ATTEMPTS:
+                        display.print_stuck(attempt_count)
+                        tool_results.append({
+                            "type": "tool_result",
+                            "tool_use_id": tool_id,
+                            "content": json.dumps({"error": "MAX_ATTEMPTS_REACHED"})
+                        })
+                        stuck = True
+                        continue
+
+                result = _dispatch_tool(tool_name, tool_inputs, cwd, display, client)
+                tool_results.append({
+                    "type": "tool_result",
+                    "tool_use_id": tool_id,
+                    "content": result  # full result sent to model this turn
+                })
+
+            # Truncate tool results before storing in history to prevent context bloat.
+            # The model already processed the full content this turn.
+            MAX_TOOL_RESULT_CHARS = 1500
+            history_tool_results = []
+            for tr in tool_results:
+                content = tr["content"]
+                if len(content) > MAX_TOOL_RESULT_CHARS:
+                    content = content[:MAX_TOOL_RESULT_CHARS] + "…[truncated]"
+                history_tool_results.append({**tr, "content": content})
+            messages.append({"role": "user", "content": history_tool_results})
+
+            if stuck:
+                break

cfdpilot/auth.py

@@ -0,0 +1,57 @@
+import json
+import time
+import httpx
+from pathlib import Path
+
+TOKEN_PATH = Path.home() / ".cfdpilot" / "config"
+API_BASE = "https://cfdpilot.com"
+POLL_INTERVAL = 2
+POLL_TIMEOUT = 600
+
+
+def save_token(token: str) -> None:
+    TOKEN_PATH.parent.mkdir(parents=True, exist_ok=True)
+    TOKEN_PATH.write_text(json.dumps({"token": token}))
+    TOKEN_PATH.chmod(0o600)
+
+
+def load_token() -> str | None:
+    if not TOKEN_PATH.exists():
+        return None
+    try:
+        return json.loads(TOKEN_PATH.read_text()).get("token")
+    except Exception:
+        return None
+
+
+def device_login() -> str:
+    """Run device flow. Blocks until authorized or timeout."""
+    try:
+        with httpx.Client(timeout=10) as client:
+            resp = client.post(f"{API_BASE}/device/code")
+            resp.raise_for_status()
+            data = resp.json()
+    except Exception as e:
+        raise ConnectionError(f"Could not reach cfdpilot.com: {e}") from e
+
+    code = data["code"]
+    url = data["url"]
+    print(f"\n  Open this URL in your browser:\n  {url}\n")
+    print("  Waiting for authentication", end="", flush=True)
+
+    deadline = time.time() + POLL_TIMEOUT
+    with httpx.Client() as client:
+        while time.time() < deadline:
+            time.sleep(POLL_INTERVAL)
+            print(".", end="", flush=True)
+            try:
+                resp = client.get(f"{API_BASE}/device/poll/{code}")
+                if resp.status_code == 200:
+                    data = resp.json()
+                    if data["status"] == "authorized":
+                        print(" ✓")
+                        return data["token"]
+            except Exception:
+                continue
+
+    raise TimeoutError("Authentication timed out. Run `cfdpilot login` again.")

cfdpilot/case_detector.py

@@ -0,0 +1,90 @@
+import re
+from pathlib import Path
+from cfdpilot.tools.log_parser import _find_log
+
+SOLVER_PATTERN = re.compile(r"application\s+(\w+);")
+TURBULENCE_PATTERN = re.compile(r"RASModel\s+(\w+);|LESModel\s+(\w+);|model\s+(\w+);")
+DELTA_T_PATTERN = re.compile(r"deltaT\s+([\d.eE+-]+);")
+END_TIME_PATTERN = re.compile(r"endTime\s+([\d.eE+-]+);")
+
+
+_OF_FLAT_MARKERS = {"controlDict", "fvSchemes", "fvSolution", "turbulenceProperties", "momentumTransport"}
+_OF_BC_FILES = {"U", "p", "T", "k", "omega", "epsilon", "nut", "alphat", "nuTilda", "p_rgh"}
+
+
+def detect_case(cwd: str) -> dict:
+    base = Path(cwd)
+    required = [base / "system" / "controlDict", base / "constant", base / "0"]
+
+    # Standard OF structure
+    if all(p.exists() for p in required):
+        pass  # proceed below
+    else:
+        # Flat structure: files dumped in one directory (forum thread, shared files)
+        flat_files = {f.name for f in base.iterdir() if f.is_file()}
+        has_markers = bool(flat_files & _OF_FLAT_MARKERS)
+        has_bc = bool(flat_files & _OF_BC_FILES)
+        if not (has_markers or has_bc):
+            return {"is_of_case": False}
+        # Flat case detected — build result directly
+        result = {"is_of_case": True, "cwd": cwd, "flat_structure": True}
+        ctrl_path = base / "controlDict"
+        if ctrl_path.exists():
+            ctrl = ctrl_path.read_text(errors="replace")
+            m = SOLVER_PATTERN.search(ctrl)
+            result["solver"] = m.group(1) if m else "unknown"
+            m = DELTA_T_PATTERN.search(ctrl)
+            result["deltaT"] = float(m.group(1)) if m else None
+            m = END_TIME_PATTERN.search(ctrl)
+            result["endTime"] = float(m.group(1)) if m else None
+        else:
+            result["solver"] = "unknown"
+        for turb_name in ("turbulenceProperties", "momentumTransport"):
+            turb_path = base / turb_name
+            if turb_path.exists():
+                turb = turb_path.read_text(errors="replace")
+                m = TURBULENCE_PATTERN.search(turb)
+                result["turbulence_model"] = next((g for g in m.groups() if g), "unknown") if m else "unknown"
+                result["simulation_type"] = "LES" if "LESModel" in turb else "RAS"
+                break
+        else:
+            result["turbulence_model"] = "unknown"
+        result["mesh_type"] = "unknown"
+        result["log_file"] = None
+        result["fields"] = sorted(flat_files & _OF_BC_FILES)
+        return result
+
+    result = {"is_of_case": True, "cwd": cwd}
+
+    ctrl = (base / "system" / "controlDict").read_text(errors="replace")
+    m = SOLVER_PATTERN.search(ctrl)
+    result["solver"] = m.group(1) if m else "unknown"
+
+    m = DELTA_T_PATTERN.search(ctrl)
+    result["deltaT"] = float(m.group(1)) if m else None
+
+    m = END_TIME_PATTERN.search(ctrl)
+    result["endTime"] = float(m.group(1)) if m else None
+
+    turb_file = base / "constant" / "turbulenceProperties"
+    if not turb_file.exists():
+        turb_file = base / "constant" / "momentumTransport"
+    result["turbulence_model"] = "unknown"
+    if turb_file.exists():
+        turb = turb_file.read_text(errors="replace")
+        m = TURBULENCE_PATTERN.search(turb)
+        if m:
+            result["turbulence_model"] = next(g for g in m.groups() if g)
+        result["simulation_type"] = "LES" if "LESModel" in turb else "RAS"
+
+    result["mesh_type"] = "blockMesh"
+    if (base / "system" / "snappyHexMeshDict").exists():
+        result["mesh_type"] = "snappyHexMesh"
+
+    log = _find_log(cwd)
+    result["log_file"] = str(log) if log else None
+
+    fields = list((base / "0").iterdir())
+    result["fields"] = [f.name for f in fields if f.is_file()]
+
+    return result

cfdpilot/client.py

@@ -0,0 +1,51 @@
+import json
+import uuid
+import httpx
+
+API_BASE = "https://cfdpilot.com"
+
+
+class CFDPilotClient:
+    def __init__(self, token: str):
+        self.token = token
+        self.session_id = str(uuid.uuid4())
+        self.headers = {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json",
+        }
+
+    def search(self, query: str) -> list[dict]:
+        """GET /agent/search — query the RAG knowledge base."""
+        try:
+            with httpx.Client(timeout=30) as client:
+                response = client.get(
+                    f"{API_BASE}/agent/search",
+                    headers=self.headers,
+                    params={"query": query},
+                )
+                response.raise_for_status()
+                return response.json().get("results", [])
+        except Exception:
+            return []
+
+    def chat(self, messages: list[dict], tools: list[dict]) -> dict:
+        """POST to /agent/chat, return the response dict."""
+        try:
+            with httpx.Client(timeout=120) as client:
+                response = client.post(
+                    f"{API_BASE}/agent/chat",
+                    headers=self.headers,
+                    json={"messages": messages, "tools": tools, "session_id": self.session_id},
+                )
+                if response.status_code == 429:
+                    raise RuntimeError("Session token limit reached. Start a new cfdpilot session.")
+                if response.status_code == 401:
+                    raise RuntimeError("Invalid token. Run: cfdpilot login")
+                response.raise_for_status()
+                return response.json()
+        except httpx.TimeoutException:
+            raise RuntimeError("Request timed out. The backend may be overloaded.")
+        except httpx.HTTPStatusError as e:
+            raise RuntimeError(f"Backend error: HTTP {e.response.status_code}")
+        except httpx.NetworkError as e:
+            raise RuntimeError(f"Network error: {e}")

cfdpilot/display.py

@@ -0,0 +1,71 @@
+from rich.console import Console
+from rich.syntax import Syntax
+from rich.panel import Panel
+
+console = Console()
+
+
+class Display:
+    def __init__(self, case_info: dict):
+        self.case_info = case_info
+
+    def print_welcome(self):
+        info = self.case_info
+        console.print()
+        console.print("[bold]CFDPilot Agent v0.1[/bold]")
+        console.rule()
+        if info.get("is_of_case"):
+            solver = info.get("solver", "unknown")
+            turb = info.get("turbulence_model", "unknown")
+            mesh = info.get("mesh_type", "unknown")
+            log = info.get("log_file")
+            console.print(
+                f"Case: [cyan]{solver}[/cyan] · [cyan]{turb}[/cyan] · [cyan]{mesh}[/cyan]"
+            )
+            if log:
+                console.print(f"Log:  [dim]{log}[/dim]")
+        else:
+            console.print("[yellow]No OpenFOAM case detected in this directory[/yellow]")
+        console.rule()
+        console.print()
+
+    def get_input(self) -> str:
+        return console.input("[bold cyan]>[/bold cyan] ").strip()
+
+    def print_text(self, text: str):
+        console.print(f"  {text}")
+
+    def print_action(self, msg: str):
+        console.print(f"[dim]● {msg}[/dim]")
+
+    def print_solver_line(self, line: str):
+        if "Solving for" in line or "Courant" in line or "Time = " in line:
+            console.print(f"  [dim]{line}[/dim]")
+
+    def print_diff(self, diff: str):
+        console.print()
+        syntax = Syntax(diff, "diff", theme="monokai", line_numbers=False)
+        console.print(Panel(syntax, title="[bold]Proposed changes[/bold]", border_style="yellow"))
+
+    def confirm(self, prompt: str) -> bool:
+        try:
+            answer = console.input(f"\n  {prompt} [Y/n] ").strip().lower()
+            return answer in ("", "y", "yes")
+        except (KeyboardInterrupt, EOFError):
+            console.print("\n[dim](cancelled)[/dim]")
+            return False
+
+    def print_error(self, msg: str):
+        console.print(f"\n[red]Error: {msg}[/red]")
+
+    def print_stuck(self, attempts: int):
+        console.print(Panel(
+            f"[yellow]I have made {attempts} fix attempts without success.[/yellow]\n"
+            "The remaining issue likely requires manual inspection.\n"
+            "Run [cyan]checkMesh[/cyan] if you suspect a mesh quality problem.",
+            title="[bold yellow]Stuck[/bold yellow]",
+            border_style="yellow"
+        ))
+
+    def print_goodbye(self):
+        console.print("\n[dim]Session ended.[/dim]")

cfdpilot/main.py

@@ -0,0 +1,47 @@
+import os
+import typer
+from rich.console import Console
+from cfdpilot.auth import device_login, save_token, load_token
+from cfdpilot.case_detector import detect_case
+from cfdpilot.display import Display
+from cfdpilot.agent import run_agent_loop
+
+app = typer.Typer(help="CFDPilot Agent — AI engineer for your OpenFOAM cases")
+console = Console()
+
+
+@app.command("login")
+def login():
+    """Authenticate with your CFDpilot account."""
+    console.print("\n[bold]CFDPilot Agent[/bold] — Login\n")
+    try:
+        token = device_login()
+        save_token(token)
+        console.print("[green]Logged in successfully.[/green]")
+    except (TimeoutError, ConnectionError) as e:
+        console.print(f"[red]{e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command("setup")
+def setup(token: str = typer.Argument(..., help="Your CFDpilot access token")):
+    """Activate your CFDpilot access token."""
+    save_token(token)
+    console.print("[green]Token saved. You're ready — run: cfdpilot[/green]")
+
+
+@app.callback(invoke_without_command=True)
+def main(ctx: typer.Context):
+    """Run the CFDPilot Agent in the current OpenFOAM case directory."""
+    if ctx.invoked_subcommand is not None:
+        return
+
+    token = load_token()
+    if not token:
+        console.print("[red]Not logged in. Run:[/red] cfdpilot login")
+        raise typer.Exit(1)
+
+    cwd = os.getcwd()
+    case_info = detect_case(cwd)
+    display = Display(case_info)
+    run_agent_loop(token=token, cwd=cwd, display=display, case_info=case_info)

cfdpilot/tools/filesystem.py

@@ -0,0 +1,45 @@
+import os
+from pathlib import Path
+
+
+def _safe_path(path: str, cwd: str) -> Path | None:
+    base = Path(cwd).resolve()
+    target = (base / path).resolve()
+    if target != base and not str(target).startswith(str(base) + os.sep):
+        return None
+    return target
+
+
+MAX_FILE_CHARS = 50_000  # ~12k tokens — prevents log files from blowing up the context
+
+
+def read_file(path: str, cwd: str) -> dict:
+    safe = _safe_path(path, cwd)
+    if safe is None:
+        return {"content": None, "error": "Access denied: path outside case directory"}
+    if not safe.exists():
+        return {"content": None, "error": f"File not found: {path}"}
+    try:
+        content = safe.read_text(errors="replace")
+        truncated = len(content) > MAX_FILE_CHARS
+        if truncated:
+            content = content[:MAX_FILE_CHARS] + f"\n\n[TRUNCATED — file is {len(content)} chars, showing first {MAX_FILE_CHARS}. Use parse_log for log files.]"
+        return {"content": content, "error": None, "size": len(content), "truncated": truncated}
+    except Exception as e:
+        return {"content": None, "error": str(e)}
+
+
+def list_dir(path: str, cwd: str) -> dict:
+    safe = _safe_path(path, cwd)
+    if safe is None:
+        return {"entries": [], "error": "Access denied"}
+    if not safe.exists():
+        return {"entries": [], "error": f"Directory not found: {path}"}
+    entries = []
+    for item in sorted(safe.iterdir()):
+        entries.append({
+            "name": item.name,
+            "type": "dir" if item.is_dir() else "file",
+            "size": item.stat().st_size if item.is_file() else None
+        })
+    return {"entries": [e["name"] for e in entries], "details": entries, "error": None}

cfdpilot/tools/log_parser.py

@@ -0,0 +1,94 @@
+import re
+from pathlib import Path
+
+SOLVER_PATTERN = re.compile(r"^Exec\s+:\s+(\w+)", re.MULTILINE)
+VERSION_PATTERN = re.compile(r"Version:\s+([\w.]+)")
+BUILD_PATTERN = re.compile(r"^Build\s+:\s+([\w.]+)", re.MULTILINE)
+CO_PATTERN = re.compile(r"Courant Number mean:\s+[\d.]+\s+max:\s+([\d.]+)")
+RESIDUAL_PATTERN = re.compile(
+    r"Solving for (\w+),\s+Initial residual = ([\d.eE+-]+),\s+Final residual = ([\d.eE+-]+)"
+)
+CONVERGED_PATTERN = re.compile(r"(SIMPLE solution converged|End)", re.IGNORECASE)
+FATAL_PATTERN = re.compile(r"FOAM FATAL|Floating point exception|divergence detected", re.IGNORECASE)
+
+
+_UTILITY_LOGS = {
+    "blockMesh", "checkMesh", "snappyHexMesh", "decomposePar", "reconstructPar",
+    "reconstructParMesh", "surfaceFeatures", "surfaceFeatureExtract", "renumberMesh",
+    "setFields", "extrudeMesh", "topoSet", "createPatch", "transformPoints",
+    "mergeMeshes", "mirrorMesh", "splitMeshRegions", "mapFields", "changeDictionary",
+    "createBaffles", "refineMesh", "moveDynamicMesh", "postProcess", "foamToVTK",
+}
+
+
+def _find_log(cwd: str) -> Path | None:
+    """Return the solver log, not a meshing/utility log.
+
+    Auto-detect previously grabbed the first log.* alphabetically (e.g. log.blockMesh),
+    a meshing step rather than the solver run. Exclude utility logs and prefer the most
+    recently modified remaining log (the solver runs after meshing/setup).
+    """
+    cwd_path = Path(cwd)
+    logs = [f for f in cwd_path.glob("log.*") if f.is_file()]
+    if not logs:
+        return None
+    solver_logs = [f for f in logs if f.name[len("log."):] not in _UTILITY_LOGS]
+    pool = solver_logs or logs
+    return max(pool, key=lambda f: f.stat().st_mtime)
+
+
+def parse_log(log_path: str | None, cwd: str = ".") -> dict:
+    if log_path is None:
+        found = _find_log(cwd)
+        if not found:
+            return {"error": "No log file found. Run your solver first."}
+        log_path = str(found)
+
+    path = Path(log_path)
+    if not path.exists():
+        return {"error": f"Log file not found: {log_path}"}
+
+    text = path.read_text(errors="replace")
+    lines = text.splitlines()
+
+    solver_match = SOLVER_PATTERN.search(text)
+    solver = solver_match.group(1) if solver_match else "unknown"
+
+    ver_match = VERSION_PATTERN.search(text) or BUILD_PATTERN.search(text)
+    of_version = ver_match.group(1) if ver_match else "unknown"
+
+    residuals: dict[str, list[float]] = {}
+    for match in RESIDUAL_PATTERN.finditer(text):
+        field, init_res = match.group(1), float(match.group(2))
+        residuals.setdefault(field, []).append(init_res)
+
+    co_numbers = [float(m.group(1)) for m in CO_PATTERN.finditer(text)]
+    co_max = max(co_numbers) if co_numbers else None
+
+    fatal_match = FATAL_PATTERN.search(text)
+    diverged = fatal_match is not None
+    divergence_at = None
+    if diverged:
+        for i, line in enumerate(lines):
+            if FATAL_PATTERN.search(line):
+                divergence_at = i + 1
+                break
+
+    converged = bool(CONVERGED_PATTERN.search(text)) and not diverged
+
+    warnings = [l.strip() for l in lines if "WARNING" in l.upper() or "WARN:" in l]
+
+    return {
+        "solver": solver,
+        "of_version": of_version,
+        "log_path": str(log_path),
+        "iterations": len(residuals.get(next(iter(residuals), "p"), [])),
+        "residuals": {k: v[-5:] for k, v in residuals.items()},
+        "Co_max": co_max,
+        "diverged": diverged,
+        "divergence_at": divergence_at,
+        "converged": converged,
+        "warnings": warnings[:10],
+        "errors": [l.strip() for l in lines if "FATAL" in l or "Floating point" in l],
+        "error": None
+    }

cfdpilot/tools/patcher.py

@@ -0,0 +1,42 @@
+import re
+import shutil
+import difflib
+from pathlib import Path
+
+
+def generate_diff(file_path: str, proposed_content: str) -> str:
+    path = Path(file_path)
+    if not path.exists():
+        return f"(new file)\n{proposed_content}"
+    current = path.read_text().splitlines(keepends=True)
+    proposed = proposed_content.splitlines(keepends=True)
+    diff = difflib.unified_diff(
+        current, proposed,
+        fromfile=f"{path.name} (current)",
+        tofile=f"{path.name} (proposed)",
+        lineterm=""
+    )
+    return "\n".join(diff)
+
+
+def patch_dict(file_path: str, changes: dict) -> dict:
+    path = Path(file_path)
+    if not path.exists():
+        raise FileNotFoundError(f"File not found: {file_path}")
+
+    content = path.read_text()
+    backup = Path(str(path) + ".bak")
+    shutil.copy(path, backup)
+
+    for key, new_value in changes.items():
+        simple_key = key.split(".")[-1]
+        pattern = rf"(\b{re.escape(simple_key)}\s+)[^\n;]+;"
+        replacement = rf"\g<1>{new_value};"
+        new_content = re.sub(pattern, replacement, content, count=1)
+        if new_content == content:
+            pattern = rf"({re.escape(simple_key)}\s+)[^\n;]+;"
+            new_content = re.sub(pattern, replacement, content, count=1)
+        content = new_content
+
+    path.write_text(content)
+    return {"success": True, "backup": str(backup)}

cfdpilot/tools/runner.py

@@ -0,0 +1,159 @@
+import os
+import re
+import subprocess
+import shlex
+from pathlib import Path
+from typing import Callable
+
+DIVERGENCE_SIGNALS = [
+    "FOAM FATAL",
+    "Floating point exception",
+    "divergence detected",
+    "solution singularity",
+]
+CONVERGENCE_SIGNALS = [
+    "SIMPLE solution converged",
+    "solution converged",
+]
+
+_HOME = str(Path.home())
+_DOCKER_WORKDIR = "/home/ofuser/workingDir"
+# Configurable — was hardcoded "of_v11", which broke for any other container name.
+_DOCKER_BASHRC = os.environ.get("CFDPILOT_OF_BASHRC", "/opt/openfoam11/etc/bashrc")
+_CONTAINER_CACHE = None
+
+
+def _docker_container() -> str:
+    """Resolve the OpenFOAM Docker container name.
+
+    Order: CFDPILOT_DOCKER_CONTAINER env var → first running OpenFOAM-ish
+    container (via `docker ps`) → 'of_v11' fallback. Result is cached.
+    """
+    global _CONTAINER_CACHE
+    if _CONTAINER_CACHE:
+        return _CONTAINER_CACHE
+    name = os.environ.get("CFDPILOT_DOCKER_CONTAINER")
+    if not name:
+        try:
+            out = subprocess.run(
+                ["docker", "ps", "--format", "{{.Names}}"],
+                capture_output=True, text=True, timeout=10
+            ).stdout
+            name = next((n for n in out.split() if re.search(r"foam|of[_-]?v?\d", n, re.I)), None)
+        except Exception:
+            name = None
+    _CONTAINER_CACHE = name or "of_v11"
+    return _CONTAINER_CACHE
+
+
+def _to_docker_path(mac_path: str) -> str:
+    abs_path = str(Path(mac_path).resolve())
+    if abs_path.startswith(_HOME):
+        return _DOCKER_WORKDIR + abs_path[len(_HOME):]
+    return abs_path
+
+
+def _wrap_docker(cmd: str, cwd: str) -> list:
+    """Return a docker exec command list that runs cmd inside the OF container with OF sourced."""
+    docker_cwd = _to_docker_path(cwd)
+    # Source the configured bashrc if present, else glob common Foundation/ESI locations.
+    source = (
+        f'if [ -f "{_DOCKER_BASHRC}" ]; then source "{_DOCKER_BASHRC}"; '
+        f'else source $(ls /opt/openfoam*/etc/bashrc /usr/lib/openfoam/openfoam*/etc/bashrc 2>/dev/null | head -1); fi'
+    )
+    inner = f"{source} && cd {shlex.quote(docker_cwd)} && {cmd}"
+    return ["docker", "exec", _docker_container(), "bash", "-c", inner]
+
+
+def run_command(cmd: str, cwd: str = ".", timeout: int = 300) -> dict:
+    try:
+        result = subprocess.run(
+            cmd, shell=True, cwd=cwd,
+            capture_output=True, text=True, timeout=timeout
+        )
+        if result.returncode == 127:
+            # Command not found in PATH — retry inside Docker container
+            result = subprocess.run(
+                _wrap_docker(cmd, cwd), cwd=cwd,
+                capture_output=True, text=True, timeout=timeout
+            )
+        return {
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "exit_code": result.returncode,
+            "error": None
+        }
+    except subprocess.TimeoutExpired:
+        return {"stdout": "", "stderr": "", "exit_code": -1, "error": "timeout"}
+    except Exception as e:
+        return {"stdout": "", "stderr": "", "exit_code": -1, "error": str(e)}
+
+
+def run_solver(
+    solver: str,
+    cwd: str = ".",
+    max_iterations: int | None = None,
+    on_line: Callable[[str], None] | None = None,
+) -> dict:
+    try:
+        proc = subprocess.Popen(
+            [solver], cwd=cwd,
+            stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+            text=True, bufsize=1
+        )
+    except FileNotFoundError:
+        # Solver not in PATH — run inside Docker container
+        try:
+            proc = subprocess.Popen(
+                _wrap_docker(solver, cwd), cwd=cwd,
+                stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                text=True, bufsize=1
+            )
+        except Exception as e:
+            return {
+                "diverged": False, "converged": False, "iterations": 0, "log_lines": [],
+                "exit_code": -1,
+                "error": f"Could not start solver '{solver}'. Is your OpenFOAM Docker container running? Start it (e.g. `docker start {_docker_container()}`), or set CFDPILOT_DOCKER_CONTAINER / CFDPILOT_OF_BASHRC. Error: {e}"
+            }
+
+    lines = []
+    diverged = False
+    converged = False
+    iteration = 0
+
+    try:
+        for line in proc.stdout:
+            line = line.rstrip()
+            lines.append(line)
+            if on_line:
+                on_line(line)
+
+            if any(sig in line for sig in DIVERGENCE_SIGNALS):
+                diverged = True
+                proc.terminate()
+                break
+            if any(sig in line for sig in CONVERGENCE_SIGNALS):
+                converged = True
+                proc.terminate()
+                break
+            if "Time = " in line:
+                iteration += 1
+                if max_iterations and iteration >= max_iterations:
+                    proc.terminate()
+                    break
+
+        proc.wait(timeout=5)
+    except Exception:
+        try:
+            proc.kill()
+            proc.wait(timeout=2)
+        except Exception:
+            pass
+
+    return {
+        "diverged": diverged,
+        "converged": converged,
+        "iterations": iteration,
+        "log_lines": lines[-50:],
+        "exit_code": proc.returncode if proc.returncode is not None else -1,
+    }

cfdpilot-0.1.1.dist-info/METADATA

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: cfdpilot
+Version: 0.1.1
+Summary: AI agent for OpenFOAM — diagnose, fix, and relaunch cases from your terminal
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: rich>=13
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: httpx; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# CFDpilot
+
+**An AI agent for OpenFOAM — in your terminal.**
+
+CFDpilot reads your OpenFOAM case directly from disk, diagnoses why it diverges or
+gives wrong physics, proposes the exact fix as a colored diff, and — once you confirm —
+patches the files and reruns the solver. No ZIP upload, no browser. It runs where you
+already work: your laptop, your workstation, or an HPC node over SSH.
+
+```bash
+pip install cfdpilot
+cfdpilot login                 # authenticate once
+cd path/to/your/case && cfdpilot
+```
+
+Then just ask, in plain English:
+
+> *"Why won't my rhoSimpleFoam case converge?"*
+
+The agent maps your case, reads `fvSchemes`, `fvSolution`, your boundary conditions and
+solver log, reasons from the actual numbers (Courant number, residuals, turbulence wall
+treatment, scheme/switch consistency), and reports the bugs ranked by impact — with the
+exact fix for each. Nothing is changed without showing you a diff first, and every patch
+makes a `.bak` backup.
+
+## What it checks
+
+Boundary-condition consistency, turbulence wall treatment (low-Re vs high-Re), Courant
+number and time-step control, relaxation factors, discretisation schemes, solver-mode
+switches (e.g. `transonic`), and solver/turbulence-model compatibility — across
+incompressible, compressible, multiphase (VoF) and heat-transfer solvers.
+
+## Requirements
+
+- Python 3.10+
+- An OpenFOAM case directory (Foundation or ESI). OpenFOAM itself can run natively or in
+  Docker; the agent will use it to run the solver when you ask.
+
+## Access
+
+CFDpilot is in **free early access** for the first engineers. Run `cfdpilot login` to get
+started, or request access at [cfdpilot.com](https://cfdpilot.com).

cfdpilot-0.1.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+cfdpilot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cfdpilot/agent.py,sha256=1i48rTot82I5BOMsZ-MruUSubJ4LDY01yB6ycbmpjgA,11243
+cfdpilot/auth.py,sha256=B2V1ZFKcYls39EXG0z40-l7yVl9liLs7BagHGNtRKOk,1748
+cfdpilot/case_detector.py,sha256=J6ME-FFwmwNvI51iqnYbSsBl7O7ibZrVZwf7DSqGFr4,3695
+cfdpilot/client.py,sha256=mPS7BZWx2dBF6WL5ILTmCa3CXx749FX1lPcfQJPepG8,1994
+cfdpilot/display.py,sha256=r4XbmSq5phQ30_Lq1lz9GvQ4kzPzg6Fe7dT6POs46NE,2522
+cfdpilot/main.py,sha256=uny0TSRk5Wn9Go1F0PTLWHBm7sFSQaeMmPnZZ-5Cj68,1516
+cfdpilot/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cfdpilot/tools/filesystem.py,sha256=5JAELASlu_KLXC3MnAvx8N-UjtcqxGVlW1IYAXK_jgE,1703
+cfdpilot/tools/log_parser.py,sha256=VEESE6AMsl5oF5gQJeDak6o3_ZUpFXnF3hxnq2RVSzc,3669
+cfdpilot/tools/patcher.py,sha256=CM06A-CGjp2sZr4AiAGExJee3vA2smHUa-hzcJaq7Xw,1361
+cfdpilot/tools/runner.py,sha256=hhsMd8NcdgSEKugpKvfh1fBrej8mlktIveIup-G82wc,5291
+cfdpilot-0.1.1.dist-info/METADATA,sha256=pMGLjtVGwhwkZvbOul6JQoKzS61i6q_55vAwpEGJMvU,2141
+cfdpilot-0.1.1.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+cfdpilot-0.1.1.dist-info/entry_points.txt,sha256=kWaVnnh6PvfLHuTfpuFLA4y1XIlCj_dWE-8JhAPtmgA,47
+cfdpilot-0.1.1.dist-info/RECORD,,

cfdpilot-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

cfdpilot-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cfdpilot = cfdpilot.main:app