Currently, we are using my own account devjiwonchoi and devjiwonchoi_equine to test the assets. We should find a better way to test this.

• Messaging - message.send()

• Stream incoming events - bot.events()
• Get online bots - bot.online()
• Upgrade to Bot account - bot.upgrade()
• Stream Bot game state - bot.stream()
• Make a Bot move - bot.move()
• Write in the chat - (POST) bot.chat()
• Fetch the game chat - (GET) bot.chat()
• Abort a game - bot.abort()
• Resign a game - bot.resign()

• https://lichess.org/api/team/{teamId}/users

Maybe with nextra?

• users/status
• player
• player/top/{nb}/{perfType}
• user/{username}
• user/{username}/rating-history
• user/{username}/perf/{perf}
• user/{username}/activity
• users - POST
• #5
• streamer/live
• crosstable/{user1}/{user2}
• autocomplete
• user/{username}/note - POST
• user/{username}/note - GET

// berserk

client.users.get_realtime_statuses ✅ 
client.users.get_all_top_10 ✅ 
client.users.get_leaderboard ✅ 
client.users.get_public_data ✅ 
client.users.get_activity_feed ✅ 
client.users.get_by_id ✅ 
client.users.get_by_team ❓ 
client.users.get_live_streamers ✅ 
client.users.get_rating_history ✅ 
client.users.get_crosstable ✅ 
client.users.get_user_performance ✅ 

Use native fetch instead of node-fetch

• Get users followed by the logged in user - relations.following()
• Follow a player - relations.follow()
• Unfollow a player - relations.unfollow()

I'm assuming that by adding challenge, we'll be able to test against board.

• List your challenges - challenge.list()
• Create a challenge - challenge.create()
• Accept a challenge - challenge.accept()
• Decline a challenge - challenge.decline()
• Cancel a challenge - challenge.cancel()
• Challenge the AI - challenge.ai()
• Open-ended challenge - challenge.open()
• Start clocks of a game - challenge.start()
• Add time to the opponent clock - challenge.grant()
• Admin challenge tokens - challenge.admin()

• Get current TV games - tv.current()
• Stream current TV game - tv.stream()
• Get best ongoing games of a TV channel - tv.ongoing()

• Add CI pipeline
• Add pulls template
• Modify package.json for better access
• Add README

Some methods take a single param as an object and some takes as multiple.
Convert all to take as an object, with consistent naming.

What is the Issue?

Fetcher only supports endpoints starting with /api

The LICHESS_API_URL constant starts with /api, which I am assuming is for convenience. This means that any provided endpoint must start with /api to be used by the fetcher. However, while working on the Study API, I noticed that the study.studies() method is not compatible with the current fetcher structure because its endpoint does not start with /api.

Fetcher only supports JSON endpoints

Moreover, the study.chapter() and study.chapters() methods return PGN, which is in string format. These responses cannot be JSON parsed. The current fetcher implementation always parses the response as JSON, which means that these methods are also not compatible with the current fetcher.

My proposal

In order to support these exceptions in the current fetcher, and to be more futureproof, why don't we add an additional parameter fetchOptions to the fetcher? Here, we can define a custom API url (in case it does not start with the lichess API url, for example), state whether the response should be parsed through JSON, or, perhaps in the future, whether the response is in nd-json format and needs to be streamed instead. I can self-assign this issue (with your approval, of course) since I am already busy with the Study API.

• [Simuls](Get current simuls) - simuls.info()

• Analysis - analysis.evaluate()

• Stream incoming events - board.events()
• Create a seek - board.seek()
• Stream Board game state - board.stream()
• Make a Board move - board.move()
• Write in the chat - (POST) board.chat() vs game.chat()
• Fetch the game chat - (GET) board.chat() vs game.chat()
• Abort a game - board.abort() vs game.abort()
• Resign a game - board.resign() vs game.resign()
• Handle draw offers - board.draw() vs game.draw()
• Handle takeback offers - board.takeback() vs game.takeback()
• Claim victory of a game - board.victory() vs game.victory()
• Berserk a tournament game - board.BERSERK() vs game.BERSERK()

• Export one study chapter - studies.export({ studyId, chapterId })
• Export all chapters - studies.export({ studyId })
• Export all studies of a user - studies.export({ username })
• Study metadata - studies.metadata()
• List studies of a user - user.studies() vs studies.user()

Hi,

Hope you're doing great. I wanted to ask whether you're open to contributions, and whether the following additions you'd consider useful:

• Increasing the Coverage of Lichess API: there're some endpoints that I was missing
• Zod Parsers for Data Sanity: This would help make sure our data's always in the right shape and give us clearer error messages when it's not. Plus, I'd like to implement it in a way where we could skip this step if needed.
• Better Error Messages: Building on the parsers to help us figure out whether the responses are as expected.

If all, or some of these, are interesting to you, I'd be happy to implement them. I already have some of the code for my personal project. If not, of course, no worries.
And, lastly, I'd like to ask whether there are any contribution guidelines, standards you'd like pull requests to meet (tests, coding style, whatever).

Hope all is good with you, cheers!
Lukas