clixad 0.0.1-beta.15 → 0.0.1-beta.16

package/README.md

@@ -19,6 +19,10 @@ npm install -g clixad
 
 Requires Node.js >= 20.
 
+## Community
+
+Discord: <https://discord.gg/pwxPM3QyF> — bug reports and feature requests are read there.
+
 ## What it does
 
 It reads, searches and edits files and runs shell commands in the directory you start it in, asking

package/dist/clixad.mjs

@@ -101,6 +101,52 @@ function grantRangeLabel(range) {
   const n = (v) => v.toLocaleString("en-US");
   return low === high ? `${n(low)} credits on completion` : `${n(low)}\u2013${n(high)} credits on completion`;
 }
+function streakLabel(streak) {
+  if (streak.length <= 0 || streak.day <= 0) return null;
+  const n = (x) => x.toLocaleString("en-US");
+  const where = `day ${streak.day} of ${streak.length}`;
+  if (!streak.claimed) return `daily streak: ${where} \xB7 today's already counted`;
+  const tomorrow = streak.schedule[Math.min(streak.day, streak.length - 1)];
+  const next = tomorrow === void 0 ? "" : ` \xB7 tomorrow ${n(tomorrow)}`;
+  return `daily streak: ${where} \xB7 +${n(streak.credits)} credits${next}`;
+}
+function referLines(info) {
+  const n = (x) => x.toLocaleString("en-US");
+  const lines = [
+    `your code: ${info.code}`,
+    `share it: clixad login --invite ${info.code}`,
+    `you both get ${n(info.inviterCredits)} credits once they complete their first offer`
+  ];
+  if (info.invited === 0) {
+    lines.push("nobody has signed up with it yet");
+    return lines;
+  }
+  const waiting = info.invited - info.credited;
+  lines.push(
+    `${n(info.invited)} signed up \xB7 ${n(info.credited)} completed an offer \xB7 ${n(info.creditsEarned)} credits earned`
+  );
+  if (waiting > 0) {
+    lines.push(`${n(waiting)} haven't completed an offer yet \u2014 that pays nothing until they do`);
+  }
+  if (info.remaining === 0 && info.maxCredited > 0) {
+    lines.push(`you've been paid for the maximum of ${n(info.maxCredited)} referrals`);
+  }
+  return lines;
+}
+function redeemMessage(result) {
+  switch (result.status) {
+    case "redeemed":
+      return { ok: true, text: `+${result.credited.toLocaleString("en-US")} credits` };
+    case "used":
+      return { ok: false, text: "that code has already been used" };
+    case "expired":
+      return { ok: false, text: "that code has expired" };
+    case "wrong_account":
+      return { ok: false, text: "that code belongs to a different account \u2014 check who you're signed in as" };
+    default:
+      return { ok: false, text: "that isn't a code we recognise \u2014 check it for typos" };
+  }
+}
 function ledgerReasonLabel(reason) {
   return LEDGER_REASONS[reason] ?? reason.replace(/_/g, " ");
 }
