@jpetit/toolkit 3.0.0

package/toolkit/ai.ts

@@ -0,0 +1,30 @@
+import { Command } from '@commander-js/extra-typings'
+import { complete, listModels } from '@/lib/ai.ts'
+
+export const ai = new Command('ai').description('Query AI models')
+
+ai.command('complete')
+    .description('Complete a prompt')
+
+    .argument('prompt', 'the user prompt to complete')
+    .option('-s, --system-prompt <system>', 'the system prompt to use', 'You are a helpful assistant.')
+    .option(
+        '-m, --model <model>',
+        'the AI model to use (eg: openai/gpt-5, google/gemini-2.5-pro, ...)',
+        'google/gemini-2.5-flash-lite',
+    )
+
+    .action(async (prompt, { model, systemPrompt }) => {
+        if (!prompt) prompt = 'Who are you?'
+        if (!systemPrompt) systemPrompt = 'You are a helpful assistant.'
+
+        const answer = await complete(model, systemPrompt, prompt)
+        console.log(answer)
+    })
+
+ai.command('models')
+    .description('Show available AI models')
+    .action(async () => {
+        const models = await listModels()
+        console.dir(models, { depth: null })
+    })

package/toolkit/clean.ts

@@ -0,0 +1,19 @@
+import { cleanFiles } from '@/lib/cleaner'
+import { Command, Option } from '@commander-js/extra-typings'
+import boxen from 'boxen'
+import chalk from 'chalk'
+
+export const clean = new Command('clean')
+    .description('Clean generated files')
+
+    .addOption(new Option('-f, --force', 'force removal').conflicts('dryRun'))
+    .addOption(new Option('-n, --dry-run', 'show but do not remove files').conflicts('force'))
+    .option('-d, --directory <path>', 'problem directory', '.')
+
+    .action(async (options) => {
+        // Default to dry-run if neither option is specified
+        console.log(chalk.blue(boxen('Clean files', { padding: { left: 1, right: 1 }, width: process.stdout.columns })))
+        console.log()
+        const force = options.force || false
+        await cleanFiles(force, options.directory)
+    })

package/toolkit/compilers.ts

@@ -0,0 +1,29 @@
+import { getAvailableCompilers, getCompilersInfo, getDefinedCompilerIds } from '@/lib/compilers'
+import { Command } from '@commander-js/extra-typings'
+
+export const compilers = new Command('compilers')
+    .description('Query compiler information')
+    // default action is to list all compilers
+
+    .action(async () => {
+        const info = await getCompilersInfo()
+        console.dir(info)
+    })
+
+compilers
+    .command('list-defined')
+    .description('List all defined compiler names')
+
+    .action(async () => {
+        const items = await getDefinedCompilerIds()
+        console.dir(items)
+    })
+
+compilers
+    .command('list-available')
+    .description('List all available compiler names')
+
+    .action(async () => {
+        const items = await getAvailableCompilers()
+        console.dir(items)
+    })

package/toolkit/create-jutge-ai.ts

@@ -0,0 +1,101 @@
+import { generateProblemWithJutgeAI, type ProblemData } from '@/lib/generate'
+import { guessUserEmail, guessUserName } from '@/lib/utils'
+import { checkbox, input, select } from '@inquirer/prompts'
+import * as tui from '@/lib/tui.js'
+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

