@jpetit/toolkit 3.0.14 → 3.0.16

package/lib/compilers/python3.ts

@@ -0,0 +1,96 @@
+import tui from '@/lib/tui'
+import { execa } from 'execa'
+import { cp, exists, rm } from 'fs/promises'
+import { join } from 'path'
+import { readText, writeText } from '@/lib/utils'
+import { Compiler } from './base'
+import type { Handler } from '@/lib/types'
+
+export class Python3_Compiler extends Compiler {
+    id(): string {
+        return 'Python3'
+    }
+
+    name(): string {
+        return 'Python3'
+    }
+
+    type(): string {
+        return 'interpreter'
+    }
+
+    language(): string {
+        return 'Python'
+    }
+
+    async version(): Promise<string> {
+        return await this.getVersion('python3 --version', 0)
+    }
+
+    flags1(): string {
+        return ''
+    }
+
+    flags2(): string {
+        return ''
+    }
+
+    extension(): string {
+        return 'py'
+    }
+
+    async compile(handler: Handler, directory: string, sourcePath: string): Promise<void> {
+        const exePath = sourcePath + '.exe'
+
+        if (handler.source_modifier === 'none') {
+            tui.command(`tweak ${sourcePath} to ${exePath}`, { italic: true })
+            const source = await readText(join(directory, sourcePath))
+            const sourceModified = source
+                .replace('import turtle', 'import turtle_pil as turtle')
+                .replace('from turtle import', 'from turtle_pil import')
+            await writeText(join(directory, exePath), sourceModified)
+        } else if (handler.source_modifier === 'no_main' || handler.source_modifier === 'structs') {
+            tui.command(`cat ${sourcePath} main.py > ${exePath}`)
+            const solution = await readText(join(directory, sourcePath))
+            const main = await readText(join(directory, 'main.py'))
+            const solutionWithMain = solution + '\n\n\n' + main
+            await writeText(join(directory, exePath), solutionWithMain)
+        } else {
+            throw new Error(`Unknown source modifier: ${handler.source_modifier as string}`)
+        }
+
+        tui.command(`python3 -m py_compile ${exePath}`)
+
+        const { exitCode } = await execa({
+            reject: false,
+            stderr: 'inherit',
+            stdout: 'inherit',
+            cwd: directory,
+        })`python3 -m py_compile ${exePath}`
+
+        if (exitCode !== 0) throw new Error(`Compilation failed for ${sourcePath}`)
+    }
+
+    override async execute(handler: Handler, directory: string, inputPath: string, outputPath: string): Promise<void> {
+        const exePath = 'solution.py.exe'
+        if (!(await exists(join(directory, exePath)))) {
+            throw new Error(`Executable file ${exePath} does not exist in directory ${directory}`)
+        }
+        const fullInputPath = join(directory, inputPath)
+        const fullOutputPath = join(directory, outputPath)
+        await rm(fullOutputPath, { force: true })
+        const input = await readText(fullInputPath)
+
+        tui.command(`python3 ${exePath} < ${inputPath} > ${outputPath}`)
+
+        const { exitCode } = await execa({
+            reject: false,
+            input,
+            stdout: { file: fullOutputPath },
+            stderr: 'inherit',
+            cwd: directory,
+        })`python3 ${exePath}`
+
+        if (exitCode !== 0) throw new Error(`Execution failed for ${exePath}`)
+    }
+}

package/lib/compilers/run-haskell.ts

