Merge branch 'main' of https://github.com/stacklok/codegate

Author: yrobla

.github/workflows/image-build.yml

@@ -20,6 +20,10 @@ jobs:
         uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@c47758b77c9736f4b2ef4073d4d51994fabfe349 # v3
+      - name: Fetch latest FE commit SHA
+        id: fetch_commit_fe_sha
+        run: |
+          echo "LATEST_COMMIT_SHA=$(curl -LSsk 'https://api.github.com/repos/stacklok/codegate-ui/commits?per_page=1' -H 'Authorization: Bearer ${{ secrets.GH_CI_TOKEN }}' | jq -r '.[0].sha')" >> $GITHUB_ENV
       - name: Test build on x86
         id: docker_build
         uses: docker/build-push-action@48aba3b46d1b1fec4febb7c5d0c644b249a11355 # v5
@@ -30,4 +34,8 @@ jobs:
           push: false # Only attempt to build, to verify the Dockerfile is working
           load: true
           cache-from: type=gha
-          cache-to: type=gha,mode=max
+          cache-to: type=gha,mode=max
+          secrets: |
+            gh_token=${{ secrets.GH_CI_TOKEN }}
+          build-args: |
+            LATEST_COMMIT_SHA=${{ env.LATEST_COMMIT_SHA }}

.github/workflows/image-publish.yml

@@ -61,6 +61,10 @@ jobs:
           name_is_regexp: true
           skip_unpack: false
           if_no_artifact_found: ignore
+      - name: Fetch latest FE commit SHA
+        id: fetch_commit_fe_sha
+        run: |
+          echo "LATEST_COMMIT_SHA=$(curl -LSsk 'https://api.github.com/repos/stacklok/codegate-ui/commits?per_page=1' -H 'Authorization: Bearer ${{ secrets.GH_CI_TOKEN }}' | jq -r '.[0].sha')" >> $GITHUB_ENV
       - name: Rename to accomodate to image
         run: mv ./backup_weaviate ./weaviate_backup
       - name: Build image
@@ -76,3 +80,7 @@ jobs:
           labels: ${{ steps.docker-metadata.outputs.labels }}
           cache-from: type=gha
           cache-to: type=gha,mode=max
+          secrets: |
+            gh_token=${{ secrets.GH_CI_TOKEN }}
+          build-args: |
+            LATEST_COMMIT_SHA=${{ env.LATEST_COMMIT_SHA }}

Dockerfile

@@ -21,23 +21,74 @@ RUN poetry config virtualenvs.create false && \
 # Copy the rest of the application
 COPY . /app
 
+# Build the webapp
+FROM node:20.18-slim AS webbuilder
+
+# Install curl for downloading the webapp from GH and unzip to extract it
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    curl \
+    unzip\
+    ca-certificates
+
+WORKDIR /usr/src/
+
+# Get the latest commit sha as a build arg
+# This is needed otherwise Docker will cache the git clone step. With this workaround
+# we can force Docker to re-run the git clone step if the latest commit sha changes.
+# --build-arg LATEST_COMMIT_SHA=$(curl \
+#     -LSsk "https://api.github.com/repos/stacklok/codegate-ui/commits?per_page=1" \
+#     -H "Authorization: Bearer $GH_CI_TOKEN" | jq -r '.[0].sha')
+ARG LATEST_COMMIT_SHA=LATEST
+RUN echo "Latest FE commit: $LATEST_COMMIT_SHA"
+# Download the webapp from GH
+# -L to follow redirects
+RUN --mount=type=secret,id=gh_token \
+    LATEST_COMMIT_SHA=${LATEST_COMMIT_SHA} \
+    curl -L -o main.zip "https://api.github.com/repos/stacklok/codegate-ui/zipball/main" \
+    -H "Authorization: Bearer $(cat /run/secrets/gh_token)"
+
+# Extract the downloaded zip file
+RUN unzip main.zip
+RUN rm main.zip
+# Rename the extracted folder
+RUN mv *codegate-ui* webapp
+
+WORKDIR /usr/src/webapp
+
+# Install the webapp dependencies and build it
+RUN npm install
+RUN npm run build
+
 # Runtime stage: Create the final lightweight image
 FROM python:3.12-slim AS runtime
 
 # Install runtime system dependencies
 RUN apt-get update && apt-get install -y --no-install-recommends \
     libgomp1 \
