@jpetit/toolkit 3.0.14 → 3.0.16

package/toolkit/doctor.ts

@@ -0,0 +1,18 @@
+import * as doc from '@/lib/doctor'
+import { Command } from '@commander-js/extra-typings'
+import tui from '@/lib/tui'
+
+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 XeLaTeX installation', doc.checkXeLaTeX)
+        await tui.section('Checking Pandoc installation', doc.checkPandoc)
+        await tui.section('Checking ImageMagick installation', doc.checkImageMagick)
+        await tui.section('Checking AI models', doc.checkEnvVars)
+        await tui.section('Checking terminal', doc.checkTerminal)
+    })

package/toolkit/generate.ts

@@ -0,0 +1,116 @@
+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 { 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)')
+    .option(
+        '-m, --model <model>',
+        'the 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 () => {
+            for (const language of languages) {
+                await generateTranslation(parentOptions.model, maker, 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
+    .command('solutions')
+    .description('Generate solutions TODO')
+    .argument('<proglangs...>', 'programming languages to generate')
+
+    .action(async (proglangs, options, command) => {
+        await nothing()
+        throw new Error('Not implemented yet')
+    })
+
+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,
+        }
+        await writeText(join(maker.directory, `problem.${language}.tex`), answer)
+        await writeYaml(join(maker.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`)
+    })
+}

package/toolkit/index.ts

@@ -1,6 +1,5 @@
 #!/usr/bin/env bun
 
-import { projectDir, readJson } from '@/lib/utils'
 import { program } from '@commander-js/extra-typings'
 import { confirm } from '@inquirer/prompts'
 import { join } from 'path'
@@ -13,6 +12,7 @@ import { init } from './init'
 import { make } from './make'
 import { verify } from './verify'
 import { generate } from './generate'
+import { projectDir, readJson } from '../lib/utils'
 
 const packageJson = await readJson(join(projectDir(), 'package.json'))
 

package/toolkit/init.ts

@@ -0,0 +1,56 @@
+import { initializePaths, loadSettings, paths, saveSettings, settingsExist } from '@/lib/settings'
+import tui from '@/lib/tui'
+import { guessUserEmail, guessUserName, nothing } from '@/lib/utils'
+import { Command } from '@commander-js/extra-typings'
+import { confirm, input } from '@inquirer/prompts'
+import chalk from 'chalk'
+
+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 = await confirm({ message: 'Enable notifications?', default: 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 notifications = await confirm({ message: 'Enable notifications?', default: settings.notifications })
+
+        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 tui.section('Directories', async () => {
+            await nothing()
+            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,109 @@
+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, 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 (const dir of directories) {
+        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
+    verbose?: boolean
+}
+
+export const make = new Command('make')
+    .description('Make problem components')
+    .argument('[directories...]', 'problem directories', ['.'])
+    .option('-i, --ignore-errors', 'ignore errors on a directory and continue processing', 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) => {
+        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)
+        // console.log(realDirectories)
+
+        for (const directory of realDirectories) {
+            try {
+                tui.title(`Making problem in directory ${tui.hyperlink(directory, resolve(directory))}`)
+
+                const maker = await newMaker({ ...makerOptions, directory })
+
+                // If tasks include 'all', run makeProblem
+                if (tasks.includes('all')) {
+                    await maker.makeProblem()
+                } else {
+                    // Run specific tasks
+                    if (tasks.includes('inspection')) {
+                        // already done in maker initialization
+                    }
+                    if (tasks.includes('executables')) {
+                        await maker.makeExecutables()
+                    }
+                    if (tasks.includes('corrects')) {
+                        await maker.makeCorrects()
+                    }
+                    if (tasks.includes('pdf')) {
+                        await maker.makePdfs()
+                    }
+                    if (tasks.includes('text')) {
+                        await maker.makeTexts()
+                    }
+                }
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error)
+
+                if (ignoreErrors) {
+                    errors[directory] = errorMessage
+                    tui.error(`Error: ${errorMessage}`)
+                } else {
+                    throw error
+                }
+            }
+            console.log()
+        }
+
+        tui.title('Summary')
+        await tui.section('', async () => {
+            await nothing()
+            for (const directory of realDirectories) {
+                tui.directory(directory)
+                if (errors[directory]) {
+                    tui.error(`  ${errors[directory]}`)
+                } else {
+                    tui.success(`  No errors found`)
+                }
+            }
+        })
+    })

package/toolkit/verify.ts

@@ -0,0 +1,19 @@
+import { newMaker } from '@/lib/maker'
+import { Command } from '@commander-js/extra-typings'
+import { normalize } from 'path'
+
+export const verify = new Command('verify')
+    .description('Verify candidate programs')
+    // 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)
+        }
+    })