testeranto 0.203.0 → 0.206.0

package/src/services/GitHubAuthService.ts

@@ -1,240 +0,0 @@
-interface GitHubUser {
-  login: string;
-  id: number;
-  avatar_url: string;
-  name: string;
-  email: string;
-}
-
-type EventListener = (...args: any[]) => void;
-
-export class GitHubAuthService {
-  private static get CLIENT_ID(): string | undefined {
-    // Read from the global configuration
-    if (
-      typeof window !== "undefined" &&
-      (window as any).testerantoConfig?.githubOAuth?.clientId
-    ) {
-      return (window as any).testerantoConfig.githubOAuth.clientId;
-    }
-    console.log("GitHub OAuth client ID not found in configuration");
-    return undefined;
-  }
-  private static readonly REDIRECT_URI = `${window.location.origin}/auth/github/callback`;
-  private static readonly SCOPE = "repo user";
-
-  private accessToken: string | null = null;
-  private user: GitHubUser | null = null;
-  private listeners: Map<string, EventListener[]> = new Map();
-
-  constructor() {
-    this.loadStoredAuth();
-  }
-
-  on(event: string, listener: EventListener) {
-    if (!this.listeners.has(event)) {
-      this.listeners.set(event, []);
-    }
-    this.listeners.get(event)!.push(listener);
-  }
-
-  off(event: string, listener: EventListener) {
-    const eventListeners = this.listeners.get(event);
-    if (eventListeners) {
-      const index = eventListeners.indexOf(listener);
-      if (index > -1) {
-        eventListeners.splice(index, 1);
-      }
-    }
-  }
-
-  emit(event: string, ...args: any[]) {
-    const eventListeners = this.listeners.get(event);
-    if (eventListeners) {
-      eventListeners.forEach((listener) => {
-        try {
-          listener(...args);
-        } catch (error) {
-          console.error(`Error in event listener for ${event}:`, error);
-        }
-      });
-    }
-  }
-
-  private loadStoredAuth() {
-    const token = localStorage.getItem("github_access_token");
-    const userStr = localStorage.getItem("github_user");
-
-    if (token) {
-      this.accessToken = token;
-    }
-
-    if (userStr) {
-      this.user = JSON.parse(userStr);
-    }
-  }
-
-  get isAuthenticated(): boolean {
-    return !!this.accessToken;
-  }
-
-  get userInfo(): GitHubUser | null {
-    return this.user;
-  }
-
-  get token(): string | null {
-    return this.accessToken;
-  }
-
-  initiateLogin() {
-    const clientId = GitHubAuthService.CLIENT_ID;
-    console.log("Initiating login with CLIENT_ID:", clientId);
-
-    if (!clientId) {
-      console.error(
-        "GitHub OAuth client ID is not configured. Please set GITHUB_CLIENT_ID environment variable."
-      );
-
-      // Provide helpful instructions for setup
-      const setupInstructions = `
-GitHub authentication is not configured.
-
-To set up GitHub OAuth:
-
-1. Go to https://github.com/settings/developers
-2. Create a new OAuth App
-3. Set Authorization callback URL to: ${GitHubAuthService.REDIRECT_URI}
-4. Add GITHUB_CLIENT_ID to your environment variables
-5. Restart the development server
-
-For development, you can create a .env file in the root directory with:
-GITHUB_CLIENT_ID=your_client_id_here
-
-Current environment analysis:
-- process.env.GITHUB_CLIENT_ID: ${
-        typeof process !== "undefined"
-          ? process.env?.GITHUB_CLIENT_ID || "undefined"
-          : "process undefined"
-      }
-- window.env.GITHUB_CLIENT_ID: ${
-        typeof window !== "undefined"
-          ? (window as any).env?.GITHUB_CLIENT_ID || "undefined"
-          : "window undefined"
-      }
-      `;
-
-      alert(setupInstructions);
-      return;
-    }
-    const authUrl = `https://github.com/login/oauth/authorize?client_id=${clientId}&redirect_uri=${encodeURIComponent(
-      GitHubAuthService.REDIRECT_URI
-    )}&scope=${encodeURIComponent(GitHubAuthService.SCOPE)}`;
-    console.log("Opening auth popup:", authUrl);
-    
-    // Open in a popup window
-    const width = 600;
-    const height = 700;
-    const left = (window.screen.width - width) / 2;
-    const top = (window.screen.height - height) / 2;
-    
-    window.open(
-      authUrl,
-      'github-auth',
-      `width=${width},height=${height},left=${left},top=${top},resizable=yes,scrollbars=yes,status=yes`
-    );
-  }
-
-  async handleCallback(code: string): Promise<boolean> {
-    try {
-      const response = await fetch("/api/auth/github/token", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({ code }),
-      });
-
-      if (!response.ok) {
-        throw new Error("Failed to exchange code for token");
-      }
-
-      const data = await response.json();
-      this.accessToken = data.access_token;
-
-      // Store token
-      localStorage.setItem("github_access_token", this.accessToken);
-
-      // Get user info
-      await this.fetchUserInfo();
-
-      this.emit("authChange", true);
-      return true;
-    } catch (error) {
-      console.error("Authentication failed:", error);
-      this.logout();
-      return false;
-    }
-  }
-
-  private async fetchUserInfo() {
-    if (!this.accessToken) return;
-
-    try {
-      const response = await fetch("https://api.github.com/user", {
-        headers: {
-          Authorization: `Bearer ${this.accessToken}`,
-          Accept: "application/vnd.github.v3+json",
-        },
-      });
-
-      if (!response.ok) {
-        throw new Error("Failed to fetch user info");
-      }
-
-      this.user = await response.json();
-      localStorage.setItem("github_user", JSON.stringify(this.user));
-    } catch (error) {
-      console.error("Failed to fetch user info:", error);
-    }
-  }
-
-  logout() {
-    this.accessToken = null;
-    this.user = null;
-    localStorage.removeItem("github_access_token");
-    localStorage.removeItem("github_user");
-    this.emit("authChange", false);
-  }
-
-  isConfigured(): boolean {
-    const clientId = GitHubAuthService.CLIENT_ID;
-    console.log("Checking if configured - CLIENT_ID:", clientId);
-    return !!clientId;
-  }
-
-  async makeAuthenticatedRequest(url: string, options: RequestInit = {}) {
-    if (!this.accessToken) {
-      throw new Error("Not authenticated");
-    }
-
-    const headers = {
-      Authorization: `Bearer ${this.accessToken}`,
-      Accept: "application/vnd.github.v3+json",
-      ...options.headers,
-    };
-
-    const response = await fetch(url, {
-      ...options,
-      headers,
-    });
-
-    if (response.status === 401) {
-      this.logout();
-      throw new Error("Authentication expired");
-    }
-
-    return response;
-  }
-}
-
-export const githubAuthService = new GitHubAuthService();

