clinkz-cli 0.0.0-stage → 0.2.3

package/anim.js

@@ -0,0 +1,46 @@
+// Terminal motion for clinkz: the logo sweep on start and the working spinner. Only runs on a real, colour-capable
+// terminal; piped output stays plain. NO_COLOR or CLINKZ_NO_ANIM turns it off.
+const live = () => Boolean(process.stdout.isTTY) && !process.env.NO_COLOR && !process.env.CLINKZ_NO_ANIM;
+const LOGO = [
+  " ██████╗██╗     ██╗███╗   ██╗██╗  ██╗███████╗",
+  "██╔════╝██║     ██║████╗  ██║██║ ██╔╝╚══███╔╝",
+  "██║     ██║     ██║██╔██╗ ██║█████╔╝   ███╔╝ ",
+  "██║     ██║     ██║██║╚██╗██║██╔═██╗  ███╔╝  ",
+  "╚██████╗███████╗██║██║ ╚████║██║  ██╗███████╗",
+  " ╚═════╝╚══════╝╚═╝╚═╝  ╚═══╝╚═╝  ╚═╝╚══════╝",
+];
+const WIDTH = LOGO[0].length, STOPS = [[122, 85, 255], [182, 162, 255], [255, 255, 255]];
+const mix = (a, b, t) => Math.round(a + (b - a) * t);
+function shade(t) { const p = Math.min(0.999, Math.max(0, t)) * (STOPS.length - 1), i = Math.floor(p), k = p - i; return STOPS[i].map((v, n) => mix(v, STOPS[i + 1][n], k)); }
+const ink = (ch, t) => { const [r, g, b] = shade(t); return `\x1b[38;2;${r};${g};${b}m${ch}`; };
+const RESET = "\x1b[0m", HIDE = "\x1b[?25l", SHOW = "\x1b[?25h", CLEAR = "\r\x1b[2K";
+const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+const put = (s) => process.stdout.write(s);
+process.on("exit", () => { if (live()) put(SHOW); });
+
+function rows(upTo) {
+  return LOGO.map((line) => { let out = ""; for (let i = 0; i < WIDTH; i++) { const ch = i < upTo ? line[i] : " "; if (ch === " ") { out += " "; continue; } const glow = i > upTo - 5; out += glow ? `\x1b[38;2;255;255;255m${ch}` : ink(ch, i / (WIDTH - 1)); } return out + RESET; }).join("\n");
+}
+/** The logo wipes in from the left behind a white edge. Skipped when the terminal is too narrow for it. */
+export async function banner() {
+  if (!live() || (process.stdout.columns || 80) < WIDTH + 2) return false;
+  put(HIDE + "\n");
+  for (let col = 0; col <= WIDTH + 4; col += 3) { put(rows(col)); await wait(22); put(`\r\x1b[${LOGO.length - 1}A`); }
+  put(rows(WIDTH + 8) + "\n" + SHOW); return true;
+}
+
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const WORDS = ["Thinking", "Nocking", "Drawing the bow", "Taking aim", "Reading the wind", "Fletching", "Tracing the arrow"];
+/** One line that spins while nothing is printing. start() may be called again to change the label. */
+export function spinner() {
+  let timer = null, label = null, t0 = 0, n = 0;
+  const draw = () => {
+    const secs = Math.floor((Date.now() - t0) / 1000), word = label || WORDS[Math.floor(secs / 4) % WORDS.length];
+    const [r, g, b] = shade(0.5 + 0.5 * Math.sin(n / 5)); n++;
+    put(`${CLEAR}\x1b[38;2;${r};${g};${b}m${FRAMES[n % FRAMES.length]} ${word}…${RESET} \x1b[2m(${secs}s)${RESET}`);
+  };
+  return {
+    start(text = null) { if (!live()) return; label = text; if (timer) return; t0 = Date.now(); put(HIDE); draw(); timer = setInterval(draw, 90); },
+    stop() { if (!timer) return; clearInterval(timer); timer = null; put(CLEAR + SHOW); },
+  };
+}

package/build.js

