habithive-code 0.2.1 → 0.2.3

package/README.md

@@ -113,6 +113,29 @@ launch (habithive reopens your session automatically after a change).
 Tested against: **opencode 1.18.x**, **oh-my-openagent 4.19.x** (pinned in the installer).
 opencode auto-updates its own binary; if a release changes internals, open an issue.
 
+## Migrating from the previous package name
+
+`habithive-code` is a rebrand of an earlier package that used a different name and
+plugin entry. `habithive setup` only manages its own plugin entry, so if the old
+package is still installed or wired into your opencode config, both load together
+and you'll see two wordmarks stacked on the home screen. Fix it once with:
+
+```sh
+npm rm -g maliv-code
+rm -rf ~/.maliv
+node -e "
+const fs=require('fs'), os=require('os'), path=require('path');
+const p=path.join(os.homedir(),'.config','opencode','tui.json');
+const c=JSON.parse(fs.readFileSync(p,'utf8'));
+c.plugin=(c.plugin||[]).filter(e=>!String(e).includes('maliv'));
+fs.writeFileSync(p, JSON.stringify(c,null,2)+'\n');
+console.log('cleaned:', p);
+"
+habithive setup
+```
+This is a one-time cleanup — anyone installing `habithive-code` fresh, who never had
+the old package, can skip this section entirely.
+
 ## Uninstall
 
 ```sh

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "habithive-code",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "A control layer for opencode: one-command install, live simple/complex mode switching, and a model tree for oh-my-opencode agents.",
   "type": "module",
   "bin": {

package/src/logo.js

@@ -1,18 +1,21 @@
 // habithive-code — home-screen wordmark in opencode's TUI.
 //
-// Renders a big <ascii_font> "HABITHIVE" (block font: white fill, black outline —
-// same monochrome, high-contrast look as opencode's own wordmark) into the
-// `home_logo` slot, with a slow breathing-brightness animation. A @opentui/core
-// renderable is a valid slot node, so there's no JSX build step. We probe-construct
-// once at register time (inside try/catch, OUTSIDE opencode's render loop) so any
-// failure aborts gracefully instead of crashing the home screen — the slot is only
-// registered if the probe succeeds.
+// Renders a two-line mark into the `home_logo` slot:
+//   HIVE                                  <- big <ascii_font> (block font: white
+//   HABIT Intelligent Value Engineering      fill, black outline), animated
+//                                          <- small caption underneath
+// A @opentui/core renderable is a valid slot node, so there's no JSX build step.
+// We probe-construct once at register time (inside try/catch, OUTSIDE opencode's
+// render loop) so any failure aborts gracefully instead of crashing the home
+// screen — the slot is only registered if the probe succeeds.
 
-const TEXT = "habithive";  // ascii_font uppercases it
-const FONT = "block";      // tiny | slick | block | huge | shade | grid | pallet
+const TITLE_TEXT = "hive";  // ascii_font uppercases it
+const FONT = "block";       // tiny | slick | block | huge | shade | grid | pallet
 // `block` renders two color layers: [fill, outline]. White-on-black, opencode-style.
 const FILL = "#ffffff";
 const OUTLINE = "#000000";
+const CAPTION_TEXT = "HABIT Intelligent Value Engineering";
+const CAPTION_COLOR = "#999999";
 const PULSE_MS = 90;       // animation frame interval
 const PULSE_STEPS = 40;    // full breathing cycle length
 
@@ -33,44 +36,55 @@ export async function registerLogo(api) {
     try { rctx = (rnd && rnd.renderContext) || (rnd && rnd.root && rnd.root.ctx) || null; } catch {}
     if (!rctx) return;
 
-    let AsciiFont, RenderableEvents;
+    let AsciiFont, TextRenderable, BoxRenderable, RenderableEvents;
     try {
       const mod = await import("@opentui/core");
       AsciiFont = mod.ASCIIFontRenderable;
+      TextRenderable = mod.TextRenderable;
+      BoxRenderable = mod.BoxRenderable;
       RenderableEvents = mod.RenderableEvents;
     } catch { return; }
-    if (typeof AsciiFont !== "function") return;
+    if (typeof AsciiFont !== "function" || typeof TextRenderable !== "function" || typeof BoxRenderable !== "function") return;
 
-    const make = () => new AsciiFont(rctx, { text: TEXT, font: FONT, color: [FILL, OUTLINE] });
+    const makeTitle = () => new AsciiFont(rctx, { text: TITLE_TEXT, font: FONT, color: [FILL, OUTLINE] });
+    const makeCaption = () => new TextRenderable(rctx, { content: CAPTION_TEXT, fg: CAPTION_COLOR });
+    const make = () => {
+      const box = new BoxRenderable(rctx, { flexDirection: "column", rowGap: 1 });
+      const title = makeTitle();
+      const caption = makeCaption();
+      box.add(title);
+      box.add(caption);
+      return { box, title };
+    };
 
     // Prove construction works before registering (a throw here is caught → no crash).
     try {
       const probe = make();
-      if (probe && typeof probe.destroyRecursively === "function") probe.destroyRecursively();
+      if (probe.box && typeof probe.box.destroyRecursively === "function") probe.box.destroyRecursively();
     } catch { return; }
 
     api.slots.register({
       slots: {
         home_logo: () => {
-          const node = make();
+          const { box, title } = make();
           try {
             let step = 0;
             const timer = setInterval(() => {
               try {
                 step = (step + 1) % PULSE_STEPS;
-                node.color = [breathGray(step), OUTLINE];
+                title.color = [breathGray(step), OUTLINE];
               } catch { clearInterval(timer); }
             }, PULSE_MS);
             const stop = () => clearInterval(timer);
-            if (RenderableEvents && typeof node.once === "function") {
-              node.once(RenderableEvents.DESTROYED, stop);
-            } else if (typeof node.on === "function") {
-              node.on("destroyed", stop);
+            if (RenderableEvents && typeof box.once === "function") {
+              box.once(RenderableEvents.DESTROYED, stop);
+            } else if (typeof box.on === "function") {
+              box.on("destroyed", stop);
             }
           } catch {
             // animation is best-effort; a static logo still renders if this fails
           }
-          return node;
+          return box;
         },
       },
     });