@jpetit/toolkit 3.0.15 → 3.0.16

package/lib/ai.ts

@@ -0,0 +1,144 @@
+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: '',
+}
+
+export function cleanMardownCodeString(s: string): string {
+    const pattern = /^\n*```\w*\s*(.*?)\s*```\n*$/s
+    const clean = s.replace(pattern, '$1')
+    return clean
+}

package/lib/cleaner.ts

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

package/lib/compilers/base.ts

@@ -0,0 +1,97 @@
+import tui from '@/lib/tui'
+import { execa } from 'execa'
+import { exists, rm } from 'fs/promises'
+import { join, sep } from 'path'
+import { readText } from '@/lib/utils'
+import type { Handler } from '@/lib/types'
+
+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(handler: Handler, directory: string, sourcePath: string): Promise<void>
+
+    // Default implementation of execute for compiled languages
+    async execute(handler: Handler, 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 })
+        const input = await readText(fullInputPath)
+
+        tui.command(`${relativeExecutablePath} < ${inputPath} > ${outputPath}`)
+
+        const { exitCode } = await execa({
+            reject: false,
+            input,
+            stdout: { file: fullOutputPath },
+            stderr: 'inherit',
+            cwd: directory,
+        })`${relativeExecutablePath}`
+
+        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 { stdout } = await execa`${cmd.split(' ')}`
+            const lines = stdout.split('\n')
+            return lines[lineIndex]?.trim() || 'Unknown version'
+        } catch {
+            return 'not found'
+        }
+    }
+}

package/lib/compilers/clojure.ts

@@ -0,0 +1,44 @@
+// TODO: all!
+
+import { type Handler } from '@/lib/types'
+import { nothing } from '@/lib/utils'
+import { Compiler } from './base'
+
+export class Clojure_Compiler extends Compiler {
+    id(): string {
+        return 'Clojure'
+    }
+
+    name(): string {
+        return 'Clojure'
+    }
+
+    type(): string {
+        return 'vm'
+    }
+
+    language(): string {
+        return 'Clojure'
+    }
+
+    async version(): Promise<string> {
+        return await this.getVersion('clj --version', 0)
+    }
+
+    flags1(): string {
+        return ''
+    }
+
+    flags2(): string {
+        return ''
+    }
+
+    extension(): string {
+        return 'clj'
+    }
+
+    async compile(handler: Handler, directory: string, sourcePath: string): Promise<void> {
+        await nothing()
+        throw new Error(`Not implemented`)
+    }
+}

package/lib/compilers/gcc.ts

@@ -0,0 +1,68 @@
+import { type Handler } from '@/lib/types'
+import tui from '@/lib/tui'
+import { Compiler } from './base'
+import { rm, exists } from 'fs/promises'
+import { join } from 'path'
+import { execa } from 'execa'
+
+export class GCC_Compiler extends Compiler {
+    id(): string {
+        return 'GCC'
+    }
+
+    name(): string {
+        return 'GNU C Compiler'
+    }
+
+    type(): string {
+        return 'compiler'
+    }
+
+    language(): string {
+        return 'C'
+    }
+
+    async version(): Promise<string> {
+        return await this.getVersion('gcc --version', 0)
+    }
+
+    flags1(): string {
+        return '-D_JUDGE_ -O2 -DNDEBUG -Wall -Wextra -Wno-sign-compare'
+    }
+
+    flags2(): string {
+        return ''
+    }
+
+    extension(): string {
+        return 'c'
+    }
+
+    async compile(handler: Handler, directory: string, sourcePath: string): Promise<void> {
+        const exePath = sourcePath + '.exe'
+        const fullExePath = join(directory, exePath)
+        await rm(fullExePath, { force: true })
+
+        if (handler.source_modifier === 'none') {
+            tui.command(`gcc ${this.flags1()} ${sourcePath} -o ${exePath}`)
+            await execa({
+                reject: false,
+                stderr: 'inherit',
+                stdout: 'inherit',
+                cwd: directory,
+            })`gcc ${this.flags1().split(' ')} ${sourcePath} -o ${exePath}`
+        } else if (handler.source_modifier === 'no_main') {
+            tui.command(`gcc ${this.flags1()} ${sourcePath} main.cc -o ${exePath}`)
+            await execa({
+                reject: false,
+                stderr: 'inherit',
+                stdout: 'inherit',
+                cwd: directory,
+            })`gcc ${this.flags1().split(' ')} ${sourcePath} main.cc -o ${exePath}`
+        } else {
+            throw new Error(`Unknown source modifier: ${handler.source_modifier}`)
+        }
+
+        if (!(await exists(fullExePath))) throw new Error(`Compilation failed for ${sourcePath}`)
+    }
+}

