@jpetit/toolkit 3.0.0

package/lib/compilers/gcc.ts

@@ -0,0 +1,47 @@
+import * as tui from '@/lib/tui.js'
+import { Compiler } from './base'
+import { rm, exists } from 'fs/promises'
+import { join } from 'path'
+
+export class Compiler_GCC extends Compiler {
+    id(): string {
+        return 'GCC'
+    }
+
+    name(): string {
+        return 'GNU C Compiler'
+    }
+
+    type(): string {
+        return 'compiler'
+    }
+
+    language(): string {
+        return 'C'
+    }
+
+    async version(): Promise<string> {
+        return await this.getVersion('gcc --version', 0)
+    }
+
+    flags1(): string {
+        return '-D_JUDGE_ -O2 -DNDEBUG -Wall -Wextra -Wno-sign-compare'
+    }
+
+    flags2(): string {
+        return ''
+    }
+
+    extension(): string {
+        return 'c'
+    }
+
+    async compile(directory: string, sourcePath: string): Promise<void> {
+        const outputPath = sourcePath + '.exe'
+        const fullOutputPath = join(directory, outputPath)
+        await rm(fullOutputPath, { force: true })
+        tui.command(`gcc ${this.flags1()} ${sourcePath} -o ${outputPath}`)
+        await Bun.$`gcc ${this.flags1().split(' ')} ${sourcePath} -o ${outputPath}`.cwd(directory).nothrow()
+        if (!(await exists(fullOutputPath))) throw new Error(`Compilation failed for ${sourcePath}`)
+    }
+}

package/lib/compilers/gxx.ts

@@ -0,0 +1,47 @@
+import { rm, exists } from 'fs/promises'
+import { Compiler } from './base'
+import chalk from 'chalk'
+import { join } from 'path'
+
+export class Compiler_GXX extends Compiler {
+    id(): string {
+        return 'GXX'
+    }
+
+    name(): string {
+        return 'GNU C++ Compiler'
+    }
+
+    type(): string {
+        return 'compiler'
+    }
+
+    language(): string {
+        return 'C++'
+    }
+
+    async version(): Promise<string> {
+        return await this.getVersion('g++ --version', 0)
+    }
+
+    flags1(): string {
+        return '-std=c++11 -D_JUDGE_ -O2 -DNDEBUG -Wall -Wextra -Wno-sign-compare -Wshadow'
+    }
+
+    flags2(): string {
+        return '-std=c++11 -D_JUDGE_ -O2 -DNDEBUG -Wall -Wextra -Wno-sign-compare -Wshadow'
+    }
+
+    extension(): string {
+        return 'cc'
+    }
+
+    async compile(directory: string, sourcePath: string): Promise<void> {
+        const outputPath = sourcePath + '.exe'
+        const fullOutputPath = join(directory, outputPath)
+        await rm(fullOutputPath, { force: true })
+        console.log(chalk.magenta(`❯ g++ ${this.flags1()} ${sourcePath} -o ${outputPath}`))
+        await Bun.$`g++ ${this.flags1().split(' ')} ${sourcePath} -o ${outputPath}`.cwd(directory).nothrow()
+        if (!(await exists(fullOutputPath))) throw new Error(`Compilation failed for ${sourcePath}`)
+    }
+}

package/lib/compilers/index.ts

