aitesting 1.1.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,220 @@
+# 🚀 AITesting - Complete API Testing & Documentation Suite
+
+An AI-powered CLI tool that automatically generates Postman collections, API documentation, test files, and live endpoint testing from your backend codebase.
+
+## ✨ Features
+
+- 🔍 **Route Scanning** - Automatically discovers all API routes from TypeScript files
+- 🧪 **Live Endpoint Testing** - Makes REAL HTTP requests and records actual responses
+- 🔐 **Auth Detection** - Automatically detects login endpoints and manages JWT tokens
+- 📋 **Schema Detection** - Finds Zod, Joi, and class-validator schemas
+- 📁 **Postman Collections** - Generates organized collections with example responses
+- 🌍 **Environment Files** - Creates local & production Postman environments
+- 🧪 **Test Generation** - Generates Bun test files for all routes
+- 📜 **OpenAPI/Swagger** - Generates OpenAPI 3.0 spec with interactive Swagger UI
+- 📚 **Enhanced Documentation** - Creates comprehensive markdown API docs
+- 📊 **Test Reports** - Saves detailed live test results in JSON format
+
+## 🛠️ Installation
+
+### Install Globally (Recommended)
+
+```bash
+cd /Users/devx/Desktop/AITESTING
+bun link
+```
+
+Now use `aitesting` command from anywhere!
+
+### Or Run Locally
+
+```bash
+cd /Users/devx/Desktop/AITESTING
+bun install
+```
+
+## 📖 Usage
+
+### Simple Mode (Just scan and generate Postman collection)
+
+```bash
+aitesting --path /path/to/your/backend
+```
+
+### Complete Mode (Everything!)
+
+```bash
+aitesting --path /path/to/your/backend --all
+```
+
+### With Remote Backend
+
+```bash
+aitesting --path /path/to/backend --all --url https://api.yourapp.com
+```
+
+### Specify Output Directory
+
+```bash
+aitesting --path /backend --all -o ~/Documents/api-docs
+```
+
+The `--all` flag runs the complete workflow:
+
+1. ✅ Scans backend for routes
+2. ✅ Detects authentication endpoints
+3. ✅ Finds validation schemas
+4. ✅ Tests all endpoints live
+5. ✅ Captures JWT tokens automatically
+6. ✅ Generates Postman collection with example responses
+7. ✅ Creates environment files
+8. ✅ Generates automated test files
+9. ✅ Creates enhanced documentation
+
+## 📦 Generated Files
+
+When you run with `--all`, you'll get:
+
+```
+📁 Project Root
+├── postman_collection.json              # Postman collection with examples
+├── local_environment.postman_environment.json
+├── production_environment.postman_environment.json
+├── openapi.json                         # OpenAPI 3.0 specification
+├── api-docs.html                        # Swagger UI (open in browser!)
+├── API_DOCUMENTATION.md                 # Markdown API docs
+├── .aitesting/
+│   └── report.json                      # Live test results
+└── tests/auto/
+    ├── users.test.ts                    # Auto-generated tests
+    ├── auth.test.ts
+    └── ...
+```
+
+## 🎯 What It Does
+
+### 1. Route Discovery
+
+Scans your TypeScript files using AST parsing to find all route definitions:
+
+```typescript
+router.get("/users/:id", handler);
+router.post("/auth/login", handler);
+```
+
+### 2. Live Testing (REAL HTTP Requests!)
+
+**⚠️ Makes actual HTTP requests to your backend:**
+
+- Tests each endpoint with real network calls (using `fetch`)
+- Records actual response status codes
+- Captures real response bodies
+- Saves headers and error messages
+- **Requires your backend to be running!**
+
+### 3. Auth Handling
+
+- Automatically detects login/auth endpoints
+- Obtains JWT tokens during testing
+- Injects tokens into subsequent requests
+- Adds auth headers to Postman collection
+
+### 4. Schema Detection
+
+Finds validation schemas in your code:
+
+- Zod schemas (`z.object(...)`)
+- Joi schemas (`Joi.object(...)`)
+- class-validator decorators (`@IsString()`, etc.)
+
+### 5. Test Generation
+
+Creates ready-to-run Bun tests:
+
+```typescript
+import { test, expect, describe } from "bun:test";
+
+describe("Users Routes", () => {
+  test("GET /users/:id", async () => {
+    const response = await fetch(`${baseUrl}/users/1`);
+    expect(response).toBeDefined();
+  });
+});
+```
+
+### 6. OpenAPI/Swagger Generation
+
+Generates industry-standard OpenAPI 3.0 specification:
+
+- **`openapi.json`** - Complete OpenAPI 3.0 spec
+- **`api-docs.html`** - Interactive Swagger UI
+- Includes auth schemes, request/response examples
+- Path parameters, request bodies, responses
+- **Open `api-docs.html` in browser for interactive docs!**
+
+## 🔧 Configuration
+
+The tool works out-of-the-box, but you can customize:
+
+- **Base URL**: Edit the `baseUrl` in generated environment files
+- **Auth Token Detection**: Supports `token`, `access_token`, and `accessToken` fields
+- **Route Detection**: Looks for `router.*` patterns in TypeScript files
+
+## 📋 Requirements
+
+- Bun runtime
+- Backend with TypeScript route definitions
+- Routes using `router.get()`, `router.post()`, etc. pattern
+
+## 🚦 Example Output
+
+```
+🚀 AITesting v1.0 - Full Workflow
+
+🔍 Scanning backend in: ./backend
+
+✅ Found 23 routes
+🔐 Detected auth endpoint: POST /auth/login
+📋 Detected schemas: zod, class-validator
+
+🧪 Running live endpoint tests...
+
+✅ Auth token obtained
+✓ GET /users 200
+✓ POST /users 201
+✓ GET /users/:id 200
+✗ DELETE /users/:id 401
+
+📊 Live test report saved to .aitesting/report.json
+
+📁 Generated: postman_collection.json
+🌍 Environments generated (local & production)
+🧪 Test files generated in tests/auto/
+📘 Enhanced documentation generated (API_DOCUMENTATION.md)
+
+✅ Complete! All features executed successfully.
+```
+
+## 📝 Important Notes
+
+### Live Testing (with `--all` flag)
+
+- **⚠️ Requires your backend to be running** at `http://localhost:5000` (default)
+- Makes **REAL HTTP requests** using `fetch()` - not mock/sample data!
+- Path parameters (e.g., `:id`) are replaced with `1` during testing
+- Failed tests are recorded in the report but don't stop the workflow
+- Responses in `openapi.json` and Postman collection are **actual responses** from your API
+
+### OpenAPI/Swagger UI
+
+- Open `api-docs.html` in any browser for interactive documentation
+- Works offline - Swagger UI loads from CDN
+- Can be hosted on any web server for team sharing
+
+## 🤝 Contributing
+
+This is a productivity tool. Feel free to extend and customize for your needs!
+
+## 📄 License
+
+See LICENSE file.

