@nomad-e/bluma-cli 0.1.84 → 0.3.0

package/dist/WorkingTimer.js

@@ -0,0 +1,130 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Indicador de trabalho em curso — pulso minimalista + shimmer suave.
+ */
+import { useState, useEffect, memo, useRef } from "react";
+import { Box, Text } from "ink";
+import { BLUMA_TERMINAL as T } from "./theme/blumaTerminal.js";
+import { TOOL_DETAIL_PREFIX } from "./constants/toolUiSymbols.js";
+import { formatTurnDurationMs } from "./utils/formatTurnDurationMs.js";
+import { getToolActionLabel } from "./utils/toolActionLabels.js";
+// ─── Pulse ────────────────────────────────────────────────────────────────────
+// Frames com "peso visual" crescente/decrescente → sensação de respiração
+const PULSE_FRAMES = ["·", "○", "◌", "◎", "●", "◎", "◌", "○"];
+const PULSE_INTERVAL_MS = 200; // Increased from 110ms to reduce screen flicker
+// ─── Shimmer ──────────────────────────────────────────────────────────────────
+// Paleta de 5 níveis de brilho (sem mudar hue, apenas luminosidade percebida)
+// Usamos gray scale para ficar neutro com qualquer tema
+const SHIMMER_PALETTE = [
+    "#4a4a4a", // escuro
+    "#6e6e6e",
+    "#9a9a9a", // mid
+    "#c8c8c8",
+    "#f0f0f0", // quase branco
+    "#ffffff", // pico de brilho (branco puro)
+    "#f0f0f0",
+    "#c8c8c8",
+    "#9a9a9a",
+    "#6e6e6e",
+];
+const SHIMMER_CYCLE_MS = 2000; // Increased from 1000ms to reduce flicker (slower shimmer)
+/** Shimmer com uma única sombra que percorre o texto da esquerda para a direita.
+ *  Cada passada (início → fim) demora SHIMMER_CYCLE_MS (1s).
+ *  Quando chega ao fim, volta instantaneamente ao início e recomeça.
+ *  Usa ref para animação fluída sem re-render quando o texto muda. */
+const ShimmerText = memo(({ text, baseColor = "#9a9a9a" }) => {
+    const posRef = useRef(0);
+    const [, forceUpdate] = useState({});
+    const textRef = useRef(text);
+    const intervalMsRef = useRef(50); // valor padrão inicial
+    // Atualiza ref do texto sem afetar a animação
+    useEffect(() => {
+        textRef.current = text;
+        // Recalcula o intervalo para que a passada (início → fim) demore SHIMMER_CYCLE_MS
+        const cycleSteps = Math.max(1, text.length);
+        intervalMsRef.current = SHIMMER_CYCLE_MS / cycleSteps;
+    }, [text]);
+    useEffect(() => {
+        const rafId = setInterval(() => {
+            const len = textRef.current.length;
+            // Posição vai de 0 a len-1 (apenas ida, esquerda → direita)
+            // Quando chega ao fim, volta ao início (0)
+            posRef.current = (posRef.current + 1) % (len || 1);
+            forceUpdate({}); // Força re-render mínimo apenas para atualizar cores
+        }, intervalMsRef.current);
+        return () => clearInterval(rafId);
+    }, []);
+    const currentText = textRef.current;
+    const currentPos = posRef.current;
+    // Calcula a cor baseada na distância do ponto de brilho
+    // O caractere na currentPos tem o brilho máximo (índice 5 = branco)
+    // Os adjacentes têm brilho decrescente
+    const getColorForIndex = (i) => {
+        const dist = Math.abs(i - currentPos);
+        if (dist === 0)
+            return SHIMMER_PALETTE[5]; // branco puro no pico
+        if (dist === 1)
+            return SHIMMER_PALETTE[4]; // quase branco
+        if (dist === 2)
+            return SHIMMER_PALETTE[3]; // claro
+        if (dist === 3)
+            return SHIMMER_PALETTE[2]; // mid
+        return baseColor; // cor base para o resto
+    };
+    return (_jsx(_Fragment, { children: currentText.split("").map((char, i) => (_jsx(Text, { color: getColorForIndex(i), children: char }, i))) }));
+});
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function trimLine(s, max = 76) {
+    const t = String(s ?? "")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!t)
+        return "";
+    return t.length <= max ? t : `${t.slice(0, max - 1)}…`;
+}
+// ─── WorkingTimer ─────────────────────────────────────────────────────────────
+const WorkingTimerComponent = ({ eventBus, taskName, taskStatus, liveToolName, liveToolArgs, isReasoning, startedAtMs, }) => {
+    const [currentAction, setCurrentAction] = useState("working");
+    const [pulseFrame, setPulseFrame] = useState(0);
+    const [nowTick, setNowTick] = useState(() => Date.now());
+    const dynamicActionLabel = liveToolName
+        ? getToolActionLabel(liveToolName, liveToolArgs)
+        : null;
+    useEffect(() => {
+        if (!eventBus)
+            return;
+        const handleActionStatus = (data) => {
+            if (data.action)
+                setCurrentAction(data.action);
+        };
+        eventBus.on("action_status", handleActionStatus);
+        return () => { eventBus.off("action_status", handleActionStatus); };
+    }, [eventBus]);
+    // Pulse — frame rate próprio, independente do shimmer
+    useEffect(() => {
+        const id = setInterval(() => {
+            setPulseFrame((prev) => (prev + 1) % PULSE_FRAMES.length);
+        }, PULSE_INTERVAL_MS);
+        return () => clearInterval(id);
+    }, []);
+    // Elapsed timer
+    useEffect(() => {
+        if (startedAtMs == null)
+            return;
+        setNowTick(Date.now());
+        const id = setInterval(() => setNowTick(Date.now()), 500);
+        return () => clearInterval(id);
+    }, [startedAtMs]);
+    const displayAction = dynamicActionLabel ||
+        (taskStatus || (isReasoning ? "thinking" : currentAction)).trim() ||
+        "working";
+    const actionLine = `${displayAction}…`;
+    const elapsedMs = startedAtMs != null ? Math.max(0, nowTick - startedAtMs) : 0;
+    const elapsedLabel = startedAtMs != null ? formatTurnDurationMs(elapsedMs) : null;
+    // Intensidade do pulse: frame central (●) = full, bordas = dim
+    const pulseSymbol = PULSE_FRAMES[pulseFrame];
+    const isPulsePeak = pulseFrame === 4; // "●"
+    const isPulseDim = pulseFrame === 0; // "·"
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 0.5, children: [_jsxs(Box, { flexDirection: "row", alignItems: "flex-start", children: [_jsx(Text, { color: T.onSurfaceVariant, dimColor: isPulseDim, bold: isPulsePeak, children: pulseSymbol }), _jsx(Text, { children: " " }), _jsx(ShimmerText, { text: actionLine, baseColor: T.onSurfaceVariant ?? "#6e6e6e" }), elapsedLabel ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: T.m3OnSurface, dimColor: true, children: " \u00B7 " }), _jsx(Text, { color: T.m3OnSurface, dimColor: true, children: elapsedLabel })] })) : null] }), taskName ? (_jsx(Box, { paddingLeft: TOOL_DETAIL_PREFIX.length, children: _jsx(Text, { color: T.m3OnSurface, dimColor: true, wrap: "truncate", children: trimLine(taskName) }) })) : null] }));
+};
+export const WorkingTimer = memo(WorkingTimerComponent);

