gent-cli 13.0.0 → 15.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gent-cli",
-  "version": "13.0.0",
+  "version": "15.0.0",
   "description": "A modern, Git-like version control CLI with cloud sync, AI-powered superpowers (ask/review/docs/changelog), and zero-friction setup (gent setup/doctor/config).",
   "main": "src/index.js",
   "bin": {

package/src/commands/login.js

@@ -8,12 +8,14 @@ const inquirer = require('inquirer');
 const ora = require('ora');
 const boxen = require('boxen');
 const authService = require('../services/auth-service');
+const pet = require('./pet');
 
 /**
  * Login user
  * @param {Object} options - Command options
  */
 async function login(options) {
+    pet.banner('Knock knock — let\'s sign you in.', 'Enter your details below.');
     console.log(chalk.cyan('\n🔐 Login to your Gent account\n'));
 
     try {
@@ -75,6 +77,8 @@ ${chalk.bold('Commands:')}
             borderColor: 'cyan'
         }));
 
+        await pet.celebrate('auth');
+
     } catch (error) {
         console.error(chalk.red('\n✗ Login failed'));
         console.error(chalk.red(`Error: ${error.message}\n`));

package/src/commands/pet.js

@@ -379,73 +379,122 @@ const SCENES = {
 const HIDE = '\x1b[?25l';
 const SHOW = '\x1b[?25h';
 const CLEAR_LINE = '\x1b[2K';
+const HOME = '\x1b[H';
+const ENTER_ALT = '\x1b[?1049h';   // switch to the alternate screen buffer
+const LEAVE_ALT = '\x1b[?1049l';   // …and restore the user's scrollback on exit
 const up = (n) => `\x1b[${n}A`;
 
 /**
- * Play a scene. Redraws IN PLACE (no full-screen clear, no scrollback spam).
- * Resolves when finished.
+ * Play a scene. Resolves when finished.
+ *
+ * Two redraw strategies:
+ *  - altScreen:true  → take over the whole screen (alternate buffer), redraw
+ *    from HOME each frame, restore on exit. Zero scrollback drift. Used by the
+ *    standalone `gent pet` command.
+ *  - altScreen:false → inline redraw below existing output via cursor-up, so a
+ *    command's own text stays visible above. Used by post-command celebrations.
  *
  * @param {string}  sceneName
  * @param {object}  opts
- * @param {boolean} opts.loop     keep looping until Ctrl+C (default: play once)
- * @param {boolean} opts.footer   show the "Ctrl+C to leave / try …" hint line
- * @param {boolean} opts.goodbye  print a farewell line when done
+ * @param {boolean} opts.loop       keep looping until Ctrl+C (default: play once)
+ * @param {boolean} opts.footer     show the hint line under the stage
+ * @param {boolean} opts.goodbye    print a farewell line when done
+ * @param {boolean} opts.altScreen  use the alternate screen buffer
  * @returns {Promise<void>}
  */
-function play(sceneName, { loop = false, footer = true, goodbye = false } = {}) {
-    return new Promise((resolve) => {
-        const scene = SCENES[sceneName] || SCENES.idle;
-        const cv = new Canvas(CV_W, CV_H);
-        const state = { count: 0, tip: TIPS[Math.floor(Math.random() * TIPS.length)] };
-        const totalTicks = loop ? Infinity : scene.cycle + 1; // one clean cycle
-        let t = 0;
-        let printed = false;
-        let done = false;
-
-        const footerLine = () => footer
-            ? chalk.gray('  ') +
-              (loop ? chalk.gray('Ctrl+C to leave') : C.body('Genti')) +
-              chalk.gray('   ·   more scenes: ') + C.say('gent pet push|pull|merge')
-            : '';
-
-        // Draw one frame, moving the cursor back over the previous frame.
-        const paint = () => {
-            cv.clear();
-            scene.fn(cv, t, state);
-            if (sceneName === 'idle' && loop && t > 0 && t % scene.cycle === 0) {
-                state.tip = TIPS[Math.floor(Math.random() * TIPS.length)];
-            }
-            const lines = cv.render().split('\n');
-            lines.push(footerLine());
-            const block = lines.map(l => CLEAR_LINE + l).join('\n');
+function runLoop(sceneName, {
+    loop = false, footer = true, goodbye = false, altScreen = false,
+    maxTicks = Infinity, clearOnStop = false, exitOnSig = false,
+} = {}) {
+    const scene = SCENES[sceneName] || SCENES.idle;
+    const cv = new Canvas(CV_W, CV_H);
+    const state = { count: 0, tip: TIPS[Math.floor(Math.random() * TIPS.length)] };
+    const totalTicks = loop ? Infinity : Math.min(scene.cycle + 1, maxTicks);
+    const blockH = CV_H + (footer ? 1 : 0);
+    let t = 0;
+    let printed = false;
+    let done = false;
+    let resolveFn;
+    const promise = new Promise((r) => { resolveFn = r; });
+
+    const footerLine = () => footer
+        ? chalk.gray('  ') +
+          (loop ? chalk.gray('Ctrl+C to cancel') : C.body('Genti')) +
+          chalk.gray('   ·   more scenes: ') + C.say('gent pet push|pull|merge')
+        : '';
+
+    const paint = () => {
+        cv.clear();
+        scene.fn(cv, t, state);
+        if (sceneName === 'idle' && loop && t > 0 && t % scene.cycle === 0) {
+            state.tip = TIPS[Math.floor(Math.random() * TIPS.length)];
+        }
+        const lines = cv.render().split('\n');
+        lines.push(footerLine());
+        const block = lines.map(l => CLEAR_LINE + l).join('\n');
+        if (altScreen) {
+            process.stdout.write(HOME + block);
+        } else {
             if (printed) process.stdout.write(up(lines.length));
             process.stdout.write(block + '\n');
-            printed = true;
-        };
-
-        const finish = () => {
-            if (done) return;
-            done = true;
-            clearInterval(timer);
-            process.removeListener('SIGINT', onSig);
-            process.stdout.write(SHOW);
-            if (goodbye) {
-                console.log(C.body('  Genti waves.') + chalk.gray(' Come back with ') + C.say('gent pet') + chalk.gray('.'));
-            }
-            resolve();
-        };
+        }
+        printed = true;
+    };
 
-        const onSig = () => finish();
+    // Erase the inline block so the caller can print clean output in its place.
+    const eraseBlock = () => {
+        if (!printed) return;
+        process.stdout.write(up(blockH));
+        for (let i = 0; i < blockH; i++) process.stdout.write(CLEAR_LINE + (i < blockH - 1 ? '\n' : ''));
+        process.stdout.write(up(blockH - 1));
+    };
+
+    const stop = () => {
+        if (done) return;
+        done = true;
+        clearInterval(timer);
+        process.removeListener('SIGINT', onSig);
+        if (clearOnStop && !altScreen) eraseBlock();
+        process.stdout.write(SHOW + (altScreen ? LEAVE_ALT : ''));
+        if (goodbye) {
+            console.log(C.body('  Genti waves.') + chalk.gray(' Come back with ') + C.say('gent pet') + chalk.gray('.'));
+        }
+        resolveFn();
+    };
 
-        process.stdout.write(HIDE);
+    const onSig = () => { stop(); if (exitOnSig) process.exit(130); };
+
+    process.stdout.write((altScreen ? ENTER_ALT + HOME : '') + HIDE);
+    paint();
+    const timer = setInterval(() => {
+        t++;
+        if (t >= totalTicks) { paint(); return stop(); }
         paint();
-        const timer = setInterval(() => {
-            t++;
-            if (t >= totalTicks) { paint(); return finish(); }
-            paint();
-        }, FRAME_MS);
-        process.on('SIGINT', onSig);
-    });
+    }, FRAME_MS);
+    process.on('SIGINT', onSig);
+
+    return { promise, stop };
+}
+
+// Play a scene to completion (or until Ctrl+C when looping). Resolves when done.
+function play(sceneName, opts = {}) {
+    return runLoop(sceneName, opts).promise;
+}
+
+/**
+ * A compact STATIC Genti header — safe to print above an interactive prompt
+ * (inquirer, etc.) because it never animates or moves the cursor.
+ * @param {string} greeting  bold line beside the mascot
+ * @param {string} [sub]     dimmer line under the greeting
+ */
+function banner(greeting, sub) {
+    if (process.env.GENT_NO_PET || !process.stdout.isTTY) return;
+    const cv = new Canvas(52, 9);
+    cv.sprite(mascot({}), 1, 0);
+    cv.sprite(legs('stand'), 1, 7);
+    cv.text(18, 2, greeting, C.body);
+    if (sub) cv.text(18, 4, sub, C.say);
+    console.log('\n' + cv.render());
 }
 
 // Static single frame for non-TTY (piped) output.
@@ -476,8 +525,9 @@ async function petCommand(scene, options = {}) {
     }
 
     if (!process.stdout.isTTY) return still(name);
-    // Default: play once. `--loop` keeps it running until Ctrl+C.
-    await play(name, { loop: !!options.loop, footer: true, goodbye: true });
+    // Default: play once, on the alternate screen so nothing pollutes scrollback.
+    // `--loop` keeps it running until Ctrl+C.
+    await play(name, { loop: !!options.loop, footer: true, goodbye: true, altScreen: true });
 }
 
 /**
@@ -492,9 +542,38 @@ async function celebrate(scene) {
         if (process.env.GENT_NO_PET || process.env.CI) return;
         if (!SCENES[scene]) return;
         console.log(); // one blank line between command output and Genti
-        await play(scene, { loop: false, footer: false, goodbye: false });
+        // Auth flows just need a quick friendly wave; action scenes tell a fuller story.
+        const maxTicks = (scene === 'auth' || scene === 'login') ? 34 : Infinity;
+        await play(scene, { loop: false, footer: false, goodbye: false, maxTicks });
     } catch (_) { /* ignore — decoration only */ }
 }
 
