@esha_susan/mockingbird-cli 1.0.0

package/README.md

@@ -0,0 +1,293 @@
+# 🐦 Mockingbird CLI
+
+> AI-powered Jest test generator for Express.js backends.
+
+Mockingbird scans your Express.js project, extracts API routes from controller files, and uses Google Gemini AI to automatically generate Jest integration tests — saving hours of manual test writing.
+
+---
+
+## Demo
+
+```bash
+$ mockingbird run ./my-express-project
+
+[INFO] Scanning project at: ./my-express-project
+[INFO]   Found: userController.ts
+[INFO]   Found: authController.ts
+[INFO]   Found: productController.ts
+[SUCCESS] Found 3 controller file(s)
+
+Generating tests with Gemini AI...
+[SUCCESS] Generated 224 lines of test code
+[SUCCESS] Generated 189 lines of test code
+[SUCCESS] Generated 300 lines of test code
+
+Writing test files...
+[SUCCESS] Written: tests/generated/userController.test.ts
+[SUCCESS] Written: tests/generated/authController.test.ts
+[SUCCESS] Written: tests/generated/productController.test.ts
+
+═══════════════════════════════════════════════
+       MOCKINGBIRD GENERATION REPORT
+═══════════════════════════════════════════════
+
+  Controllers scanned     3
+  Routes found            11
+  Tests generated         3
+  Tests written           3
+  Total lines generated   713
+  Time taken              18.45s
+
+  Output files:
+   ✓ tests/generated/userController.test.ts
+   ✓ tests/generated/authController.test.ts
+   ✓ tests/generated/productController.test.ts
+
+═══════════════════════════════════════════════
+```
+
+---
+
+## Features
+
+- 🔍 **Recursive project scanning** — walks your entire project tree to find controller files
+- 🧠 **AI-powered test generation** — uses Google Gemini to write realistic, meaningful Jest tests
+- 📁 **Automatic file writing** — saves generated tests directly to disk, formatted with Prettier
+- 📊 **Generation report** — prints a clean summary of everything generated
+- ⚡ **Zero configuration** — works out of the box with standard Express.js project structures
+- 🎨 **Colored terminal output** — clear, readable logs at every step
+
+---
+
+## Prerequisites
+
+Before using Mockingbird, ensure your machine has:
+
+- **Node.js** v18 or higher
+- **npm** v9 or higher
+- A **Google Gemini API key** — get one free at [aistudio.google.com](https://aistudio.google.com)
+
+Your target Express.js project should have:
+
+- Controller files named with `Controller.ts`, `controller.ts`, `Router.ts`, or `routes.ts`
+- Routes defined using `router.get/post/put/delete/patch(...)` or `app.get/post/...` syntax
+
+---
+
+## Installation
+
+### Option 1 — Install globally from npm (recommended)
+
+```bash
+npm install -g mockingbird-cli
+```
+
+### Option 2 — Clone and run locally
+
+```bash
+git clone https://github.com/yourusername/mockingbird-cli.git
+cd mockingbird-cli
+npm install
+npm run build
+npm link
+```
+
+---
+
+## Configuration
+
+Create a `.env` file in your **Mockingbird** directory (not your target project):
+
+```bash
+GEMINI_API_KEY=your_api_key_here
+```
+
+> ⚠️ Never commit your `.env` file. It is already listed in `.gitignore`.
+
+---
+
+## Usage
+
+### Basic usage
+
+```bash
+mockingbird run <path-to-your-express-project>
+```
+
+### With custom output directory
+
+```bash
+mockingbird run <path-to-your-express-project> --output ./custom-tests
+```
+
+### Examples
+
+```bash
+# Scan a project in the current directory
+mockingbird run .
+
+# Scan a project at a specific path
+mockingbird run ./my-express-api
+
+# Save tests to a custom folder
+mockingbird run ./my-express-api --output ./tests/ai-generated
+```
+
+### Help
+
+```bash
+mockingbird --help
+mockingbird run --help
+```
+
+---
+
+## How It Works
+
+Mockingbird runs a 5-step pipeline:
+
+SCAN      Recursively walks the project directory
+
+1. Finds files matching controller naming patterns
+
+↓
+2. EXTRACT   Reads each controller file
+
+Uses regex to find route definitions
+
+Extracts: HTTP method, path, handler name
+
+↓
+3. GENERATE  Groups routes by controller
+
+Sends route data to Google Gemini AI
+
+Receives Jest + Supertest test code
+
+↓
+4. WRITE     Formats code with Prettier
+
+Creates output directory if needed
+
+Saves .test.ts files to disk
+
+↓
+5. REPORT    Prints a summary of everything generated
+
+Shows file paths, line counts, timing
+
+Each step is a separate module with a single responsibility. If any step fails, the error is caught and reported cleanly — the pipeline continues for other controllers.
+
+---
+
+## Project Structure
+mockingbird-cli/
+
+├── src/
+
+│   ├── index.ts              ← Entry point, loads environment variables
+
+│   ├── cli/
+
+│   │   └── cli.ts            ← Commander.js CLI definition and orchestration
+
+│   ├── scanner/
+
+│   │   └── scanner.ts        ← Recursive directory traversal
+
+│   ├── extractor/
+
+│   │   └── extractor.ts      ← Regex-based route extraction
+
+│   ├── generator/
+
+│   │   └── generator.ts      ← Gemini AI integration
+
+│   ├── writer/
+
+│   │   └── writer.ts         ← File creation and Prettier formatting
+
+│   ├── reporter/
+
+│   │   └── reporter.ts       ← Terminal report generation
+
+│   └── utils/
+
+│       └── logger.ts         ← Colored terminal logging
+
+├── package.json
+
+├── tsconfig.json
+
+└── README.md
+
+---
+
+## Running Tests
+
+Mockingbird has a unit test suite covering its core logic:
+
+```bash
+npm test
+```
+
+Test coverage includes:
+- **Scanner** — controller file detection patterns
+- **Extractor** — regex route parsing across different Express patterns
+- **Writer** — output path generation
+- **Generator** — AI response cleaning and markdown fence removal
+
+---
+
+## Tech Stack
+
+| Technology | Purpose | Why chosen |
+|---|---|---|
+| **TypeScript** | Primary language | Type safety catches bugs at compile time, not runtime |
+| **Node.js** | Runtime | Native file system access, ideal for CLI tooling |
+| **Commander.js** | CLI framework | Industry standard for Node.js CLIs, automatic help generation |
+| **Google Gemini AI** | Test generation | Fast, free tier available, strong code generation capability |
+| **Prettier** | Code formatting | Ensures generated tests are consistently formatted |
+| **Chalk** | Terminal colors | Makes CLI output readable and professional |
+| **Jest** | Test framework | Industry standard for Node.js/TypeScript testing |
+| **dotenv** | Environment config | Keeps API keys out of source code |
+
+---
+
+## Limitations
+
+Mockingbird works best with standard Express.js patterns. The following are known limitations:
+
+- **Regex-based extraction** — routes defined dynamically (inside loops, conditionals, or factory functions) may not be detected
+- **Express.js only** — currently supports Express route syntax (`router.get`, `app.post`, etc.)
+- **Generated tests need a real app** — the generated test files assume your project exports an Express `app` object and has `jest`, `supertest`, and `@types/jest` installed
+- **AI non-determinism** — Gemini may generate slightly different tests on repeated runs for the same routes
+
+### Required dependencies in target project
+
+Before running the generated tests in your Express project:
+
+```bash
+npm install --save-dev jest @types/jest supertest @types/supertest ts-jest
+```
+
+---
+
+## Future Improvements
+
+- [ ] AST-based route extraction for more complex patterns
+- [ ] Support for Fastify, Koa, and Hapi frameworks
+- [ ] Configurable test templates
+- [ ] Watch mode — regenerate tests when controllers change
+- [ ] CI/CD integration guide
+
+---
+
+
+## Author
+
+Built by ESHA SUSAN SHAJI(https://github.com/esha-susan) as a portfolio project demonstrating:
+- CLI tool development with Node.js and TypeScript
+- AI API integration (Google Gemini)
+- Modular software architecture
+- Automated code generation

package/dist/cli/cli.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCLI = runCLI;
+const commander_1 = require("commander");
+const scanner_1 = require("../scanner/scanner");
+const extractor_1 = require("../extractor/extractor");
+const generator_1 = require("../generator/generator");
+const writer_1 = require("../writer/writer");
+const reporter_1 = require("../reporter/reporter");
+const logger_1 = require("../utils/logger");
+function runCLI() {
+    const program = new commander_1.Command();
+    program
+        .name("mockingbird")
+        .description("AI-powered Jest test generator for Express.js APIs")
+        .version("1.0.0");
+    program
+        .command("run")
+        .description("Scan a project and generate Jest tests for its API routes")
+        .argument("<projectPath>", "path to the Express.js project to scan")
+        .option("-o, --output <dir>", "output directory for generated tests", "tests/generated")
+        .action(async (projectPath, options) => {
+        await handleRunCommand(projectPath, options.output);
+    });
+    program.parse(process.argv);
+}
+async function handleRunCommand(projectPath, outputDir) {
+    const startTime = Date.now();
+    try {
+        (0, logger_1.logHeader)("MOCKINGBIRD — AI Test Generator");
+        const scanResult = (0, scanner_1.scanProject)(projectPath);
+        if (scanResult.totalFound === 0) {
+            (0, logger_1.logError)("No controller files found. Nothing to generate.");
+            process.exit(1);
+        }
+        const routes = (0, extractor_1.extractAllRoutes)(scanResult.controllerFiles);
+        if (routes.length === 0) {
+            (0, logger_1.logError)("No routes found in any controller file.");
+            process.exit(1);
+        }
+        console.log("\nGenerating tests with Gemini AI...");
+        const generationResults = await (0, generator_1.generateAllTests)(routes);
+        console.log("\nWriting test files...");
+        const writeResults = await (0, writer_1.writeAllTestFiles)(generationResults, outputDir);
+        const endTime = Date.now();
+        (0, reporter_1.printReport)({
+            scanResult,
+            routes,
+            generationResults,
+            writeResults,
+            startTime,
+            endTime
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error occurred";
+        (0, logger_1.logError)(`Fatal error: ${message}`);
+        process.exit(1);
+    }
+}

package/dist/extractor/extractor.js

@@ -0,0 +1,92 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRoutesFromCode = parseRoutesFromCode;
+exports.extractRoutes = extractRoutes;
+exports.extractAllRoutes = extractAllRoutes;
+const fs = __importStar(require("fs"));
+const logger_1 = require("../utils/logger");
+const ROUTE_PATTERN = /(router|app)\.(get|post|put|delete|patch)\s*\(\s*['"`]([^'"`]+)['"`]\s*,\s*(?:\w+\s*,\s*)*(\w+)\s*\)/gi;
+// Pure function — takes code as a string, returns routes
+// No file system access — easy to test
+function parseRoutesFromCode(code, controllerFile = "unknown") {
+    const routes = [];
+    const matches = code.matchAll(ROUTE_PATTERN);
+    for (const match of matches) {
+        routes.push({
+            method: match[2].toUpperCase(),
+            path: match[3],
+            handler: match[4],
+            controllerFile
+        });
+    }
+    return routes;
+}
+function extractRoutes(controllerFilePath) {
+    let fileContent;
+    try {
+        fileContent = fs.readFileSync(controllerFilePath, "utf-8");
+    }
+    catch (error) {
+        (0, logger_1.logError)(`Couldn't read file" ${controllerFilePath}`);
+        return {
+            routes: [],
+            totalFound: 0,
+            controllerFile: controllerFilePath
+        };
+    }
+    (0, logger_1.logInfo)(`Extracting routes from ${controllerFilePath}`);
+    // Use the pure function for the actual parsing
+    const routes = parseRoutesFromCode(fileContent, controllerFilePath);
+    routes.forEach(route => {
+        (0, logger_1.logInfo)(`  ${route.method} ${route.path} → ${route.handler}`);
+    });
+    if (routes.length == 0) {
+        (0, logger_1.logWarning)(`  No routes found in: ${controllerFilePath}`);
+    }
+    return {
+        routes,
+        totalFound: routes.length,
+        controllerFile: controllerFilePath
+    };
+}
+function extractAllRoutes(controllerFiles) {
+    const allRoutes = [];
+    for (const filePath of controllerFiles) {
+        const result = extractRoutes(filePath);
+        allRoutes.push(...result.routes);
+    }
+    return allRoutes;
+}

package/dist/generator/generator.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTests = generateTests;
+exports.generateAllTests = generateAllTests;
+exports.cleanGeneratedCode = cleanGeneratedCode;
+const generative_ai_1 = require("@google/generative-ai");
+const logger_1 = require("../utils/logger");
+// Initialize the Gemini client once at module level
+function createGeminiClient() {
+    const apiKey = process.env.GEMINI_API_KEY;
+    if (!apiKey) {
+        throw new Error("GEMINI_API_KEY is not set. Please add it to your .env file.");
+    }
+    return new generative_ai_1.GoogleGenerativeAI(apiKey);
+}
+function buildPrompt(routes, controllerName) {
+    const routeDescriptions = routes
+        .map(r => `  - ${r.method} ${r.path} (handler: ${r.handler})`)
+        .join("\n");
+    return `You are an expert Node.js testing engineer.
+
+Generate Jest integration tests for the following Express.js API routes from the "${controllerName}" controller:
+
+${routeDescriptions}
+
+Requirements:
+1. Use Jest as the testing framework
+2. Use supertest for HTTP assertions
+3. Import the Express app as: import app from "../app"
+4. Each route must have at least:
+   - One test for successful response (2xx status)
+   - One test for error/edge case
+5. Use describe blocks to group tests by route
+6. Use clear, descriptive test names
+7. Include realistic request bodies for POST/PUT routes
+8. Test for correct status codes and response structure
+
+Return ONLY the TypeScript test code. No explanations. No markdown code blocks. Just the raw TypeScript code starting with import statements.`;
+}
+function getControllerName(filePath) {
+    const fileName = filePath.split("/").pop() || filePath;
+    return fileName.replace(".ts", "").replace(".js", "");
+}
+async function generateTests(routes, controllerFile) {
+    if (routes.length === 0) {
+        (0, logger_1.logWarning)(`No routes to generate tests for: ${controllerFile}`);
+        return {
+            testCode: "",
+            controllerFile,
+            routeCount: 0,
+            success: false
+        };
+    }
+    const controllerName = getControllerName(controllerFile);
+    (0, logger_1.logInfo)(`Generating tests for: ${controllerName} (${routes.length} routes)`);
+    try {
+        const genAI = createGeminiClient();
+        const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
+        const prompt = buildPrompt(routes, controllerName);
+        // Step 3 — call Gemini
+        (0, logger_1.logInfo)("  Calling Gemini AI...");
+        const result = await model.generateContent(prompt);
+        const response = result.response;
+        let testCode = response.text();
+        // Step 4 — clean the response
+        // Sometimes AI wraps code in markdown blocks despite instructions
+        testCode = cleanGeneratedCode(testCode);
+        if (!testCode || testCode.trim().length === 0) {
+            throw new Error("Gemini returned empty response");
+        }
+        (0, logger_1.logSuccess)(`  Generated ${testCode.split("\n").length} lines of test code`);
+        return {
+            testCode,
+            controllerFile,
+            routeCount: routes.length,
+            success: true
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        (0, logger_1.logError)(`  Failed to generate tests: ${message}`);
+        return {
+            testCode: "",
+            controllerFile,
+            routeCount: routes.length,
+            success: false
+        };
+    }
+}
+async function generateAllTests(routes) {
+    const routesByController = groupRoutesByController(routes);
+    const results = [];
+    for (const [controllerFile, controllerRoutes] of routesByController) {
+        const result = await generateTests(controllerRoutes, controllerFile);
+        results.push(result);
+        // Small delay between API calls to avoid rate limiting
+        await delay(500);
+    }
+    return results;
+}
+function groupRoutesByController(routes) {
+    const grouped = new Map();
+    for (const route of routes) {
+        const existing = grouped.get(route.controllerFile) || [];
+        existing.push(route);
+        grouped.set(route.controllerFile, existing);
+    }
+    return grouped;
+}
+// Removes markdown code fences AI sometimes adds despite instructions
+function cleanGeneratedCode(code) {
+    return code
+        .replace(/```typescript/gi, "")
+        .replace(/```ts/gi, "")
+        .replace(/```/g, "")
+        .trim();
+}
+// Simple delay utility
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/dist/index.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+const cli_1 = require("./cli/cli");
+(0, cli_1.runCLI)();

package/dist/reporter/reporter.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printReport = printReport;
+const chalk_1 = __importDefault(require("chalk"));
+function printReport(data) {
+    const { scanResult, routes, generationResults, writeResults, startTime, endTime } = data;
+    const durationSeconds = ((endTime - startTime) / 1000).toFixed(2);
+    const successfulGenerations = generationResults.filter(r => r.success);
+    const successfulWrites = writeResults.filter(w => w.success);
+    const totalLines = writeResults.reduce((sum, w) => sum + w.linesWritten, 0);
+    const divider = "═".repeat(45);
+    console.log("\n" + chalk_1.default.bold.magenta(divider));
+    console.log(chalk_1.default.bold.magenta("       MOCKINGBIRD GENERATION REPORT"));
+    console.log(chalk_1.default.bold.magenta(divider) + "\n");
+    printStat("Controllers scanned", scanResult.totalFound);
+    printStat("Routes found", routes.length);
+    printStat("Tests generated", successfulGenerations.length);
+    printStat("Tests written", successfulWrites.length);
+    printStat("Total lines generated", totalLines);
+    printStat("Time taken", `${durationSeconds}s`);
+    console.log("\n  " + chalk_1.default.bold("Output files:"));
+    writeResults.forEach(result => {
+        if (result.success) {
+            console.log(`   ${chalk_1.default.green("✓")} ${result.outputPath}`);
+        }
+        else {
+            console.log(`   ${chalk_1.default.red("✗")} ${result.controllerFile} (failed)`);
+        }
+    });
+    console.log("\n" + chalk_1.default.bold.magenta(divider) + "\n");
+    const failedCount = generationResults.length - successfulGenerations.length;
+    if (failedCount > 0) {
+        console.log(chalk_1.default.yellow(`⚠ ${failedCount} controller(s) failed to generate tests. Check logs above for details.\n`));
+    }
+}
+function printStat(label, value) {
+    const paddedLabel = label.padEnd(24);
+    console.log(`  ${paddedLabel} ${chalk_1.default.cyan(String(value))}`);
+}

package/dist/scanner/scanner.js

@@ -0,0 +1,103 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanProject = scanProject;
+exports.isControllerFile = isControllerFile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_1 = require("../utils/logger");
+const CONTROLLER_PATTERNS = [
+    "controller.ts",
+    "Controller.ts",
+    "router.ts",
+    "Router.ts",
+    "routes.ts",
+    "Routes.ts"
+];
+const IGNORED_DIRECTORIES = [
+    "node_modules",
+    "dist",
+    ".git",
+    "coverage",
+    "build"
+];
+function scanProject(projectPath) {
+    const absolutePath = path.resolve(projectPath);
+    if (!fs.existsSync(absolutePath)) {
+        (0, logger_1.logWarning)(`Directory not found: ${absolutePath}`);
+        return {
+            controllerFiles: [],
+            totalFound: 0,
+            scannedDirectory: absolutePath
+        };
+    }
+    (0, logger_1.logInfo)(`Scanning project at ${absolutePath}`);
+    const controllerFiles = [];
+    walkDirectory(absolutePath, controllerFiles);
+    (0, logger_1.logSuccess)(`Found ${controllerFiles.length} controller file(s)`);
+    return {
+        controllerFiles,
+        totalFound: controllerFiles.length,
+        scannedDirectory: absolutePath
+    };
+}
+function walkDirectory(currentPath, results) {
+    let entries;
+    try {
+        entries = fs.readdirSync(currentPath, { withFileTypes: true });
+    }
+    catch (error) {
+        (0, logger_1.logError)(`Couldn't read directory: ${currentPath}`);
+        return;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(currentPath, entry.name);
+        if (entry.isDirectory()) {
+            if (IGNORED_DIRECTORIES.includes(entry.name)) {
+                continue;
+            }
+            walkDirectory(fullPath, results);
+        }
+        else if (entry.isFile()) {
+            if (isControllerFile(entry.name)) {
+                results.push(fullPath);
+                (0, logger_1.logInfo)(` Found:${entry.name}`);
+            }
+        }
+    }
+}
+function isControllerFile(fileName) {
+    return CONTROLLER_PATTERNS.some(pattern => fileName.toLowerCase().endsWith(pattern.toLocaleLowerCase()));
+}

package/dist/utils/logger.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logInfo = logInfo;
+exports.logError = logError;
+exports.logSuccess = logSuccess;
+exports.logWarning = logWarning;
+exports.logHeader = logHeader;
+const chalk_1 = __importDefault(require("chalk"));
+function logInfo(message) {
+    console.log(chalk_1.default.cyan("[INFO]"), message);
+}
+function logError(message) {
+    console.log(chalk_1.default.red("[ERROR]"), message);
+}
+function logSuccess(message) {
+    console.log(chalk_1.default.green("[SUCCESS]"), message);
+}
+function logWarning(message) {
+    console.log(chalk_1.default.yellow("[WARNING]"), message);
+}
+function logHeader(message) {
+    console.log(chalk_1.default.magenta("\n" + message));
+}

package/dist/writer/writer.js

@@ -0,0 +1,116 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeTestFile = writeTestFile;
+exports.writeAllTestFiles = writeAllTestFiles;
+exports.buildOutputPath = buildOutputPath;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const prettier = __importStar(require("prettier"));
+const logger_1 = require("../utils/logger");
+const DEFAULT_OUTPUT_DIR = "tests/generated";
+async function writeTestFile(generationResult, outputDir = DEFAULT_OUTPUT_DIR) {
+    if (!generationResult.success || !generationResult.testCode) {
+        (0, logger_1.logWarning)(`Skipping write — no test code for: ${generationResult.controllerFile}`);
+        return {
+            success: false,
+            outputPath: "",
+            controllerFile: generationResult.controllerFile,
+            linesWritten: 0
+        };
+    }
+    const outputPath = buildOutputPath(generationResult.controllerFile, outputDir);
+    try {
+        ensureDirectoryExists(path.dirname(outputPath));
+        const formattedCode = await formatCode(generationResult.testCode);
+        fs.writeFileSync(outputPath, formattedCode, "utf-8");
+        const linesWritten = formattedCode.split("\n").length;
+        (0, logger_1.logSuccess)(`Written: ${outputPath} (${linesWritten} lines)`);
+        return {
+            success: true,
+            outputPath,
+            controllerFile: generationResult.controllerFile,
+            linesWritten
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        (0, logger_1.logError)(`Failed to write file: ${message}`);
+        return {
+            success: false,
+            outputPath,
+            controllerFile: generationResult.controllerFile,
+            linesWritten: 0
+        };
+    }
+}
+async function writeAllTestFiles(generationResults, outputDir = DEFAULT_OUTPUT_DIR) {
+    (0, logger_1.logInfo)(`Writing test files to: ${outputDir}`);
+    const writeResults = [];
+    for (const result of generationResults) {
+        const writeResult = await writeTestFile(result, outputDir);
+        writeResults.push(writeResult);
+    }
+    return writeResults;
+}
+function buildOutputPath(controllerFilePath, outputDir) {
+    const fileName = path.basename(controllerFilePath);
+    const baseName = fileName.replace(".ts", "").replace(".js", "");
+    const testFileName = `${baseName}.test.ts`;
+    return path.join(outputDir, testFileName);
+}
+function ensureDirectoryExists(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+        (0, logger_1.logInfo)(`Created directory: ${dirPath}`);
+    }
+}
+async function formatCode(code) {
+    try {
+        const formatted = await prettier.format(code, {
+            parser: "typescript",
+            semi: true,
+            singleQuote: true,
+            tabWidth: 2,
+            trailingComma: "es5",
+            printWidth: 80
+        });
+        return formatted;
+    }
+    catch (error) {
+        (0, logger_1.logWarning)("Prettier formatting failed — saving unformatted code");
+        return code;
+    }
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@esha_susan/mockingbird-cli",
+  "version": "1.0.0",
+  "description": "AI-powered test generation CLI for Express.js backends",
+  "main": "dist/index.js",
+  "bin": {
+    "mockingbird": "dist/index.js"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts",
+    "watch": "nodemon --exec ts-node src/index.ts",
+    "test": "jest"
+  },
+  "keywords": [
+    "cli",
+    "testing",
+    "ai",
+    "express",
+    "jest"
+  ],
+  "author": "Esha Susan",
+  "license": "MIT",
+  "dependencies": {
+    "@google/generative-ai": "^0.24.1",
+    "chalk": "^4.1.2",
+    "commander": "^15.0.0",
+    "dotenv": "^17.4.2",
+    "prettier": "^3.8.3"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.9.1",
+    "jest": "^30.4.2",
+    "nodemon": "^3.1.14",
+    "ts-jest": "^29.4.11",
+    "ts-node": "^10.9.2",
+    "typescript": "^6.0.3"
+  }
+}