package/dist/components/StreamingText.js

@@ -0,0 +1,113 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect, useRef, memo } from "react";
+import { Box, Text } from "ink";
+import { ChatBlock, MessageResponse } from "../theme/m3Layout.js";
+import { BLUMA_TERMINAL as T } from "../theme/blumaTerminal.js";
+import { applyStreamEndFlush } from "./streamingTextFlush.js";
+import { collapseRepeatedReasoningLines } from "./reasoningText.js";
+const THROTTLE_MS = 500; // Increased from 300ms to reduce Ink re-render flicker
+const MAX_VISIBLE_LINES = 20;
+const StreamingTextComponent = ({ eventBus, onReasoningComplete, onAssistantContentComplete, }) => {
+    const [reasoning, setReasoning] = useState("");
+    const [assistantContent, setAssistantContent] = useState("");
+    const [isStreaming, setIsStreaming] = useState(false);
+    const reasoningRef = useRef("");
+    const contentRef = useRef("");
+    const flushTimerRef = useRef(null);
+    const onReasoningCompleteRef = useRef(onReasoningComplete);
+    onReasoningCompleteRef.current = onReasoningComplete;
+    const onAssistantContentCompleteRef = useRef(onAssistantContentComplete);
+    onAssistantContentCompleteRef.current = onAssistantContentComplete;
+    const streamEndHandledRef = useRef(false);
+    useEffect(() => {
+        const syncVisible = () => {
+            setReasoning(reasoningRef.current);
+            setAssistantContent(contentRef.current);
+        };
+        const startFlushTimer = () => {
+            if (flushTimerRef.current)
+                return;
+            flushTimerRef.current = setInterval(() => {
+                setReasoning(reasoningRef.current);
+                setAssistantContent(contentRef.current);
+            }, THROTTLE_MS);
+        };
+        const handleStart = () => {
+            streamEndHandledRef.current = false;
+            reasoningRef.current = "";
+            contentRef.current = "";
+            setReasoning("");
+            setAssistantContent("");
+            setIsStreaming(true);
+            startFlushTimer();
+        };
+        const handleReasoningChunk = (data) => {
+            if (data.delta) {
+                reasoningRef.current += data.delta;
+            }
+        };
+        const handleContentChunk = (data) => {
+            if (data.delta) {
+                contentRef.current += data.delta;
+            }
+        };
+        const handleEnd = (payload) => {
+            if (streamEndHandledRef.current)
+                return;
+            streamEndHandledRef.current = true;
+            // Clear timers first
+            if (flushTimerRef.current) {
+                clearInterval(flushTimerRef.current);
+                flushTimerRef.current = null;
+            }
+            // IMMEDIATELY clear the streaming UI before adding to history
+            // This prevents the reasoning from appearing twice
+            const finalReasoning = reasoningRef.current;
+            const finalContent = contentRef.current;
+            setReasoning("");
+            setAssistantContent("");
+            reasoningRef.current = "";
+            contentRef.current = "";
+            setIsStreaming(false);
+            // NOW add to history (after UI is cleared)
+            applyStreamEndFlush({
+                finalReasoning,
+                finalContent,
+                payload,
+                onReasoningComplete: onReasoningCompleteRef.current,
+                onAssistantContentComplete: onAssistantContentCompleteRef.current,
+            });
+        };
+        eventBus.on("stream_start", handleStart);
+        eventBus.on("stream_reasoning_chunk", handleReasoningChunk);
+        eventBus.on("stream_chunk", handleContentChunk);
+        eventBus.on("stream_end", handleEnd);
+        return () => {
+            eventBus.off("stream_start", handleStart);
+            eventBus.off("stream_reasoning_chunk", handleReasoningChunk);
+            eventBus.off("stream_chunk", handleContentChunk);
+            eventBus.off("stream_end", handleEnd);
+            if (flushTimerRef.current) {
+                clearInterval(flushTimerRef.current);
+                flushTimerRef.current = null;
+            }
+        };
+    }, [eventBus]);
+    if (!isStreaming || (!reasoning && !assistantContent)) {
+        return null;
+    }
+    const renderLines = (text, dim) => {
+        const normalized = collapseRepeatedReasoningLines(text);
+        const lines = normalized.split("\n");
+        let displayLines = lines;
+        let truncatedCount = 0;
+        if (lines.length > MAX_VISIBLE_LINES) {
+            truncatedCount = lines.length - MAX_VISIBLE_LINES;
+            displayLines = lines.slice(-MAX_VISIBLE_LINES);
+        }
+        return (_jsxs(Box, { flexDirection: "column", children: [truncatedCount > 0 ? (_jsxs(Text, { dimColor: true, children: ["\u2026 ", truncatedCount, " lines above hidden"] })) : null, displayLines.map((line, i) => (_jsx(Text, { dimColor: dim, color: dim ? undefined : T.m3OnSurface, children: line }, i)))] }));
+    };
+    return (_jsxs(ChatBlock, { marginBottom: 0, children: [reasoning ? (_jsx(Box, { flexDirection: "column", paddingLeft: 2, children: renderLines(reasoning, true) })) : null, assistantContent ? (_jsx(MessageResponse, { children: renderLines(assistantContent, false) })) : null] }));
+};
+export const StreamingText = memo(StreamingTextComponent);
+export default StreamingText;