@@ -0,0 +1,51 @@
+import { paths } from '@/lib/settings'
+import * as tui from '@/lib/tui.js'
+import { confirm, select, Separator } from '@inquirer/prompts'
+import { cp } 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(paths.data, 'assets', 'problems')
+    const dirsGlob = new Bun.Glob('*')
+    for await (const dir of dirsGlob.scan({ cwd: path, onlyFiles: false })) {
+        choices.push(new Separator(`◇ ${title(dir)}:`))
+        const problemsGlob = new Bun.Glob('*')
+        for await (const problem of problemsGlob.scan({ cwd: join(path, dir), onlyFiles: false })) {
+            const readme = await Bun.file(join(path, dir, problem, 'README.md')).text()
+            const name = // Extract title from README.md
+                '   ' +
+                    readme
+                        .split('\n')
+                        .filter((line) => line.startsWith('#'))[0]
+                        ?.replace('#', '')
+                        .trim() || 'No description'
+            choices.push({ name, value: join(dir, problem) })
+        }
+    }
+
+    while (true) {
+        const template = await select({ choices, message: 'Select a problem template:', loop: false })
+
+        const readme = await Bun.file(join(path, template, 'README.md')).text()
+        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(paths.data, 'assets', 'problems', template)
+    tui.action(`Creating new problem from template ${template}`)
+    await cp(source, outputDir, { recursive: true })
+    tui.success(`Problem created at ${outputDir}`)
+}

package/toolkit/create-wizard.ts

@@ -0,0 +1,4 @@
+export async function createProblemWithWizard(outputDir: string): Promise<void> {
+    await Bun.sleep(0) // to ignore warning
+    console.error('Wizard method is not yet implemented.')
+}

package/toolkit/create.ts

@@ -0,0 +1,75 @@
+import * as tui from '@/lib/tui.js'
+import { Command } from '@commander-js/extra-typings'
+import { confirm, input, select } from '@inquirer/prompts'
+import { exists, mkdir, rm } from 'fs/promises'
+import { normalize } from 'path'
+import { createProblemWithJutgeAI } from './create-jutge-ai'
+import { createProblemWithTemplate } from './create-template'
+import { createProblemWithWizard } from './create-wizard'
+
+async function selectMethod(): Promise<'template' | 'wizard' | 'jutgeAI'> {
+    return await select({
+        message: 'Method to create a new problem:',
+        choices: [
+            { name: 'Use a template', value: 'template' },
+            { name: 'Use the wizard', value: 'wizard' },
+            { name: 'Use JutgeAI', value: 'jutgeAI' },
+        ],
+    })
+}
+
+async function selectOutputDir(): Promise<string> {
+    let dir = 'my-new-problem.pbm'
+    while (true) {
+        dir = await input({
+            message: 'Output directory for the new problem:',
+            default: dir,
+        })
+        dir = normalize(dir)
+        if (await exists(dir)) {
+            tui.error(`Directory ${dir} already exists.`)
+            const remove = await confirm({
+                message: 'Remove it?',
+                default: false,
+            })
+            if (!remove) continue
+            try {
+                tui.action(`Removing directory ${dir}`)
+                await rm(dir, { recursive: true, force: true })
+            } catch (err) {
+                tui.warning(`Failed to remove directory ${dir}. Please try again.`)
+                continue
+            }
+            tui.success(`Removed directory ${dir}`)
+        }
+        if (!dir.endsWith('.pbm')) {
+            tui.warning("The output directory must end with the '.pbm' extension. Please try again.")
+            dir += '.pbm'
+            continue
+        }
+        try {
+            await mkdir(dir, { recursive: true })
+        } catch (err) {
+            tui.warning(`Failed to create directory ${dir}. Please try again.`)
+            continue
+        }
+        tui.success(`Created directory ${dir}`)
+        return dir
+    }
+}
+
+export const create = new Command('create')
+    .description('Create a new problem')
+
+    .action(async () => {
+        tui.title('Create new problem')
+        const outputDir = await selectOutputDir()
+        const method = await selectMethod()
+        if (method === 'template') {
+            await createProblemWithTemplate(outputDir)
+        } else if (method === 'wizard') {
+            await createProblemWithWizard(outputDir)
+        } else if (method === 'jutgeAI') {
+            await createProblemWithJutgeAI(outputDir)
+        }
+    })

package/toolkit/doctor.ts

