Finish tasks migration

Author: vtm9

.gitignore

@@ -3,5 +3,4 @@
 release/
 release.tar.gz
 release-v*.tar.gz
-.clj-kondo
 .lsp

Makefile

@@ -4,12 +4,37 @@ preview:
 	@pnpm --dir preview install --silent
 	@cd preview && pnpm dev
 
-build:
+build-private:
+	@$(PYTHON) test_solutions.py private
+
+check-names:
+	@$(PYTHON) check_task_names.py
+
+build: check-names
 	@$(PYTHON) test_solutions.py tasks
 
 build-and-preview: build preview
 
 release: build
 	tar -czf release.tar.gz release/
 
-.PHONY: release preview build build-and-preview
+
+push-local:
+	@$(PYTHON) push_tasks.py http://localhost:4000/ext_api/tasks --hidden
+
+push-private:
+	@$(PYTHON) push_tasks.py https://codebattle.hexlet.io/ext_api/tasks --hidden
+
+push-public:
+	@$(PYTHON) push_tasks.py https://codebattle.hexlet.io/ext_api/tasks --public
+
+push-packs-local:
+	@$(PYTHON) push_task_packs.py http://localhost:4000/ext_api/task_packs --hidden
+
+push-packs-private:
+	@$(PYTHON) push_task_packs.py https://codebattle.hexlet.io/ext_api/task_packs --hidden
+
+push-packs-public:
+	@$(PYTHON) push_task_packs.py https://codebattle.hexlet.io/ext_api/task_packs --public
+
+.PHONY: release preview build build-and-preview check-names push push-private push-public push-local push-packs-local push-packs-private push-packs-public

ai/project_structure.md

@@ -0,0 +1,5 @@
+1. all tasks lives in tasks
+2. there are 4 levels of tasks: elementary, easy, medium, hard
+3. each task has a unique name
+4. each task has a set of tags which is a list of strings
+5. task path should be always as /tasks/<level>/<tags[0]>/<name>.toml

