@noobdemon/noob-cli 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 yukkis3nse1
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,137 @@
+# noob — agentic coding CLI
+
+A Claude-Code-style coding agent that lives in your terminal, powered by
+**Noob Demon** (34 models across 8 providers — GPT, Claude, Gemini, DeepSeek,
+Grok, Qwen, Kimi, Llama).
+
+It reads and edits files, runs shell commands, and iterates on a task — asking
+permission before anything destructive — all inside a polished terminal UI.
+
+```
+  ███╗   ██╗ ██████╗  ██████╗ ██████╗
+  ████╗  ██║██╔═══██╗██╔═══██╗██╔══██╗
+  ██╔██╗ ██║██║   ██║██║   ██║██████╔╝
+  ██║╚██╗██║██║   ██║██║   ██║██╔══██╗
+  ██║ ╚████║╚██████╔╝╚██████╔╝██████╔╝
+  ╚═╝  ╚═══╝ ╚═════╝  ╚═════╝ ╚═════╝
+```
+
+## Install
+
+```bash
+cd "noob cli"
+npm install
+npm link          # optional: makes `noob` available globally
+```
+
+Requires Node.js ≥ 18 (tested on 22).
+
+## Xác thực & gói cước (Authentication)
+
+noob đi qua một **gateway** (Cloudflare Worker `claude-code-proxy`) để ẩn backend
+thật và quản lý API key qua Supabase. Bạn cần một API key để dùng:
+
+```bash
+noob login nk_xxx_xxxxxxxx     # đăng nhập, key lưu ở ~/.noob/config.json
+noob usage                     # xem hạn mức còn lại
+noob logout                    # đăng xuất
+```
+
+Trong phiên: `/login <key>`, `/usage`, `/logout`.
+
+**Các gói:**
+
+| Gói | Hạn mức |
+|---|---|
+| `pro` | 5 000 request / 5 giờ (cửa sổ trượt) |
+| `proplus` | 10 000 request / 5 giờ |
+| `admin` | không giới hạn |
+| `trial` | 200 request dùng thử, hết là key **dead** |
+
+> Mỗi lệnh gọi mô hình (kể cả từng bước tool trong một tác vụ) tính là 1 request.
+
+Cấp/huỷ key (admin) — trong repo gateway `D:\Dev\free claude code`:
+
+```bash
+node scripts/admin.mjs create pro "khách A"
+node scripts/admin.mjs list
+node scripts/admin.mjs revoke nk_pro_xxx
+```
+
+## Use
+
+```bash
+noob                                   # interactive session
+noob "add input validation to api.js"  # start with a request
+noob -m gateway-claude-opus-4-7        # pick a model
+noob --yolo                            # auto-approve edits & commands
+```
+
+Without `npm link`, run `node bin/noob.js …`.
+
+### In-session commands
+
+| Command | What it does |
+|---|---|
+| `/model [name]` | switch model (fuzzy match), or list all |
+| `/models` | list every model grouped by provider |
+| `/merge` | toggle **Merge AI** — synthesizes GPT-5.5 + Claude + Gemini via o3 |
+| `/search` | toggle **web search** mode |
+| `/chat` | back to normal chat mode |
+| `/yolo` | toggle auto-approve for file/command tools (or **Shift+Tab**) |
+| `/clear` `/new` | wipe conversation context |
+| `/status` | show current model + working directory |
+| `/exit` | quit (Ctrl+C once = stop turn, twice = quit) |
+
+## How it works
+
+The Noob Demon gateway is a **stateless single-message** endpoint with no native
+function-calling. noob layers an agent on top:
+
+1. The full transcript (system prompt + history + tool results) is serialized into
+   one `message` and streamed to the gateway's `/api/chat`.
+2. The model replies with either a final answer or a single \`\`\`tool JSON block.
+3. noob parses the tool call, asks permission if it's destructive, executes it, and
+   feeds the result back — looping until the model answers without a tool block.
+
+### Tools the agent can call
+
+`read_file` · `write_file` · `edit_file` · `list_dir` · `glob` · `grep` · `run_command`
+
+Destructive tools (`write_file`, `edit_file`, `run_command`) prompt for approval
+(`y` / `n` / `a`lways) unless `/yolo` is on.
+
+## Configuration
+
+| Env var | Effect |
+|---|---|
+| `NOOB_API_BASE` | override the gateway URL |
+| `NOOB_API_KEY` | API key (overrides `~/.noob/config.json`) |
+| `NOOB_INSECURE_TLS=1` | disable TLS verification — **last resort** for machines behind a TLS-intercepting proxy. Prefer adding your proxy CA to the trust store. |
+
+## Model compatibility
+
+The agent drives tools through a text protocol (the proxy has no native
+function-calling). Models differ in how willingly they follow it:
+
+| Provider | Agentic tools | Notes |
+|---|---|---|
+| **Anthropic** (Claude) | ✅ best | default — `gateway-claude-opus-4-7` |
+| **DeepSeek** | ✅ works | good free alternative |
+| OpenAI (GPT/o-series) | ⚠️ often refuses | replies "I can't access your filesystem" |
+| Google (Gemini) | ⚠️ often refuses | same |
+
+Stick with Claude or DeepSeek for file edits & commands. Any model is fine for
+plain chat, `/merge`, and `/search`.
+
+## Notes & limits
+
+- Free shared proxy: rate limits and occasional hiccups are expected.
+- Context is sent in full each turn, so very long sessions cost more tokens — use
+  `/clear` to reset.
+- This is an unofficial tool built against a public community endpoint; it is not
+  affiliated with Anthropic or the model providers.
+
+## License
+
+MIT

package/bin/noob.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import { startRepl } from "../src/repl.js";
+import { config } from "../src/config.js";
+import { usage, ApiError } from "../src/api.js";
+import { c } from "../src/ui.js";
+import { t } from "../src/i18n.js";
+
+const argv = process.argv.slice(2);
+const opts = { yolo: false, model: undefined, prompt: undefined };
+const positional = [];
+
+for (let i = 0; i < argv.length; i++) {
+  const a = argv[i];
+  if (a === "--yolo" || a === "-y") opts.yolo = true;
+  else if (a === "--insecure-tls") process.env.NOOB_INSECURE_TLS = "1";
+  else if (a === "--model" || a === "-m") opts.model = argv[++i];
+  else if (a === "--help" || a === "-h") {
+    printHelp();
+    process.exit(0);
+  } else positional.push(a);
+}
+
+const sub = positional[0];
+
+// ── subcommands ──────────────────────────────────────────────────────────
+if (sub === "login") {
+  const key = positional[1];
+  if (!key) {
+    console.log(c.err(t.needKeyArg));
+    process.exit(1);
+  }
+  config.setKey(key);
+  console.log(c.ok("✓ ") + t.loginSaved(config.path));
+  try {
+    const u = await usage();
+    if (u.ok) console.log(c.ok(t.loginOk({ pro: "Pro", proplus: "Pro+", admin: "Admin", trial: "Trial" }[u.plan] || u.plan)));
+    else console.log(c.err("✗ " + t.errInvalidKey));
+  } catch {
+    /* network — key still saved */
+  }
+  process.exit(0);
+} else if (sub === "logout") {
+  config.clearKey();
+  console.log(c.ok(t.loggedOut));
+  process.exit(0);
+} else if (sub === "usage") {
+  if (!config.apiKey) {
+    console.log(c.tool(t.notLoggedIn));
+    process.exit(1);
+  }
+  try {
+    const u = await usage();
+    console.log(JSON.stringify(u, null, 2));
+  } catch (err) {
+    console.log(c.err("✗ " + (err.message || t.errConn)));
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
+if (positional.length) opts.prompt = positional.join(" ");
+
+startRepl(opts).catch((err) => {
+  console.error(c.err("lỗi nghiêm trọng: " + (err?.stack || err?.message || err)));
+  process.exit(1);
+});
+
+function printHelp() {
+  console.log(`noob — trợ lý lập trình CLI · Noob Demon
+
+Cách dùng:
+  noob [tuỳ chọn] ["yêu cầu ban đầu"]
+  noob login <api-key>     đăng nhập bằng API key
+  noob logout              đăng xuất
+  noob usage               xem hạn mức key
+
+Tuỳ chọn:
+  -m, --model <id>    chọn mô hình (vd: gateway-claude-opus-4-7)
+  -y, --yolo          tự động duyệt sửa file & chạy lệnh (cẩn thận)
+      --insecure-tls  tắt kiểm tra TLS (chỉ cho mạng có proxy chặn TLS)
+  -h, --help          hiện trợ giúp
+
+Trong phiên: gõ /help để xem mọi lệnh.`);
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@noobdemon/noob-cli",
+  "version": "1.0.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Trợ lý lập trình agentic trong terminal (kiểu Claude Code), tiếng Việt, dùng sức mạnh Noob Demon — 34 mô hình AI.",
+  "type": "module",
+  "bin": {
+    "noob": "bin/noob.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node bin/noob.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "cli",
+    "ai",
+    "coding-agent",
+    "claude-code",
+    "gemini-cli",
+    "agent",
+    "tui",
+    "llm",
+    "vietnamese"
+  ],
+  "author": "yukkis3nse1",
+  "license": "MIT",
+  "dependencies": {
+    "boxen": "^8.0.1",
+    "chalk": "^5.4.1",
+    "cli-highlight": "^2.1.11",
+    "gradient-string": "^3.0.0",
+    "ora": "^8.2.0"
+  }
+}

package/src/agent.js

@@ -0,0 +1,116 @@
+import { stream } from "./api.js";
+import { t } from "./i18n.js";
+
+export const SYSTEM = `You are noob, an agentic coding assistant in the spirit of Claude Code. You help with software engineering tasks by reading and editing files and running commands in the user's current working directory.
+
+You do NOT access anything yourself. Instead, a local runtime executes tools on your behalf: you emit a tool-call JSON block, the runtime runs it on the user's machine and replies with the result. This is fully supported — never claim you "can't access the terminal/filesystem". Just emit the tool call.
+
+# Tools
+To call a tool, emit EXACTLY ONE fenced code block tagged \`tool\` containing a single JSON object, and nothing after it:
+
+\`\`\`tool
+{"name": "<tool>", "input": { ... }}
+\`\`\`
+
+Then STOP and wait — the runtime executes the tool and replies with a TOOL RESULT. Use one tool per step. When the task is complete (or you are only answering a question), reply normally in Markdown with NO tool block.
+
+Available tools:
+- read_file   {"path": str, "offset"?: int, "limit"?: int}   — read a file (1-indexed lines)
+- write_file  {"path": str, "content": str}                   — create/overwrite a file
+- edit_file   {"path": str, "old_string": str, "new_string": str, "replace_all"?: bool} — exact string replace; old_string must be unique unless replace_all
+- list_dir    {"path"?: str}                                  — list a directory
+- glob        {"pattern": str}                                — find files by glob (supports ** and *)
+- grep        {"pattern": str, "path"?: str, "glob"?: str}    — regex search file contents
+- run_command {"command": str}                                — run a shell command in the cwd
+
+# Rules
+- Investigate before editing: read the relevant files first; never invent file contents.
+- Make the smallest change that fully solves the task. Match the surrounding code style.
+- Prefer edit_file over write_file for existing files.
+- After changes, verify when sensible (run a build/test/lint command).
+- Keep prose tight. Explain what you did and why, not how to use a tool.
+- JSON in the tool block must be valid: escape newlines as \\n inside string values.
+- LANGUAGE: Always write your prose answers to the user in Vietnamese (tiếng Việt), unless the user explicitly writes in another language. Keep code, file paths, commands, and tool JSON unchanged.
+
+# Example interaction
+## USER
+how many lines are in app.js?
+## ASSISTANT
+\`\`\`tool
+{"name": "run_command", "input": {"command": "wc -l app.js"}}
+\`\`\`
+## TOOL RESULT (run_command)
+42 app.js
+[exit code 0]
+## ASSISTANT
+app.js has 42 lines.
+
+Follow this pattern exactly. Your very first response to a task that needs the filesystem MUST be a tool block — do not refuse or explain limitations.`;
+
+const MAX_STEPS = 30;
+
+// The proxy is stateless, so we serialize the whole transcript into one prompt.
+function buildPrompt(history) {
+  const parts = [SYSTEM, "", "=".repeat(60), "# CONVERSATION", ""];
+  for (const m of history) {
+    if (m.role === "user") parts.push(`## USER\n${m.content}`);
+    else if (m.role === "assistant") parts.push(`## ASSISTANT\n${m.content}`);
+    else if (m.role === "tool") parts.push(`## TOOL RESULT (${m.name})\n${m.content}`);
+    parts.push("");
+  }
+  parts.push("=".repeat(60));
+  parts.push("Continue. Emit a tool block to act, or reply in Markdown if done.");
+  return parts.join("\n");
+}
+
+// Extract a single tool call from an assistant message, if present.
+export function parseToolCall(text) {
+  // Preferred: ```tool { ... } ```
+  let m = text.match(/```tool\s*\n([\s\S]*?)```/);
+  // Fallback: a ```json block that contains a "name" field.
+  if (!m) {
+    const j = text.match(/```json\s*\n([\s\S]*?)```/);
+    if (j && /"name"\s*:/.test(j[1])) m = j;
+  }
+  if (!m) return null;
+  try {
+    const obj = JSON.parse(m[1].trim());
+    if (obj && typeof obj.name === "string") return { name: obj.name, input: obj.input || {} };
+  } catch {
+    /* malformed — treat as prose */
+  }
+  return null;
+}
+
+/**
+ * Run one agent turn (which may span several tool steps).
+ *
+ * @param {object} opts
+ * @param {Array} opts.history            mutated in place with assistant/tool msgs
+ * @param {string} opts.model
+ * @param {AbortSignal} opts.signal
+ * @param {(name:string,input:object)=>Promise<{allow:boolean,result?:string}>} opts.onTool
+ *        Called for every tool call. Should handle permission + execution and
+ *        return the textual result (or {allow:false} to feed a denial back).
+ * @param {(msg:string)=>void} opts.onStatus      thinking/streaming status
+ * @returns {Promise<string>} the final assistant answer (no tool block)
+ */
+export async function runAgent({ history, model, signal, onTool, onStatus }) {
+  for (let step = 0; step < MAX_STEPS; step++) {
+    const prompt = buildPrompt(history);
+    onStatus?.("thinking");
+    const { text } = await stream({ mode: "chat", model, message: prompt, signal });
+    history.push({ role: "assistant", content: text });
+
+    const call = parseToolCall(text);
+    if (!call) return text; // final answer
+
+    const { allow, result } = await onTool(call.name, call.input);
+    history.push({
+      role: "tool",
+      name: call.name,
+      content: allow ? result : t.toolDenied,
+    });
+  }
+  return t.maxSteps;
+}

