@jpetit/toolkit 3.0.23 → 3.1.2

package/lib/doctor.ts

@@ -1,7 +1,7 @@
-import tui from './tui'
 import { execa } from 'execa'
-import { nothing } from './utils'
 import terminalLink from 'terminal-link'
+import tui from './tui'
+import { nothing } from './utils'
 
 export async function probePython3(showInfo: boolean = false): Promise<boolean> {
     if (showInfo) tui.command('python3 --version')
@@ -32,6 +32,38 @@ export async function probeGCC(showInfo: boolean = false): Promise<boolean> {
     return stdout.startsWith('Apple clang') || stdout.startsWith('g++')
 }
 
+export async function probeHaskell(showInfo: boolean = false): Promise<boolean> {
+    if (showInfo) tui.command('ghc --version')
+    const { stdout } = await execa({ reject: false })`ghc --version`
+    const version = stdout.split('\n')[0]!.trim()
+    if (showInfo) console.log(version)
+    return stdout.startsWith('The Glorious Glasgow Haskell Compilation System')
+}
+
+export async function probeClojure(showInfo: boolean = false): Promise<boolean> {
+    if (showInfo) tui.command('clj --version')
+    const { stdout } = await execa({ reject: false })`clj --version`
+    const version = stdout.split('\n')[0]!.trim()
+    if (showInfo) console.log(version)
+    return stdout.startsWith('Clojure')
+}
+
+export async function probeJava(showInfo: boolean = false): Promise<boolean> {
+    if (showInfo) tui.command('javac -version')
+    const { stdout } = await execa({ reject: false })`javac -version`
+    const version = stdout.split('\n')[0]!.trim()
+    if (showInfo) console.log(version)
+    return stdout.startsWith('javac')
+}
+
+export async function probeRust(showInfo: boolean = false): Promise<boolean> {
+    if (showInfo) tui.command('rustc --version')
+    const { stdout } = await execa({ reject: false })`rustc --version`
+    const version = stdout.split('\n')[0]!.trim()
+    if (showInfo) console.log(version)
+    return stdout.startsWith('rustc')
+}
+
 export async function probePdfLaTeX(showInfo: boolean = false): Promise<boolean> {
     if (showInfo) tui.command('pdflatex --version')
     const { stdout } = await execa({ reject: false })`pdflatex --version`
@@ -77,7 +109,6 @@ export async function checkPython3(): Promise<void> {
         tui.print('See https://www.python.org/downloads/')
     }
 }
-
 export async function checkGCC(): Promise<void> {
     if (await probeGCC(true)) {
         tui.success('C/C++ seems installed')
@@ -88,6 +119,46 @@ export async function checkGCC(): Promise<void> {
     }
 }
 
+export async function checkHaskell(): Promise<void> {
+    if (await probeHaskell(true)) {
+        tui.success('Haskell seems installed')
+    } else {
+        tui.warning('Haskell does not appear to be installed')
+        tui.print('This is not a problem if you do not plan to use Haskell solutions')
+        tui.print('See https://www.haskell.org/ghc/download.html')
+    }
+}
+
+export async function checkClojure(): Promise<void> {
+    if (await probeClojure(true)) {
+        tui.success('Clojure seems installed')
+    } else {
+        tui.warning('Clojure does not appear to be installed')
+        tui.print('This is not a problem if you do not plan to use Clojure solutions')
+        tui.print('See https://clojure.org/guides/getting_started')
+    }
+}
+
+export async function checkJava(): Promise<void> {
+    if (await probeJava(true)) {
+        tui.success('Java seems installed')
+    } else {
+        tui.warning('Java does not appear to be installed')
+        tui.print('You will not be able to compile/execute Java solutions')
+        tui.print('See https://www.oracle.com/java/technologies/javase-jdk11-downloads.html')
+    }
+}
+
+export async function checkRust(): Promise<void> {
+    if (await probeRust(true)) {
+        tui.success('Rust seems installed')
+    } else {
+        tui.warning('Rust does not appear to be installed')
+        tui.print('You will not be able to compile/execute Rust solutions')
+        tui.print('See https://www.rust-lang.org/tools/install')
+    }
+}
+
 export async function checkPdfLaTeX(): Promise<void> {
     if (await probePdfLaTeX(true)) {
         tui.success('LaTeX seems installed')
@@ -128,14 +199,14 @@ export async function checkImageMagick(): Promise<void> {
     }
 }
 
-export async function checkEnvVars(): Promise<void> {
+export async function checkAIEnvVars(): 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`)
+            tui.success(`${v} environment variable is set`)
         } else {
-            tui.warning(`${v} is not set`)
+            tui.warning(`${v} environment variable is not set`)
             tui.print(`You will not be able to use related AI models`)
         }
     }
@@ -155,4 +226,13 @@ export async function checkTerminal(): Promise<void> {
         tui.warning('Terminal does not support hyperlinks')
         tui.print('Links to files may not be clickable')
     }
+
+    const vars = ['EDITOR', 'VISUAL']
+    for (const v of vars) {
+        if (process.env[v]) {
+            tui.success(`${v} environment variable is set to "${process.env[v]}"`)
+        } else {
+            tui.warning(`${v} environment variable is not set`)
+        }
+    }
 }

package/lib/generate.ts

@@ -1,329 +1,171 @@
-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 Handlebars from 'handlebars'
 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.
+import { cleanMardownCodeString, complete } from './ai'
+import { languageKeys, languageNames, proglangExtensions, proglangKeys, proglangNames } from './data'
+import { getPromptForProglang, getTitleFromStatement } from './helpers'
+import type { Inspector } from './inspector'
+import { settings } from './settings'
+import tui from './tui'
+import { projectDir, readText, readTextInDir, stripLaTeX, writeTextInDir, writeYamlInDir } from './utils'
+import { exists } from 'fs/promises'
 
-\\Sample
+export async function addStatementTranslation(model: string, inspector: Inspector, language: string) {
+    const original = inspector.originalLanguage
 
-`
-    constructor(info: ProblemData) {
-        this.info = info
-        this.bot = new ChatBot(info.model, this.systemPrompt)
+    if (!original) {
+        throw new Error('Original language not set, cannot generate translations')
+    }
+    if (language === original) {
+        throw new Error(`Language ${language} is the original language`)
+    }
+    if (inspector.languages.includes(language)) {
+        throw new Error(`Language ${language} already exists`)
+    }
+    if (!languageKeys.includes(language)) {
+        throw new Error(`Language ${language} is not supported`)
     }
 
-    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:
+    const statememt = await readTextInDir(inspector.directory, `problem.${original}.tex`)
 
-${this.info.title}
+    await tui.section(`Translating from ${languageNames[original]} to ${languageNames[language]}`, async () => {
+        const prompt = `
+Translate the given problem statement to ${languageNames[language]}.
 
-Here is the description of this problem and some additional instructions:
+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 complete(model, prompt, statememt))
+
+        const info = {
+            title: getTitleFromStatement(answer) || 'Error translating title',
+            translator: settings.name,
+            translator_email: settings.email,
+            model,
+        }
+        await writeTextInDir(inspector.directory, `problem.${language}.tex`, answer)
+        await writeYamlInDir(inspector.directory, `problem.${language}.yml`, info)
+
+        tui.success(`Translation completed: files problem.${language}.tex and problem.${language}.yml created`)
+        tui.warning(`Please review the generated translation`)
+    })
+}
 
-${this.info.description}
-`
-            const answer = cleanMardownCodeString(await this.complete(statementPrompt)) + this.statementCoda
-            return answer
-        })
+export async function addAlternativeSolution(model: string, inspector: Inspector, extension: string) {
+    if (!inspector.goldenSolution) {
+        throw new Error('No golden solution defined')
     }
-
-    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
-        })
+    const originalExtension = inspector.goldenSolution.split('.').pop()
+    if (!originalExtension) {
+        throw new Error('Invalid golden solution filename')
     }
-
-    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
-        })
+    if (!proglangKeys.includes(extension)) {
+        throw new Error(`Extension ${extension} is not supported`)
+    }
+    if (inspector.solutions.includes(`solution.${extension}`)) {
+        throw new Error(`Solution already exists`)
     }
+    const proglang = proglangNames[extension]
 
-    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
-        })
+    if (!proglang) {
+        throw new Error(`Programming language for extension ${extension} not found`)
     }
 
