Feat/repo

server/build.gradle

@@ -34,18 +34,35 @@ dependencies {
     implementation 'com.bucket4j:bucket4j_jdk17-redis-common:8.14.0'
     implementation 'com.bucket4j:bucket4j_jdk17-lettuce:8.14.0'
     implementation 'io.jsonwebtoken:jjwt-api:0.13.0'
+    implementation 'org.springframework.boot:spring-boot-starter-data-jdbc'
     runtimeOnly 'io.jsonwebtoken:jjwt-impl:0.13.0'
     runtimeOnly 'io.jsonwebtoken:jjwt-jackson:0.13.0'
     implementation 'org.springframework.boot:spring-boot-starter-data-redis'
     implementation 'org.flywaydb:flyway-database-postgresql'
     implementation 'org.springframework.ai:spring-ai-starter-model-ollama'
-    implementation 'org.springframework.ai:spring-ai-starter-vector-store-pgvector'
-    implementation 'org.springframework.ai:spring-ai-vector-store-advisor'
     compileOnly 'org.projectlombok:lombok'
     implementation 'org.eclipse.jgit:org.eclipse.jgit:7.6.0.202603022253-r'
     developmentOnly 'org.springframework.boot:spring-boot-devtools'
     developmentOnly 'org.springframework.boot:spring-boot-docker-compose'
+    implementation 'com.pgvector:pgvector:0.1.6'
     runtimeOnly 'org.postgresql:postgresql'
+    implementation 'io.github.bonede:tree-sitter:0.26.3'
+    runtimeOnly 'io.github.bonede:tree-sitter-java:0.23.5'
+    runtimeOnly 'io.github.bonede:tree-sitter-python:0.25.0'
+    runtimeOnly 'io.github.bonede:tree-sitter-kotlin:0.3.8.1'
+    runtimeOnly 'io.github.bonede:tree-sitter-javascript:0.25.0'
+    runtimeOnly 'io.github.bonede:tree-sitter-typescript:0.23.2'
+    runtimeOnly 'io.github.bonede:tree-sitter-tsx:0.23.2'
+    runtimeOnly 'io.github.bonede:tree-sitter-go:0.23.3'
+    runtimeOnly 'io.github.bonede:tree-sitter-rust:0.23.1'
+    runtimeOnly 'io.github.bonede:tree-sitter-c:0.24.1'
+    runtimeOnly 'io.github.bonede:tree-sitter-cpp:0.23.4'
+    runtimeOnly 'io.github.bonede:tree-sitter-c-sharp:0.23.1'
+    runtimeOnly 'io.github.bonede:tree-sitter-php:0.23.11'
+    runtimeOnly 'io.github.bonede:tree-sitter-ruby:0.23.1'
+    runtimeOnly 'io.github.bonede:tree-sitter-swift:0.5.0'
+    runtimeOnly 'io.github.bonede:tree-sitter-html:0.23.2'
+    runtimeOnly 'io.github.bonede:tree-sitter-css:0.25.0'
     developmentOnly 'org.springframework.ai:spring-ai-spring-boot-docker-compose'
     annotationProcessor 'org.projectlombok:lombok'
     testImplementation 'org.springframework.boot:spring-boot-starter-data-jpa-test'

server/src/main/java/com/meet/server/ServerApplication.java

@@ -7,10 +7,12 @@
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
 import org.springframework.scheduling.annotation.EnableScheduling;
+import org.springframework.scheduling.annotation.EnableAsync;
 
 @SpringBootApplication
 @EnableJpaAuditing
 @EnableScheduling
+@EnableAsync
 public class ServerApplication {
 
     private static final Logger log = LogManager.getLogger(ServerApplication.class);

server/src/main/java/com/meet/server/common/config/AppConfig.java

@@ -1,10 +1,11 @@
 package com.meet.server.common.config;
 
 import org.springframework.beans.factory.annotation.Value;
-import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Bean;
 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 
 @Configuration
 public class AppConfig {
@@ -26,4 +27,15 @@ public void setCookieSecure(String env) {
     public PasswordEncoder passwordEncoder() {
         return new BCryptPasswordEncoder(12);
     }
+
+    @Bean(name = "codebaseTaskExecutor")
+    public ThreadPoolTaskExecutor codebaseTaskExecutor() {
+        var executor = new ThreadPoolTaskExecutor();
+        executor.setCorePoolSize(2);
+        executor.setMaxPoolSize(4);
+        executor.setQueueCapacity(100);
+        executor.setThreadNamePrefix("codebase-");
+        executor.initialize();
+        return executor;
+    }
 }

server/src/main/java/com/meet/server/common/exception/CodebaseException.java

@@ -0,0 +1,23 @@
+package com.meet.server.common.exception;
+
+import lombok.Getter;
+import org.springframework.http.HttpStatus;
+
+@Getter
+public class CodebaseException extends RuntimeException {
+
+    private final String errorCode;
+    private final HttpStatus status;
+
+    public CodebaseException(String errorCode, String message, HttpStatus status) {
+        super(message);
+        this.errorCode = errorCode;
+        this.status = status;
+    }
+
+    public CodebaseException(String errorCode, String message, HttpStatus status, Throwable cause) {
+        super(message, cause);
+        this.errorCode = errorCode;
+        this.status = status;
+    }
+}

server/src/main/java/com/meet/server/common/exception/GlobalExceptionHandler.java

@@ -61,6 +61,12 @@ public ResponseEntity<ApiResponse<Void>> handleAuthException(AuthException excep
         return response(exception.getStatus(), exception.getMessage());
     }
 
+    @ExceptionHandler(CodebaseException.class)
+    public ResponseEntity<ApiResponse<Void>> handleCodebaseException(CodebaseException exception) {
+        log.warn("Codebase operation failed [{}]: {}", exception.getErrorCode(), exception.getMessage());
+        return response(exception.getStatus(), exception.getMessage());
+    }
+
     @ExceptionHandler(InvalidTokenException.class)
     public ResponseEntity<ApiResponse<Void>> handleInvalidToken(InvalidTokenException exception) {
         return response(HttpStatus.UNAUTHORIZED, exception.getMessage());

server/src/main/java/com/meet/server/feature/codebase/CodebaseController.java

@@ -0,0 +1,42 @@
+package com.meet.server.feature.codebase;
+
+import com.meet.server.common.api.ApiResponse;
+import com.meet.server.feature.codebase.dto.CodebaseImportRequest;
+import com.meet.server.feature.codebase.dto.CodebaseImportResponse;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.Authentication;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.Optional;
+import java.util.UUID;
+
+@RestController
+@RequestMapping("/api/codebases")
+@RequiredArgsConstructor
+public class CodebaseController {
+
+    private final CodebaseService codebaseService;
+
+    @PostMapping
+    public ResponseEntity<ApiResponse<CodebaseImportResponse>> importCodebase(
+            Authentication authentication,
+            @Valid @RequestBody CodebaseImportRequest request
+    ) {
+        var response = codebaseService.startClone(
+                UUID.fromString(authentication.getName()),
+                request);
+
+        return ResponseEntity
+                .status(HttpStatus.ACCEPTED)
+                .body(new ApiResponse<>(
+                        true,
+                        "Codebase import queued",
+                        Optional.of(response)));
+    }
+}

server/src/main/java/com/meet/server/feature/codebase/CodebaseRepository.java

@@ -0,0 +1,20 @@
+package com.meet.server.feature.codebase;
+
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.repository.query.Param;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.UUID;
+
+@Repository
+public interface CodebaseRepository extends JpaRepository<Codebase, UUID> {
+
+    @Modifying
+    @Transactional
+    @Query("update Codebase c set c.lastCommitSha = :lastCommitSha where c.id = :codebaseId")
+    int updateLastCommitSha(@Param("codebaseId") UUID codebaseId,
+                            @Param("lastCommitSha") String lastCommitSha);
+}

server/src/main/java/com/meet/server/feature/codebase/CodebaseService.java

@@ -0,0 +1,170 @@
+package com.meet.server.feature.codebase;
+
+import com.meet.server.common.exception.CodebaseException;
+import com.meet.server.feature.codebase.dto.CodebaseImportRequest;
+import com.meet.server.feature.codebase.dto.CodebaseImportResponse;
+import com.meet.server.feature.repositoryfile.RepositoryFileProcessor;
+import com.meet.server.feature.user.UserService;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.support.TransactionSynchronization;
+import org.springframework.transaction.support.TransactionSynchronizationManager;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.Inet4Address;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Locale;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+
+@Service
+public class CodebaseService {
+
+    private final CodebaseRepository codebaseRepository;
+    private final UserService userService;
+    private final GitService gitService;
+    private final RepositoryFileProcessor fileProcessor;
+    private final CodebaseStatusService statusService;
+    private final Executor codebaseTaskExecutor;
+
+    public CodebaseService(
+            CodebaseRepository codebaseRepository,
+            UserService userService,
+            GitService gitService,
+            RepositoryFileProcessor fileProcessor,
+            CodebaseStatusService statusService,
+            @Qualifier("codebaseTaskExecutor") Executor codebaseTaskExecutor
+    ) {
+        this.codebaseRepository = codebaseRepository;
+        this.userService = userService;
+        this.gitService = gitService;
+        this.fileProcessor = fileProcessor;
+        this.statusService = statusService;
+        this.codebaseTaskExecutor = codebaseTaskExecutor;
+    }
+
+    @Transactional
+    public CodebaseImportResponse startClone(UUID userId, CodebaseImportRequest request) {
+        validateCloneUrl(request.cloneUrl());
+        var codebase = codebaseRepository.save(Codebase.builder()
+                .user(userService.getById(userId))
+                .name(request.name())
+                .cloneUrl(request.cloneUrl())
+                .branch(request.branch() == null || request.branch().isBlank() ? "main" : request.branch())
+                .status(CodebaseStatus.QUEUED)
+                .build());
+
+        var codebaseId = codebase.getId();
+        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
+            @Override
+            public void afterCommit() {
+                processAsync(codebaseId);
+            }
+        });
+
+        return new CodebaseImportResponse(codebaseId, CodebaseStatus.QUEUED, 0);
+    }
+
+    private void validateCloneUrl(String cloneUrl) {
+        if (cloneUrl == null || cloneUrl.isBlank()) {
+            throw invalidCloneUrl(null);
+        }
+        final URI uri;
+        try {
+            uri = new URI(cloneUrl);
+        } catch (URISyntaxException exception) {
+            throw invalidCloneUrl(exception);
+        }
+
+        if (!"https".equalsIgnoreCase(uri.getScheme())
+                || uri.getHost() == null
+                || uri.getHost().isBlank()
+                || uri.getUserInfo() != null) {
+            throw invalidCloneUrl(null);
+        }
+
+        try {
+            for (InetAddress address : InetAddress.getAllByName(uri.getHost())) {
+                if (isInternalAddress(address)) {
+                    throw invalidCloneUrl(null);
+                }
+            }
+        } catch (IOException exception) {
+            throw invalidCloneUrl(exception);
+        }
+    }
+
+    private boolean isInternalAddress(InetAddress address) {
+        String hostAddress = address.getHostAddress().toLowerCase(Locale.ROOT);
+        if (address.isAnyLocalAddress()
+                || address.isLoopbackAddress()
+                || address.isLinkLocalAddress()
+                || address.isSiteLocalAddress()
+                || address.isMulticastAddress()
+                || hostAddress.startsWith("fc")
+                || hostAddress.startsWith("fd")) {
+            return true;
+        }
+        if (address instanceof Inet4Address) {
+            byte[] bytes = address.getAddress();
+            int first = bytes[0] & 0xff;
+            int second = bytes[1] & 0xff;
+            return first == 100 && second >= 64 && second <= 127
+                    || first == 192 && second == 0
+                    || first == 198 && (second == 18 || second == 19)
+                    || first >= 240;
+        }
+        return false;
+    }
+
+    private CodebaseException invalidCloneUrl(Throwable cause) {
+        return cause == null
+                ? new CodebaseException("INVALID_CLONE_URL", "Clone URL must be a public HTTPS URL", HttpStatus.BAD_REQUEST)
+                : new CodebaseException("INVALID_CLONE_URL", "Clone URL must be a public HTTPS URL", HttpStatus.BAD_REQUEST, cause);
+    }
+
+    public CompletableFuture<CodebaseImportResponse> processAsync(UUID codebaseId) {
+        return CompletableFuture.supplyAsync(() -> process(codebaseId), codebaseTaskExecutor);
+    }
+
+    private CodebaseImportResponse process(UUID codebaseId) {
+        var codebase = codebaseRepository.findById(codebaseId)
+                .orElseThrow(() -> new CodebaseException(
+                        "CODEBASE_NOT_FOUND",
+                        "Codebase not found",
+                        HttpStatus.NOT_FOUND));
+        try {
+            statusService.update(codebaseId, CodebaseStatus.PROCESSING);
+
+            Path repositoryPath = Files.createTempDirectory("codebase-" + codebaseId);
+            try {
+                gitService.cloneRepository(codebase.getCloneUrl(), codebase.getBranch(), repositoryPath);
+                var commitSha = gitService.currentCommitSha(repositoryPath);
+                codebaseRepository.updateLastCommitSha(codebaseId, commitSha);
+                var files = gitService.listFiles(repositoryPath);
+                var fileCount = fileProcessor.process(codebase, repositoryPath, files, commitSha);
+                statusService.update(codebaseId, CodebaseStatus.INDEXED);
+                return new CodebaseImportResponse(codebaseId, CodebaseStatus.INDEXED, fileCount);
+            } finally {
+                gitService.deleteRepository(repositoryPath);
+            }
+        } catch (IOException exception) {
+            statusService.update(codebaseId, CodebaseStatus.FAILED);
+            throw new CodebaseException(
+                    "CODEBASE_WORKSPACE_FAILED",
+                    "Unable to process codebase workspace",
+                    HttpStatus.INTERNAL_SERVER_ERROR,
+                    exception);
+        } catch (RuntimeException exception) {
+            statusService.update(codebaseId, CodebaseStatus.FAILED);
+            throw exception;
+        }
+    }
+}

server/src/main/java/com/meet/server/feature/codebase/CodebaseStatusService.java

@@ -0,0 +1,33 @@
+package com.meet.server.feature.codebase;
+
+import com.meet.server.common.exception.CodebaseException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.Instant;
+import java.util.UUID;
+
+@Service
+@RequiredArgsConstructor
+public class CodebaseStatusService {
+
+    private final CodebaseRepository codebaseRepository;
+
+    @Transactional(propagation = Propagation.REQUIRES_NEW)
+    public void update(UUID codebaseId, CodebaseStatus status) {
+        var codebase = codebaseRepository.findById(codebaseId)
+                .orElseThrow(() -> new CodebaseException(
+                        "CODEBASE_NOT_FOUND",
+                        "Codebase not found",
+                        HttpStatus.NOT_FOUND));
+
+        codebase.setStatus(status);
+        if (status == CodebaseStatus.INDEXED) {
+            codebase.setIndexedAt(Instant.now());
+        }
+        codebaseRepository.save(codebase);
+    }
+}