package/dist/components/reasoningText.js

@@ -0,0 +1,18 @@
+export function collapseRepeatedReasoningLines(text) {
+    const raw = String(text ?? "").replace(/\r\n/g, "\n");
+    if (!raw.trim())
+        return "";
+    const lines = raw.split("\n");
+    const collapsed = [];
+    for (const line of lines) {
+        const current = line.trimEnd();
+        if (current === "" && collapsed[collapsed.length - 1] === "") {
+            continue;
+        }
+        if (collapsed.length > 0 && collapsed[collapsed.length - 1] === current) {
+            continue;
+        }
+        collapsed.push(current);
+    }
+    return collapsed.join("\n").trim();
+}

package/dist/components/streamingTextFlush.js

@@ -0,0 +1,11 @@
+export function applyStreamEndFlush(params) {
+    const { finalReasoning, finalContent, payload, onReasoningComplete, onAssistantContentComplete, } = params;
+    if (finalReasoning && onReasoningComplete) {
+        onReasoningComplete(finalReasoning);
+    }
+    const trimmed = finalContent.trim();
+    const skipAssistant = payload?.omitAssistantFlush === true;
+    if (trimmed && onAssistantContentComplete && !skipAssistant) {
+        onAssistantContentComplete(finalContent);
+    }
+}

