@jpetit/toolkit 3.0.22 → 3.1.1

package/toolkit/generate.ts

@@ -1,116 +0,0 @@
-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/init.ts

@@ -1,56 +0,0 @@
-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

@@ -1,118 +0,0 @@
-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 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('-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) => {
-        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()
-            if (realDirectories.length === 0) {
-                tui.warning('No problem directories found')
-            }
-            for (const directory of realDirectories) {
-                if (errors[directory]) {
-                    tui.directory(directory)
-                    tui.error(`  ${errors[directory]}`)
-                } else if (!options.onlyErrors) {
-                    tui.directory(directory)
-                    tui.success(`  No errors found`)
-                }
-            }
-        })
-    })

package/toolkit/verify.ts

@@ -1,19 +0,0 @@
-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)
-        }
-    })