@@ -0,0 +1,61 @@
+import { Compiler, type CompilerInfo } from './base'
+import { Compiler_GCC } from './gcc'
+import { Compiler_GXX } from './gxx'
+import { Compiler_Python3 } from './python3'
+
+const compilersRegistryById: Record<string, new () => Compiler> = {
+    C: Compiler_GCC,
+    'C++': Compiler_GXX,
+    Python3: Compiler_Python3,
+}
+
+const compilersRegistryByExtension: Record<string, new () => Compiler> = {
+    c: Compiler_GCC,
+    cc: Compiler_GXX,
+    py: Compiler_Python3,
+}
+
+export function getCompilerById(id: string): Compiler {
+    const CompilerClass = compilersRegistryById[id]
+    if (!CompilerClass) throw new Error(`Compiler '${id}' is not defined`)
+    const compilerInstance = new CompilerClass()
+    return compilerInstance
+}
+
+export function getCompilerByExtension(extension: string): Compiler {
+    const CompilerClass = compilersRegistryByExtension[extension]
+    if (!CompilerClass) throw new Error(`No compiler defined for extension '.${extension}'`)
+    const compilerInstance = new CompilerClass()
+    return compilerInstance
+}
+
+export async function getDefinedCompilerIds(): Promise<string[]> {
+    await Bun.sleep(0) // to make function async
+    return Object.keys(compilersRegistryById)
+}
+
+export async function getAvailableCompilers(): Promise<string[]> {
+    const available: string[] = []
+    for (const id of Object.keys(compilersRegistryById)) {
+        const CompilerClass = compilersRegistryById[id]!
+        const compilerInstance = new CompilerClass()
+        if (await compilerInstance.available()) {
+            available.push(id)
+        }
+    }
+    return available
+}
+
+export async function getCompilerInfo(id: string): Promise<CompilerInfo> {
+    const compilerInstance = getCompilerById(id)
+    if (!compilerInstance) throw new Error(`Compiler '${id}' is not defined`)
+    return await compilerInstance.info()
+}
+
+export async function getCompilersInfo(): Promise<Record<string, CompilerInfo>> {
+    const infos: Record<string, CompilerInfo> = {}
+    for (const id of Object.keys(compilersRegistryById)) {
+        infos[id] = await getCompilerInfo(id)
+    }
+    return infos
+}

package/lib/compilers/python3.ts

@@ -0,0 +1,67 @@
+import * as tui from '@/lib/tui.js'
+import { exists, rm } from 'fs/promises'
+import { join } from 'path'
+import { Compiler } from './base'
+
+export class Compiler_Python3 extends Compiler {
+    id(): string {
+        return 'Python3'
+    }
+
+    name(): string {
+        return 'Python3'
+    }
+
+    type(): string {
+        return 'interpreter'
+    }
+
+    language(): string {
+        return 'Python'
+    }
+
+    async version(): Promise<string> {
+        return await this.getVersion('python3 --version', 0)
+    }
+
+    flags1(): string {
+        return ''
+    }
+
+    flags2(): string {
+        return ''
+    }
+
+    extension(): string {
+        return 'py'
+    }
+
+    async compile(directory: string, sourcePath: string): Promise<void> {
+        tui.command(`python3 -m py_compile ${sourcePath}`)
+        console.log('directory:', directory, 'sourcePath:', sourcePath)
+        const { exitCode } = await Bun.$`python3 -m py_compile ${sourcePath}`.cwd(directory).nothrow()
+        if (exitCode !== 0) throw new Error(`Compilation failed for ${sourcePath}`)
+    }
+
+    override async execute(directory: string, inputPath: string, outputPath: string): Promise<void> {
+        const sourcePath = 'solution.py'
+        if (!(await exists(join(directory, sourcePath)))) {
+            throw new Error(`Source file ${sourcePath} does not exist in directory ${directory}`)
+        }
+        const fullInputPath = join(directory, inputPath)
+        const fullOutputPath = join(directory, outputPath)
+        await rm(fullOutputPath, { force: true })
+        tui.command(`python3 ${sourcePath} < ${inputPath} > ${outputPath}`)
+
+        const proc = Bun.spawn(['python3', sourcePath], {
+            cwd: directory,
+            stdin: Bun.file(fullInputPath),
+            stdout: Bun.file(fullOutputPath),
+            stderr: 'inherit',
+        })
+        await proc.exited
+        const exitCode = proc.exitCode
+
+        if (exitCode !== 0) throw new Error(`Execution failed for ${sourcePath}`)
+    }
+}

package/lib/data.ts

@@ -0,0 +1,19 @@
+import { invert } from 'radash'
+
+export const languageNames: Record<string, string> = {
+    en: 'English',
+    ca: 'Catalan',
+    es: 'Spanish',
+    fr: 'French',
+    de: 'German',
+}
+
+export const proglangNames: Record<string, string> = {
+    c: 'C',
+    cc: 'C++',
+    py: 'Python3',
+    hs: 'Haskell',
+    clj: 'Clojure',
+}
+
+export const proglangExtensions: Record<string, string> = invert(proglangNames)