package/dist/config/native_tools.json

@@ -227,41 +227,7 @@
         }
       }
     },
-    {
-      "type": "function",
-      "function": {
-        "name": "message",
-        "description": "Primary user-visible channel — use it generously. Call message_type \"info\" frequently during a turn (progress, findings, errors, next steps); multiple info calls per turn are required for good UX. The turn does not stop on \"info\". Use message_type \"result\" once when you finish this turn (final answer, deliverable, or question for the user); then the agent waits.",
-        "parameters": {
-          "type": "object",
-          "properties": {
-            "content": {
-              "type": "string",
-              "description": "Markdown body shown in the chat (user's language when appropriate)."
-            },
-            "message_type": {
-              "type": "string",
-              "enum": [
-                "info",
-                "result"
-              ],
-              "description": "Prefer \"info\" often while working (does not end turn). Use \"result\" only once to end the turn."
-            },
-            "attachments": {
-              "type": "array",
-              "items": {
-                "type": "string"
-              },
-              "description": "Optional file paths (absolute) to deliver as attachments. Put generated files under ./.bluma/artifacts/ (or paths returned by task_boundary / create_artifact); never a top-level ./artifacts/ folder — tools remap that to .bluma/artifacts/."
-            }
-          },
-          "required": [
-            "content",
-            "message_type"
-          ]
-        }
-      }
-    },
+
     {
       "type": "function",
       "function": {
@@ -720,30 +686,6 @@
         }
       }
     },
