@jpetit/toolkit 3.0.23 → 3.1.2

package/assets/prompts/creators/create-solution.tpl.txt

@@ -0,0 +1,10 @@
+Now, write a solution in {{proglang}} to solve this problem
+
+It must be written in an idiomatic way and only include relevant comments.
+The code must be efficient and handle all edge cases.
+The code must read from standard input and write to standard output.
+The code must be well written and easy to understand to novices.
+The code does not have to check the preconditions stated in the problem statement.
+Do not use any non-standard libraries.
+
+{{proglangPrompt}}

package/assets/prompts/creators/create-statement.tpl.txt

@@ -0,0 +1,21 @@
+You are to write the statement of a programming problem in {{language}}.
+
+The statement must be written in LaTeX, using a few predefined macros.
+Use LaTeX math syntax for formulas and variables.
+Use dollars for inline maths and use \[ and \] for display maths.
+Do not add input/output test cases in the statement.
+Separate paragraphs by a blank line and \medskip macro.
+
+Write in the style of programming contests like the ACM ICPC or Jutge.org.
+
+Here is an example for an unrelated problem in English, follow its structure and macros:
+
+{{latexExample}}
+
+The title for the new problem is:
+
+{{title}}
+
+Here is the description of this problem and some additional instructions:
+
+{{description}}

package/assets/prompts/creators/create-translation.tpl.txt

