clarity-ai 6.3.2 → 6.4.0

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ---
 
+## 6.4.0 (2026-06-06)
+
+### Clarity Flash 14B Model
+- Added `Clarity Flash 14B` to `/model` picker — 128K context, HuggingFace Inference API
+- New `huggingface` provider: calls `https://api-inference.huggingface.co/models/{model}/v1/chat/completions`
+- `getKey()` falls back to `HF_TOKEN` env var for seamless auth
+- Model weights at `Universal-618/Clarity-flash-weights` on HF Hub
+
+### Fixed-Height Engine (v6.3.x carried forward)
+- Fixed-height viewport with `sliceToViewport()` + `buildLineArray()`
+- Line-by-line streaming via `LineRenderer` (14 line types)
+- Composer: multiline input with auto-grow (max 3 rows), Shift+Enter newline
+
+### Training Notebooks
+- `clarity_flash_14b.ipynb`: Colab T4 — DeepSeek-R1-Distill-Qwen-14B, 4-bit QLoRA, 500 steps, 20 datasets
+- `clarity_heavy_20b_moe.ipynb`: Kaggle T4 — GPT-OSS-20B MoE, MXFP4 native, LoRA, 20 datasets
+
+---
+
 ## 3.1.0 (2026-06-05)
 
 ### UI Rewrite — OpenCode Style

package/README.md

@@ -92,16 +92,26 @@ clarity /bash ls -la
 | `/help [command]` | Command help |
 | `/exit` | Exit CLARITY |
 
+## Available Models
+
+| Model | Provider | Context |
+|---|---|---|
+| **Clarity Flash 14B** | HuggingFace Inference | 128K |
+| Llama 3.3 70B Versatile | Groq | 32K |
+| Llama 3.1 8B Instant | Groq | 8K (fast) |
+| DeepSeek R1 Distill 70B | Groq | 32K (reasoning) |
+| Gemini 2.0 Flash | Google | 32K (fast) |
+| DeepSeek R1 Free | OpenRouter | 128K |
+
 ## Provider Comparison
 
 | Provider | Free Tier | Streaming | Priority |
 |---|---|---|---|
 | Groq | ✓ | ✓ | 1 (fastest) |
 | Google Gemini | ✓ | ✓ | 2 |
-| DeepSeek | Cheap | ✓ | 3 |
-| OpenRouter | ✓ | ✓ | 4 |
-| OpenAI | Paid | ✓ | 5 |
-| Anthropic | Paid | ✓ | 6 |
+| HuggingFace (Clarity Flash) | Needs HF_TOKEN | ✓ | 3 |
+| DeepSeek | Cheap | ✓ | 4 |
+| OpenRouter | ✓ | ✓ | 5 |
 
 ## License
 

package/clarity_flash_14b.ipynb

