@jpetit/toolkit 3.0.23 → 3.1.2

package/toolkit/generate.ts

@@ -1,116 +1,213 @@
-import tui from '../lib/tui'
-import { Maker, newMaker, type MakerOptions } from '../lib/maker'
-import { guessUserEmail, guessUserName, nothing, readText, writeText, writeYaml } from '../lib/utils'
-import { Command } from '@commander-js/extra-typings'
-import { languageNames } from '../lib/data'
+import { Argument, Command } from '@commander-js/extra-typings'
 import { join } from 'path'
-import { cleanMardownCodeString, complete } from '../lib/ai'
-import { getTitleFromStatement } from '../lib/generate'
-import { writeFile } from 'fs/promises'
-import * as jdenticon from 'jdenticon'
-
-type Options = {
-    directory: string
-    verbose: boolean
-    model: string
-}
-
-export const generate = new Command('generate')
-    .description('Generate additional components')
-    // Add common options here
-    .option('-d, --directory <path>', 'problem directory', process.cwd()) // TODO: use '.' when bun fixes it
-    .option('-v, --verbose', 'verbose output (TODO)')
+import sharp from 'sharp'
+import {
+    addAlternativeSolution,
+    addMainFile,
+    addStatementTranslation,
+    generateTestCasesGenerator,
+} from '../lib/generate'
+import { complete, generateImage } from '../lib/ai'
+import { languageKeys, languageNames, proglangKeys } from '../lib/data'
+import { newInspector } from '../lib/inspector'
+import tui from '../lib/tui'
+import { writeText } from '../lib/utils'
+
+export const generateCmd = new Command('generate')
+    .description('Generate elements using JutgeAI')
+
+    .action(() => {
+        generateCmd.help()
+    })
+
+generateCmd
+    .command('translations')
+    .summary('Generate statement translations using JutgeAI')
+    .description(
+        `Generate statement translations using JutgeAI
+    
+Use this command to add translations of the problem statement into different languages.
+The original statement will be used as the source text for translation.
+
+Provide one or more target language from the following list:
+${Object.entries(languageNames)
+    .map(([key, name]) => `  - ${key}: ${name}`)
+    .join('\n')}
+
+The added translations will be saved in the problem directory overwrite possible existing files.`,
+    )
+
+    .addArgument(new Argument('<languages...>', 'languages to add').choices(languageKeys))
+    .option('-d, --directory <path>', 'problem directory', '.')
     .option(
         '-m, --model <model>',
-        'the AI model to use (eg: openai/gpt-5, google/gemini-2.5-pro, ...)',
+        'AI model to use (eg: openai/gpt-5, google/gemini-2.5-pro, ...)',
         'google/gemini-2.5-flash-lite',
     )
 
