@testspectra/cli 1.0.0

package/dist/runner/reporter.js

@@ -0,0 +1,42 @@
+export class Reporter {
+    logs = [];
+    networkEvents = [];
+    addLog(log) {
+        this.logs.push(log);
+        const time = `\x1b[90m${log.timestamp}\x1b[0m`;
+        let prefix = `[${log.level}]`;
+        if (log.level === "SUCCESS" || log.level === "PASSED") {
+            prefix = `\x1b[32m${prefix}\x1b[0m`;
+        }
+        else if (log.level === "ERROR" || log.level === "FAILED") {
+            prefix = `\x1b[31m${prefix}\x1b[0m`;
+        }
+        else if (log.level === "WARN" || log.level === "WARNING") {
+            prefix = `\x1b[33m${prefix}\x1b[0m`;
+        }
+        else if (log.level === "INFO") {
+            prefix = `\x1b[36m${prefix}\x1b[0m`;
+        }
+        else {
+            prefix = `\x1b[90m${prefix}\x1b[0m`;
+        }
+        console.log(`${time} ${prefix} ${log.message}`);
+    }
+    addNetwork(res) {
+        this.networkEvents.push(res);
+    }
+    getLogs() {
+        return this.logs;
+    }
+    getNetworkEvents() {
+        return this.networkEvents;
+    }
+    generateResult(status, duration) {
+        return {
+            status,
+            duration,
+            logs: this.logs,
+            networkResources: this.networkEvents,
+        };
+    }
+}

package/dist/types/generator.d.ts

@@ -0,0 +1,7 @@
+export type PlatformTarget = "web" | "android" | "ios" | "mobile" | "common";
+export declare class TypeGenerator {
+    static getPageObjectsDir(cwd: string): string;
+    static generateAmbientDeclarations(cwd: string): Record<string, string>;
+    static generateFixturesDeclaration(cwd: string): string;
+    static writeDeclarationFiles(cwd: string): void;
+}

package/dist/types/generator.js

