@jpetit/toolkit 3.1.1 → 3.1.2

package/lib/ai.ts

@@ -0,0 +1,200 @@
+import { encode } from 'gpt-tokenizer'
+
+import { estimateCost } from 'gpt-tokenizer/model/gpt-5'
+import { igniteModel, LlmModel, loadModels, logger, Message } from 'multi-llm-ts'
+import OpenAI from 'openai'
+import tui from './tui'
+import ora from 'ora'
+import { settings } from './settings'
+
+// 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)
+    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)]
+    if (settings.showPrompts) tui.gray(`[SYSTEM PROMPT] ${systemPrompt}`)
+    if (settings.showPrompts) tui.gray(`[USER PROMPT] ${userPrompt}`)
+    const spinner = ora(`Generating response with model ${model}`).start()
+    const response = await bot.complete(messages)
+    spinner.stop()
+    const answer = response.content!
+    if (settings.showAnswers) tui.gray(`[ANSWER] ${answer}`)
+    return answer
+}
+
+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
+    public totalOutputCost: number = 0
+    private messages: Message[]
+    private bot: LlmModel | null = null
+    public totalInputTokens: number = 0
+    public totalOutputTokens: number = 0
+    public totalInputCost: number = 0
+    private systemPrompt: string
+
+    constructor(model: string, systemPrompt: string) {
+        this.model = model
+        this.systemPrompt = systemPrompt
+        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))
+        if (settings.showPrompts) tui.gray(`[SYSTEM PROMPT] ${this.systemPrompt}`)
+        if (settings.showPrompts) tui.gray(`[USER PROMPT] ${this.messages[this.messages.length - 1]!.content}`)
+        const spinner = ora(`Generating response with model ${this.model}`).start()
+        const response = await this.bot.complete(this.messages)
+        spinner.stop()
+        this.messages.push(new Message('assistant', response.content))
+        if (settings.showAnswers) tui.gray(`[ANSWER] ${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
+}
+
+/**
+ * Generate image with openai/dall-e-3 or equivalent model
+ * Returns png image as a Buffer
+ */
+export async function generateImage(model: string, prompt: string): Promise<Buffer> {
+    model = model.split('/')[1]!
+    if (settings.showPrompts) tui.gray(`[PROMPT] ${prompt}`)
+
+    // Initialize OpenAI client
+    const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY })
+
+    // Generate image
+    const spinner = ora(`Generating image with model ${model}`).start()
+    const response1 = await openai.images.generate({
+        model,
+        prompt: prompt,
+        n: 1,
+        size: '1024x1024',
+        quality: 'standard',
+    })
+    spinner.stop()
+
+    // Retrieve image URL
+    if (!response1.data || !response1.data.length || !response1.data[0] || !response1.data[0].url) {
+        throw new Error('No image generated')
+    }
+    const url = response1.data[0].url
+
+    // Download image
+    spinner.start('Downloading image')
+    const response2 = await fetch(url)
+    const arrayBuffer = await response2.arrayBuffer()
+    const buffer = Buffer.from(arrayBuffer)
+    spinner.stop()
+
+    // Done!
+    return buffer
+}

package/lib/cleaner.ts

@@ -0,0 +1,77 @@
+import path from 'path'
+import tui from './tui'
+import { confirm } from '@inquirer/prompts'
+import { readdir, rm } from 'fs/promises'
+import { toolkitPrefix } from './utils'
+
+export async function cleanDirectory(force: boolean, all: boolean, directory: string): Promise<void> {
+    const patterns = [
+        `^${toolkitPrefix()}-`,
+        '\\.exe$',
+        '\\.out$',
+        '\\.pyc$',
+        '\\.class$',
+        '\\.o$',
+        '\\.hi$',
+        '~$',
+        '^a\\.out$',
+        '^__pycache__$',
+    ]
+    const allPatterns = [
+        '\\.cor$',
+        '^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$',
+    ]
+    if (all) {
+        patterns.push(...allPatterns)
+    }
+
+    const pattern = new RegExp(patterns.join('|'))
+
+    const entries = await readdir(directory, { withFileTypes: true })
+
+    const removalList: string[] = []
+    for (const entry of entries) {
+        const fullPath = path.join(directory, entry.name)
+        if (pattern.test(entry.name)) {
+            removalList.push(fullPath)
+        }
+    }
+
+    if (removalList.length === 0) {
+        tui.success('No entries to remove')
+        return
+    }
+
+    tui.warning(`The following ${removalList.length} entries will be removed:`)
+    for (const elem of removalList.sort()) {
+        tui.print(tui.hyperlink(directory, elem))
+    }
+
+    if (!force) {
+        console.log()
+        const conformation = await confirm({
+            message: `Remove ${removalList.length} entries?`,
+            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 entry ${elem}`)
+        }
+    }
+
+    tui.success(`Removed ${removalCount} entries`)
+    if (!all) {
+        tui.warning(`You can use the --all option to remove generated statement and correct files as well`)
+    }
+}

package/lib/compilers/base.ts