@@ -0,0 +1,226 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# CLARITY Flash 14B — Trained! Push to Universal-618/Clarity-flash-weights\n",
+        "Model: deepseek-ai/DeepSeek-R1-Distill-Qwen-14B\n",
+        "4-bit QLoRA + grad ckpt + max_len=256\n",
+        "Weights pushed to HF dataset repo for inference on 6 Clarity Spaces\n"
+      ],
+      "metadata": {}
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os,gc,torch\n",
+        "from huggingface_hub import create_repo\n",
+        "from google.colab import userdata\n",
+        "HF_TOKEN = os.environ.get('HF_TOKEN') or userdata.get('HF_TOKEN')\n",
+        "assert HF_TOKEN and len(HF_TOKEN)>10, 'Set HF_TOKEN in Colab secrets'\n"
+      ],
+      "metadata": {},
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install -q transformers datasets accelerate peft bitsandbytes sentencepiece huggingface_hub\n"
+      ],
+      "metadata": {},
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "assert torch.cuda.is_available()\n",
+        "print('GPU:', torch.cuda.get_device_name(0))\n",
+        "gc.collect(); torch.cuda.empty_cache()\n"
+      ],
+      "metadata": {},
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import requests,sys\n",
+        "from datasets import Dataset, load_dataset\n",
+        "import random\n",
+        "\n",
+        "all_samples = []\n",
+        "def add(i,r): all_samples.append(dict(instruction=str(i or ''), response=str(r or '')))\n",
+        "\n",
+        "def load_std(n,s,f,l,**kw):\n",
+        "    try:\n",
+        "        for i,row in enumerate(load_dataset(n,split=s,streaming=True,token=HF_TOKEN,**kw)):\n",
+        "            if i>=l: break\n",
+        "            add(row.get(f['instruction'],''),row.get(f['response'],''))\n",
+        "    except Exception as e: print(f'  skip {n}: {e}', file=sys.stderr)\n",
+        "\n",
+        "def load_msgs(n,s,l,**kw):\n",
+        "    try:\n",
+        "        for i,row in enumerate(load_dataset(n,split=s,streaming=True,token=HF_TOKEN,**kw)):\n",
+        "            if i>=l: break\n",
+        "            msgs=row.get('messages',[])\n",
+        "            if len(msgs)>=2: add(msgs[0].get('content',''),msgs[-1].get('content',''))\n",
+        "    except Exception as e: print(f'  skip {n}: {e}', file=sys.stderr)\n",
+        "\n",
+        "for sfx in ['main','2','3','4','5','6']:\n",
+        "    try:\n",
+        "        r=requests.get(f'https://huggingface.co/spaces/Universal-618/Clarity-{sfx}/main-data',headers={'Authorization':f'Bearer {HF_TOKEN}'},timeout=30)\n",
+        "        if r.status_code==200:\n",
+        "            d=r.json()\n",
+        "            for x in (d if isinstance(d,list) else d.get('data',[])):\n",
+        "                add(x.get('instruction',x.get('prompt',x.get('problem',''))),x.get('response',x.get('completion',x.get('output',x.get('solution','')))))\n",
+        "    except: pass\n",
+        "\n",
+        "load_std('Open-Orca/OpenOrca','train',dict(instruction='question',response='response'),800)\n",
+        "load_msgs('HuggingFaceH4/no_robots','train',500)\n",
+        "load_msgs('HuggingFaceH4/ultrachat_200k','train_sft',500)\n",
+        "load_std('tatsu-lab/alpaca','train',dict(instruction='instruction',response='output'),500)\n",
+        "load_std('TIGER-Lab/MathInstruct','train',dict(instruction='instruction',response='output'),800)\n",
+        "load_std('AI-MO/NuminaMath-CoT','train',dict(instruction='problem',response='solution'),600)\n",
+        "load_std('meta-math/MetaMathQA','train',dict(instruction='query',response='response'),600)\n",
+        "load_std('microsoft/orca-math-word-problems-200k','train',dict(instruction='question',response='answer'),500)\n",
+        "load_std('GAIR/Reasoning-Intensive','train',dict(instruction='question',response='answer'),500)\n",
+        "load_std('BAAI/AgentInstruct','train',dict(instruction='instruction',response='output'),500)\n",
+        "load_std('bigcode/commitpackft','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('sahil2801/CodeAlpaca-20k','train',dict(instruction='instruction',response='output'),500)\n",
+        "load_std('jondurbin/airoboros-3.2','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('cognitivecomputations/dolphin','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('databricks/databricks-dolly-15k','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('WizardLM/WizardLM_evol_instruct_V2_196k','train',dict(instruction='instruction',response='output'),500)\n",
+        "load_std('Intel/orca_dpo_pairs','train',dict(instruction='question',response='chosen'),500)\n",
+        "load_std('nvidia/HelpSteer','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('Dahoas/full-hh-rlhf','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('BAAI/Infinity-Instruct','0625',dict(instruction='instruction',response='output'),500)\n",
+        "\n",
+        "print(f'Total: {len(all_samples)}')\n",
+        "random.shuffle(all_samples); gc.collect()\n"
+      ],
+      "metadata": {},
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from transformers import AutoTokenizer\n",
+        "\n",
+        "MODEL_ID='deepseek-ai/DeepSeek-R1-Distill-Qwen-14B'\n",
+        "tokz=AutoTokenizer.from_pretrained(MODEL_ID,token=HF_TOKEN,trust_remote_code=True,use_fast=True)\n",
+        "tokz.pad_token=tokz.eos_token\n",
+        "\n",
+        "def fmt(s): return tokz.apply_chat_template([{'role':'user','content':s.get('instruction','')},{'role':'assistant','content':s.get('response','')}],tokenize=False)\n",
+        "\n",
+        "ds=Dataset.from_list([{'text':fmt(s)} for s in all_samples])\n",
+        "sp=ds.train_test_split(test_size=0.01,seed=42)\n",
+        "del all_samples,ds; gc.collect()\n",
+        "print(f'Train: {len(sp[\"train\"])}  Test: {len(sp[\"test\"])}')\n"
+      ],
+      "metadata": {},
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from transformers import AutoModelForCausalLM,BitsAndBytesConfig\n",
+        "gc.collect(); torch.cuda.empty_cache()\n",
+        "\n",
+        "bnb=BitsAndBytesConfig(load_in_4bit=True,bnb_4bit_use_double_quant=True,bnb_4bit_quant_type='nf4',bnb_4bit_compute_dtype=torch.float16)\n",
+        "\n",
+        "model=AutoModelForCausalLM.from_pretrained(MODEL_ID,quantization_config=bnb,device_map='auto',dtype=torch.float16,token=HF_TOKEN,trust_remote_code=True,low_cpu_mem_usage=True)\n",
+        "model.gradient_checkpointing_enable()\n",
+        "model.config.use_cache=False\n",
+        "gc.collect(); torch.cuda.empty_cache()\n",
+        "print('Model:',round(model.num_parameters()/1e9,1),'B  trainable:',round(model.num_parameters(only_trainable=True)/1e6,1),'M')\n"
+      ],
+      "metadata": {},
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from peft import LoraConfig,get_peft_model,TaskType\n",
+        "lora=LoraConfig(task_type=TaskType.CAUSAL_LM,r=4,lora_alpha=8,lora_dropout=0.05,target_modules=['q_proj','k_proj','v_proj','o_proj','gate_proj','up_proj','down_proj'],bias='none')\n",
+        "model=get_peft_model(model,lora)\n",
+        "model.print_trainable_parameters()\n",
+        "gc.collect(); torch.cuda.empty_cache()\n"
+      ],
+      "metadata": {},
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from transformers import TrainingArguments,Trainer,DataCollatorForSeq2Seq\n",
+        "\n",
+        "def tok_fn(ex):\n",
+        "    t=tokz(ex['text'],truncation=True,max_length=256,padding=False)\n",
+        "    t['labels']=t['input_ids'].copy()\n",
+        "    return t\n",
+        "\n",
+        "tok=sp.map(tok_fn,remove_columns=['text'],batched=True,num_proc=2)\n",
+        "del sp; gc.collect()\n",
+        "\n",
+        "args=TrainingArguments(\n",
+        "    output_dir='./clarity-flash',\n",
+        "    per_device_train_batch_size=1,\n",
+        "    gradient_accumulation_steps=4,\n",
+        "    max_steps=500,\n",
+        "    learning_rate=3e-4,\n",
+        "    fp16=True,\n",
+        "    logging_steps=10,\n",
+        "    save_strategy='no',\n",
+        "    optim='adamw_8bit',\n",
+        "    report_to='none',\n",
+        "    dataloader_num_workers=0,\n",
+        "    lr_scheduler_type='cosine',\n",
+        "    warmup_steps=25,\n",
+        ")\n",
+        "\n",
+        "trainer=Trainer(model=model,args=args,train_dataset=tok['train'],data_collator=DataCollatorForSeq2Seq(tokz,padding=True,pad_to_multiple_of=8))\n",
+        "gc.collect(); torch.cuda.empty_cache()\n",
+        "trainer.train()\n"
+      ],
+      "metadata": {},
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "WEIGHTS_REPO='Universal-618/Clarity-flash-weights'\n",
+        "create_repo(WEIGHTS_REPO,repo_type='model',exist_ok=True,token=HF_TOKEN)\n",
+        "model.push_to_hub(WEIGHTS_REPO,token=HF_TOKEN,use_temp_dir=True)\n",
+        "tokz.push_to_hub(WEIGHTS_REPO,token=HF_TOKEN)\n",
+        "import sys; print('done',file=sys.stderr)\n"
+      ],
+      "metadata": {},
+      "execution_count": null,
+      "outputs": []
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python",
+      "version": "3.10.0"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 4
+}