package/lib/compilers/ghc.ts

@@ -0,0 +1,60 @@
+import { type Handler } from '@/lib/types'
+import tui from '@/lib/tui'
+import { Compiler } from './base'
+import { rm, exists } from 'fs/promises'
+import { join } from 'path'
+import { execa } from 'execa'
+
+export class GHC_Compiler extends Compiler {
+    id(): string {
+        return 'GHC'
+    }
+
+    name(): string {
+        return 'GHC'
+    }
+
+    type(): string {
+        return 'compiler'
+    }
+
+    language(): string {
+        return 'Haskell'
+    }
+
+    async version(): Promise<string> {
+        return await this.getVersion('ghc --version', 0)
+    }
+
+    flags1(): string {
+        return '-O3'
+    }
+
+    flags2(): string {
+        return '-O3'
+    }
+
+    extension(): string {
+        return 'hs'
+    }
+
+    async compile(handler: Handler, directory: string, sourcePath: string): Promise<void> {
+        const exePath = sourcePath + '.exe'
+        const fullExePath = join(directory, exePath)
+        await rm(fullExePath, { force: true })
+
+        if (handler.source_modifier === 'none') {
+            tui.command(`ghc ${this.flags1()} ${sourcePath} -o ${exePath}`)
+            await execa({
+                reject: false,
+                stderr: 'inherit',
+                stdout: 'inherit',
+                cwd: directory,
+            })`ghc ${this.flags1().split(' ')} ${sourcePath} -o ${exePath}`
+        } else {
+            throw new Error(`Unknown source modifier: ${handler.source_modifier}`)
+        }
+
+        if (!(await exists(fullExePath))) throw new Error(`Compilation failed for ${sourcePath}`)
+    }
+}

package/lib/compilers/gxx.ts

@@ -0,0 +1,69 @@
+import { rm, exists } from 'fs/promises'
+import { Compiler } from './base'
+import tui from '@/lib/tui'
+import { join } from 'path'
+import { execa } from 'execa'
+import { type Handler } from '@/lib/types'
+import { stderr } from 'process'
+
+export class GXX_Compiler extends Compiler {
+    id(): string {
+        return 'GXX'
+    }
+
+    name(): string {
+        return 'GNU C++ Compiler'
+    }
+
+    type(): string {
+        return 'compiler'
+    }
+
+    language(): string {
+        return 'C++'
+    }
+
+    async version(): Promise<string> {
+        return await this.getVersion('g++ --version', 0)
+    }
+
+    flags1(): string {
+        return '-std=c++17 -D_JUDGE_ -O2 -DNDEBUG -Wall -Wextra -Wno-sign-compare -Wshadow'
+    }
+
+    flags2(): string {
+        return '-std=c++17 -D_JUDGE_ -O2 -DNDEBUG -Wall -Wextra -Wno-sign-compare -Wshadow'
+    }
+
+    extension(): string {
+        return 'cc'
+    }
+
+    async compile(handler: Handler, directory: string, sourcePath: string): Promise<void> {
+        const outputPath = sourcePath + '.exe'
+        const fullOutputPath = join(directory, outputPath)
+        await rm(fullOutputPath, { force: true })
+
+        if (handler.source_modifier === 'none') {
+            tui.command(`g++ ${this.flags1()} ${sourcePath} -o ${outputPath}`)
+            await execa({
+                reject: false,
+                stderr: 'inherit',
+                stdout: 'inherit',
+                cwd: directory,
+            })`g++ ${this.flags1().split(' ')} ${sourcePath} -o ${outputPath}`
+        } else if (handler.source_modifier === 'no_main') {
+            tui.command(`g++ ${this.flags1()} ${sourcePath} main.cc -o ${outputPath}`)
+            await execa({
+                reject: false,
+                stderr: 'inherit',
+                stdout: 'inherit',
+                cwd: directory,
+            })`g++ ${this.flags1().split(' ')} ${sourcePath} main.cc -o ${outputPath}`
+        } else {
+            throw new Error(`Unknown source modifier: ${handler.source_modifier}`)
+        }
+
+        if (!(await exists(fullOutputPath))) throw new Error(`Compilation failed for ${sourcePath}`)
+    }
+}