package/src/api.js

@@ -0,0 +1,106 @@
+// Client for the noob gateway (claude-code-proxy worker). The gateway validates
+// the API key against Supabase, enforces plan limits, and hides the real
+// upstream. The CLI only ever sees the gateway URL + the user's key.
+import { config } from "./config.js";
+
+// Opt-in TLS escape hatch for machines behind a TLS-intercepting / broken-
+// revocation proxy. Off by default. Prefer fixing the trust store.
+if (process.env.NOOB_INSECURE_TLS === "1") {
+  process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+}
+
+function authHeaders() {
+  const h = { "Content-Type": "application/json" };
+  if (config.apiKey) h["Authorization"] = "Bearer " + config.apiKey;
+  return h;
+}
+
+class ApiError extends Error {
+  constructor(message, { status, code, reset_at, plan } = {}) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status;
+    this.code = code;
+    this.reset_at = reset_at;
+    this.plan = plan;
+  }
+}
+
+async function parseError(resp) {
+  let j = null;
+  try {
+    j = await resp.json();
+  } catch {}
+  return new ApiError(j?.error || `HTTP ${resp.status}`, {
+    status: resp.status,
+    code: j?.code,
+    reset_at: j?.reset_at,
+    plan: j?.plan,
+  });
+}
+
+/**
+ * Stream a chat/merge/search request from the gateway.
+ * @returns {Promise<{text:string, reasoning:string}>}
+ */
+export async function stream({ mode = "chat", message, model, signal, onDelta, onReasoning, onStatus }) {
+  const endpoint = mode === "search" ? "/api/search" : mode === "merge" ? "/api/merge" : "/api/chat";
+  const body = mode === "search" ? { query: message } : mode === "merge" ? { message } : { message, model };
+
+  const resp = await fetch(config.gatewayUrl + endpoint, {
+    method: "POST",
+    headers: authHeaders(),
+    body: JSON.stringify(body),
+    signal,
+  });
+
+  if (!resp.ok || !resp.body) throw await parseError(resp);
+
+  const reader = resp.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  let text = "";
+  let reasoning = "";
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+    let nl;
+    while ((nl = buf.indexOf("\n")) !== -1) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      if (!line.startsWith("data:")) continue;
+      const data = line.slice(5).trim();
+      if (!data) continue;
+      let p;
+      try {
+        p = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      if (p.status && onStatus) onStatus(p.status);
+      if (p.delta) {
+        text += p.delta;
+        onDelta?.(p.delta);
+      }
+      if (p.reasoning) {
+        reasoning = p.reasoning;
+        onReasoning?.(p.reasoning);
+        if (p.answer) text = p.answer;
+      }
+      if (p.error) throw new ApiError(p.error, { status: resp.status });
+    }
+  }
+
+  return { text: text.trim(), reasoning: reasoning.trim() };
+}
+
+/** Fetch the current key's quota/usage from the gateway (no request consumed). */
+export async function usage() {
+  const resp = await fetch(config.gatewayUrl + "/api/usage", { headers: authHeaders() });
+  if (!resp.ok) throw await parseError(resp);
+  return await resp.json();
+}
+
+export { ApiError };