@@ -0,0 +1,107 @@
+import tui from '@/lib/tui'
+import { execa } from 'execa'
+import { cp, exists, rm } from 'fs/promises'
+import { join } from 'path'
+import { readText, writeText } from '@/lib/utils'
+import { Compiler } from './base'
+import type { Handler } from '@/lib/types'
+
+export class RunHaskell_Compiler extends Compiler {
+    id(): string {
+        return 'RunHaskell'
+    }
+
+    name(): string {
+        return 'RunHaskell'
+    }
+
+    type(): string {
+        return 'compiler'
+    }
+
+    language(): string {
+        return 'Haskell'
+    }
+
+    async version(): Promise<string> {
+        return await this.getVersion('ghc --version', 0)
+    }
+
+    flags1(): string {
+        return ''
+    }
+
+    flags2(): string {
+        return ''
+    }
+
+    extension(): string {
+        return 'hs'
+    }
+
+    async compile(handler: Handler, directory: string, sourcePath: string): Promise<void> {
+        if (handler.source_modifier !== 'none') {
+            throw new Error(`Unknown source modifier: ${handler.source_modifier as string}`)
+        }
+
+        // ghci -e ':q' solution.hs
+        // This will load and typecheck the file, then immediately quit.
+        // If there are compilation errors, they'll be shown. If it loads successfully and just exits, the code compiles.
+        // With execa, it seems we have to remove the quotes around :q
+
+        tui.command(`ghci -e ':q' ${sourcePath}`)
+
+        const { exitCode } = await execa({
+            reject: false,
+            stderr: 'inherit',
+            stdout: 'inherit',
+            cwd: directory,
+        })`ghci -e :q ${sourcePath}`
+
+        if (exitCode !== 0) throw new Error(`Compilation failed for ${sourcePath}`)
+    }
+
+    override async execute(handler: Handler, directory: string, inputPath: string, outputPath: string): Promise<void> {
+        const mergedPath = `solution-${inputPath}.hs.exe`
+
+        tui.command(`Merging solution.hs and ${inputPath} into ${mergedPath}`, { italic: true })
+        await this.mergeScripts(directory, 'solution.hs', inputPath, mergedPath)
+
+        const fullOutputPath = join(directory, outputPath)
+
+        await rm(fullOutputPath, { force: true })
+
+        tui.command(`runhaskell ${mergedPath} > ${outputPath}`)
+
+        const { exitCode } = await execa({
+            reject: false,
+            stdout: { file: fullOutputPath },
+            stderr: 'inherit',
+            cwd: directory,
+        })`runhaskell ${mergedPath}`
+
+        if (exitCode !== 0) throw new Error(`Execution failed for ${mergedPath}`)
+    }
+
+    async mergeScripts(
+        directory: string,
+        scriptPath1: string,
+        scriptPath2: string,
+        outputScriptPath: string,
+    ): Promise<void> {
+        const script1 = await readText(join(directory, scriptPath1))
+        const script2 = await readText(join(directory, scriptPath2))
+        let mergedScript = script1
+        mergedScript += '\n\n\nmain = do\n'
+        for (const line of script2.split('\n')) {
+            if (line.trim() === '') {
+                mergedScript += '\n'
+            } else if (line.startsWith('let')) {
+                mergedScript += `    ${line}\n`
+            } else {
+                mergedScript += `    print $ ${line}\n`
+            }
+        }
+        await writeText(join(directory, outputScriptPath), mergedScript)
+    }
+}

package/lib/compilers/run-python.ts