package/clarity_heavy_20b_moe.ipynb

@@ -0,0 +1,232 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# CLARITY Heavy 20B MoE — Kaggle Single T4\n",
+        "Model: openai/gpt-oss-20b (21B MoE, 3.6B active, native MXFP4)\n",
+        "LoRA + grad ckpt + max_len=256 + no eval + no checkpoints\n"
+      ],
+      "metadata": {}
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os,gc,torch\n",
+        "from huggingface_hub import create_repo\n",
+        "HF_TOKEN=os.environ.get('HF_TOKEN')\n",
+        "if not HF_TOKEN:\n",
+        "    from kaggle_secrets import UserSecretsClient\n",
+        "    HF_TOKEN=UserSecretsClient().get_secret('HF_TOKEN')\n",
+        "assert HF_TOKEN and len(HF_TOKEN)>10, 'Set HF_TOKEN as Kaggle secret'\n"
+      ],
+      "metadata": {},
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install -q transformers datasets accelerate peft bitsandbytes sentencepiece huggingface_hub\n"
+      ],
+      "metadata": {},
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "assert torch.cuda.is_available()\n",
+        "print('GPU:',torch.cuda.get_device_name(0))\n",
+        "gc.collect(); torch.cuda.empty_cache()\n"
+      ],
+      "metadata": {},
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import requests,sys\n",
+        "from datasets import Dataset, load_dataset\n",
+        "import random\n",
+        "\n",
+        "all_samples=[]\n",
+        "def add(i,r): all_samples.append(dict(instruction=str(i or ''), response=str(r or '')))\n",
+        "\n",
+        "def load_std(n,s,f,l,**kw):\n",
+        "    try:\n",
+        "        for i,row in enumerate(load_dataset(n,split=s,streaming=True,token=HF_TOKEN,**kw)):\n",
+        "            if i>=l: break\n",
+        "            add(row.get(f['instruction'],''),row.get(f['response'],''))\n",
+        "    except Exception as e: print(f'  skip {n}: {e}', file=sys.stderr)\n",
+        "\n",
+        "def load_msgs(n,s,l,**kw):\n",
+        "    try:\n",
+        "        for i,row in enumerate(load_dataset(n,split=s,streaming=True,token=HF_TOKEN,**kw)):\n",
+        "            if i>=l: break\n",
+        "            msgs=row.get('messages',[])\n",
+        "            if len(msgs)>=2: add(msgs[0].get('content',''),msgs[-1].get('content',''))\n",
+        "    except Exception as e: print(f'  skip {n}: {e}', file=sys.stderr)\n",
+        "\n",
+        "for sfx in ['main','2','3','4','5','6']:\n",
+        "    try:\n",
+        "        r=requests.get(f'https://huggingface.co/spaces/Universal-618/Clarity-{sfx}/main-data',headers={'Authorization':f'Bearer {HF_TOKEN}'},timeout=30)\n",
+        "        if r.status_code==200:\n",
+        "            d=r.json()\n",
+        "            for x in (d if isinstance(d,list) else d.get('data',[])):\n",
+        "                add(x.get('instruction',x.get('prompt',x.get('problem',''))),x.get('response',x.get('completion',x.get('output',x.get('solution','')))))\n",
+        "    except: pass\n",
+        "\n",
+        "load_std('Open-Orca/OpenOrca','train',dict(instruction='question',response='response'),800)\n",
+        "load_msgs('HuggingFaceH4/no_robots','train',500)\n",
+        "load_msgs('HuggingFaceH4/ultrachat_200k','train_sft',500)\n",
+        "load_std('tatsu-lab/alpaca','train',dict(instruction='instruction',response='output'),500)\n",
+        "load_std('TIGER-Lab/MathInstruct','train',dict(instruction='instruction',response='output'),800)\n",
+        "load_std('AI-MO/NuminaMath-CoT','train',dict(instruction='problem',response='solution'),600)\n",
+        "load_std('meta-math/MetaMathQA','train',dict(instruction='query',response='response'),600)\n",
+        "load_std('microsoft/orca-math-word-problems-200k','train',dict(instruction='question',response='answer'),500)\n",
+        "load_std('GAIR/Reasoning-Intensive','train',dict(instruction='question',response='answer'),500)\n",
+        "load_std('BAAI/AgentInstruct','train',dict(instruction='instruction',response='output'),500)\n",
+        "load_std('bigcode/commitpackft','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('sahil2801/CodeAlpaca-20k','train',dict(instruction='instruction',response='output'),500)\n",
+        "load_std('jondurbin/airoboros-3.2','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('cognitivecomputations/dolphin','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('databricks/databricks-dolly-15k','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('WizardLM/WizardLM_evol_instruct_V2_196k','train',dict(instruction='instruction',response='output'),500)\n",
+        "load_std('Intel/orca_dpo_pairs','train',dict(instruction='question',response='chosen'),500)\n",
+        "load_std('nvidia/HelpSteer','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('Dahoas/full-hh-rlhf','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('BAAI/Infinity-Instruct','0625',dict(instruction='instruction',response='output'),500)\n",
+        "\n",
+        "print(f'Total: {len(all_samples)}')\n",
+        "random.shuffle(all_samples); gc.collect()\n"
+      ],
+      "metadata": {},
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from transformers import AutoTokenizer\n",
+        "\n",
+        "MODEL_ID='openai/gpt-oss-20b'\n",
+        "tokz=AutoTokenizer.from_pretrained(MODEL_ID,token=HF_TOKEN,trust_remote_code=True)\n",
+        "tokz.pad_token=tokz.eos_token\n",
+        "\n",
+        "def fmt(s): return tokz.apply_chat_template([{'role':'system','content':'Reasoning: high'},{'role':'user','content':s.get('instruction','')},{'role':'assistant','content':s.get('response','')}],tokenize=False)\n",
+        "\n",
+        "ds=Dataset.from_list([{'text':fmt(s)} for s in all_samples])\n",
+        "sp=ds.train_test_split(test_size=0.01,seed=42)\n",
+        "del all_samples,ds; gc.collect()\n",
+        "print(f'Train: {len(sp[\"train\"])}  Test: {len(sp[\"test\"])}')\n"
+      ],
+      "metadata": {},
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from transformers import AutoModelForCausalLM\n",
+        "import requests as req\n",
+        "gc.collect(); torch.cuda.empty_cache()\n",
+        "\n",
+        "r=req.get(f'https://huggingface.co/{MODEL_ID}/raw/main/config.json',headers={'Authorization':f'Bearer {HF_TOKEN}'})\n",
+        "cd=r.json()\n",
+        "cd.pop('_attn_implementation',None); cd.pop('attn_implementation',None)\n",
+        "\n",
+        "model=AutoModelForCausalLM.from_pretrained(MODEL_ID,config=cd,device_map='auto',token=HF_TOKEN,trust_remote_code=True,low_cpu_mem_usage=True)\n",
+        "model.gradient_checkpointing_enable()\n",
+        "model.config.use_cache=False\n",
+        "gc.collect(); torch.cuda.empty_cache()\n",
+        "print('Model:',round(model.num_parameters()/1e9,1),'B')\n"
+      ],
+      "metadata": {},
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from peft import LoraConfig,get_peft_model,TaskType\n",
+        "lora=LoraConfig(task_type=TaskType.CAUSAL_LM,r=4,lora_alpha=8,lora_dropout=0.1,target_modules=['q_proj','k_proj','v_proj','o_proj','gate_proj','up_proj','down_proj'],bias='none')\n",
+        "model=get_peft_model(model,lora)\n",
+        "model.print_trainable_parameters()\n",
+        "gc.collect(); torch.cuda.empty_cache()\n"
+      ],
+      "metadata": {},
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from transformers import TrainingArguments,Trainer,DataCollatorForSeq2Seq\n",
+        "\n",
+        "def tok_fn(ex):\n",
+        "    t=tokz(ex['text'],truncation=True,max_length=256,padding=False)\n",
+        "    t['labels']=t['input_ids'].copy()\n",
+        "    return t\n",
+        "\n",
+        "tok=sp.map(tok_fn,remove_columns=['text'],batched=True,num_proc=2)\n",
+        "del sp; gc.collect()\n",
+        "\n",
+        "args=TrainingArguments(\n",
+        "    output_dir='./clarity-heavy',\n",
+        "    per_device_train_batch_size=1,\n",
+        "    gradient_accumulation_steps=16,\n",
+        "    num_train_epochs=1,\n",
+        "    learning_rate=2e-4,\n",
+        "    fp16=True,\n",
+        "    logging_steps=10,\n",
+        "    save_strategy='no',\n",
+        "    optim='adamw_8bit',\n",
+        "    report_to='none',\n",
+        "    dataloader_num_workers=0,\n",
+        "    lr_scheduler_type='cosine',\n",
+        "    warmup_steps=25,\n",
+        ")\n",
+        "\n",
+        "trainer=Trainer(model=model,args=args,train_dataset=tok['train'],data_collator=DataCollatorForSeq2Seq(tokz,padding=True,pad_to_multiple_of=8))\n",
+        "gc.collect(); torch.cuda.empty_cache()\n",
+        "trainer.train()\n"
+      ],
+      "metadata": {},
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "WEIGHTS_REPO='Universal-618/Clarity-heavy-weights'\n",
+        "create_repo(WEIGHTS_REPO,repo_type='model',exist_ok=True,token=HF_TOKEN)\n",
+        "model.push_to_hub(WEIGHTS_REPO,token=HF_TOKEN,use_temp_dir=True)\n",
+        "tokz.push_to_hub(WEIGHTS_REPO,token=HF_TOKEN)\n",
+        "import sys; print('done',file=sys.stderr)\n"
+      ],
+      "metadata": {},
+      "execution_count": null,
+      "outputs": []
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "kaggle": {
+      "accelerator": "GPU",
+      "gpuModel": "T4",
+      "gpuCount": 2
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python",
+      "version": "3.10.0"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 4
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "clarity-ai",
-  "version": "6.3.2",
-  "description": "Premium terminal AI agent — fixed-height viewport, box-drawing UI, TrueColor theme, streaming with abort",
+  "version": "6.4.0",
+  "description": "Premium terminal AI agent — Clarity Flash 14B model, HF Inference API, fixed-height viewport, TrueColor theme",
   "type": "module",
   "bin": {
     "clarity": "bin/clarity.js"

package/src/components/CodeBlock.js

@@ -1,6 +1,6 @@
 import React, { useMemo } from 'react';
 import { Box, Text } from 'ink';
-import { hex, usym } from '../config/theme.js';
+import { hex, sym } from '../config/theme.js';
 import { getLayout } from '../config/layout.js';
 const { createElement: h } = React;
 
@@ -40,7 +40,7 @@ export function CodeBlock({ code, language }) {
       ),
       lines.length > maxLines
         ? h(Text, { color: hex.textMuted, backgroundColor: hex.codeBg },
-            '  ' + usym.ellipsis + ' ' + (lines.length - maxLines) + ' more lines')
+            '  ' + sym.ellipsis + ' ' + (lines.length - maxLines) + ' more lines')
         : null
     )
   );