package/lib/compilers/index.ts

@@ -0,0 +1,72 @@
+import { nothing } from '@/lib/utils'
+import { Compiler, type CompilerInfo } from './base'
+import { GCC_Compiler } from './gcc'
+import { GXX_Compiler } from './gxx'
+import { Python3_Compiler } from './python3'
+import { GHC_Compiler } from './ghc'
+import { Clojure_Compiler } from './clojure'
+import { RunPython_Compiler } from './run-python'
+import { RunHaskell_Compiler } from './run-haskell'
+
+const compilersRegistryById: Record<string, new () => Compiler> = {
+    C: GCC_Compiler,
+    'C++': GXX_Compiler,
+    Python3: Python3_Compiler,
+    Haskell: GHC_Compiler,
+    Clojure: Clojure_Compiler,
+    RunPython: RunPython_Compiler,
+    RunHaskell: RunHaskell_Compiler,
+}
+
+const compilersRegistryByExtension: Record<string, new () => Compiler> = {
+    c: GCC_Compiler,
+    cc: GXX_Compiler,
+    py: Python3_Compiler,
+    hs: GHC_Compiler,
+    clj: Clojure_Compiler,
+}
+
+export function getCompilerById(id: string): Compiler {
+    const CompilerClass = compilersRegistryById[id]
+    if (!CompilerClass) throw new Error(`Compiler '${id}' is not defined`)
+    const compilerInstance = new CompilerClass()
+    return compilerInstance
+}
+
+export function getCompilerByExtension(extension: string): Compiler {
+    const CompilerClass = compilersRegistryByExtension[extension]
+    if (!CompilerClass) throw new Error(`No compiler defined for extension '.${extension}'`)
+    const compilerInstance = new CompilerClass()
+    return compilerInstance
+}
+
+export async function getDefinedCompilerIds(): Promise<string[]> {
+    await nothing()
+    return Object.keys(compilersRegistryById)
+}
+
+export async function getAvailableCompilers(): Promise<string[]> {
+    const available: string[] = []
+    for (const id of Object.keys(compilersRegistryById)) {
+        const CompilerClass = compilersRegistryById[id]!
+        const compilerInstance = new CompilerClass()
+        if (await compilerInstance.available()) {
+            available.push(id)
+        }
+    }
+    return available
+}
+
+export async function getCompilerInfo(id: string): Promise<CompilerInfo> {
+    const compilerInstance = getCompilerById(id)
+    if (!compilerInstance) throw new Error(`Compiler '${id}' is not defined`)
+    return await compilerInstance.info()
+}
+
+export async function getCompilersInfo(): Promise<Record<string, CompilerInfo>> {
+    const infos: Record<string, CompilerInfo> = {}
+    for (const id of Object.keys(compilersRegistryById)) {
+        infos[id] = await getCompilerInfo(id)
+    }
+    return infos
+}