@jpetit/toolkit 3.0.0

package/lib/ai.ts

@@ -0,0 +1,138 @@
+import { encode } from 'gpt-tokenizer'
+import { estimateCost } from 'gpt-tokenizer/model/gpt-5'
+import { igniteModel, LlmModel, loadModels, logger, Message } from 'multi-llm-ts'
+
+// do not log anything from multi-llm-ts
+logger.disable()
+
+export async function complete(model: string, systemPrompt: string, userPrompt: string): Promise<string> {
+    const parts = model.split('/')
+    const providerName = parts[0]!
+    const modelName = parts[1]!
+
+    const config = { apiKey: process.env[keys[providerName]!] || '' }
+
+    const models = await loadModels(providerName, config)
+    // console.log(models)
+    const chat = models!.chat.find((m) => m.id === modelName)!
+
+    const bot = igniteModel(providerName, chat, config)
+    const messages = [new Message('system', systemPrompt), new Message('user', userPrompt)]
+    const response = await bot.complete(messages)
+    return response.content!
+}
+
+type ModelInfo = Record<string, Record<string, string[]>>
+
+export async function listModels(): Promise<ModelInfo> {
+    const result: ModelInfo = {}
+    const providers = Object.keys(keys).sort()
+    for (const providerName of providers) {
+        if (providerName === 'ollama') continue // Ollama models are local, skip for now
+        const config = { apiKey: process.env[keys[providerName]!] || '' }
+        const models = await loadModels(providerName, config)
+        if (models === null) continue
+        result[providerName] = {}
+        for (const modelType in models) {
+            result[providerName][modelType] = []
+            for (const model of models.chat) {
+                result[providerName][modelType].push(model.id)
+            }
+        }
+    }
+    return result
+}
+
+export class ChatBot {
+    private model: string
+    private bot: LlmModel | null = null
+    private messages: Message[]
+    public totalInputTokens: number = 0
+    public totalOutputTokens: number = 0
+    public totalInputCost: number = 0
+    public totalOutputCost: number = 0
+
+    constructor(model: string, systemPrompt: string) {
+        this.model = model
+        this.messages = [new Message('system', systemPrompt)]
+    }
+
+    async init() {
+        const parts = this.model.split('/')
+        const providerName = parts[0]!
+        const modelName = parts[1]!
+        const config = { apiKey: process.env[keys[providerName]!] || '' }
+        const models = await loadModels(providerName, config)
+        const chat = models!.chat.find((m: any) => m.id === modelName)!
+        this.bot = igniteModel(providerName, chat, config)
+    }
+
+    async complete(userPrompt: string): Promise<string> {
+        if (!this.bot) {
+            throw new Error(`Model '${this.model}' could not be initialized`)
+        }
+
+        this.messages.push(new Message('user', userPrompt))
+        const response = await this.bot.complete(this.messages)
+        this.messages.push(new Message('assistant', response.content))
+
+        const inputTokens = encode(userPrompt).length
+        const outputTokens = encode(response.content!).length
+        const inputCost = estimateCost(inputTokens)
+        const outputCost = estimateCost(outputTokens)
+
+        this.totalInputTokens += inputTokens
+        this.totalOutputTokens += outputTokens
+        this.totalInputCost += inputCost.main!.input!
+        this.totalOutputCost += outputCost.main!.output!
+
+        return response.content!
+    }
+
+    forgetLastInteraction() {
+        if (this.messages.length > 2) {
+            this.messages.pop()
+            this.messages.pop()
+        }
+    }
+
+    modelInformation(): any {
+        if (!this.bot) {
+            throw new Error(`Model '${this.model}' has not been initialized`)
+        }
+        return this.bot.model
+    }
+}
+
+export type PowerEstimation = {
+    wattHours: number
+    joules: number
+    co2Grams: number
+    trees: number
+}
+
+export function estimatePowerConsumption(inputTokens: number, outputTokens: number): PowerEstimation {
+    // Written by Claude.ai
+
+    // Very rough estimates based on public data
+    // One tree absorbs approximately:
+    // - 22 kg (22,000g) of CO2 per year on average
+    // - 1 ton (1,000,000g) over its lifetime (~40 years)
+
+    const wattsPerToken = 0.0003 // ~0.3 milliwatts per token
+    const totalTokens = inputTokens + outputTokens
+    const co2PerTree = 22000
+
+    return {
+        wattHours: (totalTokens * wattsPerToken) / 3600, // Convert to Wh
+        joules: totalTokens * wattsPerToken,
+        co2Grams: ((totalTokens * wattsPerToken) / 3600) * 0.5, // Rough CO2 estimate
+        trees: (((totalTokens * wattsPerToken) / 3600) * 0.5) / co2PerTree,
+    }
+}
+
+const keys: Record<string, string> = {
+    google: 'GEMINI_API_KEY',
+    openai: 'OPENAI_API_KEY',
+    ollama: '',
+}