package/src/components/CommandPicker.js

@@ -1,6 +1,7 @@
 import React, { useState } from 'react';
 import { Box, Text, useInput } from 'ink';
-import { hex, usym } from '../config/theme.js';
+import { hex, sym } from '../config/theme.js';
+import { getLayout } from '../config/layout.js';
 const { createElement: h } = React;
 
 const COMMANDS = [
@@ -8,7 +9,7 @@ const COMMANDS = [
   { name: '/model',    desc: 'Switch model' },
   { name: '/provider', desc: 'Switch provider' },
   { name: '/agent',    desc: 'Toggle agent mode' },
-  { name: '/stop',     desc: 'Cancel streaming' },
+  { name: '/stop',     desc: 'Cancel running stream' },
   { name: '/clear',    desc: 'Clear conversation' },
   { name: '/export',   desc: 'Export conversation' },
   { name: '/help',     desc: 'Show all commands' },
@@ -18,6 +19,7 @@ const COMMANDS = [
 export function CommandPicker({ query, onSelect, onClose }) {
   const [search, setSearch] = useState('');
   const [idx, setIdx] = useState(0);
+  const { cols } = getLayout();
 
   const filtered = COMMANDS.filter(c =>
     c.name.includes(search) || c.desc.toLowerCase().includes(search.toLowerCase())
@@ -26,40 +28,36 @@ export function CommandPicker({ query, onSelect, onClose }) {
   useInput((input, key) => {
     if (key.upArrow) setIdx(i => Math.max(0, i - 1));
     if (key.downArrow) setIdx(i => Math.min(filtered.length - 1, i + 1));
-    if (key.return) onSelect(filtered[idx]?.name || '');
+    if (key.return && filtered[idx]) onSelect(filtered[idx].name);
     if (key.escape) onClose();
     if (key.backspace) setSearch(s => s.slice(0, -1));
     else if (input && !key.ctrl && !key.meta) setSearch(s => s + input);
   });
 
-  const tw = process.stdout.columns || 80;
-  const boxWidth = Math.min(tw - 4, 50);
+  const w = Math.min(cols - 4, 48);
 
-  return h(Box, { flexDirection: 'column', width: boxWidth },
-    h(Box, { flexDirection: 'row', marginBottom: 1, gap: 1 },
-      h(Text, { color: hex.textMuted }, usym.bulb),
-      h(Text, { color: search ? hex.text : hex.textMuted }, search || 'type to filter...'),
+  return h(Box, { flexDirection: 'column', backgroundColor: hex.surfaceAlt, width: w },
+    h(Box, { height: 1, backgroundColor: hex.surfaceAlt },
+      h(Text, { color: hex.textMuted, backgroundColor: hex.surfaceAlt }, '  ' + sym.star + ' ' + (search || 'filter commands...'))
     ),
     filtered.map((cmd, i) =>
       h(Box, {
-        key: cmd.name,
-        flexDirection: 'row',
-        backgroundColor: i === idx ? hex.selectionBg : undefined,
-        width: boxWidth,
+        key: cmd.name, height: 1,
+        backgroundColor: i === idx ? hex.selectionBg : 'transparent',
       },
         h(Text, {
           color: i === idx ? hex.selectionText : hex.text,
           bold: i === idx,
-          backgroundColor: i === idx ? hex.selectionBg : undefined,
-          wrap: 'truncate-end',
-        }, '  ' + cmd.name.padEnd(16)),
+          backgroundColor: i === idx ? hex.selectionBg : 'transparent',
+        }, '  ' + cmd.name + '  '),
         h(Text, {
           color: i === idx ? hex.selectionText : hex.textDim,
-          backgroundColor: i === idx ? hex.selectionBg : undefined,
-          wrap: 'truncate-end',
+          backgroundColor: i === idx ? hex.selectionBg : 'transparent',
         }, cmd.desc)
       )
     ),
-    h(Text, { color: hex.textMuted }, ' ' + usym.arrowU + usym.arrowD + ' nav Enter select Esc close')
+    h(Box, { height: 1, backgroundColor: hex.surfaceAlt },
+      h(Text, { color: hex.textMuted, backgroundColor: hex.surfaceAlt }, '  ' + sym.arrowU + sym.arrowD + ' nav  ' + sym.arrowR + ' select  Esc close')
+    )
   );
 }