@@ -0,0 +1,103 @@
+import tui from '@/lib/tui'
+import { execa } from 'execa'
+import { cp, exists, rm } from 'fs/promises'
+import { join } from 'path'
+import { readText, writeText } from '@/lib/utils'
+import { Compiler } from './base'
+import type { Handler } from '@/lib/types'
+
+export class RunPython_Compiler extends Compiler {
+    id(): string {
+        return 'RunPython'
+    }
+
+    name(): string {
+        return 'RunPython'
+    }
+
+    type(): string {
+        return 'interpreter'
+    }
+
+    language(): string {
+        return 'Python'
+    }
+
+    async version(): Promise<string> {
+        return await this.getVersion('python3 --version', 0)
+    }
+
+    flags1(): string {
+        return ''
+    }
+
+    flags2(): string {
+        return ''
+    }
+
+    extension(): string {
+        return 'py'
+    }
+
+    async compile(handler: Handler, directory: string, sourcePath: string): Promise<void> {
+        const exePath = sourcePath + '.exe'
+
+        if (handler.source_modifier === 'none') {
+            tui.command(`cp ${sourcePath} ${exePath}`)
+            await cp(join(directory, sourcePath), join(directory, exePath))
+        } else {
+            throw new Error(`Unknown source modifier: ${handler.source_modifier as string}`)
+        }
+
+        tui.command(`python3 -m py_compile ${exePath}`)
+
+        const { exitCode } = await execa({
+            reject: false,
+            stderr: 'inherit',
+            stdout: 'inherit',
+            cwd: directory,
+        })`python3 -m py_compile ${exePath}`
+
+        if (exitCode !== 0) throw new Error(`Compilation failed for ${sourcePath}`)
+    }
+
+    override async execute(handler: Handler, directory: string, inputPath: string, outputPath: string): Promise<void> {
+        const exePath = 'solution.py.exe'
+        if (!(await exists(join(directory, exePath)))) {
+            throw new Error(`Executable file ${exePath} does not exist in directory ${directory}`)
+        }
+
+        const mergedPath = `solution-${inputPath}.py.exe`
+
+        tui.command(`Merging ${exePath} and ${inputPath} into ${mergedPath}`, { italic: true })
+
+        await this.mergeScripts(directory, exePath, inputPath, mergedPath)
+
+        const fullOutputPath = join(directory, outputPath)
+
+        await rm(fullOutputPath, { force: true })
+
+        tui.command(`python3 ${mergedPath} > ${outputPath}`)
+
+        const { exitCode } = await execa({
+            reject: false,
+            stdout: { file: fullOutputPath },
+            stderr: 'inherit',
+            cwd: directory,
+        })`python3 ${mergedPath}`
+
+        if (exitCode !== 0) throw new Error(`Execution failed for ${mergedPath}`)
+    }
+
+    async mergeScripts(
+        directory: string,
+        scriptPath1: string,
+        scriptPath2: string,
+        outputScriptPath: string,
+    ): Promise<void> {
+        const script1 = await readText(join(directory, scriptPath1))
+        const script2 = await readText(join(directory, scriptPath2))
+        const mergedScript = script1 + '\n\n\n' + script2
+        await writeText(join(directory, outputScriptPath), mergedScript)
+    }
+}

package/lib/data.ts

@@ -0,0 +1,19 @@
+import { invert } from 'radash'
+
+export const languageNames: Record<string, string> = {
+    en: 'English',
+    ca: 'Catalan',
+    es: 'Spanish',
+    fr: 'French',
+    de: 'German',
+}
+
+export const proglangNames: Record<string, string> = {
+    c: 'C',
+    cc: 'C++',
+    py: 'Python3',
+    hs: 'Haskell',
+    clj: 'Clojure',
+}
+
+export const proglangExtensions: Record<string, string> = invert(proglangNames)

package/lib/doctor.ts

