@jpetit/toolkit 3.0.22 → 3.1.1

package/lib/settings.ts

@@ -1,42 +0,0 @@
-import { exists } from 'fs/promises'
-import envPaths from 'env-paths'
-import { mkdir } from 'fs/promises'
-import { join } from 'path'
-import { z } from 'zod'
-import { readJson, writeJson } from './utils'
-
-const ZSettings = z.object({
-    name: z.string().min(1).default('John Doe'),
-    email: z.string().email().default('john.doe@example.com'),
-    notifications: z.boolean().default(true),
-})
-
-export type Settings = z.infer<typeof ZSettings>
-
-export const paths = envPaths('jutge', { suffix: 'toolkit' })
-
-function configPath() {
-    return join(paths.config, 'config.json')
-}
-
-export async function initializePaths() {
-    await mkdir(paths.config, { recursive: true })
-    await mkdir(paths.data, { recursive: true })
-    await mkdir(paths.cache, { recursive: true })
-    await mkdir(paths.log, { recursive: true })
-    await mkdir(paths.temp, { recursive: true })
-}
-
-export async function saveSettings(settings: Settings) {
-    await initializePaths()
-    return await writeJson(configPath(), settings)
-}
-
-export async function loadSettings(): Promise<Settings> {
-    const data = await readJson(configPath())
-    return ZSettings.parse(data)
-}
-
-export async function settingsExist(): Promise<boolean> {
-    return await exists(configPath())
-}

package/lib/tui.ts

@@ -1,142 +0,0 @@
-import boxen from 'boxen'
-import chalk from 'chalk'
-import { marked } from 'marked'
-import { markedTerminal } from 'marked-terminal'
-import { resolve } from 'path'
-import terminalImage from 'terminal-image'
-import terminalLink from 'terminal-link'
-import YAML from 'yaml'
-
-let indentation = 0
-
-const symbols = ['', '▶', '◆', '●', '■']
-
-function sectionStart(text: string) {
-    if (indentation === 0) {
-        console.log()
-        if (text) {
-            console.log(chalk.blue(boxen(text, { padding: { left: 1, right: 1 }, width: process.stdout.columns })))
-        }
-    } else {
-        if (text) {
-            console.log(chalk.blue(`${symbols[indentation]} ${text}`))
-        }
-    }
-    ++indentation
-    console.group()
-}
-
-function sectionEnd() {
-    --indentation
-    console.groupEnd()
-}
-
-function sectionReset() {
-    while (indentation > 0) {
-        --indentation
-        sectionEnd()
-    }
-}
-
-async function section<T>(text: string, fn: () => Promise<T>): Promise<T> {
-    try {
-        sectionStart(text)
-        const result = await fn()
-        return result
-    } finally {
-        sectionEnd()
-    }
-}
-
-function title(text: string) {
-    console.log(
-        chalk.blue.bold(
-            boxen(text, { padding: { left: 1, right: 1 }, width: process.stdout.columns, borderStyle: 'double' }),
-        ),
-    )
-}
-
-// TODO: use them anywhere
-type CommandOptions = {
-    italic?: boolean
-}
-
-function command(text: string, options: CommandOptions = {}) {
-    if (options.italic) {
-        console.log(chalk.magenta.italic(`❯ ${text}`))
-    } else {
-        console.log(chalk.magenta(`❯ ${text}`))
-    }
-}
-
-function directory(text: string) {
-    console.log(chalk.magenta('◳ ' + hyperlink(process.cwd(), text)))
-}
-
-function warning(text: string) {
-    console.log(chalk.hex('#FFA500')(text))
-}
-
-function error(text: string) {
-    console.log(chalk.red(text))
-}
-
-function success(text: string) {
-    console.log(chalk.green(text))
-}
-
-function action(text: string) {
-    console.log(chalk.blue(`${text}...`))
-}
-
-function print(text: string): void {
-    const lines = text.split('\n')
-    for (const line of lines) {
-        console.log(line)
-    }
-}
-
-async function markdown(content: string): Promise<void> {
-    // @ts-expect-error: i don't know why types are not working here but seems to work at runtime
-    marked.use(markedTerminal())
-    const output = await marked.parse(content)
-    console.log(output)
-}
-
-function yaml(content: any): void {
-    const output = YAML.stringify(content, null, 2).trim()
-    print(output)
-}
-
-function json(content: any): void {
-    const output = JSON.stringify(content, null, 2)
-    print(output)
-}
-
-async function image(path: string, width: number, height: number): Promise<void> {
-    console.log(await terminalImage.file(path, { width, height }))
-}
-
-function hyperlink(dir: string, path: string): string {
-    return terminalLink(path, 'file://' + resolve(dir, path))
-}
-
-export default {
-    sectionStart,
-    sectionEnd,
-    sectionReset,
-    section,
-    title,
-    command,
-    directory,
-    warning,
-    error,
-    success,
-    action,
-    print,
-    markdown,
-    yaml,
-    json,
-    image,
-    hyperlink,
-}

package/lib/types.ts

@@ -1,20 +0,0 @@
-import { z } from 'zod'
-
-export const ZHandler = z.object({
-    handler: z.enum(['std', 'graphic']).default('std'),
-    solution: z.string().default('C++'),
-    source_modifier: z.enum(['none', 'no_main', 'structs']).default('none'),
-    compilers: z.enum(['RunPython', 'RunHaskell', 'RunClojure', 'GHC']).nullable().default(null),
-})
-
-export type Handler = z.infer<typeof ZHandler>
-
-export const ZScores = z.array(
-    z.object({
-        part: z.string(),
-        prefix: z.string(),
-        points: z.number().min(0),
-    }),
-)
-
-export type Scores = z.infer<typeof ZScores>

package/lib/utils.ts

