Create App.py

App.py

@@ -0,0 +1,521 @@
+# CodeMind AI — Pure API Server (No UI)
+# Call from any app using your API Key + URL!
+
+import os, re, ast, json, time, random, hashlib
+import warnings; warnings.filterwarnings("ignore")
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers import GPT2TokenizerFast
+from dataclasses import dataclass
+from typing import List, Dict, Any
+from collections import deque
+from fastapi import FastAPI, HTTPException, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from fastapi.security import APIKeyHeader
+from pydantic import BaseModel
+import uvicorn
+
+# ══════════════════════════════════════════════════
+# API KEY — set in HF Space → Settings → Secrets
+# Name: CODEMIND_API_KEY
+# ══════════════════════════════════════════════════
+API_KEY = os.environ.get("CODEMIND_API_KEY", "codemind-change-me")
+print("✅ API Key loaded!" if "change-me" not in API_KEY
+      else "⚠️  Set CODEMIND_API_KEY in HF Secrets!")
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+print(f"🚀 Device: {device.upper()}")
+
+@dataclass
+class Config:
+    vocab_size:     int   = 50304
+    n_embd:         int   = 512
+    n_head:         int   = 8
+    n_kv_head:      int   = 4
+    n_layer:        int   = 8
+    block_size:     int   = 512
+    temperature:    float = 0.8
+    top_k:          int   = 50
+    top_p:          float = 0.95
+    rep_penalty:    float = 1.1
+    max_new_tokens: int   = 256
+
+cfg = Config()
+random.seed(42); torch.manual_seed(42)
+
+# ── Tokenizer ─────────────────────────────────────
+tokenizer = GPT2TokenizerFast.from_pretrained("gpt2")
+tokenizer.pad_token = tokenizer.eos_token
+_SPECIAL = [
+    '<|generate|>','<|complete|>','<|explain|>','<|bugfix|>',
+    '<|optimize|>','<|translate|>','<|docstring|>','<|unittest|>',
+    '<|review|>','<|refactor|>','<|security|>','<|complexity|>',
+    '<|async|>','<|python|>','<|javascript|>','<|java|>',
+    '<|cpp|>','<|typescript|>','<|go|>','<|rust|>',
+]
+tokenizer.add_special_tokens({'additional_special_tokens': _SPECIAL})
+cfg.vocab_size = len(tokenizer)
+print(f"✅ Vocab: {cfg.vocab_size:,}")
+
+# ── Model ─────────────────────────────────────────
+class RMSNorm(nn.Module):
+    def __init__(self,d,eps=1e-8):
+        super().__init__()
+        self.scale=nn.Parameter(torch.ones(d)); self.eps=eps
+    def forward(self,x):
+        return self.scale*x/(x.pow(2).mean(-1,keepdim=True).add(self.eps).sqrt())
+
+class RotaryEmbedding(nn.Module):
+    def __init__(self,dim):
+        super().__init__()
+        self.register_buffer("inv_freq",1.0/(10000**(torch.arange(0,dim,2).float()/dim)))
+    def forward(self,T,dev):
+        t=torch.arange(T,device=dev).float()
+        f=torch.outer(t,self.inv_freq)
+        e=torch.cat([f,f],dim=-1)
+        return e.cos(),e.sin()
+
+def _rot(x):
+    a,b=x.chunk(2,dim=-1); return torch.cat([-b,a],dim=-1)
+
+def apply_rope(q,k,cos,sin):
+    c,s=cos[None,None],sin[None,None]
+    return (q*c)+(_rot(q)*s),(k*c)+(_rot(k)*s)
+
+class GQA(nn.Module):
+    def __init__(self,cfg):
+        super().__init__()
+        self.nh=cfg.n_head; self.nkv=cfg.n_kv_head; self.hd=cfg.n_embd//cfg.n_head
+        self.q=nn.Linear(cfg.n_embd,cfg.n_embd,bias=False)
+        self.k=nn.Linear(cfg.n_embd,self.nkv*self.hd,bias=False)
+        self.v=nn.Linear(cfg.n_embd,self.nkv*self.hd,bias=False)
+        self.o=nn.Linear(cfg.n_embd,cfg.n_embd,bias=False)
+        self.rope=RotaryEmbedding(self.hd)
+    def forward(self,x,cache=None):
+        B,T,C=x.shape; cos,sin=self.rope(T,x.device)
+        q=self.q(x).view(B,T,self.nh,self.hd).transpose(1,2)
+        k=self.k(x).view(B,T,self.nkv,self.hd).transpose(1,2)
+        v=self.v(x).view(B,T,self.nkv,self.hd).transpose(1,2)
+        q,k=apply_rope(q,k,cos,sin)
+        if cache is not None:
+            k=torch.cat([cache[0],k],dim=2); v=torch.cat([cache[1],v],dim=2)
+        nc=(k.detach(),v.detach())
+        k=k.repeat_interleave(self.nh//self.nkv,dim=1)
+        v=v.repeat_interleave(self.nh//self.nkv,dim=1)
+        out=F.scaled_dot_product_attention(q,k,v,is_causal=True,dropout_p=0.0)
+        return self.o(out.transpose(1,2).contiguous().view(B,T,C)),nc
+
+class SwiGLU(nn.Module):
+    def __init__(self,cfg):
+        super().__init__()
+        h=int(cfg.n_embd*8/3)
+        self.w1=nn.Linear(cfg.n_embd,h,bias=False)
+        self.w2=nn.Linear(h,cfg.n_embd,bias=False)
+        self.w3=nn.Linear(cfg.n_embd,h,bias=False)
+    def forward(self,x): return self.w2(F.silu(self.w1(x))*self.w3(x))
+
+class Block(nn.Module):
+    def __init__(self,cfg):
+        super().__init__()
+        self.n1=RMSNorm(cfg.n_embd); self.n2=RMSNorm(cfg.n_embd)
+        self.attn=GQA(cfg); self.mlp=SwiGLU(cfg)
+    def forward(self,x,cache=None):
+        a,c=self.attn(self.n1(x),cache); x=x+a; x=x+self.mlp(self.n2(x)); return x,c
+
+class CodeMindModel(nn.Module):
+    def __init__(self,cfg):
+        super().__init__()
+        self.emb=nn.Embedding(cfg.vocab_size,cfg.n_embd)
+        self.blocks=nn.ModuleList([Block(cfg) for _ in range(cfg.n_layer)])
+        self.norm=RMSNorm(cfg.n_embd)
+        self.head=nn.Linear(cfg.n_embd,cfg.vocab_size,bias=False)
+        self.emb.weight=self.head.weight
+        self.apply(lambda m:nn.init.normal_(m.weight,0,0.02) if isinstance(m,(nn.Linear,nn.Embedding)) else None)
+        print(f"🧠 CodeMind: {sum(p.numel() for p in self.parameters())/1e6:.1f}M params")
+
+    def forward(self,idx,targets=None,caches=None):
+        x=self.emb(idx); nc=[]
+        for i,b in enumerate(self.blocks):
+            x,c=b(x,caches[i] if caches else None); nc.append(c)
+        logits=self.head(self.norm(x))
+        loss=(F.cross_entropy(logits.view(-1,logits.size(-1)),targets.view(-1),ignore_index=-1) if targets is not None else None)
+        return logits,loss,nc
+
+    @torch.no_grad()
+    def generate(self,ids,max_t=256):
+        self.eval(); caches=None; start=ids.shape[1]
+        for _ in range(max_t):
+            inp=ids[:,-cfg.block_size:]
+            logits,_,caches=self(inp,caches=caches)
+            logits=logits[:,-1,:].float()/cfg.temperature
+            v,_=torch.topk(logits,min(cfg.top_k,logits.size(-1)))
+            logits[logits<v[:,[-1]]]=float('-inf')
+            probs=F.softmax(logits,dim=-1)
+            sp,si=torch.sort(probs,descending=True)
+            cp=sp.cumsum(-1); sp[cp-sp>cfg.top_p]=0.0
+            probs=torch.zeros_like(probs).scatter_(1,si,sp)
+            probs/=probs.sum(-1,keepdim=True).clamp(1e-8)
+            for tid in set(ids[0,-20:].tolist()):
+                if probs[0,tid]>0: probs[0,tid]/=cfg.rep_penalty
+            probs/=probs.sum(-1,keepdim=True).clamp(1e-8)
+            nxt=torch.multinomial(probs,1)
+            if nxt.item()==tokenizer.eos_token_id: break
+            ids=torch.cat([ids,nxt],dim=1)
+        return tokenizer.decode(ids[0,start:].tolist(),skip_special_tokens=True).strip()
+
+# ── Memory ────────────────────────────────────────
+class Memory:
+    def __init__(self): self.cache={}; self.history=[]
+    def get(self,c,k): return self.cache.get(f"{hashlib.md5(c.encode()).hexdigest()}_{k}")
+    def set(self,c,k,v): self.cache[f"{hashlib.md5(c.encode()).hexdigest()}_{k}"]=v
+    def stats(self): return {"requests":len(self.history),"cache":len(self.cache)}
+
+# ── 20 Functions ──────────────────────────────────
+class Functions:
+    def __init__(self,model,mem): self.model=model; self.mem=mem
+
+    def _gen(self,prompt,max_t=128):
+        ids=tokenizer.encode(prompt,return_tensors="pt").to(device)
+        return self.model.generate(ids[:,-cfg.block_size:],max_t)
+
+    def generate_code(self,prompt,lang="python",max_t=256):
+        lt=f"<|{lang}|>" if f"<|{lang}|>" in _SPECIAL else ""
+        out=self._gen(f"{lt}<|generate|># Task: {prompt}\n",max_t)
+        imp=self.suggest_imports(out)
+        return ("\n".join(imp)+"\n\n"+out) if imp else out
+
+    def complete_code(self,partial,max_t=128):
+        return self._gen(f"<|complete|>\n{partial}",max_t)
+
+    def explain_code(self,code):
+        c=self.mem.get(code,"explain")
+        if c: return c
+        r=self._gen(f"<|explain|>\n{code[:400]}\n# Explanation:",200)
+        self.mem.set(code,"explain",r); return r
+
+    def detect_bugs(self,code):
+        bugs=[]
+        try: ast.parse(code); ok=True
+        except SyntaxError as e: ok=False; bugs.append({"type":"SyntaxError","line":e.lineno,"msg":str(e)})
+        rules=[(r'== None',"StyleWarning","Use 'is None'"),(r'!= None',"StyleWarning","Use 'is not None'"),
+               (r'except:\s*$',"BestPractice","Bare except"),(r'print\s*\(',"DebugCode","Debug print"),
+               (r'TODO|FIXME',"Incomplete","Unresolved TODO")]
+        for i,line in enumerate(code.split('\n'),1):
+            for pat,kind,msg in rules:
+                if re.search(pat,line): bugs.append({"type":kind,"line":i,"msg":msg})
+        return {"syntax_ok":ok,"bugs":bugs,"total":len(bugs)}
+
+    def optimize_code(self,code): return self._gen(f"<|optimize|>\n{code[:400]}\n# Optimized:",256)
+    def translate_code(self,code,target="javascript"): return self._gen(f"<|translate|>\n# Python:\n{code[:400]}\n# {target}:",300)
+    def generate_docs(self,code): return self._gen(f"<|docstring|>\n{code[:400]}\n# Documented:",300)
+    def generate_tests(self,code,fw="pytest"): return self._gen(f"<|unittest|>\n{code[:350]}\n# {fw} tests:",350)
+
+    def review_code(self,code):
+        lines=[l for l in code.split('\n') if l.strip()]
+        score,iss=100,[]
+        if '"""' not in code: score-=20; iss.append("❌ No docstrings")
+        if '->' not in code: score-=10; iss.append("⚠️  No type hints")
+        if not any(l.strip().startswith('#') for l in code.split('\n')): score-=10; iss.append("⚠️  No comments")
+        if len(lines)>50: score-=15; iss.append("⚠️  Too long")
+        g="A" if score>=90 else "B" if score>=75 else "C" if score>=60 else "D"
+        return {"score":max(score,0),"grade":g,"issues":iss,"loc":len(lines)}
+
+    def analyze_complexity(self,code):
+        md=0
+        for line in code.split('\n'):
+            s=line.lstrip()
+            if s.startswith(('for ','while ')): md=max(md,(len(line)-len(s))//4+1)
+        tm={0:"O(1)",1:"O(n)",2:"O(n²)",3:"O(n³)"}.get(md,f"O(n^{md})")
+        sp="O(n)" if re.search(r'\bappend\b|\[\]',code) else "O(1)"
+        return {"time":tm,"space":sp,"loop_depth":md}
+
+    def suggest_imports(self,code):
+        MAP={r'\bpd\.': "import pandas as pd",r'\bnp\.': "import numpy as np",
+             r'\bplt\.': "import matplotlib.pyplot as plt",r'\btorch\b': "import torch",
+             r'\bos\b': "import os",r'\bre\b': "import re",r'\bmath\b': "import math",
+             r'\bjson\b': "import json",r'\brandom\b': "import random",r'\bsys\b': "import sys"}
+        ex=set(re.findall(r'(?:import|from)\s+(\w+)',code))
+        return [s for p,s in MAP.items() if re.search(p,code) and s.split()[-1].split('.')[0] not in ex]
+
+    def format_code(self,code):
+        lines=[]
+        for line in code.split('\n'):
+            line=re.sub(r'(?<![=!<>])=(?!=)',' = ',line); line=re.sub(r'(?<! ),',', ',line); lines.append(line.rstrip())
+        return '\n'.join(lines).rstrip()+'\n'
+
+    def summarize_code(self,code):
+        fns=re.findall(r'def (\w+)',code); cls=re.findall(r'class (\w+)',code)
+        lns=[l for l in code.split('\n') if l.strip()]; parts=[]
+        if cls: parts.append(f"Classes: {', '.join(cls)}")
+        if fns: parts.append(f"Functions: {', '.join(fns)}")
+        parts.append(f"{len(lns)} lines"); return " | ".join(parts)
+
+    def detect_dead_code(self,code):
+        dead=[]
+        try: tree=ast.parse(code)
+        except: return [{"type":"ParseError","msg":"Cannot parse"}]
+        assigned,used=set(),set()
+        for n in ast.walk(tree):
+            if isinstance(n,ast.Assign):
+                for t in n.targets:
+                    if isinstance(t,ast.Name): assigned.add(t.id)
+            elif isinstance(n,ast.Name) and not isinstance(n.ctx,ast.Store): used.add(n.id)
+        for v in (assigned-used-{'self','_'}):
+            dead.append({"type":"UnusedVariable","name":v,"msg":f"'{v}' never used"})
+        return dead
+
+    def scan_security(self,code):
+        checks=[(r'\beval\s*\(', "CRITICAL","eval() dangerous"),(r'\bexec\s*\(', "CRITICAL","exec() dangerous"),
+                (r'os\.system\s*\(', "HIGH","os.system risk"),(r'pickle\.loads?\s*\(', "HIGH","Unsafe pickle"),
+                (r'shell\s*=\s*True', "HIGH","shell=True injection"),(r'password\s*=\s*["\']', "HIGH","Hardcoded password"),
+                (r'api_key\s*=\s*["\']', "HIGH","Hardcoded API key"),(r'\bmd5\b', "MEDIUM","MD5 broken"),(r'http://', "LOW","Use HTTPS")]
+        vulns=[]
+        for i,line in enumerate(code.split('\n'),1):
+            for pat,sev,msg in checks:
+                if re.search(pat,line,re.I): vulns.append({"line":i,"severity":sev,"msg":msg})
+        order={"CRITICAL":0,"HIGH":1,"MEDIUM":2,"LOW":3}
+        risk=("CRITICAL" if any(v["severity"]=="CRITICAL" for v in vulns)
+              else "HIGH" if any(v["severity"]=="HIGH" for v in vulns)
+              else "MEDIUM" if vulns else "SAFE")
+        return sorted(vulns,key=lambda x:order.get(x["severity"],9)),risk
+
+    def generate_type_hints(self,code):
+        lines,out=code.split('\n'),[]
+        for line in lines:
+            m=re.match(r'(\s*def \w+\()(.*)(\):.*)',line)
+            if m and '->' not in line:
+                typed=[]
+                for p in m.group(2).split(','):
+                    p=p.strip()
+                    if not p or p=='self': typed.append(p)
+                    elif any(k in p for k in ('name','text','msg','key')): typed.append(f"{p}: str")
+                    elif any(k in p for k in ('num','count','n','i')): typed.append(f"{p}: int")
+                    else: typed.append(f"{p}: Any")
+                out.append(f"{m.group(1)}{', '.join(typed)}) -> Any:")
+            else: out.append(line)
+        return '\n'.join(out)
+
+    def refactor_code(self,code): return self._gen(f"<|refactor|>\n{code[:400]}\n# Clean:",300)
+
+    def extract_functions(self,code):
+        try: tree=ast.parse(code)
+        except Exception as e: return [{"error":str(e)}]
+        return [{"name":n.name,"args":[a.arg for a in n.args.args],"line":n.lineno}
+                for n in ast.walk(tree) if isinstance(n,ast.FunctionDef)]
+
+    def convert_to_async(self,code):
+        out=re.sub(r'\bdef (\w+)\s*\(',r'async def \1(',code)
+        out=re.sub(r'\btime\.sleep\b','await asyncio.sleep',out)
+        return "import asyncio\nimport aiohttp\n\n"+out
+
+    def estimate_cost(self,n_params=70_000_000,n_tokens=5_000_000,gpu="T4"):
+        flops=6*n_params*n_tokens; tp={"T4":65e12,"A100":312e12}.get(gpu,65e12)
+        pr={"T4":0.35,"A100":3.00}.get(gpu,0.35); h=flops/tp/3600
+        return {"gpu":gpu,"est_hours":round(h,2),"est_cost_usd":round(h*pr,2)}
+
+
+# ── 17 Agents ─────────────────────────────────────
+class Agent:
+    def __init__(self,name,fn): self.name=name; self.fn=fn
+    def run(self,*a,**k): raise NotImplementedError
+    def ok(self,d): return {"agent":self.name,"status":"ok","result":d}
+    def err(self,m): return {"agent":self.name,"status":"error","msg":m}
+
+class GenAgent(Agent):
+    def __init__(self,fn): super().__init__("CodeGenerator",fn)
+    def run(self,prompt,lang="python"): return self.ok({"code":self.fn.generate_code(prompt,lang),"lang":lang})
+
+class BugAgent(Agent):
+    def __init__(self,fn): super().__init__("BugDetector",fn)
+    def run(self,code):
+        b=self.fn.detect_bugs(code); d=self.fn.detect_dead_code(code)
+        return self.ok({"bugs":b,"dead_code":d,"total":b["total"]+len(d),"healthy":b["total"]+len(d)==0})
+
+class OptAgent(Agent):
+    def __init__(self,fn): super().__init__("Optimizer",fn)
+    def run(self,code): return self.ok({"optimized":self.fn.format_code(self.fn.optimize_code(code)),"complexity":self.fn.analyze_complexity(code)})
+
+class DocAgent(Agent):
+    def __init__(self,fn): super().__init__("Documentation",fn)
+    def run(self,code): return self.ok({"docstrings":self.fn.generate_docs(code),"summary":self.fn.summarize_code(code),"functions":self.fn.extract_functions(code)})
+
+class TestAgent(Agent):
+    def __init__(self,fn): super().__init__("TestGenerator",fn)
+    def run(self,code,fw="pytest"): return self.ok({"tests":self.fn.generate_tests(code,fw),"framework":fw})
+
+class SecAgent(Agent):
+    def __init__(self,fn): super().__init__("SecurityScanner",fn)
+    def run(self,code):
+        v,r=self.fn.scan_security(code); return self.ok({"vulnerabilities":v,"risk_level":r,"is_safe":not v})
+
+class RefAgent(Agent):
+    def __init__(self,fn): super().__init__("Refactor",fn)
+    def run(self,code):
+        r=self.fn.refactor_code(code)
+        return self.ok({"refactored":r,"score_before":self.fn.review_code(code)["score"],"score_after":self.fn.review_code(r)["score"]})
+
+class TrAgent(Agent):
+    SUPPORTED=["javascript","java","cpp","typescript","go","rust","csharp"]
+    def __init__(self,fn): super().__init__("Translator",fn)
+    def run(self,code,target="javascript"):
+        if target not in self.SUPPORTED: return self.err(f"Choose: {self.SUPPORTED}")
+        return self.ok({"translated":self.fn.translate_code(code,target),"target":target})
+
+class RevAgent(Agent):
+    def __init__(self,fn): super().__init__("CodeReviewer",fn)
+    def run(self,code):
+        r=self.fn.review_code(code); v,_=self.fn.scan_security(code); d=self.fn.detect_dead_code(code)
+        s=max(r["score"]-len(v)*5-len(d)*2,0)
+        return self.ok({"score":s,"grade":r["grade"],"issues":r["issues"],"recommendation":"✅ LGTM!" if s>=80 else "❌ Needs work"})
+
+class CpxAgent(Agent):
+    def __init__(self,fn): super().__init__("ComplexityAnalyzer",fn)
+    def run(self,code): return self.ok(self.fn.analyze_complexity(code))
+
+class ImpAgent(Agent):
+    def __init__(self,fn): super().__init__("ImportManager",fn)
+    def run(self,code): return self.ok({"suggested":self.fn.suggest_imports(code)})
+
+class FmtAgent(Agent):
+    def __init__(self,fn): super().__init__("Formatter",fn)
+    def run(self,code): return self.ok({"formatted":self.fn.generate_type_hints(self.fn.format_code(code))})
+
+class ExpAgent(Agent):
+    def __init__(self,fn): super().__init__("Explainer",fn)
+    def run(self,code,level="beginner"):
+        pre={"beginner":"Simply: ","expert":"Technical: "}.get(level,"")
+        return self.ok({"explanation":pre+self.fn.explain_code(code),"summary":self.fn.summarize_code(code)})
+
+class DcdAgent(Agent):
+    def __init__(self,fn): super().__init__("DeadCodeDetector",fn)
+    def run(self,code): d=self.fn.detect_dead_code(code); return self.ok({"items":d,"total":len(d)})
+
+class PerfAgent(Agent):
+    def __init__(self,fn): super().__init__("Profiler",fn)
+    def run(self,code):
+        sug=[]
+        if re.search(r'for .+ in .+:\n.*\.append\(',code,re.S): sug.append("Use list comprehension")
+        if re.search(r'for .* in range\(len\(',code): sug.append("Use enumerate()")
+        if 'global ' in code: sug.append("Remove global variables")
+        return self.ok({"suggestions":sug,"perf_score":max(100-len(sug)*15,10)})
+
+class AsynAgent(Agent):
+    def __init__(self,fn): super().__init__("AsyncConverter",fn)
+    def run(self,code): return self.ok({"async_code":self.fn.convert_to_async(code)})
+
+class Orchestrator:
+    def __init__(self,fn):
+        self.fn=fn; self.mem=fn.mem
+        self.agents={"generate":GenAgent(fn),"bugs":BugAgent(fn),"optimize":OptAgent(fn),
+                     "docs":DocAgent(fn),"tests":TestAgent(fn),"security":SecAgent(fn),
+                     "refactor":RefAgent(fn),"translate":TrAgent(fn),"review":RevAgent(fn),
+                     "complexity":CpxAgent(fn),"imports":ImpAgent(fn),"format":FmtAgent(fn),
+                     "explain":ExpAgent(fn),"deadcode":DcdAgent(fn),"performance":PerfAgent(fn),
+                     "async":AsynAgent(fn)}
+        print(f"✅ {len(self.agents)} agents ready")
+
+    def run(self,task,data,**kw):
+        a=self.agents.get(task)
+        if not a: return {"status":"error","msg":f"Unknown task: {task}"}
+        self.mem.history.append({"agent":task,"ts":time.time()})
+        return a.run(data,**kw)
+
+    def pipeline(self,code):
+        t0,res=time.time(),{}
+        for step in ["bugs","security","review","complexity","deadcode","performance"]:
+            try: res[step]=self.agents[step].run(code)
+            except Exception as e: res[step]={"error":str(e)}
+        res["_meta"]={"elapsed_s":round(time.time()-t0,2)}
+        return res
+
+# ── Build ─────────────────────────────────────────
+print("🔨 Building system...")
+model=CodeMindModel(cfg).to(device)
+memory=Memory()
+functions=Functions(model,memory)
+orc=Orchestrator(functions)
+
+import glob as _g
+_ckpts=sorted(_g.glob("/tmp/*.pt")+_g.glob("*.pt")+_g.glob("checkpoints/*.pt"))
+if _ckpts:
+    try:
+        ck=torch.load(_ckpts[-1],map_location=device)
+        model.load_state_dict(ck["model"]); print(f"✅ Checkpoint: {_ckpts[-1]}")
+    except Exception as e: print(f"⚠️  {e}")
+print("✅ System ready!\n")
+
+# ══════════════════════════════════════════════════
+# FASTAPI — Pure REST API
+# ══════════════════════════════════════════════════
+app=FastAPI(title="CodeMind AI API",description="17 Agents · 20 Functions · Use X-API-Key header",version="3.0",docs_url="/docs")
+app.add_middleware(CORSMiddleware,allow_origins=["*"],allow_methods=["*"],allow_headers=["*"])
+
+_kh=APIKeyHeader(name="X-API-Key",auto_error=False)
+
+async def require_key(key:str=Depends(_kh)):
+    if key!=API_KEY:
+        raise HTTPException(status_code=401,detail={
+            "error":"❌ Wrong or missing API Key",
+            "fix":"Add header: X-API-Key: YOUR_KEY",
+            "your_key":"Set CODEMIND_API_KEY in HF Space → Settings → Secrets"})
+    return key
+
+class Req(BaseModel):
+    code:str=""; prompt:str=""; lang:str="python"; target:str="javascript"
+    framework:str="pytest"; level:str="beginner"; max_tokens:int=256
+
+def _j(d): return JSONResponse(content=d if isinstance(d,dict) else {"result":d})
+
+# ── Public ─────────────────────────────────────────
+@app.get("/")
+async def root():
+    return {"name":"CodeMind AI","version":"3.0","status":"✅ Online","agents":len(orc.agents),
+            "auth":"Add  X-API-Key: YOUR_KEY  header to all /api/ requests",
+            "swagger_ui":"/docs","health":"/health"}
+
+@app.get("/health")
+async def health():
+    return {"status":"online","device":device,"agents":len(orc.agents),"memory":memory.stats(),"ts":time.time()}
+
+# ── Protected ──────────────────────────────────────
+@app.post("/api/generate",    dependencies=[Depends(require_key)])
+async def ep_gen(r:Req):  return _j(orc.run("generate",   r.prompt,lang=r.lang))
+@app.post("/api/complete",    dependencies=[Depends(require_key)])
+async def ep_cmp(r:Req):  return _j({"completion":functions.complete_code(r.code,r.max_tokens)})
+@app.post("/api/bugs",        dependencies=[Depends(require_key)])
+async def ep_bug(r:Req):  return _j(orc.run("bugs",        r.code))
+@app.post("/api/optimize",    dependencies=[Depends(require_key)])
+async def ep_opt(r:Req):  return _j(orc.run("optimize",    r.code))
+@app.post("/api/docs",        dependencies=[Depends(require_key)])
+async def ep_doc(r:Req):  return _j(orc.run("docs",        r.code))
+@app.post("/api/tests",       dependencies=[Depends(require_key)])
+async def ep_tst(r:Req):  return _j(orc.run("tests",       r.code,fw=r.framework))
+@app.post("/api/security",    dependencies=[Depends(require_key)])
+async def ep_sec(r:Req):  return _j(orc.run("security",    r.code))
+@app.post("/api/refactor",    dependencies=[Depends(require_key)])
+async def ep_ref(r:Req):  return _j(orc.run("refactor",    r.code))
+@app.post("/api/translate",   dependencies=[Depends(require_key)])
+async def ep_tr(r:Req):   return _j(orc.run("translate",   r.code,target=r.target))
+@app.post("/api/review",      dependencies=[Depends(require_key)])
+async def ep_rev(r:Req):  return _j(orc.run("review",      r.code))
+@app.post("/api/complexity",  dependencies=[Depends(require_key)])
+async def ep_cpx(r:Req):  return _j(orc.run("complexity",  r.code))
+@app.post("/api/imports",     dependencies=[Depends(require_key)])
+async def ep_imp(r:Req):  return _j(orc.run("imports",     r.code))
+@app.post("/api/format",      dependencies=[Depends(require_key)])
+async def ep_fmt(r:Req):  return _j(orc.run("format",      r.code))
+@app.post("/api/explain",     dependencies=[Depends(require_key)])
+async def ep_exp(r:Req):  return _j(orc.run("explain",     r.code,level=r.level))
+@app.post("/api/deadcode",    dependencies=[Depends(require_key)])
+async def ep_dcd(r:Req):  return _j(orc.run("deadcode",    r.code))
+@app.post("/api/performance", dependencies=[Depends(require_key)])
+async def ep_prf(r:Req):  return _j(orc.run("performance", r.code))
+@app.post("/api/async",       dependencies=[Depends(require_key)])
+async def ep_asn(r:Req):  return _j(orc.run("async",       r.code))
+@app.post("/api/pipeline",    dependencies=[Depends(require_key)])
+async def ep_pip(r:Req):  return _j(orc.pipeline(r.code))
+
+if __name__=="__main__":
+    uvicorn.run(app,host="0.0.0.0",port=7860,log_level="info")