@testspectra/cli 1.0.0

package/src/runner/reporter.ts

@@ -0,0 +1,64 @@
+export interface TestLog {
+  timestamp: string;
+  level: "INFO" | "SUCCESS" | "WARNING" | "ERROR" | "DEBUG" | string;
+  message: string;
+}
+
+export interface NetworkResource {
+  requestId: string;
+  url: string;
+  method: string;
+  status: number;
+}
+
+export interface TestRunResult {
+  status: "passed" | "failed" | "error" | string;
+  duration: string;
+  logs: TestLog[];
+  networkResources?: NetworkResource[];
+}
+
+export class Reporter {
+  private logs: TestLog[] = [];
+  private networkEvents: NetworkResource[] = [];
+
+  addLog(log: TestLog) {
+    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: NetworkResource) {
+    this.networkEvents.push(res);
+  }
+
+  getLogs(): TestLog[] {
+    return this.logs;
+  }
+
+  getNetworkEvents(): NetworkResource[] {
+    return this.networkEvents;
+  }
+
+  generateResult(status: string, duration: string): TestRunResult {
+    return {
+      status,
+      duration,
+      logs: this.logs,
+      networkResources: this.networkEvents,
+    };
+  }
+}

package/src/types/generator.ts

@@ -0,0 +1,202 @@
+import fs from "fs";
+import path from "path";
+
+export type PlatformTarget = "web" | "android" | "ios" | "mobile" | "common";
+
+const PLATFORM_HIERARCHY: Record<PlatformTarget, string[]> = {
+  web: ["web", "common"],
+  ios: ["ios", "mobile", "common"],
+  android: ["android", "mobile", "common"],
+  mobile: ["mobile", "common"],
+  common: ["common"],
+};
+
+export class TypeGenerator {
+  static getPageObjectsDir(cwd: string): string {
+    const p1 = path.join(cwd, "page-objects");
+    if (fs.existsSync(p1)) return p1;
+    return path.join(cwd, "pageobjects");
+  }
+
+  static generateAmbientDeclarations(cwd: string): Record<string, string> {
+    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: PlatformTarget[] = ["web", "android", "ios", "mobile", "common"];
+    const results: Record<string, string> = {};
+
+    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: string | null = 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: string | null = 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: string | null = 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: string): string {
+    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: string): void {
+    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/src/types/webdriverio.d.ts

@@ -0,0 +1,46 @@
+declare global {
+  namespace WebdriverIO {
+    export interface InterceptFixtureOptions {
+      statusCode?: number;
+      headers?: Record<string, string>;
+    }
+
+    export interface InterceptFixtureObject<TData = unknown> {
+      statusCode?: number;
+      body: TData;
+      headers?: Record<string, string>;
+    }
+
+    export type InterceptInput<TData = unknown> =
+      | InterceptFixtureObject<TData>
+      | TData
+      | string;
+
+    interface Mock {
+      /**
+       * Dynamically set or change the fixture response for this mock instance.
+       * Supports Fixture paths, `{ statusCode, body, headers }` objects, or raw payloads.
+       */
+      respondWith<TData = unknown>(
+        fixture: InterceptInput<TData>,
+        options?: InterceptFixtureOptions,
+      ): Promise<void>;
+    }
+
+    interface Browser {
+      /**
+       * Clean & strongly-typed API interceptor for WebdriverIO.
+       * Automatically resolves relative path against browser.options.baseUrl.
+       * Integrated directly with TestSpectra Fixtures.
+       */
+      intercept<TData = unknown>(
+        path: string,
+        method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH',
+        fixture?: InterceptInput<TData>,
+        options?: InterceptFixtureOptions,
+      ): Promise<Mock>;
+    }
+  }
+}
+
+export {};

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}