-    {
-      "type": "function",
-      "function": {
-        "name": "create_artifact",
-        "description": "Create or update an artifact under the workspace .bluma/artifacts/<session>/ directory (see task_boundary artifacts_dir). Use for plans, walkthroughs, notes, or deliverables. Not the same as ~/.bluma.",
-        "parameters": {
-          "type": "object",
-          "properties": {
-            "filename": {
-              "type": "string",
-              "description": "Name of the artifact file to create. Examples: 'implementation_plan.md', 'walkthrough.md', 'notes.md'."
-            },
-            "content": {
-              "type": "string",
-              "description": "Content to write to the artifact file. Supports markdown formatting."
-            }
-          },
-          "required": [
-            "filename",
-            "content"
-          ]
-        }
-      }
-    },
     {
       "type": "function",
       "function": {

package/dist/config/plan_mode_instructions.md

@@ -0,0 +1,218 @@
+# Plan Mode Instructions
+
+## Overview
+
+Plan Mode is a structured approach to problem-solving that emphasizes **clarity, alignment, and decision-completeness** before implementation.
+
+When in Plan Mode, you must follow the **3-phase workflow**:
+
+---
+
+## Phase 1: Grounding (Understanding)
+
+**Goal:** Demonstrate deep understanding of the problem before proposing solutions.
+
+**Actions:**
+- Read relevant files to understand context
+- Identify the root cause, not just symptoms
+- Map out the codebase structure affected
+- Ask clarifying questions if information is missing
+
+**Output format:**
+```
+<proposed_plan>
+## Understanding
+
+### What I Found
+- [Key findings from investigation]
+- [Root cause analysis]
+- [Files and lines involved]
+
+### Context
+- [Relevant code patterns]
+- [Dependencies and side effects]
+</proposed_plan>
+```
+
+---
+
+## Phase 2: Intent (Proposal)
+
+**Goal:** Present a clear, actionable plan for user approval.
+
+**Actions:**
+- Propose specific changes with file paths and line numbers
+- Explain the "why" behind each decision
+- Consider alternatives and trade-offs
+- Make the plan "decision complete" (user can approve without asking follow-ups)
+
+**Output format:**
+```
+<proposed_plan>
+## Proposed Plan
+
+### Objective
+[Clear statement of what we're fixing/building]
+
+### Approach
+1. [Step 1 with specific files/lines]
+2. [Step 2 with specific files/lines]
+3. [Step 3...]
+
+### Changes
+- **File: `src/path/to/file.ts`**
+  - Line 42: Change X to Y because...
+  - Add function `helper()` at line 50 to...
+
+### Alternatives Considered
+- Alternative A: [why not chosen]
+- Alternative B: [why not chosen]
+
+### Risks & Mitigations
+- [Potential issue] → [mitigation strategy]
+
+### Success Criteria
+- [How we'll know this is working]
+- [Tests to run]
+</proposed_plan>
+```
+
+---
+
+## Phase 3: Implementation (Execution)
+
+**Goal:** Execute the approved plan with precision.
+
+**Actions:**
+- Follow the approved plan exactly
+- Use `enter_plan_mode` before making changes
+- Make surgical, targeted edits
+- Run tests after each change
+- Use `exit_plan_mode` when complete
+
+**Important:**
+- Do NOT deviate from the approved plan without user consent
+- If you discover new issues, pause and propose an updated plan
+- Commit changes with clear, descriptive messages
+
+---
+
+## Plan Mode Rules
+
+### DO:
+✅ Use `<proposed_plan>` tags for all plans
+✅ Make plans "decision complete" (no follow-up questions needed)
+✅ Include specific file paths and line numbers
+✅ Explain reasoning behind each decision
+✅ Consider alternatives and trade-offs
+✅ Use `enter_plan_mode` before making changes
+✅ Run tests and verify changes work
+
+### DON'T:
+❌ Make changes without a proposed plan
+❌ Propose vague or incomplete plans
+❌ Skip the grounding phase (understand first!)
+❌ Deviate from approved plan without consent
+❌ Make multiple unrelated changes in one plan
+❌ Forget to run tests after implementation
+
+---
+
+## When to Use Plan Mode
+
+**Use Plan Mode when:**
+- Fixing bugs (especially complex ones)
+- Adding new features
+- Refactoring code
+- Making architectural changes
+- Any change that affects multiple files
+
+**Skip Plan Mode for:**
+- Simple, one-line fixes
+- Reading files to gather information
+- Quick exploratory tasks
+- User explicitly asks to "just fix it"
+
+---
+
+## Plan Mode Workflow Summary
+
+1. **Investigate** → Read files, understand the problem
+2. **Propose** → Create `<proposed_plan>` with clear steps
+3. **Wait** → Let user review and approve
+4. **Activate** → Call `enter_plan_mode` when approved
+5. **Implement** → Make the changes exactly as proposed
+6. **Verify** → Run tests, confirm success
+7. **Complete** → Call `exit_plan_mode` and report results
+
+---
+
+## Example Plan
+
+```
+<proposed_plan>
+## Understanding
+
+### What I Found
+- Null pointer in `src/auth/validate.ts:42` when `Session.expired` is true
+- The `user` field is undefined but code tries to access `user.id`
+- This happens because token cache isn't cleared on expiry
+
+### Context
+- `validateToken()` returns cached token even when expired
+- `getSession()` doesn't check if user exists before accessing properties
+
+## Proposed Plan
+
+### Objective
+Fix null pointer exception when session expires but token is cached
+
+### Approach
+1. Add null check in `validate.ts:42` before accessing `user.id`
+2. Clear token cache when session expires
+3. Add test case for expired session with cached token
+
+### Changes
+- **File: `src/auth/validate.ts`**
+  - Line 42: Add `if (!user) return { valid: false, error: 'Session expired' };`
+  - Line 58: Add cache invalidation when `Session.expired === true`
+
+### Alternatives Considered
+- Alternative: Always refresh token on expiry → Too aggressive, impacts performance
+- Alternative: Remove caching entirely → Loses benefit of caching valid tokens
+
+### Risks & Mitigations
+- Risk: Breaking existing valid sessions → Mitigation: Add comprehensive tests
+- Risk: Performance impact from cache invalidation → Mitigation: Only invalidate on confirmed expiry
+
+### Success Criteria
+- No null pointer on expired session
+- Valid sessions still cached and fast
+- Test coverage for edge case added
+</proposed_plan>
+```
+
+---
+
+## Tool Usage in Plan Mode
+
+When `enter_plan_mode` is active:
+- All write/execute tools require explicit confirmation
+- This ensures you review each change before it happens
+- Use this as a safety check, not a barrier
+
+Tools that require confirmation in Plan Mode:
+- `edit_tool`
+- `file_write`
+- `shell_command`
+- `spawn_agent`
+
+---
+
+## Final Notes
+
+**Remember:** A good plan is specific, actionable, and decision-complete.
+The user should be able to approve your plan without asking "what about X?" or "why this approach?"
+
+If you're unsure, **ask questions first** before proposing the plan.
+Better to spend 2 minutes clarifying than 20 minutes fixing the wrong thing.

package/dist/constants/toolUiSymbols.js

@@ -0,0 +1,10 @@
+/**
+ * Marcador de invocação de tool — bullet compacto (U+2022 •).
+ */
+export const TOOL_INVOCATION_MARK = "\u2022 ";
+/** Indentação do detalhe da tool. */
+export const TOOL_DETAIL_PREFIX = "  ";
+/**
+ * Prefixo da linha de resultado sob a invocação (• List / path) — ramo `└` em dim, estilo BluMa.
+ */
+export const RESULT_LINE_GUTTER = "  \u2514 ";