-    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]}.
+    const originalProglang = proglangNames[originalExtension]
 
-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
-        })
-    }
+    const goldenSource = await readTextInDir(inspector.directory, inspector.goldenSolution)
 
-    async generateReadme(): Promise<string> {
-        return tui.section('Generating README.md', async () => {
-            await nothing()
-            const readme = `
-# ${this.info.title}
+    const proglangPrompt = await getPromptForProglang(proglang)
 
-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}.
+    const prompt = `
+Convert the given program in ${originalProglang} to ${proglang}.
 
-**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.
+The translation must be accurate and follow the structure and logic of the original program.
+Each function should have a documentation comment explaining its purpose, parameters, and return values.
 
-## Author
+If some function in the original program is not defined, do not define it in the translated program either.
 
-${this.info.author}
+Your program should start with a comment line saying 'Generated by ${model}'.
 
-## Original prompt
+${proglangPrompt}
+    `
 
-${this.info.description}
+    const answer = cleanMardownCodeString(await complete(model, prompt, goldenSource))
 
-## Generated solutions
+    await writeTextInDir(inspector.directory, `solution.${extension}`, answer)
 
-- ${this.info.proglangs.map((proglang) => proglangNames[proglang]).join('\n- ')}
+    tui.success(`solution.${extension} created`)
+    tui.warning(`Please review the generated solution`)
+}
 
-## Generated languages
+// TODO: check this function
+export async function addMainFile(model: string, inspector: Inspector, proglang: string) {
+    if (!inspector.goldenSolution) {
+        throw new Error('No golden solution defined')
+    }
 
-- English
-- ${this.info.languages.map((language) => languageNames[language]).join('\n- ')}
+    const originalExtension = inspector.goldenSolution.split('.').pop()
+    if (!originalExtension) {
+        throw new Error('Invalid golden solution filename')
+    }
+    const originalProglang = proglangNames[originalExtension]
 
-## Model information
+    const goldenSource = await readTextInDir(inspector.directory, `main.${originalExtension}`)
 
-\`\`\`yaml
-${YAML.stringify(this.bot.modelInformation(), null, 2)}
-\`\`\`
+    await tui.section(`Converting main.${originalExtension} to ${proglang}`, async () => {
+        const proglangPrompt = await getPromptForProglang(proglang)
 
-## Estimated cost
+        const prompt = `
+Convert the given program in ${originalProglang} to ${proglang}.
 
-The following information is based on estimations from token counts and do not reflect the actual costs incurred. Using GPT-5 pricing as reference.
+The translation must be accurate and follow the structure and logic of the original program.
 
-- 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₂
+If some function in the original program is not defined, do not define it in the translated program either.
 
-`
-            return readme
-        })
-    }
+Your program should start with a comment line saying 'Generated by ${model}'.
 
-    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()
-    }
+${proglangPrompt}
+    `
 
-    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)
-        })
-    }
+        const answer = cleanMardownCodeString(await complete(model, prompt, goldenSource))
 