package/lib/assets.ts

@@ -0,0 +1,31 @@
+import zipFile from '@/assets.zip' with { type: 'file' }
+import chalk from 'chalk'
+import { unzipSync } from 'fflate'
+import { mkdir, rm } from 'fs/promises'
+import { join } from 'path'
+import { paths } from './settings'
+import * as tui from './tui.js'
+
+export async function decompressAssets() {
+    await tui.section('Decompressing assets', async () => {
+        const destination = paths.data
+        tui.action(`Decompressing assets to ${destination}`)
+        const bytes = await Bun.file(zipFile).arrayBuffer()
+        const zipBuffer = new Uint8Array(bytes)
+
+        await rm(destination, { recursive: true, force: true })
+        await mkdir(destination, { recursive: true })
+
+        const unzipped = unzipSync(zipBuffer)
+        for (const [filePath, content] of Object.entries(unzipped)) {
+            // console.log(chalk.magenta(filePath))
+            const fullPath = join(destination, filePath)
+            if (filePath.endsWith('/')) {
+                await mkdir(fullPath, { recursive: true })
+            } else {
+                await Bun.write(fullPath, content)
+            }
+        }
+        tui.success('Assets decompressed')
+    })
+}

package/lib/cleaner.ts

@@ -0,0 +1,58 @@
+import { confirm } from '@inquirer/prompts'
+import * as tui from '@/lib/tui.js'
+import { readdir, unlink } from 'fs/promises'
+import { join } from 'path'
+
+export async function cleanFiles(force: boolean, directory: string): Promise<void> {
+    const patterns = [
+        '\\.exe$',
+        '\\.cor$',
+        '\\.out$',
+        '\\.class$',
+        '\\.o$',
+        '\\.ho$',
+        '~$',
+        '^problem\\.[a-z][a-z]\\.pdf$',
+        '^problem\\.[a-z][a-z]\\.ps$',
+        '^a\\.out$',
+    ]
+    const pattern = new RegExp(patterns.join('|'))
+
+    const entries = await readdir(directory, { withFileTypes: true })
+
+    const removalList: string[] = []
+    for (const entry of entries) {
+        const fullPath = join(directory, entry.name)
+        if (entry.isFile() && pattern.test(entry.name)) {
+            removalList.push(fullPath)
+        }
+    }
+
+    if (removalList.length === 0) {
+        tui.success('No files to remove')
+        return
+    }
+
+    tui.warning(`The following ${removalList.length} files will be removed:`)
+    for (const elem of removalList.sort()) {
+        tui.print(elem)
+    }
+    console.log()
+
+    if (!force) {
+        const conformation = await confirm({ message: `Remove ${removalList.length} files?`, default: false })
+        if (!conformation) return
+    }
+
+    let removalCount = 0
+    for (const elem of removalList) {
+        try {
+            await unlink(elem)
+            removalCount++
+        } catch (error) {
+            tui.error(`Could not remove file ${elem}`)
+        }
+    }
+
+    tui.success(`Removed ${removalCount} files`)
+}

package/lib/compilers/_frompython.ts