package/src/types/features.ts

@@ -1,38 +0,0 @@
-export type TreeNode = {
-  name: string;
-  type: 'project' | 'file';
-  path?: string;
-  children?: TreeNode[];
-};
-
-export function buildTree(projects: string[]): TreeNode[] {
-  return projects.map(projectName => ({
-    name: projectName,
-    type: 'project',
-    children: [{
-      name: 'src',
-      type: 'file',
-      children: [{
-        name: 'components',
-        type: 'file',
-        children: [{
-          name: 'pure',
-          type: 'file',
-          children: [
-            { name: 'AppFrame.test', type: 'file', path: 'src/components/pure/AppFrame.test' },
-            { name: 'FeaturesReporterView.test', type: 'file', path: 'src/components/pure/FeaturesReporterView.test' },
-            { name: 'ProjectPageView.test', type: 'file', path: 'src/components/pure/ProjectPageView.test' }
-          ]
-        }]
-      }, {
-        name: 'lib',
-        type: 'file',
-        children: [{
-          name: 'baseBuilder.test',
-          type: 'file',
-          path: 'src/lib/baseBuilder.test'
-        }]
-      }]
-    }]
-  }));
-}

package/src/utils/api.ts

@@ -1,108 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { ISummary, IBuiltConfig } from "../Types";
-import { getLogFilesForRuntime, STANDARD_LOGS } from "./logFiles";
-
-export const fetchProjectData = async (projectName: string) => {
-  const [summaryRes, configRes] = await Promise.all([
-    fetch(summaryDotJson(projectName)),
-    fetch("/reports/config.json"),
-  ]);
-
-  return {
-    summary: (await summaryRes.json()) as ISummary,
-    config: (await configRes.json()) as IBuiltConfig,
-  };
-};
-
-export const fetchTestData = async (
-  projectName: string,
-  filepath: string,
-  runTime: string
-): Promise<{
-  logs: Record<string, string>;
-  error: string | null;
-}> => {
-  const basePath = `reports/${projectName}/${filepath
-    .split(".")
-    .slice(0, -1)
-    .join(".")}/${runTime}`;
-
-  try {
-    const logFiles = getLogFilesForRuntime(runTime);
-    const logs: Record<string, string> = {};
-
-    // Fetch all log files in parallel
-    const logRequests = logFiles.map(async (file) => {
-      try {
-        const response = await fetch(`${basePath}/${file}`);
-        if (!response.ok) return null;
-
-        const content = file.endsWith(".json")
-          ? await response.json()
-          : await response.text();
-
-        return { file, content };
-      } catch (err) {
-        console.error(`Failed to fetch ${file}:`, err);
-        return null;
-      }
-    });
-
-    // Wait for all requests and populate logs
-    const logResults = await Promise.all(logRequests);
-    logResults.forEach((result) => {
-      if (result) {
-        logs[result.file] = result.content;
-      }
-    });
-
-    // Ensure we fetch all standard logs
-    for (const file of Object.values(STANDARD_LOGS)) {
-      if (!logs[file]) {
-        try {
-          const response = await fetch(`${basePath}/${file}`);
-          if (response.ok) {
-            logs[file] = file.endsWith(".json")
-              ? await response.json()
-              : await response.text();
-          }
-        } catch (err) {
-          console.error(`Failed to fetch ${file}:`, err);
-        }
-      }
-    }
-
-    // const logs = await logFiles.reduce(async (acc, file, i) => {
-    //   acc[file.split(".")[0]] = await logRes[i].text();
-    //   return acc;
-    // }, {});
-
-    // Check if we got any logs at all
-    if (Object.keys(logs).length === 0) {
-      return {
-        logs: {},
-        error:
-          "No test logs found. The test may not have run or the report files are missing.",
-      };
-    }
-
-    return {
-      logs,
-      error: null,
-    };
-  } catch (err) {
-    return {
-      // testData: null,
-      logs: {},
-      // typeErrors: "",
-      // lintErrors: "",
-      error: `Failed to load test data: ${
-        err instanceof Error ? err.message : String(err)
-      }`,
-    };
-  }
-};
-
-export const summaryDotJson = (name: string): string => {
-  return `reports/${name}/summary.json`;
-};