+/**
+ * Public: run `task` while Genti animates as the live loader — carrying the
+ * crate to the cloud on push, home on pull, etc. The animation loops until the
+ * task settles, then erases itself so the command can print its own result.
+ *
+ * Safe + transparent: with no TTY / GENT_NO_PET / CI it simply awaits the task
+ * with no animation. Always returns (or throws) exactly what `task` does.
+ *
+ * @param {string} scene           'push' | 'pull' | 'merge' | …
+ * @param {() => Promise<any>} task the real async work (e.g. the network call)
+ * @returns {Promise<any>}
+ */
+async function during(scene, task) {
+    if (!process.stdout.isTTY || process.env.GENT_NO_PET || process.env.CI || !SCENES[scene]) {
+        return task();
+    }
+    const anim = runLoop(scene, { loop: true, footer: true, altScreen: false, clearOnStop: true, exitOnSig: true });
+    try {
+        return await task();
+    } finally {
+        anim.stop();
+        await anim.promise;
+    }
+}
+
 module.exports = petCommand;
 module.exports.celebrate = celebrate;
+module.exports.banner = banner;
+module.exports.during = during;

package/src/commands/pull.js

@@ -73,14 +73,15 @@ async function pull(remoteName, branchName, options) {
 
         // 1. Fetch commits + objects for this branch in a single call. `since`
         //    lets the server send only what we don't have on a fast-forward.
-        spinner.text = `Fetching updates for ${branch}...`;
+        // Genti walks a crate home from the cloud while we fetch.
+        spinner.stop();
         let pullData;
         try {
             const pullUrl = buildRepoUrl(API_ENDPOINTS.REPO_PULL, repoInfo);
             const query = localHead
                 ? `?branch=${encodeURIComponent(branch)}&since=${encodeURIComponent(localHead)}`
                 : `?branch=${encodeURIComponent(branch)}`;
-            pullData = await apiClient.get(pullUrl + query);
+            pullData = await pet.during('pull', () => apiClient.get(pullUrl + query));
         } catch (error) {
             if (error.response?.status === 404) {
                 spinner.succeed(chalk.green('Remote branch not found — nothing to pull'));
@@ -138,7 +139,6 @@ async function pull(remoteName, branchName, options) {
 
             spinner.succeed(chalk.green(`Fast-forward: ${newCount} new commit(s)`));
             console.log(chalk.gray(`  ${remote}/${branch} → ${remoteHead.substring(0, 7)}`));
-            await pet.celebrate('pull');
         } else {
             // Diverged — need 3-way merge
             spinner.text = 'Branches diverged, merging...';
@@ -194,7 +194,6 @@ async function pull(remoteName, branchName, options) {
             } else {
                 spinner.succeed(chalk.green(`Merged ${newCount} remote commit(s)`));
                 console.log(chalk.gray(`  Merge commit: ${mergeCommit.hash.substring(0, 7)}`));
-                await pet.celebrate('pull');
             }
         }
     } catch (error) {

package/src/commands/push.js

@@ -232,20 +232,19 @@ async function push(remoteName, branchName, options) {
             tags: tagsToPush
         };
 
-        // Send to backend
+        // Send to backend — Genti carries the crate to the cloud while we wait.
         const pushUrl = buildRepoUrl(API_ENDPOINTS.REPO_PUSH, repoInfo);
-        const response = await apiClient.post(pushUrl, payload);
+        spinner.stop();
+        const response = await pet.during('push', () => apiClient.post(pushUrl, payload));
 
         // Update remote ref
         config.remoteRefs[`${remote}/${branch}`] = localHead;
         await writeJSON(configPath, config);
 
-        spinner.succeed(chalk.green(`Pushed ${commitsToPush.length} commit(s) to ${remote}/${branch}`));
+        console.log(chalk.green(`✔ Pushed ${commitsToPush.length} commit(s) to ${remote}/${branch}`));
         console.log(chalk.gray(`  ${localHead.substring(0, 7)} → ${remote}/${branch}`));
         console.log(chalk.gray(`  ${packBlobs.length} blob(s), ${packTrees.length} tree(s) transferred`));
 
-        await pet.celebrate('push');
-
     } catch (error) {
         spinner.fail(chalk.red('Push failed'));
 

package/src/commands/register.js

@@ -8,12 +8,14 @@ const inquirer = require('inquirer');
 const ora = require('ora');
 const boxen = require('boxen');
 const authService = require('../services/auth-service');
+const pet = require('./pet');
 
 /**
  * Register a new user
  * @param {Object} options - Command options
  */
 async function register(options) {
+    pet.banner('New here? Let\'s get you set up.', 'Create your account below.');
     console.log(chalk.cyan('\n🚀 Create your Gent account\n'));
 
     try {
@@ -120,6 +122,8 @@ ${chalk.bold('Next steps:')}
             borderColor: 'green'
         }));
 
+        await pet.celebrate('auth');
+
     } catch (error) {
         console.error(chalk.red('\n✗ Registration failed'));
         console.error(chalk.red(`Error: ${error.message}\n`));