@jutge.org/toolkit 4.4.9 → 4.4.17

package/docs/getting-started-guide.md

@@ -1,6 +1,6 @@
 # Jutge Toolkit - Getting Started Guide
 
-Welcome to the New Jutge Toolkit! This guide will help you start using the toolkit to create, manage, and upload programming problems to Jutge.org. Information about problem formats will be provided in a separate document.
+Welcome to the New Jutge Toolkit! This guide will help you start using the toolkit to create, manage, and upload programming problems to Jutge.org. For general problem structure and file formats, see [Problem anatomy](problem-anatomy.md); for quiz problems, see [Quiz anatomy](quiz-anatomy.md).
 
 ## What is Jutge Toolkit?
 

package/docs/login.md

@@ -1 +0,0 @@
-

package/docs/problem-anatomy.md

@@ -34,7 +34,7 @@ There are four types of problems in Jutge.org:
 
 - **Games**: Problems where users must implement an AI to play a game against other users or predefined strategies. These problems often involve turn-based gameplay and require users to implement specific functions to decide their moves. These are not covered in this document.
 
-- **Quizzes**: Problems where users must answer multiple-choice questions. These are not covered in this document.
+- **Quizzes**: Problems where users must answer multiple-choice, fill-in, ordering, matching, or open-ended questions. See [Quiz anatomy](quiz-anatomy.md) for details.
 
 ## Problem structure
 

package/docs/quiz-anatomy.md