package/src/config.js

@@ -0,0 +1,61 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+// Default gateway — the Noob Demon endpoint. The real upstream is hidden behind
+// it; the CLI only ever talks to this gateway.
+const DEFAULT_GATEWAY = "https://claude-code-proxy.lohieuky678.workers.dev";
+
+const DIR = path.join(os.homedir(), ".noob");
+const FILE = path.join(DIR, "config.json");
+
+function read() {
+  try {
+    return JSON.parse(fs.readFileSync(FILE, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+function write(cfg) {
+  try {
+    fs.mkdirSync(DIR, { recursive: true });
+    fs.writeFileSync(FILE, JSON.stringify(cfg, null, 2), "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+let cache = read();
+
+export const config = {
+  get gatewayUrl() {
+    return process.env.NOOB_API_BASE || cache.gatewayUrl || DEFAULT_GATEWAY;
+  },
+  get apiKey() {
+    return process.env.NOOB_API_KEY || cache.apiKey || "";
+  },
+  get model() {
+    return cache.model || "";
+  },
+  setKey(key) {
+    cache.apiKey = key;
+    write(cache);
+  },
+  clearKey() {
+    delete cache.apiKey;
+    write(cache);
+  },
+  setGateway(url) {
+    cache.gatewayUrl = url;
+    write(cache);
+  },
+  setModel(id) {
+    cache.model = id;
+    write(cache);
+  },
+  get path() {
+    return FILE;
+  },
+};

package/src/i18n.js

@@ -0,0 +1,82 @@
+// Vietnamese UI strings for noob CLI. Single language (tiếng Việt).
+export const t = {
+  tagline: "trợ lý lập trình trong terminal · sức mạnh từ Noob Demon",
+  ready: "Nhập yêu cầu của bạn, hoặc gõ /help để xem lệnh.",
+  promptYou: "bạn ",
+  thinking: "đang suy nghĩ",
+  searching: "đang tìm trên web",
+  merging: "đang tổng hợp đa mô hình",
+  bye: "tạm biệt 👋",
+  interrupted: "đã ngắt",
+  pressAgainToExit: "nhấn Ctrl+C lần nữa để thoát",
+  running: "đang chạy…",
+  denied: "đã từ chối",
+
+  // auth
+  notLoggedIn:
+    "Bạn chưa đăng nhập. Chạy:  noob login <api-key>\nChưa có key? Liên hệ admin để lấy key (Pro / Pro+ / Trial).",
+  loginOk: (plan) => `Đăng nhập thành công. Gói: ${plan}.`,
+  loginSaved: (p) => `Đã lưu API key vào ${p}`,
+  loggedOut: "Đã đăng xuất, xoá API key khỏi máy.",
+  needKeyArg: "Thiếu key. Dùng:  noob login <api-key>",
+
+  // usage
+  usageTitle: "Hạn mức API key",
+  plan: "Gói",
+  status: "Trạng thái",
+  remaining: "Còn lại",
+  used: "Đã dùng",
+  unlimited: "không giới hạn",
+  resetAt: "Đặt lại lúc",
+  trialLeft: (n) => `${n} lượt dùng thử còn lại`,
+  windowInfo: (used, limit) => `${used}/${limit} trong cửa sổ 5 giờ`,
+
+  // errors (gateway codes → VN)
+  errMissingKey: "Thiếu API key. Chạy: noob login <key>",
+  errInvalidKey: "API key không hợp lệ.",
+  errKeyDead: "API key đã bị vô hiệu hoá (dead).",
+  errTrialExhausted: "Key dùng thử đã hết 200 lượt — key đã dead. Liên hệ admin để nâng cấp.",
+  errDisabled: "API key đã bị khoá.",
+  errRateLimited: (reset) =>
+    `Đã hết hạn mức trong cửa sổ 5 giờ.${reset ? " Đặt lại lúc " + reset + "." : " Thử lại sau."}`,
+  errConn: "Lỗi kết nối tới máy chủ.",
+
+  // help
+  helpTitle: "noob · trợ giúp",
+  helpCommands: "Lệnh",
+  helpTips: "Mẹo",
+  cmdModel: "/model [tên]   đổi mô hình, hoặc liệt kê tất cả",
+  cmdModels: "/models        liệt kê mọi mô hình",
+  cmdMerge: "/merge         bật/tắt Merge AI (tổng hợp đa mô hình)",
+  cmdSearch: "/search        bật/tắt chế độ tìm web",
+  cmdChat: "/chat          quay lại chế độ chat thường",
+  cmdYolo: "/yolo          bật/tắt tự duyệt (hoặc nhấn Shift+Tab)",
+  cmdClear: "/clear /new    xoá ngữ cảnh hội thoại",
+  cmdLogin: "/login <key>   đăng nhập bằng API key",
+  cmdLogout: "/logout        đăng xuất",
+  cmdUsage: "/usage         xem hạn mức key còn lại",
+  cmdStatus: "/status        xem mô hình + thư mục hiện tại",
+  cmdExit: "/exit /quit     thoát",
+  tip1: "• Mô tả việc cần làm; noob sẽ đọc/sửa file & chạy lệnh giúp bạn.",
+  tip2: "• Thao tác nguy hiểm sẽ hỏi phép, trừ khi bật yolo (Shift+Tab).",
+  tip3: "• Ctrl+C 1 lần = dừng lượt hiện tại, 2 lần = thoát. CLI không tự tắt sau khi xong.",
+
+  // misc
+  yoloOn: "⚠ yolo BẬT — tự động duyệt mọi thao tác sửa file & chạy lệnh",
+  yoloOff: "✓ yolo TẮT — sẽ hỏi trước khi sửa file & chạy lệnh",
+  mergeOn: "Merge AI: BẬT",
+  mergeOff: "Merge AI: TẮT",
+  searchOn: "Tìm web: BẬT",
+  searchOff: "Tìm web: TẮT",
+  backToChat: "quay lại chế độ chat",
+  ctxCleared: "đã xoá ngữ cảnh",
+  unknownCmd: (c) => `không rõ lệnh: /${c}`,
+  tryHelp: "(gõ /help)",
+  noModelMatch: (q) => `không có mô hình khớp "${q}"`,
+  modelListHint: "/model <tên>  để chuyển",
+  switchTo: "→ đã chuyển",
+  providerRefuses: (p) =>
+    `lưu ý: mô hình ${p} trên gateway này hay từ chối giao thức tool; nên dùng Anthropic/DeepSeek cho tác vụ sửa code.`,
+  maxSteps: "_(đã dừng: chạm giới hạn số bước tool)_",
+  toolDenied: "Người dùng từ chối thao tác này. Hãy đổi cách làm hoặc hỏi lại.",
+};