@@ -0,0 +1,195 @@
+import fs from "fs";
+import path from "path";
+const PLATFORM_HIERARCHY = {
+    web: ["web", "common"],
+    ios: ["ios", "mobile", "common"],
+    android: ["android", "mobile", "common"],
+    mobile: ["mobile", "common"],
+    common: ["common"],
+};
+export class TypeGenerator {
+    static getPageObjectsDir(cwd) {
+        const p1 = path.join(cwd, "page-objects");
+        if (fs.existsSync(p1))
+            return p1;
+        return path.join(cwd, "pageobjects");
+    }
+    static generateAmbientDeclarations(cwd) {
+        const poDir = this.getPageObjectsDir(cwd);
+        const actionsDir = path.join(cwd, "actions");
+        const stepsDir = path.join(cwd, "steps");
+        const fixturesDir = path.join(cwd, "fixtures");
+        const platforms = ["web", "android", "ios", "mobile", "common"];
+        const results = {};
+        for (const platform of platforms) {
+            const hierarchy = PLATFORM_HIERARCHY[platform];
+            let content = `// Auto-generated ambient declarations for TestSpectra [${platform.toUpperCase()}]\n`;
+            content += `// Do not edit manually. Run 'spectra watch' or let the Language Service manage this.\n\n`;
+            content += `/// <reference types="@wdio/globals/types" />\n`;
+            content += `/// <reference types="@wdio/mocha-framework" />\n`;
+            content += `/// <reference path="./fixtures.d.ts" />\n\n`;
+            content += `declare namespace WebdriverIO {\n`;
+            content += `  export interface InterceptFixtureOptions {\n`;
+            content += `    statusCode?: number;\n`;
+            content += `    headers?: Record<string, string>;\n`;
+            content += `  }\n`;
+            content += `  export interface InterceptFixtureObject<TData = unknown> {\n`;
+            content += `    statusCode?: number;\n`;
+            content += `    body: TData;\n`;
+            content += `    headers?: Record<string, string>;\n`;
+            content += `  }\n`;
+            content += `  export type InterceptInput<TData = unknown> = InterceptFixtureObject<TData> | TData | string;\n`;
+            content += `  interface Mock {\n`;
+            content += `    respondWith<TData = unknown>(fixture: InterceptInput<TData>, options?: InterceptFixtureOptions): Promise<void>;\n`;
+            content += `  }\n`;
+            content += `  interface Browser {\n`;
+            content += `    intercept<TData = unknown>(path: string, method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH', fixture?: InterceptInput<TData>, options?: InterceptFixtureOptions): Promise<Mock>;\n`;
+            content += `  }\n`;
+            content += `}\n\n`;
+            // 1. Page Objects Global Declarations (Hierarchical)
+            // 2. Page Objects Global Declarations (Hierarchical)
+            if (fs.existsSync(poDir)) {
+                const poEntries = fs.readdirSync(poDir, { withFileTypes: true });
+                for (const entry of poEntries) {
+                    if (entry.name.startsWith("."))
+                        continue;
+                    if (entry.isDirectory()) {
+                        const className = entry.name;
+                        const classFolder = path.join(poDir, className);
+                        // Search hierarchy
+                        let matchedFile = null;
+                        for (const stem of hierarchy) {
+                            const cand = path.join(classFolder, `${stem}.ts`);
+                            if (fs.existsSync(cand)) {
+                                matchedFile = `../../page-objects/${className}/${stem}.js`;
+                                break;
+                            }
+                        }
+                        if (matchedFile) {
+                            content += `declare const ${className}: typeof import('${matchedFile}').default;\n`;
+                        }
+                    }
+                    else if (entry.isFile() && entry.name.endsWith(".ts")) {
+                        const className = entry.name.split(".")[0];
+                        content += `declare const ${className}: typeof import('../../page-objects/${entry.name.replace(".ts", ".js")}').default;\n`;
+                    }
+                }
+            }
+            // 3. Actions Global Interface
+            content += `\ninterface TestSpectraActions {\n`;
+            if (fs.existsSync(actionsDir)) {
+                const actionEntries = fs.readdirSync(actionsDir, { withFileTypes: true });
+                for (const entry of actionEntries) {
+                    if (entry.name.startsWith("."))
+                        continue;
+                    if (entry.isDirectory()) {
+                        const actionName = entry.name;
+                        const actionFolder = path.join(actionsDir, actionName);
+                        let matchedFile = null;
+                        for (const stem of hierarchy) {
+                            const cand1 = path.join(actionFolder, `${stem}.action.ts`);
+                            const cand2 = path.join(actionFolder, `${stem}.ts`);
+                            if (fs.existsSync(cand1)) {
+                                matchedFile = `../../actions/${actionName}/${stem}.action.js`;
+                                break;
+                            }
+                            else if (fs.existsSync(cand2)) {
+                                matchedFile = `../../actions/${actionName}/${stem}.js`;
+                                break;
+                            }
+                        }
+                        if (matchedFile) {
+                            content += `  ${actionName}: typeof import('${matchedFile}');\n`;
+                        }
+                        else {
+                            content += `  ${actionName}: (...args: any[]) => Promise<any>;\n`;
+                        }
+                    }
+                    else if (entry.isFile() && entry.name.endsWith(".ts")) {
+                        const actionName = entry.name.split(".")[0];
+                        content += `  ${actionName}: typeof import('../../actions/${entry.name.replace(".ts", ".js")}');\n`;
+                    }
+                }
+            }
+            content += `}\n`;
+            content += `declare const Spectra: TestSpectraActions;\n\n`;
+            // 4. Shared Steps Global Interface
+            content += `interface TestSpectraSteps {\n`;
+            if (fs.existsSync(stepsDir)) {
+                const stepEntries = fs.readdirSync(stepsDir, { withFileTypes: true });
+                for (const entry of stepEntries) {
+                    if (entry.name.startsWith("."))
+                        continue;
+                    if (entry.isDirectory()) {
+                        const stepName = entry.name;
+                        const stepFolder = path.join(stepsDir, stepName);
+                        let matchedFile = null;
+                        for (const stem of hierarchy) {
+                            const cand1 = path.join(stepFolder, `${stem}.step.ts`);
+                            const cand2 = path.join(stepFolder, `${stem}.ts`);
+                            if (fs.existsSync(cand1)) {
+                                matchedFile = `../../steps/${stepName}/${stem}.step.js`;
+                                break;
+                            }
+                            else if (fs.existsSync(cand2)) {
+                                matchedFile = `../../steps/${stepName}/${stem}.js`;
+                                break;
+                            }
+                        }
+                        if (matchedFile) {
+                            content += `  ${stepName}: typeof import('${matchedFile}');\n`;
+                        }
+                        else {
+                            content += `  ${stepName}: (...args: any[]) => Promise<any>;\n`;
+                        }
+                    }
+                    else if (entry.isFile() && entry.name.endsWith(".ts")) {
+                        const stepName = entry.name.split(".")[0];
+                        content += `  ${stepName}: typeof import('../../steps/${entry.name.replace(".ts", ".js")}');\n`;
+                    }
+                }
+            }
+            content += `}\n`;
+            content += `declare const Step: TestSpectraSteps;\n\n`;
+            results[platform] = content;
+        }
+        return results;
+    }
+    static generateFixturesDeclaration(cwd) {
+        const fixturesDir = path.join(cwd, "fixtures");
+        let content = `// Auto-generated ambient fixture declarations for TestSpectra\n`;
+        content += `// Do not edit manually. Run 'spectra watch' or let the Language Service manage this.\n\n`;
+        content += `interface TestSpectraFixtures {\n`;
+        if (fs.existsSync(fixturesDir)) {
+            const fixtureFiles = fs.readdirSync(fixturesDir);
+            for (const file of fixtureFiles) {
+                if (file.startsWith("."))
+                    continue;
+                const parsed = path.parse(file);
+                const varName = parsed.name.replace(/[^a-zA-Z0-9_$]/g, "_");
+                content += `  readonly ${varName}: string;\n`;
+            }
+        }
+        content += `}\n`;
+        content += `declare const Fixture: TestSpectraFixtures;\n`;
+        return content;
+    }
+    static writeDeclarationFiles(cwd) {
+        const typesDir = path.join(cwd, ".testspectra", "types");
+        if (!fs.existsSync(typesDir)) {
+            fs.mkdirSync(typesDir, { recursive: true });
+        }
+        // 1. Write single platform-agnostic fixtures.d.ts
+        const fixturesContent = this.generateFixturesDeclaration(cwd);
+        fs.writeFileSync(path.join(typesDir, "fixtures.d.ts"), fixturesContent, "utf-8");
+        // 2. Write per-platform ambient types
+        const declarations = this.generateAmbientDeclarations(cwd);
+        for (const [platform, content] of Object.entries(declarations)) {
+            const filePath = path.join(typesDir, `${platform}.d.ts`);
+            fs.writeFileSync(filePath, content, "utf-8");
+        }
+        // Also write a universal ambient index
+        const universalPath = path.join(typesDir, "index.d.ts");
+        fs.writeFileSync(universalPath, `/// <reference path="./common.d.ts" />\n`, "utf-8");
+    }
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@testspectra/cli",
+  "version": "1.0.0",
+  "description": "TestSpectra Zero-Config Cross-Platform Test Runner CLI",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "spectra": "./bin/spectra.js",
+    "testspectra": "./bin/spectra.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc -w",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "chokidar": "^3.6.0",
+    "commander": "^12.1.0",
+    "dotenv": "^16.4.5",
+    "inquirer": "^9.3.2",
+    "ora": "^8.0.1",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.14.0",
+    "typescript": "^5.4.5"
+  },
+  "type": "module",
+  "license": "MIT"
+}

