zeroed-some/bashamole / 9c38f5f

+# Python

+backend/venv/

+backend/.molenv/*

+backend/env/

+backend/*.pyc

+backend/__pycache__/

+backend/**/__pycache__/

+backend/db.sqlite3

+backend/.env

+backend/*.log

+backend/.coverage

+backend/htmlcov/

+backend/media/

+backend/staticfiles/

+

+# Node

+frontend/node_modules/

+frontend/.next/

+frontend/out/

+frontend/dist/

+frontend/build/

+frontend/.env.local

+frontend/.env.*.local

+frontend/npm-debug.log*

+frontend/yarn-debug.log*

+frontend/yarn-error.log*

+

+# IDE

+.vscode/

+.idea/

+*.swp

+*.swo

+*~

+

+# OS

+.DS_Store

+Thumbs.db

+

+# Shared

+shared/node_modules/

+shared/dist/

+

+# Logs

+*.log

+logs/

+

+# Testing

+coverage/

+.nyc_output/

+*.coverage

+.pytest_cache/

+nodejs 23.11.0

+# backend/.env.example

+DEBUG=True

+SECRET_KEY=your-secret-key-here

+ALLOWED_HOSTS=localhost,127.0.0.1

+

+# Database (for production)

+# DATABASE_URL=postgresql://user:password@localhost/bashamole

+

+# CORS

+CORS_ALLOWED_ORIGINS=http://localhost:3000,http://localhost:5173

+

+# API Settings

+API_PAGE_SIZE=100

+# apps/trees/admin.py

+from django.contrib import admin

+from .models import FileSystemTree, DirectoryNode, GameSession

+

+

+class DirectoryNodeInline(admin.TabularInline):

+    model = DirectoryNode

+    extra = 0

+    fields = ['name', 'path', 'is_fhs_standard', 'parent']

+    readonly_fields = ['path']

+    

+    def has_add_permission(self, request, obj=None):

+        return False

+

+

+@admin.register(FileSystemTree)

+class FileSystemTreeAdmin(admin.ModelAdmin):

+    list_display = ['name', 'created_at', 'is_completed', 'mole_location', 'player_location']

+    list_filter = ['is_completed', 'created_at']

+    readonly_fields = ['created_at', 'completed_at', 'tree_data', 'seed']

+    

+    fieldsets = (

+        ('Basic Info', {

+            'fields': ('name', 'seed', 'created_at')

+        }),

+        ('Game State', {

+            'fields': ('player_location', 'mole_location', 'is_completed', 'completed_at')

+        }),

+        ('Tree Data', {

+            'fields': ('tree_data',),

+            'classes': ('collapse',)

+        })

+    )

+    

+    actions = ['regenerate_trees']

+    

+    def regenerate_trees(self, request, queryset):

+        for tree in queryset:

+            tree.generate_tree()

+        self.message_user(request, f"Regenerated {queryset.count()} trees")

+    regenerate_trees.short_description = "Regenerate selected trees"

+

+

+@admin.register(DirectoryNode)

+class DirectoryNodeAdmin(admin.ModelAdmin):

+    list_display = ['path', 'name', 'tree', 'is_fhs_standard', 'parent']

+    list_filter = ['is_fhs_standard', 'tree']

+    search_fields = ['path', 'name']

+    raw_id_fields = ['tree', 'parent']

+    

+    def get_queryset(self, request):

+        return super().get_queryset(request).select_related('tree', 'parent')

+

+

+@admin.register(GameSession)

+class GameSessionAdmin(admin.ModelAdmin):

+    list_display = ['player_name', 'tree', 'started_at', 'completed_at', 'commands_used', 'time_taken']

+    list_filter = ['completed_at', 'started_at']

+    readonly_fields = ['started_at', 'completed_at', 'time_taken', 'command_history']

+    

+    fieldsets = (

+        ('Player Info', {

+            'fields': ('player_name', 'tree')

+        }),

+        ('Game Stats', {

+            'fields': ('started_at', 'completed_at', 'time_taken', 'commands_used', 'directories_visited')

+        }),

+        ('Command History', {

+            'fields': ('command_history',),

+            'classes': ('collapse',)

+        })

+    )

+from django.apps import AppConfig

+

+

+class TreesConfig(AppConfig):

+    default_auto_field = "django.db.models.BigAutoField"

+    name = "apps.trees"

+# apps/trees/management/commands/populate_trees.py

+from django.core.management.base import BaseCommand

+from apps.trees.models import FileSystemTree

+

+

+class Command(BaseCommand):

+    help = 'Create sample filesystem trees for testing'

+    

+    def add_arguments(self, parser):

+        parser.add_argument(

+            '--count',

+            type=int,

+            default=3,

+            help='Number of trees to create'

+        )

+    

+    def handle(self, *args, **options):

+        count = options['count']

+        

+        self.stdout.write('Creating sample filesystem trees...')

+        

+        difficulties = [

+            {'name': 'Beginner Tree', 'max_depth': 3, 'dirs_per_level': 2},

+            {'name': 'Intermediate Tree', 'max_depth': 4, 'dirs_per_level': 3},

+            {'name': 'Advanced Tree', 'max_depth': 5, 'dirs_per_level': 4},

+            {'name': 'Expert Tree', 'max_depth': 6, 'dirs_per_level': 5},

+        ]

+        

+        created_count = 0

+        for i in range(count):

+            difficulty = difficulties[i % len(difficulties)]

+            

+            tree = FileSystemTree.objects.create(

+                name=f"{difficulty['name']} #{i+1}"

+            )

+            tree.generate_tree(

+                max_depth=difficulty['max_depth'],

+                directories_per_level=difficulty['dirs_per_level']

+            )

+            

+            created_count += 1

+            self.stdout.write(

+                self.style.SUCCESS(

+                    f"Created tree: {tree.name} with {tree.nodes.count()} directories"

+                )

+            )

+            self.stdout.write(f"  Mole hidden at: {tree.mole_location}")

+        

+        self.stdout.write(

+            self.style.SUCCESS(f'Successfully created {created_count} filesystem trees')

+        )

+# Generated by Django 5.2.3 on 2025-06-14 18:26

+

+import django.db.models.deletion

+from django.db import migrations, models

+

+

+class Migration(migrations.Migration):

+

+    initial = True

+

+    dependencies = []

+

+    operations = [

+        migrations.CreateModel(

+            name="FileSystemTree",

+            fields=[

+                (

+                    "id",

+                    models.BigAutoField(

+                        auto_created=True,

+                        primary_key=True,

+                        serialize=False,

+                        verbose_name="ID",

+                    ),

+                ),

+                ("name", models.CharField(default="FHS Tree", max_length=100)),

+                ("created_at", models.DateTimeField(auto_now_add=True)),

+                ("seed", models.IntegerField(default=0)),

+                ("mole_location", models.CharField(blank=True, max_length=500)),

+                ("player_location", models.CharField(default="/home", max_length=500)),

+                ("is_completed", models.BooleanField(default=False)),

+                ("completed_at", models.DateTimeField(blank=True, null=True)),

+                ("tree_data", models.JSONField(blank=True, null=True)),

+            ],

+        ),

+        migrations.CreateModel(

+            name="GameSession",

+            fields=[

+                (

+                    "id",

+                    models.BigAutoField(

+                        auto_created=True,

+                        primary_key=True,

+                        serialize=False,

+                        verbose_name="ID",

+                    ),

+                ),

+                ("player_name", models.CharField(default="Anonymous", max_length=100)),

+                ("started_at", models.DateTimeField(auto_now_add=True)),

+                ("completed_at", models.DateTimeField(blank=True, null=True)),

+                ("commands_used", models.IntegerField(default=0)),

+                ("directories_visited", models.IntegerField(default=0)),

+                ("time_taken", models.DurationField(blank=True, null=True)),

+                ("command_history", models.JSONField(default=list)),

+                (

+                    "tree",

+                    models.ForeignKey(

+                        on_delete=django.db.models.deletion.CASCADE,

+                        related_name="sessions",

+                        to="trees.filesystemtree",

+                    ),

+                ),

+            ],

+        ),

+        migrations.CreateModel(

+            name="DirectoryNode",

+            fields=[

+                (

+                    "id",

+                    models.BigAutoField(

+                        auto_created=True,

+                        primary_key=True,

+                        serialize=False,

+                        verbose_name="ID",

+                    ),

+                ),

+                ("name", models.CharField(max_length=100)),

+                ("path", models.CharField(db_index=True, max_length=500)),

+                ("is_fhs_standard", models.BooleanField(default=False)),

+                ("description", models.TextField(blank=True)),

+                (

+                    "parent",

+                    models.ForeignKey(

+                        blank=True,

+                        null=True,

+                        on_delete=django.db.models.deletion.CASCADE,

+                        related_name="children",

+                        to="trees.directorynode",

+                    ),

+                ),

+                (

+                    "tree",

+                    models.ForeignKey(

+                        on_delete=django.db.models.deletion.CASCADE,

+                        related_name="nodes",

+                        to="trees.filesystemtree",

+                    ),

+                ),

+            ],

+            options={

+                "ordering": ["path"],

+                "unique_together": {("tree", "path")},

+            },

+        ),

+    ]

+# apps/trees/models.py

+from django.db import models

+from django.utils import timezone

+import json

+import random

+import string

+

+class FileSystemTree(models.Model):

+    """A complete filesystem tree for a game session"""

+    name = models.CharField(max_length=100, default="FHS Tree")

+    created_at = models.DateTimeField(auto_now_add=True)

+    seed = models.IntegerField(default=0)

+    

+    # Game state

+    mole_location = models.CharField(max_length=500, blank=True)  # Path to mole

+    player_location = models.CharField(max_length=500, default="/home")

+    is_completed = models.BooleanField(default=False)

+    completed_at = models.DateTimeField(null=True, blank=True)

+    

+    # Cached tree structure

+    tree_data = models.JSONField(null=True, blank=True)

+    

+    def __str__(self):

+        return f"{self.name} - {'Completed' if self.is_completed else 'Active'}"

+    

+    def generate_tree(self, max_depth=5, directories_per_level=3):

+        """Generate a procedural Unix filesystem tree"""

+        if self.seed == 0:

+            self.seed = random.randint(1, 1000000)

+        

+        random.seed(self.seed)

+        

+        # Clear existing nodes

+        self.nodes.all().delete()

+        

+        # Create root

+        root = DirectoryNode.objects.create(

+            tree=self,

+            name="",

+            path="/",

+            parent=None,

+            is_fhs_standard=True,

+            description="Root directory"

+        )

+        

+        # Create standard FHS directories

+        self._create_fhs_structure(root)

+        

+        # Add procedural directories to some locations

+        self._add_procedural_directories(max_depth, directories_per_level)

+        

+        # Place the mole in a random directory (not in standard FHS locations)

+        self._place_mole()

+        

+        # Cache the tree structure

+        self.cache_tree()

+        self.save()

+    

+    def _create_fhs_structure(self, root):

+        """Create standard FHS directory structure"""

+        fhs_dirs = [

+            {"name": "bin", "desc": "Essential command binaries"},

+            {"name": "boot", "desc": "Static files of the boot loader"},

+            {"name": "dev", "desc": "Device files"},

+            {"name": "etc", "desc": "Host-specific system configuration"},

+            {"name": "home", "desc": "User home directories"},

+            {"name": "lib", "desc": "Essential shared libraries and kernel modules"},

+            {"name": "media", "desc": "Mount points for removable media"},

+            {"name": "mnt", "desc": "Mount point for temporarily mounted filesystems"},

+            {"name": "opt", "desc": "Add-on application software packages"},

+            {"name": "proc", "desc": "Virtual filesystem for process information"},

+            {"name": "root", "desc": "Home directory for the root user"},

+            {"name": "run", "desc": "Data relevant to running processes"},

+            {"name": "sbin", "desc": "Essential system binaries"},

+            {"name": "srv", "desc": "Data for services provided by this system"},

+            {"name": "sys", "desc": "Virtual filesystem for system information"},

+            {"name": "tmp", "desc": "Temporary files"},

+            {"name": "usr", "desc": "Secondary hierarchy"},

+            {"name": "var", "desc": "Variable data"},

+        ]

+        

+        for dir_info in fhs_dirs:

+            DirectoryNode.objects.create(

+                tree=self,

+                name=dir_info["name"],

+                path=f"/{dir_info['name']}",

+                parent=root,

+                is_fhs_standard=True,

+                description=dir_info["desc"]

+            )

+        

+        # Create some standard subdirectories

+        usr = DirectoryNode.objects.get(tree=self, path="/usr")

+        for subdir in ["bin", "lib", "local", "share", "src"]:

+            DirectoryNode.objects.create(

+                tree=self,

+                name=subdir,

+                path=f"/usr/{subdir}",

+                parent=usr,

+                is_fhs_standard=True,

+                description=f"User {subdir} directory"

+            )

+        

+        # Create user directories

+        home = DirectoryNode.objects.get(tree=self, path="/home")

+        for username in ["alice", "bob", "charlie"]:

+            user_home = DirectoryNode.objects.create(

+                tree=self,

+                name=username,

+                path=f"/home/{username}",

+                parent=home,

+                is_fhs_standard=False,

+                description=f"Home directory for {username}"

+            )

+            

+            # Add some standard user directories

+            for userdir in ["Documents", "Downloads", "Desktop", "Pictures"]:

+                DirectoryNode.objects.create(

+                    tree=self,

+                    name=userdir,

+                    path=f"/home/{username}/{userdir}",

+                    parent=user_home,

+                    is_fhs_standard=False,

+                    description=f"{username}'s {userdir}"

+                )

+    

+    def _add_procedural_directories(self, max_depth, dirs_per_level):

+        """Add procedurally generated directories to make the tree interesting"""

+        # Common directory names for procedural generation

+        dir_names = [

+            "projects", "workspace", "temp", "backup", "archive", "data",

+            "config", "logs", "cache", "build", "dist", "assets",

+            "scripts", "tools", "utils", "resources", "public", "private",

+            "old", "new", "test", "prod", "dev", "staging",

+            "alpha", "beta", "gamma", "delta", "epsilon", "zeta",

+            "red", "blue", "green", "yellow", "purple", "orange",

+            "cat", "dog", "fish", "bird", "mouse", "rabbit"

+        ]

+        

+        # Add procedural dirs to certain locations

+        base_paths = [

+            "/home/alice", "/home/bob", "/home/charlie",

+            "/opt", "/var", "/usr/local"

+        ]

+        

+        for base_path in base_paths:

+            try:

+                base_node = DirectoryNode.objects.get(tree=self, path=base_path)

+                self._generate_subtree(base_node, max_depth-2, dirs_per_level, dir_names)

+            except DirectoryNode.DoesNotExist:

+                continue

+    

+    def _generate_subtree(self, parent, depth, dirs_per_level, name_pool):

+        """Recursively generate random subdirectories"""

+        if depth <= 0:

+            return

+        

+        # Random number of directories at this level

+        num_dirs = random.randint(1, dirs_per_level)

+        used_names = set()

+        

+        for _ in range(num_dirs):

+            # Pick a unique name for this level

+            name = random.choice(name_pool)

+            while name in used_names:

+                name = random.choice(name_pool)

+            used_names.add(name)

+            

+            # Create the directory

+            path = f"{parent.path}/{name}" if parent.path != "/" else f"/{name}"

+            new_dir = DirectoryNode.objects.create(

+                tree=self,

+                name=name,

+                path=path,

+                parent=parent,

+                is_fhs_standard=False,

+                description=f"Procedurally generated directory"

+            )

+            

+            # Randomly decide whether to create subdirectories

+            if random.random() > 0.3:  # 70% chance of subdirectories

+                self._generate_subtree(new_dir, depth-1, dirs_per_level, name_pool)

+    

+    def _place_mole(self):

+        """Place the mole in a random non-FHS directory"""

+        candidates = DirectoryNode.objects.filter(

+            tree=self,

+            is_fhs_standard=False

+        ).exclude(path__in=[

+            "/home", "/home/alice", "/home/bob", "/home/charlie"

+        ])

+        

+        if candidates.exists():

+            mole_dir = random.choice(candidates)

+            self.mole_location = mole_dir.path

+    

+    def cache_tree(self):

+        """Cache the tree structure for efficient retrieval"""

+        def build_tree_dict(node):

+            children = DirectoryNode.objects.filter(parent=node)

+            return {

+                "name": node.name,

+                "path": node.path,

+                "is_fhs": node.is_fhs_standard,

+                "description": node.description,

+                "has_mole": node.path == self.mole_location,

+                "children": [build_tree_dict(child) for child in children]

+            }

+        

+        root = DirectoryNode.objects.get(tree=self, path="/")

+        self.tree_data = build_tree_dict(root)

+    

+    def move_player(self, target_path):

+        """Move player to a new location if valid"""

+        # Normalize path

+        if not target_path.startswith('/'):

+            # Relative path

+            if target_path == "..":

+                # Go up one directory

+                if self.player_location == "/":

+                    return False, "Already at root directory"

+                self.player_location = "/".join(self.player_location.split("/")[:-1]) or "/"

+            else:

+                # Go to subdirectory

+                new_path = f"{self.player_location}/{target_path}" if self.player_location != "/" else f"/{target_path}"

+                if DirectoryNode.objects.filter(tree=self, path=new_path).exists():

+                    self.player_location = new_path

+                else:

+                    return False, f"Directory not found: {target_path}"

+        else:

+            # Absolute path

+            if DirectoryNode.objects.filter(tree=self, path=target_path).exists():

+                self.player_location = target_path

+            else:

+                return False, f"Directory not found: {target_path}"

+        

+        self.save()

+        return True, f"Moved to {self.player_location}"

+    

+    def check_win_condition(self):

+        """Check if player is in the same directory as the mole"""

+        return self.player_location == self.mole_location

+

+

+class DirectoryNode(models.Model):

+    """A directory in the filesystem tree"""

+    tree = models.ForeignKey(FileSystemTree, on_delete=models.CASCADE, related_name='nodes')

+    parent = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE, related_name='children')

+    

+    name = models.CharField(max_length=100)

+    path = models.CharField(max_length=500, db_index=True)

+    is_fhs_standard = models.BooleanField(default=False)

+    description = models.TextField(blank=True)

+    

+    class Meta:

+        unique_together = ('tree', 'path')

+        ordering = ['path']

+    

+    def __str__(self):

+        return f"{self.path} ({'FHS' if self.is_fhs_standard else 'Generated'})"

+    

+    @property

+    def depth(self):

+        """Calculate directory depth"""

+        return self.path.count('/')

+    

+    def get_contents(self):

+        """Get immediate children of this directory"""

+        return DirectoryNode.objects.filter(parent=self).order_by('name')

+

+

+class GameSession(models.Model):

+    """Track game sessions and scores"""

+    tree = models.ForeignKey(FileSystemTree, on_delete=models.CASCADE, related_name='sessions')

+    player_name = models.CharField(max_length=100, default="Anonymous")

+    started_at = models.DateTimeField(auto_now_add=True)

+    completed_at = models.DateTimeField(null=True, blank=True)

+    

+    # Game metrics

+    commands_used = models.IntegerField(default=0)

+    directories_visited = models.IntegerField(default=0)

+    time_taken = models.DurationField(null=True, blank=True)

+    

+    # Command history

+    command_history = models.JSONField(default=list)

+    

+    def __str__(self):

+        return f"{self.player_name} - {self.tree.name}"

+    

+    def add_command(self, command):

+        """Add a command to the history"""

+        self.command_history.append({

+            'command': command,

+            'timestamp': str(timezone.now())

+        })

+        self.commands_used += 1

+        self.save()

+# apps/trees/serializers.py

+from rest_framework import serializers

+from .models import FileSystemTree, DirectoryNode, GameSession

+

+

+class DirectoryNodeSerializer(serializers.ModelSerializer):

+    class Meta:

+        model = DirectoryNode

+        fields = ['id', 'name', 'path', 'is_fhs_standard', 'description', 'depth']

+        read_only_fields = ['depth']

+

+

+class FileSystemTreeSerializer(serializers.ModelSerializer):

+    total_directories = serializers.SerializerMethodField()

+    

+    class Meta:

+        model = FileSystemTree

+        fields = [

+            'id', 'name', 'created_at', 'seed', 

+            'player_location', 'is_completed', 'completed_at',

+            'tree_data', 'total_directories'

+        ]

+        read_only_fields = ['created_at', 'tree_data', 'total_directories']

+    

+    def get_total_directories(self, obj):

+        return obj.nodes.count()

+

+

+class GameSessionSerializer(serializers.ModelSerializer):

+    tree_name = serializers.CharField(source='tree.name', read_only=True)

+    

+    class Meta:

+        model = GameSession

+        fields = [

+            'id', 'tree', 'tree_name', 'player_name',

+            'started_at', 'completed_at', 'commands_used',

+            'directories_visited', 'time_taken', 'command_history'

+        ]

+        read_only_fields = [

+            'started_at', 'completed_at', 'time_taken', 'command_history'

+        ]

+

+

+class GameCommandSerializer(serializers.Serializer):

+    """Serializer for game commands"""

+    command = serializers.CharField(max_length=200)

+    session_id = serializers.IntegerField(required=False)

+from django.test import TestCase

+

+# Create your tests here.

+# apps/trees/urls.py

+from django.urls import path, include

+from rest_framework.routers import DefaultRouter

+from . import views

+

+router = DefaultRouter()

+router.register(r'filesystem-trees', views.FileSystemTreeViewSet)

+router.register(r'directories', views.DirectoryNodeViewSet)

+router.register(r'game-sessions', views.GameSessionViewSet)

+

+urlpatterns = [

+    path('', include(router.urls)),

+]

+# apps/trees/views.py

+from django.http import HttpResponse

+from rest_framework import viewsets, status

+from rest_framework.decorators import action

+from rest_framework.response import Response

+from django.utils import timezone

+from datetime import timedelta

+from .models import FileSystemTree, DirectoryNode, GameSession

+from .serializers import (

+    FileSystemTreeSerializer, DirectoryNodeSerializer, 

+    GameSessionSerializer, GameCommandSerializer

+)

+

+

+class FileSystemTreeViewSet(viewsets.ModelViewSet):

+    """ViewSet for filesystem trees"""

+    queryset = FileSystemTree.objects.all()

+    serializer_class = FileSystemTreeSerializer

+    

+    @action(detail=False, methods=['post'])

+    def create_game(self, request):

+        """Create a new game with a generated filesystem tree"""

+        tree_name = request.data.get('name', 'FHS Game Tree')

+        max_depth = request.data.get('max_depth', 5)

+        dirs_per_level = request.data.get('dirs_per_level', 3)

+        

+        # Create and generate tree

+        tree = FileSystemTree.objects.create(name=tree_name)

+        tree.generate_tree(max_depth=max_depth, directories_per_level=dirs_per_level)

+        

+        # Create game session

+        player_name = request.data.get('player_name', 'Anonymous')

+        session = GameSession.objects.create(

+            tree=tree,

+            player_name=player_name

+        )

+        

+        serializer = self.get_serializer(tree)

+        return Response({

+            'tree': serializer.data,

+            'session_id': session.id,

+            'mole_hint': f"The mole is hiding somewhere in the filesystem!"

+        }, status=status.HTTP_201_CREATED)

+    

+    @action(detail=True, methods=['get'])

+    def current_directory(self, request, pk=None):

+        """Get current directory contents and player location"""

+        tree = self.get_object()

+        

+        try:

+            current_dir = DirectoryNode.objects.get(

+                tree=tree, 

+                path=tree.player_location

+            )

+            contents = current_dir.get_contents()

+            

+            return Response({

+                'path': tree.player_location,

+                'contents': DirectoryNodeSerializer(contents, many=True).data,

+                'parent': current_dir.parent.path if current_dir.parent else None

+            })

+        except DirectoryNode.DoesNotExist:

+            return Response(

+                {'error': 'Current directory not found'}, 

+                status=status.HTTP_404_NOT_FOUND

+            )

+    

+    @action(detail=True, methods=['post'])

+    def execute_command(self, request, pk=None):

+        """Execute a shell command in the game"""

+        tree = self.get_object()

+        command = request.data.get('command', '').strip()

+        session_id = request.data.get('session_id')

+        

+        if not command:

+            return Response(

+                {'error': 'No command provided'}, 

+                status=status.HTTP_400_BAD_REQUEST

+            )

+        

+        # Get session if provided

+        session = None

+        if session_id:

+            try:

+                session = GameSession.objects.get(id=session_id, tree=tree)

+                session.add_command(command)

+            except GameSession.DoesNotExist:

+                pass

+        

+        # Parse and execute command

+        parts = command.split()

+        cmd = parts[0] if parts else ""

+        

+        response_data = {

+            'command': command,

+            'success': False,

+            'output': '',

+            'current_path': tree.player_location

+        }

+        

+        if cmd == 'cd':

+            if len(parts) < 2:

+                response_data['output'] = "cd: missing operand"

+            else:

+                target = parts[1]

+                success, message = tree.move_player(target)

+                response_data['success'] = success

+                response_data['output'] = message

+                response_data['current_path'] = tree.player_location

+                

+                if success and session:

+                    session.directories_visited += 1

+                    session.save()

+        

+        elif cmd == 'ls':

+            try:

+                current_dir = DirectoryNode.objects.get(

+                    tree=tree, 

+                    path=tree.player_location

+                )

+                contents = current_dir.get_contents()

+                if contents:

+                    response_data['output'] = '\n'.join([d.name for d in contents])

+                else:

+                    response_data['output'] = ''

+                response_data['success'] = True

+            except DirectoryNode.DoesNotExist:

+                response_data['output'] = "ls: cannot access directory"

+        

+        elif cmd == 'pwd':

+            response_data['output'] = tree.player_location

+            response_data['success'] = True

+        

+        elif cmd == 'killall' and len(parts) > 1 and parts[1] == 'moles':

+            if tree.check_win_condition():

+                tree.is_completed = True

+                tree.completed_at = timezone.now()

+                tree.save()

+                

+                if session:

+                    session.completed_at = timezone.now()

+                    session.time_taken = session.completed_at - session.started_at

+                    session.save()

+                

+                response_data['output'] = "🎉 Congratulations! You found and eliminated the mole!"

+                response_data['success'] = True

+                response_data['game_won'] = True

+            else:

+                response_data['output'] = "No moles found in this directory."

+                response_data['success'] = True

+        

+        elif cmd == 'help':

+            response_data['output'] = """Available commands:

+cd <directory>  - Change directory

+ls              - List directory contents

+pwd             - Print working directory

+killall moles   - Eliminate moles (when in the same directory)

+help            - Show this help message"""

+            response_data['success'] = True

+        

+        else:

+            response_data['output'] = f"bash: {cmd}: command not found"

+        

+        return Response(response_data)

+    

+    @action(detail=True, methods=['get'])

+    def hint(self, request, pk=None):

+        """Get a hint about the mole's location"""

+        tree = self.get_object()

+        

+        if not tree.mole_location:

+            return Response({'hint': 'No mole in this tree!'})

+        

+        mole_depth = tree.mole_location.count('/')

+        player_depth = tree.player_location.count('/')

+        

+        hints = []

+        if mole_depth > player_depth:

+            hints.append("The mole is deeper in the filesystem than you are.")

+        elif mole_depth < player_depth:

+            hints.append("The mole is in a shallower directory than you are.")

+        else:

+            hints.append("You're at the same depth as the mole!")

+        

+        # Give a path hint

+        mole_parts = tree.mole_location.split('/')

+        player_parts = tree.player_location.split('/')

+        

+        # Find common path

+        common_parts = []

+        for i, (m, p) in enumerate(zip(mole_parts, player_parts)):

+            if m == p:

+                common_parts.append(m)

+            else:

+                break

+        

+        if len(common_parts) == len(mole_parts):

+            hints.append("You're in the mole's directory! Use 'killall moles'!")

+        elif len(common_parts) > 1:

+            hints.append(f"You share a common path with the mole: {'/'.join(common_parts) or '/'}")

+        

+        return Response({'hints': hints})

+

+

+class DirectoryNodeViewSet(viewsets.ReadOnlyModelViewSet):

+    """ViewSet for browsing directory nodes"""

+    queryset = DirectoryNode.objects.all()

+    serializer_class = DirectoryNodeSerializer

+    

+    def get_queryset(self):

+        queryset = super().get_queryset()

+        tree_id = self.request.query_params.get('tree', None)

+        if tree_id:

+            queryset = queryset.filter(tree_id=tree_id)

+        return queryset

+

+

+class GameSessionViewSet(viewsets.ModelViewSet):

+    """ViewSet for game sessions"""

+    queryset = GameSession.objects.all()

+    serializer_class = GameSessionSerializer

+    

+    @action(detail=False, methods=['get'])

+    def leaderboard(self, request):

+        """Get the leaderboard of fastest completions"""

+        completed_sessions = GameSession.objects.filter(

+            completed_at__isnull=False

+        ).order_by('time_taken', 'commands_used')[:20]

+        

+        serializer = self.get_serializer(completed_sessions, many=True)

+        return Response(serializer.data)

+"""

+ASGI config for bashamole project.

+

+It exposes the ASGI callable as a module-level variable named ``application``.

+

+For more information on this file, see

+https://docs.djangoproject.com/en/5.2/howto/deployment/asgi/

+"""

+

+import os

+

+from django.core.asgi import get_asgi_application

+

+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "bashamole.settings")

+

+application = get_asgi_application()

+"""

+Django settings for bashamole project.

+

+Generated by 'django-admin startproject' using Django 5.2.3.

+

+For more information on this file, see

+https://docs.djangoproject.com/en/5.2/topics/settings/

+

+For the full list of settings and their values, see

+https://docs.djangoproject.com/en/5.2/ref/settings/

+"""

+

+from pathlib import Path

+

+# Build paths inside the project like this: BASE_DIR / 'subdir'.

+BASE_DIR = Path(__file__).resolve().parent.parent

+

+

+# Quick-start development settings - unsuitable for production

+# See https://docs.djangoproject.com/en/5.2/howto/deployment/checklist/

+

+# SECURITY WARNING: keep the secret key used in production secret!

+SECRET_KEY = "django-insecure-xykf5$__a(xn*avfxs2njr#==cn7*+t8kg+4_lbi$(#+@5_j8g"

+

+# SECURITY WARNING: don't run with debug turned on in production!

+DEBUG = True

+

+ALLOWED_HOSTS = []

+

+

+# Application definition

+

+INSTALLED_APPS = [

+    "django.contrib.admin",

+    "django.contrib.auth",

+    "django.contrib.contenttypes",

+    "django.contrib.sessions",

+    "django.contrib.messages",

+    "django.contrib.staticfiles",

+    "rest_framework",

+    "corsheaders",

+    "apps.trees",

+]

+

+MIDDLEWARE = [

+    "django.middleware.security.SecurityMiddleware",

+    "django.contrib.sessions.middleware.SessionMiddleware",

+    "django.middleware.common.CommonMiddleware",

+    "django.middleware.csrf.CsrfViewMiddleware",

+    "django.contrib.auth.middleware.AuthenticationMiddleware",

+    "django.contrib.messages.middleware.MessageMiddleware",

+    "django.middleware.clickjacking.XFrameOptionsMiddleware",

+    'corsheaders.middleware.CorsMiddleware',

+    'django.middleware.common.CommonMiddleware',

+]

+

+ROOT_URLCONF = "bashamole.urls"

+

+TEMPLATES = [

+    {

+        "BACKEND": "django.template.backends.django.DjangoTemplates",

+        "DIRS": [],

+        "APP_DIRS": True,

+        "OPTIONS": {

+            "context_processors": [

+                "django.template.context_processors.request",

+                "django.contrib.auth.context_processors.auth",

+                "django.contrib.messages.context_processors.messages",

+            ],

+        },

+    },

+]

+

+WSGI_APPLICATION = "bashamole.wsgi.application"

+

+

+# Database

+# https://docs.djangoproject.com/en/5.2/ref/settings/#databases

+

+DATABASES = {

+    "default": {

+        "ENGINE": "django.db.backends.sqlite3",

+        "NAME": BASE_DIR / "db.sqlite3",

+    }

+}

+

+

+# Password validation

+# https://docs.djangoproject.com/en/5.2/ref/settings/#auth-password-validators

+

+AUTH_PASSWORD_VALIDATORS = [

+    {

+        "NAME": "django.contrib.auth.password_validation.UserAttributeSimilarityValidator",

+    },

+    {

+        "NAME": "django.contrib.auth.password_validation.MinimumLengthValidator",

+    },

+    {

+        "NAME": "django.contrib.auth.password_validation.CommonPasswordValidator",

+    },

+    {

+        "NAME": "django.contrib.auth.password_validation.NumericPasswordValidator",

+    },

+]

+

+

+# Internationalization

+# https://docs.djangoproject.com/en/5.2/topics/i18n/

+

+LANGUAGE_CODE = "en-us"

+

+TIME_ZONE = "UTC"

+

+USE_I18N = True

+

+USE_TZ = True

+

+

+# Static files (CSS, JavaScript, Images)

+# https://docs.djangoproject.com/en/5.2/howto/static-files/

+

+STATIC_URL = "static/"

+

+# Default primary key field type

+# https://docs.djangoproject.com/en/5.2/ref/settings/#default-auto-field

+

+DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField"

+

+CORS_ALLOWED_ORIGINS = [

+    "http://localhost:3000",

+    "http://localhost:5173",

+]

+

+# API settings

+REST_FRAMEWORK = {

+    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',

+    'PAGE_SIZE': 100

+}

+"""

+URL configuration for bashamole project.

+

+The `urlpatterns` list routes URLs to views. For more information please see:

+    https://docs.djangoproject.com/en/5.2/topics/http/urls/

+Examples:

+Function views

+    1. Add an import:  from my_app import views

+    2. Add a URL to urlpatterns:  path('', views.home, name='home')

+Class-based views

+    1. Add an import:  from other_app.views import Home

+    2. Add a URL to urlpatterns:  path('', Home.as_view(), name='home')

+Including another URLconf

+    1. Import the include() function: from django.urls import include, path

+    2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))

+"""

+

+from django.contrib import admin

+from django.urls import path, include

+

+urlpatterns = [

+    path('admin/', admin.site.urls),

+    path('api/trees/', include('apps.trees.urls')),

+    path('api-auth/', include('rest_framework.urls')),

+]

+"""

+WSGI config for bashamole project.

+

+It exposes the WSGI callable as a module-level variable named ``application``.

+

+For more information on this file, see

+https://docs.djangoproject.com/en/5.2/howto/deployment/wsgi/

+"""

+

+import os

+

+from django.core.wsgi import get_wsgi_application

+

+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "bashamole.settings")

+

+application = get_wsgi_application()

+#!/usr/bin/env python

+"""Django's command-line utility for administrative tasks."""

+import os

+import sys

+

+

+def main():

+    """Run administrative tasks."""

+    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "bashamole.settings")

+    try:

+        from django.core.management import execute_from_command_line

+    except ImportError as exc:

+        raise ImportError(

+            "Couldn't import Django. Are you sure it's installed and "

+            "available on your PYTHONPATH environment variable? Did you "

+            "forget to activate a virtual environment?"

+        ) from exc

+    execute_from_command_line(sys.argv)

+

+

+if __name__ == "__main__":

+    main()

+asgiref==3.8.1

+Django==5.2.3

+django-cors-headers==4.7.0

+djangorestframework==3.16.0

+sqlparse==0.5.3

+{

+  "name": "bashamole",

+  "version": "1.0.0",

+  "private": true,

+  "scripts": {

+    "dev:backend": "cd backend && python manage.py runserver",

+    "dev:frontend": "cd frontend && npm run dev",

+    "install:backend": "cd backend && pip install -r requirements.txt",

+    "install:frontend": "cd frontend && npm install"

+  },

+  "dependencies": {

+    "@types/d3": "^7.4.3",

+    "axios": "^1.10.0",

+    "d3": "^7.9.0"

+  },

+  "devDependencies": {

+    "autoprefixer": "^10.4.21",

+    "postcss": "^8.5.5",

+    "tailwindcss": "^4.1.10"

+  }

+}