package/lib/doctor.ts

@@ -0,0 +1,104 @@
+import chalk from 'chalk'
+import * as tui from '@/lib/tui.js'
+
+export async function probePython3(showInfo: boolean = false): Promise<boolean> {
+    if (showInfo) tui.command('python3 --version')
+    const output = await Bun.$`python3 --version`.nothrow().text()
+    const version = output.trim()
+    if (showInfo) console.log(version)
+    return version.startsWith('Python 3')
+}
+
+export async function probeGCC(showInfo: boolean = false): Promise<boolean> {
+    if (showInfo) tui.command('g++ --version')
+    const output = await Bun.$`g++ --version`.nothrow().text()
+    const version = output.split('\n')[0]!.trim()
+    if (showInfo) console.log(version)
+    return output.startsWith('Apple clang') || output.startsWith('g++')
+}
+
+export async function probeLaTeX(showInfo: boolean = false): Promise<boolean> {
+    if (showInfo) tui.command('pdflatex --version')
+    const output = await Bun.$`pdflatex --version`.nothrow().text()
+    const version = output.split('\n')[0]!.trim()
+    if (showInfo) console.log(version)
+    return output.startsWith('pdfTeX')
+}
+
+export async function probePandoc(showInfo: boolean = false): Promise<boolean> {
+    if (showInfo) tui.command('pandoc --version')
+    const output = await Bun.$`pandoc --version`.nothrow().text()
+    const version = output.split('\n')[0]!.trim()
+    if (showInfo) console.log(version)
+    return output.startsWith('pandoc') && output.includes('+lua')
+}
+
+export async function probeImageMagick(showInfo: boolean = false): Promise<boolean> {
+    if (showInfo) tui.command('magick --version')
+    const output = await Bun.$`magick --version`.nothrow().text()
+    const version = output.split('\n')[0]!.trim()
+    if (showInfo) console.log(version)
+    return output.startsWith('Version: ImageMagick')
+}
+
+export async function checkPython3(): Promise<void> {
+    if (await probePython3(true)) {
+        tui.success('Python3 seems installed')
+    } else {
+        tui.error('Python3 does not appear to be installed')
+        tui.warning('This is not a problem if you do not plan to use Python solutions.')
+        tui.warning('See https://www.python.org/downloads/')
+    }
+}
+
+export async function checkGCC(): Promise<void> {
+    if (await probeGCC(true)) {
+        tui.success('C/C++ seems installed')
+    } else {
+        tui.error('C/C++ does not appear to be installed')
+        tui.warning('This is not a problem if you do not plan to use C or C++ solutions.')
+        tui.warning('Please install GCC or Clang.')
+    }
+}
+
+export async function checkLaTeX(): Promise<void> {
+    if (await probeLaTeX(true)) {
+        tui.success('LaTeX seems installed')
+    } else {
+        tui.error('LaTeX does not appear to be installed')
+        tui.warning('You will not be able to generate PDF statements.')
+        tui.warning('TODO: Provide instructions for installing LaTeX')
+    }
+}
+
+export async function checkPandoc(): Promise<void> {
+    if (await probePandoc(true)) {
+        tui.success('Pandoc with Lua support seems installed')
+    } else {
+        tui.error('Pandoc with Lua support does not appear to be installed')
+        tui.warning('You will not be able to generate text statements (HTML, TXT, MD).')
+        tui.warning('See https://pandoc.org/installing.html')
+    }
+}
+
+export async function checkImageMagick(): Promise<void> {
+    if (await probeImageMagick(true)) {
+        tui.success('ImageMagick seems installed')
+    } else {
+        tui.error('ImageMagick does not appear to be installed')
+        tui.warning('You will not be able to convert images for text statements.')
+        tui.warning('See https://imagemagick.org/script/download.php')
+    }
+}
+
+export async function checkEnvVars(): Promise<void> {
+    await Bun.sleep(0) // to prevent "async function has no await" warning
+    const vars = ['OPENAI_API_KEY', 'GEMINI_API_KEY']
+    for (const v of vars) {
+        if (process.env[v]) {
+            tui.success(`${v} is set`)
+        } else {
+            tui.error(`${v} is not set`)
+        }
+    }
+}