@@ -195,6 +241,10 @@ var init_client = __esm({
     CHAT_ENCODED_CONTENT_TYPE = "application/vnd.clixad.chat+gzip";
     LEDGER_REASONS = {
       signup_bonus: "signup bonus",
+      login_streak: "daily streak",
+      feedback_bonus: "thanks for the feedback",
+      referral_bonus: "referral bonus",
+      redeem_code: "code redeemed",
       ad_reward: "offer reward",
       ad_screenout_bonus: "screenout bonus (didn't qualify)",
       ad_sponsor_impression: "sponsored line shown",
@@ -323,6 +373,138 @@ var init_client = __esm({
           return void 0;
         }
       }
+      /**
+       * Claim today's login-streak grant, or find out that today is already claimed.
+       *
+       * Safe to call from anywhere and as often as you like: the gateway keys it on
+       * `(account, UTC day)`, so the second call of the day credits nothing and
+       * answers with the same day number. That is what lets every surface which
+       * might be somebody's first contact today — a login, the REPL opening,
+       * `wallet` — claim without coordinating.
+       *
+       * **Never throws.** Like `sponsorConfig`, every caller is decorating something
+       * that already works: a gateway too old to have the route, a cold start, a
+       * dropped connection and an expired token all mean the same thing here, which
+       * is "say nothing about a streak". A missed grant is claimed by the next
+       * command; a session that died over one would be a real loss.
+       */
+      async claimStreak(signal) {
+        try {
+          const res = await fetch(`${this.config.gatewayUrl}/v1/streak/claim`, {
+            method: "POST",
+            headers: this.headers(),
+            ...signal ? { signal } : {}
+          });
+          if (!res.ok) return null;
+          const body = await res.json();
+          if (typeof body.day !== "number" || typeof body.credits !== "number") return null;
+          return {
+            day: body.day,
+            credits: body.credits,
+            claimed: body.claimed === true,
+            balance: typeof body.balance === "number" ? body.balance : 0,
+            schedule: Array.isArray(body.schedule) ? body.schedule : [],
+            length: typeof body.length === "number" ? body.length : 0
+          };
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Send one rating, and answer what it was paid.
+       *
+       * **Never throws**, for `claimStreak`'s reason and one of its own: this is
+       * called from a prompt that has already interrupted somebody, and the worst
+       * possible outcome is that answering it takes the session down. A gateway too
+       * old for the route, a cold start and an expired token all mean the same thing
+       * — the rating is lost, which costs the user nothing and us one data point.
+       *
+       * `null` for "nothing to say"; an outcome with `credited: 0` for "recorded,
+       * unpaid", which is what the daily ceiling looks like from here and is worth
+       * telling the user apart from a grant.
+       */
+      async sendFeedback(report, signal) {
+        try {
+          const res = await fetch(`${this.config.gatewayUrl}/v1/feedback`, {
+            method: "POST",
+            headers: this.headers(),
+            ...signal ? { signal } : {},
+            body: JSON.stringify({
+              session_id: report.session,
+              turn: report.turn,
+              rating: report.rating,
+              model: report.model,
+              prompt: report.prompt,
+              response: report.response,
+              ...report.steps === void 0 ? {} : { steps: report.steps }
+            })
+          });
+          if (!res.ok) return null;
+          const body = await res.json();
+          return {
+            recorded: body.recorded === true,
+            credited: typeof body.credited === "number" ? body.credited : 0,
+            balance: typeof body.balance === "number" ? body.balance : 0
+          };
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * This account's referral code and standing, minting the code if it has none.
+       *
+       * **This one throws**, unlike `claimStreak` and `sendFeedback`. Those two
+       * decorate something that already works and a failure costs a line of chrome;
+       * this *is* the command — `clixad refer` with nothing to print is a command
+       * that did not run, and saying so beats printing an empty summary.
+       */
+      async referral(signal) {
+        const res = await fetch(`${this.config.gatewayUrl}/v1/referrals`, {
+          headers: this.headers(),
+          ...signal ? { signal } : {}
+        });
+        if (res.status === 401) throw await authFailure(res, "referrals");
+        if (!res.ok) throw new Error(await httpFailure(res, "referrals"));
+        const body = await res.json();
+        const num = (value) => typeof value === "number" ? value : 0;
+        if (typeof body.code !== "string" || !body.code) {
+          throw new Error("the gateway did not return a referral code");
+        }
+        return {
+          code: body.code,
+          invited: num(body.invited),
+          credited: num(body.credited),
+          creditsEarned: num(body.credits_earned),
+          remaining: num(body.remaining),
+          maxCredited: num(body.max_credited),
+          inviterCredits: num(body.inviter_credits),
+          inviteeCredits: num(body.invitee_credits)
+        };
+      }
+      /**
+       * Spend a redeem code.
+       *
+       * **Throws**, like `referral` and unlike `claimStreak`: this is the command
+       * itself, and somebody who typed a code and got silence has been told nothing.
+       * A refusal is not a throw though — an expired or already-spent code answers
+       * 200 with a status, because that is an answer rather than a failure.
+       */
+      async redeem(code, signal) {
+        const res = await fetch(`${this.config.gatewayUrl}/v1/redeem`, {
+          method: "POST",
+          headers: this.headers(),
+          ...signal ? { signal } : {},
+          body: JSON.stringify({ code })
+        });
+        if (res.status === 401) throw await authFailure(res, "redeem");
+        if (!res.ok) throw new Error(await httpFailure(res, "redeem"));
+        const body = await res.json();
+        return {
+          status: body.status ?? "unknown",
+          credited: typeof body.credited === "number" ? body.credited : 0,
+          balance: typeof body.balance === "number" ? body.balance : 0
+        };
+      }
       async creditPacks() {
         const res = await fetch(`${this.config.gatewayUrl}/v1/billing/packs`);
         if (!res.ok) throw new Error(`packs failed: ${res.status}`);
@@ -4452,6 +4634,15 @@ var init_commands = __esm({
       // forms, surveys and app trials, and describing the top-up as a video costs
       // the user the one expectation that makes a screenout make sense.
       { name: "earn", desc: "open the offer wall to earn credits" },
+      // Deliberately *no* `args`, for /login's reason: an arg hint makes enter
+      // complete the command instead of running it, and printing the code is the
+      // whole command.
+      { name: "refer", desc: "your invite code, and what it has earned" },
+      // This one *does* carry an `args` hint, unlike /refer and /login: the code is
+      // the whole command, and `/redeem` on its own has nothing to do — so enter
+      // completing to "/redeem " is the helpful outcome rather than the surprising
+      // one.
+      { name: "redeem", args: "<code>", desc: "spend a code you were given" },
       // Reachable from inside the REPL because that is where the 401 is printed.
       // "Run `clixad login` first" is not a runnable instruction at this prompt —
       // anything without a leading slash is a prompt, so it went to the model and
@@ -4926,7 +5117,7 @@ function useTerminalSize() {
   }, [stdout]);
   return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
 }
-function App({ client, config, wallet, session, initialTask, sponsorServe }) {
+function App({ client, config, wallet, streak, session, initialTask, sponsorServe }) {
   const { exit } = useApp();
   const { stdout, write: writeToStdout } = useStdout();
   const idRef = useRef(1);
@@ -5001,6 +5192,8 @@ function App({ client, config, wallet, session, initialTask, sponsorServe }) {
   const pendingTaskRef = useRef(null);
   const mcpRef = useRef(McpHub.empty());
   const todosRef = useRef(new TodoList());
+  const lastTurnRef = useRef(null);
+  const turnCountRef = useRef(config.turns ?? 0);
   const deltaBufRef = useRef("");
   const deltaTimerRef = useRef(null);
   const sponsorRef = useRef(sponsorSource());
@@ -5080,6 +5273,8 @@ function App({ client, config, wallet, session, initialTask, sponsorServe }) {
     client.onNotice = (text2) => push({ kind: "notice", tone: "warn", text: text2 });
     const files = contextRef.current.files;
     if (files.length) push({ kind: "notice", text: `  context: ${files.join(", ")}` });
+    const streakLine = streak && streak.claimed ? streakLabel(streak) : null;
+    if (streakLine) push({ kind: "notice", tone: "good", text: `  ${streakLine}` });
     if (session?.messages.length) {
       push({ kind: "notice", text: `  resumed session ${session.id} (${session.messages.length} messages)` });
     }
@@ -5364,6 +5559,16 @@ ${NO_SEARCH_INSTRUCTION}`),
             text: result.content,
             meta: `[${result.creditsCharged} credits \xB7 balance ${result.balance.toLocaleString("en-US")}]`
           });
+          lastTurnRef.current = {
+            turn: turnCountRef.current,
+            model,
+            prompt: task,
+            response: result.content,
+            steps: result.steps
+          };
+          turnCountRef.current += 1;
+          config.turns = turnCountRef.current;
+          saveConfig(config);
         }
       } catch (err) {
         if (err instanceof PaywallError) {
@@ -5458,6 +5663,10 @@ ${NO_SEARCH_INSTRUCTION}`),
               tone: "good",
               text: `  signed in as ${account.login ?? account.email ?? "you"} \xB7 balance ${account.balance.toLocaleString("en-US")} credits` + (account.created ? " (signup bonus)" : "")
             });
+            const claimed = await client.claimStreak(signal);
+            const line2 = claimed?.claimed ? streakLabel(claimed) : null;
+            if (claimed?.claimed) setBalance(claimed.balance);
+            if (line2) push({ kind: "notice", tone: "good", text: `  ${line2}` });
             return;
           }
           case "closed":
@@ -5549,6 +5758,7 @@ ${NO_SEARCH_INSTRUCTION}`),
           expandedRef.current = /* @__PURE__ */ new Set();
           heightCacheRef.current = /* @__PURE__ */ new Map();
           todosRef.current = new TodoList();
+          lastTurnRef.current = null;
           sessionRef.current = { id: newSessionId(), started: (/* @__PURE__ */ new Date()).toISOString() };
           writeToStdout("\x1B[2J\x1B[3J\x1B[H");
           push({ kind: "notice", text: "  cleared \u2014 new session, empty context" });
@@ -5635,16 +5845,19 @@ ${NO_SEARCH_INSTRUCTION}`),
           return;
         case "wallet":
           await runBusy(LOADING, async (signal) => {
+            const streakNow = await client.claimStreak(signal);
             const w = await client.wallet(signal);
             setBalance(w.balance);
             const reversals = w.ledger.filter((e) => e.reason === "ad_reversal");
             const reversed = reversals.reduce((sum, e) => sum + Math.abs(e.delta), 0);
             const screenouts = w.screenouts_today ?? 0;
             const screenoutCredits = w.screenout_credits_today ?? 0;
+            const streakLine = streakNow && streakLabel(streakNow);
             push({
               kind: "notice",
               text: `  balance ${w.balance.toLocaleString("en-US")} credits \xB7 ${w.ads_today} offers today \xB7 $${w.earned_usd_today.toFixed(2)}/$${w.max_reward_usd_per_day.toFixed(2)} earned` + (screenouts ? `
-  plus ${screenoutCredits.toLocaleString("en-US")} credits from ${screenouts} screenout bonus${screenouts === 1 ? "" : "es"} \u2014 attempts that didn't qualify, which CPX pays a little for anyway.` : "") + (reversals.length ? `
+  plus ${screenoutCredits.toLocaleString("en-US")} credits from ${screenouts} screenout bonus${screenouts === 1 ? "" : "es"} \u2014 attempts that didn't qualify, which CPX pays a little for anyway.` : "") + (streakLine ? `
+  ${streakLine}` : "") + (reversals.length ? `
   recently: ${reversed.toLocaleString("en-US")} credits from ${reversals.length} offer${reversals.length === 1 ? "" : "s"} were reversed by the provider. Run \`clixad wallet\` for the full ledger.` : "")
             });
           });
@@ -5752,6 +5965,32 @@ ${NO_SEARCH_INSTRUCTION}`),
         case "earn":
           await runAdWall();
           return;
+        // Through `runBusy` like every other gateway call: the free instance can
+        // cold-start for the better part of a minute, and the box says "esc to
+        // stop" whenever it is locked.
+        case "refer":
+          await runBusy(LOADING, async (signal) => {
+            const info = await client.referral(signal);
+            push({ kind: "notice", text: referLines(info).map((line3) => `  ${line3}`).join("\n") });
+          });
+          return;
+        case "redeem": {
+          if (!arg) {
+            push({ kind: "notice", tone: "warn", text: "  usage: /redeem <code>" });
+            return;
+          }
+          await runBusy(LOADING, async (signal) => {
+            const result = await client.redeem(arg, signal);
+            const { ok, text: text2 } = redeemMessage(result);
+            if (ok) setBalance(result.balance);
+            push({
+              kind: "notice",
+              tone: ok ? "good" : "warn",
+              text: ok ? `  ${text2} \xB7 balance ${result.balance.toLocaleString("en-US")}` : `  ${text2}`
+            });
+          });
+          return;
+        }
         case "login":
           await runLogin(arg);
           return;
@@ -5819,14 +6058,58 @@ ${output}` }
     },
     [push, root, runCommand, runShell, runTurn2]
   );
+  const askFeedback = useCallback(async () => {
+    const turn = lastTurnRef.current;
+    if (!turn) return;
+    lastTurnRef.current = null;
+    const amount = wallet?.rewards?.feedback_credits;
+    const pay = amount ? `Both answers pay ${amount.toLocaleString("en-US")} credits` : "Both answers pay the same";
+    const choice = await new Promise((resolve2) => {
+      setPickerSel(0);
+      setPicker({
+        title: "Was that last answer any good?",
+        subtitle: `${pay} \xB7 we keep that exchange to test against \xB7 esc skips`,
+        items: [
+          { value: "up", label: "yes \u2014 that worked", hint: "" },
+          { value: "down", label: "no \u2014 that missed", hint: "" },
+          { value: "skip", label: "skip", hint: "nothing is sent, nothing is stored" }
+        ],
+        onPick: (item) => resolve2(item.value),
+        // Esc and "skip" are the same outcome and must stay that way: a skip
+        // that cost something is a prompt people stop reading.
+        onCancel: () => resolve2(null)
+      });
+    });
+    if (choice !== "up" && choice !== "down") return;
+    await runBusy(SENDING_FEEDBACK, async (signal) => {
+      const outcome = await client.sendFeedback(
+        { ...turn, session: sessionRef.current.id, rating: choice },
+        signal
+      );
+      if (!outcome) return;
+      if (outcome.credited > 0) setBalance(outcome.balance);
+      push({
+        kind: "notice",
+        tone: "good",
+        text: outcome.credited > 0 ? `  thanks \u2014 +${outcome.credited.toLocaleString("en-US")} credits` : (
+          // Recorded and unpaid: the daily ceiling, or a turn already rated.
+          // Worth saying, because the offer of credits was made a moment ago.
+          "  thanks \u2014 noted (today's feedback credits are already in)"
+        )
+      });
+    });
+  }, [client, push, runBusy, wallet]);
   const runSerially = useCallback(
     async (line2) => {
       await dispatchLine(line2);
       for (let next = dequeue(); next !== void 0; next = dequeue()) {
         await dispatchLine(next);
       }
+      if (lastTurnRef.current && turnCountRef.current % FEEDBACK_TURN_INTERVAL === 0) {
+        await askFeedback();
+      }
     },
-    [dequeue, dispatchLine]
+    [askFeedback, dequeue, dispatchLine]
   );
   const submit = useCallback(
     async (raw) => {
@@ -6326,7 +6609,7 @@ function tailLines(text, max) {
   const lines = text.split("\n");
   return lines.length <= max ? text : lines.slice(-max).join("\n");
 }
-var WORKING, WAITING_FOR_REWARD, LOADING, COMPACTING, SIGNING_IN, RUNNING, NOT_SIGNED_IN, LIVE_OUTPUT_LINES, COMMITTED_OUTPUT_LINES, DELTA_FLUSH_MS, MAX_INPUT_ROWS, MAX_PICKER_ROWS, MAX_QUEUE_ROWS, QUEUE_MARKER, PICKER_CURRENT, MIN_PICKER_LABEL_COLS, PICKER_CHROME, PICKER_CHROME_COMPACT, ASK_CHROME, PLAN_CHROME, ASK_HINT, PLAN_HINT, EXPAND_MAX_LINES, FALLBACK_ROWS, FALLBACK_COLS, CONTEXT_NOTICE_AT, KEEP_ALWAYS;
+var WORKING, WAITING_FOR_REWARD, LOADING, COMPACTING, SIGNING_IN, RUNNING, SENDING_FEEDBACK, FEEDBACK_TURN_INTERVAL, NOT_SIGNED_IN, LIVE_OUTPUT_LINES, COMMITTED_OUTPUT_LINES, DELTA_FLUSH_MS, MAX_INPUT_ROWS, MAX_PICKER_ROWS, MAX_QUEUE_ROWS, QUEUE_MARKER, PICKER_CURRENT, MIN_PICKER_LABEL_COLS, PICKER_CHROME, PICKER_CHROME_COMPACT, ASK_CHROME, PLAN_CHROME, ASK_HINT, PLAN_HINT, EXPAND_MAX_LINES, FALLBACK_ROWS, FALLBACK_COLS, CONTEXT_NOTICE_AT, KEEP_ALWAYS;
 var init_app = __esm({
   "src/tui/app.tsx"() {
     "use strict";
@@ -6363,6 +6646,8 @@ var init_app = __esm({
     COMPACTING = "compacting\u2026";
     SIGNING_IN = "signing in\u2026";
     RUNNING = "running\u2026";
+    SENDING_FEEDBACK = "sending\u2026";
+    FEEDBACK_TURN_INTERVAL = 50;
     NOT_SIGNED_IN = "  Not signed in, or the stored token isn't valid for this gateway.\n  Run /login to sign in.";
     LIVE_OUTPUT_LINES = 5;
     COMMITTED_OUTPUT_LINES = 4;
@@ -6485,6 +6770,10 @@ async function main() {
       return showWallet(client);
     case "earn":
       return earn(client, config);
+    case "refer":
+      return refer(client, config);
+    case "redeem":
+      return redeem(client, config, rest[0]);
     case "buy":
       return buyCmd(client, config, rest[0]);
     case "ask":
@@ -6546,6 +6835,7 @@ async function login(client, config, args) {
 \u2713 logged in as ${who}`) + suffix);
       const bonus = account.created ? c.dim(account.signupBonus === void 0 ? " (signup bonus)" : ` (signup bonus ${credits(account.signupBonus)})`) : "";
       console.log(`  balance: ${c.bold(credits(account.balance))} credits${bonus}`);
+      await showStreak(client);
       console.log(c.dim(`  token stored in ${configPath()}`));
       return;
     }
@@ -6630,9 +6920,12 @@ async function setModel(client, config, model) {
   console.log(c.green(`\u2713 model set to ${model}`));
 }
 async function showWallet(client) {
+  const streak = await client.claimStreak();
   const w = await client.wallet();
   console.log(`balance: ${c.bold(w.balance.toLocaleString("en-US"))} credits`);
   console.log(`${earnedToday(w)}  \xB7  offers pay ${grantRangeLabel(w.grant_per_ad_range)}`);
+  const line2 = streak && streakLabel(streak);
+  if (line2) console.log(streak.claimed ? c.green(line2) : c.dim(line2));
   if (w.ledger.length) {
     console.log(c.dim("recent:"));
     const label = (e) => ledgerReasonLabel(e.reason);
@@ -6679,6 +6972,40 @@ async function earn(client, config) {
   );
   console.log(c.yellow("  pays nothing and is normal. Start another, or check `clixad wallet` later."));
 }
+async function refer(client, config) {
+  if (!config.token) return console.log(c.yellow("Not logged in. Run `clixad login` first."));
+  let info;
+  try {
+    info = await client.referral();
+  } catch (err) {
+    console.error(c.red(err.message));
+    process.exitCode = 1;
+    return;
+  }
+  const [code, share, deal, ...rest] = referLines(info);
+  console.log(`
+  ${c.bold(code)}`);
+  console.log(`  ${c.cyan(share)}`);
+  console.log(c.dim(`  ${deal}`));
+  for (const line2 of rest) console.log(c.dim(`  ${line2}`));
+  console.log("");
+}
+async function redeem(client, config, code) {
+  if (!config.token) return console.log(c.yellow("Not logged in. Run `clixad login` first."));
+  if (!code) return console.error(c.red("usage: clixad redeem <code>"));
+  let result;
+  try {
+    result = await client.redeem(code);
+  } catch (err) {
+    console.error(c.red(err.message));
+    process.exitCode = 1;
+    return;
+  }
+  const { ok, text } = redeemMessage(result);
+  if (!ok) return console.log(c.yellow(`  ${text}`));
+  console.log(c.green(`
+\u2713 ${text}`) + `  \xB7  balance ${c.bold(credits(result.balance))}`);
+}
 async function buyCmd(client, config, pack) {
   if (!config.token) return console.log(c.yellow("Not logged in. Run `clixad login` first."));
   const { enabled, packs } = await client.creditPacks();
@@ -6845,10 +7172,11 @@ async function repl(client, config, opts = {}) {
     session = loadSession(opts.resume);
     if (!session) return console.log(c.red(`no such session: ${opts.resume}`));
   }
+  const streak = await client.claimStreak();
   const wallet = await safeWallet(client);
   clearScreen();
   const { startTui: startTui2 } = await Promise.resolve().then(() => (init_tui(), tui_exports));
-  await startTui2({ client, config, wallet, session, initialTask: opts.task });
+  await startTui2({ client, config, wallet, streak, session, initialTask: opts.task });
 }
 async function runTurn(client, config, messages) {
   try {
@@ -6875,6 +7203,13 @@ async function runTurn(client, config, messages) {
     return void 0;
   }
 }
+async function showStreak(client) {
+  const streak = await client.claimStreak();
+  const line2 = streak && streakLabel(streak);
+  if (!line2) return streak;
+  console.log(streak.claimed ? c.green(`  ${line2}`) : c.dim(`  ${line2}`));
+  return streak;
+}
 async function safeWallet(client) {
   try {
     return await client.wallet();
@@ -6892,6 +7227,8 @@ function printHelp() {
   ${c.cyan("model")} <id>        set default model
   ${c.cyan("wallet")}            balance, ads today, ledger
   ${c.cyan("earn")}              open the ad wall to earn credits
+  ${c.cyan("refer")}             your invite code, and what it has earned
+  ${c.cyan("redeem")} <code>     spend a code you were given
   ${c.cyan("buy")} [pack]         list credit packs / buy one via Stripe
   ${c.cyan("ask")} "<prompt>"    one-shot completion (no tools)
   ${c.cyan("agent")} "<task>"    open the REPL with a task already running
@@ -6901,7 +7238,9 @@ function printHelp() {
   ${c.cyan("--resume")} [id]     list saved sessions, or resume one
   ${c.cyan("--version")}         print the version and exit
   (no command)        interactive coding REPL ${c.dim("(signs you in if needed)")}
-  "<task>"            same as ${c.cyan("agent")} \u2014 anything that is not a command is a task`);
+  "<task>"            same as ${c.cyan("agent")} \u2014 anything that is not a command is a task
+
+  ${c.dim("Discord: https://discord.gg/pwxPM3QyF \u2014 bugs and feature requests are read there")}`);
 }
 main().catch((err) => {
   console.error(c.red(err.message));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clixad",
-  "version": "0.0.1-beta.15",
+  "version": "0.0.1-beta.16",
   "description": "Free AI coding agent in your terminal, funded by rewarded ads.",
   "license": "UNLICENSED",
   "type": "module",