@jpetit/toolkit 3.0.23 → 3.1.2

package/lib/settings.ts

@@ -1,24 +1,17 @@
-import { exists } from 'fs/promises'
 import envPaths from 'env-paths'
-import { mkdir } from 'fs/promises'
+import { exists, 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>
+import { guessUserEmail, guessUserName, readYaml, writeYaml } from './utils'
+import { Settings } from './types'
 
 export const paths = envPaths('jutge', { suffix: 'toolkit' })
 
-function configPath() {
-    return join(paths.config, 'config.json')
+export function configPath() {
+    return join(paths.config, 'config.yml')
 }
 
+// console.log(`Configuration path: ${configPath()}`)
+
 export async function initializePaths() {
     await mkdir(paths.config, { recursive: true })
     await mkdir(paths.data, { recursive: true })
@@ -29,14 +22,30 @@ export async function initializePaths() {
 
 export async function saveSettings(settings: Settings) {
     await initializePaths()
-    return await writeJson(configPath(), settings)
+    settings = Settings.parse(settings)
+    return await writeYaml(configPath(), settings)
 }
 
 export async function loadSettings(): Promise<Settings> {
-    const data = await readJson(configPath())
-    return ZSettings.parse(data)
+    const data = await readYaml(configPath())
+    return Settings.parse(data)
+}
+
+export async function loadSettingsAtStart(): Promise<Settings> {
+    if (!(await settingsExist())) {
+        const defaultSettings = Settings.parse({})
+        defaultSettings.name = (await guessUserName()) || 'John Doe'
+        defaultSettings.email = (await guessUserEmail()) || 'john.doe@example.com'
+        await saveSettings(defaultSettings)
+        return defaultSettings
+    } else {
+        return await loadSettings()
+    }
 }
 
 export async function settingsExist(): Promise<boolean> {
     return await exists(configPath())
 }
+
+// settings loaded at the start of the program
+export const settings = await loadSettingsAtStart()

package/lib/tui.ts

@@ -56,21 +56,20 @@ function title(text: string) {
     )
 }
 
-// TODO: use them anywhere
-type CommandOptions = {
-    italic?: boolean
+function command(text: string) {
+    console.log(chalk.magenta(`❯ ${text}`))
 }
 
-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('◳ ' + fileLink(process.cwd(), text)))
 }
 
-function directory(text: string) {
-    console.log(chalk.magenta('◳ ' + hyperlink(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) {
@@ -89,7 +88,11 @@ function action(text: string) {
     console.log(chalk.blue(`${text}...`))
 }
 
-function print(text: string): void {
+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)
@@ -117,8 +120,12 @@ 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))
+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 {
@@ -129,8 +136,11 @@ export default {
     title,
     command,
     directory,
+    url,
+    link,
     warning,
     error,
+    gray,
     success,
     action,
     print,
@@ -138,5 +148,5 @@ export default {
     yaml,
     json,
     image,
-    hyperlink,
+    hyperlink: fileLink,
 }

package/lib/types.ts

@@ -1,15 +1,15 @@
 import { z } from 'zod'
 
-export const ZHandler = z.object({
-    handler: z.enum(['std', 'graphic']).default('std'),
+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 ZHandler>
+export type Handler = z.infer<typeof Handler>
 
-export const ZScores = z.array(
+export const Scores = z.array(
     z.object({
         part: z.string(),
         prefix: z.string(),
@@ -17,4 +17,39 @@ export const ZScores = z.array(
     }),
 )
 
-export type Scores = z.infer<typeof ZScores>
+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

@@ -1,9 +1,8 @@
 import { execa } from 'execa'
-import { readFileSync } from 'fs'
-import { readFile, stat, writeFile } from 'fs/promises'
+import { exists, readFile, stat, writeFile } from 'fs/promises'
 import humanId from 'human-id'
 import { customAlphabet } from 'nanoid'
-import { dirname, join } from 'path'
+import { basename, dirname, join, normalize } from 'path'
 import { fileURLToPath } from 'url'
 import YAML from 'yaml'
 
@@ -11,40 +10,52 @@ 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 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 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> {
@@ -52,22 +63,38 @@ export async function writeYaml(path: string, data: any): Promise<void> {
     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)
@@ -77,6 +104,10 @@ export async function isDirectory(path: string): Promise<boolean> {
     }
 }
 
+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 {
@@ -129,5 +160,42 @@ export function humanid(): string {
 export function projectDir(): string {
     const __filename = fileURLToPath(import.meta.url)
     const __dirname = dirname(__filename)
-    return join(__dirname, '..')
+    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}`)
+    }
+}