@jpetit/toolkit 3.0.23 → 3.1.1

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/package.json

@@ -1,27 +1,50 @@
 {
     "name": "@jpetit/toolkit",
     "description": "Toolkit to prepare problems for Jutge.org",
-    "version": "3.0.23",
+    "version": "3.1.1",
+    "homepage": "https://jutge.org",
+    "author": {
+        "name": "Jutge.org",
+        "email": "info@jutge.org",
+        "url": "https://jutge.org"
+    },
+    "contributors": [
+        {
+            "name": "Jordi Petit",
+            "url": "https://github.com/jordi-petit"
+        },
+        {
+            "name": "Pau Fernández",
+            "url": "https://github.com/pauek"
+        }
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/jutge-org/jutge-toolkit.git"
+    },
     "publishConfig": {
         "access": "public"
     },
     "module": "index.ts",
     "type": "module",
-    "bin": "toolkit/index.ts",
+    "bin": {
+        "jutge-toolkit": "toolkit/index.ts",
+        "jtk": "toolkit/index.ts"
+    },
     "scripts": {
         "lint": "eslint .",
         "format": "bun prettier --write .",
-        "depcheck": "bunx depcheck"
+        "depcheck": "bunx depcheck",
+        "update-jutge-client": "(cd lib ; rm -f jutge_api_client.ts ; https --download https://api.jutge.org/clients/download/typescript)"
     },
     "files": [
-        "lib",
-        "toolkit",
         "assets"
     ],
     "dependencies": {
         "@commander-js/extra-typings": "^14.0.0",
         "@eslint/js": "^9.39.2",
         "@inquirer/prompts": "^8.1.0",
+        "archiver": "^7.0.1",
         "boxen": "^8.0.1",
         "bun-types": "^1.3.5",
         "chalk": "^5.6.2",
@@ -30,35 +53,49 @@
         "eslint": "^9.39.2",
         "execa": "^9.6.1",
         "gpt-tokenizer": "^3.4.0",
+        "handlebars": "^4.7.8",
         "human-id": "^4.1.3",
         "image-size": "^2.0.2",
-        "install": "^0.13.0",
-        "jdenticon": "^3.3.0",
+        "inquirer-checkbox-plus-plus": "^1.1.1",
         "marked": "^17.0.1",
         "marked-terminal": "^7.3.0",
         "multi-llm-ts": "^4.6.2",
         "nanoid": "^5.1.6",
+        "openai": "^6.15.0",
         "ora": "^9.0.0",
         "prettier": "^3.7.4",
         "pretty-bytes": "^7.1.0",
         "pretty-ms": "^9.3.0",
         "radash": "^12.1.1",
-        "slug": "^11.0.1",
+        "semver": "^7.7.3",
+        "sharp": "^0.34.5",
         "terminal-image": "^4.1.0",
         "terminal-link": "^5.0.0",
-        "typescript-eslint": "^8.50.0",
+        "typescript-eslint": "^8.51.0",
         "yaml": "^2.8.2",
-        "zod": "^4.2.1"
+        "zod": "^4.3.4",
+        "zod-package-json": "^2.1.0",
+        "zod-validation-error": "^5.0.0"
     },
     "devDependencies": {
+        "@types/archiver": "^7.0.0",
         "@types/image-size": "^0.8.0",
         "@types/marked": "^6.0.0",
         "@types/marked-terminal": "^6.1.1",
         "@types/node": "^25.0.3",
         "@types/ora": "^3.2.0",
-        "@types/slug": "^5.0.9"
+        "@types/semver": "^7.7.1"
     },
     "peerDependencies": {
         "typescript": "^5.9.3"
+    },
+    "prettier": {
+        "semi": false,
+        "singleQuote": true,
+        "trailingComma": "all",
+        "tabWidth": 4,
+        "useTabs": false,
+        "arrowParens": "always",
+        "printWidth": 120
     }
 }

package/toolkit/index.ts

@@ -1,34 +1,44 @@
 #!/usr/bin/env bun
 
 import { program } from '@commander-js/extra-typings'
-import { confirm } from '@inquirer/prompts'
 import { join } from 'path'
-import { ai } from './ai'
-import { clean } from './clean'
-import { compilers } from './compilers'
-import { create } from './create'
-import { doctor } from './doctor'
-import { init } from './init'
-import { make } from './make'
-import { verify } from './verify'
-import { generate } from './generate'
+import { ZodError } from 'zod'
+import { fromError } from 'zod-validation-error'
+import { settings } from '../lib/settings'
 import { projectDir, readJson } from '../lib/utils'
+import { aboutCmd } from './about'
+import { aiCmd } from './ai'
+import { checkCmd } from './check'
+import { cleanCmd } from './clean'
+import { compilersCmd } from './compilers'
+import { configCmd } from './config'
+import { createCmd } from './create'
+import { doctorCmd } from './doctor'
+import { generateCmd } from './generate'
+import { makeCmd } from './make'
+import { upgradeCmd } from './upgrade'
+import { uploadCmd } from './upload'
 
 const packageJson = await readJson(join(projectDir(), 'package.json'))
 
 program.name('jutge-toolkit')
+program.alias('jtk')
 program.version(packageJson.version as string)
 program.description(packageJson.description as string)
+program.helpCommand('help [command]', 'Display help for command') // To get the message with uppercase :-)
 
-program.addCommand(init)
-program.addCommand(create)
-program.addCommand(make)
-program.addCommand(verify)
-program.addCommand(generate)
-program.addCommand(clean)
-program.addCommand(compilers)
-program.addCommand(doctor)
-program.addCommand(ai)
+program.addCommand(configCmd)
+program.addCommand(createCmd)
+program.addCommand(makeCmd)
+program.addCommand(checkCmd)
+program.addCommand(generateCmd)
+program.addCommand(cleanCmd)
+program.addCommand(uploadCmd)
+program.addCommand(compilersCmd)
+program.addCommand(doctorCmd)
+program.addCommand(aiCmd)
+program.addCommand(upgradeCmd)
+program.addCommand(aboutCmd)
 
 try {
     await program.parseAsync()
@@ -38,10 +48,11 @@ try {
     if (error instanceof Error) {
         if (error.name === 'ExitPromptError') {
             console.error('Operation cancelled by the user')
+        } else if (error instanceof ZodError) {
+            console.error(fromError(error).toString())
         } else {
             console.error(error.message)
-            const showTrace = await confirm({ message: 'Show stack trace?', default: false })
-            if (showTrace) console.error(error)
+            if (settings.developer) console.error(error)
         }
     } else {
         console.error(error)

package/lib/ai.ts

@@ -1,144 +0,0 @@
-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

@@ -1,66 +0,0 @@
-import tui from './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`)
-}