prepforge 0.1.0__py3-none-any.whl

major_project/cli.py

@@ -0,0 +1,186 @@
+import argparse
+import subprocess
+import os
+import sys
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="prepforge",
+        description="prepforge - Multi-interface AI assistant with training support",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+    subparsers.required = True
+
+    # -------------------------
+    # RUN APPS
+    # -------------------------
+    run_parser = subparsers.add_parser(
+        "run",
+        help="Run the application (tui | gui | streamlit)",
+        description=(
+            "Run prepforce in one of the following modes:\n\n"
+            "  tui        Terminal interface\n"
+            "  gui        Desktop application\n"
+            "  streamlit  Web interface\n"
+        ),
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+
+    run_parser.add_argument(
+        "mode",
+        choices=["tui", "gui", "streamlit"],
+        help="Mode to run",
+    )
+
+    # -------------------------
+    # TRAIN
+    # -------------------------
+    train_parser = subparsers.add_parser(
+        "train",
+        help="Train a LoRA adapter",
+        description=(
+            "Train a model using your dataset\n\n"
+            "Dataset Control Options:\n"
+            "  --limit N     Train on first N samples\n"
+            "  --subset F    Train on fraction (0.1 = 10%%)\n\n"
+            "Examples:\n"
+            "  prepforce train --dataset data.jsonl\n"
+            "  prepforce train --dataset data.jsonl --limit 500\n"
+            "  prepforce train --dataset data.jsonl --subset 0.05\n"
+        ),
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+
+    train_parser.add_argument(
+        "--dataset",
+        required=True,
+        help="Path to dataset file (JSON/JSONL format)",
+    )
+
+    train_parser.add_argument(
+        "--output",
+        default="trained_model",
+        help="Output directory for trained model",
+    )
+
+    train_parser.add_argument(
+        "--epochs",
+        type=int,
+        default=2,
+        help="Number of training epochs",
+    )
+
+    train_parser.add_argument(
+        "--lr",
+        type=float,
+        default=2e-4,
+        help="Learning rate",
+    )
+
+    # 🔥 Mutually exclusive group
+    group = train_parser.add_mutually_exclusive_group()
+
+    group.add_argument(
+        "--limit",
+        type=int,
+        help="Limit number of samples (e.g. 500)",
+    )
+
+    group.add_argument(
+        "--subset",
+        type=float,
+        help="Use fraction of dataset (0.05 = 5%%)",
+    )
+
+    # -------------------------
+    # CONFIG
+    # -------------------------
+    config_parser = subparsers.add_parser(
+        "config",
+        help="Set default model or LoRA",
+        description=(
+            "Configure default model and LoRA adapter\n\n"
+            "Examples:\n"
+            "  prepforce config --model meta-llama/Llama-3-8B\n"
+            "  prepforce config --lora ~/adapter\n"
+        ),
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+
+    config_parser.add_argument(
+        "--model",
+        help="Set default base model",
+    )
+
+    config_parser.add_argument(
+        "--lora",
+        help="Set default LoRA adapter path",
+    )
+
+    args = parser.parse_args()
+
+    try:
+        # -------------------------
+        # RUN MODES
+        # -------------------------
+        if args.command == "run":
+            if args.mode == "tui":
+                from .tui_app import main
+
+                main()
+
+            elif args.mode == "gui":
+                from .gui_app import main
+
+                main()
+
+            elif args.mode == "streamlit":
+                base_dir = os.path.dirname(__file__)
+                app_path = os.path.join(base_dir, "streamlit_app.py")
+
+                subprocess.run([sys.executable, "-m", "streamlit", "run", app_path])
+
+        # -------------------------
+        # TRAIN
+        # -------------------------
+        elif args.command == "train":
+            from .core.train import train_model
+
+            train_model(
+                dataset_path=args.dataset,
+                output_dir=args.output,
+                epochs=args.epochs,
+                lr=args.lr,
+                limit=args.limit,
+                subset=args.subset,
+            )
+
+        # -------------------------
+        # CONFIG
+        # -------------------------
+        elif args.command == "config":
+            from .core.config_store import load_user_config, save_user_config
+
+            config = load_user_config()
+
+            if args.model:
+                config["model"] = args.model
+                print(f"✅ Default model set to: {args.model}")
+
+            if args.lora:
+                config["lora"] = args.lora
+                print(f"✅ Default LoRA set to: {args.lora}")
+
+            if not args.model and not args.lora:
+                print("⚠️ No changes provided. Use --model or --lora")
+
+            save_user_config(config)
+
+    except Exception as e:
+        print(f"\n❌ Error: {str(e)}\n")
+
+
+if __name__ == "__main__":
+    main()

major_project/config.py

@@ -0,0 +1,17 @@
+import os
+from major_project.core.config_store import load_user_config
+
+DEFAULT_MODEL = "unsloth/llama-3.2-3b-instruct-unsloth-bnb-4bit"
+DEFAULT_LORA = None
+DEFAULT_APP_NAME = "PrepForge"
+MAX_HISTORY = 6
+
+
+def get_model():
+    user_config = load_user_config()
+    return user_config.get("model") or os.getenv("MENTORAI_MODEL") or DEFAULT_MODEL
+
+
+def get_lora():
+    user_config = load_user_config()
+    return user_config.get("lora") or os.getenv("MENTORAI_LORA") or DEFAULT_LORA

major_project/core/config_store.py

@@ -0,0 +1,20 @@
+import os
+import json
+
+CONFIG_DIR = os.path.expanduser("~/.prepforce")
+CONFIG_FILE = os.path.join(CONFIG_DIR, "config.json")
+
+
+def load_user_config():
+    if not os.path.exists(CONFIG_FILE):
+        return {}
+
+    with open(CONFIG_FILE, "r") as f:
+        return json.load(f)
+
+
+def save_user_config(config):
+    os.makedirs(CONFIG_DIR, exist_ok=True)
+
+    with open(CONFIG_FILE, "w") as f:
+        json.dump(config, f, indent=2)

major_project/core/model.py

@@ -0,0 +1,112 @@
+import os
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from peft import PeftModel
+
+# ✅ Use shared config
+from major_project.config import get_model, get_lora
+
+
+def _check_cuda():
+    """
+    Ensure NVIDIA GPU is available.
+    """
+    if not torch.cuda.is_available():
+        raise RuntimeError(
+            "\n❌ CUDA GPU not detected.\n"
+            "This application requires an NVIDIA GPU.\n"
+            "CPU execution is not supported.\n"
+            "\n👉 Install CUDA-enabled PyTorch:\n"
+            "pip install torch --index-url https://download.pytorch.org/whl/cu121\n"
+        )
+
+
+def load_model(
+    base_model: str | None = None,
+    lora_path: str | None = None,
+    device_map: str = "auto",
+    dtype: torch.dtype = torch.float16,
+):
+    """
+    Load base model and optionally apply LoRA adapter.
+
+    Args:
+        base_model (str | None): HuggingFace model name or local path
+        lora_path (str | None): Path to LoRA adapter folder
+        device_map (str): Device mapping ("auto", "cpu", etc.)
+        dtype (torch.dtype): Torch dtype
+
+    Returns:
+        model, tokenizer
+    """
+
+    # -----------------------------
+    # 🔥 CUDA CHECK
+    # -----------------------------
+    _check_cuda()
+
+    # -----------------------------
+    # USE DEFAULT CONFIG (if not provided)
+    # -----------------------------
+    if base_model is None:
+        base_model = get_model()
+
+    if lora_path is None:
+        lora_path = get_lora()
+
+    # -----------------------------
+    # VALIDATE INPUTS
+    # -----------------------------
+    if not base_model:
+        raise ValueError("Base model path/name must be provided")
+
+    if lora_path:
+        lora_path = os.path.expanduser(lora_path)
+
+        if not os.path.exists(lora_path):
+            raise FileNotFoundError(f"LoRA path not found: {lora_path}")
+
+        expected = os.path.join(lora_path, "adapter_config.json")
+        if not os.path.exists(expected):
+            raise ValueError(
+                f"Invalid LoRA adapter folder (missing adapter_config.json): {lora_path}"
+            )
+
+    # -----------------------------
+    # LOAD BASE MODEL
+    # -----------------------------
+    print(f"[MODEL] Loading base model: {base_model}")
+
+    model = AutoModelForCausalLM.from_pretrained(
+        base_model,
+        device_map=device_map,
+        torch_dtype=dtype,
+        local_files_only=True,
+    )
+
+    tokenizer = AutoTokenizer.from_pretrained(
+        base_model,
+        local_files_only=True,
+        use_fast=True,
+    )
+
+    # -----------------------------
+    # APPLY LORA (OPTIONAL)
+    # -----------------------------
+    if lora_path:
+        print(f"[MODEL] Applying LoRA adapter: {lora_path}")
+
+        model = PeftModel.from_pretrained(
+            model,
+            lora_path,
+            local_files_only=True,
+        )
+
+        print("[MODEL] LoRA successfully loaded")
+
+    # -----------------------------
+    # FINAL SETUP
+    # -----------------------------
+    model.eval()
+
+    return model, tokenizer

major_project/core/train.py

@@ -0,0 +1,149 @@
+from unsloth import FastLanguageModel
+from datasets import load_dataset, Dataset
+from transformers import TrainingArguments
+from trl.trainer.sft_trainer import SFTTrainer
+
+from major_project.config import get_model
+
+
+def train_model(
+    dataset_path,
+    output_dir,
+    epochs=2,
+    lr=2e-4,
+    batch_size=2,
+    max_seq_length=512,
+    limit=None,
+    subset=None,
+):
+    # -----------------------------
+    # LOAD MODEL FROM CONFIG
+    # -----------------------------
+    model_name = get_model()
+    print(f"[TRAIN] Using model: {model_name}")
+
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        model_name=model_name,
+        max_seq_length=max_seq_length,
+        load_in_4bit=True,
+    )
+
+    # -----------------------------
+    # APPLY LoRA
+    # -----------------------------
+    model = FastLanguageModel.get_peft_model(
+        model,
+        r=16,
+        target_modules=[
+            "q_proj",
+            "k_proj",
+            "v_proj",
+            "o_proj",
+            "gate_proj",
+            "up_proj",
+            "down_proj",
+        ],
+        lora_alpha=16,
+        lora_dropout=0,
+        bias="none",
+        use_gradient_checkpointing="unsloth",
+    )
+
+    # -----------------------------
+    # LOAD DATASET
+    # -----------------------------
+    dataset = load_dataset("json", data_files=dataset_path, split="train")
+    assert isinstance(dataset, Dataset)
+
+    print(f"[TRAIN] Original dataset size: {len(dataset)}")
+
+    # -----------------------------
+    # APPLY LIMIT / SUBSET
+    # -----------------------------
+    if limit is not None:
+        dataset = dataset.select(range(min(limit, len(dataset))))
+        print(f"[TRAIN] Using first {len(dataset)} samples")
+
+    elif subset is not None:
+        size = int(len(dataset) * subset)
+        dataset = dataset.select(range(size))
+        print(f"[TRAIN] Using {subset * 100:.1f}% → {len(dataset)} samples")
+
+    # -----------------------------
+    # FORMAT DATA
+    # -----------------------------
+    def format_prompt(example):
+        instruction = example.get("instruction", "")
+        input_text = example.get("input", "")
+        output = example.get("output", "")
+
+        prompt = f"{instruction}\n{input_text}".strip()
+
+        user_part = f"""<|begin_of_text|>
+<|start_header_id|>user<|end_header_id|>
+
+{prompt}
+
+<|start_header_id|>assistant<|end_header_id|>
+
+"""
+
+        full_text = user_part + output
+
+        user_tokens = tokenizer(user_part, add_special_tokens=False)
+        full_tokens = tokenizer(
+            full_text,
+            truncation=True,
+            max_length=max_seq_length,
+        )
+
+        labels = full_tokens["input_ids"].copy()
+        user_len = len(user_tokens["input_ids"])
+        labels[:user_len] = [-100] * user_len
+
+        return {
+            "input_ids": full_tokens["input_ids"],
+            "attention_mask": full_tokens["attention_mask"],
+            "labels": labels,
+        }
+
+    dataset = dataset.map(format_prompt)
+
+    dataset = dataset.remove_columns(
+        [
+            c
+            for c in dataset.column_names or []
+            if c not in ["input_ids", "attention_mask", "labels"]
+        ]
+    )
+
+    # -----------------------------
+    # TRAINER
+    # -----------------------------
+    trainer = SFTTrainer(
+        model=model,
+        train_dataset=dataset,
+        args=TrainingArguments(
+            per_device_train_batch_size=batch_size,
+            num_train_epochs=epochs,
+            learning_rate=lr,
+            output_dir=output_dir,
+            logging_steps=10,
+            save_steps=500,
+            optim="adamw_8bit",
+        ),
+    )
+
+    # -----------------------------
+    # TRAIN
+    # -----------------------------
+    print("[TRAIN] Starting training...")
+    trainer.train()
+
+    # -----------------------------
+    # SAVE
+    # -----------------------------
+    model.save_pretrained(output_dir)
+    tokenizer.save_pretrained(output_dir)
+
+    print("[TRAIN] Training complete.")

major_project/core/utils.py

@@ -0,0 +1,222 @@
+import threading
+from transformers import TextIteratorStreamer
+
+# -----------------------------
+# MEMORY (SHARED)
+# -----------------------------
+chat_history = []
+last_mcq_block = None
+MAX_HISTORY = 6
+
+
+def trim_history():
+    global chat_history
+    if len(chat_history) > MAX_HISTORY:
+        chat_history = chat_history[-MAX_HISTORY:]
+
+
+# -----------------------------
+# PROMPT BUILDER (SHARED)
+# -----------------------------
+def build_prompt(mode, user_input, count):
+    global last_mcq_block
+
+    user_lower = user_input.lower()
+
+    # -------------------------
+    # 🔥 MCQ FOLLOWUPS
+    # -------------------------
+    if last_mcq_block:
+        # ONLY ANSWERS
+        if (
+            "answer" in user_lower
+            and "why" not in user_lower
+            and "explain" not in user_lower
+        ):
+            return f"""Here are the MCQs:
+
+{last_mcq_block}
+
+Give ONLY the answers in this format:
+1. A
+2. B
+3. C
+(continue...)
+"""
+
+        # EXPLANATION MODE
+        if "why" in user_lower or "explain" in user_lower:
+            return f"""Here are the MCQs:
+
+{last_mcq_block}
+
+For EACH question:
+- Give the correct answer
+- Explain WHY it is correct
+- Briefly explain why other options are incorrect
+
+FORMAT:
+
+1. Answer: A
+Explanation: ...
+
+2. Answer: B
+Explanation: ...
+"""
+
+    # -------------------------
+    # CHAT
+    # -------------------------
+    if mode in ["chat", "Chat"]:
+        return user_input
+
+    # -------------------------
+    # NOTES
+    # -------------------------
+    elif mode in ["notes", "Notes"]:
+        return f"""
+Explain {user_input} in structured notes.
+
+Use:
+- Clear headings
+- Bullet points
+- Simple explanations
+"""
+
+    # -------------------------
+    # MCQ GENERATION (FIXED)
+    # -------------------------
+    elif mode in ["mcq", "MCQ Generator"]:
+        return f"""
+Generate EXACTLY {count} multiple choice questions on {user_input}.
+
+STRICT RULES:
+- Generate EXACTLY {count} questions (no more, no less)
+- Each question MUST have 4 options: A, B, C, D
+- Each option MUST be on a new line
+- Do NOT combine options in one line
+- Do NOT stop early
+- Do NOT skip numbers
+
+FORMAT:
+
+SECTION 1: QUESTIONS
+
+1. Question text
+A. Option
+B. Option
+C. Option
+D. Option
+
+2. Question text
+A. Option
+B. Option
+C. Option
+D. Option
+
+(continue until {count})
+
+SECTION 2: ANSWERS
+
+1. A
+2. B
+3. C
+4. D
+(continue until {count})
+
+IMPORTANT:
+- SECTION 1 must contain ALL {count} questions
+- SECTION 2 must contain ALL {count} answers
+- DO NOT include explanations
+- DO NOT add extra commentary
+"""
+
+    # -------------------------
+    # PRACTICE QUESTIONS
+    # -------------------------
+    elif mode in ["practice", "Practice"]:
+        return f"""
+Generate EXACTLY {count} practice questions on {user_input}.
+
+RULES:
+- These must be descriptive or short-answer questions
+- DO NOT generate MCQs
+- DO NOT provide answers initially
+- Keep questions clear and numbered
+
+FORMAT:
+
+1. Question
+2. Question
+3. Question
+(continue...)
+"""
+
+    # -------------------------
+    # PRACTICE FOLLOWUP (EXPLANATION)
+    # -------------------------
+    if mode in ["practice", "Practice"] and (
+        "answer" in user_lower or "explain" in user_lower or "why" in user_lower
+    ):
+        return f"""
+Here are the practice questions:
+
+{user_input}
+
+Provide detailed answers and explanations for each question.
+"""
+
+    # -------------------------
+    # STUDY PLAN
+    # -------------------------
+    elif mode in ["plan", "Study Plan"]:
+        return f"""
+Create a structured study plan for {user_input}.
+
+Include:
+- Daily/weekly breakdown
+- Topics to cover
+- Practice suggestions
+"""
+
+    return user_input
+
+
+# -----------------------------
+# STREAM GENERATION (SHARED)
+# -----------------------------
+def generate_stream(model, tokenizer, prompt, max_tokens):
+    global chat_history
+
+    chat_history.append({"role": "user", "content": prompt})
+    trim_history()
+
+    messages = [{"role": "system", "content": "You are a helpful AI teacher."}]
+    messages.extend(chat_history)
+
+    full_prompt = tokenizer.apply_chat_template(
+        messages, tokenize=False, add_generation_prompt=True
+    )
+
+    inputs = tokenizer(full_prompt, return_tensors="pt").to(model.device)
+
+    streamer = TextIteratorStreamer(
+        tokenizer,
+        skip_prompt=True,
+        skip_special_tokens=True,
+    )
+
+    def run():
+        model.generate(
+            **inputs,
+            max_new_tokens=max_tokens,
+            temperature=0.7,
+            top_p=0.95,
+            do_sample=True,
+            streamer=streamer,
+            pad_token_id=tokenizer.pad_token_id,
+            eos_token_id=tokenizer.eos_token_id,
+        )
+
+    threading.Thread(target=run).start()
+    return streamer