@@ -0,0 +1,17 @@
+import * as doc from '@/lib/doctor'
+import { Command } from '@commander-js/extra-typings'
+import * as tui from '@/lib/tui.js'
+
+export const doctor = new Command('doctor')
+    .description('Diagnose and fix common issues with the project setup')
+
+    .action(async () => {
+        tui.title('Doctor')
+
+        await tui.section('Checking Python3 installation', doc.checkPython3)
+        await tui.section('Checking C/C++ installation', doc.checkGCC)
+        await tui.section('Checking LaTeX installation', doc.checkLaTeX)
+        await tui.section('Checking Pandoc installation', doc.checkPandoc)
+        await tui.section('Checking ImageMagick installation', doc.checkImageMagick)
+        await tui.section('Checking environment variables', doc.checkEnvVars)
+    })

package/toolkit/index.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env bun
+
+import { program } from '@commander-js/extra-typings'
+import { ai } from './ai'
+import { compilers } from './compilers'
+import { make } from './make'
+import { clean } from './clean'
+import { create } from './create'
+import { doctor } from './doctor'
+import { init } from './init'
+import { verify } from './verify'
+
+program.name('jutge-toolkit')
+
+program.description('Toolkit to prepare problems for Jutge.org')
+
+program.version('3.0.0')
+
+program.addCommand(init)
+program.addCommand(create)
+program.addCommand(make)
+program.addCommand(verify)
+program.addCommand(clean)
+program.addCommand(compilers)
+program.addCommand(doctor)
+program.addCommand(ai)
+
+await program.parseAsync()

package/toolkit/init.ts

@@ -0,0 +1,66 @@
+import { decompressAssets } from '@/lib/assets'
+import { initializePaths, loadSettings, paths, saveSettings, settingsExist } from '@/lib/settings'
+import { guessUserEmail, guessUserName } from '@/lib/utils'
+import { Command } from '@commander-js/extra-typings'
+import { input, select } from '@inquirer/prompts'
+import chalk from 'chalk'
+import * as tui from '@/lib/tui.js'
+
+async function initialize() {
+    await tui.section('Initialize', async () => {
+        let name = (await guessUserName()) || 'John Doe'
+        let email = (await guessUserEmail()) || 'john.doe@example.com'
+        name = await input({ message: 'What is your name?', default: name })
+        email = await input({ message: 'What is your email?', default: email })
+        const notifications = true
+
+        await initializePaths()
+        await saveSettings({ name, email, notifications })
+
+        tui.success('Settings created')
+    })
+}
+
+async function configure() {
+    await tui.section('Configure', async () => {
+        const settings = await loadSettings()
+
+        const name = await input({ message: 'What is your name?', default: settings.name })
+        const email = await input({ message: 'What is your email?', default: settings.email })
+        const notificationsInput = await select({
+            message: 'Enable notifications?',
+            choices: [
+                { name: 'Yes', value: 'yes' },
+                { name: 'No', value: 'no' },
+            ],
+            default: settings.notifications ? 'yes' : 'no',
+        })
+        const notifications = notificationsInput === 'yes'
+
+        await saveSettings({ name, email, notifications })
+
+        tui.success('Settings updated')
+    })
+}
+
+export const init = new Command('init')
+    .description('Initialize/configure the toolkit')
+
+    .action(async () => {
+        if (await settingsExist()) {
+            await configure()
+        } else {
+            await initialize()
+        }
+
+        await decompressAssets()
+
+        await tui.section('Directories', async () => {
+            await Bun.sleep(0) // hide lint warning
+            console.log('config:', chalk.magenta(paths.config))
+            console.log('data:  ', chalk.magenta(paths.data))
+            console.log('cache: ', chalk.magenta(paths.cache))
+            console.log('log:   ', chalk.magenta(paths.log))
+            console.log('temp:  ', chalk.magenta(paths.temp))
+        })
+    })

package/toolkit/make.ts