ai/example.toml ai/task_example.tomlai/example.toml renamed to ai/task_example.toml

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+"""
+Check uniqueness of task names across tasks/ and private/ directories.
+Task names are checked case-insensitively to prevent confusion.
+"""
+
+import os
+import sys
+from collections import defaultdict
+from typing import Dict, List, Tuple
+
+import tomli
+from termcolor import colored
+
+
+def find_toml_files(directory: str) -> List[str]:
+    """
+    Recursively find all .toml files in directory.
+    Returns list of absolute paths.
+    Returns empty list if directory doesn't exist.
+    """
+    if not os.path.exists(directory):
+        return []
+
+    toml_files = []
+    for root, _, files in os.walk(directory):
+        for file in files:
+            if file.endswith(".toml"):
+                toml_files.append(os.path.join(root, file))
+
+    return toml_files
+
+
+def extract_task_names(toml_files: List[str], base_dir: str) -> Dict[str, List[str]]:
+    """
+    Extract task names from TOML files.
+    Returns mapping of lowercase_name -> [file_paths]
+    Raises ValueError if any file is missing 'name' field.
+    """
+    name_to_files = defaultdict(list)
+
+    for toml_path in toml_files:
+        rel_path = os.path.relpath(toml_path, base_dir)
+
+        # Parse TOML file
+        try:
+            with open(toml_path, "rb") as f:
+                data = tomli.load(f)
+        except Exception as e:
+            print(colored(f"ERROR: Failed to parse '{rel_path}': {str(e)}", "red"))
+            sys.exit(1)
+
+        # Extract name field
+        name = data.get("name")
+        if not name:
+            print(
+                colored(
+                    f"ERROR: File '{rel_path}' is missing required 'name' field", "red"
+                )
+            )
+            sys.exit(1)
+
+        # Store with lowercase key for case-insensitive comparison
+        lowercase_name = name.lower()
+        name_to_files[lowercase_name].append(toml_path)
+
+    return dict(name_to_files)
+
+
+def check_uniqueness(
+    name_to_files: Dict[str, List[str]], base_dir: str
+) -> Tuple[bool, int, int]:
+    """
+    Check for duplicate task names and print report.
+    Returns (is_unique, total_files, duplicate_count)
+    """
+    total_files = sum(len(files) for files in name_to_files.values())
+
+    print(colored("Checking task names for uniqueness...", "cyan"))
+    print(
+        f"Found {colored(str(total_files), 'cyan')} task files across tasks/ and private/\n"
+    )
+
+    # Find duplicates (names appearing in more than one file)
+    duplicates = {
+        name: files for name, files in name_to_files.items() if len(files) > 1
+    }
+
+    if not duplicates:
+        print(colored("✅ All task names are unique!", "green", attrs=["bold"]))
+        return (True, total_files, 0)
+
+    # Report duplicates
+    print(colored("❌ DUPLICATE TASK NAMES FOUND:", "red", attrs=["bold"]))
+    print()
+
+    for name, files in sorted(duplicates.items()):
+        print(colored(f"Task name: '{name}' appears in {len(files)} files:", "yellow"))
+        for file_path in files:
+            rel_path = os.path.relpath(file_path, base_dir)
+            print(f"  - {rel_path}")
+        print()
+
+    # Print summary
+    duplicate_file_count = sum(len(files) for files in duplicates.values())
+    print(colored("═" * 70, "blue"))
+    print(
+        colored(
+            f"Summary: Found {len(duplicates)} duplicate task name(s) across {duplicate_file_count} files",
+            "red",
+            attrs=["bold"],
+        )
+    )
+
+    return (False, total_files, len(duplicates))
+
+
+def main():
+    """Main entry point."""
+    # Get base directory (project root)
+    base_dir = os.path.dirname(os.path.abspath(__file__))
+
+    # Define paths to check
+    tasks_dir = os.path.join(base_dir, "tasks")
+    private_dir = os.path.join(base_dir, "private")
+
+    # Find all TOML files
+    toml_files = []
+    toml_files.extend(find_toml_files(tasks_dir))
+    toml_files.extend(find_toml_files(private_dir))
+
+    if not toml_files:
+        print(colored("WARNING: No TOML files found in tasks/ or private/", "yellow"))
+        sys.exit(0)
+
+    # Extract task names (case-insensitive)
+    try:
+        name_to_files = extract_task_names(toml_files, base_dir)
+    except Exception as e:
+        print(colored(f"ERROR: {str(e)}", "red"))
+        sys.exit(1)
+
+    # Check for duplicates
+    is_unique, total_files, duplicate_count = check_uniqueness(name_to_files, base_dir)
+
+    # Exit with appropriate code
+    sys.exit(0 if is_unique else 1)
+
+
+if __name__ == "__main__":
+    main()