@@ -0,0 +1,97 @@
+// clinkz build: vibe coding in the terminal. The model runs on the server; its tools run here, in the current folder.
+// Nothing escapes that folder, secret files stay unreadable, and every write and command waits for the user's yes.
+import { spawn } from "node:child_process";
+import { lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+import { banner, spinner } from "./anim.js";
+
+const ROOT_LIMIT = 200_000, OUTPUT_LIMIT = 20_000, COMMAND_MS = 120_000, ROUNDS = 30;
+const SECRET = /(^|[\\/])(\.env[^\\/]*|\.ssh|\.aws|\.npmrc|id_rsa[^\\/]*|id_ed25519[^\\/]*|[^\\/]*\.pem|[^\\/]*\.key|[^\\/]*wallet[^\\/]*\.json|config\.json)($|[\\/])/i;
+const SKIP = new Set(["node_modules", ".git", "dist", ".next"]);
+const SAFE_ENV = () => Object.fromEntries(Object.entries(process.env).filter(([k]) => !/KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL|MNEMONIC/i.test(k)));
+
+/** Resolve a model-supplied path inside the workspace, or throw. Links are followed so they cannot lead outside. */
+export function inside(root, given, { write = false } = {}) {
+  const raw = String(given ?? ""); if (!raw || raw.includes("\0")) throw new Error("Bad path.");
+  const full = path.resolve(root, raw), rel = path.relative(root, full);
+  if (rel.startsWith("..") || path.isAbsolute(rel)) throw new Error("That path is outside the project folder.");
+  if (SECRET.test(rel)) throw new Error("Secret files are off limits.");
+  if (write && /(^|[\\/])\.git($|[\\/])/.test(rel)) throw new Error("The .git folder is off limits.");
+  let probe = full; for (;;) { try { lstatSync(probe); break; } catch { const up = path.dirname(probe); if (up === probe) break; probe = up; } }
+  const real = realpathSync(probe), back = path.relative(realpathSync(root), real);
+  if (back.startsWith("..") || path.isAbsolute(back)) throw new Error("That path leads outside the project folder.");
+  return full;
+}
+function listing(root, dir, depth, out) {
+  for (const e of readdirSync(dir, { withFileTypes: true })) { if (SKIP.has(e.name)) continue; const p = path.join(dir, e.name), rel = path.relative(root, p); if (SECRET.test(rel)) continue; out.push(rel + (e.isDirectory() ? "/" : "")); if (e.isDirectory() && depth > 0 && out.length < 400) listing(root, p, depth - 1, out); }
+  return out;
+}
+function runCommand(command, cwd) {
+  return new Promise((resolve) => {
+    const child = spawn(command, { cwd, shell: true, env: SAFE_ENV(), stdio: ["ignore", "pipe", "pipe"] }); let out = "";
+    const take = (d) => { process.stdout.write(d); out = (out + d).slice(-OUTPUT_LIMIT); };
+    child.stdout.on("data", take); child.stderr.on("data", take);
+    const timer = setTimeout(() => { child.kill(); out += `\n(Stopped after ${COMMAND_MS / 1000} s.)`; }, COMMAND_MS);
+    child.on("close", (code) => { clearTimeout(timer); resolve(`exit code ${code}\n${out}`); });
+    child.on("error", (e) => { clearTimeout(timer); resolve(`Could not start: ${e.message}`); });
+  });
+}
+
+export async function runBuild({ api, stream, clean, ui, task }) {
+  const root = process.cwd(), { dim, bold, green, red, violet, yellow } = ui;
+  if (path.resolve(root) === path.resolve(homedir()) || path.dirname(root) === root) throw new Error("Run this inside a project folder, not your home or drive root.");
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout }), lines = rl[Symbol.asyncIterator]();
+  const ask = async (q) => { process.stdout.write(q); const r = await lines.next(); return r.done ? null : r.value.trim(); };
+  let writesOk = false; const spin = spinner();
+  const STEP = { list_files: "Looking around", read_file: "Reading the code", write_file: "Writing code", run_command: "Preparing a command" };
+  const tools = {
+    list_files: (i) => listing(root, inside(root, i.path || "."), 3, []).join("\n") || "(empty folder)",
+    read_file: (i) => { const f = inside(root, i.path); if (statSync(f).size > ROOT_LIMIT) throw new Error("File is too large to read."); return readFileSync(f, "utf8"); },
+    async write_file(i) {
+      const f = inside(root, i.path, { write: true }); if (typeof i.content !== "string") throw new Error("Content is missing.");
+      console.log(`  ${yellow("write")} ${clean(i.path)} ${dim(`(${i.content.split("\n").length} lines)`)}`);
+      if (!writesOk) { const a = (await ask(`  ${bold("Allow?")} [y] yes  [a] all writes  [n] no: `))?.toLowerCase(); if (a === "a") writesOk = true; else if (a !== "y") throw new Error("The user declined this write."); }
+      mkdirSync(path.dirname(f), { recursive: true }); writeFileSync(f, i.content); return "Written.";
+    },
+    async run_command(i) {
+      if (typeof i.command !== "string" || !i.command.trim()) throw new Error("Command is missing.");
+      console.log(`  ${yellow("run")} ${clean(i.command)}\n  ${dim(clean(i.why || ""))}`);
+      if ((await ask(`  ${bold("Run it?")} [y] yes  [n] no: `))?.toLowerCase() !== "y") throw new Error("The user declined this command.");
+      return runCommand(i.command, root);
+    },
+  };
+  const messages = [];
+  async function turn(text) {
+    messages.push({ role: "user", content: text });
+    for (let round = 0; round < ROUNDS; round++) {
+      let final = null, midLine = false; spin.start();
+      try {
+        await stream("/api/build", { method: "POST", body: JSON.stringify({ messages }) }, (ev, d) => {
+          if (ev === "delta") { spin.stop(); const t = clean(d); process.stdout.write(t); midLine = !t.endsWith("\n"); }
+          else if (ev === "trial") { spin.stop(); console.log(dim(`  Free trial: ${d.left} build${d.left === 1 ? "" : "s"} left after this one.`)); spin.start(); }
+          else if (ev === "working") { if (midLine) { process.stdout.write("\n"); midLine = false; } spin.start(STEP[d.name] || "Working"); }
+          else if (ev === "message") final = d; else if (ev === "error") throw new Error(d.message);
+        });
+      } finally { spin.stop(); }
+      if (midLine) process.stdout.write("\n");
+      if (!final) throw new Error("The server ended the step early.");
+      if (final.stop_reason !== "tool_use") { messages.push({ role: "assistant", content: final.content }); if (final.stop_reason === "max_tokens") console.log(yellow("That answer hit the length limit. Ask for a smaller step.")); return; }
+      messages.push({ role: "assistant", content: final.content }); const results = [];
+      for (const b of final.content) {
+        if (b.type !== "tool_use") continue;
+        try { const h = Object.hasOwn(tools, b.name) ? tools[b.name] : null; if (!h) throw new Error("Unknown tool."); if (b.name === "list_files" || b.name === "read_file") console.log(dim(`  › ${b.name === "read_file" ? "read " + clean(b.input?.path) : "looked through the folder"}`)); const out = await h(b.input || {}); results.push({ type: "tool_result", tool_use_id: b.id, content: String(out).slice(0, OUTPUT_LIMIT * 10) }); }
+        catch (e) { console.log(`  ${red("✕")} ${clean(e.message)}`); results.push({ type: "tool_result", tool_use_id: b.id, content: String(e.message), is_error: true }); }
+      }
+      messages.push({ role: "user", content: results });
+    }
+    console.log(yellow("Stopped after too many steps."));
+  }
+  const drawn = await banner();
+  console.log(`${drawn ? "" : violet(bold("CLINKZ build")) + " "}${dim(`${drawn ? "build " : ""}· ${clean(root)}`)}\n${dim("Describe what you want. It asks before every write and command. /exit to leave.")}`);
+  let next = task || (await ask(violet("› ")));
+  try {
+    while (next && next !== "/exit" && next !== "/quit") { await turn(`Project folder: ${path.basename(root)}. CLINKZ API base: ${api}.\n\n${next}`); console.log(green("Done.")); next = task ? null : await ask(violet("› ")); while (next === "") next = await ask(violet("› ")); }
+  } finally { rl.close(); }
+}

