@jpetit/toolkit 3.1.1 → 3.1.2

package/lib/doctor.ts

@@ -0,0 +1,238 @@
+import { execa } from 'execa'
+import terminalLink from 'terminal-link'
+import tui from './tui'
+import { nothing } from './utils'
+
+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 probeHaskell(showInfo: boolean = false): Promise<boolean> {
+    if (showInfo) tui.command('ghc --version')
+    const { stdout } = await execa({ reject: false })`ghc --version`
+    const version = stdout.split('\n')[0]!.trim()
+    if (showInfo) console.log(version)
+    return stdout.startsWith('The Glorious Glasgow Haskell Compilation System')
+}
+
+export async function probeClojure(showInfo: boolean = false): Promise<boolean> {
+    if (showInfo) tui.command('clj --version')
+    const { stdout } = await execa({ reject: false })`clj --version`
+    const version = stdout.split('\n')[0]!.trim()
+    if (showInfo) console.log(version)
+    return stdout.startsWith('Clojure')
+}
+
+export async function probeJava(showInfo: boolean = false): Promise<boolean> {
+    if (showInfo) tui.command('javac -version')
+    const { stdout } = await execa({ reject: false })`javac -version`
+    const version = stdout.split('\n')[0]!.trim()
+    if (showInfo) console.log(version)
+    return stdout.startsWith('javac')
+}
+
+export async function probeRust(showInfo: boolean = false): Promise<boolean> {
+    if (showInfo) tui.command('rustc --version')
+    const { stdout } = await execa({ reject: false })`rustc --version`
+    const version = stdout.split('\n')[0]!.trim()
+    if (showInfo) console.log(version)
+    return stdout.startsWith('rustc')
+}
+
+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 checkHaskell(): Promise<void> {
+    if (await probeHaskell(true)) {
+        tui.success('Haskell seems installed')
+    } else {
+        tui.warning('Haskell does not appear to be installed')
+        tui.print('This is not a problem if you do not plan to use Haskell solutions')
+        tui.print('See https://www.haskell.org/ghc/download.html')
+    }
+}
+
+export async function checkClojure(): Promise<void> {
+    if (await probeClojure(true)) {
+        tui.success('Clojure seems installed')
+    } else {
+        tui.warning('Clojure does not appear to be installed')
+        tui.print('This is not a problem if you do not plan to use Clojure solutions')
+        tui.print('See https://clojure.org/guides/getting_started')
+    }
+}
+
+export async function checkJava(): Promise<void> {
+    if (await probeJava(true)) {
+        tui.success('Java seems installed')
+    } else {
+        tui.warning('Java does not appear to be installed')
+        tui.print('You will not be able to compile/execute Java solutions')
+        tui.print('See https://www.oracle.com/java/technologies/javase-jdk11-downloads.html')
+    }
+}
+
+export async function checkRust(): Promise<void> {
+    if (await probeRust(true)) {
+        tui.success('Rust seems installed')
+    } else {
+        tui.warning('Rust does not appear to be installed')
+        tui.print('You will not be able to compile/execute Rust solutions')
+        tui.print('See https://www.rust-lang.org/tools/install')
+    }
+}
+
+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 checkAIEnvVars(): Promise<void> {
+    await nothing()
+    const vars = ['OPENAI_API_KEY', 'GEMINI_API_KEY']
+    for (const v of vars) {
+        if (process.env[v]) {
+            tui.success(`${v} environment variable is set`)
+        } else {
+            tui.warning(`${v} environment variable 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')
+    }
+
+    const vars = ['EDITOR', 'VISUAL']
+    for (const v of vars) {
+        if (process.env[v]) {
+            tui.success(`${v} environment variable is set to "${process.env[v]}"`)
+        } else {
+            tui.warning(`${v} environment variable is not set`)
+        }
+    }
+}

package/lib/generate.ts

@@ -0,0 +1,171 @@
+import Handlebars from 'handlebars'
+import { join } from 'path'
+import { cleanMardownCodeString, complete } from './ai'
+import { languageKeys, languageNames, proglangExtensions, proglangKeys, proglangNames } from './data'
+import { getPromptForProglang, getTitleFromStatement } from './helpers'
+import type { Inspector } from './inspector'
+import { settings } from './settings'
+import tui from './tui'
+import { projectDir, readText, readTextInDir, stripLaTeX, writeTextInDir, writeYamlInDir } from './utils'
+import { exists } from 'fs/promises'
+
+export async function addStatementTranslation(model: string, inspector: Inspector, language: string) {
+    const original = inspector.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 (inspector.languages.includes(language)) {
+        throw new Error(`Language ${language} already exists`)
+    }
+    if (!languageKeys.includes(language)) {
+        throw new Error(`Language ${language} is not supported`)
+    }
+
+    const statememt = await readTextInDir(inspector.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.
+    `
+
+        const answer = cleanMardownCodeString(await complete(model, prompt, statememt))
+
+        const info = {
+            title: getTitleFromStatement(answer) || 'Error translating title',
+            translator: settings.name,
+            translator_email: settings.email,
+            model,
+        }
+        await writeTextInDir(inspector.directory, `problem.${language}.tex`, answer)
+        await writeYamlInDir(inspector.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`)
+    })
+}
+
+export async function addAlternativeSolution(model: string, inspector: Inspector, extension: string) {
+    if (!inspector.goldenSolution) {
+        throw new Error('No golden solution defined')
+    }
+    const originalExtension = inspector.goldenSolution.split('.').pop()
+    if (!originalExtension) {
+        throw new Error('Invalid golden solution filename')
+    }
+    if (!proglangKeys.includes(extension)) {
+        throw new Error(`Extension ${extension} is not supported`)
+    }
+    if (inspector.solutions.includes(`solution.${extension}`)) {
+        throw new Error(`Solution already exists`)
+    }
+    const proglang = proglangNames[extension]
+
+    if (!proglang) {
+        throw new Error(`Programming language for extension ${extension} not found`)
+    }
+
+    const originalProglang = proglangNames[originalExtension]
+
+    const goldenSource = await readTextInDir(inspector.directory, inspector.goldenSolution)
+
+    const proglangPrompt = await getPromptForProglang(proglang)
+
+    const prompt = `
+Convert the given program in ${originalProglang} to ${proglang}.
+
+The translation must be accurate and follow the structure and logic of the original program.
+Each function should have a documentation comment explaining its purpose, parameters, and return values.
+
+If some function in the original program is not defined, do not define it in the translated program either.
+
+Your program should start with a comment line saying 'Generated by ${model}'.
+
+${proglangPrompt}
+    `
+
+    const answer = cleanMardownCodeString(await complete(model, prompt, goldenSource))
+
+    await writeTextInDir(inspector.directory, `solution.${extension}`, answer)
+
+    tui.success(`solution.${extension} created`)
+    tui.warning(`Please review the generated solution`)
+}
+
+// TODO: check this function
+export async function addMainFile(model: string, inspector: Inspector, proglang: string) {
+    if (!inspector.goldenSolution) {
+        throw new Error('No golden solution defined')
+    }
+
+    const originalExtension = inspector.goldenSolution.split('.').pop()
+    if (!originalExtension) {
+        throw new Error('Invalid golden solution filename')
+    }
+    const originalProglang = proglangNames[originalExtension]
+
+    const goldenSource = await readTextInDir(inspector.directory, `main.${originalExtension}`)
+
+    await tui.section(`Converting main.${originalExtension} to ${proglang}`, async () => {
+        const proglangPrompt = await getPromptForProglang(proglang)
+
+        const prompt = `
+Convert the given program in ${originalProglang} to ${proglang}.
+
+The translation must be accurate and follow the structure and logic of the original program.
+
+If some function in the original program is not defined, do not define it in the translated program either.
+
+Your program should start with a comment line saying 'Generated by ${model}'.
+
+${proglangPrompt}
+    `
+
+        const answer = cleanMardownCodeString(await complete(model, prompt, goldenSource))
+
+        await writeTextInDir(inspector.directory, `main.${proglangExtensions[proglang]}`, answer)
+
+        tui.success(`main.${proglang} created`)
+        tui.warning(`Please review the generated file`)
+    })
+}
+
+export async function generateTestCasesGenerator(
+    model: string,
+    inspector: Inspector,
+    output: string, // file to create (template with {{type}})
+    type: 'random' | 'hard' | 'efficiency',
+) {
+    const outputPath = Handlebars.compile(output)({ type })
+    await tui.section(`Generating test cases generator ${outputPath}`, async () => {
+        const statement = await getStatementAsText(inspector)
+        const promptPath = join(projectDir(), 'assets', 'prompts', 'generators', `${type}.md`)
+        const promptTemplate = await readText(promptPath)
+        const prompt = Handlebars.compile(promptTemplate)({ statement })
+        const answer = cleanMardownCodeString(await complete(model, '', prompt))
+        await writeTextInDir(inspector.directory, outputPath, answer)
+        tui.success(`Test cases generator ${outputPath} generated`)
+        tui.warning(`Please review the generated test cases generator`)
+    })
+}
+
+// TODO: move into inspector?
+export async function getStatementAsText(inspector: Inspector): Promise<string> {
+    const original = inspector.originalLanguage
+    if (!original) throw new Error('Original language not set')
+    if (await exists(join(inspector.directory, `problem.${original}.txt`))) {
+        const text = await readTextInDir(inspector.directory, `problem.${original}.txt`)
+        return text
+    } else {
+        const latex = await readTextInDir(inspector.directory, `problem.${original}.tex`)
+        const text = stripLaTeX(latex)
+        return text
+    }
+}

package/lib/helpers.ts

@@ -0,0 +1,48 @@
+import { exists } from 'fs/promises'
+import { projectDir, readText } from './utils'
+import { join } from 'path'
+import { normalize, resolve } from 'node:path'
+import { languageNames } from './data'
+
+export function getTitleFromStatement(statement: string): string | null {
+    const pattern = /\\Problem\{(.*?)\}/
+    const match = statement.match(pattern)
+    if (match) {
+        return match[1]!.trim()
+    }
+    return null
+}
+
+export async function getPromptForProglang(proglang: string): Promise<string> {
+    const location = join(projectDir(), 'assets', 'prompts', `${proglang}.md`)
+    if (await exists(location)) {
+        return await readText(location)
+    } else {
+        return ''
+    }
+}
+
+/*
+    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.
+*/
+export 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
+}