@@ -0,0 +1,388 @@
+import { $ } from 'bun'
+import chalk from 'chalk'
+import { access, copyFile, mkdir, readFile, rename, rm, unlink, writeFile } from 'fs/promises'
+
+// Constants
+const MAX_COMPILATION_TIME = 30000 // 30 seconds in milliseconds
+
+// Custom Errors
+export class CompilationTooLongError extends Error {
+    constructor() {
+        super('Compilation time exceeded')
+        this.name = 'CompilationTooLongError'
+    }
+}
+
+export class ExecutionError extends Error {
+    constructor(message: string) {
+        super(message)
+        this.name = 'ExecutionError'
+    }
+}
+
+export class CompilationError extends Error {
+    constructor(message: string) {
+        super(message)
+        this.name = 'CompilationError'
+    }
+}
+
+interface CompilerInfo {
+    compiler_id: string
+    name: string
+    language: string
+    version: string
+    flags1: string
+    flags2: string
+    extension: string
+    type: string
+    warning: string
+}
+
+interface Handler {
+    source_modifier?: string
+    [key: string]: any
+}
+
+const compilersList: Record<string, typeof Compiler> = {}
+
+function compiler(baseClass: typeof Compiler) {
+    return function <T extends typeof Compiler>(derivedClass: T) {
+        compilersList[derivedClass.name] = derivedClass
+        return derivedClass
+    }
+}
+
+export abstract class Compiler {
+    protected handler: Handler
+    protected _name: string
+    static availableCompilers: string[] = []
+
+    constructor(handler: Handler | null, name: string | null) {
+        this.handler = handler || {}
+        this._name = name || ''
+    }
+
+    abstract name(): string
+    abstract type(): string
+    abstract executable(): string
+    abstract language(): string
+    abstract version(): Promise<string>
+    abstract flags1(): string
+    abstract flags2(): string
+    abstract extension(): string
+    abstract compile(): Promise<boolean>
+    abstract execute(tst: string, correct: boolean, iterations?: number): Promise<number>
+
+    id(): string {
+        return this.constructor.name.replace('Compiler_', '').replace('XX', '++')
+    }
+
+    warning(): string {
+        return ''
+    }
+
+    async prepareExecution(ori: string): Promise<void> {
+        // Override in subclasses if needed
+    }
+
+    protected async executeCompiler(cmd: string): Promise<void> {
+        console.log(chalk.dim(cmd))
+
+        return new Promise((resolve, reject) => {
+            const startTime = Date.now()
+            const proc = Bun.spawn(cmd.split(' '), {
+                stdout: 'pipe',
+                stderr: 'pipe',
+            })
+
+            let output = ''
+            let hasError = false
+
+            const timeout = setTimeout(() => {
+                proc.kill()
+                console.log(chalk.bold.red('Compilation time exceeded!'))
+                reject(new CompilationTooLongError())
+            }, MAX_COMPILATION_TIME)
+
+            ;(async () => {
+                try {
+                    const [stdout, stderr] = await Promise.all([
+                        new Response(proc.stdout).text(),
+                        new Response(proc.stderr).text(),
+                    ])
+
+                    output = stdout + stderr
+                    if (stderr.length > 0) {
+                        hasError = true
+                    }
+
+                    const exitCode = await proc.exited
+                    clearTimeout(timeout)
+
+                    if (exitCode !== 0 || hasError || output.length > 0) {
+                        if (output.length > 0) {
+                            console.log('\n' + output.trim() + '\n')
+                        }
+                        console.log(
+                            chalk.bold.red('Compilation error! ') +
+                                chalk.normal(`Please check ${this._name}.${this.extension()} and try again.`),
+                        )
+                        reject(new CompilationError('Compilation failed'))
+                    } else {
+                        resolve()
+                    }
+                } catch (error) {
+                    clearTimeout(timeout)
+                    reject(error)
+                }
+            })()
+        })
+    }
+
+    protected async getVersion(cmd: string, lineIndex: number): Promise<string> {
+        try {
+            const proc = Bun.spawn(cmd.split(' '), {
+                stdout: 'pipe',
+                stderr: 'pipe',
+            })
+
+            const stdout = await new Response(proc.stdout).text()
+            const lines = stdout.split('\n')
+            return lines[lineIndex]?.trim() || 'Unknown version'
+        } catch {
+            return 'not found'
+        }
+    }
+
+    info(): CompilerInfo {
+        return {
+            compiler_id: this.id(),
+            name: this._name,
+            language: this.language(),
+            version: '', // Will be populated asynchronously
+            flags1: this.flags1(),
+            flags2: this.flags2(),
+            extension: this.extension(),
+            type: this.type(),
+            warning: this.warning(),
+        }
+    }
+
+    protected async timeExecution(cmd: string, iterations: number = 1): Promise<number> {
+        const start = Date.now()
+        for (let i = 0; i < iterations; i++) {
+            await $`sh -c ${cmd}`.quiet()
+        }
+        const end = Date.now()
+        return (end - start) / iterations / 1000 // Return in seconds
+    }
+}
+
+// Python3 Compiler
+export class Compiler_Python3 extends Compiler {
+    name(): string {
+        return 'Python3'
+    }
+
+    type(): string {
+        return 'interpreter'
+    }
+
+    executable(): string {
+        return `${this._name}.py`
+    }
+
+    language(): string {
+        return 'Python'
+    }
+
+    async version(): Promise<string> {
+        return await this.getVersion('python3 -V', 0)
+    }
+
+    flags1(): string {
+        return ''
+    }
+
+    flags2(): string {
+        return ''
+    }
+
+    extension(): string {
+        return 'py'
+    }
+
+    private async genWrapper(): Promise<void> {
+        await Util.writeFile(
+            'py3c.py',
+            `#!/usr/bin/python3
+
+import py_compile, sys
+
+py_compile.compile(sys.argv[1])`,
+        )
+    }
+
+    private async delWrapper(): Promise<void> {
+        await Util.delFile('py3c.py')
+    }
+
+    async execute(tst: string, correct: boolean, iterations: number = 1): Promise<number> {
+        let exec = this.executable()
+
+        if (this.handler.source_modifier === 'no_main' || this.handler.source_modifier === 'structs') {
+            await Util.copyFile(`${this._name}.py`, 'modified.py')
+            const ori = await Util.readFile(`${this._name}.py`)
+            const main = await Util.readFile('main.py')
+            await Util.writeFile('modified.py', `${ori}\n${main}\n`)
+            exec = 'modified.py'
+        }
+
+        const ext = correct ? 'cor' : 'py.out'
+        const cmd = `python3 ${exec} < ${tst}.inp > ${tst}.${ext}`
+
+        if (correct) {
+            process.stdout.write(cmd)
+        }
+
+        const time = await this.timeExecution(cmd, iterations)
+
+        await Util.delFile('modified.py')
+        await Util.delDir('__pycache__')
+
+        return time
+    }
+
+    async compile(): Promise<boolean> {
+        if (this.handler.source_modifier === 'no_main' || this.handler.source_modifier === 'structs') {
+            return await this.compileNoMain()
+        } else {
+            return await this.compileNormal()
+        }
+    }
+
+    private async compileNormal(): Promise<boolean> {
+        try {
+            await this.genWrapper()
+            const code = await Util.readFile(`${this._name}.py`)
+            await Util.writeFile(`${this._name}.py`, code)
+            await this.executeCompiler(`python3 py3c.py ${this._name}.py 1> /dev/null`)
+        } catch (error) {
+            if (error instanceof CompilationTooLongError) {
+                console.log(chalk.bold.red('Compilation time exceeded!'))
+            }
+            return false
+        } finally {
+            await this.delWrapper()
+        }
+        return true
+    }
+
+    private async compileNoMain(): Promise<boolean> {
+        if (!(await this.compileNormal())) {
+            return false
+        }
+
+        await Util.copyFile(`${this._name}.py`, 'modified.py')
+        const ori = await Util.readFile(`${this._name}.py`)
+        const main = await Util.readFile('main.py')
+        await Util.writeFile('modified.py', `${ori}\n${main}\n`)
+
+        try {
+            await this.genWrapper()
+            await this.executeCompiler('python3 py3c.py modified.py 1> /dev/null')
+        } catch (error) {
+            if (error instanceof CompilationTooLongError) {
+                console.log(chalk.bold.red('Compilation time exceeded!'))
+            }
+            return false
+        } finally {
+            await this.delWrapper()
+        }
+        return true
+    }
+}
+
+// Compiler registry
+const COMPILERS = ['GCC', 'GXX', 'Python3']
+
+export function getCompiler(cpl: string, handler: Handler | null = null, name: string | null = null): Compiler {
+    const compilerClass = cpl.replace('++', 'XX')
+
+    switch (compilerClass) {
+        case 'GCC':
+            return new Compiler_GCC(handler, name)
+        case 'GXX':
+            return new Compiler_GXX(handler, name)
+        case 'Python3':
+            return new Compiler_Python3(handler, name)
+        default:
+            throw new Error(`Unknown compiler: ${cpl}`)
+    }
+}
+
+export async function getCompilerExtensions(handlerCompiler: string): Promise<Record<string, string>> {
+    const result: Record<string, string> = {}
+
+    for (const compilerName of COMPILERS) {
+        const compiler = getCompiler(compilerName)
+        const ext = compiler.extension()
+
+        if (compilerName === handlerCompiler) {
+            result[ext] = compilerName
+        } else if (!compilerName.includes('Run') && !(ext in result)) {
+            result[ext] = compilerName
+        }
+    }
+
+    return result
+}
+
+export async function getAvailableCompilers(): Promise<string[]> {
+    const available: string[] = []
+
+    for (const compilerName of COMPILERS) {
+        const compiler = getCompiler(compilerName)
+        const version = await compiler.version()
+
+        if (!version.includes('not found')) {
+            available.push(compilerName)
+        }
+    }
+
+    return available
+}
+
+export async function printAvailableCompilers(): Promise<void> {
+    const available = await getAvailableCompilers()
+
+    if (available.length > 0) {
+        process.stdout.write('Available compilers: ')
+
+        for (let i = 0; i < available.length; i++) {
+            process.stdout.write(available[i])
+
+            if (i === available.length - 2) {
+                process.stdout.write(' and ')
+            } else if (i !== available.length - 1) {
+                process.stdout.write(', ')
+            }
+        }
+
+        console.log()
+    }
+}
+
+export async function getCompilerInfo(): Promise<Record<string, CompilerInfo>> {
+    const result: Record<string, CompilerInfo> = {}
+
+    for (const compilerName of COMPILERS) {
+        const compiler = getCompiler(compilerName)
+        const info = compiler.info()
+        info.version = await compiler.version()
+        result[compilerName] = info
+    }
+
+    return result
+}