@@ -0,0 +1,158 @@
+import tui from '@/lib/tui'
+import { execa } from 'execa'
+import { nothing } from './utils'
+import terminalLink from 'terminal-link'
+
+export async function probePython3(showInfo: boolean = false): Promise<boolean> {
+    if (showInfo) tui.command('python3 --version')
+    const { stdout } = await execa({ reject: false })`python3 --version`
+    const version = stdout.trim()
+    if (showInfo) console.log(version)
+    return version.startsWith('Python 3')
+}
+
+export async function probePythonModule(showInfo: boolean = false, module: string): Promise<boolean> {
+    if (showInfo) tui.command(`python3 -m pip show ${module}`)
+    const { exitCode } = await execa({ reject: false })`python3 -m pip show ${module}`
+    if (showInfo) {
+        if (exitCode === 0) {
+            tui.success(`Module ${module} is installed`)
+        } else {
+            tui.warning(`Module ${module} is not installed`)
+        }
+    }
+    return exitCode === 0
+}
+
+export async function probeGCC(showInfo: boolean = false): Promise<boolean> {
+    if (showInfo) tui.command('g++ --version')
+    const { stdout } = await execa({ reject: false })`g++ --version`
+    const version = stdout.split('\n')[0]!.trim()
+    if (showInfo) console.log(version)
+    return stdout.startsWith('Apple clang') || stdout.startsWith('g++')
+}
+
+export async function probePdfLaTeX(showInfo: boolean = false): Promise<boolean> {
+    if (showInfo) tui.command('pdflatex --version')
+    const { stdout } = await execa({ reject: false })`pdflatex --version`
+    const version = stdout.split('\n')[0]!.trim()
+    if (showInfo) console.log(version)
+    return stdout.startsWith('pdfTeX')
+}
+
+export async function probeXeLaTeX(showInfo: boolean = false): Promise<boolean> {
+    if (showInfo) tui.command('xelatex --version')
+    const { stdout } = await execa({ reject: false })`xelatex --version`
+    const version = stdout.split('\n')[0]!.trim()
+    if (showInfo) console.log(version)
+    return stdout.startsWith('XeTeX')
+}
+
+export async function probePandoc(showInfo: boolean = false): Promise<boolean> {
+    if (showInfo) tui.command('pandoc --version')
+    const { stdout } = await execa({ reject: false })`pandoc --version`
+    const version = stdout.split('\n')[0]!.trim()
+    if (showInfo) console.log(version)
+    return stdout.startsWith('pandoc') && stdout.includes('+lua')
+}
+
+export async function probeImageMagick(showInfo: boolean = false): Promise<boolean> {
+    if (showInfo) tui.command('magick --version')
+    const { stdout } = await execa({ reject: false })`magick --version`
+    const version = stdout.split('\n')[0]!.trim()
+    if (showInfo) console.log(version)
+    return stdout.startsWith('Version: ImageMagick')
+}
+
+export async function checkPython3(): Promise<void> {
+    if (await probePython3(true)) {
+        tui.success('Python3 seems installed')
+        const modules = 'turtle-pil yogi easyinput'.split(' ')
+        for (const m of modules) {
+            await probePythonModule(true, m)
+        }
+    } else {
+        tui.warning('Python3 does not appear to be installed')
+        tui.print('This is not a problem if you do not plan to use Python solutions')
+        tui.print('See https://www.python.org/downloads/')
+    }
+}
+
+export async function checkGCC(): Promise<void> {
+    if (await probeGCC(true)) {
+        tui.success('C/C++ seems installed')
+    } else {
+        tui.warning('C/C++ does not appear to be installed')
+        tui.print('This is not a problem if you do not plan to use C or C++ solutions')
+        tui.print('Please install GCC or Clang')
+    }
+}
+
+export async function checkPdfLaTeX(): Promise<void> {
+    if (await probePdfLaTeX(true)) {
+        tui.success('LaTeX seems installed')
+    } else {
+        tui.warning('LaTeX does not appear to be installed')
+        tui.print('You will not be able to generate PDF statements')
+        tui.print('TODO: Provide instructions for installing LaTeX')
+    }
+}
+
+export async function checkXeLaTeX(): Promise<void> {
+    if (await probeXeLaTeX(true)) {
+        tui.success('XeLaTeX seems installed')
+    } else {
+        tui.warning('XeLaTeX does not appear to be installed')
+        tui.print('You will not be able to generate PDF statements with Unicode support')
+        tui.print('TODO: Provide instructions for installing XeLaTeX')
+    }
+}
+
+export async function checkPandoc(): Promise<void> {
+    if (await probePandoc(true)) {
+        tui.success('Pandoc with Lua support seems installed')
+    } else {
+        tui.warning('Pandoc with Lua support does not appear to be installed')
+        tui.print('You will not be able to generate text statements (HTML, TXT, MD)')
+        tui.print('See https://pandoc.org/installing.html')
+    }
+}
+
+export async function checkImageMagick(): Promise<void> {
+    if (await probeImageMagick(true)) {
+        tui.success('ImageMagick seems installed')
+    } else {
+        tui.warning('ImageMagick does not appear to be installed')
+        tui.print('You will not be able to convert images for text statements')
+        tui.print('See https://imagemagick.org/script/download.php')
+    }
+}
+
+export async function checkEnvVars(): Promise<void> {
+    await nothing()
+    const vars = ['OPENAI_API_KEY', 'GEMINI_API_KEY']
+    for (const v of vars) {
+        if (process.env[v]) {
+            tui.success(`${v} is set`)
+        } else {
+            tui.warning(`${v} is not set`)
+            tui.print(`You will not be able to use related AI models`)
+        }
+    }
+}
+
+export async function checkTerminal(): Promise<void> {
+    await nothing()
+    if (process.stdout.isTTY) {
+        tui.success('Terminal supports TTY')
+    } else {
+        tui.warning('Terminal does not support TTY')
+        tui.print('Some output features may not work as expected')
+    }
+    if (terminalLink.isSupported) {
+        tui.success('Terminal supports hyperlinks')
+    } else {
+        tui.warning('Terminal does not support hyperlinks')
+        tui.print('Links to files may not be clickable')
+    }
+}