-generate
-    .command('translations')
-    .description('Generate statement translations')
-    .argument('<languages...>', 'languages to generate')
-
-    .action(async (languages, options, command) => {
-        const parentOptions = (command.parent?.opts() || {}) as any as Options
-        const maker = await newMaker(parentOptions)
-
-        await tui.section('Generating translations', async () => {
+    .action(async (languages, { directory, model }) => {
+        const inspector = await newInspector(directory)
+        await tui.section('Generating statement translations', async () => {
             for (const language of languages) {
-                await generateTranslation(parentOptions.model, maker, language)
+                await addStatementTranslation(model, inspector, language)
             }
         })
     })
 
-generate
-    .command('award')
-    .description('Generate random award')
-
-    .action(async (options, command) => {
-        const parentOptions = (command.parent?.opts() || {}) as any as Options
-        const maker = await newMaker(parentOptions)
-
-        await tui.section('Generating award', async () => {
-            const png = jdenticon.toPng(maker.directory, 200)
-            await writeFile(join(maker.directory, 'award.png'), png)
-            await writeText(join(maker.directory, 'award.html'), '<b>Well done!</b>\n')
-            tui.success(
-                'Award generated: ' +
-                    tui.hyperlink(maker.directory, 'award.png') +
-                    ' and ' +
-                    tui.hyperlink(maker.directory, 'award.html'),
-            )
-            await tui.image(join(maker.directory, 'award.png'), 6, 3)
-        })
-    })
-
-generate
+generateCmd
     .command('solutions')
-    .description('Generate solutions TODO')
-    .argument('<proglangs...>', 'programming languages to generate')
+    .summary('Generate alternative solutions using JutgeAI')
+    .description(
+        `Generate alternative solutions using JutgeAI
 
-    .action(async (proglangs, options, command) => {
-        await nothing()
-        throw new Error('Not implemented yet')
+Use this command to add alternative solutions for the problem in different programming languages.
+The golden solution will be used as a reference for generating the alternatives.
+
+Provide one or more target programming languages from the following list:
+${Object.entries(languageNames)
+    .map(([key, name]) => `  - ${key}: ${name}`)
+    .join('\n')}
+
+The added solutions will be saved in the problem directory overwrite possible existing files.`,
+    )
+
+    .addArgument(new Argument('<proglangs...>', 'proglangs to add').choices(proglangKeys))
+    .option('-d, --directory <path>', 'problem directory', '.')
+    .option(
+        '-m, --model <model>',
+        'AI model to use (eg: openai/gpt-5, google/gemini-2.5-pro, ...)',
+        'google/gemini-2.5-flash-lite',
+    )
+
+    .action(async (proglangs, { directory, model }) => {
+        const inspector = await newInspector(directory)
+        for (const proglang of proglangs) {
+            await addAlternativeSolution(model, inspector, proglang)
+        }
     })
 
-async function generateTranslation(model: string, maker: Maker, language: string) {
-    const original = maker.originalLanguage
-    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 (maker.languages.includes(language)) {
-        throw new Error(`Language ${language} already exists`)
-    }
-
-    const statememt = await readText(join(maker.directory, `problem.${original}.tex`))
-
-    await tui.section(`Translating from ${languageNames[original]} to ${languageNames[language]}`, async () => {
-        const prompt = `
-Translate the given 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.
-    `
-
-        tui.action(`Generating translation with ${model}`)
-
-        const answer = cleanMardownCodeString(await complete(model, prompt, statememt))
-
-        const info = {
-            title: getTitleFromStatement(answer) || 'Error translating title',
-            translator: (await guessUserName()) || 'Unknown',
-            translator_email: (await guessUserEmail()) || 'unknown',
-            model,
+generateCmd
+    .command('mains')
+    .summary('Generate main files using JutgeAI')
+    .description(
+        `Generate main files using JutgeAI
+
+Main files are the entry point for problems that ask users to implement specific functions or classes.
+
+Use this command to add main files for the problem in different programming languages.
+The main file for the golden solution will be used as a reference for generating the main files.
+
+Provide one or more target programming languages from the following list:
+${Object.entries(languageNames)
+    .map(([key, name]) => `  - ${key}: ${name}`)
+    .join('\n')}
+
+The added main files will be saved in the problem directory overwrite possible existing files.`,
+    )
+
+    .addArgument(new Argument('<proglangs...>', 'proglangs to add').choices(proglangKeys))
+    .option('-d, --directory <path>', 'problem directory', '.')
+    .option(
+        '-m, --model <model>',
+        'AI model to use (eg: openai/gpt-5, google/gemini-2.5-pro, ...)',
+        'google/gemini-2.5-flash-lite',
+    )
+
+    .action(async (proglangs, { directory, model }) => {
+        const inspector = await newInspector(directory)
+        for (const proglang of proglangs) {
+            await addMainFile(model, inspector, proglang)
         }
-        await writeText(join(maker.directory, `problem.${language}.tex`), answer)
-        await writeYaml(join(maker.directory, `problem.${language}.yml`), info)
+    })
+
+generateCmd
+    .command('award.png')
+    .summary('Generate award.png using JutgeAI')
+    .description(
+        `Generate award.png using AI
+    
+Use this command to add an award image for the problem.
+Awards are shown to users when they solve the problem.
+They help to motivate users and make the platform more engaging.
+
+Provide an interesting prompt to customize the image content. For example:
+    - "A golden trophy with a blue ribbon on a wooden base."
+    - "A star made of sparkling diamonds on a black background."
+    - "A minimalist image with a white background using Van Gogh style."
+
+The new image will be saved as award.png in the problem directory, overriding any existing file.`,
+    )
+
+    .option('-d, --directory <path>', 'problem directory', '.')
+    .option('-m, --model <model>', 'graphic AI model to use', 'openai/dall-e-3')
+    .argument('[prompt]', 'prompt to generate the image', 'A colorful image on a white background. ')
+
+    .action(async (prompt, { directory, model }) => {
+        const output = join(directory, 'award.png')
+        const inspector = await newInspector(directory)
+        const image = await generateImage(model, prompt)
+        await sharp(image).resize(512, 512).toFile(output)
+        await tui.image(output, 20, 10)
+        tui.success(`Added ${output}`)
+    })
+
+generateCmd
+    .command('award.html')
+    .summary('Generate award.html using JutgeAI')
+    .description(
+        `Generate award.html using JutgeAI
+
+Use this command to add an award message for the problem.
+Awards are shown to users when they solve the problem.
+They help to motivate users and make the platform more engaging.
 
-        tui.success(`Translation completed: files problem.${language}.tex and problem.${language}.yml created`)
-        tui.warning(`Please review the generated translation`)
+Provide an interesting prompt to customize the message content. For example:
+- "A short encouraging message after having solved a challenge or a problem."
+- "A congratulatory message for completing a difficult task."
+- "A motivational quote to inspire further learning."
+
+The new message will be saved as award.html in the problem directory, overriding any existing file.`,
+    )
+
+    .option('-d, --directory <path>', 'problem directory', '.')
+    .argument(
+        '[prompt]',
+        'prompt to generate the award message',
+        'Only provide a short encouraging message after having solved a challenge or a problem. Nothing else!',
+    )
+    .option('-m, --model <model>', 'AI model to use', 'google/gemini-2.5-flash-lite')
+
+    .action(async (prompt, { directory, model }) => {
+        const output = join(directory, 'award.html')
+        const inspector = await newInspector(directory)
+        const message = await complete(model, '', prompt)
+        tui.print(message)
+        await writeText(output, message)
+        tui.success(`Added ${output}`)
+    })
+
+generateCmd
+    .command('generator')
+    .summary('Generate test cases generators using JutgeAI')
+
+    .option('--random', 'add a random test case generator')
+    .option('--hard', 'add a hard test case generator')
+    .option('--efficiency', 'add an efficiency test case generator')
+    .option('--all', 'add all three test case generators')
+
+    .option('-d, --directory <path>', 'problem directory', '.')
+    .option('-o, --output <path>', 'output file', 'generator-{{type}}.py')
+    .option(
+        '-m, --model <model>',
+        'AI model to use (eg: openai/gpt-5, google/gemini-2.5-pro, ...)',
+        'google/gemini-2.5-flash-lite',
+    )
+
+    .action(async ({ efficiency, hard, random, all, directory, model, output }) => {
+        const inspector = await newInspector(directory)
+        await tui.section('Generating test cases generators', async () => {
+            if (all || random) await generateTestCasesGenerator(model, inspector, output, 'random')
+            if (all || hard) await generateTestCasesGenerator(model, inspector, output, 'hard')
+            if (all || efficiency) await generateTestCasesGenerator(model, inspector, output, 'efficiency')
+        })
     })
-}

package/toolkit/index.ts

@@ -1,34 +1,44 @@
 #!/usr/bin/env bun
 
 import { program } from '@commander-js/extra-typings'
-import { confirm } from '@inquirer/prompts'
 import { join } from 'path'
-import { ai } from './ai'
-import { clean } from './clean'
-import { compilers } from './compilers'
-import { create } from './create'
-import { doctor } from './doctor'
-import { init } from './init'
-import { make } from './make'
-import { verify } from './verify'
-import { generate } from './generate'
+import { ZodError } from 'zod'
+import { fromError } from 'zod-validation-error'
+import { settings } from '../lib/settings'
 import { projectDir, readJson } from '../lib/utils'
+import { aboutCmd } from './about'
+import { aiCmd } from './ai'
+import { checkCmd } from './check'
+import { cleanCmd } from './clean'
+import { compilersCmd } from './compilers'
+import { configCmd } from './config'
+import { createCmd } from './create'
+import { doctorCmd } from './doctor'
+import { generateCmd } from './generate'
+import { makeCmd } from './make'
+import { upgradeCmd } from './upgrade'
+import { uploadCmd } from './upload'
 
 const packageJson = await readJson(join(projectDir(), 'package.json'))
 
 program.name('jutge-toolkit')
+program.alias('jtk')
 program.version(packageJson.version as string)
 program.description(packageJson.description as string)
+program.helpCommand('help [command]', 'Display help for command') // To get the message with uppercase :-)
 
-program.addCommand(init)
-program.addCommand(create)
-program.addCommand(make)
-program.addCommand(verify)
-program.addCommand(generate)
-program.addCommand(clean)
-program.addCommand(compilers)
-program.addCommand(doctor)
-program.addCommand(ai)
+program.addCommand(configCmd)
+program.addCommand(createCmd)
+program.addCommand(makeCmd)
+program.addCommand(checkCmd)
+program.addCommand(generateCmd)
+program.addCommand(cleanCmd)
+program.addCommand(uploadCmd)
+program.addCommand(compilersCmd)
+program.addCommand(doctorCmd)
+program.addCommand(aiCmd)
+program.addCommand(upgradeCmd)
+program.addCommand(aboutCmd)
 
 try {
     await program.parseAsync()
@@ -38,10 +48,11 @@ try {
     if (error instanceof Error) {
         if (error.name === 'ExitPromptError') {
             console.error('Operation cancelled by the user')
+        } else if (error instanceof ZodError) {
+            console.error(fromError(error).toString())
         } else {
             console.error(error.message)
-            const showTrace = await confirm({ message: 'Show stack trace?', default: false })
-            if (showTrace) console.error(error)
+            if (settings.developer) console.error(error)
         }
     } else {
         console.error(error)

package/toolkit/make.ts

@@ -1,59 +1,23 @@
+import { Command } from '@commander-js/extra-typings'
+import { join, resolve } from 'path'
+import { findRealDirectories } from '../lib/helpers'
+import { newMaker } from '../lib/maker'
 import tui from '../lib/tui'
-import { newMaker, type MakerOptions } from '../lib/maker'
 import { nothing, projectDir } from '../lib/utils'
-import { Command } from '@commander-js/extra-typings'
-import { join, normalize, resolve } from 'path'
-import { languageNames } from '../lib/data'
-import { exists } from 'fs/promises'
-
-/*
-    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.
-*/
-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
-}
-
-type TaskType = 'all' | 'inspection' | 'executables' | 'corrects' | 'pdf' | 'text'
 
-interface MakeOptions extends MakerOptions {
-    directories: string[]
-    tasks: TaskType[]
-    ignoreErrors: boolean
-    onlyErrors: boolean
-    verbose?: boolean
-}
+export const makeCmd = new Command('make')
+    .alias('build')
+    .description('Make problem elements')
 
-export const make = new Command('make')
-    .description('Make problem components')
-    .argument('[directories...]', 'problem directories', ['.'])
+    .argument('[tasks...]', 'tasks to run: all, inspection, executables, corrects, pdf, text', ['all'])
+    .option('-d, --directories <directories...>', 'problem directories', ['.'])
     .option('-i, --ignore-errors', 'ignore errors on a directory and continue processing', false)
     .option('-e, --only-errors', 'only show errors at the final summary', false)
-    .option('-t, --tasks <tasks...>', 'tasks to run: all, inspection, executables, corrects, pdf, text', ['all'])
-    .option('-v, --verbose', 'verbose output (TODO)', false)
 
-    .action(async (directories, options) => {
+    .action(async (tasks, { directories, ignoreErrors, onlyErrors }) => {
         console.log()
         await tui.image(join(projectDir(), 'assets', 'images', 'jutge-toolkit.png'), 8, 4)
 
-        const { tasks, ignoreErrors, ...makerOptions } = options as MakeOptions
         const errors: Record<string, string> = {} // directory -> error message
 
         const realDirectories = await findRealDirectories(directories)
@@ -63,7 +27,7 @@ export const make = new Command('make')
             try {
                 tui.title(`Making problem in directory ${tui.hyperlink(directory, resolve(directory))}`)
 
-                const maker = await newMaker({ ...makerOptions, directory })
+                const maker = await newMaker(directory)
 
                 // If tasks include 'all', run makeProblem
                 if (tasks.includes('all')) {
@@ -109,7 +73,7 @@ export const make = new Command('make')
                 if (errors[directory]) {
                     tui.directory(directory)
                     tui.error(`  ${errors[directory]}`)
-                } else if (!options.onlyErrors) {
+                } else if (!onlyErrors) {
                     tui.directory(directory)
                     tui.success(`  No errors found`)
                 }

package/toolkit/upgrade.ts

@@ -0,0 +1,9 @@
+import { Command } from '@commander-js/extra-typings'
+import { upgrade } from 'lib/versions'
+
+export const upgradeCmd = new Command('upgrade')
+    .description('Upgrade Jutge Toolkit to the latest version')
+
+    .action(async () => {
+        await upgrade()
+    })

package/toolkit/upload.ts

@@ -0,0 +1,19 @@
+import { Command } from '@commander-js/extra-typings'
+import { uploadProblem } from '../lib/upload'
+
+export const uploadCmd = new Command('upload')
+    .alias('push')
+    .summary('Upload problem to Jutge.org')
+    .description(
+        `Upload problem to Jutge.org
+
+If problem.yml exists, the problem will be updated at Jutge.org using that information.
+If problem.yml does not exist, a new problem will be created at Jutge.org and problem.yml will be generated.
+`,
+    )
+
+    .option('-d, --directory <directory>', 'problem directory', '.')
+
+    .action(async ({ directory }) => {
+        await uploadProblem(directory)
+    })

package/toolkit/create-jutge-ai.ts

@@ -1,101 +0,0 @@
-import { generateProblemWithJutgeAI, type ProblemData } from '../lib/generate'
-import { guessUserEmail, guessUserName } from '../lib/utils'
-import { checkbox, input, select } from '@inquirer/prompts'
-import tui from '../lib/tui'
-import humanId from 'human-id'
-import slug from 'slug'
-
-const proglangsChoices = [
-    { name: 'C', value: 'c' },
-    { name: 'C++', value: 'cpp' },
-    { name: 'Python3', value: 'py' },
-    { name: 'Haskell', value: 'hs' },
-    { name: 'Clojure', value: 'clj' },
-]
-
-const problemTypesChoices = [
-    { name: 'Standard (read input, write output)', value: 'Standard' },
-    { name: 'Function (use functions)', value: 'Function' },
-    { name: 'Graphic', value: 'Graphic' },
-]
-
-const languagesChoices = [
-    { name: 'English', value: 'en' },
-    { name: 'Catalan', value: 'ca' },
-    { name: 'Spanish', value: 'es' },
-    { name: 'French', value: 'fr' },
-    { name: 'German', value: 'de' },
-]
-
-const modelsChoices = [
-    { name: 'Google - Gemini 2.5 flash lite', value: 'google/gemini-2.5-flash-lite' },
-    { name: 'Google - Gemini 2.5 flash', value: 'google/gemini-2.5-flash' },
-    { name: 'Google - Gemini 2.5', value: 'google/gemini-2.5' },
-    { name: 'OpenAI - GPT-5 Nano', value: 'openai/gpt-5-nano' },
-    { name: 'OpenAI - GPT-5 Mini', value: 'openai/gpt-5-mini' },
-    { name: 'OpenAI - GPT-5', value: 'openai/gpt-5' },
-    { name: 'Ollama - GPT OSS', value: 'ollama/gpt-oss' },
-]
-
-async function getInitialData(outputDir: string): Promise<ProblemData> {
-    const author = (await guessUserName()) || 'John Doe'
-    const email = (await guessUserEmail()) || 'john.doe@example.com'
-    const title = 'The ' + humanId({ separator: ' ', capitalize: false })
-    const folder = slug(`The ${title}.pbm`)
-
-    const data = {
-        title,
-        description: '',
-        author,
-        email,
-        type: 'std',
-        proglangs: ['cpp', 'py'],
-        languages: ['en', 'ca', 'es'],
-        model: modelsChoices[0]!.value,
-        outputDir,
-    }
-
-    return data
-}
-
-async function updateDataFromUser(data: ProblemData) {
-    data.author = await input({ message: 'Author:', default: data.author })
-    data.email = await input({ message: 'Author email:', default: data.email })
-    data.title = await input({ message: 'Problem title:', default: data.title })
-    data.description = await input({ message: 'Problem description:', default: data.description })
-
-    const checkedProglangsChoices = proglangsChoices.map((choice) => ({
-        ...choice,
-        checked: data.proglangs.includes(choice.value),
-    }))
-    data.proglangs = await checkbox({
-        message: 'Select programming languages for solutions:',
-        choices: checkedProglangsChoices,
-        required: true,
-    })
-
-    const checkedLanguagesChoices = languagesChoices.map((choice) => ({
-        ...choice,
-        checked: data.languages.includes(choice.value),
-    }))
-    data.languages = await checkbox({
-        message: 'Select languages for statements:',
-        choices: checkedLanguagesChoices,
-        required: true,
-    })
-
-    data.model = await select({
-        message: 'Select an AI model:',
-        choices: modelsChoices,
-        default: data.model || modelsChoices[0]!.value,
-    })
-}
-
-export async function createProblemWithJutgeAI(outputDir: string): Promise<void> {
-    tui.warning('JutgeAI can only create std problems for now.')
-
-    const data = await getInitialData(outputDir)
-    await updateDataFromUser(data)
-    console.log(data)
-    await generateProblemWithJutgeAI(data)
-}

package/toolkit/create-template.ts

@@ -1,55 +0,0 @@
-import tui from '../lib/tui'
-import { isDirectory, projectDir, readText } from '../lib/utils'
-import { confirm, select, Separator } from '@inquirer/prompts'
-import { cp, glob } from 'fs/promises'
-import { join } from 'path'
-import { title } from 'radash'
-
-async function chooseTemplate(): Promise<string> {
-    // build the choices array
-    const choices = []
-    const path = join(projectDir(), 'assets', 'problems')
-    const glob1 = glob('*', { cwd: path })
-    for await (const entry1 of glob1) {
-        if (await isDirectory(join(path, entry1))) {
-            choices.push(new Separator(`◇ ${title(entry1)}:`))
-            const glob2 = glob('*', { cwd: join(path, entry1) })
-            for await (const entry2 of glob2) {
-                if (await isDirectory(join(path, entry1, entry2))) {
-                    const readme = await readText(join(path, entry1, entry2, 'README.md'))
-                    const name = // Extract title from README.md
-                        '   ' +
-                            readme
-                                .split('\n')
-                                .filter((line) => line.startsWith('#'))[0]
-                                ?.replace('#', '')
-                                .trim() || 'No description'
-                    choices.push({ name, value: join(entry1, entry2) })
-                }
-            }
-        }
-    }
-
-    while (true) {
-        const template = await select({ choices, message: 'Select a problem template:', loop: false })
-
-        const readme = await readText(join(path, template, 'README.md'))
-        await tui.markdown(readme)
-        console.log()
-
-        const confirmation = await confirm({
-            message: `Use this template?`,
-            default: true,
-        })
-        if (confirmation) return template
-    }
-}
-
-export async function createProblemWithTemplate(outputDir: string): Promise<void> {
-    const template = await chooseTemplate()
-
-    const source = join(projectDir(), 'assets', 'problems', template)
-    tui.action(`Creating new problem from template ${template}`)
-    await cp(source, outputDir, { recursive: true })
-    tui.success(`Problem created at ${outputDir}`)
-}