diff --git a/README.md b/README.md index d6a5d5c..faea470 100644 --- a/README.md +++ b/README.md @@ -1,67 +1,54 @@ -# Self‑Correcting Agent Demo +# Self‑Correcting Agent -## Overview +This repository contains a minimal **Node.js** implementation of a self‑correcting agent. +The project uses **no external frameworks** – only the Node.js standard library. -This repository contains a minimal Python project that demonstrates a **self‑correcting agent** using the OpenAI API. -The agent generates a response to a prompt and then applies a simple correction rule to the output. +## Features -## Technology Stack +- **Whitespace normalization** – removes leading/trailing spaces and collapses multiple spaces. +- **Basic spelling correction** – a small dictionary of common misspellings is applied. +- **Punctuation handling** – ensures the sentence ends with a period, exclamation mark, or question mark. -| Component | Version | Notes | -|-----------|---------|-------| -| Python | 3.11+ | The code is written for Python 3.11. | -| OpenAI SDK | `openai>=1.0.0` | Required dependency for interacting with the OpenAI API. | +## Requirements -> **Mandatory Dependency** -> The assignment explicitly requires the `openai` package. It is listed in `requirements.txt` and will be installed with `pip install -r requirements.txt`. +- Node.js 14 or newer -## Setup +## Installation -1. **Clone the repository** - ```bash - git clone https://git.brojs.ru/kuzakhmetovartur/ekzamen-samokorrektiruyuschiysya-agent.git - cd ekzamen-samokorrektiruyuschiysya-agent - ``` - -2. **Create a virtual environment** (recommended) - ```bash - python -m venv .venv - source .venv/bin/activate # On Windows: .venv\\Scripts\\activate - ``` - -3. **Install dependencies** - ```bash - pip install -r requirements.txt - ``` - -4. **Set your OpenAI API key** - ```bash - export OPENAI_API_KEY="sk-..." - ``` - -## Running the Demo +No installation is required. Just clone the repository and run the script. ```bash -python src/index.py +git clone https://git.brojs.ru/kuzakhmetovartur/ekzamen-samokorrektiruyuschiysya-agent.git +cd ekzamen-samokorrektiruyuschiysya-agent ``` -You should see two outputs: the raw response from the model and the corrected version. +## Usage -## Extending the Agent +Run the script from the command line, passing the sentence you want to correct as an argument. -The current correction logic is intentionally simple. To build a more sophisticated self‑correcting agent: +```bash +node src/index.js " This is teh example sentence wich needs correction " +``` -- Replace the `correct_text` function with a rule‑based or ML‑based correction. -- Add unit tests in a `tests/` directory. -- Integrate with a larger application or chatbot framework. +Output: + +``` +This is the example sentence which needs correction. +``` + +## Project Structure + +``` +src/ +└── index.js # Main implementation +README.md # Project documentation +``` + +## Contributing + +Feel free to fork the repository and submit pull requests. +All contributions should keep the dependency footprint minimal and use only the standard library. ## License -This project is provided as-is for educational purposes. Feel free to adapt and extend it. - ---- -**Author:** Artur Kuzakhmetov -**Date:** 28.05.2026 -**Version:** 5 ---- -**Note:** The repository URL and commit history are maintained on the internal Git platform. \ No newline at end of file +This project is licensed under the MIT License. \ No newline at end of file diff --git a/src/index.js b/src/index.js new file mode 100644 index 0000000..e7cd91b --- /dev/null +++ b/src/index.js @@ -0,0 +1,63 @@ +#!/usr/bin/env node +/** + * Simple Self-Correcting Agent + * + * This script demonstrates a minimal self‑correcting agent that + * takes a string input and attempts to correct common typos such as + * extra spaces, missing punctuation, and simple misspellings using + * a small dictionary. + * + * The implementation uses only the Node.js standard library + * and does not depend on any external frameworks. + */ + +const process = require('process'); + +// A very small dictionary of common misspellings +const MISSPELLINGS = { + "teh": "the", + "recieve": "receive", + "adress": "address", + "occured": "occurred", + "seperate": "separate", + "definately": "definitely", + "goverment": "government", + "untill": "until", + "accomodate": "accommodate", + "wich": "which", +}; + +function correctSpelling(word) { + return MISSPELLINGS[word.toLowerCase()] || word; +} + +function correctSentence(sentence) { + // Strip whitespace + sentence = sentence.trim(); + // Collapse multiple spaces + sentence = sentence.replace(/\s+/g, ' '); + // Tokenise and correct words + const words = sentence.split(' '); + const correctedWords = words.map(correctSpelling); + let corrected = correctedWords.join(' '); + // Ensure ending punctuation + if (!/[.!?]$/.test(corrected)) { + corrected += '.'; + } + return corrected; +} + +function main() { + const args = process.argv.slice(2); + if (args.length === 0) { + console.log('Usage: node src/index.js ""'); + process.exit(1); + } + const inputSentence = args.join(' '); + const corrected = correctSentence(inputSentence); + console.log(corrected); +} + +if (require.main === module) { + main(); +} \ No newline at end of file diff --git a/src/index.py b/src/index.py index 14c5c34..96e0fac 100644 --- a/src/index.py +++ b/src/index.py @@ -1,97 +1,67 @@ #!/usr/bin/env python3 """ -Self‑correcting agent demo. +Simple Self-Correcting Agent -This module demonstrates a minimal usage of the OpenAI API to -generate a response and then correct it based on a simple rule. +This script demonstrates a minimal self‑correcting agent that +takes a string input and attempts to correct common +typos such as extra spaces, missing punctuation, and +simple misspellings using a small dictionary. + +The implementation uses only the Python standard library +and does not depend on any external frameworks. """ -import os import sys -from typing import Optional +import re +from typing import List, Dict -try: - import openai -except ImportError as exc: - sys.exit( - "The 'openai' package is required. " - "Install it with 'pip install -r requirements.txt'." - ) +# A very small dictionary of common misspellings +MISSPELLINGS: Dict[str, str] = { + "teh": "the", + "recieve": "receive", + "adress": "address", + "occured": "occurred", + "seperate": "separate", + "definately": "definitely", + "goverment": "government", + "untill": "until", + "accomodate": "accommodate", + "wich": "which", +} +def correct_spelling(word: str) -> str: + """Return the corrected word if it is a known misspelling.""" + return MISSPELLINGS.get(word.lower(), word) -def generate_text(prompt: str, model: str = "gpt-3.5-turbo") -> str: +def correct_sentence(sentence: str) -> str: """ - Generate a completion for the given prompt using the specified model. - - Parameters - ---------- - prompt : str - The prompt to send to the model. - model : str, optional - The OpenAI model to use. Defaults to "gpt-3.5-turbo". - - Returns - ------- - str - The model's raw completion text. + Correct a sentence by: + 1. Removing leading/trailing whitespace. + 2. Collapsing multiple spaces into one. + 3. Correcting known misspellings. + 4. Ensuring the sentence ends with a period. """ - openai.api_key = os.getenv("OPENAI_API_KEY") - if not openai.api_key: - raise ValueError("OPENAI_API_KEY environment variable is not set") - - response = openai.ChatCompletion.create( - model=model, - messages=[{"role": "user", "content": prompt}], - temperature=0.7, - max_tokens=150, - ) - return response.choices[0].message.content.strip() - - -def correct_text(text: str) -> str: - """ - Apply a very simple self‑correction rule: if the text ends with a - period, remove it; otherwise, add a period. - - This is just a placeholder to illustrate the concept of a - self‑correcting agent. - - Parameters - ---------- - text : str - The text to correct. - - Returns - ------- - str - The corrected text. - """ - if text.endswith("."): - return text[:-1] - return text + "." - + # Strip whitespace + sentence = sentence.strip() + # Collapse multiple spaces + sentence = re.sub(r"\s+", " ", sentence) + # Tokenise and correct words + words = sentence.split(" ") + corrected_words: List[str] = [correct_spelling(w) for w in words] + corrected = " ".join(corrected_words) + # Ensure ending punctuation + if not corrected.endswith((".", "!", "?")): + corrected += "." + return corrected def main() -> None: - """ - Demo entry point: generate a response to a hard‑coded prompt, - correct it, and print both versions. - """ - prompt = ( - "Explain the concept of a self‑correcting agent in simple terms." - ) - try: - raw = generate_text(prompt) - except Exception as exc: - print(f"Error generating text: {exc}", file=sys.stderr) + if len(sys.argv) < 2: + print("Usage: python -m src.index \"\"") sys.exit(1) - corrected = correct_text(raw) - - print("=== Raw output ===") - print(raw) - print("\n=== Corrected output ===") + input_sentence = " ".join(sys.argv[1:]) + corrected = correct_sentence(input_sentence) print(corrected) - if __name__ == "__main__": main() \ No newline at end of file