@@ -0,0 +1,159 @@
+import { execa } from 'execa'
+import { exists, rm } from 'fs/promises'
+import { join, sep } from 'path'
+import tui from '../tui'
+import type { Handler } from '../types'
+import { readText, toolkitPrefix, writeText } from '../utils'
+
+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 tool(): 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(),
+        }
+    }
+
+    public async compileNormal(handler: Handler, directory: string, sourcePath: string): Promise<string> {
+        const exePath = `${sourcePath}.exe`
+
+        await this.rmInDir(directory, exePath)
+
+        tui.command(`${this.tool()} ${this.flags1()} ${sourcePath} -o ${exePath}`)
+        await execa({
+            reject: false,
+            stderr: 'inherit',
+            stdout: 'inherit',
+            cwd: directory,
+        })`${this.tool()}  ${this.flags1().split(' ')} ${sourcePath} -o ${exePath}`
+
+        return exePath
+    }
+
+    public async compileWithMain(handler: Handler, directory: string, sourcePath: string): Promise<string> {
+        const exePath = `${sourcePath}.exe`
+
+        tui.command(`add main.${this.extension()} to ${sourcePath}`)
+        await this.concatText(directory, [sourcePath, `main.${this.extension()}`], sourcePath)
+
+        tui.command(`${this.tool()} ${this.flags1()} ${sourcePath} -o ${exePath}`)
+        await execa({
+            reject: false,
+            stderr: 'inherit',
+            stdout: 'inherit',
+            cwd: directory,
+        })`${this.tool()} ${this.flags1().split(' ')} ${sourcePath} -o ${exePath}`
+
+        return exePath
+    }
+
+    // Default implementation of execute for compiled languages
+    async execute(
+        handler: Handler,
+        directory: string,
+        sourcePath: string,
+        inputPath: string,
+        outputPath: string,
+    ): Promise<void> {
+        const exePath = `${sourcePath}.exe`
+
+        // TODO: check in windows
+        const relativeExecutablePath = `.${sep}${exePath}` // force prepending ./ to make it work
+        await this.rmInDir(directory, outputPath)
+        const input = await this.getInput(directory, inputPath)
+
+        tui.command(`${relativeExecutablePath} < ${inputPath} > ${outputPath}`)
+
+        const { exitCode } = await execa({
+            reject: false,
+            input,
+            stdout: { file: join(directory, outputPath) },
+            stderr: 'inherit',
+            cwd: directory,
+        })`${relativeExecutablePath}`
+
+        if (exitCode !== 0) {
+            throw new Error(`Execution failed for ${exePath} 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'
+        }
+    }
+
+    getInput(directory: string, inputPath: string): Promise<string> {
+        return readText(join(directory, inputPath))
+    }
+
+    rmInDir(directory: string, path: string): Promise<void> {
+        return rm(join(directory, path), { force: true })
+    }
+
+    existsInDir(directory: string, path: string): Promise<boolean> {
+        return exists(join(directory, path))
+    }
+
+    async concatText(
+        directory: string,
+        inputPaths: string[],
+        outputPath: string,
+        separator: string = '\n\n\n',
+    ): Promise<void> {
+        let content = ''
+        for (const inputPath of inputPaths) {
+            content += (await readText(join(directory, inputPath))) + separator
+        }
+        await writeText(join(directory, outputPath), content)
+    }
+}

package/lib/compilers/clojure.ts

@@ -0,0 +1,87 @@
+import tui from '../tui'
+import { type Handler } from '../types'
+import { Compiler } from './base'
+import { execa } from 'execa'
+import { join } from 'path'
+import { nothing, readText, toolkitPrefix } from '../utils'
+import { rm } from 'fs/promises'
+
+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 ''
+    }
+
+    tool(): string {
+        return 'clj'
+    }
+
+    extension(): string {
+        return 'clj'
+    }
+
+    override async compileNormal(handler: Handler, directory: string, sourcePath: string): Promise<string> {
+        await nothing()
+
+        tui.warning(`No compilation available for Clojure`)
+
+        return sourcePath
+    }
+
+    override async compileWithMain(handler: Handler, directory: string, sourcePath: string): Promise<string> {
+        tui.command(`add main.${this.extension()} to ${sourcePath}`)
+        await this.concatText(directory, [sourcePath, `main.${this.extension()}`], sourcePath)
+
+        tui.warning(`No compilation available for Clojure`)
+
+        return sourcePath
+    }
+
+    override async execute(
+        handler: Handler,
+        directory: string,
+        sourcePath: string,
+        inputPath: string,
+        outputPath: string,
+    ): Promise<void> {
+        const exePath = `${toolkitPrefix()}-${sourcePath}`
+
+        await this.rmInDir(directory, outputPath)
+        const input = await this.getInput(directory, inputPath)
+
+        tui.command(`clj -M ${sourcePath} < ${inputPath} > ${outputPath}`)
+
+        const { exitCode } = await execa({
+            reject: false,
+            input,
+            stdout: { file: join(directory, outputPath) },
+            stderr: 'inherit',
+            cwd: directory,
+        })`clj -M ${sourcePath}`
+
+        if (exitCode !== 0) throw new Error(`Execution failed for ${sourcePath}`)
+    }
+}

package/lib/compilers/gcc.ts

@@ -0,0 +1,39 @@
+import { Compiler } from './base'
+
+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 ''
+    }
+
+    tool(): string {
+        return 'gcc'
+    }
+
+    extension(): string {
+        return 'c'
+    }
+}

package/lib/compilers/ghc.ts

@@ -0,0 +1,39 @@
+import { Compiler } from './base'
+
+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'
+    }
+
+    tool(): string {
+        return 'ghc'
+    }
+
+    extension(): string {
+        return 'hs'
+    }
+}

package/lib/compilers/gxx.ts

@@ -0,0 +1,39 @@
+import { Compiler } from './base'
+
+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'
+    }
+
+    tool(): string {
+        return 'g++'
+    }
+
+    extension(): string {
+        return 'cc'
+    }
+}