-    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
-    }
+        await writeTextInDir(inspector.directory, `main.${proglangExtensions[proglang]}`, answer)
+
+        tui.success(`main.${proglang} created`)
+        tui.warning(`Please review the generated file`)
+    })
+}
+
+export async function generateTestCasesGenerator(
+    model: string,
+    inspector: Inspector,
+    output: string, // file to create (template with {{type}})
+    type: 'random' | 'hard' | 'efficiency',
+) {
+    const outputPath = Handlebars.compile(output)({ type })
+    await tui.section(`Generating test cases generator ${outputPath}`, async () => {
+        const statement = await getStatementAsText(inspector)
+        const promptPath = join(projectDir(), 'assets', 'prompts', 'generators', `${type}.md`)
+        const promptTemplate = await readText(promptPath)
+        const prompt = Handlebars.compile(promptTemplate)({ statement })
+        const answer = cleanMardownCodeString(await complete(model, '', prompt))
+        await writeTextInDir(inspector.directory, outputPath, answer)
+        tui.success(`Test cases generator ${outputPath} generated`)
+        tui.warning(`Please review the generated test cases generator`)
+    })
 }
 
-export function getTitleFromStatement(statement: string): string | null {
-    const pattern = /\\Problem\{(.*?)\}/
-    const match = statement.match(pattern)
-    if (match) {
-        return match[1]!.trim()
+// TODO: move into inspector?
+export async function getStatementAsText(inspector: Inspector): Promise<string> {
+    const original = inspector.originalLanguage
+    if (!original) throw new Error('Original language not set')
+    if (await exists(join(inspector.directory, `problem.${original}.txt`))) {
+        const text = await readTextInDir(inspector.directory, `problem.${original}.txt`)
+        return text
+    } else {
+        const latex = await readTextInDir(inspector.directory, `problem.${original}.tex`)
+        const text = stripLaTeX(latex)
+        return text
     }
-    return null
 }

package/lib/helpers.ts

@@ -0,0 +1,48 @@
+import { exists } from 'fs/promises'
+import { projectDir, readText } from './utils'
+import { join } from 'path'
+import { normalize, resolve } from 'node:path'
+import { languageNames } from './data'
+
+export function getTitleFromStatement(statement: string): string | null {
+    const pattern = /\\Problem\{(.*?)\}/
+    const match = statement.match(pattern)
+    if (match) {
+        return match[1]!.trim()
+    }
+    return null
+}
+
+export async function getPromptForProglang(proglang: string): Promise<string> {
+    const location = join(projectDir(), 'assets', 'prompts', `${proglang}.md`)
+    if (await exists(location)) {
+        return await readText(location)
+    } else {
+        return ''
+    }
+}
+
+/*
+    Find real problem directories from a list of directories. A real problem directory is one that contains a handler.yml file.
+    If a directory does not contain a handler.yml file, check if it contains subdirectories for each language that contain a handler.yml file.
+    If so, add those subdirectories to the list of real problem directories.
+*/
+export async function findRealDirectories(directories: string[]): Promise<string[]> {
+    const realDirectories: string[] = []
+    for (let dir of directories) {
+        if (dir === '.') {
+            dir = normalize(resolve(process.cwd()))
+        }
+        if (await exists(join(dir, 'handler.yml'))) {
+            realDirectories.push(dir)
+        } else {
+            for (const language of Object.keys(languageNames).sort()) {
+                const child = join(dir, language, 'handler.yml')
+                if (await exists(child)) {
+                    realDirectories.push(resolve(dir, language))
+                }
+            }
+        }
+    }
+    return realDirectories
+}