@oxecli/oxe 1.0.76 → 1.0.78

package/dist/engine.js

@@ -103,7 +103,7 @@ export class InferenceEngine {
                     result = await toolBash(args.command, args.timeout, args.cwd);
                     break;
                 case "glob":
-                    result = toolGlob(args.pattern, args.path, args.limit);
+                    result = toolGlob(args.pattern, args.path, args.limit, args.depth);
                     break;
                 case "grep":
                     result = toolGrep(args.pattern, args.path, args.glob, args.limit);
@@ -578,11 +578,12 @@ export class InferenceEngine {
                     this.workActive = false;
                     const started = toolCallLabel(c.name, c.arguments);
                     const toolSpinner = new Spinner();
-                    toolSpinner.start(started);
+                    toolSpinner.startDots("Running");
                     const rawResult = await this.runTool(c.name, c.arguments);
-                    toolSpinner.stop();
-                    if (this.interrupted)
+                    if (this.interrupted) {
+                        toolSpinner.stop();
                         throw new Error("interrupt");
+                    }
                     const failed = toolOutputFailed(c.name, rawResult);
                     const action = formatToolResult(rawResult, failed);
                     story.push({
@@ -591,7 +592,10 @@ export class InferenceEngine {
                         text: action,
                         status: failed ? "failed" : "ok",
                     });
-                    process.stdout.write(`${started}\n${action}\n\n`);
+                    // Replace the "Running..." line in place with the tool label so the
+                    // transition is seamless, then print the result beneath it.
+                    toolSpinner.replaceWith(started);
+                    process.stdout.write(`${action}\n\n`);
                     // Any diff the tool produced is flushed only now, after the spinner
                     // has stopped, so the box renders cleanly below the action line.
                     flushPendingDiffOutput();

package/dist/tools.js

@@ -122,26 +122,29 @@ function displayDiff(pathName, oldContent, newContent) {
             maxNum = Math.max(maxNum, v.newNum);
     }
     const numW = String(maxNum).length;
-    const indent = "      ";
-    const bodyMax = Math.max(termW - plainLen(indent) - numW - 4, 20);
+    const bodyMax = Math.max(termW - numW - 4, 20);
     const gap = " ".repeat(numW);
     for (const v of visible) {
         if (v.kind === "~") {
             const body = truncateStyled(v.body, bodyMax);
-            pendingDiffOutput.push(`\x1b[90m${indent}${gap}   ${body}\x1b[0m`);
+            pendingDiffOutput.push(`\x1b[90m${gap}   ${body}\x1b[0m`);
             continue;
         }
         const num = v.kind === "+" ? v.newNum : v.oldNum;
         const numStr = num ? String(num).padStart(numW, " ") : gap;
         if (v.kind === "+" || v.kind === "-") {
-            const color = v.kind === "+" ? "\x1b[32m" : "\x1b[31m";
+            const bg = v.kind === "+" ? "\x1b[48;2;2;40;0m" : "\x1b[48;2;61;1;0m";
             const sign = v.kind === "+" ? "+" : "-";
             const body = truncateStyled(v.body, bodyMax);
-            pendingDiffOutput.push(`${indent}${color}${numStr} ${sign}  ${body}\x1b[0m`);
+            const fill = Math.max(0, termW - numW - 4 - plainLen(body));
+            pendingDiffOutput.push(`${bg}\x1b[97m${numStr} ${sign}  ${body}${" ".repeat(fill)}\x1b[0m`);
         }
         else {
-            const body = truncateStyled(v.kind === "\\" ? v.body : highlightCodeLine(v.body), bodyMax);
-            pendingDiffOutput.push(`\x1b[90m${indent}${numStr}  ${body}\x1b[0m`);
+            const raw = v.kind === "\\" ? v.body : highlightCodeLine(v.body);
+            // highlightCodeLine resets to default after each token; re-apply the dim
+            // gray base so plain text stays dim and only tokens show color.
+            const body = truncateStyled(raw.replace(/\x1b\[0m/g, "\x1b[0m\x1b[90m"), bodyMax);
+            pendingDiffOutput.push(`\x1b[90m${numStr}  ${body}\x1b[0m`);
         }
     }
     return { added, removed };
@@ -629,7 +632,7 @@ function globMatch(name, pattern) {
         .replace(/\?/g, ".");
     return new RegExp(`^${regex}$`, "i").test(name);
 }
-function walkFiles(root, current, rel, parts, out) {
+function walkFiles(root, current, rel, parts, out, depthLeft) {
     let entries;
     try {
         entries = fs.readdirSync(current, { withFileTypes: true });
@@ -643,8 +646,10 @@ function walkFiles(root, current, rel, parts, out) {
             if (entry.isDirectory()) {
                 if (ignoredDirs.has(name))
                     continue;
+                if (depthLeft <= 0)
+                    continue;
                 rel.push(name);
-                walkFiles(root, path.join(current, name), rel, parts, out);
+                walkFiles(root, path.join(current, name), rel, parts, out, depthLeft - 1);
                 rel.pop();
             }
             else if (entry.isFile()) {
@@ -661,13 +666,13 @@ function walkFiles(root, current, rel, parts, out) {
         }
     }
 }
-function rglobPruned(base, pattern) {
+function rglobPruned(base, pattern, depth = 12) {
     const norm = pattern.replace(/\\/g, "/");
     const parts = norm.split("/").filter((p) => p !== "" && p !== ".");
     const hasDotDot = parts.includes("..");
     if (hasDotDot) {
         const out = [];
-        const walk = (dir) => {
+        const walk = (dir, depthLeft) => {
             let entries;
             try {
                 entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -678,8 +683,8 @@ function rglobPruned(base, pattern) {
             for (const e of entries) {
                 const full = path.join(dir, e.name);
                 if (e.isDirectory()) {
-                    if (!ignoredDirs.has(e.name))
-                        walk(full);
+                    if (!ignoredDirs.has(e.name) && depthLeft > 0)
+                        walk(full, depthLeft - 1);
                 }
                 else if (e.isFile()) {
                     out.push([full, fs.statSync(full).size]);
@@ -690,7 +695,7 @@ function rglobPruned(base, pattern) {
             out.push([base, fs.statSync(base).size]);
         }
         else {
-            walk(base);
+            walk(base, depth);
         }
         return out;
     }
@@ -702,17 +707,18 @@ function rglobPruned(base, pattern) {
     if (!parts.length)
         return [];
     const out = [];
-    walkFiles(base, base, [], ["**", ...parts], out);
+    walkFiles(base, base, [], ["**", ...parts], out, depth);
     return out;
 }
-export function toolGlob(pattern, pathName = ".", limit = 200) {
+export function toolGlob(pattern, pathName = ".", limit = 200, depth = 12) {
     const base = sanitizePath(pathName) || ".";
     if (!fs.existsSync(base))
         return `Error: path not found: ${pathName}`;
     const lim = typeof limit === "number" ? limit : parseInt(String(limit), 10) || 200;
+    const dep = Math.max(0, typeof depth === "number" ? depth : parseInt(String(depth), 10) || 12);
     let matches;
     try {
-        matches = rglobPruned(base, pattern);
+        matches = rglobPruned(base, pattern, dep);
     }
     catch {
         return `Error: path not found: ${pathName}`;
@@ -891,6 +897,10 @@ export const RESPONSES_TOOLS = [
                     type: "integer",
                     description: "Max number of matches to return (default 200)",
                 },
+                depth: {
+                    type: "integer",
+                    description: "Max directory depth to descend (default 12)",
+                },
             },
             required: ["pattern"],
         },

package/dist/ui.js

@@ -512,6 +512,7 @@ export function showCursor() {
     }
 }
 const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const DOT_FRAMES = [".  ", ".. ", "..."];
 export class Spinner {
     timer = null;
     frame = 0;
@@ -520,6 +521,8 @@ export class Spinner {
     enabled;
     lastRendered = "";
     lastLen = 0;
+    dotsText = "";
+    dotsFrame = 0;
     constructor(enabled = true) {
         this.enabled = enabled;
     }
@@ -547,6 +550,53 @@ export class Spinner {
         }, 80);
         this.draw();
     }
+    /** Dots-mode label: renders `Running` + a fixed 3-cell animated dots field.
+     *  Each tick rewrites ONLY the dots cells via a cursor jump, so the rest of
+     *  the line never flickers. Swap in the final label with replaceWith(). */
+    startDots(text) {
+        if (!this.enabled)
+            return;
+        if (this.timer)
+            clearInterval(this.timer);
+        this.dotsText = text;
+        this.dotsFrame = 0;
+        this.rows = 1;
+        this.lastRendered = "";
+        this.lastLen = text.length + 3;
+        this.writeDots(true);
+        this.timer = setInterval(() => {
+            this.dotsFrame = (this.dotsFrame + 1) % DOT_FRAMES.length;
+            this.writeDots(false);
+        }, 300);
+    }
+    writeDots(initial) {
+        const label = `\x1b[1;36m${this.dotsText}\x1b[0m`;
+        const dots = `\x1b[1;36m${DOT_FRAMES[this.dotsFrame]}\x1b[0m`;
+        if (initial) {
+            process.stdout.write("\r" + label + dots + "\r");
+        }
+        else {
+            // Jump to the dots column (1-based) and rewrite only the 3-cell field.
+            process.stdout.write(`\x1b[${this.dotsText.length + 1}G` + dots + "\r");
+        }
+    }
+    /** Overwrite the dots line in place with `text` and advance to the next
+     *  line, without erasing (so there is no flash). */
+    replaceWith(text) {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        if (!this.enabled) {
+            process.stdout.write(`${text}\n`);
+            return;
+        }
+        const plain = stripAnsi(text);
+        const pad = Math.max(0, this.lastLen - plain.length);
+        process.stdout.write("\r" + text + " ".repeat(pad) + "\r\n");
+        this.rows = 0;
+        this.lastLen = plain.length;
+    }
     update(text) {
         if (this.timer) {
             this.render = () => text;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxecli/oxe",
-  "version": "1.0.76",
+  "version": "1.0.78",
   "publishConfig": {
     "access": "public"
   },