@@ -1,133 +0,0 @@
-import { execa } from 'execa'
-import { readFileSync } from 'fs'
-import { readFile, stat, writeFile } from 'fs/promises'
-import humanId from 'human-id'
-import { customAlphabet } from 'nanoid'
-import { dirname, join } from 'path'
-import { fileURLToPath } from 'url'
-import YAML from 'yaml'
-
-export async function nothing(): Promise<void> {
-    // Do nothing: just a way to ignore lint warnings
-}
-
-export async function readText(path: string): Promise<string> {
-    const content = await readFile(path, 'utf8')
-    return content
-}
-
-export async function readBytes(path: string): Promise<Uint8Array> {
-    const content = await readFile(path)
-    return content
-}
-
-export async function readYaml(path: string): Promise<any> {
-    const content = await readText(path)
-    return YAML.parse(content)
-}
-
-export async function readJson(path: string): Promise<any> {
-    const content = await readText(path)
-    return JSON.parse(content)
-}
-
-export async function writeText(path: string, content: string): Promise<void> {
-    await writeFile(path, content)
-}
-
-export async function concatText(
-    inputPaths: string[],
-    outputPath: string,
-    separator: string = '\n\n\n',
-): Promise<void> {
-    let content = ''
-    for (const inputPath of inputPaths) {
-        content += (await readText(inputPath)) + separator
-    }
-    await writeText(outputPath, content)
-}
-
-export async function writeYaml(path: string, data: any): Promise<void> {
-    const content = YAML.stringify(data, null, 4)
-    await writeText(path, content)
-}
-
-export async function writeJson(path: string, data: any): Promise<void> {
-    const content = JSON.stringify(data, null, 4)
-    await writeText(path, content)
-}
-
-export async function fileSize(path: string): Promise<number> {
-    const stats = await stat(path)
-    return stats.size
-}
-
-export async function filesAreEqual(path1: string, path2: string): Promise<boolean> {
-    const bytes1 = await readBytes(path1)
-    const bytes2 = await readBytes(path2)
-    return bytes1.length === bytes2.length && bytes1.every((b, i) => b === bytes2[i])
-}
-
-export async function isDirectory(path: string): Promise<boolean> {
-    try {
-        const stats = await stat(path)
-        return stats.isDirectory()
-    } catch (e) {
-        return false
-    }
-}
-
-// Guess user name from git config
-export async function guessUserName(): Promise<string | null> {
-    try {
-        const { stdout } = await execa`git config user.name`
-        const name = stdout.trim()
-        if (name === '') return null
-        return name
-    } catch (e) {
-        return null
-    }
-}
-
-// Guess user email from git config
-export async function guessUserEmail(): Promise<string | null> {
-    try {
-        const { stdout } = await execa`git config user.email`
-        const email = stdout.trim()
-        if (email === '') return null
-        return email
-    } catch (e) {
-        return null
-    }
-}
-
-export function nanoid16(): string {
-    const alphabet = '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
-    const nanoid = customAlphabet(alphabet, 16)
-    return nanoid()
-}
-
-export function nanoid12(): string {
-    const alphabet = '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
-    const nanoid = customAlphabet(alphabet, 12)
-    return nanoid()
-}
-
-export function nanoid8(): string {
-    const alphabet = '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
-    const nanoid = customAlphabet(alphabet, 8)
-    return nanoid()
-}
-
-export function humanid(): string {
-    return humanId({
-        separator: '-',
-        capitalize: false,
-    })
-}
-
-export function projectDir(): string {
-    const __filename = fileURLToPath(import.meta.url)
-    const __dirname = dirname(__filename)
-    return join(__dirname, '..')
-}

package/toolkit/ai.ts

@@ -1,30 +0,0 @@
-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 using an AI model')
-
-    .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

@@ -1,37 +0,0 @@
-import { cleanFiles } from '../lib/cleaner'
-import tui from '../lib/tui'
-import { Command, Option } from '@commander-js/extra-typings'
-import { resolve } from 'path'
-
-export const clean = new Command('clean')
-    .description('Clean generated files')
-
-    .argument('[directories...]', 'problem directories', ['.'])
-    .option('-i, --ignore-errors', 'ignore errors on a directory and continue processing', false)
-    .addOption(new Option('-f, --force', 'force removal').conflicts('dryRun'))
-    .addOption(new Option('-n, --dry-run', 'show but do not remove files').conflicts('force'))
-
-    .action(async (directories, { ignoreErrors, force }) => {
-        // Default to dry-run if neither option is specified
-        const isForce = force || false
-        await tui.section('Cleaning generated files', async () => {
-            for (const directory of directories) {
-                try {
-                    await tui.section(
-                        `Cleaning directory ${tui.hyperlink(directory, resolve(directory))}`,
-                        async () => {
-                            await cleanFiles(isForce, directory)
-                        },
-                    )
-                } catch (error) {
-                    const errorMessage = error instanceof Error ? error.message : String(error)
-
-                    if (ignoreErrors) {
-                        tui.error(`Error: ${errorMessage}`)
-                    } else {
-                        throw error
-                    }
-                }
-            }
-        })
-    })

package/toolkit/compilers.ts

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

@@ -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}`)
-}

package/toolkit/create-wizard.ts

@@ -1,6 +0,0 @@
-import { nothing } from '../lib/utils'
-
-export async function createProblemWithWizard(outputDir: string): Promise<void> {
-    await nothing()
-    throw new Error('Wizard method is not yet implemented.')
-}

package/toolkit/create.ts

@@ -1,65 +0,0 @@
-import tui from '../lib/tui'
-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
-            tui.action(`Removing directory ${dir}`)
-            await rm(dir, { recursive: true, force: true })
-            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
-        }
-        await mkdir(dir, { recursive: true })
-        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

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