package/src/utils/featureUtils.tsx

@@ -1,42 +0,0 @@
-export interface Feature {
-  name: string;
-  status: string;
-}
-
-export const buildTree = (features: Feature[]) => {
-  const tree: any = {};
-  features.forEach(({ name, status }) => {
-    const parts = name.split(" - ");
-    const projectAndTest = parts.slice(0, 2).join(" - ");
-    const givenAndThen = parts.slice(2).join(" - ");
-    const pathParts = projectAndTest.split("/");
-    let current = tree;
-    pathParts.forEach((part) => {
-      if (!current[part]) {
-        current[part] = {};
-      }
-      current = current[part];
-    });
-    current[givenAndThen] = status;
-  });
-  return tree;
-};
-
-export const renderTree = (nodes: any) => (
-  <ul>
-    {Object.entries(nodes).map(([key, value]) => (
-      <li key={key}>
-        {typeof value === "string" ? (
-          <span>
-            {key} - {value}
-          </span>
-        ) : (
-          <>
-            <span>{key}</span>
-            {renderTree(value)}
-          </>
-        )}
-      </li>
-    ))}
-  </ul>
-);

package/src/utils/gitTest.ts

@@ -1,29 +0,0 @@
-import { getFileService } from '../services/FileService';
-
-export const testGitIntegration = async () => {
-  try {
-    const fileService = getFileService('dev');
-    
-    // Test basic file operations
-    const testContent = '// Test file content\nconsole.log("Hello Git!");';
-    await fileService.writeFile('test-file.ts', testContent);
-    
-    const content = await fileService.readFile('test-file.ts');
-    console.log('File content:', content);
-    
-    const exists = await fileService.exists('test-file.ts');
-    console.log('File exists:', exists);
-    
-    // Test Git operations
-    const changes = await fileService.getChanges();
-    console.log('Changes:', changes);
-    
-    const branch = await fileService.getCurrentBranch();
-    console.log('Current branch:', branch);
-    
-    return { success: true, changes, branch };
-  } catch (error) {
-    console.error('Git integration test failed:', error);
-    return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
-  }
-};

package/src/utils/makePrompt.ts