@@ -0,0 +1,60 @@
+import { newMaker, type MakerOptions } from '@/lib/maker'
+import { Command } from '@commander-js/extra-typings'
+
+export const make = new Command('make')
+    .description('Make problem 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)')
+
+    .action(async (options) => {
+        const maker = await newMaker(options)
+        await maker.makeProblem()
+    })
+
+make.command('problem')
+    .description('Make problem (default)')
+    .action(async (options, command) => {
+        const parentOptions = (command.parent?.opts() || {}) as any as MakerOptions
+        const maker = await newMaker(parentOptions)
+        await maker.makeProblem()
+    })
+
+make.command('inspection')
+    .description('Make inspection')
+    .action(async (options, command) => {
+        const parentOptions = (command.parent?.opts() || {}) as any as MakerOptions
+        const maker = await newMaker(parentOptions)
+    })
+
+make.command('executables')
+    .description('Make executables')
+    .action(async (options, command) => {
+        const parentOptions = (command.parent?.opts() || {}) as any as MakerOptions
+        const maker = await newMaker(parentOptions)
+        await maker.makeExecutables()
+    })
+
+make.command('corrects')
+    .description('Make corrects')
+    .action(async (options, command) => {
+        const parentOptions = (command.parent?.opts() || {}) as any as MakerOptions
+        const maker = await newMaker(parentOptions)
+        await maker.makeCorrects()
+    })
+
+make.command('pdf')
+    .description('Make PDF statements')
+    .action(async (options, command) => {
+        const parentOptions = (command.parent?.opts() || {}) as any as MakerOptions
+        const maker = await newMaker(parentOptions)
+        await maker.makePdfs()
+    })
+
+make.command('text')
+    .description('Make text statements (HTML, TXT, MD)')
+    .action(async (options, command) => {
+        const parentOptions = (command.parent?.opts() || {}) as any as MakerOptions
+        const maker = await newMaker(parentOptions)
+        await maker.makeTexts()
+    })

package/toolkit/verify.ts

@@ -0,0 +1,19 @@
+import { Command } from '@commander-js/extra-typings'
+import { newMaker, type MakerOptions } from '@/lib/maker'
+import { normalize } from 'path'
+
+export const verify = new Command('verify')
+    .description('Verify a candidate program')
+    // Add common options here
+
+    .argument('<programs...>', 'source programs to verify')
+    .option('-d, --directory <path>', 'problem directory', process.cwd()) // TODO: use '.' when bun fixes it
+    .option('-v, --verbose', 'verbose output (TODO)')
+
+    .action(async (programs, { directory, verbose }) => {
+        directory = normalize(directory)
+        const maker = await newMaker({ verbose, directory })
+        for (const program of programs) {
+            await maker.verifyCandidate(program)
+        }
+    })

package/tsconfig.json

@@ -0,0 +1,38 @@
+{
+    "compilerOptions": {
+        // Environment setup & latest features
+        "lib": ["ESNext"],
+        "target": "ESNext",
+        "module": "Preserve",
+        "moduleDetection": "force",
+        "jsx": "react-jsx",
+        "allowJs": true,
+
+        // Bundler mode
+        "moduleResolution": "bundler",
+        "allowImportingTsExtensions": true,
+        "verbatimModuleSyntax": true,
+        "noEmit": true,
+
+        // Best practices
+        "strict": true,
+        "skipLibCheck": true,
+        "noFallthroughCasesInSwitch": true,
+        "noUncheckedIndexedAccess": true,
+        "noImplicitOverride": true,
+
+        // Some stricter flags (disabled by default)
+        "noUnusedLocals": false,
+        "noUnusedParameters": false,
+        "noPropertyAccessFromIndexSignature": false,
+
+        // Path aliases
+        "baseUrl": ".",
+        "paths": {
+            "@/*": ["*"]
+        },
+
+        // Types
+        "types": ["bun-types"]
+    }
+}

package/types/zip.d.ts

@@ -0,0 +1,4 @@
+declare module '*.zip' {
+    const content: ArrayBuffer
+    export default content
+}