package/lib/generate.ts

@@ -0,0 +1,333 @@
+import { ChatBot, estimatePowerConsumption } from '@/lib/ai'
+import * as tui from '@/lib/tui.js'
+import chalk from 'chalk'
+import { appendFile, mkdir } from 'fs/promises'
+import { oraPromise } from 'ora'
+import { join } from 'path'
+import { z } from 'zod'
+import { paths } from './settings'
+import { proglangNames, languageNames } from './data'
+
+const showPrompt = true
+const showAnswer = true
+
+export const ZProblemData = z.object({
+    title: z.string(),
+    description: z.string(),
+    author: z.string(),
+    email: z.string().email(),
+    type: z.string(),
+    proglangs: z.array(z.string()),
+    languages: z.array(z.string()),
+    model: z.string(),
+    outputDir: z.string(),
+})
+
+export type ProblemData = z.infer<typeof ZProblemData>
+
+export async function generateProblemWithJutgeAI(info: ProblemData): Promise<void> {
+    const generator = new ProblemGenerator(info)
+    await generator.run()
+    await generator.save(info.outputDir)
+}
+
+class ProblemGenerator {
+    private bot: ChatBot
+    private info: ProblemData
+
+    // generated problem parts
+    private problemStatement: string = ''
+    private problemSampleTests: string = ''
+    private problemPrivateTests: string = ''
+    private problemSolutions: Record<string, string> = {}
+    private problemTranslations: Record<string, string> = {}
+    private problemReadme: string = ''
+
+    private latexExample = `
+\\Problem{Which one is missing?}
+
+\\Statement
+
+Johny has a list of objects, labeled between 1 and $n$, but he lost one of them. He wants to know which one is missing.
+
+\\medskip
+
+Write a program that reads sequences with all the numbers between 1 and $n$ but one, and tells which one is missing.
+
+\\Input
+
+Input consists of several sequences.
+Every sequence begins with a number $n$ between~1 and~$10^4$ followed by $n - 1$ natural numbers.
+Every number between 1 and $n$ appears exactly once, except one of them, which is missing.
+
+\\Output
+
+For every sequence, print the missing number.
+`
+
+    private systemPrompt = `
+You are an expert in coding and writing programmming problems.
+You provide accurate information and write following the instructed format.
+`
+
+    private statementCoda = `
+
+\\Observation
+
+This problem has been generated by Jutge$^{\\text{AI}}$. Remove this observation after reviewing it carefully.
+
+\\Sample
+
+`
+    constructor(info: ProblemData) {
+        this.info = info
+        this.bot = new ChatBot(info.model, this.systemPrompt)
+    }
+
+    async generateStatement(): Promise<string> {
+        return await tui.section('Generating problem statement', async () => {
+            const statementPrompt = `
+You are to write the statement of a programming problem
+
+The statement must be written in LaTeX, using a few predefined macros.
+Use LaTeX math syntax for formulas and variables.
+Use dollars for inline maths and use \\[ and \\] for display maths.
+Do not add input/output test cases in the statement.
+Separate paragraphs by a blank line and \\medskip macro.
+
+Write in the style of Salvador Roura, the famous problem setter from Jutge.org.
+
+Here is an example for an unrelated problem, follow its structure and macros:
+
+${this.latexExample}
+
+The title for this problem is:
+
+${this.info.title}
+
+Here is the description of this problem and some additional instructions:
+
+${this.info.description}
+`
+            const answer = cleanMardownCodeString(await this.complete(statementPrompt)) + this.statementCoda
+            return answer
+        })
+    }
+
+    async generateSampleTests(): Promise<string> {
+        return await tui.section('Generating sample test cases', async () => {
+            const sampleTestCasesPrompt = `
+Now, write a sample test case file to illustrate the input that the program must read according to the problem statement.
+
+Only the input should be given, the output will be computed from it.
+Sample test cases should be relatively small but cover interesting cases but not all edge cases.
+`
+            const answer = cleanMardownCodeString(await this.complete(sampleTestCasesPrompt))
+            return answer
+        })
+    }
+
+    async generatePrivateTests(): Promise<string> {
+        return await tui.section('Generating private test cases', async () => {
+            const privateTestCasesPrompt = `
+Now, write a private test case file to check the correctness and efficiency of the program.
+
+Only the input should be given, the output will be computed from it.
+The private test cases should cover edge cases.
+Limit the number of test cases to 20.
+`
+            const answer = cleanMardownCodeString(await this.complete(privateTestCasesPrompt))
+            return answer
+        })
+    }
+
+    async generateSolutions(): Promise<Record<string, string>> {
+        return await tui.section('Generating solutions', async () => {
+            const solutions: Record<string, string> = {}
+            for (const proglang of this.info.proglangs) {
+                await tui.section(`Generating solution in ${proglangNames[proglang]}`, async () => {
+                    const solutionPrompt = `
+Now, write a solution in ${proglangNames[proglang]} to solve this problem
+
+It must be written in an idiomatic way and only include relevant comments.
+The code must be efficient and handle all edge cases.
+The code must read from standard input and write to standard output.
+The code must be well written and easy to understand to novices.
+The code does not have to check the preconditions stated in the probleM
+Do not use any non-standard libraries.
+${proglang === 'cpp' ? 'Do not use fast input/output methods.' : ''}
+${proglang === 'cpp' ? 'Add a using namespace std; declaration after the includes and do not use std:: prefixes.' : ''}
+${proglang === 'py' ? 'Use type annotations.' : ''}
+`
+                    const answer = cleanMardownCodeString(await this.complete(solutionPrompt))
+                    this.bot.forgetLastInteraction()
+                    solutions[proglang] = answer
+                })
+            }
+            return solutions
+        })
+    }
+
+    async translateStatements(): Promise<Record<string, string>> {
+        return await tui.section('Translating problem statements', async () => {
+            const translations: Record<string, string> = {}
+            for (const language of this.info.languages) {
+                await tui.section(`Translating to ${languageNames[language]}`, async () => {
+                    const translationPrompt = `
+Now, translate the problem statement to ${languageNames[language]}.
+
+The translation must be accurate and use proper technical terminology.
+Maintain the LaTeX formatting and macros.
+The texts that the program must read and write should not be translated.
+`
+                    const answer = cleanMardownCodeString(await this.complete(translationPrompt)) + this.statementCoda
+                    this.bot.forgetLastInteraction()
+                    translations[language] = answer
+                })
+            }
+            return translations
+        })
+    }
+
+    async generateReadme(): Promise<string> {
+        return tui.section('Generating README.md', async () => {
+            await Bun.sleep(0)
+            const readme = `
+# ${this.info.title}
+
+This programming problem for Jutge.org was generated by Jutge<sup>AI</sup> through the Jutge.org API using ${this.info.model} and a prompt by ${this.info.author}.
+
+**Warning**: This problem may contain inaccuracies or errors. Review the problem statements, test cases, and solutions carefully before using them in a real setting. Output tests and statement PDFs have not been generated, use \`jutge-make-problem\` to generate them.
+
+## Author
+
+${this.info.author}
+
+## Original prompt
+
+${this.info.description}
+
+## Generated solutions
+
+- ${this.info.proglangs.map((proglang) => proglangNames[proglang]).join('\n- ')}
+
+## Generated languages
+
+- English
+- ${this.info.languages.map((language) => languageNames[language]).join('\n- ')}
+
+## Model information
+
+\`\`\`yaml
+${Bun.YAML.stringify(this.bot.modelInformation(), null, 2)}
+\`\`\`
+
+## Estimated cost
+
+The following information is based on estimations from token counts and do not reflect the actual costs incurred. Using GPT-5 pricing as reference.
+
+- Total input tokens:   ${this.bot.totalInputTokens}
+- Total output tokens:  ${this.bot.totalOutputTokens}
+- Total input cost:     ${this.bot.totalInputCost.toFixed(6)} USD
+- Total output cost:    ${this.bot.totalOutputCost.toFixed(6)} USD
+- Total estimated cost: ${(this.bot.totalInputCost + this.bot.totalOutputCost).toFixed(6)} USD
+- Energy:               ${estimatePowerConsumption(this.bot.totalInputTokens, this.bot.totalOutputTokens).wattHours.toFixed(6)} Wh
+- CO₂ emissions:        ${estimatePowerConsumption(this.bot.totalInputTokens, this.bot.totalOutputTokens).co2Grams.toFixed(6)} g CO₂
+
+`
+            return readme
+        })
+    }
+
+    async run() {
+        tui.title('Generating problem with JutgeAI')
+        await this.bot.init()
+        this.problemStatement = await this.generateStatement()
+        this.problemSampleTests = await this.generateSampleTests()
+        this.problemPrivateTests = await this.generatePrivateTests()
+        this.problemSolutions = await this.generateSolutions() // these are forgotten inside
+        this.bot.forgetLastInteraction() // forget private tests
+        this.bot.forgetLastInteraction() // forget sample tests
+        this.problemTranslations = await this.translateStatements()
+        this.problemReadme = await this.generateReadme()
+    }
+
+    async save(path: string) {
+        await tui.section(`Saving problem to ${path}`, async () => {
+            await mkdir(path, { recursive: true })
+            await Bun.write(join(path, 'problem.en.tex'), this.problemStatement)
+
+            const yml = {
+                title: this.info.title,
+                author: this.info.author,
+                email: this.info.email,
+                model: this.info.model,
+            }
+            await Bun.write(`${path}/problem.en.yml`, Bun.YAML.stringify(yml, null, 2) + '\n')
+
+            for (const [lang, translation] of Object.entries(this.problemTranslations)) {
+                await Bun.write(join(path, `problem.${lang}.tex`), translation)
+                const yml = {
+                    title: getTitleFromTranslation(translation) || this.info.title,
+                    translator: this.info.author,
+                    translator_email: this.info.email,
+                    original_language: 'en',
+                    model: this.info.model,
+                }
+                await Bun.write(join(path, `problem.${lang}.yml`), Bun.YAML.stringify(yml, null, 2) + '\n')
+            }
+
+            await Bun.write(join(path, 'sample.inp'), this.problemSampleTests)
+
+            await Bun.write(join(path, 'test.inp'), this.problemPrivateTests)
+
+            for (const [proglang, solution] of Object.entries(this.problemSolutions)) {
+                const ext = proglang
+                await Bun.write(join(path, `solution.${ext}`), solution)
+            }
+
+            const handlerYml: any = {
+                handler: 'std',
+            }
+            await Bun.write(join(path, 'handler.yml'), Bun.YAML.stringify(handlerYml, null, 2) + '\n')
+
+            await Bun.write(join(path, 'README.md'), this.problemReadme)
+        })
+    }
+
+    async complete(prompt: string): Promise<string> {
+        if (showPrompt) console.log(chalk.gray(prompt))
+        await appendFile(join(paths.log, 'jutge-ai.log'), '------------------- PROMPT -------------------\n\n')
+        await appendFile(join(paths.log, 'jutge-ai.log'), prompt + '\n\n')
+
+        const answer = await oraPromise(
+            async () => {
+                return await this.bot.complete(prompt)
+            },
+            {
+                text: `JutgeAI is thinking`,
+            },
+        )
+
+        if (showAnswer) console.log(chalk.gray(answer))
+        await appendFile(join(paths.log, 'jutge-ai.log'), '------------------- ANSWER -------------------\n\n')
+        await appendFile(join(paths.log, 'jutge-ai.log'), answer + '\n\n')
+
+        return answer
+    }
+}
+
+function getTitleFromTranslation(translation: string): string | null {
+    const pattern = /\\Problem\{(.*?)\}/
+    const match = translation.match(pattern)
+    if (match) {
+        return match[1]!.trim()
+    }
+    return null
+}
+
+function cleanMardownCodeString(s: string): string {
+    const pattern = /^\n*```\w*\s*(.*?)\s*```\n*$/s
+    const clean = s.replace(pattern, '$1')
+    return clean
+}