@@ -0,0 +1,367 @@
+# Quiz anatomy
+
+This document describes the anatomy of a **quiz problem** in [Jutge.org](https://jutge.org/). It explains the terminology used, the structure of a quiz, and the purpose of each file. Quiz problems are a type of problem where users answer multiple-choice, fill-in, ordering, matching, or open-ended questions instead of submitting a program. Quiz questions and answers may be randomized for each run. For the general structure of a problem folder (e.g. `.pbm` extension, `problem.yml`, statement files), see [Problem anatomy](problem-anatomy.md).
+
+## Terminology
+
+A **quiz** is a problem whose handler is set to `quiz`. It is made of a **quiz root** and a list of **questions**. The quiz root is defined in `quiz.yml` and holds the quiz title, statement, whether questions are shuffled, and the list of questions with their scores. Each **question** is defined in a separate YAML file (e.g. `single-choice.yml`) and has a **type**: SingleChoice, MultipleChoice, FillIn, Ordering, Matching, or OpenQuestion.
+
+Quiz content can be **localized**: the same quiz can have different `quiz.yml` and question files per language (e.g. under `en/` and `ca/`). The toolkit runs or lints the quiz for a given directory, so you typically run it from a language-specific subdirectory. Each language should live inside its own folder.
+
+**Variable substitution** allows question text and options to depend on values generated at run time. If a question file is named `example.yml`, the toolkit looks for `example.py` in the same directory. When present, it runs the Python script with a random **seed** and collects the script’s global variables. Those variables can be referenced in the question YAML with `$name` or `${name}`. This makes it possible to have different numbers, strings, or options for each run while keeping the same correct answer logic (e.g. “What is $a + $b?” with `a` and `b` random).
+
+**Scoring**: Each question has a **score** between 0–100, and the total of all question scores listed in `quiz.yml` must add up to 100. Users earn points for each question based on question type and that question’s **partial_answer** setting. The **partial_answer** option is set per question in the question YAML (not in `quiz.yml`):
+
+- If `partial_answer` is set to `false` (default), users get full points for that question only when their answer is completely correct; any mistake gives zero points for that question.
+
+- If `partial_answer` is set to `true`, users can receive partial points for that question when the answer is partially correct (e.g. proportional to how many parts are right), and the response may still be marked as "correct" if at least one part is right.
+
+## Quiz structure
+
+A quiz lives inside a problem folder (e.g. a `.pbm`). Each language should live inside its own folder (e.g. `en/`, `ca/`) .
+
+Example with multiple languages:
+
+```
+problem_folder.pbm
+├── en
+│   ├── handler.yml
+│   ├── quiz.yml
+│   ├── some-question.yml
+│   ├── some-question.py
+│   └── ...
+├── ca
+│   ├── handler.yml
+│   ├── quiz.yml
+│   ├── some-question.yml
+│   ├── some-question.py
+│   └── ...
+└── problem.yml
+```
+
+You run or lint the quiz from the directory that contains `quiz.yml` (e.g. `jtk quiz run -d en` or `cd en && jtk quiz run`).
+
+`yml` files are YAML (YAML Ain't Markup Language) files. YAML is a human-readable data-serialization language; see [YAML documentation](https://yaml.org/) for more details. Also, see [YAML multiline info](https://yaml-multiline.info/) for more details on how to write multiline strings in YAML.
+
+Many items are written in Markdown. See [Markdown documentation](https://www.markdownguide.org/) for more details. In addition, you can use a small subset of LaTeX for mathematical expressions but these have to be enclosed between `·` signs, not standard `$` signs.
+
+## The `quiz.yml` file
+
+The file `quiz.yml` defines the quiz root.
+
+- **title**: Title of the quiz.
+- **statement**: Short description or instructions shown for the quiz (Markdown).
+- **questions**: List of question entries. Each entry has:
+    - **title**: Title of the question (e.g. for display in a table of contents).
+    - **file**: Base name of the question file, without the `.yml` extension (e.g. `question` for `question.yml`).
+    - **score**: Integer from 0 to 100. The sum of all `score` values in the list must be 100.
+- **shuffle** (optional): Whether to shuffle the order of questions when running the quiz. Defaults to `false`.
+
+### Example
+
+```yaml
+title: Demo quiz
+
+statement: This quiz showcases the possibilities of the quiz problems at Jutge.org.
+
+shuffle: true
+
+questions:
+    - title: Single choice question
+      file: single-choice
+      score: 10
+
+    - title: Multiple choice question
+      file: multiple-choice
+      score: 10
+
+    - title: Fill in question
+      file: fill-in-1
+      score: 20
+
+    - title: Ordering question
+      file: ordering
+      score: 10
+
+    - title: Matchings question
+      file: matchings
+      score: 20
+```
+
+## Question types
+
+Each question is stored in a YAML file whose name matches the `file` field in `quiz.yml` (e.g. `question.yml`). The file must contain a **type** field that identifies the kind of question. All question types support an optional **hide_score** (default `false`) and an optional **partial_answer** (default `false`); see [Scoring](#terminology) above. Variable substitution applies to text fields and options when a corresponding `.py` file exists.
+
+### SingleChoice
+
+One correct option among several. Exactly one choice must have `correct: true`. Choices can be shuffled (optional **shuffle**, default `true`). Each choice can have an optional **hint**. Duplicate choice text is not allowed.
+
+- **text**: Question text (supports `$var` and `${var}`).
+- **choices**: List of `{ text, correct?, hint? }`. One and only one choice must have `correct: true`.
+- **shuffle** (optional): Whether to shuffle choices. Defaults to `true`.
+- **partial_answer** (optional): Whether to award partial credit for this question. Defaults to `false`.
+
+Example:
+
+```yaml
+type: SingleChoice
+
+text: 'What is the result of the evaluation of `$a + $b`?'
+
+choices:
+    - text: '`$s1`'
+      correct: true
+      hint: 'You did well'
+    - text: '`$s2`'
+      hint: 'Sorry...'
+    - text: '`$s3`'
+```
+
+Variables `a`, `b`, `s1`, `s2`, `s3` would be produced by a `single-choice.py` script in the same directory.
+
+### MultipleChoice
+
+Zero or more correct options. Multiple choices can have `correct: true`. Choices can be shuffled (optional **shuffle**, default `true`).
+
+- **text**: Question text (supports variables).
+- **choices**: List of `{ text, correct?, hint? }`.
+- **shuffle** (optional): Whether to shuffle choices. Defaults to `true`.
+- **partial_answer** (optional): Whether to award partial credit for this question. Defaults to `false`.
+
+Example:
+
+```yaml
+type: MultipleChoice
+
+text: 'Which of the following expressions are `true`?'
+
+choices:
+    - text: '`$s == $a + $b`'
+      correct: true
+    - text: '`$s != $a + $b`'
+      hint: 'Sorry...'
+    - text: '`$a + $b >= $s`'
+      correct: true
+```
+
+### FillIn
+
+One or more blanks in a text or code block. Each blank is identified by a placeholder (e.g. `S1`, `XXXX`) and has a correct answer and optional options (dropdown). If **options** are given, the correct answer must be one of them.
+
+- **text**: Question or instructions (supports variables).
+- **context**: Text containing placeholders (e.g. `S1`, `S2`, `XXXX`). Placeholders are the keys in **items**.
+- **items**: Map from placeholder name to an item object:
+    - **correct**: Correct answer (string).
+    - **options** (optional): List of strings; if present, the blank is shown as a dropdown and **correct** must be in this list.
+    - **maxlength** (optional): Max length for the answer. Defaults to 100.
+    - **placeholder** (optional): Placeholder text in the input (e.g. `"?"`).
+    - **ignorecase** (optional): Whether to ignore case when checking. Defaults to `true`.
+    - **trim** (optional): Whether to trim spaces. Defaults to `true`.
+    - **partial_answer** (optional): Whether this blank contributes to partial credit for the question. Defaults to `false`.
+- **partial_answer** (optional, at question level): Whether to award partial credit for this question. Defaults to `false`.
+
+Example with dropdowns:
+
+```yaml
+type: FillIn
+
+text: 'Fill in the blanks.'
+
+context: |
+    A/An S1 is a self-contained step-by-step set of operations...
+    A/An S2 is a collection of instructions...
+
+items:
+    S1:
+        correct: algorithm
+        options:
+            - program
+            - algorithm
+            - pseudocode
+    S2:
+        correct: program
+        options:
+            - program
+            - algorithm
+```
+
+Example with free-text blanks (e.g. numeric):
+
+````yaml
+type: FillIn
+
+text: |
+    Fill in the blanks of the given program.
+
+context: |
+    ```python
+    def sum (L):
+        s = XXXX
+        for x in L:
+            s = s YYYY x
+        return s
+    ```
+
+items:
+    XXXX:
+        maxlength: 5
+        correct: 0
+    YYYY:
+        correct: '+'
+        options:
+            - '+'
+            - '-'
+            - '*'
+            - '/'
+````
+
+### Ordering
+
+User must order a list of items (e.g. chronological order). Items can be shown in shuffled order (optional **shuffle**, default `true`).
+
+- **text**: Question text (supports variables).
+- **label**: Label for the list (e.g. “Programming language”).
+- **items**: List of strings in the **correct** order.
+- **shuffle** (optional): Whether to show items in random order. Defaults to `true`.
+- **partial_answer** (optional): Whether to award partial credit for this question. Defaults to `false`.
+
+Example:
+
+```yaml
+type: Ordering
+
+text: Drag and drop the item to order the programming languages by date of appearance (older on top).
+
+label: Programming language
+
+items:
+    - Fortran
+    - C
+    - C++
+    - Python
+    - Java
+    - Julia
+```
+
+### Matching
+
+Two columns: user matches each left item with one right item. Left and right lists can be shuffled (optional **shuffle**, default `true`).
+
+- **text**: Question text (supports variables).
+- **labels**: Two strings, e.g. `["Countries", "Capitals"]`.
+- **left**: List of strings (e.g. countries).
+- **right**: List of strings (e.g. capitals), in the same order as **left** (left[i] matches right[i]).
+- **shuffle** (optional): Whether to shuffle left and right columns. Defaults to `true`.
+- **partial_answer** (optional): Whether to award partial credit for this question. Defaults to `false`.
+
+Example:
+
+```yaml
+type: Matching
+
+text: Match the countries with their capitals.
+
+labels:
+    - Countries
+    - Capitals
+
+left:
+    - France
+    - Germany
+    - Spain
+    - Italy
+    - Andorra
+
+right:
+    - Paris
+    - Berlin
+    - Madrid
+    - Rome
+    - Andorra la Vella
+```
+
+### OpenQuestion
+
+Free-text answer with no automatic correction. Useful for open-ended or reflective answers.
+
+- **text**: Question text (supports variables).
+- **placeholder** (optional): Placeholder for the text area. Defaults to `""`. Supports variables.
+- **partial_answer** (optional): Whether to award partial credit for this question. Defaults to `false`.
+
+Example:
+
+```yaml
+type: OpenQuestion
+
+text: Talk about yourself.
+
+placeholder: 'My name is **$name** and I want to pass this course.'
+```
+
+The variable `name` can be set by an optional `open-ended.py` (or the same base name as the question file) in the same directory.
+
+## Variable substitution (`.py` files)
+
+If a question file is named `example.yml`, the toolkit looks for `example.py` in the same directory. When present:
+
+1. The Python script is run with a given **seed** (passed as an argument by the toolkit) so that the run is reproducible.
+2. The script’s global variables (that are JSON-serializable and whose names do not start with `__`) are collected.
+3. In the question YAML, any string field that supports substitution can use `$name` or `${name}` to be replaced by the value of `name`.
+
+This allows different runs to show different numbers or options while keeping the same correct answer (e.g. “What is $a + $b?” with `a` and `b` random and one choice `$s1 = a + b` marked correct).
+
+Example `question.py`:
+
+```python
+import random
+
+a = random.randint(1, 10)
+b = random.randint(1, 10)
+
+s1 = a + b
+s2 = a + b - 1
+s3 = a + b + 1
+s4 = a - b
+s5 = a * b
+```
+
+Used with a SingleChoice question where the correct answer is `$s1`, so each run has different numbers but the same structure.
+
+## The `handler.yml` file
+
+For a quiz problem, the problem’s `handler.yml` must set the handler to `quiz`:
+
+```yaml
+handler: quiz
+```
+
+Other handler options (e.g. `std`, `graphic`) are for non-quiz problems. See [Problem anatomy — handler.yml](problem-anatomy.md#the-handleryml-file) for the full list of handler and option descriptions.
+
+## Running and linting quizzes
+
+From the toolkit CLI:
+
+- **Lint** a quiz (validate `quiz.yml` and all referenced question YAML files):
+
+    ```bash
+    jtk quiz lint -d <directory>
+    ```
+
+    Use the directory that contains `quiz.yml` (e.g. the `en` subdirectory).
+
+- **Run** a quiz (build questions, apply variables, output JSON or YAML):
+    ```bash
+    jtk quiz run -d <directory> [-s <seed>] [-f json|yaml]
+    ```
+    If no seed is provided, a random one is used. Running the quiz applies variable substitution and, if `shuffle` is true, shuffles question order (and, per question, choices or ordering/matching items when their `shuffle` is true).
+
+## Quick checklist
+
+- Use a problem folder with `handler: quiz` in `handler.yml`.
+- Place `quiz.yml` in the root (single-language) or in a per-language subdirectory (e.g. `en/`, `ca/`).
+- Ensure every `file` in `quiz.yml` has a corresponding `file.yml` in the same directory.
+- Ensure question scores in `quiz.yml` sum to 100.
+- For SingleChoice, set exactly one choice with `correct: true`.
+- For FillIn with **options**, ensure **correct** is in the **options** list.
+- For Matching, ensure **left** and **right** have the same length and are in matching order.
+- Use variable names in `$name` / `${name}` that are produced by the optional `file.py` script; the script is run with the toolkit’s seed for reproducibility.

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@jutge.org/toolkit",
     "description": "Toolkit to prepare problems for Jutge.org",
-    "version": "4.4.9",
+    "version": "4.4.17",
     "homepage": "https://jutge.org",
     "author": {
         "name": "Jutge.org",
@@ -61,31 +61,33 @@
     ],
     "dependencies": {
         "@commander-js/extra-typings": "^14.0.0",
-        "@dicebear/collection": "^9.3.1",
-        "@dicebear/core": "^9.3.1",
-        "@eslint/js": "^9.39.2",
-        "@inquirer/prompts": "^8.2.0",
+        "@dicebear/collection": "^9.3.2",
+        "@dicebear/core": "^9.3.2",
+        "@eslint/js": "^10.0.1",
+        "@inquirer/prompts": "^8.3.0",
         "adm-zip": "^0.5.16",
         "archiver": "^7.0.1",
         "boxen": "^8.0.1",
-        "bun-types": "^1.3.7",
+        "bun-types": "^1.3.9",
         "chalk": "^5.6.2",
         "chokidar": "^5.0.0",
         "cli-highlight": "^2.1.11",
-        "commander": "^14.0.2",
+        "commander": "^14.0.3",
         "dayjs": "^1.11.19",
         "env-paths": "^4.0.0",
-        "eslint": "^9.39.2",
+        "eslint": "^10.0.2",
         "execa": "^9.6.1",
         "handlebars": "^4.7.8",
         "image-size": "^2.0.2",
         "inquirer-checkbox-plus-plus": "^1.1.1",
+        "marked": "^17.0.3",
+        "marked-terminal": "^7.3.0",
         "nanoid": "^5.1.6",
         "open": "^11.0.0",
         "pretty-bytes": "^7.1.0",
         "pretty-ms": "^9.3.0",
         "radash": "^12.1.1",
-        "semver": "^7.7.3",
+        "semver": "^7.7.4",
         "sharp": "^0.34.5",
         "terminal-link": "^5.0.0",
         "tree-node-cli": "^1.6.0",
@@ -98,10 +100,11 @@
         "@types/adm-zip": "^0.5.0",
         "@types/archiver": "^7.0.0",
         "@types/image-size": "^0.8.0",
-        "@types/node": "^25.1.0",
+        "@types/marked-terminal": "^6.1.1",
+        "@types/node": "^25.3.0",
         "@types/semver": "^7.7.1",
         "prettier": "^3.8.1",
-        "typescript-eslint": "^8.54.0"
+        "typescript-eslint": "^8.56.1"
     },
     "peerDependencies": {
         "typescript": "^5.9.3"

package/toolkit/ask.ts

@@ -21,7 +21,7 @@ export const askCmd = new Command('ask')
         const docs = await loadDocumentation() // Load your markdown files
         const fullPrompt = `${docs}\n\nUser question: ${question}`
 
-        const answer = await complete(jutge, model, "ask", systemPrompt, fullPrompt)
+        const answer = await complete(jutge, model, 'ask', systemPrompt, fullPrompt)
         await tui.markdown(answer)
         tui.warning(
             `This answer generated by JutgeAI using ${model} is not authoritative but we hope it will help you.`,

package/toolkit/dummies.ts

@@ -50,7 +50,6 @@ async function chooseCommand(
         return chooseCommand(program, path.slice(0, -1))
     }
 
-
     const newPath = [...path, chosen]
     const nextCmd = resolveCommand(program, newPath)!
     const nextSubs = getVisibleSubcommands(nextCmd)
@@ -91,10 +90,12 @@ async function promptForArgument(arg: Argument, existing: string[]): Promise<str
 
     const defaultStr =
         defaultVal != null
-            ? (Array.isArray(defaultVal) ? defaultVal.join(' ') : String(defaultVal))
+            ? Array.isArray(defaultVal)
+                ? defaultVal.join(' ')
+                : String(defaultVal)
             : required
-                ? undefined
-                : ''
+              ? undefined
+              : ''
 
     const raw = await input({
         message,

package/toolkit/generate.ts

@@ -1,8 +1,10 @@
-import { Argument, Command } from '@commander-js/extra-typings'
+import { Argument, Command, Option } from '@commander-js/extra-typings'
+import { exists } from 'fs/promises'
 import { join } from 'path'
 import sharp from 'sharp'
-import { createProblemWithJutgeAI } from '../lib/create-with-jutgeai'
 import { complete } from '../lib/aiclient'
+import { createFuncsProblem } from '../lib/create-funcs'
+import { createIOProblem } from '../lib/create-io'
 import { languageKeys, languageNames, proglangKeys, proglangNames } from '../lib/data'
 import {
     addAlternativeSolution,
@@ -11,11 +13,11 @@ import {
     generateStatementFromSolution,
     generateTestCasesGenerator,
 } from '../lib/generate'
+import { getLoggedInJutgeClient } from '../lib/login'
 import { newProblem } from '../lib/problem'
 import { settings } from '../lib/settings'
 import tui from '../lib/tui'
 import { writeText } from '../lib/utils'
-import { getLoggedInJutgeClient } from '../lib/login'
 
 export const generateCmd = new Command('generate')
     .description('Generate problem elements using JutgeAI')
@@ -28,16 +30,76 @@ generateCmd
     .command('problem')
     .description('Generate a problem with JutgeAI')
 
+    .summary(
+        `Generate a problem with JutgeAI
+
+Use this command to generate a problem with JutgeAI from a specification.
+
+There are currently two types of problems that can be generated:
+
+- io: The problem consists of reading input from standard input and writing output to standard output.
+
+    Current implementation supports C, C++, Python, Haskell, Java, Rust, R and Clojure programming languages.
+    
+    The following items will be generated:
+        - problem statement in original language
+        - sample test cases
+        - private test cases
+        - golden solution 
+        - translations of the problem statement into other languages
+        - alternative solutions in other programming languages
+        - test cases generators
+        - a README.md file describing the problem and LLM usage
+
+- funcs: The problem consists of implementing one or more functions.
+
+    Current implementation supports Python, Haskell and Clojure programming languages (through RunPython, RunHaskell and RunClojure compilers).
+
+    The following items will be generated:
+        - problem statement in original language
+        - translations of the problem statement into other languages
+        - generate sample.dt for Python
+        - sample test cases
+        - private test cases for each function
+        - golden solution
+        - alternative solutions in other programming languages
+        - scores.yml file with the scores for each function (if there is more than one function)
+        - a README.md file describing the problem and LLM usage
+
+Problem generation needs a problem specification:
+    - If --input is provided, the system will read the given input specification file.
+    - If --output is provided, the system will write the problem specification to the given output specification file.
+    - The system will ask interactively for the problem specification (using the values in the --input specification file if provided as defaults)
+    - unless the --do-not-ask flag is given.
+
+Treat the generated problem as a starting draft. You should edit the problem directory manually after the generation.
+`,
+    )
+
+    .addOption(new Option('-k, --kind <kind>', 'problem kind').default('io').choices(['io', 'funcs']))
     .option('-d, --directory <path>', 'output directory', 'new-problem.pbm')
     .option('-i, --input <path>', 'input specification file')
     .option('-o, --output <path>', 'output specification file')
     .option('-n, --do-not-ask', 'do not ask interactively if --input given', false)
     .option('-m, --model <model>', 'AI model to use', settings.defaultModel)
 
-    .action(async ({ input, output, directory, model, doNotAsk }) => {
+    .action(async ({ input, output, directory, model, doNotAsk, kind }) => {
         const jutge = await getLoggedInJutgeClient()
-        await tui.section('Generating problem with JutgeAI', async () => {
-            await createProblemWithJutgeAI(jutge, model, directory, input, output, doNotAsk)
+        await tui.section(`Generating ${kind} problem with JutgeAI`, async () => {
+            if (await exists(directory)) {
+                throw new Error(`Directory ${directory} already exists`)
+            }
+            if (!directory.endsWith('.pbm')) {
+                throw new Error('The output directory must end with .pbm')
+            }
+
+            if (kind === 'io') {
+                await createIOProblem(jutge, model, directory, input, output, doNotAsk)
+            } else if (kind === 'funcs') {
+                await createFuncsProblem(jutge, model, directory, input, output, doNotAsk)
+            } else {
+                throw new Error(`Invalid problem kind: ${kind as string}`)
+            }
         })
     })
 
@@ -52,8 +114,8 @@ The original statement will be used as the source text for translation.
 
 Provide one or more target language from the following list:
 ${Object.entries(languageNames)
-            .map(([key, name]) => `  - ${key}: ${name}`)
-            .join('\n')}
+    .map(([key, name]) => `  - ${key}: ${name}`)
+    .join('\n')}
 
 The added translations will be saved in the problem directory overwrite possible existing files.`,
     )
@@ -94,7 +156,14 @@ The result is written to statement.<lang>.tex in the problem directory.`,
     .action(async (proglang, language, prompt, { directory, model }) => {
         const jutge = await getLoggedInJutgeClient()
         const problem = await newProblem(directory)
-        await generateStatementFromSolution(jutge, model, problem, proglang, language, (prompt ?? '').trim() || undefined)
+        await generateStatementFromSolution(
+            jutge,
+            model,
+            problem,
+            proglang,
+            language,
+            (prompt ?? '').trim() || undefined,
+        )
     })
 
 generateCmd
@@ -108,8 +177,8 @@ The golden solution will be used as a reference for generating the alternatives.
 
 Provide one or more target programming languages from the following list:
 ${Object.entries(languageNames)
-            .map(([key, name]) => `  - ${key}: ${name}`)
-            .join('\n')}
+    .map(([key, name]) => `  - ${key}: ${name}`)
+    .join('\n')}
 
 The added solutions will be saved in the problem directory overwrite possible existing files.`,
     )
@@ -143,8 +212,8 @@ The main file for the golden solution will be used as a reference for generating
 
 Provide one or more target programming languages from the following list:
 ${Object.entries(languageNames)
-            .map(([key, name]) => `  - ${key}: ${name}`)
-            .join('\n')}
+    .map(([key, name]) => `  - ${key}: ${name}`)
+    .join('\n')}
 
 The added main files will be saved in the problem directory overwrite possible existing files.`,
     )
@@ -211,7 +280,7 @@ The new image will be saved as award.png in the problem directory, overriding an
     .action(async (prompt, { directory, model }) => {
         const jutge = await getLoggedInJutgeClient()
         const output = join(directory, 'award.png')
-        const problem = await newProblem(directory)
+        await newProblem(directory)
         let imagePrompt = prompt.trim()
         if (imagePrompt === '') {
             imagePrompt = 'A colorful award on a white background'

package/toolkit/lint.ts

@@ -16,7 +16,8 @@ export async function printLintResults(results: LintResult[], directories: strin
         const errors = result.issues.filter((i) => i.severity === 'error')
         if (errors.length > 0) hasError = true
 
-        const dirLabel = result.directory === directories[0] && results.length === 1 ? result.directory : result.directory
+        const dirLabel =
+            result.directory === directories[0] && results.length === 1 ? result.directory : result.directory
         if (result.issues.length === 0) {
             tui.print(chalk.green('✓') + ' ' + dirLabel + ' ' + chalk.gray('— no issues'))
         } else {
@@ -35,9 +36,7 @@ export async function printLintResults(results: LintResult[], directories: strin
         const totalErrors = results.reduce((s, r) => s + r.issues.filter((i) => i.severity === 'error').length, 0)
         const totalWarnings = results.reduce((s, r) => s + r.issues.filter((i) => i.severity === 'warning').length, 0)
         if (totalErrors > 0 || totalWarnings > 0) {
-            tui.gray(
-                `Total: ${totalErrors} error(s), ${totalWarnings} warning(s) across ${results.length} problem(s)`,
-            )
+            tui.gray(`Total: ${totalErrors} error(s), ${totalWarnings} warning(s) across ${results.length} problem(s)`)
         }
     }