@jpetit/toolkit 3.1.1 → 3.1.2

package/lib/tui.ts

@@ -0,0 +1,152 @@
+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' }),
+        ),
+    )
+}
+
+function command(text: string) {
+    console.log(chalk.magenta(`❯ ${text}`))
+}
+
+function directory(text: string) {
+    console.log(chalk.magenta('◳ ' + fileLink(process.cwd(), text)))
+}
+
+function url(dst: string) {
+    console.log(chalk.magenta('🌐 ' + terminalLink(dst, dst)))
+}
+
+function link(dst: string, text?: string) {
+    return terminalLink(text || dst, dst)
+}
+
+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 gray(text: string) {
+    print(chalk.gray(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 fileLink(dir: string, path?: string): string {
+    if (path) {
+        return terminalLink(path, 'file://' + resolve(dir, path))
+    } else {
+        return terminalLink(dir, 'file://' + resolve(dir))
+    }
+}
+
+export default {
+    sectionStart,
+    sectionEnd,
+    sectionReset,
+    section,
+    title,
+    command,
+    directory,
+    url,
+    link,
+    warning,
+    error,
+    gray,
+    success,
+    action,
+    print,
+    markdown,
+    yaml,
+    json,
+    image,
+    hyperlink: fileLink,
+}

package/lib/types.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod'
+
+export const Handler = z.object({
+    handler: z.enum(['std', 'graphic', 'quiz']).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 Handler>
+
+export const Scores = z.array(
+    z.object({
+        part: z.string(),
+        prefix: z.string(),
+        points: z.number().min(0),
+    }),
+)
+
+export type Scores = z.infer<typeof Scores>
+
+export const Specification = z.object({
+    title: z.string(),
+    description: z.string(),
+    author: z.string(),
+    email: z.string().email(),
+    golden_proglang: z.string(),
+    more_proglangs: z.array(z.string()),
+    original_language: z.string(),
+    more_languages: z.array(z.string()),
+    generators: z.array(z.string()),
+})
+
+export type Specification = z.infer<typeof Specification>
+
+export const ProblemInfo = z.object({
+    problem_nm: z.string(),
+    passcode: z.string(),
+    created_at: z.string(),
+    updated_at: z.string(),
+})
+
+export type ProblemInfo = z.infer<typeof ProblemInfo>
+
+export const Settings = z.object({
+    name: z.string().min(1).default('John Doe'),
+    email: z.string().email().default('john.doe@example.com'),
+    defaultModel: z.string().default('google/gemini-2.5-flash-lite'),
+    notifications: z.boolean().default(false),
+    showPrompts: z.boolean().default(false),
+    showAnswers: z.boolean().default(false),
+    developer: z.boolean().default(false),
+})
+
+export type Settings = z.infer<typeof Settings>

package/lib/upload.ts

@@ -0,0 +1,216 @@
+import archiver from 'archiver'
+import { createWriteStream } from 'fs'
+import { glob, mkdir } from 'fs/promises'
+import { basename, join } from 'path'
+import { JutgeApiClient } from './jutge_api_client'
+import tui from './tui'
+import { ProblemInfo } from './types'
+import {
+    createFileFromPath,
+    existsInDir,
+    humanid,
+    nanoid12,
+    readYamlInDir,
+    toolkitPrefix,
+    writeYamlInDir,
+} from './utils'
+import YAML from 'yaml'
+
+export async function uploadProblem(directory: string) {
+    await tui.section('Uploading problem', async () => {
+        await tui.section('Checking .inp/.cor files', async () => {
+            // TODO: check that each .inp has a corresponding .cor file
+            // TODO: check that date of .cor is not before .inp nor before solution/main files
+            const inps = await Array.fromAsync(glob('*.inp', { cwd: directory }))
+            const cors = await Array.fromAsync(glob('*.cor', { cwd: directory }))
+            if (inps.length !== cors.length) {
+                throw new Error(
+                    `Number of .inp files (${inps.length}) does not match number of .cor files (${cors.length})`,
+                )
+            }
+            tui.success(`Looks good`)
+        })
+
+        const tmpDir = join(directory, toolkitPrefix() + '-zip', humanid())
+        const base = basename(process.cwd())
+        const zipFilePath = join(tmpDir, `${base}.zip`)
+        await mkdir(tmpDir, { recursive: true })
+
+        await tui.section('Creating zip file', async () => {
+            tui.directory(tmpDir)
+            await createZipFile(directory, zipFilePath, base)
+            tui.success(`Created zip file ${base}.zip at ${tui.hyperlink(tmpDir)}`)
+        })
+
+        let info = await tui.section('Loading problem.yml', async () => {
+            const info = await readProblemInfo(directory)
+            if (info) {
+                tui.print(YAML.stringify(info, null, 4).trim())
+            } else {
+                tui.warning('problem.yml not found, will create a new problem')
+            }
+            return info
+        })
+
+        if (info) {
+            info = await updateProblem(directory, info, zipFilePath)
+        } else {
+            info = await createProblem(directory, zipFilePath)
+        }
+        tui.print(YAML.stringify(info, null, 4).trim())
+        tui.url(`https://jutge.org/problems/${info.problem_nm}`)
+    })
+}
+
+async function createProblem(directory: string, zipFilePath: string): Promise<ProblemInfo> {
+    const info = {
+        problem_nm: '',
+        passcode: nanoid12(),
+        created_at: '',
+        updated_at: '',
+    }
+    const jutge = new JutgeApiClient()
+
+    await tui.section('Loging in into Jutge.org', async () => {
+        await login(jutge)
+    })
+
+    await tui.section('Creating problem in Jutge.org', async () => {
+        const file = await createFileFromPath(zipFilePath, 'application/zip')
+        const { id } = await jutge.instructor.problems.legacyCreateWithTerminal(info.passcode, file)
+        const problem_nm = await showTerminalOutput(id)
+        if (!problem_nm) throw new Error('Failed to get problem name')
+        info.problem_nm = problem_nm
+        info.created_at = new Date().toISOString()
+        info.updated_at = new Date().toISOString()
+    })
+
+    await tui.section('Creating problem.yml', async () => {
+        await writeProblemInfo(directory, info)
+        tui.success(`Created problem.yml`)
+    })
+
+    tui.print('')
+    tui.success(`Problem ${info.problem_nm} created successfully`)
+
+    return info
+}
+
+async function updateProblem(directory: string, info: ProblemInfo, zipFilePath: string): Promise<ProblemInfo> {
+    const jutge = new JutgeApiClient()
+
+    await tui.section('Loging in into Jutge.org', async () => {
+        await login(jutge)
+    })
+
+    await tui.section('Updating problem in Jutge.org', async () => {
+        const file = await createFileFromPath(zipFilePath, 'application/zip')
+        const { id } = await jutge.instructor.problems.legacyUpdateWithTerminal(info.problem_nm, file)
+        await showTerminalOutput(id)
+        info.updated_at = new Date().toISOString()
+    })
+
+    await tui.section('Updating problem.yml', async () => {
+        await writeProblemInfo(directory, info)
+        tui.success(`Updated problem.yml`)
+    })
+
+    tui.print('')
+    tui.success(`Problem ${info.problem_nm} updated successfully`)
+
+    return info
+}
+
+async function createZipFile(directory: string, zipFilePath: string, base: string) {
+    const output = createWriteStream(zipFilePath)
+    const archive = archiver('zip', { zlib: { level: 9 } })
+
+    // Wrap the completion in a Promise
+    const zipPromise = new Promise<void>((resolve, reject) => {
+        output.on('close', function () {
+            // console.log(`Archive created: ${archive.pointer()} total bytes`)
+            resolve() // ← Resolve when done
+        })
+
+        output.on('error', reject) // ← Handle output stream errors
+        archive.on('error', reject) // ← Handle archive errors
+        archive.on('warning', function (err) {
+            if (err.code === 'ENOENT') {
+                console.warn(err)
+            } else {
+                reject(err)
+            }
+        })
+    })
+
+    // Pipe archive data to the file
+    archive.pipe(output)
+
+    const add = async (pattern: string) => {
+        const files = glob(pattern, { cwd: directory })
+        const list = await Array.fromAsync(files)
+        const sortedList = list.sort()
+        for (const file of sortedList) {
+            tui.print(`  add ${file}`)
+            archive.file(join(directory, file), { name: join(base, file) })
+        }
+    }
+
+    // Add files according to Jutge.org problem structure
+    await add('README.{md,txt}')
+    await add('problem.yml')
+    await add('handler.yml')
+    await add('problem.[a-z][a-z].{yml,tex}')
+    await add('solution.*')
+    await add('main.*')
+    await add('*.{inp,cor}')
+    await add('award.{html,png}')
+    await add('*.png')
+
+    // Finalize the archive (this does not end immediately, thus the Promise)
+    await archive.finalize()
+    await zipPromise // ← Wait for the file to actually be written
+}
+
+// returns the found problem_nm
+async function showTerminalOutput(id: string): Promise<string | null> {
+    let problem_nm: string | undefined = undefined
+
+    const jutge = new JutgeApiClient()
+
+    const response = await fetch(`${jutge.JUTGE_API_URL}/webstreams/${id}`)
+    if (response.body === null) return null
+
+    const reader = response.body.getReader()
+    while (true) {
+        const { done, value } = await reader.read()
+        if (done) return problem_nm || null
+        const text = new TextDecoder().decode(value as Uint8Array) // TODO: check
+        tui.print(text.replaceAll(/\n/g, '\r\n'))
+        const matchCreated = text.match(/Problem ([A-Z]\d{5}) created./)
+        if (matchCreated) problem_nm = matchCreated[1]
+        const matchUpdated = text.match(/Problem ([A-Z]\d{5}) updated./)
+        if (matchUpdated) problem_nm = matchUpdated[1]
+    }
+}
+
+async function readProblemInfo(directory: string): Promise<ProblemInfo | null> {
+    if (!(await existsInDir(directory, 'problem.yml'))) {
+        return null
+    }
+    return ProblemInfo.parse(await readYamlInDir(directory, 'problem.yml'))
+}
+
+async function writeProblemInfo(directory: string, problemInfo: ProblemInfo): Promise<void> {
+    await writeYamlInDir(directory, 'problem.yml', problemInfo)
+}
+
+// TODO: improve login mechanism
+async function login(jutge: JutgeApiClient): Promise<void> {
+    const email = process.env.JUTGE_EMAIL
+    const password = process.env.JUTGE_PASSWORD
+    if (!email || !password) {
+        throw new Error('JUTGE_EMAIL and JUTGE_PASSWORD environment variables must be set to login')
+    }
+    await jutge.login({ email, password })
+}

package/lib/utils.ts

@@ -0,0 +1,201 @@
+import { execa } from 'execa'
+import { exists, readFile, stat, writeFile } from 'fs/promises'
+import humanId from 'human-id'
+import { customAlphabet } from 'nanoid'
+import { basename, dirname, join, normalize } 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 existsInDir(directory: string, path: string): Promise<boolean> {
+    return await exists(join(directory, path))
+}
+
+export async function readText(path: string): Promise<string> {
+    const content = await readFile(path, 'utf8')
+    return content
+}
+
+export async function readTextInDir(directory: string, path: string): Promise<string> {
+    return await readFile(join(directory, path), 'utf8')
+}
+
+export async function readBytes(path: string): Promise<Uint8Array> {
+    const content = await readFile(path)
+    return content
+}
+
+export async function readBytesInDir(directory: string, path: string): Promise<Uint8Array> {
+    return await readBytes(join(directory, path))
+}
+
+export async function readYaml(path: string): Promise<any> {
+    const content = await readText(path)
+    return YAML.parse(content)
+}
+
+export async function readYamlInDir(directory: string, path: string): Promise<any> {
+    return await readYaml(join(directory, path))
+}
+
+export async function readJson(path: string): Promise<any> {
+    const content = await readText(path)
+    return JSON.parse(content)
+}
+
+export async function readJsonInDir(directory: string, path: string): Promise<any> {
+    return await readJson(join(directory, path))
+}
+
+export async function writeText(path: string, content: string): Promise<void> {
+    await writeFile(path, content)
+}
+
+export async function writeTextInDir(directory: string, path: string, content: string): Promise<void> {
+    await writeText(join(directory, path), 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 writeYamlInDir(directory: string, path: string, data: any): Promise<void> {
+    await writeYaml(join(directory, path), data)
+}
+
+export async function writeJson(path: string, data: any): Promise<void> {
+    const content = JSON.stringify(data, null, 4)
+    await writeText(path, content)
+}
+
+export async function writeJsonInDir(directory: string, path: string, data: any): Promise<void> {
+    await writeJson(join(directory, path), data)
+}
+
+export async function fileSize(path: string): Promise<number> {
+    const stats = await stat(path)
+    return stats.size
+}
+
+export async function fileSizeInDir(directory: string, path: string): Promise<number> {
+    return await fileSize(join(directory, path))
+}
+
+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 filesAreEqualInDir(directory: string, path1: string, path2: string): Promise<boolean> {
+    return await filesAreEqual(join(directory, path1), join(directory, path2))
+}
+
+export async function isDirectory(path: string): Promise<boolean> {
+    try {
+        const stats = await stat(path)
+        return stats.isDirectory()
+    } catch (e) {
+        return false
+    }
+}
+
+export async function isDirectoryInDir(directory: string, path: string): Promise<boolean> {
+    return await isDirectory(join(directory, path))
+}
+
+// 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 normalize(join(__dirname, '..'))
+}
+
+export function toolkitPrefix(): string {
+    return 'jtk'
+}
+
+export async function createFileFromPath(path: string, type: string): Promise<File> {
+    const buffer = await readFile(path)
+    const filename = basename(path)
+    const file = new File([buffer], filename, { type })
+    return file
+}
+
+// Utility function to strip LaTeX commands from text
+// Simplistic implementation; may need to be improved for complex LaTeX but works for basic cases and our needs
+export function stripLaTeX(text: string): string {
+    return text
+        .replace(/\\[a-zA-Z]+\{([^}]*)\}/g, '$1') // Remove commands like \textbf{text}
+        .replace(/\$\$([^$]+)\$\$/g, '$1') // Remove display math $$...$$
+        .replace(/\$([^$]+)\$/g, '$1') // Remove inline math $...$
+        .replace(/\\[a-zA-Z]+/g, '') // Remove other commands
+        .replace(/[{}]/g, '') // Remove remaining braces
+}
+
+export function convertStringToItsType(value: string): string | number | boolean {
+    // Try parsing as boolean
+    const lower = value.toLowerCase()
+    if (lower === 'true') return true
+    if (lower === 'false') return false
+
+    // Try parsing as number
+    if (!isNaN(Number(value)) && value.trim() !== '') {
+        return Number(value)
+    }
+
+    // Return as string
+    return value
+}

package/lib/versions.ts

@@ -0,0 +1,46 @@
+import { execSync } from 'child_process'
+import { join } from 'path'
+import semver from 'semver'
+import tui from './tui'
+import { nothing, projectDir, readJson } from './utils'
+
+const packageJson = await readJson(join(projectDir(), 'package.json'))
+
+export async function checkVersion(): Promise<void> {
+    const currentVersion = await getCurrentVersion()
+    const latestPublishedVersion = await getLatestPublishedVersion()
+    if (semver.lt(currentVersion, latestPublishedVersion)) {
+        tui.warning(
+            `A new version of ${packageJson.name} is available: ${latestPublishedVersion} (you have ${packageJson.version})`,
+        )
+        tui.warning(`Please update by running: jtk upgrade`)
+        tui.print()
+    }
+}
+
+export async function getCurrentVersion(): Promise<string> {
+    await nothing()
+    return packageJson.version as string
+}
+
+export async function getLatestPublishedVersion(): Promise<string> {
+    const response = await fetch(`https://registry.npmjs.org/${packageJson.name}/latest`)
+    const data = (await response.json()) as any
+    return data.version as string
+}
+
+export async function upgrade(): Promise<void> {
+    const currentVersion = await getCurrentVersion()
+    const latestPublishedVersion = await getLatestPublishedVersion()
+    if (semver.eq(currentVersion, latestPublishedVersion)) {
+        tui.success(`You already have the latest version (${currentVersion})`)
+    } else if (semver.gt(currentVersion, latestPublishedVersion)) {
+        tui.success(
+            `You have a newer version (${currentVersion}) than the latest published version (${latestPublishedVersion})`,
+        )
+    } else {
+        tui.action(`Upgrading from version ${currentVersion} to ${latestPublishedVersion}`)
+        execSync(`bun install --global ${packageJson.name}@latest`, { stdio: 'inherit' })
+        tui.success(`Successfully upgraded to version ${latestPublishedVersion}`)
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@jpetit/toolkit",
     "description": "Toolkit to prepare problems for Jutge.org",
-    "version": "3.1.1",
+    "version": "3.1.2",
     "homepage": "https://jutge.org",
     "author": {
         "name": "Jutge.org",
@@ -38,7 +38,9 @@
         "update-jutge-client": "(cd lib ; rm -f jutge_api_client.ts ; https --download https://api.jutge.org/clients/download/typescript)"
     },
     "files": [
-        "assets"
+        "assets",
+        "lib",
+        "toolkit"
     ],
     "dependencies": {
         "@commander-js/extra-typings": "^14.0.0",