package/lib/compilers/base.ts

@@ -0,0 +1,97 @@
+import { rm, exists } from 'fs/promises'
+import { join, sep } from 'path'
+import * as tui from '@/lib/tui'
+
+export type CompilerInfo = {
+    compiler_id: string
+    name: string
+    language: string
+    version: string
+    flags1: string
+    flags2: string
+    extension: string
+    type: string
+    warning: string
+}
+
+export abstract class Compiler {
+    abstract id(): string
+
+    abstract name(): string
+
+    abstract type(): string
+
+    abstract language(): string
+
+    abstract version(): Promise<string>
+
+    abstract flags1(): string
+
+    abstract flags2(): string
+
+    abstract extension(): string
+
+    warning(): string {
+        return ''
+    }
+
+    async available(): Promise<boolean> {
+        const version = await this.version()
+        return version !== 'not found'
+    }
+
+    async info(): Promise<CompilerInfo> {
+        return {
+            compiler_id: this.id(),
+            name: this.name(),
+            language: this.language(),
+            version: await this.version(),
+            flags1: this.flags1(),
+            flags2: this.flags2(),
+            extension: this.extension(),
+            type: this.type(),
+            warning: this.warning(),
+        }
+    }
+
+    abstract compile(directory: string, sourcePath: string): Promise<void>
+
+    // Default implementation of execute for compiled languages
+    async execute(directory: string, inputPath: string, outputPath: string): Promise<void> {
+        const executablePath = `solution.${this.extension()}.exe`
+        if (!(await exists(join(directory, executablePath)))) {
+            throw new Error(`Executable file ${executablePath} does not exist in directory ${directory}`)
+        }
+        // TODO: check in windows
+        const relativeExecutablePath = `.${sep}${executablePath}` // force prepending ./ to make it work
+        const fullInputPath = join(directory, inputPath)
+        const fullOutputPath = join(directory, outputPath)
+        await rm(fullOutputPath, { force: true })
+        tui.command(`${relativeExecutablePath} < ${inputPath} > ${outputPath}`)
+        const proc = Bun.spawn([relativeExecutablePath], {
+            cwd: directory,
+            stdin: Bun.file(fullInputPath),
+            stdout: Bun.file(fullOutputPath),
+            stderr: 'inherit',
+        })
+        await proc.exited
+        const exitCode = proc.exitCode
+
+        if (exitCode !== 0) throw new Error(`Execution failed for ${executablePath} with exit code ${exitCode}`)
+    }
+
+    protected async getVersion(cmd: string, lineIndex: number): Promise<string> {
+        try {
+            const proc = Bun.spawn(cmd.split(' '), {
+                stdout: 'pipe',
+                stderr: 'pipe',
+            })
+
+            const stdout = await new Response(proc.stdout).text()
+            const lines = stdout.split('\n')
+            return lines[lineIndex]?.trim() || 'Unknown version'
+        } catch {
+            return 'not found'
+        }
+    }
+}