package/clinkz.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+// clinkz: the CLINKZ terminal client. Plain language goes to the agent on the server; commands read the public API.
+// It keeps no wallet and no private key, and it never sends a transaction. The only secret is the access code.
+import { randomBytes } from "node:crypto";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { banner, spinner } from "./anim.js";
+import { runBuild } from "./build.js";
+
+const DIR = path.join(homedir(), ".clinkz"), FILE = path.join(DIR, "config.json");
+const DEFAULT_API = "https://clinkzai.xyz";
+const color = process.stdout.isTTY && !process.env.NO_COLOR;
+const paint = (code) => (s) => (color ? `\x1b[${code}m${s}\x1b[0m` : String(s));
+const dim = paint(2), bold = paint(1), green = paint(32), red = paint(31), violet = paint(35), yellow = paint(33);
+
+// Token names and alert text come from strangers. Control characters are stripped so they cannot drive the terminal.
+const clean = (s) => String(s ?? "").replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g, "");
+const num = (v, d = 0) => Number(v || 0).toLocaleString("en-US", { maximumFractionDigits: d });
+const usd = (v) => (v == null ? "—" : v >= 1e6 ? `$${(v / 1e6).toFixed(2)}M` : v >= 1e3 ? `$${(v / 1e3).toFixed(1)}k` : v >= 1 ? `$${v.toFixed(2)}` : `$${Number(v).toPrecision(3)}`);
+const pct = (v) => (v == null ? "—" : `${v > 0 ? "+" : ""}${Number(v).toFixed(Math.abs(v) >= 100 ? 0 : 1)}%`);
+const tint = (v) => (v == null ? dim : v >= 0 ? green : red);
+const pad = (s, n) => { const t = clean(s); return t.length > n ? t.slice(0, n - 1) + "…" : t.padEnd(n); };
+const die = (m) => { console.error(red(clean(m))); process.exitCode = 1; };
+
+async function load() { try { return JSON.parse(await readFile(FILE, "utf8")); } catch { return {}; } }
+async function save(c) { await mkdir(DIR, { recursive: true }); await writeFile(FILE, JSON.stringify(c, null, 1), { mode: 0o600 }); }
+const cfg = await load();
+const server = (url) => url.replace(/\/$/, "");
+let API = server(process.env.CLINKZ_API || cfg.api || DEFAULT_API);
+const headers = () => ({ "content-type": "application/json", ...(cfg.code ? { "x-clinkz-code": cfg.code, "x-clinkz-device": cfg.device } : {}) });
+
+async function failure(r) { let m = r.statusText; try { const j = await r.json(); m = j.message || j.error || m; } catch {} return new Error(m); }
+async function get(p) { const r = await fetch(API + p, { headers: headers(), signal: AbortSignal.timeout(30_000) }); if (!r.ok) throw await failure(r); return r.json(); }
+async function stream(p, init, on) {
+  const r = await fetch(API + p, { ...init, headers: headers() }); if (!r.ok) throw await failure(r);
+  const dec = new TextDecoder(); let buf = "";
+  for await (const chunk of r.body) { buf += dec.decode(chunk, { stream: true }); let i; while ((i = buf.indexOf("\n\n")) >= 0) { const block = buf.slice(0, i); buf = buf.slice(i + 2); let ev = "message", data = null; for (const line of block.split("\n")) { if (line.startsWith("event: ")) ev = line.slice(7); else if (line.startsWith("data: ")) { try { data = JSON.parse(line.slice(6)); } catch {} } } if (data !== null) on(ev, data); } }
+}
+
+const LABEL = { discover: "reading the feed", search: "searching", get_pair: "reading the pair", alerts: "reading signals", track_record: "reading the record", scam_check: "running the scam check", forecast: "writing a forecast" };
+const STATUS = { ok: green("●"), warn: yellow("●"), bad: red("●"), unknown: dim("●") };
+const printStep = (s) => console.log(`  ${STATUS[s.status] || dim("●")} ${bold(clean(s.title))} ${dim(clean(s.detail))}`);
+
+async function ask(history) {
+  let text = "", midLine = false; const spin = spinner(); spin.start();
+  const line = (s) => { spin.stop(); if (midLine) { process.stdout.write("\n"); midLine = false; } console.log(s); };
+  await stream("/api/agent", { method: "POST", body: JSON.stringify({ messages: history.slice(-12) }) }, (ev, d) => {
+    if (ev === "delta") { spin.stop(); const t = clean(d); text += t; process.stdout.write(t); midLine = !t.endsWith("\n"); }
+    else if (ev === "tool") { line(dim(`  › ${LABEL[d.name] || "working"}…`)); spin.start(); }
+    else if (ev === "step") { spin.stop(); if (midLine) line(""); printStep(d); spin.start(); }
+    else if (ev === "error") line(red(clean(d.message)));
+  }).finally(() => spin.stop());
+  if (midLine) process.stdout.write("\n");
+  return text;
+}
+async function repl() {
+  if (!cfg.code) return die("Not logged in. Get a code on the CLINKZ dashboard, then run: clinkz login <code>");
+  const drawn = await banner();
+  console.log(`${drawn ? "" : violet(bold("CLINKZ")) + " "}${dim("terminal · type a question, /exit to leave. CLINKZ does not give financial advice.")}`);
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout }); const history = [];
+  for (;;) {
+    let q; try { q = (await rl.question(violet("› "))).trim(); } catch { break; }
+    if (!q) continue; if (q === "/exit" || q === "/quit") break; if (q === "/clear") { history.length = 0; console.log(dim("Cleared.")); continue; }
+    history.push({ role: "user", content: q });
+    try { const a = await ask(history); if (a) history.push({ role: "assistant", content: a }); else history.pop(); } catch (e) { history.pop(); die(e.message); }
+  }
+  rl.close();
+}
+
+const chainOf = (f) => (f.chain === "all" ? "" : f.chain || "robinhood");
+const flags = (args) => { const f = {}, rest = []; for (let i = 0; i < args.length; i++) { const m = args[i].match(/^--(\w+)$/); if (m) f[m[1]] = args[++i]; else rest.push(args[i]); } return { f, rest }; };
+const row = (p) => `${pad(p.base.symbol, 12)} ${dim(p.chain === "solana" ? "SOL" : "RH ")} ${usd(p.priceUsd).padStart(10)} ${tint(p.change.h1)(pct(p.change.h1).padStart(8))} ${usd(p.vol.h1).padStart(9)} ${usd(p.liq).padStart(9)}  ${dim(clean(p.pair))}`;
+const head = () => console.log(dim(`${"TOKEN".padEnd(12)} CH  ${"PRICE".padStart(10)} ${"1H".padStart(8)} ${"VOL 1H".padStart(9)} ${"LIQ".padStart(9)}  PAIR`));
+const alert = (a) => console.log(`${(a.severity === "high" ? red : a.severity === "mid" ? yellow : dim)("●")} ${bold(clean(a.title))} ${clean(a.symbol || "")} ${dim(clean(a.detail))}`);
+const need = (cond, usage) => { if (!cond) throw new Error("Usage: " + usage); };
+
+const COMMANDS = {
+  async login(args) {
+    const { f, rest } = flags(args); need(rest[0], "clinkz login <code> [--api <url>]");
+    const next = { ...cfg, code: rest[0].trim(), device: cfg.device || randomBytes(16).toString("hex"), ...(f.api ? { api: f.api } : {}) }; Object.assign(cfg, next); if (f.api) API = server(f.api);
+    await save(next); const me = await get("/api/access/me"); if (!me.wallet) { delete next.code; await save(next); throw new Error("That code was not accepted."); }
+    console.log(green(`Logged in as ${clean(me.short || me.wallet)} · ${clean(me.tier)} · ${me.quota - me.used} analyst calls left today.`));
+  },
+  async logout() { await rm(FILE, { force: true }); console.log("Logged out."); },
+  async whoami() { const me = await get("/api/access/me"); console.log(me.wallet ? `${clean(me.short || me.wallet)} · ${clean(me.tier)} · ${me.used}/${me.quota} analyst calls today · ${API}` : `Not logged in · ${API}`); },
+  async discover(args) { const { f } = flags(args); const q = new URLSearchParams({ tab: f.tab || "trending", limit: f.limit || "15", minLiq: f.minliq || "5000", chain: chainOf(f) }); const r = await get(`/api/discover?${q}`); head(); r.pairs.forEach((p) => console.log(row(p))); },
+  async search(args) { need(args[0], "clinkz search <text>"); const r = await get(`/api/search?q=${encodeURIComponent(args.join(" "))}`); head(); r.pairs.forEach((p) => console.log(row(p))); },
+  async pair([chain, pair]) { need(chain && pair, "clinkz pair <chain> <pair>"); const r = await get(`/api/pair/${encodeURIComponent(chain)}/${encodeURIComponent(pair)}`); head(); console.log(row(r.pair)); if (r.verdict) console.log(`Verdict: ${bold(clean(r.verdict.verdict))} ${r.verdict.score}/100 ${dim(clean(r.verdict.summary))}`); r.signals.slice(0, 5).forEach(alert); },
+  async alerts(args) { const { f } = flags(args); const r = await get(`/api/alerts?limit=${encodeURIComponent(f.limit || 15)}&chain=${chainOf(f)}`); r.alerts.reverse().forEach(alert); },
+  async watch(args) { const { f } = flags(args); console.log(dim("Watching signals. Ctrl+C to stop.")); await stream(`/api/stream?chain=${chainOf(f)}`, {}, (ev, d) => { if (ev === "alert") alert(d); }); },
+  async build(args) { if (!cfg.code) throw new Error("Not logged in. Get a code on the CLINKZ dashboard, then run: clinkz login <code>"); await runBuild({ api: API, stream, clean, ui: { dim, bold, green, red, violet, yellow }, task: args.join(" ") }); },
+  async record() { const { data: r } = await get("/api/v1/record"); console.log(`Forecasts ${num(r.forecasts)} · resolved ${num(r.resolved)} · direction hit ${r.directionHitRate ?? "—"}% · range hit ${r.rangeHitRate ?? "—"}% · verdicts ${num(r.verdicts)}`); },
+  async scan([chain, pair]) {
+    need(chain && pair, "clinkz scan <chain> <pair>");
+    await stream(`/api/scan/${encodeURIComponent(chain)}/${encodeURIComponent(pair)}`, {}, (ev, d) => {
+      if (ev === "step") printStep(d); else if (ev === "weighing") console.log(dim("  › weighing the evidence…")); else if (ev === "error") die(d.message);
+      else if (ev === "verdict") { console.log(`\n${bold(clean(d.verdict).toUpperCase())} ${d.score}/100 · ${clean(d.confidence)} confidence\n${clean(d.summary)}`); (d.flags || []).forEach((x) => console.log(`  ${x.severity === "high" ? red("!") : yellow("!")} ${clean(x.label)}: ${dim(clean(x.evidence))}`)); if (d.missing?.length) console.log(dim(`Missing: ${d.missing.map(clean).join(" · ")}`)); }
+    });
+  },
+  async forecast([chain, pair, horizon]) { need(chain && pair, "clinkz forecast <chain> <pair> [1h|4h|24h]"); const r = await fetch(`${API}/api/forecast/${encodeURIComponent(chain)}/${encodeURIComponent(pair)}`, { method: "POST", headers: headers(), body: JSON.stringify({ horizon }) }); if (!r.ok) throw await failure(r); const { forecast: f } = await r.json(); console.log(`${bold(clean(f.direction).toUpperCase())} ${clean(f.horizon)} · ${f.rangePct[0]}% to ${f.rangePct[1]}% · ${clean(f.confidence)} confidence\n${clean(f.summary)}\n${dim("Invalidation: " + clean(f.invalidation))}`); },
+  help() {
+    console.log(`${violet(bold("clinkz"))} ${dim("· CLINKZ in your terminal")}
+
+  clinkz                         chat with CLINKZ
+  clinkz "new Solana tokens?"    ask one question
+  clinkz login <code>            log in with a code from the dashboard
+  clinkz build ["what to make"]  build a tool in this folder, no coding needed
+  clinkz discover                live feed  ${dim("--chain solana|all --tab --limit --minliq")}
+  clinkz search <text>           find a token
+  clinkz pair <chain> <pair>     read one pair
+  clinkz scan <chain> <pair>     scam check
+  clinkz forecast <chain> <pair> [1h|4h|24h]
+  clinkz alerts                  latest signals  ${dim("--chain solana|all --limit")}
+  clinkz watch                   stream signals live
+  clinkz record                  public track record
+  clinkz whoami | logout
+
+${dim(`Server: ${API} (set CLINKZ_API to change it). CLINKZ never sees your keys and never sends a transaction.`)}`);
+  },
+};
+
+const [cmd, ...args] = process.argv.slice(2);
+try {
+  if (!cmd) await repl();
+  else if (cmd === "--help" || cmd === "-h") COMMANDS.help();
+  else if (Object.hasOwn(COMMANDS, cmd)) await COMMANDS[cmd](args);
+  else { if (!cfg.code) throw new Error("Not logged in. Get a code on the CLINKZ dashboard, then run: clinkz login <code>"); await ask([{ role: "user", content: [cmd, ...args].join(" ") }]); }
+} catch (e) { die(e.message); }

package/package.json

@@ -1,6 +1,10 @@
 {
   "name": "clinkz-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.3",
+  "description": "CLINKZ in your terminal: live signals, scam checks and forecasts for Solana and Robinhood Chain, in plain language.",
+  "type": "module",
+  "bin": { "clinkz": "clinkz.js" },
+  "files": ["clinkz.js", "build.js", "anim.js"],
+  "engines": { "node": ">=20" },
+  "license": "MIT"
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.