Temu SEO Articles from Products - Confirm & Copy Final Agent Code

Describe

Describe your task

Refine

Refine the plan

SubAgents

Review all agents

Deploy

Deploy your agent

Review Final Agent Copy

Expand

[
  {
    "taskID": 1,
    "semanticTitleOfTask": "Generate React Entry Point File",
    "taskDescription": "This task uses skill #223 to produce a minimal index.js file that sets up the root application entry point. We rely on React 18+ createRoot, StrictMode, import React, ReactDOM, and the App component, with inline comments and best practices.",
    "inputDescription": "Takes a standard React 18 environment from user input. This is the 'VARIABLE1'.",
    "inputRequired": [
      "VARIABLE1"
    ],
    "outputDescription": "A complete index.js file as text, including the code needed to render the React application into the root DOM element.",
    "outputName": "index_js_code",
    "promptInstruction": "Use skill #223 to generate a minimal React index.js entry point file that imports React, ReactDOM, and the App component. Ensure StrictMode usage, createRoot usage, inline comments, and modern best practices. Return the code as text."
  },
  {
    "taskID": 2,
    "semanticTitleOfTask": "Generate React Router Configuration",
    "taskDescription": "This task uses skill #223 to build an App.js file that configures React Router v6 with routes and basic layout structure, referencing the index.js context.",
    "inputDescription": "Requires index_js_code from the previous task to ensure the environment references and structure are consistent. Assumes that React Router v6 is already installed.",
    "inputRequired": [
      "index_js_code"
    ],
    "outputDescription": "A complete App.js file with BrowserRouter setup, route definitions for '/' (InputPage) and '/results' (ResultsPage), and placeholders for error boundaries and lazy loading.",
    "outputName": "app_js_code",
    "promptInstruction": "Use skill #223 to produce a React App.js file implementing React Router v6 with routes for '/' and '/results'. Include lazy loading, Suspense, and minimal layout (header/footer). Provide inline comments for each router element. Return the code as text."
  },
  {
    "taskID": 3,
    "semanticTitleOfTask": "Generate Input Page Structure",
    "taskDescription": "This task uses skill #223 to create the InputPage.js file, which includes form components (CategorySelector, TimeframeSelector, AdvancedFilters, and StartButton). It manages form state and prepares data flow for the results page.",
    "inputDescription": "Requires app_js_code from the previous task, ensuring there is a route pointing to this page. Assumes React 18+ usage.",
    "inputRequired": [
      "app_js_code"
    ],
    "outputDescription": "A complete InputPage.js React functional component file, implementing placeholders for child components and using hooks for form state management and validation.",
    "outputName": "input_page_code",
    "promptInstruction": "Use skill #223 to create a React functional component named InputPage that references CategorySelector, TimeframeSelector, AdvancedFilters, and StartButton. Include hook-based state management, form validation, and inline documentation. Return the code as text."
  },
  {
    "taskID": 4,
    "semanticTitleOfTask": "Generate Results Page Structure",
    "taskDescription": "This task uses skill #223 to create the ResultsPage.js file, which displays and manages product data, research results, and article previews, along with export options.",
    "inputDescription": "Requires input_page_code to ensure continuity in data flow from user inputs to the results view. Assumes React Router is already set up to navigate here.",
    "inputRequired": [
      "input_page_code"
    ],
    "outputDescription": "A fully functional ResultsPage.js React component file that integrates ProductList, ResearchResults, ArticlePreview, and ExportControls with appropriate state management and placeholders for advanced logic.",
    "outputName": "results_page_code",
    "promptInstruction": "Use skill #223 to build a React functional component named ResultsPage, which includes ProductList, ResearchResults, ArticlePreview, and ExportControls. Provide hooks for data state, loading, and error handling. Return the code as text."
  },
  {
    "taskID": 5,
    "semanticTitleOfTask": "Generate Input Form Components",
    "taskDescription": "This task uses skill #223 to create the individual components (CategorySelector, TimeframeSelector, AdvancedFilters, StartButton) used in the InputPage for data entry and submission.",
    "inputDescription": "Requires results_page_code for reference on overall design patterns, although the direct dependency is minimal. Ensures cohesive style and pattern across the project.",
    "inputRequired": [
      "results_page_code"
    ],
    "outputDescription": "Four separate React component files (CategorySelector.js, TimeframeSelector.js, AdvancedFilters.js, StartButton.js) as text, each with prop validation, hook usage, and inline documentation.",
    "outputName": "input_components_code",
    "promptInstruction": "Use skill #223 to generate four React functional components: CategorySelector, TimeframeSelector, AdvancedFilters, and StartButton. Each component should have clear props, state management (if needed), and inline comments. Return them as separate text blocks/files."
  },
  {
    "taskID": 6,
    "semanticTitleOfTask": "Generate Results Display Components",
    "taskDescription": "This task uses skill #223 to create the individual components (ProductList, ResearchResults, ArticlePreview, ExportControls) displayed in the ResultsPage for showing and managing the output data.",
    "inputDescription": "Requires input_components_code to maintain consistent style and organizational patterns across all components in the application.",
    "inputRequired": [
      "input_components_code"
    ],
    "outputDescription": "Four separate React component files (ProductList.js, ResearchResults.js, ArticlePreview.js, ExportControls.js) as text, each handling its own data interactions, rendering, and state transitions.",
    "outputName": "results_components_code",
    "promptInstruction": "Use skill #223 to construct four React functional components: ProductList, ResearchResults, ArticlePreview, and ExportControls. Focus on data display, error boundaries, and placeholders for business logic. Return the code as separate text blocks/files."
  },
  {
    "taskID": 7,
    "semanticTitleOfTask": "Generate CSS Styling",
    "taskDescription": "This task uses skill #223 to create one or more vanilla CSS files that provide styling for the entire React application, incorporating responsive design and a clean, modern layout.",
    "inputDescription": "Requires results_components_code to align class names and IDs in the styling. Ensures the final CSS references existing component structures properly.",
    "inputRequired": [
      "results_components_code"
    ],
    "outputDescription": "One or more CSS files as text, detailing a responsive layout, color variables, typography, transitions, and comments explaining design decisions.",
    "outputName": "css_code",
    "promptInstruction": "Use skill #223 to create vanilla CSS files for the entire React application. Include a root color palette, typography settings, responsive breakpoints, and transitions. Provide inline comments and ensure classes align with the previously generated components. Return the code as text."
  },
  {
    "taskID": 8,
    "semanticTitleOfTask": "Bundle Frontend Structure",
    "taskDescription": "This task uses skill #223 to assemble all previously generated code files (index.js, App.js, pages, components, CSS) into a final, organized folder structure, ready for local development or deployment.",
    "inputDescription": "Requires the outputs from steps #1 through #7 (index_js_code, app_js_code, input_page_code, results_page_code, input_components_code, results_components_code, css_code) to compile everything into a cohesive project.",
    "inputRequired": [
      "index_js_code",
      "app_js_code",
      "input_page_code",
      "results_page_code",
      "input_components_code",
      "results_components_code",
      "css_code"
    ],
    "outputDescription": "A complete React project folder structure containing all code files properly imported and ready to run with 'npm start' or an equivalent command. This can be represented as text or a zipped bundle.",
    "outputName": "react_frontend_structure",
    "promptInstruction": "Use skill #223 to assemble a final React folder structure containing index.js, App.js, pages, components, and CSS files from all previous steps. Update import statements so everything is functional. Provide a brief README or description for how to run the project. Return the structure as text or a conceptual zip."
  },
  {
    "taskID": 1,
    "semanticTitleOfTask": "Generate Apify Service Integration Code",
    "taskDescription": "This task uses the powerful LLM (#223) to produce a JavaScript module that integrates with the Apify Client. It must include rate limiting, proxy rotation, error handling, caching integration points, logging, and retry logic, ensuring a well-documented and production-ready service file.",
    "inputDescription": "We provide specifications detailing how to integrate with Apify, including placeholder credentials, rate limiting (token bucket), proxy rotation, error handling patterns, caching stubs, and usage examples. These instructions guide the LLM to produce comprehensive JavaScript code for the Apify service.",
    "inputRequired": [
      "service_requirements"
    ],
    "outputDescription": "A JavaScript file named 'apify-service.js' containing production-ready integration code for the Apify Client, including stubbed rate limiting, proxy rotation, caching hooks, logging, error handling, and usage examples in comments.",
    "outputName": "apify_service_js",
    "promptInstruction": "Generate a JavaScript service module for Apify integration with the following requirements:\n- Import and configure ApifyClient with proper TypeScript/JSDoc comments\n- Implement rate limiting using a token bucket algorithm\n- Add proxy rotation functionality with a minimum of 3 fallback proxies\n- Include error handling for network failures, rate limits, and invalid responses\n- Add caching integration points for successful responses\n- Include usage examples in comments\n- Add logging for debugging\n- Implement retry logic for failed requests\nThe code should be production-ready with proper error handling and documentation."
  },
  {
    "taskID": 2,
    "semanticTitleOfTask": "Generate YouTube Data API Service Code",
    "taskDescription": "This task uses the powerful LLM (#223) to produce a JavaScript service for interacting with the YouTube Data API, following best practices such as rate limiting, error handling, caching, and retry logic. It must include well-documented methods to search and retrieve video information.",
    "inputDescription": "We provide specifications detailing the YouTube Data API, including placeholders for API keys, methods to implement (searchVideos, getVideoDetails, getChannelVideos), rate limiting rules, error handling, caching, TypeScript/JSDoc comments, and usage examples.",
    "inputRequired": [
      "service_requirements"
    ],
    "outputDescription": "A JavaScript file named 'youtube-service.js' containing production-ready YouTube Data API integration code with rate limiting, caching, TypeScript/JSDoc documentation, error handling logic, and multiple example methods for searching and retrieving video information.",
    "outputName": "youtube_service_js",
    "promptInstruction": "Generate a JavaScript service module for YouTube Data API with the following requirements:\n- Initialize YouTube Data API client with configuration options\n- Implement methods for: searchVideos, getVideoDetails, getChannelVideos\n- Add rate limiting to respect YouTube API quotas\n- Include error handling for quota exceeded, invalid API keys, and network errors\n- Add result caching mechanism\n- Include TypeScript/JSDoc comments\n- Add usage examples in comments\n- Implement retry logic for transient failures\nThe code should be production-ready with proper error handling and documentation."
  },
  {
    "taskID": 3,
    "semanticTitleOfTask": "Generate Google Custom Search Service Code",
    "taskDescription": "This task uses the powerful LLM (#223) to produce a JavaScript service for Google Custom Search integration. It must handle various search requirements, implement rate limiting, manage errors, utilize caching, and support pagination, while providing comprehensive documentation.",
    "inputDescription": "We provide specifications detailing usage of Google Custom Search, including placeholders for API keys, required methods (searchProducts, getProductReviews, searchByTopic), rate limiting strategies, caching, error handling structure, pagination support, and usage examples.",
    "inputRequired": [
      "service_requirements"
    ],
    "outputDescription": "A JavaScript file named 'google-search-service.js' containing production-ready integration with Google Custom Search API, including error handling, caching, pagination, rate limiting, TypeScript/JSDoc comments, and example methods for searching data.",
    "outputName": "google_search_service_js",
    "promptInstruction": "Generate a JavaScript service module for Google Custom Search API with the following requirements:\n- Initialize Google Custom Search client\n- Implement methods for: searchProducts, getProductReviews, searchByTopic\n- Add rate limiting mechanism\n- Include error handling for quota exceeded and invalid responses\n- Add result caching mechanism\n- Include TypeScript/JSDoc comments\n- Add usage examples in comments\n- Implement pagination handling\nThe code should be production-ready with proper error handling and documentation."
  },
  {
    "taskID": 4,
    "semanticTitleOfTask": "Generate OpenAI GPT-4 Service Code",
    "taskDescription": "This task uses the powerful LLM (#223) to produce a JavaScript service module integrating the OpenAI GPT-4 API. The implementation must handle token counting, rate limits, caching, error handling, retry logic, and provide well-documented methods for generating and optimizing content.",
    "inputDescription": "We provide specifications detailing usage of the OpenAI GPT-4 API, including placeholders for API keys, methods (generateArticle, summarizeContent, optimizeForSEO), token counting and rate limiting strategies, caching stubs, and retry logic for failures.",
    "inputRequired": [
      "service_requirements"
    ],
    "outputDescription": "A JavaScript file named 'openai-service.js' containing production-ready integration with GPT-4. Includes robust error handling, token counting, caching hooks, rate limiting, TypeScript/JSDoc documentation, usage examples, and methods for generating and optimizing articles.",
    "outputName": "openai_service_js",
    "promptInstruction": "Generate a JavaScript service module for OpenAI GPT-4 API with the following requirements:\n- Initialize OpenAI API client\n- Implement methods for: generateArticle, summarizeContent, optimizeForSEO\n- Add rate limiting and token counting\n- Include error handling for API failures and token limits\n- Add result caching mechanism\n- Include TypeScript/JSDoc comments\n- Add usage examples in comments\n- Implement retry logic for rate limits\nThe code should be production-ready with proper error handling and documentation."
  },
  {
    "taskID": 5,
    "semanticTitleOfTask": "Generate Firebase Configuration Code",
    "taskDescription": "This task uses the powerful LLM (#223) to produce a JavaScript configuration module for Firebase setup, including authentication, Firestore, Storage, security rules templates, and error handling. The code must be well-documented and production-ready.",
    "inputDescription": "We provide specifications detailing the Firebase configuration (API key, project ID, etc.), authentication setup, Firestore database configuration, Storage service initialization, potential security rules, and placeholders for error handling and usage examples.",
    "inputRequired": [
      "service_requirements"
    ],
    "outputDescription": "A JavaScript file named 'firebase-config.js' containing the production-ready Firebase setup, including authentication initialization, Firestore configuration, Storage setup, error handling, TypeScript/JSDoc comments, and example usage instructions.",
    "outputName": "firebase_config_js",
    "promptInstruction": "Generate a JavaScript configuration module for Firebase with the following requirements:\n- Initialize Firebase app with configuration\n- Set up Authentication service\n- Configure Firestore database\n- Set up Storage service\n- Add error handling for initialization failures\n- Include TypeScript/JSDoc comments\n- Add usage examples in comments\n- Include security rules templates\nThe code should be production-ready with proper error handling and documentation."
  },
  {
    "taskID": 2231,
    "semanticTitleOfTask": "Process Caching Requirements Input",
    "taskDescription": "This task analyzes the specified caching requirements to determine the primary caching mechanism, operations, TTL configuration, error handling, and any performance constraints, producing a structured guide for the implementation phase.",
    "inputDescription": "Requires details about the preferred caching approach (localStorage, Redis, or hybrid), TTL specifications, error handling preferences, and performance considerations. These will be combined into a single, structured set of requirements.",
    "inputRequired": [
      "caching_approach_type",
      "ttl_requirements",
      "error_handling_specs",
      "performance_constraints"
    ],
    "outputDescription": "A structured technical specification summarizing the chosen caching mechanism, the required cache operations, TTL configurations, error handling strategies, and performance constraints, serving as a guide for subsequent implementation.",
    "outputName": "processed_cache_requirements",
    "promptInstruction": "As a systems architect specializing in caching implementations, analyze the following caching requirements and provide a structured output detailing:\n1. The primary caching mechanism to implement (localStorage, Redis, or hybrid approach)\n2. Required cache operations and their constraints\n3. Time-to-live (TTL) specifications\n4. Error handling requirements\n5. Any performance considerations or limitations\nPlease format your response as a technical specification that will guide the implementation."
  },
  {
    "taskID": 2232,
    "semanticTitleOfTask": "Generate Cache Service Implementation",
    "taskDescription": "Using the researched requirements, produce the complete JavaScript implementation for cache-service.js. This includes setCache and getCache functions, support for the chosen mechanism (localStorage, Redis, or both), error handling, optional TTL logic, and best-practice structure.",
    "inputDescription": "Takes the processed_cache_requirements from the previous task, plus any function_signatures details and an implementation_approach. Combines these inputs to generate ready-to-use code.",
    "inputRequired": [
      "processed_cache_requirements",
      "function_signatures",
      "implementation_approach"
    ],
    "outputDescription": "A production-ready cache-service.js code snippet that implements setCache(key, data) and getCache(key), handles errors, supports the specified caching mechanisms, and allows for TTL functionality as needed.",
    "outputName": "cache_service_code",
    "promptInstruction": "Generate a production-ready cache-service.js implementation that meets the following requirements:\n1. Implement setCache(key, data) and getCache(key) functions\n2. Support the specified caching mechanism (localStorage/Redis/hybrid)\n3. Include robust error handling\n4. Implement TTL functionality if specified\n5. Add type checking and validation\n6. Include performance optimizations\nThe code should be clean, well-structured, and follow JavaScript best practices. Include appropriate error handling and edge cases."
  },
  {
    "taskID": 2233,
    "semanticTitleOfTask": "Generate Code Documentation and Examples",
    "taskDescription": "This task takes the newly created cache service implementation and produces comprehensive documentation in JSDoc format. Usage examples, function signatures, parameter returns, error scenarios, and performance notes are all included.",
    "inputDescription": "Necessitates the generated cache_service_code, plus any implementation_approach detail and usage_scenarios that should be documented for clarity.",
    "inputRequired": [
      "cache_service_code",
      "implementation_approach",
      "usage_scenarios"
    ],
    "outputDescription": "A detailed set of documentation comments (JSDoc) and example usage snippets that clearly explain how to integrate and use the cache-service.js API in different environments or situations.",
    "outputName": "documented_cache_service",
    "promptInstruction": "Create detailed documentation for the cache-service.js implementation including:\n1. Function signatures and parameter descriptions\n2. Return values and types\n3. Error scenarios and handling\n4. Usage examples for each major functionality\n5. Implementation notes and considerations\n6. Performance characteristics\nFormat the documentation as JSDoc comments that can be automatically parsed into documentation."
  },
  {
    "taskID": 2234,
    "semanticTitleOfTask": "Assemble Final Cache Service File",
    "taskDescription": "This task merges the finalized code and all documentation into a single, coherent cache-service.js file. Ensures imports, exports, and file-level comments are in place, ready for integration into either a browser-based or Node.js environment.",
    "inputDescription": "Incorporates the documented_cache_service content along with the raw cache_service_code. Combines them in a well-structured way, ensuring all elements—from file-level docs to usage examples—are aligned.",
    "inputRequired": [
      "documented_cache_service",
      "cache_service_code"
    ],
    "outputDescription": "A final production-ready cache-service.js file containing both the working code and embedded JSDoc-style documentation and usage examples.",
    "outputName": "final_cache_service_js",
    "promptInstruction": "Combine the following elements into a production-ready cache-service.js file:\n1. File-level documentation and overview\n2. Import statements and dependencies\n3. Implementation code\n4. Inline documentation and JSDoc comments\n5. Usage examples\n6. Export statements\nFormat the final file according to standard JavaScript module conventions, ensuring it can be imported and used in both browser and Node.js environments if required."
  },
  {
    "taskID": 2231,
    "semanticTitleOfTask": "Generate Production-Ready package.json Configuration",
    "taskDescription": "Generates a production-ready package.json file for a React application with specified dependencies, version requirements, scripts, and other metadata for deployment readiness.",
    "inputDescription": "The subagent needs the project_name, version of Node, dependency_list, development_scripts, build_commands, and project_metadata in order to correctly build the package.json file, ensuring fully compatible versioning and deployment settings.",
    "inputRequired": [
      "project_name",
      "dependency_list",
      "build_commands",
      "node_version",
      "development_scripts",
      "project_metadata"
    ],
    "outputDescription": "A valid package.json configuration as a JSON string, complete with dependencies, scripts, node engine requirements, author info, and other key metadata.",
    "outputName": "package_json_config",
    "promptInstruction": "Please generate a production-ready package.json file for the TemuPro Article Generator project with React, Firebase, Apify Client, YouTube Data API, Google Custom Search API, and OpenAI API as dependencies, including development dependencies and properly versioned scripts (dev, build, test, start). Include license, author, and Node engine requirements. Format output as valid JSON."
  },
  {
    "taskID": 2232,
    "semanticTitleOfTask": "Create Comprehensive Project Documentation",
    "taskDescription": "Generates a detailed README.md file describing the project's purpose, installation steps, build instructions, Netlify deployment strategy, and usage guidelines.",
    "inputDescription": "The subagent needs knowledge of the project's overview, prerequisites, environment_setup, setup_steps, build_instructions, and deployment_guidelines to compose a thorough README with step-by-step details.",
    "inputRequired": [
      "project_overview",
      "setup_steps",
      "build_instructions",
      "deployment_guidelines",
      "environment_setup"
    ],
    "outputDescription": "A complete README.md file in Markdown format that covers project introduction, prerequisites, installation, usage, build, deployment steps, structure overview, and troubleshooting notes.",
    "outputName": "readme_documentation",
    "promptInstruction": "Please generate a README.md file for the TemuPro Article Generator project that includes: project title, brief description, prerequisites, environment variables setup, step-by-step installation, build instructions, Netlify deployment steps, API integration details, and troubleshooting guidance. Use clear headings, code blocks, and organized sections."
  },
  {
    "taskID": 2233,
    "semanticTitleOfTask": "Configure Netlify Deployment Settings",
    "taskDescription": "Generates a netlify.toml file for deploying a React application on Netlify, defining build commands, publish directory, environment variables, Node.js version, rewrite/redirect rules, and caching settings.",
    "inputDescription": "The subagent needs the build_command, publish_directory, environment_variables, build_context, and deployment_settings for hosting on Netlify, including any rewrite rules and caching parameters.",
    "inputRequired": [
      "build_command",
      "publish_directory",
      "environment_variables",
      "build_context",
      "deployment_settings"
    ],
    "outputDescription": "A netlify.toml file specifying the React project's build settings (npm run build, build folder), Node.js version, security headers, redirect rules for SPA functionality, and cache control directives for optimized hosting.",
    "outputName": "netlify_config",
    "promptInstruction": "Please create a netlify.toml file for the React application with build command (npm run build), publish directory (build), Node.js version, environment variables, build contexts (dev/prod), security headers, SPA redirect rules, and cache control settings. Include inline comments to explain each section."
  },
  {
    "taskID": 2234,
    "semanticTitleOfTask": "Compile Deployment Configuration Bundle",
    "taskDescription": "Verifies consistency among the generated package.json, README.md, and netlify.toml files, ensuring matching script names, build commands, environment variable references, and dependency versions. Produces a final consistency report.",
    "inputDescription": "The subagent needs the previously generated package_json_config, readme_documentation, and netlify_config to cross-check for matching build commands, scripts, environment variables, and references to assure a coherent deployment configuration.",
    "inputRequired": [
      "package_json_config",
      "readme_documentation",
      "netlify_config"
    ],
    "outputDescription": "Provides a confirmation message indicating all files match consistently or lists specific inconsistencies requiring adjustments before final deployment.",
    "outputName": "deployment_config",
    "promptInstruction": "Please review the generated package.json, README.md, and netlify.toml for consistency regarding script names, build commands, environment variable references, and dependency versions. Provide a message confirming alignment or detailing any mismatches, and summarize the overall result as success or failure."
  },
  {
    "taskID": 231,
    "semanticTitleOfTask": "Test Framework Setup Configuration Generation",
    "taskDescription": "This task sets up the base configuration for testing the React codebase. It includes creation of jest.config.js, setup files, coverage settings, and environment mocks, ensuring the project is ready for both unit and integration testing.",
    "inputDescription": "We require the initial codebase_structure, including the React application setup, any existing configurations or scripts, and the developer's testing_requirements for frameworks like Jest, React Testing Library, or additional libraries. We also gather any coverage or environment requirements.",
    "inputRequired": [
      "codebase_structure",
      "testing_requirements",
      "framework_preferences"
    ],
    "outputDescription": "The output includes essential configuration files for testing, such as jest.config.js, a setupTests.js (or equivalent) file for React Testing Library, any custom mock files, and coverage settings to ensure the test environment is fully prepared for all levels of testing.",
    "outputName": "test_config_files",
    "promptInstruction": "Generate test configuration files for a React application using Jest and React Testing Library. The application uses the following structure: codebase-structure. Include configuration for coverage reporting targeting 80%. Provide custom test environment setup for async operations."
  },
  {
    "taskID": 232,
    "semanticTitleOfTask": "React Component Test Suite Generation",
    "taskDescription": "This task creates Jest and React Testing Library test files for each React component, verifying rendering, user interactions, state management, and error boundaries using best practices in user-centric testing and snapshot tests.",
    "inputDescription": "We require the react_frontend_structure plus the component_specifications along with any special user interaction or state requirements that must be tested.",
    "inputRequired": [
      "react_frontend_structure",
      "component_specifications"
    ],
    "outputDescription": "The output is a set of .test.js files covering each component's rendering logic, event handlers, state updates, props interactions, and snapshots. These tests ensure that components function correctly and regressions are detected promptly.",
    "outputName": "component_test_suite",
    "promptInstruction": "Create comprehensive test suites for React components based on component-specifications. Include tests for rendering, user interactions, state changes, props validation, error boundary testing, and async operations. Use React Testing Library for user-centric testing and snapshot tests."
  },
  {
    "taskID": 233,
    "semanticTitleOfTask": "API Service Unit Test Generation",
    "taskDescription": "This task produces unit tests for each API service, mocking external dependencies to validate success and failure scenarios, rate limiting, caching, and error handling. It ensures robust coverage and reliability for all backend interactions.",
    "inputDescription": "We require details on each service file in services_folder, including the external API endpoints or libraries used, the expected input and output shapes, any rate limiting features implemented, and how errors are propagated or handled.",
    "inputRequired": [
      "services_folder",
      "api_specifications"
    ],
    "outputDescription": "The output is a collection of .test.js files for each service, employing Jest mocks to simulate external APIs. Tests validate correct request parameters, handle both successful and failed responses, confirm error handling logic, and ensure any caching or rate limiting mechanisms work as expected.",
    "outputName": "service_test_suite",
    "promptInstruction": "Generate unit tests for service files based on api-specifications. Create test suites that mock external API calls, test success and error scenarios, validate rate limiting functionality, test caching mechanisms, and verify proper error handling including timeout scenarios."
  },
  {
    "taskID": 234,
    "semanticTitleOfTask": "End-to-End Test Specification Generation",
    "taskDescription": "This task creates E2E test specifications using Cypress or Playwright to verify core user flows, from selecting product categories to generating articles. It ensures that the application behaves correctly under real user workflows across page transitions and data fetching.",
    "inputDescription": "We require the user_flow_specifications and e2e_requirements defining the primary user flows to be tested, including navigation steps, form inputs, and asynchronous data calls.",
    "inputRequired": [
      "user_flow_specifications",
      "e2e_requirements"
    ],
    "outputDescription": "The output is a set of Cypress or Playwright test specification files that simulate end-to-end user actions and assertions for the main workflows. These specs confirm the application can successfully handle navigation, form submissions, data loading states, error handling, and final display of generated content.",
    "outputName": "e2e_test_suite",
    "promptInstruction": "Create end-to-end test specifications that verify core user flows based on e2e-requirements. Include tests for complete article generation workflow, category selection and filtering, loading states, error messages, data persistence, and navigation between pages. Use Cypress commands and assertions focusing on user-facing functionality."
  },
  {
    "taskID": 235,
    "semanticTitleOfTask": "Testing Documentation Generation",
    "taskDescription": "This task produces a TESTING.md file containing comprehensive documentation on how to install, configure, and run the test suite. It outlines coverage requirements, mocking strategies, best practices, troubleshooting steps, and guidelines for creating new tests.",
    "inputDescription": "We need the test_config_files, component_test_suite, service_test_suite, and e2e_test_suite to document the overall testing approach. Additional developer notes or special instructions regarding coverage, environments, or library usage are also integrated.",
    "inputRequired": [
      "test_config_files",
      "component_test_suite",
      "service_test_suite",
      "e2e_test_suite"
    ],
    "outputDescription": "The output is a detailed TESTING.md (or similarly named) file explaining all facets of the testing process, from setup and environment prerequisites through running and interpreting test results. It also includes guidelines for writing new tests, ensuring coverage, and solving common issues.",
    "outputName": "testing_documentation",
    "promptInstruction": "Create detailed testing documentation that includes setup instructions, commands to run different types of tests, guidelines for writing new tests, mocking strategies, coverage requirements, troubleshooting common issues, and best practices. Document any custom testing utilities or helpers."
  },
  {
    "taskID": 236,
    "semanticTitleOfTask": "Test Suite Integration and Validation",
    "taskDescription": "This final task integrates all test files, ensures folder structures are correct, and validates that they run successfully. It also configures scripts for test execution, coverage reporting, and continuous integration, guaranteeing a cohesive testing pipeline.",
    "inputDescription": "We require the test_config_files, component_test_suite, service_test_suite, e2e_test_suite, and testing_documentation to finalize the continuous integration setup and ensure everything runs smoothly.",
    "inputRequired": [
      "test_config_files",
      "component_test_suite",
      "service_test_suite",
      "e2e_test_suite",
      "testing_documentation"
    ],
    "outputDescription": "A fully integrated test suite with validated scripts and directories, ensuring that developers can run tests locally or in a CI environment with minimal setup. This includes updated npm scripts, pre-commit hooks if desired, and test coverage reports for tracking code health.",
    "outputName": "complete_test_suite",
    "promptInstruction": "Generate scripts and configuration to organize all test files, create npm scripts for different test types, set up pre-commit hooks for test validation, configure CI/CD integration for running tests, and enable coverage and reporting. Ensure that all tests run independently and as part of the complete suite."
  },
  {
    "taskID": 2231,
    "semanticTitleOfTask": "Generate Terms of Service Document",
    "taskDescription": "Uses an LLM to create a comprehensive Terms of Service document for the 'TemuPro Article Generator' application. Covers API usage, disclaimers, user responsibilities, and acceptable use policies. Outputs a Markdown-formatted TOS.",
    "inputDescription": "This task requires a detailed overview of the application (app_description) and its features, including the APIs utilized (api_requirements) along with usage_restrictions, rate_limit_details, user responsibilities, and disclaimers.",
    "inputRequired": [
      "app_description",
      "api_requirements",
      "usage_restrictions",
      "rate_limit_details"
    ],
    "outputDescription": "Delivers a complete Terms of Service document in Markdown, outlining important legal and operational guidelines for the application’s users, integrating notes on content generation, scraping, and third-party data usage.",
    "outputName": "tos_text",
    "promptInstruction": "You are a legal expert. Create a comprehensive Terms of Service document for 'TemuPro Article Generator,' which uses Apify Temu Scraper, YouTube Data API, Google Custom Search API, OpenAI GPT-4, and Firebase. Cover API usage, rate limits, user responsibilities, disclaimers for content generation, and acceptable use policies. Format in Markdown, using clear and legally sound language for non-technical users."
  },
  {
    "taskID": 2232,
    "semanticTitleOfTask": "Generate Legal Disclaimers Text",
    "taskDescription": "Uses an LLM to produce a set of legal disclaimers for data scraping, AI-generated content accuracy, and third-party API usage, ensuring the application’s compliance stance is clear. Outputs a Markdown-formatted disclaimers section.",
    "inputDescription": "This task requires specific information regarding data_usage_requirements, scraping_policies, api_disclaimers, and content_accuracy_requirements. The input guides the LLM to create properly structured disclaimers for web scraping, accuracy limits, and liability.",
    "inputRequired": [
      "data_usage_requirements",
      "scraping_policies",
      "api_disclaimers",
      "content_accuracy_requirements"
    ],
    "outputDescription": "Generates a Markdown-formatted disclaimers text covering automated data collection, potential inaccuracies in AI-generated content, liability limitations, and relevant third-party API usage notes.",
    "outputName": "disclaimers_text",
    "promptInstruction": "You are a legal compliance expert. Create comprehensive disclaimers for an app that scrapes Temu product data and generates AI-written articles. Cover automated data collection, AI-generated content accuracy, third-party API usage, data storage in Firebase, and liability limitations. Format in Markdown. Provide coverage of legal issues related to scraping and content generation."
  },
  {
    "taskID": 2233,
    "semanticTitleOfTask": "Generate Copyright and Data Usage Policy",
    "taskDescription": "Uses an LLM to draft a combined copyright notice and data usage policy, addressing content ownership, data handling, and compliance with relevant regulations. Outputs Markdown-format text clarifying these legal considerations.",
    "inputDescription": "This task requires details on copyright_requirements, data_storage_details, firebase_usage_details, and content_generation_policies. It covers ownership rights of AI-generated articles, usage rights of scraped product data, integration of YouTube content, user data handling in Firebase, data retention policies, and compliance.",
    "inputRequired": [
      "copyright_requirements",
      "data_storage_details",
      "firebase_usage_details",
      "content_generation_policies"
    ],
    "outputDescription": "Delivers a Markdown-formatted document clarifying copyright and data usage terms, outlining intellectual property rights, user data handling, and compliance obligations for the application's features.",
    "outputName": "copyright_policy_text",
    "promptInstruction": "You are a data privacy and copyright expert. Create a copyright notice and data usage policy for an app that generates AI-written articles with scraped product data. Include ownership of AI-generated content, usage rights for scraped data, YouTube content integration, user data handling in Firebase, data retention, user rights, and relevant data protection compliance. Format in Markdown."
  },
  {
    "taskID": 2234,
    "semanticTitleOfTask": "Generate Robots.txt Configuration",
    "taskDescription": "Uses an LLM to produce a suitable robots.txt configuration or snippet for restricting or allowing search engine crawlers on certain paths, along with instructions for Netlify deployment. Output is in Markdown or plain text format.",
    "inputDescription": "This task needs information on crawling_requirements, scraping_restrictions, site_structure regarding which areas must be restricted for crawling, as well as guidelines on API endpoint concealment and how to prevent unwanted scraping or indexing.",
    "inputRequired": [
      "crawling_requirements",
      "scraping_restrictions",
      "site_structure"
    ],
    "outputDescription": "Produces either a complete robots.txt file or a concise snippet with commentary on how to deploy it in a Netlify environment, detailing crawling restrictions and guidance for search engines.",
    "outputName": "robots_txt_content",
    "promptInstruction": "You are a web compliance expert. Create a robots.txt configuration and instructions for a React app hosted on Netlify with public pages and administrative areas. Restrict crawling of API endpoints, guide search engine access to generated content, and address best practices to prevent scraping of sensitive areas. Provide clear Netlify deployment instructions."
  },
  {
    "taskID": 2235,
    "semanticTitleOfTask": "Consolidate All Legal Documentation",
    "taskDescription": "Combines the outputs from the previous tasks into a single Markdown file, adding a table of contents and cohesive formatting for convenient reference. Delivers a standalone LEGAL_COMPLIANCE.md file.",
    "inputDescription": "This task necessitates gathering the tos_text, disclaimers_text, copyright_policy_text, and robots_txt_content from the prior tasks to create one coherent Markdown document with consistent formatting and easy navigation.",
    "inputRequired": [
      "tos_text",
      "disclaimers_text",
      "copyright_policy_text",
      "robots_txt_content"
    ],
    "outputDescription": "Produces a finalized LEGAL_COMPLIANCE.md file that merges all necessary legal, disclaimer, and policy sections into a single, well-structured reference document for the web application.",
    "outputName": "LEGAL_COMPLIANCE_md",
    "promptInstruction": "You are a technical documentation specialist. Combine Terms of Service, Disclaimers, Copyright Notice, Data Usage Policy, and Robots.txt content into LEGAL_COMPLIANCE.md. Provide a table of contents and consistent Markdown formatting. The final text should be easy to navigate, well-structured, and properly formatted for GitHub or web display."
  }
]

Happy? Now Copy-Paste To Proceed...

BACK TO SUBAGENTS

COPY TO CLIPBOARD