package/bin/postmanai.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { program } from "commander";
+import { generateCollection } from "../src/generate.js";
+
+console.log("✅ AITesting CLI v1.1.0");
+
+program
+  .name("aitesting")
+  .description("AI-powered API testing & documentation generator")
+  .version("1.1.0")
+  .option("-p, --path <path>", "Path to your backend folder", ".")
+  .option(
+    "--all",
+    "Run complete workflow (scan, test, schemas, auth, tests, docs)"
+  )
+  .option(
+    "--url <url>",
+    "Base URL for live testing (default: http://localhost:5050)"
+  )
+  .option(
+    "-o, --output <path>",
+    "Output directory for generated files (default: current directory)"
+  )
+  .action(async (opts) => {
+    await generateCollection(opts.path, {
+      all: opts.all || false,
+      baseUrl: opts.url,
+      outputDir: opts.output,
+    });
+  });
+
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "aitesting",
+  "version": "1.1.0",
+  "description": "AI-powered API testing & documentation generator with OpenAPI/Swagger support",
+  "main": "bin/postmanai.js",
+  "type": "module",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "prepublishOnly": "echo 'Ready to publish!'"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@babel/parser": "^7.28.4",
+    "@babel/traverse": "^7.28.4",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.1",
+    "glob": "^11.0.3"
+  },
+  "bin": {
+    "aitesting": "./bin/postmanai.js"
+  },
+  "keywords": [
+    "api",
+    "testing",
+    "openapi",
+    "swagger",
+    "postman",
+    "documentation",
+    "cli",
+    "api-documentation",
+    "test-generator",
+    "openapi-generator"
+  ],
+  "author": "devxcant",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git@github-devx:devXcant/api_testing_ai.git"
+  },
+  "bugs": {
+    "url": "https://github.com/devXcant/api_testing_ai/issues"
+  },
+  "homepage": "https://github.com/devXcant/api_testing_ai"
+}

