postman-agent 1.0.0__tar.gz

postman_agent-1.0.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: postman-agent
+Version: 1.0.0
+Requires-Python: >=3.9
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Requires-Dist: langchain
+Requires-Dist: langchain-groq
+Requires-Dist: langgraph
+Requires-Dist: httpx
+Requires-Dist: pydantic
+Requires-Dist: python-dotenv

postman_agent-1.0.0/README.md

@@ -0,0 +1 @@
+"# postman-ai-agent" 

postman_agent-1.0.0/postman_agent/__init__.py

@@ -0,0 +1,3 @@
+__version__ = "1.0.0"
+__author__ = "M. Abubakar"
+__description__ = "AI Agent that auto-generates Postman Collections from backend code"

postman_agent-1.0.0/postman_agent/agent/__init__.py

@@ -0,0 +1,3 @@
+from postman_agent.agent.graph import agent
+
+__all__ = ["agent"]

postman_agent-1.0.0/postman_agent/agent/graph.py

@@ -0,0 +1,329 @@
+import json
+import os
+import uuid
+import re
+from typing import Annotated
+from dotenv import load_dotenv
+from langchain_groq import ChatGroq
+from langgraph.graph import StateGraph, END
+from langgraph.graph.message import add_messages
+from typing_extensions import TypedDict
+from pydantic import SecretStr
+from langchain.tools import tool
+import httpx
+from postman_agent.tools.code_parser import parse_code_tool
+
+load_dotenv()
+
+# ─── State ────────────────────────────────────────────────────────────────────
+class AgentState(TypedDict):
+    messages: Annotated[list, add_messages]
+    code: str
+    routes: list
+    postman_collection: dict
+    postman_import: dict
+
+# ─── Postman Import Tool ──────────────────────────────────────────────────────
+@tool
+def import_to_postman_tool(collection_json: str) -> dict:
+    """Imports a Postman Collection JSON directly into Postman workspace"""
+    api_key = os.getenv("POSTMAN_API_KEY")
+    if not api_key:
+        return {"success": False, "error": "POSTMAN_API_KEY not found in environment"}
+
+    try:
+        collection_data = json.loads(collection_json)
+    except json.JSONDecodeError as e:
+        return {"success": False, "error": f"Invalid JSON: {str(e)}"}
+
+    headers = {
+        "X-Api-Key": api_key,
+        "Content-Type": "application/json"
+    }
+
+    if "info" in collection_data:
+        collection_data["info"].pop("_postman_id", None)
+
+    payload = {"collection": collection_data}
+
+    try:
+        response = httpx.post(
+            "https://api.getpostman.com/collections",
+            headers=headers,
+            json=payload,
+            timeout=30
+        )
+
+        if response.status_code == 200:
+            data = response.json()
+            collection_id = data.get("collection", {}).get("uid", "")
+            collection_name = data.get("collection", {}).get("name", "")
+            return {
+                "success": True,
+                "message": f"Collection '{collection_name}' imported successfully!",
+                "collection_id": collection_id,
+                "postman_url": f"https://go.postman.co/collection/{collection_id}"
+            }
+        else:
+            return {
+                "success": False,
+                "error": f"Postman API error: {response.status_code} - {response.text}"
+            }
+
+    except httpx.TimeoutException:
+        return {"success": False, "error": "Request timeout"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+# ─── LLM Setup ────────────────────────────────────────────────────────────────
+llm = ChatGroq(
+    api_key=SecretStr(os.getenv("GROQ_API_KEY") or ""),
+    model="llama-3.1-8b-instant",
+    temperature=0
+)
+
+# ─── Direct Parser ────────────────────────────────────────────────────────────
+def extract_routes_directly(code: str) -> list:
+    """Directly extract routes from code without LLM"""
+    routes = []
+    seen = set()
+
+    express_pattern = r'(?:router|app)\.(get|post|put|delete|patch)\s*\(\s*["\']([^"\']+)["\']'
+    python_pattern = r'@(?:app|router)\.(get|post|put|delete|patch)\s*\(\s*["\']([^"\']+)["\']'
+    flask_pattern = r'@\w+\.route\s*\(\s*["\']([^"\']+)["\'].*?methods\s*=\s*\[([^\]]+)\]'
+    django_pattern = r'(?:path|re_path)\s*\(\s*["\']([^"\']+)["\']'
+
+    # ─── Python AST ───────────────────────────────────────────────────────
+    try:
+        import ast
+        tree = ast.parse(code)
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                for decorator in node.decorator_list:
+                    if isinstance(decorator, ast.Call):
+                        func = decorator.func
+                        if isinstance(func, ast.Attribute):
+                            method = func.attr.lower()
+                            if method in ["get", "post", "put", "delete", "patch"]:
+                                if decorator.args:
+                                    path_node = decorator.args[0]
+                                    if isinstance(path_node, ast.Constant):
+                                        key = f"{method.upper()}:{path_node.value}"
+                                        if key not in seen:
+                                            seen.add(key)
+                                            routes.append({
+                                                "method": method.upper(),
+                                                "path": path_node.value,
+                                                "name": node.name,
+                                                "description": f"{method.upper()} {path_node.value}"
+                                            })
+    except SyntaxError:
+        pass
+
+    # ─── Express.js ───────────────────────────────────────────────────────
+    if not routes:
+        matches = re.findall(express_pattern, code, re.IGNORECASE | re.MULTILINE)
+        for method, path in matches:
+            if not path.startswith('/'):
+                continue
+            key = f"{method.upper()}:{path}"
+            if key not in seen:
+                seen.add(key)
+                name = path.replace('/', ' ').replace(':', '').replace('-', ' ').strip()
+                name = ' '.join(w.capitalize() for w in name.split()) or "Endpoint"
+                routes.append({
+                    "method": method.upper(),
+                    "path": path,
+                    "name": name,
+                    "description": f"{method.upper()} {path}"
+                })
+
+    # ─── Flask ────────────────────────────────────────────────────────────
+    if not routes:
+        matches = re.findall(flask_pattern, code, re.IGNORECASE | re.DOTALL)
+        for path, methods_str in matches:
+            methods = [m.strip().strip('"\'') for m in methods_str.split(',')]
+            for method in methods:
+                if method.upper() in ["GET", "POST", "PUT", "DELETE", "PATCH"]:
+                    key = f"{method.upper()}:{path}"
+                    if key not in seen:
+                        seen.add(key)
+                        routes.append({
+                            "method": method.upper(),
+                            "path": path,
+                            "name": path.replace("/", "_").strip("_") or "endpoint",
+                            "description": f"{method.upper()} {path}"
+                        })
+
+    # ─── Django ───────────────────────────────────────────────────────────
+    if not routes:
+        matches = re.findall(django_pattern, code, re.IGNORECASE)
+        for path in matches:
+            key = f"GET:/{path}"
+            if key not in seen:
+                seen.add(key)
+                routes.append({
+                    "method": "GET",
+                    "path": f"/{path}",
+                    "name": path.replace("/", "_").strip("_") or "endpoint",
+                    "description": f"GET /{path}"
+                })
+
+    # ─── Python decorator fallback ────────────────────────────────────────
+    if not routes:
+        matches = re.findall(python_pattern, code, re.IGNORECASE)
+        for method, path in matches:
+            key = f"{method.upper()}:{path}"
+            if key not in seen:
+                seen.add(key)
+                routes.append({
+                    "method": method.upper(),
+                    "path": path,
+                    "name": path.replace("/", "_").strip("_") or "endpoint",
+                    "description": f"{method.upper()} {path}"
+                })
+
+    print(f"🔧 Direct parser found: {len(routes)} routes")
+    return routes
+
+# ─── Build Postman Collection ─────────────────────────────────────────────────
+def generate_sample_body(path: str, method: str) -> dict:
+    path_lower = path.lower()
+    if "auth" in path_lower or "login" in path_lower:
+        return {"email": "user@example.com", "password": "password123"}
+    elif "register" in path_lower:
+        return {"name": "John Doe", "email": "user@example.com", "password": "password123"}
+    elif "product" in path_lower:
+        return {"name": "Product Name", "price": 99.99, "category": "electronics", "stock": 100}
+    elif "order" in path_lower:
+        return {"products": [{"id": "product_id", "quantity": 1}], "address": "123 Street"}
+    elif "cart" in path_lower:
+        return {"productId": "product_id", "quantity": 1}
+    elif "user" in path_lower or "profile" in path_lower:
+        return {"name": "John Doe", "email": "user@example.com", "phone": "1234567890"}
+    elif "category" in path_lower:
+        return {"name": "Category Name", "description": "Category description"}
+    elif "review" in path_lower:
+        return {"rating": 5, "comment": "Great product!"}
+    elif "address" in path_lower:
+        return {"street": "123 Main St", "city": "Karachi", "country": "Pakistan"}
+    elif "coupon" in path_lower:
+        return {"code": "DISCOUNT10", "discount": 10, "type": "percentage"}
+    elif "payment" in path_lower:
+        return {"amount": 1000, "currency": "PKR", "method": "card"}
+    else:
+        return {"key": "value"}
+
+def build_postman_collection(routes: list) -> dict:
+    groups = {}
+    for route in routes:
+        path = route.get("path", "/")
+        parts = [p for p in path.split("/") if p and not p.startswith(":")]
+        group = parts[0].capitalize() if parts else "General"
+        if group not in groups:
+            groups[group] = []
+        groups[group].append(route)
+
+    items = []
+    for group_name, group_routes in groups.items():
+        group_items = []
+        for route in group_routes:
+            method = route.get("method", "GET")
+            path = route.get("path", "/")
+            name = route.get("name", path)
+            path_parts = [p for p in path.split("/") if p]
+
+            item = {
+                "name": name,
+                "request": {
+                    "method": method,
+                    "header": [
+                        {"key": "Content-Type", "value": "application/json"},
+                        {"key": "Authorization", "value": "Bearer {{token}}"}
+                    ],
+                    "url": {
+                        "raw": "{{base_url}}" + path,
+                        "host": ["{{base_url}}"],
+                        "path": path_parts
+                    }
+                }
+            }
+
+            if method in ["POST", "PUT", "PATCH"]:
+                sample_body = generate_sample_body(path, method)
+                item["request"]["body"] = {
+                    "mode": "raw",
+                    "raw": json.dumps(sample_body, indent=2),
+                    "options": {"raw": {"language": "json"}}
+                }
+
+            group_items.append(item)
+
+        items.append({"name": group_name, "item": group_items})
+
+    return {
+        "info": {
+            "name": "AI Generated API Collection",
+            "_postman_id": str(uuid.uuid4()),
+            "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json",
+            "description": "Auto-generated by Postman AI Agent"
+        },
+        "item": items,
+        "variable": [
+            {"key": "base_url", "value": "http://localhost:3000"},
+            {"key": "token", "value": "your_jwt_token_here"}
+        ]
+    }
+
+# ─── Nodes ────────────────────────────────────────────────────────────────────
+def agent_node(state: AgentState) -> AgentState:
+    print("🤖 Agent node called!")
+    print(f"📝 Code length: {len(state['code'])}")
+    routes = extract_routes_directly(state["code"])
+    from langchain_core.messages import HumanMessage
+    return {
+        "messages": [HumanMessage(content=f"Extracted {len(routes)} routes")],
+        "code": state["code"],
+        "routes": routes,
+        "postman_collection": {},
+        "postman_import": {}
+    }
+
+def generate_postman_node(state: AgentState) -> AgentState:
+    print("📦 Generating Postman Collection...")
+    routes = state.get("routes", [])
+    print(f"🔍 Found {len(routes)} routes")
+
+    postman_collection = build_postman_collection(routes)
+    print("✅ Postman collection generated!")
+
+    print("🚀 Importing to Postman...")
+    postman_result = {"success": False}
+    import_result = import_to_postman_tool.invoke(json.dumps(postman_collection))
+    postman_result = import_result
+
+    if postman_result.get("success"):
+        print(f"✅ Imported to Postman: {postman_result.get('postman_url')}")
+    else:
+        print(f"❌ Postman import failed: {postman_result.get('error')}")
+
+    from langchain_core.messages import HumanMessage
+    return {
+        "messages": [HumanMessage(content="Collection generated!")],
+        "code": state["code"],
+        "postman_collection": postman_collection,
+        "routes": routes,
+        "postman_import": postman_result
+    }
+
+# ─── Build Graph ──────────────────────────────────────────────────────────────
+def create_agent():
+    graph = StateGraph(AgentState)
+    graph.add_node("agent", agent_node)
+    graph.add_node("generate", generate_postman_node)
+    graph.set_entry_point("agent")
+    graph.add_edge("agent", "generate")
+    graph.add_edge("generate", END)
+    return graph.compile()
+
+agent = create_agent()

postman_agent-1.0.0/postman_agent/cli.py

@@ -0,0 +1,241 @@
+import argparse
+import asyncio
+import os
+import sys
+import re
+from pathlib import Path
+from dotenv import load_dotenv
+
+def load_env():
+    """Load .env from multiple possible locations"""
+    possible_paths = [
+        Path.cwd() / ".env",
+        Path.home() / ".postman-agent" / ".env",
+        Path(__file__).parent.parent / ".env",
+    ]
+    for env_path in possible_paths:
+        if env_path.exists():
+            load_dotenv(env_path)
+            return str(env_path)
+    return None
+
+def print_banner():
+    print("""
+╔═══════════════════════════════════════╗
+║       🤖 Postman AI Agent CLI         ║
+║   LangGraph + Groq + Postman API      ║
+╚═══════════════════════════════════════╝
+    """)
+
+def detect_framework(code: str) -> str:
+    if "express" in code.lower() or "router." in code.lower():
+        return "Express.js"
+    elif "fastapi" in code.lower():
+        return "FastAPI"
+    elif "flask" in code.lower():
+        return "Flask"
+    elif "django" in code.lower() or "urlpatterns" in code.lower():
+        return "Django"
+    elif "fastify" in code.lower():
+        return "Fastify"
+    return "Unknown"
+
+def is_api_file(file_path: Path) -> bool:
+    """File naam se nahi — content se detect karo"""
+    api_patterns = [
+        r'(?:router|app)\.(get|post|put|delete|patch)\s*\(',
+        r'@(?:app|router)\.(get|post|put|delete|patch)\s*\(',
+        r'@\w+\.route\s*\(',
+        r'(?:path|re_path|url)\s*\(\s*["\']',
+        r'fastify\.(get|post|put|delete|patch)\s*\(',
+        r'app\.use\s*\(\s*["\']\/',
+    ]
+    try:
+        content = file_path.read_text(encoding="utf-8", errors="ignore")
+        for pattern in api_patterns:
+            if re.search(pattern, content, re.IGNORECASE):
+                return True
+    except Exception:
+        pass
+    return False
+
+async def run_agent(code: str):
+    from postman_agent.agent.graph import agent
+    initial_state = {
+        "messages": [],
+        "code": code,
+        "routes": [],
+        "postman_collection": {},
+        "postman_import": {}
+    }
+    result = await agent.ainvoke(initial_state)
+    return result
+
+def setup_command(args):
+    """Save API keys to .env file"""
+    print_banner()
+    print("⚙️  Setup — API Keys Configuration\n")
+
+    groq_key = input("🔑 Enter your GROQ API Key: ").strip()
+    postman_key = input("🔑 Enter your POSTMAN API Key: ").strip()
+
+    # ─── Save to home directory ───────────────────────────────────────────
+    env_dir = Path.home() / ".postman-agent"
+    env_dir.mkdir(exist_ok=True)
+    env_file = env_dir / ".env"
+
+    with open(env_file, "w") as f:
+        f.write(f"GROQ_API_KEY={groq_key}\n")
+        f.write(f"POSTMAN_API_KEY={postman_key}\n")
+
+    print(f"\n✅ API keys saved to: {env_file}")
+    print("🚀 You're ready! Run: postman-agent generate --scan .\n")
+
+def generate_command(args):
+    """Main generate command"""
+    print_banner()
+
+    # ─── Load env ─────────────────────────────────────────────────────────
+    env_path = load_env()
+
+    # ─── Check API keys ───────────────────────────────────────────────────
+    if not os.getenv("GROQ_API_KEY"):
+        print("❌ GROQ_API_KEY not found!")
+        print("💡 Run: postman-agent setup")
+        sys.exit(1)
+
+    if not os.getenv("POSTMAN_API_KEY"):
+        print("❌ POSTMAN_API_KEY not found!")
+        print("💡 Run: postman-agent setup")
+        sys.exit(1)
+
+    # ─── Excluded folders ─────────────────────────────────────────────────
+    excluded = [
+        "node_modules", "venv", "__pycache__",
+        ".git", "dist", "build", ".next",
+        "coverage", "vendor", "env", ".venv"
+    ]
+
+    if args.file:
+        file_path = Path(args.file)
+        if not file_path.exists():
+            print(f"❌ File not found: {args.file}")
+            sys.exit(1)
+        print(f"📝 Reading file: {args.file}")
+        code = file_path.read_text(encoding="utf-8", errors="ignore")
+
+    elif args.scan:
+        scan_path = Path(args.scan)
+        if not scan_path.exists():
+            print(f"❌ Directory not found: {args.scan}")
+            sys.exit(1)
+
+        print(f"🔍 Scanning directory: {args.scan}")
+
+        extensions = [".js", ".ts", ".py"]
+        all_files = []
+        for ext in extensions:
+            all_files.extend(scan_path.rglob(f"*{ext}"))
+
+        all_files = [
+            f for f in all_files
+            if not any(ex in str(f) for ex in excluded)
+        ]
+
+        files = [f for f in all_files if is_api_file(f)]
+
+        if not files:
+            print("❌ No API files found!")
+            print("💡 Try: postman-agent generate --file path/to/routes.js")
+            sys.exit(1)
+
+        print(f"📁 Found {len(files)} API files:")
+        for f in files:
+            print(f"   → {f.name}")
+
+        code = ""
+        for f in files:
+            code += f"\n// ═══ File: {f.name} ═══\n"
+            code += f.read_text(encoding="utf-8", errors="ignore")
+
+    else:
+        print("❌ Please provide --file or --scan")
+        print("   Example: postman-agent generate --file routes.js")
+        print("   Example: postman-agent generate --scan .")
+        sys.exit(1)
+
+    framework = detect_framework(code)
+    print(f"🔎 Detected Framework: {framework}")
+    print(f"📊 Code size: {len(code)} characters")
+    print(f"\n🤖 AI Agent analyzing code...")
+    print("⏳ Please wait...\n")
+
+    try:
+        result = asyncio.run(run_agent(code))
+    except Exception as e:
+        print(f"❌ Agent error: {str(e)}")
+        sys.exit(1)
+
+    routes = result.get("routes", [])
+    postman_import = result.get("postman_import", {})
+    postman_collection = result.get("postman_collection", {})
+
+    print(f"✅ Found {len(routes)} routes!")
+
+    if routes:
+        print("\n📋 Detected Routes:")
+        for route in routes:
+            method = route.get("method", "GET")
+            path = route.get("path", "/")
+            print(f"   {method:<8} {path}")
+
+    print(f"\n📦 Postman Collection generated!")
+
+    if postman_import.get("success"):
+        print(f"\n🚀 ✅ Imported to Postman Successfully!")
+        print(f"📌 Collection: {postman_collection.get('info', {}).get('name', 'API Collection')}")
+        print(f"🔗 Open here: {postman_import.get('postman_url')}")
+    else:
+        print(f"\n⚠️  Postman Import Failed: {postman_import.get('error', 'Unknown error')}")
+        print("💡 Run: postman-agent setup")
+
+    print("\n✨ Done! Happy Testing! 🎉\n")
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="🤖 Postman AI Agent — Auto generate Postman Collections from code",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Commands:
+  setup     Save your API keys (run once)
+  generate  Generate Postman Collection
+
+Examples:
+  postman-agent setup
+  postman-agent generate --file routes.js
+  postman-agent generate --scan .
+  postman-agent generate --scan ./src
+        """
+    )
+
+    subparsers = parser.add_subparsers(dest="command")
+
+    # ─── Setup command ────────────────────────────────────────────────────
+    subparsers.add_parser("setup", help="Save API keys (run once)")
+
+    # ─── Generate command ─────────────────────────────────────────────────
+    gen_parser = subparsers.add_parser("generate", help="Generate Postman Collection")
+    gen_parser.add_argument("--file", "-f", help="Path to route file")
+    gen_parser.add_argument("--scan", "-s", help="Scan entire directory")
+
+    args = parser.parse_args()
+
+    if args.command == "setup":
+        setup_command(args)
+    elif args.command == "generate":
+        generate_command(args)
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

postman_agent-1.0.0/postman_agent/setup.py

@@ -0,0 +1,42 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as f:
+    long_description = f.read()
+
+setup(
+    name="postman-ai-agent",
+    version="1.0.0",
+    author="M. Abubakar",
+    author_email="your-email@gmail.com",
+    description="AI Agent that auto-generates Postman Collections from backend code",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/Abubakar-webmaker/postman-ai-agent",
+    packages=find_packages(),
+    python_requires=">=3.10",
+    install_requires=[
+        "langchain>=0.2.0",
+        "langgraph>=0.2.0",
+        "langchain-groq>=0.1.0",
+        "python-dotenv>=1.0.0",
+        "httpx>=0.27.0",
+        "typing-extensions>=4.0.0",
+    ],
+    entry_points={
+        "console_scripts": [
+            "postman-agent=postman_agent.cli:main",
+        ],
+    },
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Topic :: Software Development :: Code Generators",
+        "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
+    ],
+    keywords=[
+        "postman", "api", "ai-agent", "langgraph",
+        "groq", "code-generator", "rest-api", "express",
+        "fastapi", "flask", "django"
+    ],
+)

postman_agent-1.0.0/postman_agent/tools/__init__.py

@@ -0,0 +1,3 @@
+from postman_agent.tools.code_parser import parse_code_tool
+
+__all__ = ["parse_code_tool"]

postman_agent-1.0.0/postman_agent/tools/code_parser.py

@@ -0,0 +1,105 @@
+import ast
+import re
+from typing import Any
+from langchain.tools import tool
+
+@tool
+def parse_code_tool(code: str) -> dict[str, Any]:
+    """
+    Analyzes backend code and extracts API routes/endpoints.
+    Supports Express.js, FastAPI, Flask, and Django patterns.
+    """
+    routes = []
+
+    # ─── Express.js Patterns ──────────────────────────────────────────────
+    express_pattern = r'(?:router|app)\.(get|post|put|delete|patch)\s*\(\s*["\']([^"\']+)["\']'
+    use_pattern = r'app\.use\s*\(\s*["\']([^"\']+)["\']'
+
+    # ─── FastAPI / Flask Patterns ─────────────────────────────────────────
+    python_decorator_pattern = r'@(?:app|router)\.(get|post|put|delete|patch)\s*\(\s*["\']([^"\']+)["\']'
+    flask_route_pattern = r'@\w+\.route\s*\(\s*["\']([^"\']+)["\'].*?methods\s*=\s*\[([^\]]+)\]'
+    django_path_pattern = r'(?:path|re_path)\s*\(\s*["\']([^"\']+)["\']'
+
+    # ─── Try Python AST first ─────────────────────────────────────────────
+    try:
+        tree = ast.parse(code)
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                for decorator in node.decorator_list:
+                    if isinstance(decorator, ast.Call):
+                        func = decorator.func
+                        if isinstance(func, ast.Attribute):
+                            method = func.attr.lower()
+                            if method in ["get", "post", "put", "delete", "patch"]:
+                                if decorator.args:
+                                    path_node = decorator.args[0]
+                                    if isinstance(path_node, ast.Constant):
+                                        routes.append({
+                                            "method": method.upper(),
+                                            "path": path_node.value,
+                                            "name": node.name,
+                                            "description": ast.get_docstring(node) or f"{method.upper()} {path_node.value}"
+                                        })
+    except SyntaxError:
+        pass
+
+    # ─── Express.js Regex ─────────────────────────────────────────────────
+    if not routes:
+        seen = set()
+        matches = re.findall(express_pattern, code, re.IGNORECASE | re.MULTILINE)
+        for method, path in matches:
+            if not path.startswith('/'):
+                continue
+            key = f"{method.upper()}:{path}"
+            if key not in seen:
+                seen.add(key)
+                name = path.replace('/', ' ').replace(':', '').replace('-', ' ').strip()
+                name = ' '.join(w.capitalize() for w in name.split()) or "Endpoint"
+                routes.append({
+                    "method": method.upper(),
+                    "path": path,
+                    "name": name,
+                    "description": f"{method.upper()} {path}"
+                })
+
+    # ─── Flask Regex fallback ─────────────────────────────────────────────
+    if not routes:
+        matches = re.findall(flask_route_pattern, code, re.IGNORECASE | re.DOTALL)
+        for path, methods_str in matches:
+            methods = [m.strip().strip('"\'') for m in methods_str.split(',')]
+            for method in methods:
+                if method.upper() in ["GET", "POST", "PUT", "DELETE", "PATCH"]:
+                    routes.append({
+                        "method": method.upper(),
+                        "path": path,
+                        "name": path.replace("/", "_").strip("_") or "endpoint",
+                        "description": f"{method.upper()} {path}"
+                    })
+
+    # ─── Django Regex fallback ────────────────────────────────────────────
+    if not routes:
+        matches = re.findall(django_path_pattern, code, re.IGNORECASE)
+        for path in matches:
+            routes.append({
+                "method": "GET",
+                "path": f"/{path}",
+                "name": path.replace("/", "_").strip("_") or "endpoint",
+                "description": f"GET /{path}"
+            })
+
+    # ─── Python decorator fallback ────────────────────────────────────────
+    if not routes:
+        matches = re.findall(python_decorator_pattern, code, re.IGNORECASE)
+        for method, path in matches:
+            routes.append({
+                "method": method.upper(),
+                "path": path,
+                "name": path.replace("/", "_").strip("_") or "endpoint",
+                "description": f"{method.upper()} {path}"
+            })
+
+    return {
+        "routes": routes,
+        "total": len(routes),
+        "status": "success" if routes else "no_routes_found"
+    }

postman_agent-1.0.0/postman_agent.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: postman-agent
+Version: 1.0.0
+Requires-Python: >=3.9
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Requires-Dist: langchain
+Requires-Dist: langchain-groq
+Requires-Dist: langgraph
+Requires-Dist: httpx
+Requires-Dist: pydantic
+Requires-Dist: python-dotenv

postman_agent-1.0.0/postman_agent.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+postman_agent/__init__.py
+postman_agent/cli.py
+postman_agent/setup.py
+postman_agent.egg-info/PKG-INFO
+postman_agent.egg-info/SOURCES.txt
+postman_agent.egg-info/dependency_links.txt
+postman_agent.egg-info/entry_points.txt
+postman_agent.egg-info/requires.txt
+postman_agent.egg-info/top_level.txt
+postman_agent/agent/__init__.py
+postman_agent/agent/graph.py
+postman_agent/tools/__init__.py
+postman_agent/tools/code_parser.py

postman_agent-1.0.0/postman_agent.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

postman_agent-1.0.0/postman_agent.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+postman-agent = postman_agent.cli:main

postman_agent-1.0.0/postman_agent.egg-info/requires.txt

@@ -0,0 +1,8 @@
+fastapi
+uvicorn
+langchain
+langchain-groq
+langgraph
+httpx
+pydantic
+python-dotenv

postman_agent-1.0.0/postman_agent.egg-info/top_level.txt

@@ -0,0 +1 @@
+postman_agent

postman_agent-1.0.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "postman-agent"
+version = "1.0.0"
+requires-python = ">=3.9"
+dependencies = [
+    "fastapi",
+    "uvicorn",
+    "langchain",
+    "langchain-groq",
+    "langgraph",
+    "httpx",
+    "pydantic",
+    "python-dotenv",
+]
+
+[project.scripts]
+postman-agent = "postman_agent.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["postman_agent*"]

postman_agent-1.0.0/setup.cfg

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

postman_agent-1.0.0/setup.py

@@ -0,0 +1,12 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="postman-agent",
+    version="1.0.0",
+    packages=find_packages(include=["postman_agent", "postman_agent.*"]),
+    entry_points={
+        "console_scripts": [
+            "postman-agent=postman_agent.cli:main",
+        ],
+    },
+)