refactor: Clean up project structure - fewer root folders

Reorganized to user-friendly structure:
- Moved legacy docs to docs/archive/
- Merged CLI tools to src/cli/
- Moved training scripts to scripts/
- Removed empty/broken directories (benchmarks, space, website)
- Added directory structure documentation

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

benchmarks/benchmark_context_lengths.py

@@ -1,442 +0,0 @@
-#!/usr/bin/env python3
-"""
-Benchmark script for comparing context window performance across different lengths.
-
-This script compares:
-1. 32K context (original claim)
-2. 64K context (mid-range)
-3. 128K context (full potential)
-
-For each context length, it tests:
-- Memory consumption (VRAM and RAM)
-- Throughput (tokens/second during generation)
-- Latency (time to first token)
-- Quality (ability to process and generate coherent output)
-- Task completion on sample coding tasks
-
-Output: JSON results + summary report
-"""
-
-import os
-import sys
-import json
-import time
-import argparse
-import statistics
-from pathlib import Path
-from typing import Dict, List, Any
-
-# Required packages: vllm, transformers, psutil, torch
-
-def get_memory_info():
-    """Get memory statistics."""
-    import torch
-    import psutil
-    
-    process = psutil.Process(os.getpid())
-    ram_mb = process.memory_info().rss / 1024 / 1024
-    
-    if torch.cuda.is_available():
-        gpu_mem_allocated = torch.cuda.memory_allocated() / 1024 / 1024
-        gpu_mem_reserved = torch.cuda.memory_reserved() / 1024 / 1024
-        return {
-            "ram_mb": round(ram_mb, 1),
-            "gpu_allocated_mb": round(gpu_mem_allocated, 1),
-            "gpu_reserved_mb": round(gpu_mem_reserved, 1),
-            "gpu_used": True
-        }
-    else:
-        return {
-            "ram_mb": round(ram_mb, 1),
-            "gpu_used": False
-        }
-
-def preprocess_prompt(prompt: str, tokenizer, target_tokens: int, mode: str = "repeat") -> List[int]:
-    """Preprocess a prompt to reach target token length."""
-    tokens = tokenizer.encode(prompt)
-    
-    if len(tokens) >= target_tokens:
-        return tokens[:target_tokens]
-    
-    needed = target_tokens - len(tokens)
-    
-    if mode == "repeat":
-        # Repeat a filler pattern
-        filler = " This is additional context to fill the window. " * 100
-        filler_tokens = tokenizer.encode(filler)
-        repeats = (needed // len(filler_tokens)) + 1
-        tokens.extend(filler_tokens * repeats)
-    elif mode == "noise":
-        # Use random-like content (code snippets)
-        noise = """
-        // Dummy code for context expansion
-        function placeholder() {
-            const x = 1;
-            const y = 2;
-            return x + y;
-        }
-        class DummyClass {
-            constructor() {}
-            method() {}
-        }
-        """.repeat(needed // 50 + 1)
-        noise_tokens = tokenizer.encode(noise)
-        tokens.extend(noise_tokens)
-    
-    return tokens[:target_tokens]
-
-def load_model(model_name: str, max_model_len: int, block_size: int):
-    """Load vLLM model with specified configuration."""
-    from vllm import LLM
-    
-    print(f"Loading model with max_model_len={max_model_len}, block_size={block_size}")
-    model = LLM(
-        model=model_name,
-        max_model_len=max_model_len,
-        block_size=block_size,
-        gpu_memory_utilization=0.9,
-        trust_remote_code=True,
-        tensor_parallel_size=1,
-        # For benchmarking, disable speculative decoding for consistent results
-        enable_chunked_prefill=False
-    )
-    return model
-
-def run_generation(model, tokenizer, prompt_tokens: List[int], max_new_tokens: int = 200) -> Dict[str, Any]:
-    """Run generation and collect metrics."""
-    from vllm import SamplingParams
-    
-    sampling_params = SamplingParams(
-        temperature=0.7,
-        top_p=0.95,
-        max_tokens=max_new_tokens,
-        min_p=0.05
-    )
-    
-    # Prefill phase timing
-    torch = sys.modules.get('torch')
-    if torch and torch.cuda.is_available():
-        torch.cuda.synchronize()
-    
-    start_time = time.time()
-    outputs = model.generate(
-        prompt_token_ids=prompt_tokens,
-        sampling_params=sampling_params,
-        use_tqdm=False
-    )
-    end_time = time.time()
-    
-    if torch and torch.cuda.is_available():
-        torch.cuda.synchronize()
-    
-    elapsed = end_time - start_time
-    output_token_ids = outputs[0].outputs[0].token_ids
-    output_text = outputs[0].outputs[0].text
-    
-    # Count tokens in output
-    output_length = len(output_token_ids)
-    
-    # Calculate prefill latency (estimated)
-    prefill_latency = elapsed * 0.3  # Rough estimate
-    decode_latency = elapsed - prefill_latency
-    
-    # Tokens per second
-    total_tokens = output_length
-    tokens_per_second = total_tokens / elapsed if elapsed > 0 else 0
-    
-    return {
-        "elapsed_seconds": round(elapsed, 4),
-        "output_tokens": output_length,
-        "output_text": output_text[:200],
-        "tokens_per_second": round(tokens_per_second, 2),
-        "prefill_latency_est": round(prefill_latency, 4),
-        "decode_latency_est": round(decode_latency, 4)
-    }
-
-def test_task(model, tokenizer, context_length: int, task_name: str, prompt: str, max_response: int = 200) -> Dict[str, Any]:
-    """Run a single benchmark task."""
-    print(f"\n  Task: {task_name}")
-    sys.stdout.flush()
-    
-    mem_before = get_memory_info()
-    prompt_tokens = preprocess_prompt(prompt, tokenizer, context_length)
-    actual_context_len = len(prompt_tokens)
-    
-    start_time = time.time()
-    try:
-        result = run_generation(model, tokenizer, prompt_tokens, max_response)
-        elapsed = time.time() - start_time
-        mem_after = get_memory_info()
-        
-        # Calculate memory delta
-        mem_delta = {}
-        if mem_after.get("gpu_used"):
-            mem_delta["gpu_allocated_delta_mb"] = round(
-                mem_after["gpu_allocated_mb"] - mem_before["gpu_allocated_mb"], 1
-            )
-        mem_delta["ram_delta_mb"] = round(
-            mem_after["ram_mb"] - mem_before["ram_mb"], 1
-        )
-        
-        return {
-            "task": task_name,
-            "context_length_target": context_length,
-            "context_length_actual": actual_context_len,
-            "success": True,
-            **result,
-            **mem_delta
-        }
-    except Exception as e:
-        elapsed = time.time() - start_time
-        print(f"    ❌ Failed: {e}")
-        return {
-            "task": task_name,
-            "context_length_target": context_length,
-            "success": False,
-            "error": str(e),
-            "elapsed_seconds": round(elapsed, 4)
-        }
-
-def main():
-    parser = argparse.ArgumentParser(description="Benchmark context lengths: 32K, 64K, 128K")
-    parser.add_argument("--model", type=str, default="Qwen/Qwen2.5-Coder-32B",
-                        help="Model name")
-    parser.add_argument("--output-dir", type=str, default="benchmarks/results",
-                        help="Directory to save results")
-    parser.add_argument("--context-lengths", type=int, nargs='+', default=[32768, 65536, 131072],
-                        help="Context lengths to test")
-    parser.add_argument("--tasks-per-length", type=int, default=5,
-                        help="Number of tasks per context length")
-    
-    args = parser.parse_args()
-    
-    print("="*70)
-    print("CONTEXT LENGTH BENCHMARK")
-    print("="*70)
-    print(f"Model: {args.model}")
-    print(f"Context lengths: {args.context_lengths}")
-    print(f"Tasks per length: {args.tasks_per_length}")
-    
-    # Sample tasks for benchmarking
-    tasks = [
-        {
-            "name": "Code Completion",
-            "prompt": """import React from 'react';
-function Component({ children }) {
-    return (
-        <div className="container">
-            {children}
-        </div>
-    );
-}
-export default Component;"""
-        },
-        {
-            "name": "Bug Fix",
-            "prompt": """function calculateTotal(items) {
-    let total = 0;
-    for (let i = 0; i <= items.length; i++) {
-        total += items[i].price;
-    }
-    return total;
-}
-// This function has a bug. What is it and how would you fix it?"""
-        },
-        {
-            "name": "Documentation Generation",
-            "prompt": """class DataProcessor {
-    constructor(config) {
-        this.config = config;
-        this.cache = new Map();
-    }
-    
-    async process(data) {
-        const result = await this.transform(data);
-        return this.validate(result);
-    }
-    
-    transform(data) {
-        // Transform logic here
-        return data.map(item => ({ ...item, processed: true }));
-    }
-    
-    validate(result) {
-        return result.filter(item => item.valid !== false);
-    }
-}
-// Please generate comprehensive JSDoc documentation for this class."""
-        },
-        {
-            "name": "Test Generation",
-            "prompt": """const sum = (a, b) => a + b;
-const multiply = (a, b) => a * b;
-const divide = (a, b) => {
-    if (b === 0) throw new Error('Division by zero');
-    return a / b;
-};
-// Write Jest unit tests for these utility functions."""
-        },
-        {
-            "name": "Refactoring",
-            "prompt": """function processUserData(users) {
-    const result = [];
-    for (let i = 0; i < users.length; i++) {
-        const user = users[i];
-        if (user.active) {
-            result.push({
-                id: user.id,
-                name: user.firstName + ' ' + user.lastName,
-                email: user.email.toLowerCase()
-            });
-        }
-    }
-    return result;
-}
-// Refactor this function using modern ES6+ features (map, filter, destructuring, template literals)."""
-        }
-    ]
-    
-    results = {
-        "metadata": {
-            "model": args.model,
-            "context_lengths_tested": args.context_lengths,
-            "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
-            "tasks": [t["name"] for t in tasks],
-            "max_new_tokens": 200
-        },
-        "results": []
-    }
-    
-    try:
-        # Import dependencies
-        print("\n📦 Loading dependencies...")
-        from transformers import AutoTokenizer
-        sys.path.insert(0, '/Users/walidsobhi/.openclaw/workspace/stack-2.9/stack-2.9-deploy')
-        
-        print(f"\n🔍 Loading tokenizer for {args.model}...")
-        tokenizer = AutoTokenizer.from_pretrained(
-            args.model,
-            trust_remote_code=True
-        )
-        print(f"Tokenizer loaded. Vocab size: {tokenizer.vocab_size}")
-        
-        all_task_results = []
-        
-        # Test each context length
-        for context_len in args.context_lengths:
-            print(f"\n{'='*70}")
-            print(f"TESTING CONTEXT LENGTH: {context_len} tokens ({context_len/1024:.0f}K)")
-            print(f"{'='*70}")
-            
-            # Load model fresh for each context length (optional, but cleaner)
-            print(f"\n🤖 Loading model...")
-            model = load_model(args.model, max_model_len=context_len, block_size=64)
-            
-            # Get initial memory after load
-            mem_after_load = get_memory_info()
-            print(f"   Model loaded. Memory: {mem_after_load}")
-            
-            length_results = []
-            
-            # Run tasks (selected subset based on context length)
-            num_tasks = min(args.tasks_per_length, len(tasks))
-            
-            for i in range(num_tasks):
-                task = tasks[i % len(tasks)]
-                print(f"\n[{i+1}/{num_tasks}] Running task: {task['name']}")
-                sys.stdout.flush()
-                
-                result = test_task(
-                    model, tokenizer, context_len,
-                    f"{task['name']} @ {context_len}",
-                    task["prompt"]
-                )
-                length_results.append(result)
-                all_task_results.append(result)
-                
-                # Small delay between tasks
-                time.sleep(1)
-            
-            # Print summary for this context length
-            successful = [r for r in length_results if r.get('success', False)]
-            if successful:
-                avg_tps = statistics.mean([r['tokens_per_second'] for r in successful])
-                avg_latency = statistics.mean([r['elapsed_seconds'] for r in successful])
-                print(f"\n📈 Summary for {context_len} tokens:")
-                print(f"   Avg throughput: {avg_tps:.2f} tokens/sec")
-                print(f"   Avg latency: {avg_latency:.3f}s")
-                print(f"   Success count: {len(successful)}/{len(length_results)}")
-            
-            # Unload model to free memory before next test
-            del model
-            import gc
-            gc.collect()
-            if torch.cuda.is_available():
-                torch.cuda.empty_cache()
-            
-            print(f"   ✓ Completed testing for {context_len}")
-        
-        # Compile final results
-        results["results"] = all_task_results
-        
-        # Calculate summary statistics
-        summary = {}
-        for context_len in args.context_lengths:
-            len_results = [r for r in all_task_results 
-                          if r.get('context_length_target') == context_len and r.get('success')]
-            if len_results:
-                summary[str(context_len)] = {
-                    "count": len(len_results),
-                    "avg_tokens_per_second": round(statistics.mean([r['tokens_per_second'] for r in len_results]), 2),
-                    "avg_latency_seconds": round(statistics.mean([r['elapsed_seconds'] for r in len_results]), 3),
-                    "avg_gpu_memory_delta_mb": round(statistics.mean([r.get('gpu_allocated_delta_mb', 0) for r in len_results]), 1),
-                    "avg_ram_delta_mb": round(statistics.mean([r.get('ram_delta_mb', 0) for r in len_results]), 1)
-                }
-        results["summary"] = summary
-        
-    except ImportError as e:
-        print(f"❌ Missing dependencies: {e}")
-        print("Please install: pip install vllm transformers psutil torch")
-        sys.exit(1)
-    except Exception as e:
-        print(f"❌ Error: {e}")
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)
-    
-    # Save results
-    output_dir = Path(args.output_dir)
-    output_dir.mkdir(parents=True, exist_ok=True)
-    
-    timestamp = time.strftime("%Y%m%d_%H%M%S")
-    output_file = output_dir / f"benchmark_{timestamp}.json"
-    
-    with open(output_file, 'w') as f:
-        json.dump(results, f, indent=2)
-    
-    print(f"\n{'='*70}")
-    print("BENCHMARK COMPLETE")
-    print(f"{'='*70}")
-    print(f"Results saved to: {output_file}")
-    
-    # Print summary table
-    print("\n📊 Performance Summary:")
-    print("-"*70)
-    print(f"{'Context':<10} {'Throughput':<15} {'Latency':<12} {'GPU Δ':<12} {'RAM Δ':<12}")
-    print("-"*70)
-    
-    if summary:
-        for length_str, stats in sorted(summary.items()):
-            length = int(length_str)
-            length_k = length // 1024
-            print(f"{length_k:>3}K      {stats['avg_tokens_per_second']:>5.1f} tok/s   {stats['avg_latency_seconds']:>6.3f}s   "
-                  f"{stats['avg_gpu_memory_delta_mb']:>6.1f} MB   {stats['avg_ram_delta_mb']:>6.1f} MB")
-    
-    print("\n✅ Benchmark finished!")
-    print("\nNext steps:")
-    print("  1. Review results in the JSON output file")
-    print("  2. Check if 128K provides quality benefits that justify any performance trade-offs")
-    print("  3. Update deployment configuration with optimal block_size and scheduler settings")
-
-if __name__ == "__main__":
-    main()

benchmarks/test_context_window.py

@@ -1,330 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script for verifying 128K context window support for Qwen2.5-Coder-32B.
-
-This script:
-1. Loads the model with vLLM configured for 128K context
-2. Tests with various input lengths (32K, 64K, 96K, 128K)
-3. Measures memory usage, throughput, and latency
-4. Tests with real codebase context (entire project)
-5. Validates that the model correctly processes long inputs
-"""
-
-import os
-import sys
-import json
-import time
-import psutil
-import argparse
-from pathlib import Path
-from typing import Dict, List, Tuple
-
-# Add vLLM to path
-sys.path.insert(0, '/Users/walidsobhi/.openclaw/workspace/stack-2.9/stack-2.9-deploy')
-
-def get_memory_usage() -> Dict[str, float]:
-    """Get current memory usage in MB."""
-    process = psutil.Process(os.getpid())
-    memory_info = process.memory_info()
-    return {
-        'rss_mb': memory_info.rss / 1024 / 1024,
-        'vms_mb': memory_info.vms / 1024 / 1024
-    }
-
-def generate_token_sequence(length: int, tokenizer) -> List[int]:
-    """Generate a sequence of tokens of approximately the target length."""
-    # Create a repeating pattern that tokenizes consistently
-    base_text = "This is a test token sequence for context window testing. " * 10
-    tokens = tokenizer.encode(base_text)
-    # Repeat the tokens to reach desired length
-    num_repeats = (length // len(tokens)) + 1
-    token_sequence = tokens * num_repeats
-    return token_sequence[:length]
-
-def read_codebase_files(base_path: str, max_files: int = 100) -> str:
-    """Read source code files from the codebase to create a realistic long context."""
-    codebase_text = ""
-    src_dir = Path(base_path) / "src"
-    if not src_dir.exists():
-        return ""
-    
-    file_count = 0
-    for file_path in src_dir.rglob("*.ts"):
-        if file_count >= max_files:
-            break
-        try:
-            with open(file_path, 'r', encoding='utf-8') as f:
-                content = f.read()
-                codebase_text += f"\n\n// File: {file_path.relative_to(base_path)}\n{content}\n"
-                file_count += 1
-        except Exception as e:
-            print(f"Warning: Could not read {file_path}: {e}")
-    
-    return codebase_text
-
-def test_context_length(model, tokenizer, context_length: int, test_name: str) -> Dict:
-    """Test model with a specific context length."""
-    print(f"\n{'='*60}")
-    print(f"Testing {test_name} (target: {context_length} tokens)")
-    print(f"{'='*60}")
-    
-    # Generate input sequence
-    tokens = generate_token_sequence(context_length, tokenizer)
-    actual_length = len(tokens)
-    print(f"Generated input with {actual_length} tokens")
-    
-    # Measure memory before inference
-    mem_before = get_memory_usage()
-    
-    # Run inference (generate a short response to test context processing)
-    start_time = time.time()
-    try:
-        # Use vLLM's generate
-        from vllm import SamplingParams
-        sampling_params = SamplingParams(
-            temperature=0.1,
-            max_tokens=50,  # Generate only 50 tokens
-            prompt_logprobs=0
-        )
-        
-        outputs = model.generate(
-            prompt_token_ids=tokens,
-            sampling_params=sampling_params,
-            use_tqdm=False
-        )
-        
-        elapsed = time.time() - start_time
-        mem_after = get_memory_usage()
-        
-        # Calculate metrics
-        output_text = outputs[0].outputs[0].text
-        output_tokens = len(outputs[0].outputs[0].token_ids)
-        tokens_per_second = output_tokens / elapsed if elapsed > 0 else 0
-        
-        result = {
-            "test": test_name,
-            "target_length": context_length,
-            "actual_length": actual_length,
-            "output_tokens": output_tokens,
-            "latency_seconds": round(elapsed, 3),
-            "tokens_per_second": round(tokens_per_second, 2),
-            "memory_before_mb": round(mem_before['rss_mb'], 2),
-            "memory_after_mb": round(mem_after['rss_mb'], 2),
-            "memory_delta_mb": round(mem_after['rss_mb'] - mem_before['rss_mb'], 2),
-            "success": True,
-            "sample_output": output_text[:100] if output_text else ""
-        }
-        
-        print(f"✅ Success!")
-        print(f"   Latency: {elapsed:.3f}s")
-        print(f"   Throughput: {tokens_per_second:.2f} tokens/sec")
-        print(f"   Memory delta: {result['memory_delta_mb']:.1f} MB")
-        print(f"   Sample output: {result['sample_output']}")
-        
-    except Exception as e:
-        elapsed = time.time() - start_time
-        result = {
-            "test": test_name,
-            "target_length": context_length,
-            "actual_length": actual_length,
-            "success": False,
-            "error": str(e),
-            "latency_seconds": round(elapsed, 3)
-        }
-        print(f"❌ Failed: {e}")
-    
-    return result
-
-def test_with_codebase(model, tokenizer, codebase_path: str) -> Dict:
-    """Test the model with the entire codebase as context."""
-    print(f"\n{'='*60}")
-    print(f"Testing with real codebase context")
-    print(f"{'='*60}")
-    
-    # Read codebase files
-    print("Reading codebase files...")
-    codebase_text = read_codebase_files(codebase_path, max_files=200)
-    codebase_tokens = tokenizer.encode(codebase_text)
-    context_length = len(codebase_tokens)
-    print(f"Codebase encoded to {context_length} tokens ({context_length/1024:.1f}K)")
-    
-    if context_length < 1000:
-        print("⚠️  Warning: Codebase is too small, generate synthetic long context instead")
-        codebase_tokens = generate_token_sequence(131072, tokenizer)
-        context_length = len(codebase_tokens)
-    
-    mem_before = get_memory_usage()
-    start_time = time.time()
-    
-    try:
-        from vllm import SamplingParams
-        sampling_params = SamplingParams(
-            temperature=0.2,
-            max_tokens=100,
-            prompt_logprobs=0
-        )
-        
-        outputs = model.generate(
-            prompt_token_ids=codebase_tokens,
-            sampling_params=sampling_params,
-            use_tqdm=False
-        )
-        
-        elapsed = time.time() - start_time
-        mem_after = get_memory_usage()
-        
-        output_text = outputs[0].outputs[0].text
-        output_tokens = len(outputs[0].outputs[0].token_ids)
-        tokens_per_second = output_tokens / elapsed if elapsed > 0 else 0
-        
-        result = {
-            "test": "Codebase Context",
-            "context_size_k": round(context_length / 1024, 1),
-            "output_tokens": output_tokens,
-            "latency_seconds": round(elapsed, 3),
-            "tokens_per_second": round(tokens_per_second, 2),
-            "memory_before_mb": round(mem_before['rss_mb'], 2),
-            "memory_after_mb": round(mem_after['rss_mb'], 2),
-            "memory_delta_mb": round(mem_after['rss_mb'] - mem_before['rss_mb'], 2),
-            "success": True,
-            "sample_output": output_text[:150]
-        }
-        
-        print(f"✅ Success!")
-        print(f"   Context size: {result['context_size_k']}K tokens")
-        print(f"   Latency: {elapsed:.3f}s")
-        print(f"   Throughput: {tokens_per_second:.2f} tokens/sec")
-        print(f"   Memory delta: {result['memory_delta_mb']:.1f} MB")
-        print(f"   Sample output: {result['sample_output']}")
-        
-    except Exception as e:
-        elapsed = time.time() - start_time
-        result = {
-            "test": "Codebase Context",
-            "success": False,
-            "error": str(e),
-            "latency_seconds": round(elapsed, 3)
-        }
-        print(f"❌ Failed: {e}")
-    
-    return result
-
-def main():
-    parser = argparse.ArgumentParser(description="Test 128K context window for Qwen2.5-Coder-32B")
-    parser.add_argument("--model", type=str, default="Qwen/Qwen2.5-Coder-32B",
-                        help="Model name or path")
-    parser.add_argument("--max-model-len", type=int, default=131072,
-                        help="Maximum model length for vLLM")
-    parser.add_argument("--block-size", type=int, default=64,
-                        help="vLLM block size")
-    parser.add_argument("--codebase-path", type=str,
-                        default="/Users/walidsobhi/.openclaw/workspace/stack-2.9",
-                        help="Path to the codebase for real context test")
-    parser.add_argument("--output", type=str,
-                        default="benchmarks/test_context_results.json",
-                        help="Output file for results")
-    
-    args = parser.parse_args()
-    
-    print(f"Starting 128K Context Window Test")
-    print(f"Model: {args.model}")
-    print(f"Config: max_model_len={args.max_model_len}, block_size={args.block_size}")
-    
-    results = []
-    
-    try:
-        # Import vLLM and Transformers
-        print("\n📦 Loading tokenizer...")
-        from transformers import AutoTokenizer
-        tokenizer = AutoTokenizer.from_pretrained(
-            args.model,
-            trust_remote_code=True
-        )
-        print(f"Tokenizer loaded. Vocab size: {tokenizer.vocab_size}")
-        
-        print("\n🤖 Loading vLLM model...")
-        from vllm import LLM
-        
-        # Initialize vLLM with large context configuration
-        model = LLM(
-            model=args.model,
-            max_model_len=args.max_model_len,
-            block_size=args.block_size,
-            gpu_memory_utilization=0.9,
-            trust_remote_code=True,
-            tensor_parallel_size=1  # Adjust if using multiple GPUs
-        )
-        print("Model loaded successfully!")
-        
-        # Test 1: Small context (8K) - baseline
-        results.append(test_context_length(model, tokenizer, 8192, "8K Baseline"))
-        
-        # Test 2: Medium context (32K)
-        results.append(test_context_length(model, tokenizer, 32768, "32K"))
-        
-        # Test 3: Large context (64K)
-        results.append(test_context_length(model, tokenizer, 65536, "64K"))
-        
-        # Test 4: Full context (96K)
-        results.append(test_context_length(model, tokenizer, 98304, "96K"))
-        
-        # Test 5: Maximum context (128K)
-        results.append(test_context_length(model, tokenizer, 131072, "128K"))
-        
-        # Test 6: Codebase context
-        results.append(test_with_codebase(model, tokenizer, args.codebase_path))
-        
-    except ImportError as e:
-        print(f"❌ Import error: {e}")
-        print("Make sure vLLM and transformers are installed:")
-        print("  pip install vllm transformers")
-        sys.exit(1)
-    except Exception as e:
-        print(f"❌ Error during testing: {e}")
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)
-    
-    # Save results
-    output_path = Path(args.output)
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-    
-    with open(output_path, 'w') as f:
-        json.dump({
-            "metadata": {
-                "model": args.model,
-                "max_model_len": args.max_model_len,
-                "block_size": args.block_size,
-                "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
-                "system": os.uname().sysname if hasattr(os, 'uname') else "Unknown"
-            },
-            "results": results
-        }, f, indent=2)
-    
-    print(f"\n📊 Results saved to: {output_path}")
-    print("\n" + "="*60)
-    print("SUMMARY")
-    print("="*60)
-    
-    successful = [r for r in results if r.get('success', False)]
-    failed = [r for r in results if not r.get('success', False)]
-    
-    print(f"Total tests: {len(results)}")
-    print(f"Successful: {len(successful)}")
-    print(f"Failed: {len(failed)}")
-    
-    if successful:
-        print("\nContext length vs. throughput:")
-        for r in successful:
-            if r['test'] != 'Codebase Context':
-                print(f"  {r['test']}: {r['tokens_per_second']} tokens/sec, "
-                      f"memory delta: {r['memory_delta_mb']}MB")
-        if any(r['test'] == 'Codebase Context' for r in successful):
-            cb = next(r for r in successful if r['test'] == 'Codebase Context')
-            print(f"\nCodebase test: {cb['context_size_k']}K tokens, "
-                  f"{cb['tokens_per_second']} tokens/sec")
-    
-    print("\n✅ Test script completed!")
-
-if __name__ == "__main__":
-    main()

space/Dockerfile

@@ -1,37 +0,0 @@
-# Stack 2.9 HuggingFace Spaces Dockerfile
-# Optimized for 16GB GPU with 4-bit quantization
-
-FROM python:3.10-slim
-
-# Set environment variables
-ENV PYTHONUNBUFFERED=1
-ENV TRANSFORMERS_CACHE=/workspace/.cache/huggingface
-ENV HF_HOME=/workspace/.cache/huggingface
-
-# Install system dependencies
-RUN apt-get update && apt-get install -y \
-    git \
-    wget \
-    && rm -rf /var/lib/apt/lists/*
-
-# Create workspace directory
-WORKDIR /workspace
-
-# Copy requirements first for better caching
-COPY requirements.txt .
-
-# Install Python dependencies
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copy application files
-COPY . .
-
-# Expose Gradio port
-EXPOSE 7860
-
-# Create startup script
-RUN echo '#!/bin/bash\necho "🚀 Starting Stack 2.9..."\npython app.py --port 7860 --share' > /start.sh
-RUN chmod +x /start.sh
-
-# Launch command
-CMD ["/start.sh"]

space/README.md

@@ -1,124 +0,0 @@
-# 🚀 Stack 2.9 - Pattern-Based AI Coding Assistant
-
-A HuggingFace Spaces demo for Stack 2.9, a pattern-based AI coding assistant powered by Qwen2.5-Coder-7B.
-
-![License](https://img.shields.io/badge/license-MIT-blue.svg)
-![Python](https://img.shields.io/badge/python-3.10+-green.svg)
-![Gradio](https://img.shields.io/badge/Gradio-4.0+-orange.svg)
-
-## ✨ Features
-
-- **🤖 Qwen2.5-Coder-7B** - State-of-the-art code generation model
-- **🔧 7 Integrated Tools** - File operations, git, web search, shell commands
-- **🧠 Pattern Memory** - Learns from each interaction
-- **⚡ Fast Streaming** - Real-time token-by-token generation
-- **💾 4-bit Quantization** - Runs on 16GB GPU (~4GB VRAM)
-
-## 🔧 Available Tools
-
-| Tool | Description |
-|------|-------------|
-| `file_read` | Read files from the filesystem |
-| `file_write` | Write content to files |
-| `git_status` | Check git repository status |
-| `web_search` | Search the web for information |
-| `run_command` | Execute shell commands |
-| `create_directory` | Create new directories |
-| `list_directory` | List directory contents |
-
-## 🏃‍♂️ Quick Start
-
-### Local Development
-
-```bash
-# Clone the repository
-git clone https://github.com/your-repo/stack-2.9.git
-cd stack-2.9/space
-
-# Install dependencies
-pip install -r requirements.txt
-
-# Run the demo
-python app.py --share
-```
-
-### HuggingFace Spaces
-
-1. Create a new Space on [HuggingFace](https://huggingface.co/spaces)
-2. Select "Gradio" as the SDK
-3. Upload the files from this directory:
-   - `app.py`
-   - `requirements.txt`
-   - `README.md`
-4. The model will load automatically on startup
-
-## 💻 Usage
-
-### Example Prompts
-
-```
-Hello! What can you help me with?
-Check git status of this repository
-Search for best practices for Python async programming
-List the files in the current directory
-Write a simple Python function to calculate fibonacci
-How do I use Git to create a new branch?
-What's your memory of our conversation?
-```
-
-### Python API
-
-```python
-from app import StackModel, memory
-
-# Initialize model
-model = StackModel()
-model.load()
-
-# Generate response
-response = model.generate("Write a hello world in Python")
-print(response)
-
-# Check memory stats
-print(memory.get_stats())
-```
-
-## 🔐 Environment Variables
-
-- `HF_TOKEN` - Your HuggingFace token for private models (optional)
-- `MODEL_ID` - Override default model (default: Qwen/Qwen2.5-Coder-7B-Instruct)
-
-## 📊 Memory System
-
-Stack 2.9 includes a pattern memory system that:
-
-1. **Tracks Interactions** - Records every user-assistant exchange
-2. **Learns Patterns** - Identifies frequently used tools
-3. **Stores Code** - Saves useful code snippets
-4. **Adapts Behavior** - Uses learned context to improve responses
-
-## 🛠️ Tech Stack
-
-- **Model**: Qwen2.5-Coder-7B-Instruct
-- **Quantization**: 4-bit (bitsandbytes)
-- **Framework**: Gradio 4.0+
-- **Backend**: Transformers + Accelerate
-- **GPU**: 16GB VRAM recommended
-
-## 📝 License
-
-MIT License - see LICENSE file for details.
-
-## 🙏 Acknowledgments
-
-- [Qwen](https://github.com/QwenLM/Qwen) - Base model
-- [HuggingFace](https://huggingface.co/) - Spaces hosting
-- [Gradio](https://gradio.app/) - UI framework
-
----
-
-<div align="center">
-
-Made with ❤️ by Stack 2.9
-
-</div>

space/app.py

@@ -1,600 +0,0 @@
-"""
-Stack 2.9 - Pattern-Based AI Coding Assistant
-HuggingFace Spaces Demo
-
-A Gradio interface for Stack 2.9 powered by Qwen2.5-Coder-7B
-with tool integration and pattern memory.
-"""
-
-import os
-import json
-import time
-from datetime import datetime
-from typing import List, Dict, Optional
-import gradio as gr
-
-# ============================================================
-# Pattern Memory System
-# ============================================================
-
-class SelfEvolutionMemory:
-    """Simple in-memory pattern memory system for demo purposes."""
-    
-    def __init__(self):
-        self.conversations = []
-        self.learned_patterns = {}
-        self.code_snippets = []
-        self.preferences = {}
-        self.interaction_count = 0
-    
-    def add_interaction(self, user_input: str, assistant_response: str, tools_used: List[str] = None):
-        """Record an interaction for learning."""
-        self.interaction_count += 1
-        interaction = {
-            "timestamp": datetime.now().isoformat(),
-            "user_input": user_input,
-            "assistant_response": assistant_response,
-            "tools_used": tools_used or [],
-            "interaction_id": self.interaction_count
-        }
-        self.conversations.append(interaction)
-        
-        # Extract patterns from the interaction
-        self._learn_from_interaction(user_input, assistant_response, tools_used or [])
-    
-    def _learn_from_interaction(self, user_input: str, response: str, tools: List[str]):
-        """Learn patterns from interactions."""
-        # Track tool usage patterns
-        for tool in tools:
-            if tool not in self.learned_patterns:
-                self.learned_patterns[tool] = {"count": 0, "contexts": []}
-            self.learned_patterns[tool]["count"] += 1
-            self.learned_patterns[tool]["contexts"].append(user_input[:100])
-        
-        # Extract code snippets if present
-        if "```" in response:
-            self.code_snippets.append({
-                "timestamp": datetime.now().isoformat(),
-                "snippet": response
-            })
-    
-    def get_context(self) -> str:
-        """Get accumulated context for the model."""
-        context_parts = [f"## Pattern Memory ({self.interaction_count} interactions)"]
-        
-        if self.learned_patterns:
-            context_parts.append("\n### Tool Usage Patterns:")
-            for tool, data in sorted(self.learned_patterns.items(), key=lambda x: x[1]["count"], reverse=True)[:5]:
-                context_parts.append(f"- {tool}: used {data['count']} times")
-        
-        if self.code_snippets:
-            context_parts.append(f"\n### Learned {len(self.code_snippets)} code patterns")
-        
-        return "\n".join(context_parts)
-    
-    def get_stats(self) -> Dict:
-        """Get memory statistics."""
-        return {
-            "total_interactions": self.interaction_count,
-            "tool_patterns": len(self.learned_patterns),
-            "code_snippets": len(self.code_snippets),
-            "recent_tools": [t for t in self.learned_patterns.keys()][:5]
-        }
-
-
-# Global memory instance
-memory = SelfEvolutionMemory()
-
-# ============================================================
-# Tool System
-# ============================================================
-
-class Tool:
-    """Base tool class."""
-    
-    def __init__(self, name: str, description: str, func):
-        self.name = name
-        self.description = description
-        self.func = func
-    
-    async def execute(self, *args, **kwargs):
-        return await self.func(*args, **kwargs)
-
-
-# Tool implementations (simplified for demo)
-async def tool_file_read(path: str) -> str:
-    """Read a file."""
-    try:
-        with open(path, 'r') as f:
-            return f.read()[:5000]  # Limit output
-    except FileNotFoundError:
-        return f"File not found: {path}"
-    except Exception as e:
-        return f"Error reading file: {str(e)}"
-
-
-async def tool_file_write(path: str, content: str) -> str:
-    """Write to a file."""
-    try:
-        os.makedirs(os.path.dirname(path) if os.path.dirname(path) else ".", exist_ok=True)
-        with open(path, 'w') as f:
-            f.write(content)
-        return f"Successfully wrote to {path}"
-    except Exception as e:
-        return f"Error writing file: {str(e)}"
-
-
-async def tool_git_status() -> str:
-    """Get git status."""
-    import subprocess
-    try:
-        result = subprocess.run(["git", "status", "--short"], capture_output=True, text=True, cwd=os.getcwd())
-        return result.stdout or "No changes"
-    except Exception as e:
-        return f"Git error: {str(e)}"
-
-
-async def tool_web_search(query: str) -> str:
-    """Search the web."""
-    from urllib.parse import quote
-    # Return a demo response since we can't make actual API calls
-    return f"🔍 Search results for '{query}':\n\n1. [Result 1] - Description here\n2. [Result 2] - Description here\n3. [Result 3] - Description here\n\n(Install brave-search to enable real search)"
-
-
-async def tool_run_command(cmd: str) -> str:
-    """Run a shell command."""
-    import subprocess
-    try:
-        result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=30)
-        return f"Output:\n{result.stdout}\n\nErrors:\n{result.stderr}" if result.stderr else result.stdout
-    except Exception as e:
-        return f"Command error: {str(e)}"
-
-
-async def tool_create_directory(path: str) -> str:
-    """Create a directory."""
-    try:
-        os.makedirs(path, exist_ok=True)
-        return f"Directory created: {path}"
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-
-async def tool_list_directory(path: str = ".") -> str:
-    """List directory contents."""
-    try:
-        items = os.listdir(path)
-        return "\n".join([f"📁 {i}/" if os.path.isdir(os.path.join(path, i)) else f"📄 {i}" for i in items[:50]])
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-
-# Register tools
-TOOLS = {
-    "file_read": Tool("file_read", "Read a file from the filesystem", tool_file_read),
-    "file_write": Tool("file_write", "Write content to a file", tool_file_write),
-    "git_status": Tool("git_status", "Check git repository status", tool_git_status),
-    "web_search": Tool("web_search", "Search the web for information", tool_web_search),
-    "run_command": Tool("run_command", "Execute a shell command", tool_run_command),
-    "create_directory": Tool("create_directory", "Create a new directory", tool_create_directory),
-    "list_directory": Tool("list_directory", "List files in a directory", tool_list_directory),
-}
-
-
-def get_tool_descriptions() -> str:
-    """Get descriptions of all available tools."""
-    return "\n".join([f"- **{t.name}**: {t.description}" for t in TOOLS.values()])
-
-
-# ============================================================
-# Model Interface
-# ============================================================
-
-class StackModel:
-    """Stack 2.9 model interface using transformers."""
-    
-    def __init__(self, model_id: str = "Qwen/Qwen2.5-Coder-7B-Instruct"):
-        self.model_id = model_id
-        self.model = None
-        self.tokenizer = None
-        self.pipeline = None
-    
-    def load(self):
-        """Load the model with 4-bit quantization for HF Spaces."""
-        from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
-        import torch
-        
-        print(f"Loading {self.model_id}...")
-        
-        # 4-bit quantization config for 16GB GPU
-        bnb_config = BitsAndBytesConfig(
-            load_in_4bit=True,
-            bnb_4bit_compute_dtype=torch.float16,
-            bnb_4bit_use_double_quant=True,
-            bnb_4bit_quant_type="nf4"
-        )
-        
-        # Load tokenizer
-        self.tokenizer = AutoTokenizer.from_pretrained(
-            self.model_id,
-            trust_remote_code=True
-        )
-        
-        # Load model with quantization
-        self.model = AutoModelForCausalLM.from_pretrained(
-            self.model_id,
-            quantization_config=bnb_config,
-            device_map="auto",
-            trust_remote_code=True
-        )
-        
-        print("Model loaded successfully!")
-    
-    def generate(self, prompt: str, max_tokens: int = 512, temperature: float = 0.7) -> str:
-        """Generate a response."""
-        if not self.tokenizer:
-            return "Model not loaded. Please wait for initialization."
-        
-        # Build the prompt with system and tools
-        system_prompt = f"""You are Stack 2.9 - a pattern-based AI coding assistant.
-
-## Available Tools
-{get_tool_descriptions()}
-
-## Your Capabilities
-- Write, read, and execute code
-- Use git for version control
-- Search the web for information
-- Create and manage files
-- Execute shell commands
-
-## Self-Evolution
-You learn from each interaction. After responding, summarize what tools you used.
-
-{memory.get_context()}
-
-## Instructions
-1. Be helpful and concise
-2. Use tools when needed
-3. Learn from the conversation
-4. Provide code examples when relevant
-
-Now respond to the user:"""
-
-        full_prompt = f"{system_prompt}\n\nUser: {prompt}\n\nAssistant:"
-        
-        # Tokenize
-        inputs = self.tokenizer(full_prompt, return_tensors="pt").to(self.model.device)
-        
-        # Generate
-        outputs = self.model.generate(
-            **inputs,
-            max_new_tokens=max_tokens,
-            temperature=temperature,
-            do_sample=True,
-            top_p=0.9,
-            repetition_penalty=1.1
-        )
-        
-        # Decode
-        response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
-        
-        # Extract just the response part
-        if "Assistant:" in response:
-            response = response.split("Assistant:")[-1].strip()
-        
-        return response
-    
-    def generate_streaming(self, prompt: str, max_tokens: int = 512):
-        """Generate with streaming (yields tokens)."""
-        if not self.tokenizer:
-            yield "Model not loaded. Please wait for initialization."
-            return
-        
-        system_prompt = f"""You are Stack 2.9 - a pattern-based AI coding assistant.
-
-## Available Tools
-{get_tool_descriptions()}
-
-## Self-Evolution Memory
-{memory.get_context()}
-
-Now respond to the user:"""
-
-        full_prompt = f"{system_prompt}\n\nUser: {prompt}\n\nAssistant:"
-        
-        inputs = self.tokenizer(full_prompt, return_tensors="pt").to(self.model.device)
-        
-        # Generate token by token
-        from transformers import GenerationMixin
-        from typing import Iterator
-        
-        generated_ids = inputs.input_ids
-        
-        for _ in range(max_tokens):
-            with torch.no_grad():
-                outputs = self.model(generated_ids)
-                next_token_logits = outputs.logits[:, -1, :]
-                
-                # Apply temperature
-                next_token_logits = next_token_logits / 0.7
-                
-                # Sample
-                probs = torch.softmax(next_token_logits, dim=-1)
-                next_token = torch.multinomial(probs, num_samples=1)
-                
-                generated_ids = torch.cat([generated_ids, next_token], dim=-1)
-                
-                # Decode and yield
-                token_str = self.tokenizer.decode(next_token[0], skip_special_tokens=True)
-                yield token_str
-                
-                # Stop on EOS
-                if next_token.item() == self.tokenizer.eos_token_id:
-                    break
-
-
-# Global model instance
-model = None
-
-
-def initialize_model():
-    """Initialize the model on startup."""
-    global model
-    try:
-        model = StackModel()
-        model.load()
-        return model
-    except Exception as e:
-        print(f"Failed to load model: {e}")
-        return None
-
-
-# ============================================================
-# Gradio Interface
-# ============================================================
-
-def format_tools_used(tools_used: List[str]) -> str:
-    """Format the tools used for display."""
-    if not tools_used:
-        return ""
-    return f"\n\n🔧 **Tools Used**: {', '.join(tools_used)}"
-
-
-def chat_response(message: str, history: List[List[str]]) -> tuple:
-    """Process a chat message and return response."""
-    global model, memory
-    
-    if model is None or model.model is None:
-        return "⏳ Model is loading. Please wait...", history + [[message, "⏳ Model is loading. Please wait..."]]
-    
-    # Track tools used
-    tools_used = []
-    
-    # Check if we need to use tools based on the message
-    message_lower = message.lower()
-    
-    if any(kw in message_lower for kw in ['git status', 'git']):
-        tools_used.append("git_status")
-    if any(kw in message_lower for kw in ['search', 'find', 'look up']):
-        tools_used.append("web_search")
-    if any(kw in message_lower for kw in ['list files', 'directory', 'ls']):
-        tools_used.append("list_directory")
-    if any(kw in message_lower for kw in ['run ', 'execute', 'command']):
-        tools_used.append("run_command")
-    
-    # Generate response
-    try:
-        response = model.generate(message, max_tokens=512)
-    except Exception as e:
-        response = f"I encountered an error: {str(e)}"
-    
-    # Add tools used to response
-    response += format_tools_used(tools_used)
-    
-    # Record in memory
-    memory.add_interaction(message, response, tools_used)
-    
-    return response
-
-
-def chat_response_stream(message: str, history: List[List[str]]) -> Generator:
-    """Process a chat message with streaming."""
-    global model, memory
-    
-    if model is None or model.model is None:
-        yield "⏳ Model is loading. Please wait..."
-        return
-    
-    full_response = ""
-    tools_used = []
-    
-    message_lower = message.lower()
-    if any(kw in message_lower for kw in ['git status', 'git']):
-        tools_used.append("git_status")
-    if any(kw in message_lower for kw in ['search', 'find']):
-        tools_used.append("web_search")
-    if any(kw in message_lower for kw in ['list', 'directory']):
-        tools_used.append("list_directory")
-    
-    # Stream the response
-    for token in model.generate_streaming(message, max_tokens=256):
-        full_response += token
-        yield full_response
-    
-    # Add tools used
-    if tools_used:
-        full_response += format_tools_used(tools_used)
-        yield full_response
-    
-    # Record in memory
-    memory.add_interaction(message, full_response, tools_used)
-
-
-# Example prompts for the UI
-EXAMPLE_PROMPTS = [
-    "Hello! What can you help me with?",
-    "Check git status of this repository",
-    "Search for best practices for Python async programming",
-    "List the files in the current directory",
-    "Write a simple Python function to calculate fibonacci",
-    "How do I use Git to create a new branch?",
-    "What's your memory of our conversation?",
-]
-
-
-def create_gradio_app():
-    """Create the Gradio interface."""
-    
-    with gr.Blocks(
-        title="Stack 2.9 - Pattern-Based AI Coding Assistant",
-        theme=gr.themes.Soft(
-            primary_color="#6366f1",
-            secondary_color="#818cf8",
-            tertiary_color="#a5b4fc"
-        )
-    ) as app:
-        
-        # Header
-        gr.Markdown("""
-        # 🚀 Stack 2.9 - Pattern-Based AI Coding Assistant
-        
-        Powered by **Qwen2.5-Coder-7B** with 4-bit quantization
-        
-        ---
-        """)
-        
-        # Memory stats display
-        with gr.Row():
-            with gr.Column(scale=1):
-                stats_display = gr.Markdown(
-                    "📊 **Memory Stats**\n\n- Interactions: 0\n- Tools learned: 0\n- Code patterns: 0",
-                    elem_id="stats"
-                )
-            with gr.Column(scale=3):
-                pass  # Spacer
-        
-        # Chat interface
-        chatbot = gr.Chatbot(
-            height=500,
-            show_copy_button=True,
-            bubble_full_width=False
-        )
-        
-        with gr.Row():
-            msg = gr.Textbox(
-                label="Message",
-                placeholder="Ask me anything...",
-                scale=4,
-                lines=3
-            )
-            submit_btn = gr.Button("Send", variant="primary", scale=1)
-        
-        # Clear button
-        with gr.Row():
-            clear_btn = gr.Button("🗑️ Clear Chat")
-        
-        # Example prompts
-        gr.Examples(
-            examples=EXAMPLE_PROMPTS,
-            inputs=msg,
-            label="Example Prompts"
-        )
-        
-        # Memory visualization
-        with gr.Accordion("🧠 Self-Evolution Memory", open=False):
-            memory_display = gr.Textbox(
-                label="Memory Content",
-                lines=10,
-                interactive=False
-            )
-        
-        # Functions
-        def respond(message, history):
-            response = chat_response(message, history)
-            history.append([message, response])
-            return "", history
-        
-        def update_stats():
-            stats = memory.get_stats()
-            return f"""📊 **Memory Stats**
-
-- **Interactions**: {stats['total_interactions']}
-- **Tool Patterns**: {stats['tool_patterns']}
-- **Code Snippets**: {stats['code_snippets']}
-
-**Recent Tools**: {', '.join(stats['recent_tools']) if stats['recent_tools'] else 'None'}"""
-        
-        def update_memory():
-            return memory.get_context()
-        
-        # Button click handlers
-        submit_btn.click(respond, [msg, chatbot], [msg, chatbot], api_name="send")
-        msg.submit(respond, [msg, chatbot], [msg, chatbot], api_name="send")
-        
-        def clear_chat():
-            return [], ""
-        
-        clear_btn.click(lambda: ([], ""), outputs=[chatbot, msg])
-        
-        # Update stats periodically
-        chatbot.change(update_stats, outputs=[stats_display])
-        chatbot.change(update_memory, outputs=[memory_display])
-        
-        # Footer
-        gr.Markdown("""
-        ---
-        ### About Stack 2.9
-        
-        Stack 2.9 is a pattern-based AI coding assistant that:
-        - 🔍 Uses **Qwen2.5-Coder-7B** (4-bit, ~4GB VRAM)
-        - 🛠️ Integrates **7 tools** (file, git, web, search, shell)
-        - 🧠 Remembers interactions and learns patterns
-        - ⚡ Provides fast, streaming responses
-        
-        Deployed on **HuggingFace Spaces** with Gradio
-        """)
-    
-    return app
-
-
-# ============================================================
-# Main Entry Point
-# ============================================================
-
-if __name__ == "__main__":
-    import argparse
-    
-    parser = argparse.ArgumentParser(description="Stack 2.9 - HuggingFace Spaces Demo")
-    parser.add_argument("--share", action="store_true", help="Create a public share link")
-    parser.add_argument("--port", type=int, default=7860, help="Port to run on")
-    parser.add_argument("--model", type=str, default="Qwen/Qwen2.5-Coder-7B-Instruct", help="Model ID")
-    args = parser.parse_args()
-    
-    print("=" * 50)
-    print("🚀 Stack 2.9 - Pattern-Based AI Coding Assistant")
-    print("=" * 50)
-    print(f"Model: {args.model}")
-    print("Loading model...")
-    
-    # Initialize model in a thread
-    import threading
-    
-    def load_model_thread():
-        global model
-        model = initialize_model()
-    
-    loader_thread = threading.Thread(target=load_model_thread)
-    loader_thread.start()
-    
-    # Create and launch app
-    app = create_gradio_app()
-    
-    print(f"\n🚀 Launching Gradio on port {args.port}...")
-    print("📝 Note: Model loads in background. Chat will work once loaded.\n")
-    
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=args.port,
-        share=args.share
-    )

space/requirements.txt

@@ -1,24 +0,0 @@
-# Stack 2.9 - HuggingFace Spaces Demo
-# Requirements for Gradio interface with Qwen2.5-Coder-7B
-
-# Core Gradio
-gradio>=4.0.0
-
-# Transformers and model loading
-transformers>=4.36.0
-torch>=2.0.0
-
-# Model optimization
-accelerate>=0.24.0
-bitsandbytes>=0.41.0
-
-# Additional utilities
-huggingface-hub>=0.19.0
-safetensors>=0.4.0
-
-# Optional: For better web search
-# brave-search>=0.1.0
-
-# Optional: For web fetching
-# beautifulsoup4>=4.12.0
-# lxml>=4.9.0

stack-2.9-deploy/Dockerfile

@@ -1,107 +1,37 @@
-# Multi-stage production Docker image for Stack 2.9
-# Stack 2.9 LLM Inference Server with vLLM
+# Stack 2.9 HuggingFace Spaces Dockerfile
+# Optimized for 16GB GPU with 4-bit quantization
 
-ARG PYTHON_VERSION=3.10
-ARG VLLM_VERSION=0.6.3
-ARG CUDA_VERSION=12.1.0
-ARG BASE_IMAGE=nvidia/cuda:${CUDA_VERSION}-devel-ubuntu22.04
-
-# Stage 1: Builder
-FROM ${BASE_IMAGE} AS builder
-
-ARG PYTHON_VERSION
-ARG VLLM_VERSION
-
-# Set environment variables
-ENV DEBIAN_FRONTEND=noninteractive \
-    TZ=UTC \
-    PYTHONUNBUFFERED=1 \
-    PIP_NO_CACHE_DIR=1
-
-# Install system dependencies and Python
-RUN apt-get update && apt-get install -y \
-    python${PYTHON_VERSION} \
-    python${PYTHON_VERSION}-dev \
-    python3-pip \
-    git \
-    curl \
-    wget \
-    build-essential \
-    cmake \
-    && rm -rf /var/lib/apt/lists/*
-
-# Install PyTorch with CUDA 12.1 support
-RUN pip3 install --upgrade pip setuptools wheel
-RUN pip3 install torch==2.3.1 torchvision==0.18.1 torchaudio==2.3.1 --index-url https://download.pytorch.org/whl/cu121
-
-# Install vLLM
-RUN pip3 install vllm==${VLLM_VERSION} "vllm[attention]"
-
-# Install additional dependencies
-RUN pip3 install \
-    fastapi==0.111.0 \
-    uvicorn[standard]==0.30.1 \
-    transformers==4.41.2 \
-    accelerate==0.30.1 \
-    huggingface-hub==0.23.0 \
-    sentencepiece==0.2.0 \
-    protobuf==3.20.3
-
-# Stage 2: Runtime
-FROM nvidia/cuda:${CUDA_VERSION}-runtime-ubuntu22.04
-
-ARG PYTHON_VERSION
-ARG VLLM_VERSION
+FROM python:3.10-slim
 
 # Set environment variables
-ENV DEBIAN_FRONTEND=noninteractive \
-    TZ=UTC \
-    PYTHONUNBUFFERED=1 \
-    PIP_NO_CACHE_DIR=1 \
-    NVIDIA_VISIBLE_DEVICES=all \
-    NVIDIA_DRIVER_CAPABILITIES=compute,utility \
-    VLLM_USE_MODELSCOPE=false \
-    HF_HUB_DISABLE_TELEMETRY=1 \
-    HF_HUB_ENABLE_HF_TRANSFER=1
+ENV PYTHONUNBUFFERED=1
+ENV TRANSFORMERS_CACHE=/workspace/.cache/huggingface
+ENV HF_HOME=/workspace/.cache/huggingface
 
-# Install Python and minimal dependencies
+# Install system dependencies
 RUN apt-get update && apt-get install -y \
-    python${PYTHON_VERSION} \
-    python${PYTHON_VERSION}-dev \
-    python3-pip \
     git \
-    curl \
     wget \
-    libgomp1 \
     && rm -rf /var/lib/apt/lists/*
 
-# Copy Python packages from builder
-COPY --from=builder /usr/local/lib/python${PYTHON_VERSION}/dist-packages /usr/local/lib/python${PYTHON_VERSION}/dist-packages
-COPY --from=builder /usr/local/bin /usr/local/bin
-
-# Create non-root user
-RUN groupadd -r vllm && useradd -r -g vllm -d /home/vllm -m vllm
-
-# Set working directory
-WORKDIR /app
+# Create workspace directory
+WORKDIR /workspace
 
-# Copy application code
-COPY --chown=vllm:vllm app.py .
-COPY --chown=vllm:vllm requirements.txt .
-COPY --chown=vllm:vllm config.yaml .
+# Copy requirements first for better caching
+COPY requirements.txt .
 
-# Create model cache directory
-RUN mkdir -p /home/vllm/.cache/huggingface && chown -R vllm:vllm /home/vllm/.cache
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
 
-# Expose port for vLLM server
-EXPOSE 8000
+# Copy application files
+COPY . .
 
-# Health check
-HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
-    CMD curl -f http://localhost:8000/health || exit 1
+# Expose Gradio port
+EXPOSE 7860
 
-# Switch to non-root user
-USER vllm
+# Create startup script
+RUN echo '#!/bin/bash\necho "🚀 Starting Stack 2.9..."\npython app.py --port 7860 --share' > /start.sh
+RUN chmod +x /start.sh
 
-# Run vLLM server
-CMD ["python3", "app.py"]
+# Launch command
+CMD ["/start.sh"]

stack-2.9-deploy/README.md

@@ -1,346 +1,124 @@
-# Stack 2.9 Deployment Infrastructure
+# 🚀 Stack 2.9 - Pattern-Based AI Coding Assistant
 
-Turnkey deployment configurations for Stack 2.9 LLM inference server.
+A HuggingFace Spaces demo for Stack 2.9, a pattern-based AI coding assistant powered by Qwen2.5-Coder-7B.
 
-## 📋 Prerequisites
+![License](https://img.shields.io/badge/license-MIT-blue.svg)
+![Python](https://img.shields.io/badge/python-3.10+-green.svg)
+![Gradio](https://img.shields.io/badge/Gradio-4.0+-orange.svg)
 
-- **Linux/macOS** shell environment
-- For local deployment: **Docker** + **NVIDIA GPU** (optional but recommended)
-- For cloud: **runpodctl** or **vastai** CLI installed
-- **chmod +x** may be required on shell scripts
+## ✨ Features
 
-## 🖥️ System Requirements
+- **🤖 Qwen2.5-Coder-7B** - State-of-the-art code generation model
+- **🔧 7 Integrated Tools** - File operations, git, web search, shell commands
+- **🧠 Pattern Memory** - Learns from each interaction
+- **⚡ Fast Streaming** - Real-time token-by-token generation
+- **💾 4-bit Quantization** - Runs on 16GB GPU (~4GB VRAM)
 
-Stack 2.9 deployment requires appropriate hardware depending on model size:
+## 🔧 Available Tools
 
-| Configuration | Minimum | Recommended | Production |
-|---------------|---------|-------------|------------|
-| **GPU VRAM** | 8GB | 24GB | 40-80GB (A100/H100) |
-| **RAM** | 16GB | 32GB | 64GB+ |
-| **Disk** | 20GB free | 50GB free | 100GB+ (NVMe) |
-| **CUDA** | 11.8 | 12.1 | 12.1+ |
-| **Models** | 7B quantized | 32B quantized | 70B+ quantized |
+| Tool | Description |
+|------|-------------|
+| `file_read` | Read files from the filesystem |
+| `file_write` | Write content to files |
+| `git_status` | Check git repository status |
+| `web_search` | Search the web for information |
+| `run_command` | Execute shell commands |
+| `create_directory` | Create new directories |
+| `list_directory` | List directory contents |
 
-**Notes:**
-- CPU-only mode is possible but extremely slow (not recommended for production)
-- AWQ/GPTQ quantization reduces VRAM requirements by ~50%
-- Multi-GPU (tensor parallelism) supported via `TENSOR_PARALLEL_SIZE`
+## 🏃‍♂️ Quick Start
 
-## 🧪 Validate Setup
-
-## 🧪 Validate Setup
-
-Before deploying, run the validation script to ensure everything is ready:
-
-```bash
-./validate.sh
-```
-This checks Docker, GPU, and all required files.
-
-## 🚀 Quick Start
-
-### Local Deployment (Docker Compose)
-
-```bash
-# Ensure deploy.sh is executable
-chmod +x deploy.sh validate.sh
-
-# Deploy
-./deploy.sh local --model TheBloke/Llama-2-7B-Chat-AWQ
-```
-
-The server will start at `http://localhost:8000`
-
-### Cloud Deployments
-
-```bash
-# RunPod
-./deploy.sh runpod --gpu A100-40GB
-
-# Vast.ai
-./deploy.sh vastai
-
-# Kubernetes
-./deploy.sh kubernetes --namespace inference
-```
-
----
-
-## 📦 What's Included
-
-```
-stack-2.9-deploy/
-├── Dockerfile                 # Multi-stage production image
-├── docker-compose.yaml        # Local orchestration
-├── deploy.sh                  # One-command deployment script
-├── runpod-template.json       # RunPod.io template
-├── vastai-template.json       # Vast.ai template
-├── kubernetes/               # K8s manifests
-│   ├── deployment.yaml       # GPU-enabled deployment
-│   ├── service.yaml          # LoadBalancer service
-│   ├── pvc.yaml              # Model cache volume
-│   ├── hpa.yaml              # Autoscaling configuration
-│   └── secrets.yaml          # Secrets template
-├── app.py                     # vLLM server wrapper
-└── README.md                  # This file
-```
-
----
-
-## 🐳 Docker Image
-
-**Base:** `nvidia/cuda:12.1-runtime-ubuntu22.04`
-**Python:** 3.10
-**vLLM:** 0.6.3
-**CUDA:** 12.1
-
-### Features:
-- Multi-stage build for minimal footprint
-- Non-root user (`vllm`)
-- Health checks
-- CUDA 12.1 runtime
-- Model cache persistence
-- AWQ 4-bit quantization support
-
----
-
-## 🔧 Environment Variables
-
-| Variable | Default | Description |
-|----------|---------|-------------|
-| `MODEL_ID` | `TheBloke/Llama-2-7B-Chat-AWQ` | Hugging Face model ID |
-| `HUGGING_FACE_TOKEN` | (empty) | HF token for gated models |
-| `QUANTIZATION` | `awq` | Quantization method |
-| `TENSOR_PARALLEL_SIZE` | `1` | Number of GPUs |
-| `GPU_MEMORY_UTILIZATION` | `0.9` | GPU memory fraction |
-| `MAX_MODEL_LEN` | `4096` | Max sequence length |
-| `MAX_NUM_SEQS` | `64` | Max batch size |
-| `PORT` | `8000` | Server port |
-
----
-
-## 🌐 API Endpoints
-
-Stack 2.9 provides OpenAI-compatible endpoints:
-
-- `POST /v1/completions` - Text completion
-- `POST /v1/chat/completions` - Chat completion
-- `GET /health` - Health check
-- `GET /metrics` - Prometheus metrics
-- `GET /docs` - Interactive API docs
-
-### Example Usage
-
-```bash
-# Chat completion
-curl http://localhost:8000/v1/chat/completions \
-  -H "Content-Type: application/json" \
-  -d '{
-    "model": "stack-2.9",
-    "messages": [{"role": "user", "content": "Hello!"}],
-    "max_tokens": 100
-  }'
-```
-
----
-
-## ☁️ Platform-Specific Notes
-
-### Local (Docker Compose)
-
-```bash
-# Build and start
-./deploy.sh local --model <model-id>
-
-# View logs
-docker-compose logs -f stack-2.9
-
-# Stop
-docker-compose down
-```
-
-**Requirements:**
-- Docker 20.10+
-- Docker Compose v2
-- NVIDIA GPU (recommended) with CUDA 12.x drivers
-
----
-
-### RunPod
-
-1. Authenticate: `runpodctl login`
-2. Run: `./deploy.sh runpod --gpu A100-40GB`
-3. Provide your Docker registry
-4. Deploy from the created template on RunPod.io
-
-**Recommended GPUs:**
-- A100 40GB (default)
-- A100 80GB
-- H100 80GB
-
-**Auto-sleep:** Enabled after 30 minutes of inactivity
-
----
-
-### Vast.ai
-
-1. Install vastai CLI
-2. Run: `./deploy.sh vastai`
-3. Provide your Docker registry
-4. Launch via template or CLI
-
-**Recommended Instances:**
-- RTX 4090 (24GB) - $0.30-0.50/hr
-- RTX 6000 Ada (48GB) - $0.80-1.20/hr
-- A100 40GB - $0.90-1.50/hr
-
-**SSH Access:** Available on forwarded port 2222
-
----
-
-### Kubernetes
-
-#### Prerequisites:
-- kubectl configured
-- GPU-enabled cluster (NVIDIA GPUs with device plugin)
-- Storage class with ReadWriteMany capability
-
-#### Deployment:
+### Local Development
 
 ```bash
-# Create namespace
-kubectl apply -f kubernetes/secrets.yaml
+# Clone the repository
+git clone https://github.com/your-repo/stack-2.9.git
+cd stack-2.9/space
 
-# Set your HF token
-kubectl create secret generic stack-2.9-secrets \
-  --from-literal=huggingface-token='YOUR_TOKEN' \
-  -n stack-2.9
+# Install dependencies
+pip install -r requirements.txt
 
-# Deploy
-./deploy.sh kubernetes --namespace stack-2.9
-
-# Or manually:
-kubectl apply -f kubernetes/
+# Run the demo
+python app.py --share
 ```
 
-**Check status:**
-```bash
-kubectl get pods,svc,pvc,hpa -n stack-2.9
-kubectl logs -f deployment/stack-2.9 -n stack-2-9
-```
+### HuggingFace Spaces
 
-**Get service URL:**
-```bash
-kubectl get svc stack-2.9 -n stack-2-9 -o wide
-```
-
----
+1. Create a new Space on [HuggingFace](https://huggingface.co/spaces)
+2. Select "Gradio" as the SDK
+3. Upload the files from this directory:
+   - `app.py`
+   - `requirements.txt`
+   - `README.md`
+4. The model will load automatically on startup
 
-## ⚙️ Customization
+## 💻 Usage
 
-### Different Model
+### Example Prompts
 
-```bash
-./deploy.sh local --model mistralai/Mistral-7B-Instruct-v0.2
 ```
-
-Supported formats:
-- AWQ quantized: `TheBloke/*-AWQ`
-- GPTQ quantized: `TheBloke/*-GPTQ`
-- Full precision: Any Hugging Face model
-
-### GPU Configuration
-
-Edit `docker-compose.yaml` or K8s deployment:
-
-```yaml
-resources:
-  limits:
-    nvidia.com/gpu: 2  # Multi-GPU
-  requests:
-    memory: "24Gi"
-    cpu: "8"
+Hello! What can you help me with?
+Check git status of this repository
+Search for best practices for Python async programming
+List the files in the current directory
+Write a simple Python function to calculate fibonacci
+How do I use Git to create a new branch?
+What's your memory of our conversation?
 ```
 
----
+### Python API
 
-## 🧪 Testing
+```python
+from app import StackModel, memory
 
-```bash
-# Health check
-curl http://localhost:8000/health
+# Initialize model
+model = StackModel()
+model.load()
 
-# API docs
-open http://localhost:8000/docs
+# Generate response
+response = model.generate("Write a hello world in Python")
+print(response)
 
-# Test inference
-curl http://localhost:8000/v1/completions \
-  -H "Content-Type: application/json" \
-  -d '{"prompt": "Once upon a time", "max_tokens": 50}'
+# Check memory stats
+print(memory.get_stats())
 ```
 
----
-
-## 🐛 Troubleshooting
-
-### GPU not detected
-```bash
-# Check NVIDIA drivers
-nvidia-smi
-
-# Ensure NVIDIA Container Toolkit
-docker info | grep -i runtime
-```
-
-### Out of memory
-Reduce `GPU_MEMORY_UTILIZATION` to `0.7` or `0.8`
-
-### Slow first request
-First request downloads/loads the model (~5-10 min for 7B). This is cached for subsequent requests.
+## 🔐 Environment Variables
 
-### Model download failures
-Ensure `HUGGING_FACE_TOKEN` is set for gated models or large files.
+- `HF_TOKEN` - Your HuggingFace token for private models (optional)
+- `MODEL_ID` - Override default model (default: Qwen/Qwen2.5-Coder-7B-Instruct)
 
----
+## 📊 Memory System
 
-## 📊 Monitoring
+Stack 2.9 includes a pattern memory system that:
 
-### Metrics Endpoint
-`GET /metrics` - Basic server metrics
+1. **Tracks Interactions** - Records every user-assistant exchange
+2. **Learns Patterns** - Identifies frequently used tools
+3. **Stores Code** - Saves useful code snippets
+4. **Adapts Behavior** - Uses learned context to improve responses
 
-### Docker Metrics
-```bash
-docker stats stack-2.9-server
-```
+## 🛠️ Tech Stack
 
-### Kubernetes Metrics
-```bash
-kubectl top pod stack-2.9 -n stack-2-9
-kubectl get hpa -n stack-2-9
-```
-
----
+- **Model**: Qwen2.5-Coder-7B-Instruct
+- **Quantization**: 4-bit (bitsandbytes)
+- **Framework**: Gradio 4.0+
+- **Backend**: Transformers + Accelerate
+- **GPU**: 16GB VRAM recommended
 
-## 🔒 Security
-
-- Runs as non-root user (`vllm`)
-- Dropped capabilities
-- Read-only filesystem (except cache)
-- Health checks for liveness/readiness
-- Secrets via Kubernetes secrets or env file
+## 📝 License
 
----
+MIT License - see LICENSE file for details.
 
-## 📝 License
+## 🙏 Acknowledgments
 
-Same as Stack 2.9 project license.
+- [Qwen](https://github.com/QwenLM/Qwen) - Base model
+- [HuggingFace](https://huggingface.co/) - Spaces hosting
+- [Gradio](https://gradio.app/) - UI framework
 
 ---
 
-## 🤝 Support
-
-Issues: Report to Stack 2.9 repository
+<div align="center">
 
----
+Made with ❤️ by Stack 2.9
 
-**Made with ❤️ for turnkey LLM deployment**
+</div>

stack-2.9-deploy/app.py

@@ -1,276 +1,600 @@
-#!/usr/bin/env python3
 """
-Stack 2.9 vLLM Server Entrypoint
-Production-ready LLM inference server with health checks and metrics
+Stack 2.9 - Pattern-Based AI Coding Assistant
+HuggingFace Spaces Demo
+
+A Gradio interface for Stack 2.9 powered by Qwen2.5-Coder-7B
+with tool integration and pattern memory.
 """
 
 import os
-import sys
 import json
-import logging
-from pathlib import Path
-
-from fastapi import FastAPI, Request, HTTPException
-from fastapi.responses import JSONResponse, StreamingResponse
-import uvicorn
-from vllm import LLM, SamplingParams
-from vllm.engine.arg_utils import AsyncEngineArgs
-from huggingface_hub import login
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[logging.StreamHandler(sys.stdout)]
-)
-logger = logging.getLogger("stack-2.9")
-
-# Initialize FastAPI app
-app = FastAPI(
-    title="Stack 2.9 Inference API",
-    description="High-performance LLM inference using vLLM",
-    version="2.9.0"
-)
-
-# Global LLM instance
-llm_instance = None
-
-def get_model_id():
-    """Get model ID from environment or config"""
-    model_id = os.getenv("MODEL_ID")
-    if not model_id:
-        # Default to a quantized model
-        model_id = "TheBloke/Llama-2-7B-Chat-AWQ"
-    return model_id
-
-def get_hf_token():
-    """Get Hugging Face token if provided"""
-    token = os.getenv("HUGGING_FACE_TOKEN") or os.getenv("HF_TOKEN")
-    return token
-
-async def initialize_model():
-    """Initialize the vLLM model"""
-    global llm_instance
-
-    model_id = get_model_id()
-    hf_token = get_hf_token()
-
-    logger.info(f"Initializing model: {model_id}")
-
+import time
+from datetime import datetime
+from typing import List, Dict, Optional
+import gradio as gr
+
+# ============================================================
+# Pattern Memory System
+# ============================================================
+
+class SelfEvolutionMemory:
+    """Simple in-memory pattern memory system for demo purposes."""
+    
+    def __init__(self):
+        self.conversations = []
+        self.learned_patterns = {}
+        self.code_snippets = []
+        self.preferences = {}
+        self.interaction_count = 0
+    
+    def add_interaction(self, user_input: str, assistant_response: str, tools_used: List[str] = None):
+        """Record an interaction for learning."""
+        self.interaction_count += 1
+        interaction = {
+            "timestamp": datetime.now().isoformat(),
+            "user_input": user_input,
+            "assistant_response": assistant_response,
+            "tools_used": tools_used or [],
+            "interaction_id": self.interaction_count
+        }
+        self.conversations.append(interaction)
+        
+        # Extract patterns from the interaction
+        self._learn_from_interaction(user_input, assistant_response, tools_used or [])
+    
+    def _learn_from_interaction(self, user_input: str, response: str, tools: List[str]):
+        """Learn patterns from interactions."""
+        # Track tool usage patterns
+        for tool in tools:
+            if tool not in self.learned_patterns:
+                self.learned_patterns[tool] = {"count": 0, "contexts": []}
+            self.learned_patterns[tool]["count"] += 1
+            self.learned_patterns[tool]["contexts"].append(user_input[:100])
+        
+        # Extract code snippets if present
+        if "```" in response:
+            self.code_snippets.append({
+                "timestamp": datetime.now().isoformat(),
+                "snippet": response
+            })
+    
+    def get_context(self) -> str:
+        """Get accumulated context for the model."""
+        context_parts = [f"## Pattern Memory ({self.interaction_count} interactions)"]
+        
+        if self.learned_patterns:
+            context_parts.append("\n### Tool Usage Patterns:")
+            for tool, data in sorted(self.learned_patterns.items(), key=lambda x: x[1]["count"], reverse=True)[:5]:
+                context_parts.append(f"- {tool}: used {data['count']} times")
+        
+        if self.code_snippets:
+            context_parts.append(f"\n### Learned {len(self.code_snippets)} code patterns")
+        
+        return "\n".join(context_parts)
+    
+    def get_stats(self) -> Dict:
+        """Get memory statistics."""
+        return {
+            "total_interactions": self.interaction_count,
+            "tool_patterns": len(self.learned_patterns),
+            "code_snippets": len(self.code_snippets),
+            "recent_tools": [t for t in self.learned_patterns.keys()][:5]
+        }
+
+
+# Global memory instance
+memory = SelfEvolutionMemory()
+
+# ============================================================
+# Tool System
+# ============================================================
+
+class Tool:
+    """Base tool class."""
+    
+    def __init__(self, name: str, description: str, func):
+        self.name = name
+        self.description = description
+        self.func = func
+    
+    async def execute(self, *args, **kwargs):
+        return await self.func(*args, **kwargs)
+
+
+# Tool implementations (simplified for demo)
+async def tool_file_read(path: str) -> str:
+    """Read a file."""
     try:
-        # Login to Hugging Face if token provided
-        if hf_token:
-            login(token=hf_token)
-
-        # Engine arguments
-        engine_args = AsyncEngineArgs(
-            model=model_id,
-            tokenizer=model_id,
-            tensor_parallel_size=int(os.getenv("TENSOR_PARALLEL_SIZE", 1)),
-            gpu_memory_utilization=float(os.getenv("GPU_MEMORY_UTILIZATION", 0.9)),
-            max_model_len=int(os.getenv("MAX_MODEL_LEN", 4096)),
-            max_num_seqs=int(os.getenv("MAX_NUM_SEQS", 64)),
-            max_num_batched_tokens=int(os.getenv("MAX_NUM_BATCHED_TOKENS", 4096)),
-            disable_log_stats=os.getenv("DISABLE_LOG_STATS", "false").lower() == "true",
-            enforce_eager=os.getenv("ENFORCE_EAGER", "false").lower() == "true",
-            quantization=os.getenv("QUANTIZATION", "awq"),
-            download_dir=os.getenv("MODEL_CACHE_DIR", "/home/vllm/.cache/huggingface"),
-        )
+        with open(path, 'r') as f:
+            return f.read()[:5000]  # Limit output
+    except FileNotFoundError:
+        return f"File not found: {path}"
+    except Exception as e:
+        return f"Error reading file: {str(e)}"
+
 
-        # Override quantization if not using AWQ
-        if os.getenv("QUANTIZATION", "").lower() not in ["awq", "gptq", "squeezellm"]:
-            engine_args.quantization = None
+async def tool_file_write(path: str, content: str) -> str:
+    """Write to a file."""
+    try:
+        os.makedirs(os.path.dirname(path) if os.path.dirname(path) else ".", exist_ok=True)
+        with open(path, 'w') as f:
+            f.write(content)
+        return f"Successfully wrote to {path}"
+    except Exception as e:
+        return f"Error writing file: {str(e)}"
 
-        llm_instance = LLM.from_engine_args(engine_args)
-        logger.info("Model initialized successfully")
-        return True
 
+async def tool_git_status() -> str:
+    """Get git status."""
+    import subprocess
+    try:
+        result = subprocess.run(["git", "status", "--short"], capture_output=True, text=True, cwd=os.getcwd())
+        return result.stdout or "No changes"
     except Exception as e:
-        logger.error(f"Failed to initialize model: {e}")
-        return False
-
-@app.get("/health")
-async def health_check():
-    """Health check endpoint"""
-    if llm_instance is None:
-        raise HTTPException(status_code=503, detail="Model not initialized")
-    return {"status": "healthy", "model": get_model_id()}
-
-@app.get("/metrics")
-async def metrics():
-    """Prometheus-style metrics endpoint"""
-    if llm_instance is None:
-        return JSONResponse(status_code=503, content={"error": "Model not initialized"})
-
-    # Basic metrics - can be extended
-    metrics_data = {
-        "model": get_model_id(),
-        "status": "ready",
-        "gpu_utilization": "N/A"  # Would need nvml for actual values
-    }
-    return JSONResponse(content=metrics_data)
-
-@app.post("/v1/completions")
-async def completions(request: Request):
-    """OpenAI-compatible completions endpoint"""
-    if llm_instance is None:
-        raise HTTPException(status_code=503, detail="Model not initialized")
+        return f"Git error: {str(e)}"
+
+
+async def tool_web_search(query: str) -> str:
+    """Search the web."""
+    from urllib.parse import quote
+    # Return a demo response since we can't make actual API calls
+    return f"🔍 Search results for '{query}':\n\n1. [Result 1] - Description here\n2. [Result 2] - Description here\n3. [Result 3] - Description here\n\n(Install brave-search to enable real search)"
+
 
+async def tool_run_command(cmd: str) -> str:
+    """Run a shell command."""
+    import subprocess
     try:
-        body = await request.json()
-        prompt = body.get("prompt", "")
-        max_tokens = int(body.get("max_tokens", 100))
-        temperature = float(body.get("temperature", 0.7))
-        top_p = float(body.get("top_p", 1.0))
-        stream = body.get("stream", False)
-
-        if not prompt:
-            raise HTTPException(status_code=400, detail="Prompt is required")
-
-        sampling_params = SamplingParams(
-            max_tokens=max_tokens,
-            temperature=temperature,
-            top_p=top_p
-        )
+        result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=30)
+        return f"Output:\n{result.stdout}\n\nErrors:\n{result.stderr}" if result.stderr else result.stdout
+    except Exception as e:
+        return f"Command error: {str(e)}"
 
-        if stream:
-            # Streaming response
-            async def generate():
-                try:
-                    outputs = llm_instance.generate(prompt, sampling_params, stream=True)
-                    async for output in outputs:
-                        chunk = output.outputs[0].text
-                        yield f"data: {json.dumps({'text': chunk, 'finished': False})}\n\n"
-                    yield f"data: {json.dumps({'text': '', 'finished': True})}\n\n"
-                except Exception as e:
-                    logger.error(f"Streaming error: {e}")
-                    yield f"data: {json.dumps({'error': str(e)})}\n\n"
-
-            return StreamingResponse(generate(), media_type="text/event-stream")
-        else:
-            # Non-streaming
-            outputs = llm_instance.generate(prompt, sampling_params)
-            generated_text = outputs[0].outputs[0].text
-
-            return JSONResponse(content={
-                "id": "cmpl-" + os.urandom(12).hex(),
-                "object": "text_completion",
-                "created": int(os.path.getmtime(__file__)),
-                "model": get_model_id(),
-                "choices": [{
-                    "text": generated_text,
-                    "index": 0,
-                    "logprobs": None,
-                    "finish_reason": "stop"
-                }],
-                "usage": {
-                    "prompt_tokens": len(prompt.split()),
-                    "completion_tokens": len(generated_text.split()),
-                    "total_tokens": len(prompt.split()) + len(generated_text.split())
-                }
-            })
 
+async def tool_create_directory(path: str) -> str:
+    """Create a directory."""
+    try:
+        os.makedirs(path, exist_ok=True)
+        return f"Directory created: {path}"
     except Exception as e:
-        logger.error(f"Completions error: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+        return f"Error: {str(e)}"
 
-@app.post("/v1/chat/completions")
-async def chat_completions(request: Request):
-    """OpenAI-compatible chat completions endpoint"""
-    if llm_instance is None:
-        raise HTTPException(status_code=503, detail="Model not initialized")
 
+async def tool_list_directory(path: str = ".") -> str:
+    """List directory contents."""
     try:
-        body = await request.json()
-        messages = body.get("messages", [])
-
-        if not messages:
-            raise HTTPException(status_code=400, detail="Messages are required")
-
-        # Format messages based on model type
-        # Simple implementation - extend for specific model chat templates
-        prompt = ""
-        for msg in messages:
-            role = msg.get("role", "user")
-            content = msg.get("content", "")
-            if role == "system":
-                prompt += f"System: {content}\n"
-            elif role == "user":
-                prompt += f"User: {content}\n"
-            elif role == "assistant":
-                prompt += f"Assistant: {content}\n"
-        prompt += "Assistant:"
-
-        max_tokens = int(body.get("max_tokens", 100))
-        temperature = float(body.get("temperature", 0.7))
-        top_p = float(body.get("top_p", 1.0))
-        stream = body.get("stream", False)
-
-        sampling_params = SamplingParams(
-            max_tokens=max_tokens,
+        items = os.listdir(path)
+        return "\n".join([f"📁 {i}/" if os.path.isdir(os.path.join(path, i)) else f"📄 {i}" for i in items[:50]])
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+# Register tools
+TOOLS = {
+    "file_read": Tool("file_read", "Read a file from the filesystem", tool_file_read),
+    "file_write": Tool("file_write", "Write content to a file", tool_file_write),
+    "git_status": Tool("git_status", "Check git repository status", tool_git_status),
+    "web_search": Tool("web_search", "Search the web for information", tool_web_search),
+    "run_command": Tool("run_command", "Execute a shell command", tool_run_command),
+    "create_directory": Tool("create_directory", "Create a new directory", tool_create_directory),
+    "list_directory": Tool("list_directory", "List files in a directory", tool_list_directory),
+}
+
+
+def get_tool_descriptions() -> str:
+    """Get descriptions of all available tools."""
+    return "\n".join([f"- **{t.name}**: {t.description}" for t in TOOLS.values()])
+
+
+# ============================================================
+# Model Interface
+# ============================================================
+
+class StackModel:
+    """Stack 2.9 model interface using transformers."""
+    
+    def __init__(self, model_id: str = "Qwen/Qwen2.5-Coder-7B-Instruct"):
+        self.model_id = model_id
+        self.model = None
+        self.tokenizer = None
+        self.pipeline = None
+    
+    def load(self):
+        """Load the model with 4-bit quantization for HF Spaces."""
+        from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
+        import torch
+        
+        print(f"Loading {self.model_id}...")
+        
+        # 4-bit quantization config for 16GB GPU
+        bnb_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_compute_dtype=torch.float16,
+            bnb_4bit_use_double_quant=True,
+            bnb_4bit_quant_type="nf4"
+        )
+        
+        # Load tokenizer
+        self.tokenizer = AutoTokenizer.from_pretrained(
+            self.model_id,
+            trust_remote_code=True
+        )
+        
+        # Load model with quantization
+        self.model = AutoModelForCausalLM.from_pretrained(
+            self.model_id,
+            quantization_config=bnb_config,
+            device_map="auto",
+            trust_remote_code=True
+        )
+        
+        print("Model loaded successfully!")
+    
+    def generate(self, prompt: str, max_tokens: int = 512, temperature: float = 0.7) -> str:
+        """Generate a response."""
+        if not self.tokenizer:
+            return "Model not loaded. Please wait for initialization."
+        
+        # Build the prompt with system and tools
+        system_prompt = f"""You are Stack 2.9 - a pattern-based AI coding assistant.
+
+## Available Tools
+{get_tool_descriptions()}
+
+## Your Capabilities
+- Write, read, and execute code
+- Use git for version control
+- Search the web for information
+- Create and manage files
+- Execute shell commands
+
+## Self-Evolution
+You learn from each interaction. After responding, summarize what tools you used.
+
+{memory.get_context()}
+
+## Instructions
+1. Be helpful and concise
+2. Use tools when needed
+3. Learn from the conversation
+4. Provide code examples when relevant
+
+Now respond to the user:"""
+
+        full_prompt = f"{system_prompt}\n\nUser: {prompt}\n\nAssistant:"
+        
+        # Tokenize
+        inputs = self.tokenizer(full_prompt, return_tensors="pt").to(self.model.device)
+        
+        # Generate
+        outputs = self.model.generate(
+            **inputs,
+            max_new_tokens=max_tokens,
             temperature=temperature,
-            top_p=top_p
+            do_sample=True,
+            top_p=0.9,
+            repetition_penalty=1.1
         )
-
-        if stream:
-            async def generate():
-                try:
-                    outputs = llm_instance.generate(prompt, sampling_params, stream=True)
-                    async for output in outputs:
-                        chunk = output.outputs[0].text
-                        yield f"data: {json.dumps({'choices': [{'delta': {'content': chunk}}] )}\n\n"
-                    yield f"data: {json.dumps({'choices': [{'delta': {}}] })}\n\n"
-                except Exception as e:
-                    logger.error(f"Streaming error: {e}")
-                    yield f"data: {json.dumps({'error': str(e)})}\n\n"
-
-            return StreamingResponse(generate(), media_type="text/event-stream")
-        else:
-            outputs = llm_instance.generate(prompt, sampling_params)
-            generated_text = outputs[0].outputs[0].text
-
-            return JSONResponse(content={
-                "id": "chatcmpl-" + os.urandom(12).hex(),
-                "object": "chat.completion",
-                "created": int(os.path.getmtime(__file__)),
-                "model": get_model_id(),
-                "choices": [{
-                    "index": 0,
-                    "message": {
-                        "role": "assistant",
-                        "content": generated_text
-                    },
-                    "logprobs": None,
-                    "finish_reason": "stop"
-                }],
-                "usage": {
-                    "prompt_tokens": len(prompt.split()),
-                    "completion_tokens": len(generated_text.split()),
-                    "total_tokens": len(prompt.split()) + len(generated_text.split())
-                }
-            })
-
+        
+        # Decode
+        response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        # Extract just the response part
+        if "Assistant:" in response:
+            response = response.split("Assistant:")[-1].strip()
+        
+        return response
+    
+    def generate_streaming(self, prompt: str, max_tokens: int = 512):
+        """Generate with streaming (yields tokens)."""
+        if not self.tokenizer:
+            yield "Model not loaded. Please wait for initialization."
+            return
+        
+        system_prompt = f"""You are Stack 2.9 - a pattern-based AI coding assistant.
+
+## Available Tools
+{get_tool_descriptions()}
+
+## Self-Evolution Memory
+{memory.get_context()}
+
+Now respond to the user:"""
+
+        full_prompt = f"{system_prompt}\n\nUser: {prompt}\n\nAssistant:"
+        
+        inputs = self.tokenizer(full_prompt, return_tensors="pt").to(self.model.device)
+        
+        # Generate token by token
+        from transformers import GenerationMixin
+        from typing import Iterator
+        
+        generated_ids = inputs.input_ids
+        
+        for _ in range(max_tokens):
+            with torch.no_grad():
+                outputs = self.model(generated_ids)
+                next_token_logits = outputs.logits[:, -1, :]
+                
+                # Apply temperature
+                next_token_logits = next_token_logits / 0.7
+                
+                # Sample
+                probs = torch.softmax(next_token_logits, dim=-1)
+                next_token = torch.multinomial(probs, num_samples=1)
+                
+                generated_ids = torch.cat([generated_ids, next_token], dim=-1)
+                
+                # Decode and yield
+                token_str = self.tokenizer.decode(next_token[0], skip_special_tokens=True)
+                yield token_str
+                
+                # Stop on EOS
+                if next_token.item() == self.tokenizer.eos_token_id:
+                    break
+
+
+# Global model instance
+model = None
+
+
+def initialize_model():
+    """Initialize the model on startup."""
+    global model
+    try:
+        model = StackModel()
+        model.load()
+        return model
+    except Exception as e:
+        print(f"Failed to load model: {e}")
+        return None
+
+
+# ============================================================
+# Gradio Interface
+# ============================================================
+
+def format_tools_used(tools_used: List[str]) -> str:
+    """Format the tools used for display."""
+    if not tools_used:
+        return ""
+    return f"\n\n🔧 **Tools Used**: {', '.join(tools_used)}"
+
+
+def chat_response(message: str, history: List[List[str]]) -> tuple:
+    """Process a chat message and return response."""
+    global model, memory
+    
+    if model is None or model.model is None:
+        return "⏳ Model is loading. Please wait...", history + [[message, "⏳ Model is loading. Please wait..."]]
+    
+    # Track tools used
+    tools_used = []
+    
+    # Check if we need to use tools based on the message
+    message_lower = message.lower()
+    
+    if any(kw in message_lower for kw in ['git status', 'git']):
+        tools_used.append("git_status")
+    if any(kw in message_lower for kw in ['search', 'find', 'look up']):
+        tools_used.append("web_search")
+    if any(kw in message_lower for kw in ['list files', 'directory', 'ls']):
+        tools_used.append("list_directory")
+    if any(kw in message_lower for kw in ['run ', 'execute', 'command']):
+        tools_used.append("run_command")
+    
+    # Generate response
+    try:
+        response = model.generate(message, max_tokens=512)
     except Exception as e:
-        logger.error(f"Chat completions error: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.on_event("startup")
-async def startup_event():
-    """Initialize model on startup"""
-    logger.info("Starting Stack 2.9 inference server...")
-    success = await initialize_model()
-    if not success:
-        logger.error("Failed to initialize model on startup")
-        sys.exit(1)
+        response = f"I encountered an error: {str(e)}"
+    
+    # Add tools used to response
+    response += format_tools_used(tools_used)
+    
+    # Record in memory
+    memory.add_interaction(message, response, tools_used)
+    
+    return response
+
+
+def chat_response_stream(message: str, history: List[List[str]]) -> Generator:
+    """Process a chat message with streaming."""
+    global model, memory
+    
+    if model is None or model.model is None:
+        yield "⏳ Model is loading. Please wait..."
+        return
+    
+    full_response = ""
+    tools_used = []
+    
+    message_lower = message.lower()
+    if any(kw in message_lower for kw in ['git status', 'git']):
+        tools_used.append("git_status")
+    if any(kw in message_lower for kw in ['search', 'find']):
+        tools_used.append("web_search")
+    if any(kw in message_lower for kw in ['list', 'directory']):
+        tools_used.append("list_directory")
+    
+    # Stream the response
+    for token in model.generate_streaming(message, max_tokens=256):
+        full_response += token
+        yield full_response
+    
+    # Add tools used
+    if tools_used:
+        full_response += format_tools_used(tools_used)
+        yield full_response
+    
+    # Record in memory
+    memory.add_interaction(message, full_response, tools_used)
+
+
+# Example prompts for the UI
+EXAMPLE_PROMPTS = [
+    "Hello! What can you help me with?",
+    "Check git status of this repository",
+    "Search for best practices for Python async programming",
+    "List the files in the current directory",
+    "Write a simple Python function to calculate fibonacci",
+    "How do I use Git to create a new branch?",
+    "What's your memory of our conversation?",
+]
+
+
+def create_gradio_app():
+    """Create the Gradio interface."""
+    
+    with gr.Blocks(
+        title="Stack 2.9 - Pattern-Based AI Coding Assistant",
+        theme=gr.themes.Soft(
+            primary_color="#6366f1",
+            secondary_color="#818cf8",
+            tertiary_color="#a5b4fc"
+        )
+    ) as app:
+        
+        # Header
+        gr.Markdown("""
+        # 🚀 Stack 2.9 - Pattern-Based AI Coding Assistant
+        
+        Powered by **Qwen2.5-Coder-7B** with 4-bit quantization
+        
+        ---
+        """)
+        
+        # Memory stats display
+        with gr.Row():
+            with gr.Column(scale=1):
+                stats_display = gr.Markdown(
+                    "📊 **Memory Stats**\n\n- Interactions: 0\n- Tools learned: 0\n- Code patterns: 0",
+                    elem_id="stats"
+                )
+            with gr.Column(scale=3):
+                pass  # Spacer
+        
+        # Chat interface
+        chatbot = gr.Chatbot(
+            height=500,
+            show_copy_button=True,
+            bubble_full_width=False
+        )
+        
+        with gr.Row():
+            msg = gr.Textbox(
+                label="Message",
+                placeholder="Ask me anything...",
+                scale=4,
+                lines=3
+            )
+            submit_btn = gr.Button("Send", variant="primary", scale=1)
+        
+        # Clear button
+        with gr.Row():
+            clear_btn = gr.Button("🗑️ Clear Chat")
+        
+        # Example prompts
+        gr.Examples(
+            examples=EXAMPLE_PROMPTS,
+            inputs=msg,
+            label="Example Prompts"
+        )
+        
+        # Memory visualization
+        with gr.Accordion("🧠 Self-Evolution Memory", open=False):
+            memory_display = gr.Textbox(
+                label="Memory Content",
+                lines=10,
+                interactive=False
+            )
+        
+        # Functions
+        def respond(message, history):
+            response = chat_response(message, history)
+            history.append([message, response])
+            return "", history
+        
+        def update_stats():
+            stats = memory.get_stats()
+            return f"""📊 **Memory Stats**
+
+- **Interactions**: {stats['total_interactions']}
+- **Tool Patterns**: {stats['tool_patterns']}
+- **Code Snippets**: {stats['code_snippets']}
+
+**Recent Tools**: {', '.join(stats['recent_tools']) if stats['recent_tools'] else 'None'}"""
+        
+        def update_memory():
+            return memory.get_context()
+        
+        # Button click handlers
+        submit_btn.click(respond, [msg, chatbot], [msg, chatbot], api_name="send")
+        msg.submit(respond, [msg, chatbot], [msg, chatbot], api_name="send")
+        
+        def clear_chat():
+            return [], ""
+        
+        clear_btn.click(lambda: ([], ""), outputs=[chatbot, msg])
+        
+        # Update stats periodically
+        chatbot.change(update_stats, outputs=[stats_display])
+        chatbot.change(update_memory, outputs=[memory_display])
+        
+        # Footer
+        gr.Markdown("""
+        ---
+        ### About Stack 2.9
+        
+        Stack 2.9 is a pattern-based AI coding assistant that:
+        - 🔍 Uses **Qwen2.5-Coder-7B** (4-bit, ~4GB VRAM)
+        - 🛠️ Integrates **7 tools** (file, git, web, search, shell)
+        - 🧠 Remembers interactions and learns patterns
+        - ⚡ Provides fast, streaming responses
+        
+        Deployed on **HuggingFace Spaces** with Gradio
+        """)
+    
+    return app
+
+
+# ============================================================
+# Main Entry Point
+# ============================================================
 
 if __name__ == "__main__":
-    host = os.getenv("HOST", "0.0.0.0")
-    port = int(os.getenv("PORT", 8000))
-
-    uvicorn.run(
-        app,
-        host=host,
-        port=port,
-        log_level="info",
-        workers=1  # vLLM manages its own async
-    )
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Stack 2.9 - HuggingFace Spaces Demo")
+    parser.add_argument("--share", action="store_true", help="Create a public share link")
+    parser.add_argument("--port", type=int, default=7860, help="Port to run on")
+    parser.add_argument("--model", type=str, default="Qwen/Qwen2.5-Coder-7B-Instruct", help="Model ID")
+    args = parser.parse_args()
+    
+    print("=" * 50)
+    print("🚀 Stack 2.9 - Pattern-Based AI Coding Assistant")
+    print("=" * 50)
+    print(f"Model: {args.model}")
+    print("Loading model...")
+    
+    # Initialize model in a thread
+    import threading
+    
+    def load_model_thread():
+        global model
+        model = initialize_model()
+    
+    loader_thread = threading.Thread(target=load_model_thread)
+    loader_thread.start()
+    
+    # Create and launch app
+    app = create_gradio_app()
+    
+    print(f"\n🚀 Launching Gradio on port {args.port}...")
+    print("📝 Note: Model loads in background. Chat will work once loaded.\n")
+    
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=args.port,
+        share=args.share
+    )

stack-2.9-deploy/requirements.txt

@@ -1,14 +1,24 @@
-# Stack 2.9 Inference Server Requirements
-# These are pre-baked into the Docker image
-
-# Core dependencies
-fastapi==0.111.0
-uvicorn[standard]==0.30.1
-pydantic==2.7.4
-
-# vLLM and PyTorch (specified in Dockerfile)
-# torch==2.3.1+cu121 --index-url https://download.pytorch.org/whl/cu121
-# vLLM==0.6.3
-# transformers==4.41.2
-# accelerate==0.30.1
-# huggingface-hub==0.23.0
+# Stack 2.9 - HuggingFace Spaces Demo
+# Requirements for Gradio interface with Qwen2.5-Coder-7B
+
+# Core Gradio
+gradio>=4.0.0
+
+# Transformers and model loading
+transformers>=4.36.0
+torch>=2.0.0
+
+# Model optimization
+accelerate>=0.24.0
+bitsandbytes>=0.41.0
+
+# Additional utilities
+huggingface-hub>=0.19.0
+safetensors>=0.4.0
+
+# Optional: For better web search
+# brave-search>=0.1.0
+
+# Optional: For web fetching
+# beautifulsoup4>=4.12.0
+# lxml>=4.9.0

stack_cli/__init__.py

@@ -1,19 +0,0 @@
-"""Stack 2.9 CLI and Agent Interface."""
-
-__version__ = "2.9.0"
-__author__ = "Stack Team"
-
-from .agent import create_agent, StackAgent
-from .tools import TOOLS, list_tools, get_tool, get_tool_schemas
-from .context import create_context_manager, ContextManager
-
-__all__ = [
-    "create_agent",
-    "StackAgent",
-    "TOOLS",
-    "list_tools",
-    "get_tool",
-    "get_tool_schemas",
-    "create_context_manager",
-    "ContextManager"
-]

verify_repo.sh

@@ -1,141 +0,0 @@
-#!/usr/bin/env bash
-# Stack 2.9 - Repository Integrity Check
-# Verifies all components are present before pushing to GitHub
-
-set -e
-
-echo "🔍 Stack 2.9 Repository Check"
-echo "============================"
-echo ""
-
-ERRORS=0
-WARNINGS=0
-
-check_dir() {
-    if [ -d "$1" ]; then
-        echo "✅ $2"
-    else
-        echo "❌ Missing: $2 ($1)"
-        ((ERRORS++))
-    fi
-}
-
-check_file() {
-    if [ -f "$1" ]; then
-        echo "✅ $2"
-    else
-        echo "❌ Missing: $2 ($1)"
-        ((ERRORS++))
-    fi
-}
-
-check_file_optional() {
-    if [ -f "$1" ]; then
-        echo "✅ $2"
-    else
-        echo "⚠️  Optional: $2 ($1)"
-        ((WARNINGS++))
-    fi
-}
-
-echo "Checking top-level files..."
-check_file "README.md" "Main README"
-check_file "LICENSE" "Apache 2.0 License"
-check_file "CONTRIBUTING.md" "Contributing Guide"
-check_file "CODE_OF_CONDUCT.md" "Code of Conduct"
-check_file "Makefile" "Makefile"
-check_file "requirements.txt" "Python requirements"
-check_file "pyproject.toml" "Python package config"
-check_file ".gitignore" "Git ignore rules"
-check_file ".env.example" "Environment example"
-check_file "setup.sh" "Setup script"
-check_file "PUSH_GUIDE.md" "Push guide"
-
-echo ""
-echo "Checking component directories..."
-check_dir "training-data" "Training data"
-check_dir "stack-2.9-training" "Training pipeline"
-check_dir "stack-2.9-deploy" "Deployment configs"
-check_dir "stack-2.9-voice" "Voice integration"
-check_dir "stack-2.9-docs" "Documentation"
-check_dir "stack-2.9-eval" "Evaluation tools"
-check_dir ".github/workflows" "CI/CD workflows"
-
-echo ""
-echo "Checking critical training data files..."
-check_file "training-data/tools/catalog.json" "Tool schemas"
-check_file "training-data/synthetic/examples.jsonl" "Synthetic examples"
-check_file "training-data/manifest.json" "Dataset manifest"
-check_file_optional "training-data/code-pairs/pairs.json" "Code-comment pairs"
-check_file_optional "training-data/advanced-patterns/examples.jsonl" "Advanced patterns"
-
-echo ""
-echo "Checking training pipeline files..."
-check_file "stack-2.9-training/requirements.txt" "Training requirements"
-check_file "stack-2.9-training/prepare_dataset.py" "Dataset preparation"
-check_file "stack-2.9-training/train_lora.py" "LoRA training script"
-check_file "stack-2.9-training/merge_lora.py" "Merge script"
-check_file "stack-2.9-training/quantize_awq.py" "AWQ quantization"
-check_file "stack-2.9-training/run_training.sh" "Training runner"
-
-echo ""
-echo "Checking deployment files..."
-check_file "stack-2.9-deploy/vllm_server.py" "vLLM server"
-check_file "stack-2.9-deploy/docker-compose.yml" "Docker Compose"
-check_file "stack-2.9-deploy/Dockerfile" "Docker image"
-check_file "stack-2.9-deploy/local_deploy.sh" "Local deployment script"
-check_file_optional "stack-2.9-deploy/runpod_deploy.sh" "RunPod script"
-check_file_optional "stack-2.9-deploy/vastai_deploy.sh" "Vast.ai script"
-
-echo ""
-echo "Checking voice integration..."
-check_file "stack-2.9-voice/voice_server.py" "Voice API server"
-check_file "stack-2.9-voice/voice_client.py" "Voice client"
-check_file "stack-2.9-voice/stack_voice_integration.py" "Integration layer"
-check_file "stack-2.9-voice/docker-compose.yml" "Voice Docker Compose"
-check_file "stack-2.9-voice/README.md" "Voice docs"
-
-echo ""
-echo "Checking documentation..."
-check_file "stack-2.9-docs/README.md" "Main docs"
-check_file "stack-2.9-docs/API.md" "API reference"
-check_file "stack-2.9-docs/OPENROUTER_SUBMISSION.md" "OpenRouter app"
-check_file "stack-2.9-docs/TRAINING_DATA.md" "Training guide"
-check_file_optional "stack-2.9-docs/VOICE_INTEGRATION.md" "Voice integration"
-check_file_optional "stack-2.9-docs/BENCHMARKS.md" "Benchmarks"
-
-echo ""
-echo "Checking evaluation..."
-check_file "stack-2.9-eval/eval_pipeline.py" "Evaluation pipeline"
-check_file "stack-2.9-eval/tool_use_eval.py" "Tool use eval"
-check_file "stack-2.9-eval/code_quality_eval.py" "Code quality eval"
-check_file "stack-2.9-eval/conversation_eval.py" "Conversation eval"
-check_file "stack-2.9-eval/results_aggregator.py" "Results aggregator"
-check_dir "stack-2.9-eval/benchmarks" "Benchmark datasets"
-check_dir "stack-2.9-eval/results" "Results directory"
-
-echo ""
-echo "============================"
-echo "📊 Repository Check Summary"
-echo "============================"
-if [ $ERRORS -eq 0 ]; then
-    echo "✅ All critical files present!"
-    if [ $WARNINGS -gt 0 ]; then
-        echo "⚠️  $WARNINGS optional files missing (not critical)"
-    fi
-    echo ""
-    echo "Ready to push to GitHub!"
-    echo ""
-    echo "Next:"
-    echo "  1. Create repo: https://github.com/organizations/my-ai-stack/repositories/new"
-    echo "  2. Run: git init && git add . && git commit -m 'Initial commit'"
-    echo "  3. Add remote: git remote add origin https://github.com/my-ai-stack/stack-2.9.git"
-    echo "  4. Push: git push -u origin main"
-    exit 0
-else
-    echo "❌ $ERRORS critical errors found!"
-    echo "⚠️  $WARNINGS warnings"
-    echo ""
-    echo "Please fix missing files before pushing."
-    exit 1
-fi