package/src/generate.js

@@ -0,0 +1,833 @@
+import fs from "fs";
+import path from "path";
+import * as babel from "@babel/parser";
+import * as t from "@babel/types";
+import traverseModule from "@babel/traverse";
+import chalk from "chalk";
+
+import * as globModule from "glob";
+const glob = globModule.glob || globModule.default || globModule;
+
+const traverse = traverseModule.default || traverseModule;
+
+function detectRoutePrefixes(basePath) {
+  const mainFiles = glob.sync(
+    `${basePath}/**/{index,app,server,main}.{ts,js}`,
+    {
+      ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"],
+    }
+  );
+
+  const prefixMap = {};
+
+  for (const file of mainFiles) {
+    const ast = parseFile(file);
+    if (!ast) continue;
+
+    traverse(ast, {
+      CallExpression(nodePath) {
+        const callee = nodePath.node.callee;
+
+        if (
+          t.isMemberExpression(callee) &&
+          t.isIdentifier(callee.property, { name: "use" })
+        ) {
+          const args = nodePath.node.arguments;
+
+          if (args.length >= 2 && t.isStringLiteral(args[0])) {
+            const prefix = args[0].value;
+            const routeImport = args[1];
+
+            let routeIdentifier = null;
+            if (t.isIdentifier(routeImport)) {
+              routeIdentifier = routeImport.name;
+            }
+
+            if (routeIdentifier) {
+              nodePath.scope.traverse(nodePath.scope.block, {
+                ImportDeclaration(importPath) {
+                  importPath.node.specifiers.forEach((spec) => {
+                    if (
+                      t.isImportDefaultSpecifier(spec) &&
+                      spec.local.name === routeIdentifier
+                    ) {
+                      const importSource = importPath.node.source.value;
+                      const routeFile = importSource
+                        .replace(/^\.\//, "")
+                        .replace(/^\//, "");
+                      prefixMap[routeFile] = prefix;
+                    }
+                  });
+                },
+              });
+            }
+          }
+        }
+      },
+    });
+  }
+
+  return prefixMap;
+}
+
+function parseFile(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    return babel.parse(content, {
+      sourceType: "module",
+      plugins: ["typescript", "jsx", "decorators-legacy"],
+    });
+  } catch (err) {
+    console.warn(
+      chalk.yellow(`⚠️ Failed to parse ${filePath}: ${err.message}`)
+    );
+    return null;
+  }
+}
+
+function extractRoutesFromFile(filePath) {
+  const ast = parseFile(filePath);
+  if (!ast) return { routes: [], authEndpoint: null };
+
+  const routes = [];
+  let authEndpoint = null;
+
+  traverse(ast, {
+    CallExpression(nodePath) {
+      const callee = nodePath.node.callee;
+      if (
+        t.isMemberExpression(callee) &&
+        t.isIdentifier(callee.object, { name: "router" })
+      ) {
+        const method = callee.property.name?.toUpperCase?.();
+        const routeArg = nodePath.node.arguments?.[0];
+        if (method && t.isStringLiteral(routeArg)) {
+          const routePath = routeArg.value;
+          const isAuth =
+            routePath.includes("login") || routePath.includes("signin");
+
+          const route = {
+            method,
+            path: routePath,
+            file: filePath,
+            isAuth,
+            schema: null,
+          };
+
+          if (isAuth && method === "POST" && !authEndpoint) {
+            authEndpoint = route;
+          }
+
+          routes.push(route);
+        }
+      }
+    },
+  });
+
+  return { routes, authEndpoint };
+}
+
+function detectSchemas(filePath) {
+  const ast = parseFile(filePath);
+  if (!ast) return [];
+
+  const schemas = [];
+
+  traverse(ast, {
+    CallExpression(nodePath) {
+      const callee = nodePath.node.callee;
+
+      if (t.isMemberExpression(callee)) {
+        const objName = callee.object?.name;
+        const propName = callee.property?.name;
+
+        if (
+          objName === "z" ||
+          (propName &&
+            ["object", "string", "number", "boolean", "array"].includes(
+              propName
+            ))
+        ) {
+          schemas.push({ type: "zod", path: filePath });
+        }
+      }
+
+      if (t.isIdentifier(callee) && callee.name === "Joi") {
+        schemas.push({ type: "joi", path: filePath });
+      }
+    },
+    Decorator(nodePath) {
+      const expr = nodePath.node.expression;
+      if (t.isCallExpression(expr) && t.isIdentifier(expr.callee)) {
+        const decoratorName = expr.callee.name;
+        if (
+          ["IsString", "IsNumber", "IsEmail", "IsOptional"].includes(
+            decoratorName
+          )
+        ) {
+          schemas.push({ type: "class-validator", path: filePath });
+        }
+      }
+    },
+  });
+
+  return schemas;
+}
+
+function groupRoutesByController(routes) {
+  const grouped = {};
+  for (const route of routes) {
+    const folder = path.basename(path.dirname(route.file));
+    if (!grouped[folder]) grouped[folder] = [];
+    grouped[folder].push(route);
+  }
+  return grouped;
+}
+
+async function testLiveEndpoint(route, baseUrl, authToken = null) {
+  try {
+    const url = `${baseUrl}${route.path.replace(/:\w+/g, "1")}`;
+    const headers = { "Content-Type": "application/json" };
+    if (authToken) headers["Authorization"] = `Bearer ${authToken}`;
+
+    const options = {
+      method: route.method,
+      headers,
+    };
+
+    if (["POST", "PUT", "PATCH"].includes(route.method)) {
+      options.body = JSON.stringify({});
+    }
+
+    const response = await fetch(url, options);
+    const responseText = await response.text();
+
+    let responseBody;
+    try {
+      responseBody = JSON.parse(responseText);
+    } catch {
+      responseBody = responseText;
+    }
+
+    return {
+      success: response.ok,
+      status: response.status,
+      headers: Object.fromEntries(response.headers.entries()),
+      body: responseBody,
+    };
+  } catch (err) {
+    return {
+      success: false,
+      error: err.message,
+    };
+  }
+}
+
+function createPostmanCollection(
+  groupedRoutes,
+  liveResults = {},
+  authInfo = null
+) {
+  const collection = {
+    info: {
+      name: "AI Testing Collection",
+      schema:
+        "https://schema.getpostman.com/json/collection/v2.1.0/collection.json",
+    },
+    item: [],
+  };
+
+  for (const [folder, routes] of Object.entries(groupedRoutes)) {
+    const folderItem = {
+      name: folder.charAt(0).toUpperCase() + folder.slice(1),
+      item: routes.map((r) => {
+        const item = {
+          name: `${r.method} ${r.path}`,
+          request: {
+            method: r.method,
+            header: [],
+            url: {
+              raw: `{{baseUrl}}${r.path}`,
+              host: ["{{baseUrl}}"],
+              path: r.path.split("/").filter(Boolean),
+            },
+          },
+        };
+
+        if (authInfo && !r.isAuth) {
+          item.request.header.push({
+            key: "Authorization",
+            value: "Bearer {{authToken}}",
+            type: "text",
+          });
+        }
+
+        if (["POST", "PUT", "PATCH"].includes(r.method)) {
+          item.request.header.push({
+            key: "Content-Type",
+            value: "application/json",
+          });
+          item.request.body = {
+            mode: "raw",
+            raw: JSON.stringify({}, null, 2),
+          };
+        }
+
+        const liveKey = `${r.method} ${r.path}`;
+        if (liveResults[liveKey]) {
+          item.response = [
+            {
+              name: "Example Response",
+              status: `${liveResults[liveKey].status}`,
+              code: liveResults[liveKey].status,
+              body: JSON.stringify(liveResults[liveKey].body, null, 2),
+            },
+          ];
+        }
+
+        return item;
+      }),
+    };
+    collection.item.push(folderItem);
+  }
+
+  return collection;
+}
+
+function createEnvironmentFiles(authInfo = null) {
+  const baseValues = [
+    { key: "baseUrl", value: "http://localhost:5050", enabled: true },
+  ];
+
+  if (authInfo) {
+    baseValues.push({
+      key: "authToken",
+      value: "your_jwt_token_here",
+      enabled: true,
+    });
+  }
+
+  const envs = [
+    {
+      name: "Local Environment",
+      values: baseValues,
+    },
+    {
+      name: "Production Environment",
+      values: [
+        { key: "baseUrl", value: "https://api.example.com", enabled: true },
+        ...(authInfo
+          ? [{ key: "authToken", value: "your_jwt_token_here", enabled: true }]
+          : []),
+      ],
+    },
+  ];
+
+  envs.forEach((env) => {
+    fs.writeFileSync(
+      `${env.name.replace(" ", "_").toLowerCase()}.postman_environment.json`,
+      JSON.stringify(env, null, 2)
+    );
+  });
+  console.log(chalk.green("🌍 Environments generated (local & production)"));
+}
+
+function generateTestFiles(groupedRoutes, authInfo = null) {
+  const testsDir = "./tests/auto";
+  if (!fs.existsSync(testsDir)) {
+    fs.mkdirSync(testsDir, { recursive: true });
+  }
+
+  for (const [folder, routes] of Object.entries(groupedRoutes)) {
+    const testContent = `import { test, expect, describe } from "bun:test";
+
+const baseUrl = "http://localhost:5050";
+${authInfo ? 'let authToken = "";' : ""}
+
+${
+  authInfo
+    ? `describe("Authentication", () => {
+  test("should login and get token", async () => {
+    const response = await fetch(\`\${baseUrl}${authInfo.path}\`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        email: "test@example.com",
+        password: "password123"
+      })
+    });
+
+    const data = await response.json();
+    expect(response.ok).toBe(true);
+
+    authToken = data.token || data.access_token || data.accessToken;
+    expect(authToken).toBeDefined();
+  });
+});
+
+`
+    : ""
+}describe("${folder.charAt(0).toUpperCase() + folder.slice(1)} Routes", () => {
+${routes
+  .map(
+    (r) => `  test("${r.method} ${r.path}", async () => {
+    const url = \`\${baseUrl}${r.path.replace(/:\w+/g, "1")}\`;
+    const options = {
+      method: "${r.method}",
+      headers: {
+        "Content-Type": "application/json"${
+          authInfo && !r.isAuth
+            ? ',\n        "Authorization": `Bearer ${authToken}`'
+            : ""
+        }
+      }${
+        ["POST", "PUT", "PATCH"].includes(r.method)
+          ? ",\n      body: JSON.stringify({})"
+          : ""
+      }
+    };
+
+    const response = await fetch(url, options);
+    expect(response).toBeDefined();
+  });
+`
+  )
+  .join("\n")}});
+`;
+
+    fs.writeFileSync(`${testsDir}/${folder}.test.ts`, testContent);
+  }
+
+  console.log(chalk.green(`🧪 Test files generated in ${testsDir}/`));
+}
+
+function generateOpenAPISpec(
+  groupedRoutes,
+  schemas = [],
+  authInfo = null,
+  liveResults = {}
+) {
+  const spec = {
+    openapi: "3.0.0",
+    info: {
+      title: "API Documentation",
+      version: "1.0.0",
+      description: "Auto-generated API documentation from AITesting",
+    },
+    servers: [
+      {
+        url: "http://localhost:5050",
+        description: "Local Development Server",
+      },
+      {
+        url: "https://api.example.com",
+        description: "Production Server",
+      },
+    ],
+    paths: {},
+  };
+
+  if (authInfo) {
+    spec.components = {
+      securitySchemes: {
+        BearerAuth: {
+          type: "http",
+          scheme: "bearer",
+          bearerFormat: "JWT",
+        },
+      },
+    };
+  }
+
+  for (const [folder, routes] of Object.entries(groupedRoutes)) {
+    for (const route of routes) {
+      const pathKey = route.path.replace(/:(\w+)/g, "{$1}");
+
+      if (!spec.paths[pathKey]) {
+        spec.paths[pathKey] = {};
+      }
+
+      const operation = {
+        tags: [folder.charAt(0).toUpperCase() + folder.slice(1)],
+        summary: `${route.method} ${route.path}`,
+        description: `Source: ${route.file}`,
+        parameters: [],
+        responses: {},
+      };
+
+      if (authInfo && !route.isAuth) {
+        operation.security = [{ BearerAuth: [] }];
+      }
+
+      const pathParams = route.path.match(/:(\w+)/g);
+      if (pathParams) {
+        pathParams.forEach((param) => {
+          operation.parameters.push({
+            name: param.slice(1),
+            in: "path",
+            required: true,
+            schema: { type: "string" },
+            description: "Resource identifier",
+          });
+        });
+      }
+
+      if (["POST", "PUT", "PATCH"].includes(route.method)) {
+        operation.requestBody = {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {},
+              },
+            },
+          },
+        };
+      }
+
+      const liveKey = `${route.method} ${route.path}`;
+      if (liveResults[liveKey]) {
+        const result = liveResults[liveKey];
+        const statusCode = result.status || 200;
+
+        operation.responses[statusCode] = {
+          description: result.success
+            ? "Successful response"
+            : "Error response",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+              },
+              example: result.body,
+            },
+          },
+        };
+      } else {
+        operation.responses["200"] = {
+          description: "Successful response",
+        };
+      }
+
+      spec.paths[pathKey][route.method.toLowerCase()] = operation;
+    }
+  }
+
+  fs.writeFileSync("openapi.json", JSON.stringify(spec, null, 2));
+  console.log(chalk.green("📜 OpenAPI specification generated (openapi.json)"));
+
+  const swaggerHTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>API Documentation - Swagger UI</title>
+  <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5.10.3/swagger-ui.css">
+</head>
+<body>
+  <div id="swagger-ui"></div>
+  <script src="https://unpkg.com/swagger-ui-dist@5.10.3/swagger-ui-bundle.js"></script>
+  <script src="https://unpkg.com/swagger-ui-dist@5.10.3/swagger-ui-standalone-preset.js"></script>
+  <script>
+    window.onload = function() {
+      SwaggerUIBundle({
+        url: './openapi.json',
+        dom_id: '#swagger-ui',
+        deepLinking: true,
+        presets: [
+          SwaggerUIBundle.presets.apis,
+          SwaggerUIStandalonePreset
+        ],
+        plugins: [
+          SwaggerUIBundle.plugins.DownloadUrl
+        ],
+        layout: "StandaloneLayout"
+      });
+    };
+  </script>
+</body>
+</html>`;
+
+  fs.writeFileSync("api-docs.html", swaggerHTML);
+  console.log(chalk.green("🌐 Swagger UI page generated (api-docs.html)"));
+}
+
+function generateEnhancedDocs(
+  groupedRoutes,
+  schemas = [],
+  authInfo = null,
+  liveResults = {}
+) {
+  let doc = `# 📚 API Documentation
+
+Generated by AITesting - ${new Date().toLocaleDateString()}
+
+---
+
+`;
+
+  if (authInfo) {
+    doc += `## 🔐 Authentication
+
+This API uses JWT Bearer token authentication.
+
+**Login Endpoint:** \`${authInfo.method} ${authInfo.path}\`
+
+**Headers Required:**
+\`\`\`
+Authorization: Bearer <your_token>
+\`\`\`
+
+---
+
+`;
+  }
+
+  if (schemas.length > 0) {
+    const schemaTypes = [...new Set(schemas.map((s) => s.type))];
+    doc += `## 📋 Validation Schemas
+
+Detected validation libraries: ${schemaTypes.join(", ")}
+
+---
+
+`;
+  }
+
+  for (const [folder, routes] of Object.entries(groupedRoutes)) {
+    doc += `## ${folder.charAt(0).toUpperCase() + folder.slice(1)}\n\n`;
+
+    for (const route of routes) {
+      doc += `### ${route.method} ${route.path}\n\n`;
+
+      if (route.isAuth) {
+        doc += `🔓 **Public endpoint** (Authentication)\n\n`;
+      }
+
+      const pathParams = route.path.match(/:\w+/g);
+      if (pathParams) {
+        doc += `**Path Parameters:**\n`;
+        pathParams.forEach((param) => {
+          doc += `- \`${param.slice(1)}\` - ID or identifier\n`;
+        });
+        doc += `\n`;
+      }
+
+      if (["POST", "PUT", "PATCH"].includes(route.method)) {
+        doc += `**Request Body:**\n\`\`\`json\n{}\n\`\`\`\n\n`;
+      }
+
+      const liveKey = `${route.method} ${route.path}`;
+      if (liveResults[liveKey] && liveResults[liveKey].success) {
+        doc += `**Example Response (${
+          liveResults[liveKey].status
+        }):**\n\`\`\`json\n${JSON.stringify(
+          liveResults[liveKey].body,
+          null,
+          2
+        )}\n\`\`\`\n\n`;
+      }
+
+      doc += `**File:** \`${route.file}\`\n\n`;
+      doc += `---\n\n`;
+    }
+  }
+
+  fs.writeFileSync("API_DOCUMENTATION.md", doc);
+  console.log(
+    chalk.green("📘 Enhanced documentation generated (API_DOCUMENTATION.md)")
+  );
+}
+
+export async function generateCollection(basePath, options = {}) {
+  const baseUrl = options.baseUrl || "http://localhost:5050";
+  const outputDir = options.outputDir || ".";
+
+  console.log(chalk.cyan(`\n🚀 AITesting v1.1.0 - Full Workflow\n`));
+  console.log(chalk.cyan(`🔍 Scanning backend in: ${basePath}\n`));
+  if (options.all && baseUrl) {
+    console.log(chalk.blue(`🌐 Testing URL: ${baseUrl}\n`));
+  }
+
+  console.log(chalk.cyan(`🔍 Detecting route prefixes...\n`));
+  const prefixMap = detectRoutePrefixes(basePath);
+
+  if (Object.keys(prefixMap).length > 0) {
+    console.log(chalk.green(`✅ Found route prefixes:`));
+    Object.entries(prefixMap).forEach(([file, prefix]) => {
+      console.log(chalk.white(`   ${file} → ${prefix}`));
+    });
+    console.log();
+  }
+
+  const files = glob.sync(`${basePath}/**/*.ts`, {
+    ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.git/**"],
+  });
+
+  const allRoutes = [];
+  let authEndpoint = null;
+  const allSchemas = [];
+
+  for (const file of files) {
+    const { routes, authEndpoint: auth } = extractRoutesFromFile(file);
+
+    const relativeFile = file.replace(`${basePath}/`, "").replace(/\\/g, "/");
+
+    routes.forEach((route) => {
+      for (const [routeFile, prefix] of Object.entries(prefixMap)) {
+        if (
+          relativeFile.includes(routeFile) ||
+          relativeFile.endsWith(routeFile + ".ts")
+        ) {
+          route.path = prefix + route.path;
+          route.prefix = prefix;
+          break;
+        }
+      }
+    });
+
+    allRoutes.push(...routes);
+
+    if (auth) {
+      authEndpoint = auth;
+    }
+
+    if (options.all) {
+      const schemas = detectSchemas(file);
+      allSchemas.push(...schemas);
+    }
+  }
+
+  if (!allRoutes.length) {
+    console.warn(chalk.yellow("⚠️ No routes found."));
+    return;
+  }
+
+  console.log(chalk.green(`✅ Found ${allRoutes.length} routes`));
+
+  if (authEndpoint) {
+    console.log(
+      chalk.blue(
+        `🔐 Detected auth endpoint: ${authEndpoint.method} ${authEndpoint.path}`
+      )
+    );
+  }
+
+  if (allSchemas.length > 0) {
+    const schemaTypes = [...new Set(allSchemas.map((s) => s.type))];
+    console.log(
+      chalk.magenta(`📋 Detected schemas: ${schemaTypes.join(", ")}`)
+    );
+  }
+
+  const groupedRoutes = groupRoutesByController(allRoutes);
+
+  let liveResults = {};
+  let authToken = null;
+
+  if (options.all) {
+    console.log(chalk.cyan(`\n🧪 Running live endpoint tests...\n`));
+    console.log(
+      chalk.yellow(`⚠️  Making REAL HTTP requests to your backend!\n`)
+    );
+
+    if (authEndpoint) {
+      const authResult = await testLiveEndpoint(authEndpoint, baseUrl);
+      if (authResult.success && authResult.body) {
+        authToken =
+          authResult.body.token ||
+          authResult.body.access_token ||
+          authResult.body.accessToken;
+        if (authToken) {
+          console.log(chalk.green(`✅ Auth token obtained`));
+        }
+      }
+      liveResults[`${authEndpoint.method} ${authEndpoint.path}`] = authResult;
+    }
+
+    for (const route of allRoutes) {
+      if (route.isAuth) continue;
+
+      const result = await testLiveEndpoint(route, baseUrl, authToken);
+      liveResults[`${route.method} ${route.path}`] = result;
+
+      const status = result.success ? chalk.green("✓") : chalk.red("✗");
+      console.log(
+        `${status} ${route.method} ${route.path} ${result.status || ""}`
+      );
+    }
+
+    const reportDir = "./.aitesting";
+    if (!fs.existsSync(reportDir)) {
+      fs.mkdirSync(reportDir, { recursive: true });
+    }
+
+    fs.writeFileSync(
+      `${reportDir}/report.json`,
+      JSON.stringify(
+        { routes: allRoutes, results: liveResults, authEndpoint },
+        null,
+        2
+      )
+    );
+    console.log(
+      chalk.green(`\n📊 Live test report saved to .aitesting/report.json`)
+    );
+  }
+
+  const collection = createPostmanCollection(
+    groupedRoutes,
+    liveResults,
+    authEndpoint
+  );
+  fs.writeFileSync(
+    "postman_collection.json",
+    JSON.stringify(collection, null, 2)
+  );
+  console.log(chalk.green(`\n📁 Generated: postman_collection.json`));
+
+  createEnvironmentFiles(authEndpoint);
+
+  if (options.all) {
+    generateTestFiles(groupedRoutes, authEndpoint);
+    generateOpenAPISpec(groupedRoutes, allSchemas, authEndpoint, liveResults);
+    generateEnhancedDocs(groupedRoutes, allSchemas, authEndpoint, liveResults);
+  }
+
+  console.log(
+    chalk.green.bold("\n✅ Complete! All features executed successfully.\n")
+  );
+
+  if (options.all) {
+    console.log(chalk.cyan("📦 Generated files:"));
+    console.log(
+      chalk.white("  - postman_collection.json (with example responses)")
+    );
+    console.log(chalk.white("  - local_environment.postman_environment.json"));
+    console.log(
+      chalk.white("  - production_environment.postman_environment.json")
+    );
+    console.log(chalk.white("  - openapi.json (OpenAPI 3.0 specification)"));
+    console.log(
+      chalk.white("  - api-docs.html (Swagger UI - open in browser)")
+    );
+    console.log(
+      chalk.white("  - API_DOCUMENTATION.md (markdown documentation)")
+    );
+    console.log(chalk.white("  - tests/auto/*.test.ts (automated test files)"));
+    console.log(
+      chalk.white("  - .aitesting/report.json (live test results)\n")
+    );
+    console.log(
+      chalk.blue(
+        "\n💡 Tip: Open api-docs.html in your browser to view interactive Swagger UI!"
+      )
+    );
+    console.log(
+      chalk.yellow(
+        "⚠️  Note: Live responses are from REAL HTTP requests to your backend.\n"
+      )
+    );
+  }
+}