@@ -1,160 +0,0 @@
-import fs from "fs";
-import path from "path";
-
-import { promptPather } from "../utils";
-
-import { IRunTime, ISummary } from "../Types";
-import { getLogFilesForRuntime } from "./logFiles";
-import { LOG_FILES } from "./logFiles";
-import ansiColors from "ansi-colors";
-
-const makePrompt = async (
-  summary: ISummary,
-  name: string,
-  entryPoint: string,
-  addableFiles: string[],
-  runtime: IRunTime
-) => {
-  summary[entryPoint].prompt = "?";
-  const promptPath = promptPather(entryPoint, runtime, name);
-
-  // Correct directory structure: testeranto/reports/<name>/<testname>/<runtime>/
-  const testDir = path.join(
-    "testeranto",
-    "reports",
-    name,
-    entryPoint.split(".").slice(0, -1).join("."),
-    runtime
-  );
-
-  // Ensure directory exists
-  if (!fs.existsSync(testDir)) {
-    fs.mkdirSync(testDir, { recursive: true });
-  }
-
-  // Test result files
-  const testPaths = path.join(testDir, LOG_FILES.TESTS);
-  const lintPath = path.join(testDir, LOG_FILES.LINT_ERRORS);
-  const typePath = path.join(testDir, LOG_FILES.TYPE_ERRORS);
-  const messagePath = path.join(testDir, LOG_FILES.MESSAGE);
-
-  try {
-    await Promise.all([
-      fs.promises.writeFile(
-        promptPath,
-        `
-${addableFiles
-  .map((x) => {
-    return `/add ${x}`;
-  })
-  .join("\n")}
-
-/read node_modules/testeranto/docs/index.md
-/read node_modules/testeranto/docs/style.md
-/read node_modules/testeranto/docs/testing.ai.txt
-/read node_modules/testeranto/src/CoreTypes.ts
-
-/read ${testPaths}
-/read ${typePath}
-/read ${lintPath}
-
-/read ${getLogFilesForRuntime(runtime)
-          .map((p) => `${testDir}/${p}`)
-          .join("\n/read ")}
-`
-      ),
-      fs.promises.writeFile(
-        messagePath,
-        `
-There are 3 types of test reports.
-1) bdd (highest priority)
-2) type checker
-3) static analysis (lowest priority)
-
-"tests.json" is the detailed result of the bdd tests.
-if these files do not exist, then something has gone badly wrong and needs to be addressed.
-
-"type_errors.txt" is the result of the type checker.
-if this file does not exist, then type check passed without errors;
-
-"lint_errors.txt" is the result of the static analysis.
-if this file does not exist, then static analysis passed without errors;
-
-BDD failures are the highest priority. Focus on passing BDD tests before addressing other concerns.
-Do not add error throwing/catching to the tests themselves.
-`
-      ),
-    ]);
-  } catch (e) {
-    console.error(`Failed to write prompt files at ${testDir}`);
-    console.error(e);
-    throw e;
-  }
-
-  summary[
-    entryPoint
-  ].prompt = `aider --model deepseek/deepseek-chat --load testeranto/${name}/reports/${runtime}/${entryPoint
-    .split(".")
-    .slice(0, -1)
-    .join(".")}/prompt.txt`;
-};
-
-// function logs(r: IRunTime) {
-//   return getLogFilesForRuntime(r);
-// }
-
-// async function logsOfRuntime(
-//   runTime: IRunTime,
-//   testDir: string
-// ): Promise<string> {
-//   try {
-//     const fileChecks = await Promise.all(
-//       getLogFilesForRuntime(runTime).map(async (f) => {
-//         const filePath = path.join(testDir, f);
-//         try {
-//           await fs.promises.access(filePath);
-//           const content = await fs.promises.readFile(filePath, "utf-8");
-//           return content;
-//         } catch {
-//           return null;
-//         }
-//       })
-//     );
-
-//     return fileChecks.filter(Boolean).join("\n");
-//   } catch (e) {
-//     console.error(`Error checking log files in ${testDir}`);
-//     console.error(e);
-//     return "";
-//   }
-// }
-
-export const makePromptInternal = (
-  summary: ISummary,
-  name: string,
-  entryPoint: string,
-  addableFiles: string[],
-  runTime: IRunTime
-) => {
-  if (runTime === "node") {
-    return makePrompt(summary, name, entryPoint, addableFiles, "node");
-  }
-
-  if (runTime === "web") {
-    return makePrompt(summary, name, entryPoint, addableFiles, "web");
-  }
-
-  if (runTime === "pure") {
-    return makePrompt(summary, name, entryPoint, addableFiles, "pure");
-  }
-
-  if (runTime === "golang") {
-    return makePrompt(summary, name, entryPoint, addableFiles, "golang");
-  }
-
-  if (runTime === "python") {
-    return makePrompt(summary, name, entryPoint, addableFiles, "python");
-  }
-
-  throw `unknown runTime: ${runTime}`;
-};