package/src/commands/devices.ts

@@ -0,0 +1,41 @@
+import { execSync } from "child_process";
+
+export async function devicesCommand(options: { target?: "android" | "ios" | "web" | "all" }) {
+  const target = options.target || "all";
+  console.log(`\x1b[36m[TestSpectra Devices]\x1b[0m Listing connected test targets (scope: ${target})...\n`);
+
+  if (target === "all" || target === "android") {
+    console.log("\x1b[1mAndroid Devices (ADB):\x1b[0m");
+    try {
+      const adbOutput = execSync("adb devices -l", { stdio: "pipe" }).toString();
+      const lines = adbOutput.split("\n").slice(1);
+      let found = false;
+      for (const line of lines) {
+        if (line.trim()) {
+          found = true;
+          console.log(`  \x1b[32m•\x1b[0m ${line.trim()}`);
+        }
+      }
+      if (!found) {
+        console.log("  \x1b[90mNo Android devices/emulators connected via ADB.\x1b[0m");
+      }
+    } catch {
+      console.log("  \x1b[31mADB command failed or platform-tools not in PATH.\x1b[0m");
+    }
+  }
+
+  if (target === "all" || target === "web") {
+    console.log("\n\x1b[1mWeb Browsers:\x1b[0m");
+    try {
+      const chromeVer = execSync(
+        process.platform === "darwin"
+          ? '"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --version'
+          : "google-chrome --version",
+        { stdio: "pipe" }
+      ).toString().trim();
+      console.log(`  \x1b[32m•\x1b[0m Chrome: ${chromeVer}`);
+    } catch {
+      console.log("  \x1b[90m• Chrome: Not installed\x1b[0m");
+    }
+  }
+}

package/src/commands/doctor.ts

@@ -0,0 +1,57 @@
+import { execSync } from "child_process";
+
+export async function doctorCommand(options: { fix?: boolean }) {
+  console.log("\x1b[36m[TestSpectra Doctor]\x1b[0m Checking development and runtime dependencies...\n");
+
+  const checks = [
+    {
+      name: "Node.js",
+      command: "node -v",
+      required: true,
+    },
+    {
+      name: "Bun",
+      command: "bun -v",
+      required: false,
+    },
+    {
+      name: "ADB (Android Debug Bridge)",
+      command: "adb version",
+      required: false,
+    },
+    {
+      name: "Java JDK",
+      command: "java -version",
+      required: false,
+    },
+    {
+      name: "Google Chrome",
+      command: process.platform === "darwin"
+        ? '"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --version'
+        : "google-chrome --version",
+      required: false,
+    },
+  ];
+
+  let missingCount = 0;
+
+  for (const check of checks) {
+    try {
+      const out = execSync(check.command, { stdio: "pipe" }).toString().trim();
+      const firstLine = out.split("\n")[0];
+      console.log(` \x1b[32m✓\x1b[0m ${check.name.padEnd(30)} \x1b[90m(${firstLine})\x1b[0m`);
+    } catch {
+      console.log(` \x1b[31m✗\x1b[0m ${check.name.padEnd(30)} \x1b[31m(Not found)\x1b[0m`);
+      if (check.required) {
+        missingCount++;
+      }
+    }
+  }
+
+  console.log("\n------------------------------------------------------------");
+  if (missingCount === 0) {
+    console.log("\x1b[32m[Doctor]\x1b[0m System ready for local test execution!");
+  } else {
+    console.log(`\x1b[33m[Doctor]\x1b[0m Found ${missingCount} missing required dependencies.`);
+  }
+}