@@ -0,0 +1,5 @@
+Now, translate the problem statement to {{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.

package/assets/prompts/creators/private-test-cases.txt

@@ -0,0 +1,6 @@
+Now, write a private test case file to check the correctness (not the efficiency) of the program.
+
+Only the input should be given, the output will be computed from it.
+Private test cases must be written in plain text format and in the same format that the program reads.
+Private test cases should cover edge cases.
+Limit the number of test cases to a dozen.

package/assets/prompts/creators/sample-test-cases.txt

@@ -0,0 +1,6 @@
+Now, write a sample test case file to illustrate the input that the program must read according to the problem statement.
+
+Only the input should be given, the output will be computed from it.
+Sample test cases must be written in plain text format and in the same format that the program reads.
+Sample test cases should be relatively small but cover interesting cases but not all edge cases.
+If the problem statement features some examples, include them as part of the sample test cases.

package/assets/prompts/creators/system-prompt.txt

@@ -0,0 +1,2 @@
+You are an expert in coding and writing programmming problems.
+You provide accurate information and write following the instructed formats.

package/assets/prompts/examples/statement-coda.tex

@@ -0,0 +1,7 @@
+
+\Observation
+
+This problem has been generated by Jutge$^{\text{AI}}$. Remove this observation after reviewing it carefully.
+
+\Sample
+

package/assets/prompts/examples/statement.tex

@@ -0,0 +1,19 @@
+\Problem{Which one is missing?}
+
+\Statement
+
+Johny has a list of objects, labeled between 1 and $n$, but he lost one of them. He wants to know which one is missing.
+
+\medskip
+
+Write a program that reads sequences with all the numbers between 1 and $n$ but one, and tells which one is missing.
+
+\Input
+
+Input consists of several sequences.
+Every sequence begins with a number $n$ between~1 and~$10^4$ followed by $n - 1$ natural numbers.
+Every number between 1 and $n$ appears exactly once, except one of them, which is missing.
+
+\Output
+
+For every sequence, print the missing number.

package/assets/prompts/generators/efficiency.md

@@ -0,0 +1,41 @@
+# Task: Generate Efficiency Input Test Cases
+
+Write a program in Python that generates efficiency input test cases according to the specification of the given problem statement.
+
+## Important:
+
+- The program should not read any data and should write to standard output.
+
+- Its main program should be as follows:
+
+```
+if __name__ == "__main__":
+    num_cases = int(sys.argv[1])
+    generate_efficiency_test_cases(num_cases)
+```
+
+- Do not change the main program.
+
+- Add a docstring to `generate_efficiency_test_cases` explaining what the program does and what categories of random test cases it generates.
+
+- Add inline comments explaining each test case category.
+
+- Efficiency test cases are those that are specifically designed to challenge the performance and efficiency of the algorithms solving the problem, but not their correctness.
+
+- Efficiency test cases should match the problem constraints.
+
+- The number of test cases to generate is given as the first command-line argument in the `num_cases` variable.
+
+- Do not generate random test cases.
+
+- Use type hints when necessary. Do not use old-style type hints such as `List[int]` with `List` imported from `typing`, but use modern syntax such as `list[int]`.
+
+- Do not use any non-standard libraries.
+
+- Ensure that the generated Python code follows best practices, including proper indentation, use of functions, and adherence to PEP 8 style guidelines.
+
+- Only provide the code for the program, without any additional explanations or text.
+
+## Problem statement
+
+{{statement}}

package/assets/prompts/generators/hard.md

@@ -0,0 +1,47 @@
+# Task: Generate Hard Input Test Cases
+
+Write a program in Python that generates hard input test cases according to the specification of the given problem statement.
+
+## Important:
+
+- The program should not read any data and should write to standard output.
+
+- Its main program should be as follows:
+
+```
+if __name__ == "__main__":
+    generate_hard_test_cases()
+```
+
+- Do not change the main program.
+
+- Add a docstring to `generate_hard_test_cases` explaining what the program does and what categories of random test cases it generates.
+
+- Add inline comments explaining each test case category.
+
+- Hard cases are those that are specifically designed to challenge the correctness of the algorithms solving the problem, but not its efficiency.
+
+- Hard test cases should include:
+    - Edge cases that are not covered by typical random test cases.
+    - Corner cases that exploit known weaknesses in common algorithms for the problem.
+    - Cases that require careful handling of special conditions or constraints.
+    - Common pitfalls that might cause incorrect solutions.
+    - Degenerate cases that test the robustness of the solution.
+
+- But the hard test cases should match the problem constraints.
+
+- Do not generate random test cases.
+
+- Do not generate test cases to test performance or efficiency.
+
+- Use type hints when necessary. Do not use old-style type hints such as `List[int]` with `List` imported from `typing`, but use modern syntax such as `list[int]`.
+
+- Do not use any non-standard libraries.
+
+- Ensure that the generated Python code follows best practices, including proper indentation, use of functions, and adherence to PEP 8 style guidelines.
+
+- Only provide the code for the program, without any additional explanations or text.
+
+## Problem statement
+
+{{statement}}

package/assets/prompts/generators/random.md

@@ -0,0 +1,39 @@
+# Task: Generate Random Input Test Cases
+
+Write a program in Python that generates random input test cases according to the specification of the given problem statement.
+
+## Important:
+
+- The program should not read any data and should write to standard output.
+
+- Its main program should be as follows:
+
+```
+if __name__ == "__main__":
+    num_cases = int(sys.argv[1])
+    seed = int(sys.argv[2]) if len(sys.argv) > 2 else 42
+    random.seed(seed)
+    generate_random_test_cases(num_cases)
+```
+
+- Do not change the main program.
+
+- Add a docstring to `generate_random_test_cases` explaining what the program does and what categories of random test cases it generates.
+
+- Add inline comments explaining each test case category.
+
+- The generated random test cases should match the problem constraints.
+
+- The number of test cases to generate is given as the first command-line argument in the `num_cases` variable.
+
+- Use type hints when necessary. Do not use old-style type hints such as `List[int]` with `List` imported from `typing`, but use modern syntax such as `list[int]`.
+
+- Do not use any non-standard libraries.
+
+- Ensure that the generated Python code follows best practices, including proper indentation, use of functions, and adherence to PEP 8 style guidelines.
+
+- Only provide the code for the program, without any additional explanations or text.
+
+## Problem statement
+
+{{statement}}

package/assets/prompts/proglangs/cc.md

@@ -0,0 +1,3 @@
+Do not use fast input/output methods.
+
+Add a `using namespace std;` declaration after the includes and do not use `std::` prefixes.

package/assets/prompts/proglangs/py.md

@@ -0,0 +1,40 @@
+Use f-strings for string formatting.
+
+Use type hints for function definitions. Do not use old-style type hints such as `List[int]` with `List` imported from `typing`, but use modern syntax such as `list[int]`.
+
+Additionally, ensure that the generated Python3 code follows best practices, including proper indentation, use of functions, and adherence to PEP 8 style guidelines.
+
+Important: Do not use `input()`, `sys.stdin()`, or `EOFError`` to read input as data can be placed freely across many lines. Instead, use the yogi library:
+
+`yogi` provides three functions for reading typed input:
+
+**`read(type)`** - Returns the next token as `int`, `float`, or `str`. Raises exception if input ends or type mismatches.
+
+```python
+from yogi import read
+x = read(int)  # reads and returns one integer
+```
+
+**`scan(type)`** - Like `read()`, but returns `None` instead of raising exceptions when input ends or type mismatches.
+
+```python
+from yogi import scan
+s = 0
+x = scan(int)  # returns int or None
+while x is not None:
+    s += x
+    x = scan(int)  # returns int or None
+print(s)
+```
+
+**`tokens(type)`** - Iterator that yields tokens of specified type until input ends. Raises exception on type mismatch.
+
+```python
+from yogi import tokens
+s = 0
+for x in tokens(int):  # iterates over all integers in the input
+    s += x
+print(s)
+```
+
+In yogi functions, `type` can be `int`, `float`, or `str`.

package/lib/ai.ts

@@ -1,6 +1,11 @@
 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()
@@ -13,13 +18,18 @@ export async function complete(model: string, systemPrompt: string, userPrompt:
     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)]
+    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)
-    return response.content!
+    spinner.stop()
+    const answer = response.content!
+    if (settings.showAnswers) tui.gray(`[ANSWER] ${answer}`)
+    return answer
 }
 
 type ModelInfo = Record<string, Record<string, string[]>>
@@ -45,15 +55,17 @@ export async function listModels(): Promise<ModelInfo> {
 
 export class ChatBot {
     private model: string
-    private bot: LlmModel | null = null
+    public totalOutputCost: number = 0
     private messages: Message[]
+    private bot: LlmModel | null = null
     public totalInputTokens: number = 0
     public totalOutputTokens: number = 0
     public totalInputCost: number = 0
-    public totalOutputCost: number = 0
+    private systemPrompt: string
 
     constructor(model: string, systemPrompt: string) {
         this.model = model
+        this.systemPrompt = systemPrompt
         this.messages = [new Message('system', systemPrompt)]
     }
 
@@ -73,8 +85,13 @@ export class ChatBot {
         }
 
         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
@@ -142,3 +159,42 @@ export function cleanMardownCodeString(s: string): string {
     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

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

@@ -1,9 +1,9 @@
-import tui from '../tui'
 import { execa } from 'execa'
 import { exists, rm } from 'fs/promises'
 import { join, sep } from 'path'
-import { readText } from '../utils'
+import tui from '../tui'
 import type { Handler } from '../types'
+import { readText, toolkitPrefix, writeText } from '../utils'
 
 export type CompilerInfo = {
     compiler_id: string
@@ -32,6 +32,8 @@ export abstract class Compiler {
 
     abstract flags2(): string
 
+    abstract tool(): string
+
     abstract extension(): string
 
     warning(): string {
@@ -57,7 +59,38 @@ export abstract class Compiler {
         }
     }
 
-    abstract compile(handler: Handler, directory: string, sourcePath: string): Promise<void>
+    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(
@@ -67,28 +100,26 @@ export abstract class Compiler {
         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}`)
-        }
+        const exePath = `${sourcePath}.exe`
+
         // 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)
