added logs

app.py

@@ -10,6 +10,9 @@ CommitLens — Gradio UI
 
 from __future__ import annotations
 
+import logging
+import sys
+
 import gradio as gr
 import spaces
 import torch
@@ -17,6 +20,13 @@ from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
 
 from commitlens import run_pipeline
 
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    stream=sys.stdout,
+)
+log = logging.getLogger("commitlens")
+
 # ---------------------------------------------------------------------------
 # Model config
 # ---------------------------------------------------------------------------
@@ -50,31 +60,40 @@ _tokenizer = None
 def _get_llm():
     global _model, _tokenizer
     if _model is None:
+        log.info("Starting model load from %s ...", MODEL_REPO_ID)
         # 8-bit quantization is required to bypass the 16GB ZeroGPU CPU RAM limit
         quantization_config = BitsAndBytesConfig(
             load_in_8bit=True,
         )
-        
+
+        log.info("Loading tokenizer ...")
         _tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO_ID)
-        
+        log.info("Tokenizer loaded.")
+
         # flash_attention_2 removed. PyTorch will automatically use native SDPA.
+        log.info("Loading model with 8-bit quantization and device_map='auto' ...")
         _model = AutoModelForCausalLM.from_pretrained(
             MODEL_REPO_ID,
             quantization_config=quantization_config,
             device_map="auto",
-            torch_dtype=torch.bfloat16 # ZeroGPU RTX 6000 natively supports bfloat16
+            torch_dtype=torch.bfloat16, # ZeroGPU RTX 6000 natively supports bfloat16
         )
+        log.info("Model loaded successfully.")
     return _model, _tokenizer
 
 
 def _extract_filename(prompt: str) -> str:
     for line in prompt.splitlines():
         if line.startswith("Filename :"):
-            return line.split(":", 1)[1].strip()
+            name = line.split(":", 1)[1].strip()
+            log.debug("Extracted filename: %s", name)
+            return name
+    log.warning("Could not extract filename from prompt")
     return "unknown"
 
 
 def _generate_response(system_prompt: str, user_prompt: str, max_tokens: int) -> str:
+    log.info("Generating response (max_tokens=%d) ...", max_tokens)
     model, tokenizer = _get_llm()
     
     messages = [
@@ -83,12 +102,16 @@ def _generate_response(system_prompt: str, user_prompt: str, max_tokens: int) ->
     ]
     
     # Format the prompt using the model's chat template
+    log.debug("Applying chat template ...")
     formatted_prompt = tokenizer.apply_chat_template(
         messages, tokenize=False, add_generation_prompt=True
     )
     
+    log.debug("Tokenizing input ...")
     inputs = tokenizer(formatted_prompt, return_tensors="pt").to("cuda")
+    log.debug("Input shape: %s", inputs.input_ids.shape)
     
+    log.info("Running model.generate ...")
     outputs = model.generate(
         **inputs,
         max_new_tokens=max_tokens,
@@ -96,52 +119,69 @@ def _generate_response(system_prompt: str, user_prompt: str, max_tokens: int) ->
         do_sample=False,    
         pad_token_id=tokenizer.eos_token_id 
     )
+    log.info("Generation complete.")
     
     # Decode and return just the generated response
     response = tokenizer.decode(outputs[0][inputs.input_ids.shape[-1]:], skip_special_tokens=True)
+    log.debug("Response length: %d characters", len(response))
     return response.strip()
 
 
 def _summarize(prompt: str) -> str:
-    return _generate_response(SUMMARY_SYSTEM_PROMPT, prompt, max_tokens=1024)
+    log.info("Summarizing file ...")
+    result = _generate_response(SUMMARY_SYSTEM_PROMPT, prompt, max_tokens=1024)
+    log.info("File summarization done.")
+    return result
 
 
 def _final_md(combined: str) -> str:
-    return _generate_response(FINAL_SYSTEM_PROMPT, combined, max_tokens=2048)
+    log.info("Generating final markdown report ...")
+    result = _generate_response(FINAL_SYSTEM_PROMPT, combined, max_tokens=2048)
+    log.info("Final markdown report generated.")
+    return result
 
 
 # ---------------------------------------------------------------------------
 # Pipeline
 # ---------------------------------------------------------------------------
 
-# Re-added the @spaces.GPU decorator with the 300-second timeout
 @spaces.GPU(duration=300)
 def process_repo(repo_url: str, token: str, progress: gr.Progress = gr.Progress()):
     try:
+        log.info("Pipeline started for repo: %s", repo_url)
         progress(0, desc="Running CommitLens pipeline...")
         prompts = run_pipeline(repo_url, token.strip() or None)
+        log.info("CommitLens pipeline returned %d prompts.", len(prompts))
 
         if not prompts:
+            log.warning("No source-code files changed in the latest commit.")
             raise ValueError("No source-code files changed in the latest commit.")
 
         per_file_md_parts = []
         for i, prompt in enumerate(prompts):
             fname = _extract_filename(prompt)
+            log.info("Processing file %d/%d: %s", i + 1, len(prompts), fname)
             progress(
                 (i + 1) / (len(prompts) + 1),
                 desc=f"Summarizing [{i+1}/{len(prompts)}] {fname}...",
             )
             summary = _summarize(prompt)
             per_file_md_parts.append(f"## `{fname}`\n\n{summary}")
+            log.info("Finished file %d/%d: %s", i + 1, len(prompts), fname)
 
         combined = "\n\n---\n\n".join(per_file_md_parts)
+        log.info("All per-file summaries combined (%d characters).", len(combined))
 
         progress(0.95, desc="Generating final markdown report...")
         final_md = _final_md(combined)
 
+        log.info("Pipeline finished successfully.")
         return combined, final_md
 
+    except gr.Error:
+        raise
     except Exception as e:
+        log.error("Pipeline failed: %s", e, exc_info=True)
         raise gr.Error(str(e))
 
 
@@ -178,4 +218,5 @@ with gr.Blocks(title="CommitLens", theme=gr.themes.Soft()) as demo:
     )
 
 if __name__ == "__main__":
+    log.info("Starting Gradio app ...")
     demo.launch()