+    nginx \
     && rm -rf /var/lib/apt/lists/*
 
-# Create a non-root user and switch to it
+# Create a non-root user
 RUN useradd -m -u 1000 -r codegate 
+
+# Set permissions for user codegate to run nginx
+RUN chown -R codegate /var/lib/nginx && \
+    chown -R codegate /var/log/nginx && \
+    chown -R codegate /run
+
+# Switch to codegate user
 USER codegate
 WORKDIR /app
 
 # Copy necessary artifacts from the builder stage
 COPY --from=builder /usr/local/lib/python3.12/site-packages /usr/local/lib/python3.12/site-packages
 COPY --from=builder /app /app
 
+# Copy necessary artifacts from the webbuilder stage
+COPY --from=webbuilder /usr/src/webapp/dist /var/www/html
+# Expose nginx
+EXPOSE 80
+
 # Set the PYTHONPATH environment variable
 ENV PYTHONPATH=/app/src
 

README.md

@@ -1,4 +1,5 @@
-# Codegate
+![image](https://github.com/user-attachments/assets/ab37063d-039d-4857-be88-231047a7b282)
+
 
 [![CI](https://github.com/stacklok/codegate/actions/workflows/ci.yml/badge.svg)](https://github.com/stacklok/codegate/actions/workflows/ci.yml)
 

config.yaml

@@ -19,11 +19,13 @@ log_level: "INFO"  # One of: ERROR, WARNING, INFO, DEBUG
 ##
 
 # Model to use for chatting
-chat_model_path: "./models"
+model_base_path: "./models"
 
 # Context length of the model
 chat_model_n_ctx: 32768
 
 # Number of layers to offload to GPU. If -1, all layers are offloaded.
 chat_model_n_gpu_layers: -1
 
+# Embedding model
+embedding_model: "all-minilm-L6-v2-q5_k_m.gguf"

prompts/default.yaml

@@ -24,6 +24,11 @@ lookup_packages: |
   Your job is to extract any software packages from user's request. A package is a named entity.
   You MUST RESPOND with a list of packages in JSON FORMAT: {"packages": [pkg1, pkg2, ...]}.
 
+secrets_redacted: |
+  The files in the context contain sensitive information that has been redacted. Do not warn the user
+  about any tokens, passwords or similar sensitive information in the context whose value begins with
+  the string "REDACTED".
+
 # Security-focused prompts
 security_audit: "You are a security expert conducting a thorough code review. Identify potential security vulnerabilities, suggest improvements, and explain security best practices."
 

scripts/entrypoint.sh

@@ -9,6 +9,10 @@ else
     echo "No backup found at $1/$2. Skipping restore."
 fi
 
-# Step 2: Start the main application (serve)
+# Step 2: Start the Nginx server with FE
+echo "Starting the dashboard.. "
+exec nginx -g 'daemon off;' & 
+
+# Step 3: Start the main application (serve)
 echo "Starting the application..."
-exec python -m src.codegate.cli serve --port 8989 --host 0.0.0.0
+exec python -m src.codegate.cli serve --port 8989 --host 0.0.0.0 --vllm-url https://inference.codegate.ai

scripts/import_packages.py

@@ -3,7 +3,6 @@
 import os
 import shutil
 
-
 import weaviate
 from weaviate.classes.config import DataType, Property
 from weaviate.embedded import EmbeddedOptions
@@ -17,10 +16,12 @@ class PackageImporter:
     def __init__(self):
         self.client = weaviate.WeaviateClient(
             embedded_options=EmbeddedOptions(
-                persistence_data_path="./weaviate_data", grpc_port=50052,
-                additional_env_vars={"ENABLE_MODULES": "backup-filesystem",
-                                     "BACKUP_FILESYSTEM_PATH": os.getenv("BACKUP_FILESYSTEM_PATH",
-                                                                         "/tmp")}
+                persistence_data_path="./weaviate_data",
+                grpc_port=50052,
+                additional_env_vars={
+                    "ENABLE_MODULES": "backup-filesystem",
+                    "BACKUP_FILESYSTEM_PATH": os.getenv("BACKUP_FILESYSTEM_PATH", "/tmp"),
+                },
             )
         )
         self.json_files = [
@@ -35,21 +36,28 @@ def __init__(self):
     def restore_backup(self):
         if os.getenv("BACKUP_FOLDER"):
             try:
-                self.client.backup.restore(backup_id=os.getenv("BACKUP_FOLDER"),
-                                           backend="filesystem", wait_for_completion=True)
+                self.client.backup.restore(
+                    backup_id=os.getenv("BACKUP_FOLDER"),
+                    backend="filesystem",
+                    wait_for_completion=True,
+                )
             except Exception as e:
                 print(f"Failed to restore backup: {e}")
 
     def take_backup(self):
         # if backup folder exists, remove it
-        backup_path = os.path.join(os.getenv("BACKUP_FILESYSTEM_PATH", "/tmp"),
-                                   os.getenv("BACKUP_TARGET_ID", "backup"))
+        backup_path = os.path.join(
+            os.getenv("BACKUP_FILESYSTEM_PATH", "/tmp"), os.getenv("BACKUP_TARGET_ID", "backup")
+        )
         if os.path.exists(backup_path):
             shutil.rmtree(backup_path)
 
         #  take a backup of the data
-        self.client.backup.create(backup_id=os.getenv("BACKUP_TARGET_ID", "backup"),
-                                  backend="filesystem", wait_for_completion=True)
+        self.client.backup.create(
+            backup_id=os.getenv("BACKUP_TARGET_ID", "backup"),
+            backend="filesystem",
+            wait_for_completion=True,
+        )
 
     def setup_schema(self):
         if not self.client.collections.exists("Package"):

src/codegate/cli.py

@@ -5,13 +5,13 @@
 from typing import Dict, Optional
 
 import click
-from src.codegate.storage.utils import restore_storage_backup
 import structlog
 
 from codegate.codegate_logging import LogFormat, LogLevel, setup_logging
 from codegate.config import Config, ConfigurationError
 from codegate.db.connection import init_db_sync
 from codegate.server import init_app
+from codegate.storage.utils import restore_storage_backup
 
 
 def validate_port(ctx: click.Context, param: click.Parameter, value: int) -> int:

src/codegate/config.py

@@ -40,6 +40,7 @@ class Config:
     model_base_path: str = "./models"
     chat_model_n_ctx: int = 32768
     chat_model_n_gpu_layers: int = -1
+    embedding_model: str = "all-minilm-L6-v2-q5_k_m.gguf"
 
     # Provider URLs with defaults
     provider_urls: Dict[str, str] = field(default_factory=lambda: DEFAULT_PROVIDER_URLS.copy())
@@ -117,11 +118,12 @@ def from_file(cls, config_path: Union[str, Path]) -> "Config":
                 host=config_data.get("host", cls.host),
                 log_level=config_data.get("log_level", cls.log_level.value),
                 log_format=config_data.get("log_format", cls.log_format.value),
-                model_base_path=config_data.get("chat_model_path", cls.model_base_path),
+                model_base_path=config_data.get("model_base_path", cls.model_base_path),
                 chat_model_n_ctx=config_data.get("chat_model_n_ctx", cls.chat_model_n_ctx),
                 chat_model_n_gpu_layers=config_data.get(
                     "chat_model_n_gpu_layers", cls.chat_model_n_gpu_layers
                 ),
+                embedding_model=config_data.get("embedding_model", cls.embedding_model),
                 prompts=prompts_config,
                 provider_urls=provider_urls,
             )

src/codegate/llm_utils/__init__.py

@@ -0,0 +1,4 @@
+from codegate.llm_utils.extractor import PackageExtractor
+from codegate.llm_utils.llmclient import LLMClient
+
+__all__ = ["LLMClient", "PackageExtractor"]

src/codegate/llm_utils/extractor.py

@@ -0,0 +1,43 @@
+from typing import List, Optional
+
+import structlog
+
+from codegate.config import Config
+from codegate.llm_utils.llmclient import LLMClient
+from codegate.storage import StorageEngine
+
+logger = structlog.get_logger("codegate")
+
+
+class PackageExtractor:
+    """
+    Utility class to extract package names from code or queries.
+    """
+
+    def __init__(self):
+        self.storage_engine = StorageEngine()
+
+    @staticmethod
+    async def extract_packages(
+        content: str,
+        provider: str,
+        model: str = None,
+        base_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+    ) -> List[str]:
+        """Extract package names from the given content."""
+        system_prompt = Config.get_config().prompts.lookup_packages
+
+        result = await LLMClient.complete(
+            content=content,
+            system_prompt=system_prompt,
+            provider=provider,
+            model=model,
+            api_key=api_key,
+            base_url=base_url,
+        )
+
+        # Handle both formats: {"packages": [...]} and direct list [...]
+        packages = result if isinstance(result, list) else result.get("packages", [])
+        logger.info(f"Extracted packages: {packages}")
+        return packages