@jpetit/toolkit 3.0.22 → 3.1.1

package/lib/compilers/run-python.ts

@@ -1,109 +0,0 @@
-import tui from '../tui'
-import { execa } from 'execa'
-import { cp, exists, rm } from 'fs/promises'
-import { join } from 'path'
-import { readText, writeText } from '../utils'
-import { Compiler } from './base'
-import type { Handler } from '../types'
-
-export class RunPython_Compiler extends Compiler {
-    id(): string {
-        return 'RunPython'
-    }
-
-    name(): string {
-        return 'RunPython'
-    }
-
-    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(handler: Handler, directory: string, sourcePath: string): Promise<void> {
-        const exePath = sourcePath + '.exe'
-
-        if (handler.source_modifier === 'none') {
-            tui.command(`cp ${sourcePath} ${exePath}`)
-            await cp(join(directory, sourcePath), join(directory, exePath))
-        } else {
-            throw new Error(`Unknown source modifier: ${handler.source_modifier as string}`)
-        }
-
-        tui.command(`python3 -m py_compile ${exePath}`)
-
-        const { exitCode } = await execa({
-            reject: false,
-            stderr: 'inherit',
-            stdout: 'inherit',
-            cwd: directory,
-        })`python3 -m py_compile ${exePath}`
-
-        if (exitCode !== 0) throw new Error(`Compilation failed for ${sourcePath}`)
-    }
-
-    override async execute(
-        handler: Handler,
-        directory: string,
-        sourcePath: string,
-        inputPath: string,
-        outputPath: string,
-    ): Promise<void> {
-        const exePath = 'solution.py.exe'
-        if (!(await exists(join(directory, exePath)))) {
-            throw new Error(`Executable file ${exePath} does not exist in directory ${directory}`)
-        }
-
-        const mergedPath = `solution-${inputPath}.py.exe`
-
-        tui.command(`Merging ${exePath} and ${inputPath} into ${mergedPath}`, { italic: true })
-
-        await this.mergeScripts(directory, exePath, inputPath, mergedPath)
-
-        const fullOutputPath = join(directory, outputPath)
-
-        await rm(fullOutputPath, { force: true })
-
-        tui.command(`python3 ${mergedPath} > ${outputPath}`)
-
-        const { exitCode } = await execa({
-            reject: false,
-            stdout: { file: fullOutputPath },
-            stderr: 'inherit',
-            cwd: directory,
-        })`python3 ${mergedPath}`
-
-        if (exitCode !== 0) throw new Error(`Execution failed for ${mergedPath}`)
-    }
-
-    async mergeScripts(
-        directory: string,
-        scriptPath1: string,
-        scriptPath2: string,
-        outputScriptPath: string,
-    ): Promise<void> {
-        const script1 = await readText(join(directory, scriptPath1))
-        const script2 = await readText(join(directory, scriptPath2))
-        const mergedScript = script1 + '\n\n\n' + script2
-        await writeText(join(directory, outputScriptPath), mergedScript)
-    }
-}

package/lib/data.ts

@@ -1,19 +0,0 @@
-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

