@jpetit/toolkit 3.0.23 → 3.1.2

package/lib/compilers/run-python.ts

@@ -1,10 +1,10 @@
-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 { cp } from 'fs/promises'
+import { join, parse } from 'path'
+import tui from '../tui'
 import type { Handler } from '../types'
+import { nothing, readText, toolkitPrefix, writeText } from '../utils'
+import { Compiler } from './base'
 
 export class RunPython_Compiler extends Compiler {
     id(): string {
@@ -35,30 +35,34 @@ export class RunPython_Compiler extends Compiler {
         return ''
     }
 
+    tool(): string {
+        return 'python3'
+    }
+
     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}`)
+    override async compileNormal(handler: Handler, directory: string, sourcePath: string): Promise<string> {
+        tui.command(`python3 -m py_compile ${sourcePath}`)
 
         const { exitCode } = await execa({
             reject: false,
             stderr: 'inherit',
             stdout: 'inherit',
             cwd: directory,
-        })`python3 -m py_compile ${exePath}`
+        })`python3 -m py_compile ${sourcePath}`
 
-        if (exitCode !== 0) throw new Error(`Compilation failed for ${sourcePath}`)
+        if (exitCode !== 0) {
+            throw new Error(`Compilation failed for ${sourcePath}`)
+        }
+
+        return sourcePath
+    }
+
+    override async compileWithMain(handler: Handler, directory: string, sourcePath: string): Promise<string> {
+        await nothing()
+        throw new Error('Method not implemented.')
     }
 
     override async execute(
@@ -68,31 +72,21 @@ export class RunPython_Compiler extends Compiler {
         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)
+        const newSourcePath = `${toolkitPrefix()}-${parse(sourcePath).name}-${parse(inputPath).name}.py`
 
-        await rm(fullOutputPath, { force: true })
+        tui.command(`merge ${sourcePath} ${inputPath} > ${newSourcePath}`)
+        await this.mergeScripts(directory, sourcePath, inputPath, newSourcePath)
 
-        tui.command(`python3 ${mergedPath} > ${outputPath}`)
+        tui.command(`python3 ${newSourcePath} > ${outputPath}`)
 
         const { exitCode } = await execa({
             reject: false,
-            stdout: { file: fullOutputPath },
+            stdout: { file: join(directory, outputPath) },
             stderr: 'inherit',
             cwd: directory,
-        })`python3 ${mergedPath}`
+        })`python3 ${newSourcePath}`
 
-        if (exitCode !== 0) throw new Error(`Execution failed for ${mergedPath}`)
+        if (exitCode !== 0) throw new Error(`Execution failed for ${newSourcePath}`)
     }
 
     async mergeScripts(

package/lib/compilers/rust.ts

@@ -0,0 +1,39 @@
+import { Compiler } from './base'
+
+export class Rust_Compiler extends Compiler {
+    id(): string {
+        return 'Rust'
+    }
+
+    name(): string {
+        return 'Rust Compiler'
+    }
+
+    type(): string {
+        return 'compiler'
+    }
+
+    language(): string {
+        return 'Rust'
+    }
+
+    async version(): Promise<string> {
+        return await this.getVersion('rustc --version', 0)
+    }
+
+    flags1(): string {
+        return '-C opt-level=2 -D warnings'
+    }
+
+    flags2(): string {
+        return '-C opt-level=2 -D warnings'
+    }
+
+    tool(): string {
+        return 'rustc'
+    }
+
+    extension(): string {
+        return 'rs'
+    }
+}

package/lib/create-with-jutgeai.ts

@@ -0,0 +1,407 @@
+import * as prompts from '@inquirer/prompts'
+import { exists, mkdir } from 'fs/promises'
+import Handlebars from 'handlebars'
+import checkboxPlus from 'inquirer-checkbox-plus-plus'
+import { join } from 'path'
+import YAML from 'yaml'
+import { ChatBot, cleanMardownCodeString, estimatePowerConsumption } from './ai'
+import { languageNames, proglangNames } from './data'
+import { getPromptForProglang, getTitleFromStatement } from './helpers'
+import { settings } from './settings'
+import tui from './tui'
+import { Specification } from './types'
+import { nothing, projectDir, readText, readYaml, writeTextInDir, writeYaml, writeYamlInDir } from './utils'
+
+const promptsDir = join(projectDir(), 'assets', 'prompts')
+
+const latexExample = await readText(join(promptsDir, 'examples', 'statement.tex'))
+const statementCoda = await readText(join(promptsDir, 'examples', 'statement-coda.tex'))
+const systemPrompt = await readText(join(promptsDir, 'creators', 'system-prompt.txt'))
+const statementPromptTemplate = await readText(join(promptsDir, 'creators', 'create-statement.tpl.txt'))
+const translationPromptTemplate = await readText(join(promptsDir, 'creators', 'create-translation.tpl.txt'))
+const solutionPromptTemplate = await readText(join(promptsDir, 'creators', 'create-solution.tpl.txt'))
+const sampleTestCasesPrompt = await readText(join(promptsDir, 'creators', 'sample-test-cases.txt'))
+const privateTestCasesPrompt = await readText(join(promptsDir, 'creators', 'private-test-cases.txt'))
+
+export async function createProblemWithJutgeAI(
+    model: string,
+    directory: string,
+    inputPath: string | undefined,
+    outputPath: string | undefined,
+    doNotAsk: boolean,
+) {
+    if (await exists(directory)) {
+        throw new Error(`Directory ${directory} already exists`)
+    }
+    if (!directory.endsWith('.pbm')) {
+        throw new Error('The output directory must end with .pbm')
+    }
+
+    const spec = await getSpecification(inputPath, outputPath, doNotAsk)
+    const generator = new ProblemGenerator(spec, model)
+    await generator.run()
+    await generator.save(directory)
+    tui.success(`Created problem ${tui.hyperlink(directory)}`)
+}
+
+async function getSpecification(
+    inputPath: string | undefined,
+    outputPath: string | undefined,
+    doNotAsk: boolean,
+): Promise<Specification> {
+    let spec: Specification
+    if (inputPath) {
+        tui.action(`Reading specification from ${inputPath}`)
+        const data = await readYaml(inputPath)
+        spec = Specification.parse(data)
+    } else {
+        doNotAsk = true
+        spec = {
+            title: 'Your new problem title',
+            description: 'Describe the task of the problem here.',
+            author: settings.name || 'Your Name',
+            email: settings.email || 'email@example.com',
+            golden_proglang: 'cc',
+            more_proglangs: ['py'],
+            original_language: 'en',
+            more_languages: ['ca', 'es'],
+            generators: ['hard', 'random', 'efficiency'],
+        }
+    }
+
+    if (doNotAsk) {
+        return spec
+    }
+
+    while (true) {
+        spec.title = await prompts.input({ message: 'Title:', default: spec.title, prefill: 'editable' })
+
+        spec.description = await prompts.input({
+            message: 'Description:',
+            default: spec.description,
+            prefill: 'editable',
+        })
+
+        spec.author = await prompts.input({ message: 'Author:', default: spec.author, prefill: 'editable' })
+
+        spec.email = await prompts.input({ message: 'Email:', default: spec.email, prefill: 'editable' })
+
+        spec.original_language = await prompts.select({
+            message: `Language for original version:`,
+            choices: Object.entries(languageNames).map(([value, name]) => ({ value, name })),
+            default: spec.original_language,
+        })
+
+        spec.more_languages = await checkboxPlus({
+            message: `Other languages:`,
+            searchable: false,
+            // eslint-disable-next-line @typescript-eslint/require-await
+            source: async (answers, input) =>
+                Object.entries(languageNames)
+                    .filter(([value]) => value !== spec.original_language)
+                    .map(([value, name]) => ({ value, name })),
+            default: spec.more_languages,
+            loop: false,
+        })
+
+        spec.golden_proglang = await prompts.select({
+            message: `Programming language for golden solution:`,
+            choices: Object.entries(proglangNames).map(([value, name]) => ({ value, name })),
+            default: spec.golden_proglang,
+        })
+
+        spec.more_proglangs = await checkboxPlus({
+            message: `Other programming languages for solutions:`,
+            // eslint-disable-next-line @typescript-eslint/require-await
+            source: async (answers, input) =>
+                Object.entries(proglangNames)
+                    .filter(([value]) => value !== spec.golden_proglang)
+                    .map(([value, name]) => ({ value, name })),
+            default: spec.more_proglangs,
+        })
+
+        spec.generators = await checkboxPlus({
+            message: `Test case generators:`,
+            // eslint-disable-next-line @typescript-eslint/require-await
+            source: async (answers, input) => [
+                { value: 'random', name: 'Random' },
+                { value: 'hard', name: 'Hard' },
+                { value: 'efficiency', name: 'Efficiency' },
+            ],
+            default: spec.generators,
+        })
+
+        const action = await prompts.select({
+            message: 'Choose an action:',
+            choices: [
+                {
+                    value: 'confirm',
+                    name: 'Confirm',
+                    description: 'Confirm specification and proceed to problem creation',
+                },
+                { value: 'edit', name: 'Edit', description: 'Edit the specification' },
+                { value: 'cancel', name: 'Cancel', description: 'Cancel problem creation' },
+            ],
+        })
+        if (action === 'confirm') break
+        if (action === 'cancel') {
+            tui.print('Problem creation cancelled')
+            process.exit(0)
+        }
+    }
+
+    if (outputPath) {
+        await writeYaml(outputPath, spec)
+        tui.success(`Specification file written at ${tui.hyperlink(outputPath)}`)
+    }
+
+    return spec
+}
+
+class ProblemGenerator {
+    private model: string
+    private spec: Specification
+    private bot: ChatBot
+
+    // generated problem parts
+    private problemStatement: string = ''
+    private problemMoreStatements: Record<string, string> = {}
+    private problemMoreSolutions: Record<string, string> = {}
+    private problemGenerators: Record<string, string> = {}
+    private problemSampleTests1: string = ''
+    private problemSampleTests2: string = ''
+    private problemPrivateTests1: string = ''
+    private problemPrivateTests2: string = ''
+    private problemReadme: string = ''
+
+    constructor(info: Specification, model: string) {
+        this.model = model
+        this.spec = info
+        this.bot = new ChatBot(model, systemPrompt)
+    }
+
+    async generateStatement(): Promise<string> {
+        return await tui.section(
+            `Generating problem statement in ${languageNames[this.spec.original_language]}`,
+            async () => {
+                const statementPrompt = Handlebars.compile(statementPromptTemplate)({
+                    language: languageNames[this.spec.original_language],
+                    latexExample,
+                    title: this.spec.title,
+                    description: this.spec.description,
+                })
+                const answer = await this.bot.complete(statementPrompt)
+                return cleanMardownCodeString(answer) + statementCoda
+            },
+        )
+    }
+
+    async generateSampleTests(): Promise<string> {
+        return await tui.section('Generating sample test cases', async () => {
+            const answer = await this.bot.complete(sampleTestCasesPrompt)
+            return cleanMardownCodeString(answer)
+        })
+    }
+
+    async generatePrivateTests(): Promise<string> {
+        return await tui.section('Generating private test cases', async () => {
+            const answer = await this.bot.complete(privateTestCasesPrompt)
+            return cleanMardownCodeString(answer)
+        })
+    }
+
+    async generateSolutions(): Promise<Record<string, string>> {
+        return await tui.section('Generating solutions', async () => {
+            const solutions: Record<string, string> = {}
+            for (const proglang of this.spec.more_proglangs.concat([this.spec.golden_proglang]).reverse()) {
+                await tui.section(`Generating solution in ${proglangNames[proglang]}`, async () => {
+                    const proglangPrompt = await getPromptForProglang(proglang)
+                    const solutionPrompt = Handlebars.compile(solutionPromptTemplate)({
+                        proglang: proglangNames[proglang],
+                        proglangPrompt,
+                    })
+                    const answer = await this.bot.complete(solutionPrompt)
+                    solutions[proglang] = cleanMardownCodeString(answer)
+                    this.bot.forgetLastInteraction()
+                })
+            }
+            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.spec.more_languages.sort()) {
+                await tui.section(`Translating to ${languageNames[language]}`, async () => {
+                    const translationPrompt = Handlebars.compile(translationPromptTemplate)({
+                        language: languageNames[language],
+                    })
+                    const answer = await this.bot.complete(translationPrompt)
+                    translations[language] = cleanMardownCodeString(answer) + statementCoda
+                    this.bot.forgetLastInteraction()
+                })
+            }
+            return translations
+        })
+    }
+
+    async generateGenerators(): Promise<Record<string, string>> {
+        return await tui.section('Generating test cases generators', async () => {
+            const generators: Record<string, string> = {}
+            for (const type of this.spec.generators) {
+                await tui.section(`Generating ${type} test cases generator`, async () => {
+                    const statement = this.problemStatement
+                    const promptPath = join(projectDir(), 'assets', 'prompts', 'generators', `${type}.md`)
+                    const promptTemplate = await readText(promptPath)
+                    const prompt = Handlebars.compile(promptTemplate)({ statement })
+                    const answer = cleanMardownCodeString(await this.bot.complete(prompt))
+                    generators[type] = answer
+                })
+            }
+            return generators
+        })
+    }
+
+    async generateReadme(): Promise<string> {
+        return tui.section('Generating README.md', async () => {
+            await nothing()
+            const readme = `
+# Problem information
+
+This programming problem for Jutge.org was generated by Jutge<sup>AI</sup> through the Jutge.org API using ${this.model} and a prompt by ${this.spec.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.spec.author}
+
+## Problem title
+
+${this.spec.title}
+
+## Problem description
+
+${this.spec.description}
+
+## Generated solutions
+
+- ${proglangNames[this.spec.golden_proglang]} (golden solution)
+${listify(this.spec.more_proglangs.map((proglang) => proglangNames[proglang]))}
+
+## Generated languages
+
+- ${languageNames[this.spec.original_language]} (original)
+${listify(this.spec.more_languages.map((language) => languageNames[language]))}
+
+## Generated test case generators
+
+${listify(this.spec.generators)}
+
+## Problem specification
+
+\`\`\`yaml
+${YAML.stringify(this.spec, null, 4)}
+\`\`\`
+
+## 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() {
+        await tui.section('Generating problem with JutgeAI', async () => {
+            await this.bot.init()
+            this.problemStatement = await this.generateStatement()
+            this.problemSampleTests1 = await this.generateSampleTests()
+            this.bot.forgetLastInteraction() // forget first sample tests
+            this.problemSampleTests2 = await this.generateSampleTests()
+            this.problemPrivateTests1 = await this.generatePrivateTests()
+            this.bot.forgetLastInteraction() // forget first private tests
+            this.problemPrivateTests2 = await this.generatePrivateTests()
+            this.problemMoreSolutions = await this.generateSolutions() // these are forgotten inside
+            this.bot.forgetLastInteraction() // forget private tests
+            this.bot.forgetLastInteraction() // forget sample tests
+            this.problemMoreStatements = await this.translateStatements()
+            this.bot.forgetLastInteraction() // forget translations
+            this.problemGenerators = await this.generateGenerators() // these are forgotten inside
+            this.problemReadme = await this.generateReadme()
+        })
+    }
+
+    async save(path: string) {
+        await tui.section(`Saving problem to ${path}`, async () => {
+            await mkdir(path, { recursive: true })
+            await writeTextInDir(path, 'problem.en.tex', this.problemStatement)
+
+            const yml = {
+                title: this.spec.title,
+                author: this.spec.author,
+                email: this.spec.email,
+                model: this.model,
+            }
+            await writeYamlInDir(path, 'problem.en.yml', yml)
+
+            for (const [lang, translation] of Object.entries(this.problemMoreStatements)) {
+                await writeTextInDir(path, `problem.${lang}.tex`, translation)
+                const yml = {
+                    title: getTitleFromStatement(translation) || this.spec.title,
+                    translator: this.spec.author,
+                    translator_email: this.spec.email,
+                    original_language: 'en',
+                    model: this.model,
+                }
+                await writeYamlInDir(path, `problem.${lang}.yml`, yml)
+            }
+
+            await writeTextInDir(path, 'sample-1.inp', this.problemSampleTests1)
+            await writeTextInDir(path, 'sample-2.inp', this.problemSampleTests2)
+
+            await writeTextInDir(path, 'test-1.inp', this.problemPrivateTests1)
+            await writeTextInDir(path, 'test-2.inp', this.problemPrivateTests2)
+
+            for (const [proglang, solution] of Object.entries(this.problemMoreSolutions)) {
+                const ext = proglang
+                await writeTextInDir(path, `solution.${ext}`, solution)
+            }
+
+            for (const [type, code] of Object.entries(this.problemGenerators)) {
+                await writeTextInDir(path, `generate-${type}.py`, code)
+            }
+
+            const handlerYml: any = {
+                handler: 'std',
+                solution: proglangNames[this.spec.golden_proglang],
+            }
+            await writeYamlInDir(path, 'handler.yml', handlerYml)
+
+            await writeTextInDir(path, 'README.md', this.problemReadme)
+        })
+    }
+}
+
+function listify(items: (string | undefined)[]): string {
+    if (items.length === 0) {
+        return '<none>'
+    }
+    return items.map((item) => `- ${item}`).join('\n')
+}

package/lib/create-with-template.ts

@@ -0,0 +1,55 @@
+import { confirm, select, Separator } from '@inquirer/prompts'
+import { cp, exists, glob } from 'fs/promises'
+import path from 'path'
+import tui from './tui'
+import { projectDir, readText } from './utils'
+import { title } from 'radash'
+
+const templatesDir = path.join(projectDir(), 'assets', 'problems')
+
+export async function selectTemplate(): Promise<string> {
+    const choices = []
+
+    const dirs = await Array.fromAsync(glob('*', { cwd: templatesDir }))
+    dirs.sort()
+    for (const dir of dirs) {
+        choices.push(new Separator(title(dir)))
+        const templates = await Array.fromAsync(glob('*.pbm', { cwd: path.join(templatesDir, dir) }))
+        templates.sort()
+        for (const template of templates) {
+            choices.push({ name: template, value: path.join(dir, template) })
+        }
+    }
+
+    let template: string | undefined = undefined
+    while (true) {
+        template = await select({ message: 'Select a template:', choices, default: template })
+        const readme = await readText(path.join(templatesDir, template, 'README.md'))
+        console.log()
+        await tui.markdown(readme)
+        const confirmation = await confirm({ message: `Use template ${template}?`, default: true })
+        if (confirmation) return template
+    }
+}
+
+export async function createProblemWithTemplate(directory: string, template: string | undefined) {
+    if (await exists(directory)) {
+        throw new Error(`Directory ${directory} already exists`)
+    }
+    if (!directory.endsWith('.pbm')) {
+        throw new Error('The output directory must end with .pbm')
+    }
+
+    if (!template) {
+        template = await selectTemplate()
+    }
+
+    const templatePath = path.join(templatesDir, template)
+
+    if (!(await exists(templatePath))) {
+        throw new Error(`Template ${template} does not exist`)
+    }
+
+    await cp(templatePath, directory, { recursive: true })
+    tui.success(`Created problem ${tui.hyperlink(directory)} from template ${template}`)
+}

package/lib/data.ts

@@ -8,12 +8,18 @@ export const languageNames: Record<string, string> = {
     de: 'German',
 }
 
+export const languageKeys = Object.keys(languageNames)
+
 export const proglangNames: Record<string, string> = {
     c: 'C',
     cc: 'C++',
     py: 'Python3',
     hs: 'Haskell',
     clj: 'Clojure',
+    java: 'Java',
+    rs: 'Rust',
 }
 
 export const proglangExtensions: Record<string, string> = invert(proglangNames)
+
+export const proglangKeys = Object.keys(proglangNames)