ai/Task structure.md ai/task_structure.mdai/Task structure.md renamed to ai/task_structure.md

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""
+Script to publish task pack JSON files to a remote URL.
+"""
+
+import argparse
+import json
+import os
+import sys
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import List
+
+
+def read_json_files(directory: str) -> List[tuple]:
+    """
+    Read all JSON files from the specified directory.
+
+    Returns:
+        List of tuples (filename, json_data)
+    """
+    json_files = []
+    task_packs_path = Path(directory)
+
+    if not task_packs_path.exists():
+        print(f"Error: Directory '{directory}' does not exist", file=sys.stderr)
+        sys.exit(1)
+
+    for json_file in task_packs_path.glob("*.json"):
+        try:
+            with open(json_file, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                json_files.append((json_file.name, data))
+                print(f"Read: {json_file.name}")
+        except json.JSONDecodeError as e:
+            print(f"Error reading {json_file.name}: {e}", file=sys.stderr)
+        except Exception as e:
+            print(f"Error processing {json_file.name}: {e}", file=sys.stderr)
+
+    return json_files
+
+
+def publish_task_pack(
+    url: str, pack_data: dict, visibility: str, origin: str, auth_token: str
+) -> bool:
+    """
+    Publish a single task pack to the remote URL.
+
+    Args:
+        url: The target URL
+        pack_data: The JSON data to publish
+        visibility: Visibility setting ('public' or 'hidden')
+        origin: Origin of the task packs
+        auth_token: Authorization token from environment
+
+    Returns:
+        True if successful, False otherwise
+    """
+    # Prepare the payload
+    payload = {"task_pack": pack_data, "visibility": visibility, "origin": origin}
+
+    # Prepare headers
+    headers = {
+        "Content-Type": "application/json",
+    }
+
+    if auth_token:
+        headers["X-AUTH-KEY"] = auth_token
+
+    # Convert payload to JSON bytes
+    data = json.dumps(payload).encode("utf-8")
+
+    # Create request
+    req = urllib.request.Request(url, data=data, headers=headers, method="POST")
+
+    try:
+        with urllib.request.urlopen(req) as response:
+            status = response.status
+            response_body = response.read().decode("utf-8")
+            if status in (200, 201):
+                return True
+            else:
+                print(f"  Warning: Received status {status}", file=sys.stderr)
+                print(f"  Response: {response_body}", file=sys.stderr)
+                return False
+    except urllib.error.HTTPError as e:
+        error_body = e.read().decode("utf-8") if e.fp else ""
+        print(f"  HTTP Error {e.code}: {e.reason}", file=sys.stderr)
+        if error_body:
+            print(f"  Response: {error_body}", file=sys.stderr)
+        return False
+    except urllib.error.URLError as e:
+        print(f"  URL Error: {e.reason}", file=sys.stderr)
+        return False
+    except Exception as e:
+        print(f"  Error: {e}", file=sys.stderr)
+        return False
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Publish task pack JSON files to a remote URL"
+    )
+    parser.add_argument("url", help="Target URL to publish task packs to")
+    parser.add_argument(
+        "--public",
+        action="store_true",
+        help="Set visibility to public (default: hidden)",
+    )
+    parser.add_argument(
+        "--hidden", action="store_true", help="Set visibility to hidden (default)"
+    )
+    parser.add_argument(
+        "--origin",
+        default="github",
+        help="Origin of the task packs (default: github)",
+    )
+    parser.add_argument(
+        "--dir",
+        default="task_packs",
+        help="Directory containing JSON files (default: task_packs)",
+    )
+
+    args = parser.parse_args()
+
+    # Determine visibility
+    if args.public and args.hidden:
+        print("Error: Cannot specify both --public and --hidden", file=sys.stderr)
+        sys.exit(1)
+
+    visibility = "public" if args.public else "hidden"
+
+    # Get auth token from environment
+    auth_token = os.environ.get("CODEBATTLE_AUTH_TOKEN", "")
+    if not auth_token:
+        print(
+            "Warning: CODEBATTLE_AUTH_TOKEN environment variable not set",
+            file=sys.stderr,
+        )
+
+    # Read JSON files
+    print(f"Reading JSON files from '{args.dir}/'...")
+    json_files = read_json_files(args.dir)
+
+    if not json_files:
+        print("No JSON files found to publish", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"\nPublishing {len(json_files)} task packs to {args.url}...")
+    print(f"Visibility: {visibility}")
+    print(f"Origin: {args.origin}")
+    print()
+
+    # Publish each task pack
+    success_count = 0
+    fail_count = 0
+
+    for filename, pack_data in json_files:
+        print(f"Publishing: {filename}... ", end="", flush=True)
+        if publish_task_pack(args.url, pack_data, visibility, args.origin, auth_token):
+            print("✓")
+            success_count += 1
+        else:
+            print("✗")
+            fail_count += 1
+
+    # Summary
+    print()
+    print(f"Summary: {success_count} successful, {fail_count} failed")
+
+    if fail_count > 0:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()