@@ -1,158 +0,0 @@
-import tui from './tui'
-import { execa } from 'execa'
-import { nothing } from './utils'
-import terminalLink from 'terminal-link'
-
-export async function probePython3(showInfo: boolean = false): Promise<boolean> {
-    if (showInfo) tui.command('python3 --version')
-    const { stdout } = await execa({ reject: false })`python3 --version`
-    const version = stdout.trim()
-    if (showInfo) console.log(version)
-    return version.startsWith('Python 3')
-}
-
-export async function probePythonModule(showInfo: boolean = false, module: string): Promise<boolean> {
-    if (showInfo) tui.command(`python3 -m pip show ${module}`)
-    const { exitCode } = await execa({ reject: false })`python3 -m pip show ${module}`
-    if (showInfo) {
-        if (exitCode === 0) {
-            tui.success(`Module ${module} is installed`)
-        } else {
-            tui.warning(`Module ${module} is not installed`)
-        }
-    }
-    return exitCode === 0
-}
-
-export async function probeGCC(showInfo: boolean = false): Promise<boolean> {
-    if (showInfo) tui.command('g++ --version')
-    const { stdout } = await execa({ reject: false })`g++ --version`
-    const version = stdout.split('\n')[0]!.trim()
-    if (showInfo) console.log(version)
-    return stdout.startsWith('Apple clang') || stdout.startsWith('g++')
-}
-
-export async function probePdfLaTeX(showInfo: boolean = false): Promise<boolean> {
-    if (showInfo) tui.command('pdflatex --version')
-    const { stdout } = await execa({ reject: false })`pdflatex --version`
-    const version = stdout.split('\n')[0]!.trim()
-    if (showInfo) console.log(version)
-    return stdout.startsWith('pdfTeX')
-}
-
-export async function probeXeLaTeX(showInfo: boolean = false): Promise<boolean> {
-    if (showInfo) tui.command('xelatex --version')
-    const { stdout } = await execa({ reject: false })`xelatex --version`
-    const version = stdout.split('\n')[0]!.trim()
-    if (showInfo) console.log(version)
-    return stdout.startsWith('XeTeX')
-}
-
-export async function probePandoc(showInfo: boolean = false): Promise<boolean> {
-    if (showInfo) tui.command('pandoc --version')
-    const { stdout } = await execa({ reject: false })`pandoc --version`
-    const version = stdout.split('\n')[0]!.trim()
-    if (showInfo) console.log(version)
-    return stdout.startsWith('pandoc') && stdout.includes('+lua')
-}
-
-export async function probeImageMagick(showInfo: boolean = false): Promise<boolean> {
-    if (showInfo) tui.command('magick --version')
-    const { stdout } = await execa({ reject: false })`magick --version`
-    const version = stdout.split('\n')[0]!.trim()
-    if (showInfo) console.log(version)
-    return stdout.startsWith('Version: ImageMagick')
-}
-
-export async function checkPython3(): Promise<void> {
-    if (await probePython3(true)) {
-        tui.success('Python3 seems installed')
-        const modules = 'turtle-pil yogi easyinput'.split(' ')
-        for (const m of modules) {
-            await probePythonModule(true, m)
-        }
-    } else {
-        tui.warning('Python3 does not appear to be installed')
-        tui.print('This is not a problem if you do not plan to use Python solutions')
-        tui.print('See https://www.python.org/downloads/')
-    }
-}
-
-export async function checkGCC(): Promise<void> {
-    if (await probeGCC(true)) {
-        tui.success('C/C++ seems installed')
-    } else {
-        tui.warning('C/C++ does not appear to be installed')
-        tui.print('This is not a problem if you do not plan to use C or C++ solutions')
-        tui.print('Please install GCC or Clang')
-    }
-}
-
-export async function checkPdfLaTeX(): Promise<void> {
-    if (await probePdfLaTeX(true)) {
-        tui.success('LaTeX seems installed')
-    } else {
-        tui.warning('LaTeX does not appear to be installed')
-        tui.print('You will not be able to generate PDF statements')
-        tui.print('TODO: Provide instructions for installing LaTeX')
-    }
-}
-
-export async function checkXeLaTeX(): Promise<void> {
-    if (await probeXeLaTeX(true)) {
-        tui.success('XeLaTeX seems installed')
-    } else {
-        tui.warning('XeLaTeX does not appear to be installed')
-        tui.print('You will not be able to generate PDF statements with Unicode support')
-        tui.print('TODO: Provide instructions for installing XeLaTeX')
-    }
-}
-
-export async function checkPandoc(): Promise<void> {
-    if (await probePandoc(true)) {
-        tui.success('Pandoc with Lua support seems installed')
-    } else {
-        tui.warning('Pandoc with Lua support does not appear to be installed')
-        tui.print('You will not be able to generate text statements (HTML, TXT, MD)')
-        tui.print('See https://pandoc.org/installing.html')
-    }
-}
-
-export async function checkImageMagick(): Promise<void> {
-    if (await probeImageMagick(true)) {
-        tui.success('ImageMagick seems installed')
-    } else {
-        tui.warning('ImageMagick does not appear to be installed')
-        tui.print('You will not be able to convert images for text statements')
-        tui.print('See https://imagemagick.org/script/download.php')
-    }
-}
-
-export async function checkEnvVars(): Promise<void> {
-    await nothing()
-    const vars = ['OPENAI_API_KEY', 'GEMINI_API_KEY']
-    for (const v of vars) {
-        if (process.env[v]) {
-            tui.success(`${v} is set`)
-        } else {
-            tui.warning(`${v} is not set`)
-            tui.print(`You will not be able to use related AI models`)
-        }
-    }
-}
-
-export async function checkTerminal(): Promise<void> {
-    await nothing()
-    if (process.stdout.isTTY) {
-        tui.success('Terminal supports TTY')
-    } else {
-        tui.warning('Terminal does not support TTY')
-        tui.print('Some output features may not work as expected')
-    }
-    if (terminalLink.isSupported) {
-        tui.success('Terminal supports hyperlinks')
-    } else {
-        tui.warning('Terminal does not support hyperlinks')
-        tui.print('Links to files may not be clickable')
-    }
-}

package/lib/generate.ts

@@ -1,329 +0,0 @@
-import { ChatBot, cleanMardownCodeString, estimatePowerConsumption } from './ai'
-import tui from './tui'
-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'
-import { nothing, writeText, writeYaml } from './utils'
-import YAML from 'yaml'
-
-const showPrompt = false
-const showAnswer = false
-
-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 nothing()
-            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
-${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 writeText(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 writeYaml(`${path}/problem.en.yml`, yml)
-
-            for (const [lang, translation] of Object.entries(this.problemTranslations)) {
-                await writeText(join(path, `problem.${lang}.tex`), translation)
-                const yml = {
-                    title: getTitleFromStatement(translation) || this.info.title,
-                    translator: this.info.author,
-                    translator_email: this.info.email,
-                    original_language: 'en',
-                    model: this.info.model,
-                }
-                await writeYaml(join(path, `problem.${lang}.yml`), yml)
-            }
-
-            await writeText(join(path, 'sample.inp'), this.problemSampleTests)
-
-            await writeText(join(path, 'test.inp'), this.problemPrivateTests)
-
-            for (const [proglang, solution] of Object.entries(this.problemSolutions)) {
-                const ext = proglang
-                await writeText(join(path, `solution.${ext}`), solution)
-            }
-
-            const handlerYml: any = {
-                handler: 'std',
-            }
-            await writeYaml(join(path, 'handler.yml'), handlerYml)
-
-            await writeText(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
-    }
-}
-
-export function getTitleFromStatement(statement: string): string | null {
-    const pattern = /\\Problem\{(.*?)\}/
-    const match = statement.match(pattern)
-    if (match) {
-        return match[1]!.trim()
-    }
-    return null
-}