+        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: fullOutputPath },
+            stdout: { file: join(directory, outputPath) },
             stderr: 'inherit',
             cwd: directory,
         })`${relativeExecutablePath}`
 
-        if (exitCode !== 0) throw new Error(`Execution failed for ${executablePath} with exit code ${exitCode}`)
+        if (exitCode !== 0) {
+            throw new Error(`Execution failed for ${exePath} with exit code ${exitCode}`)
+        }
     }
 
     protected async getVersion(cmd: string, lineIndex: number): Promise<string> {
@@ -100,4 +131,29 @@ export abstract class Compiler {
             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

@@ -3,7 +3,7 @@ import { type Handler } from '../types'
 import { Compiler } from './base'
 import { execa } from 'execa'
 import { join } from 'path'
-import { nothing, readText } from '../utils'
+import { nothing, readText, toolkitPrefix } from '../utils'
 import { rm } from 'fs/promises'
 
 export class Clojure_Compiler extends Compiler {
@@ -35,18 +35,29 @@ export class Clojure_Compiler extends Compiler {
         return ''
     }
 
+    tool(): string {
+        return 'clj'
+    }
+
     extension(): string {
         return 'clj'
     }
 
-    async compile(handler: Handler, directory: string, sourcePath: string): Promise<void> {
+    override async compileNormal(handler: Handler, directory: string, sourcePath: string): Promise<string> {
         await nothing()
 
-        if (handler.source_modifier !== 'none') {
-            throw new Error(`source modifier not implemented`)
-        }
+        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(
@@ -56,17 +67,17 @@ export class Clojure_Compiler extends Compiler {
         inputPath: string,
         outputPath: string,
     ): Promise<void> {
-        const fullInputPath = join(directory, inputPath)
-        const fullOutputPath = join(directory, outputPath)
-        await rm(fullOutputPath, { force: true })
-        const input = await readText(fullInputPath)
+        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: fullOutputPath },
+            stdout: { file: join(directory, outputPath) },
             stderr: 'inherit',
             cwd: directory,
         })`clj -M ${sourcePath}`