@leg3ndy/otto-bridge 0.9.0 → 0.9.1

package/README.md

@@ -15,6 +15,8 @@ Para o estado atual da arquitetura, capacidades entregues, limitacoes e roadmap
 
 Para o corte de arquitetura do `0.9.0`, veja [`leg3ndy-ai-backend/docs/OTTO_BRIDGE_0_9_0_RELEASE.md`](../leg3ndy-ai-backend/docs/OTTO_BRIDGE_0_9_0_RELEASE.md).
 
+Para o patch atual `0.9.1`, com hotfixes de stream/renderizacao e completude das filesystem tools, veja [`leg3ndy-ai-backend/docs/OTTO_BRIDGE_0_9_1_PATCH.md`](../leg3ndy-ai-backend/docs/OTTO_BRIDGE_0_9_1_PATCH.md).
+
 ## Distribuicao
 
 Fluxo recomendado agora:
@@ -35,14 +37,14 @@ Enquanto o pacote nao estiver publicado, voce pode gerar um tarball local:
 
 ```bash
 npm pack
-npm install -g ./leg3ndy-otto-bridge-0.9.0.tgz
+npm install -g ./leg3ndy-otto-bridge-0.9.1.tgz
 ```
 
-No `0.9.0`, `playwright` segue como dependencia obrigatoria no `otto-bridge`. O primeiro `npm install -g @leg3ndy/otto-bridge` pode demorar mais porque instala o browser persistente usado pelo WhatsApp Web e pelos fluxos web em background do bridge.
+Na linha `0.9.1`, `playwright` segue como dependencia obrigatoria no `otto-bridge`. O primeiro `npm install -g @leg3ndy/otto-bridge` pode demorar mais porque instala o browser persistente usado pelo WhatsApp Web e pelos fluxos web em background do bridge.
 
-No macOS, o `0.9.0` usa o provider `macos-helper`, um helper `WKWebView` sem Dock para o WhatsApp Web. O helper sobe com user-agent de Chrome moderno para evitar o bloqueio do WhatsApp ao detectar Safari/WebKit. O runtime antigo com Chromium/Playwright fica disponivel apenas como override explicito via `OTTO_BRIDGE_WHATSAPP_RUNTIME_PROVIDER=embedded-playwright`.
+No macOS, a linha `0.9.1` usa o provider `macos-helper`, um helper `WKWebView` sem Dock para o WhatsApp Web. O helper sobe com user-agent de Chrome moderno para evitar o bloqueio do WhatsApp ao detectar Safari/WebKit. O runtime antigo com Chromium/Playwright fica disponivel apenas como override explicito via `OTTO_BRIDGE_WHATSAPP_RUNTIME_PROVIDER=embedded-playwright`.
 
-No nivel arquitetural, o `0.9.0` muda o papel do bridge: ele publica tools e resultados estruturados para o Otto, em vez de injetar resposta pronta como caminho principal do chat.
+No nivel arquitetural, o `0.9.0` marcou a mudanca de papel do bridge: ele publica tools e resultados estruturados para o Otto, em vez de injetar resposta pronta como caminho principal do chat. O `0.9.1` consolida esse caminho com hotfixes de stream visivel, planner LLM-first e leitura/listagem local sem truncamento silencioso.
 
 ## Publicacao
 
@@ -112,7 +114,7 @@ otto-bridge run --executor clawd-cursor --clawd-url http://127.0.0.1:3847
 
 ### WhatsApp Web em background
 
-Fluxo recomendado no `0.9.0`:
+Fluxo recomendado na linha `0.9.1`:
 
 ```bash
 otto-bridge extensions --install whatsappweb
@@ -122,13 +124,13 @@ otto-bridge extensions --status whatsappweb
 
 O setup agora abre o login do WhatsApp Web no helper/background browser do proprio bridge. Depois do QR code, o Otto usa a sessao local em background, sem depender de aba visivel no Safari.
 
-Contrato do `0.9.0`:
+Contrato da linha `0.9.1`:
 
 - `otto-bridge extensions --setup whatsappweb`: autentica a sessao uma vez
 - `otto-bridge run`: mantem o browser persistente do WhatsApp vivo em background enquanto o runtime estiver ativo, sem depender de uma aba aberta no Safari
 - ao parar o `otto-bridge run`: o browser em background e desligado, mas a sessao local fica lembrada para o proximo boot
 
-## Handoff rapido do 0.9.0
+## Handoff rapido da linha 0.9.1
 
 Ja fechado no codigo:
 
@@ -138,6 +140,9 @@ Ja fechado no codigo:
 - prompt bridge-aware no chat normal para ajudar o Otto a responder com base no que realmente aconteceu no device
 - runtime local agora publica `local_tools` para o Otto/backend saberem exatamente o que o device consegue fazer
 - o caminho principal do bridge usa `summary`/`narration_context` no lugar de resposta automatica pronta
+- `read_file` agora entrega conteudo completo segmentado em `content_chunks` para o Otto
+- `list_files` sem `limit` agora lista o diretorio inteiro, sem fallback silencioso para 40 itens
+- o planner do bridge prioriza o modelo para escolher a tool certa pelo contexto; regex fica como fallback
 
 Ainda precisa reteste em campo:
 

package/dist/executors/native_macos.js

@@ -702,6 +702,35 @@ function clipTextPreview(value, maxLength) {
     }
     return `${value.slice(0, maxLength)}\n\n[conteudo truncado: mostrando ${maxLength} de ${value.length} caracteres. Peca um trecho mais especifico se quiser continuar.]`;
 }
+function chunkTextForTransport(value, chunkSize) {
+    const normalized = String(value || "");
+    if (!normalized) {
+        return [];
+    }
+    const safeChunkSize = Math.max(400, Math.min(Math.round(chunkSize || 4000), 32_000));
+    const chunks = [];
+    let cursor = 0;
+    let index = 0;
+    while (cursor < normalized.length) {
+        let nextCursor = Math.min(normalized.length, cursor + safeChunkSize);
+        if (nextCursor < normalized.length) {
+            const lastLineBreak = normalized.lastIndexOf("\n", nextCursor);
+            if (lastLineBreak > cursor + Math.floor(safeChunkSize * 0.35)) {
+                nextCursor = lastLineBreak + 1;
+            }
+        }
+        const text = normalized.slice(cursor, nextCursor);
+        chunks.push({
+            index,
+            start_char: cursor,
+            end_char: nextCursor,
+            text,
+        });
+        cursor = nextCursor;
+        index += 1;
+    }
+    return chunks;
+}
 const TEXTUTIL_READABLE_EXTENSIONS = new Set([
     ".doc",
     ".docx",
@@ -975,14 +1004,14 @@ function parseStructuredActions(job) {
         if (type === "read_file" || type === "read_local_file") {
             const filePath = asString(action.path);
             if (filePath) {
-                const maxChars = typeof action.max_chars === "number" ? Math.max(200, Math.min(12000, action.max_chars)) : undefined;
+                const maxChars = typeof action.max_chars === "number" ? Math.max(400, Math.min(32_000, action.max_chars)) : undefined;
                 actions.push({ type: "read_file", path: filePath, max_chars: maxChars });
             }
             continue;
         }
         if (type === "list_files" || type === "ls") {
             const filePath = asString(action.path) || "~";
-            const limit = typeof action.limit === "number" ? Math.max(1, Math.min(200, action.limit)) : undefined;
+            const limit = typeof action.limit === "number" ? Math.max(1, Math.min(5_000, action.limit)) : undefined;
             actions.push({ type: "list_files", path: filePath, limit });
             continue;
         }
@@ -1389,14 +1418,18 @@ export class NativeMacOSJobExecutor {
                 }
                 if (action.type === "read_file") {
                     await reporter.progress(progressPercent, `Lendo ${action.path}`);
-                    const fileContent = await this.readLocalFile(action.path, action.max_chars);
-                    completionNotes.push(`Conteudo de ${action.path}:\n${fileContent}`);
+                    const fileContent = await this.readLocalFileSnapshot(action.path, action.max_chars);
+                    resultPayload.read_file = fileContent;
+                    resultPayload.summary = fileContent.summary;
+                    completionNotes.push(fileContent.summary);
                     continue;
                 }
                 if (action.type === "list_files") {
                     await reporter.progress(progressPercent, `Listando arquivos em ${action.path}`);
-                    const listing = await this.listLocalFiles(action.path, action.limit);
-                    completionNotes.push(`Arquivos em ${action.path}:\n${listing}`);
+                    const listing = await this.listLocalFilesSnapshot(action.path, action.limit);
+                    resultPayload.file_listing = listing;
+                    resultPayload.summary = listing.summary;
+                    completionNotes.push(listing.summary);
                     continue;
                 }
                 if (action.type === "count_files") {
@@ -2364,7 +2397,7 @@ return appNames as text
             snapshot.summary = `A pasta ${targetPath} tem ${entries.length} item${entries.length === 1 ? "" : "s"} e ocupa ${formatBytesCompact(totalSize)}.${childPreview ? ` Itens visiveis agora: ${childPreview}.` : ""}`;
             return snapshot;
         }
-        const preview = includePreview ? await this.readLocalFile(resolved, 1200) : undefined;
+        const preview = includePreview ? await this.readLocalFilePreview(resolved, 1200) : undefined;
         const snapshot = {
             captured_at: new Date().toISOString(),
             path: targetPath,
@@ -4961,9 +4994,9 @@ if let output = String(data: data, encoding: .utf8) {
             resized,
         };
     }
-    async readLocalFile(filePath, maxChars = 4000) {
-        const resolved = await this.resolveReadableFilePath(filePath);
+    async loadReadableFileContent(resolved) {
         const extension = path.extname(resolved).toLowerCase();
+        const mimeType = mimeTypeFromPath(resolved);
         if (TEXTUTIL_READABLE_EXTENSIONS.has(extension)) {
             const { stdout } = await this.runCommandCapture("textutil", [
                 "-convert",
@@ -4971,17 +5004,76 @@ if let output = String(data: data, encoding: .utf8) {
                 "-stdout",
                 resolved,
             ]);
-            const content = sanitizeTextForJsonTransport(stdout);
-            return clipTextPreview(content || "(arquivo sem texto legivel)", maxChars);
+            return {
+                mimeType,
+                encoding: "utf-8",
+                isBinary: false,
+                content: sanitizeTextForJsonTransport(stdout) || "(arquivo sem texto legivel)",
+            };
         }
         const raw = await readFile(resolved);
         if (isLikelyBinaryBuffer(raw)) {
             const filename = path.basename(resolved);
             const detectedType = extension || "binario";
-            return clipText(`O arquivo ${filename} parece ser binario (${detectedType}) e nao pode ser lido como texto puro pelo Otto Bridge ainda.`, maxChars);
+            return {
+                mimeType,
+                isBinary: true,
+                binaryNotice: `O arquivo ${filename} parece ser binario (${detectedType}) e nao pode ser lido como texto puro pelo Otto Bridge ainda.`,
+            };
+        }
+        return {
+            mimeType,
+            encoding: "utf-8",
+            isBinary: false,
+            content: sanitizeTextForJsonTransport(raw.toString("utf8")) || "(arquivo vazio)",
+        };
+    }
+    async readLocalFilePreview(filePath, maxChars = 1200) {
+        const resolved = await this.resolveReadableFilePath(filePath);
+        const loaded = await this.loadReadableFileContent(resolved);
+        if (loaded.isBinary) {
+            return clipText(loaded.binaryNotice || "O arquivo parece ser binario e nao pode ser lido como texto puro.", maxChars);
+        }
+        return clipTextPreview(loaded.content || "(arquivo vazio)", maxChars);
+    }
+    async readLocalFileSnapshot(filePath, chunkSizeChars = 4000) {
+        const resolved = await this.resolveReadableFilePath(filePath);
+        const entryStat = await stat(resolved);
+        const loaded = await this.loadReadableFileContent(resolved);
+        const fileName = path.basename(resolved) || resolved;
+        if (loaded.isBinary) {
+            return {
+                captured_at: new Date().toISOString(),
+                path: filePath,
+                resolved_path: resolved,
+                name: fileName,
+                mime_type: loaded.mimeType,
+                size_bytes: entryStat.size,
+                modified_at: entryStat.mtime.toISOString(),
+                is_binary: true,
+                binary_notice: loaded.binaryNotice,
+                summary: loaded.binaryNotice || `O arquivo ${filePath} parece ser binario e nao pode ser lido como texto puro.`,
+            };
         }
-        const content = sanitizeTextForJsonTransport(raw.toString("utf8"));
-        return clipTextPreview(content || "(arquivo vazio)", maxChars);
+        const content = loaded.content || "(arquivo vazio)";
+        const chunks = chunkTextForTransport(content, chunkSizeChars);
+        return {
+            captured_at: new Date().toISOString(),
+            path: filePath,
+            resolved_path: resolved,
+            name: fileName,
+            mime_type: loaded.mimeType,
+            size_bytes: entryStat.size,
+            modified_at: entryStat.mtime.toISOString(),
+            is_binary: false,
+            encoding: loaded.encoding || "utf-8",
+            content: chunks.length <= 1 ? content : undefined,
+            content_char_count: content.length,
+            chunk_size_chars: Math.max(400, Math.min(Math.round(chunkSizeChars || 4000), 32_000)),
+            chunk_count: chunks.length,
+            chunks,
+            summary: `Li ${filePath} por completo (${content.length} caracteres em ${chunks.length} bloco${chunks.length === 1 ? "" : "s"}).`,
+        };
     }
     async resolveReadableFilePath(filePath) {
         const resolved = expandUserPath(filePath);
@@ -5052,22 +5144,55 @@ if let output = String(data: data, encoding: .utf8) {
         }
         return null;
     }
-    async listLocalFiles(directoryPath, limit = 40) {
+    async listLocalFilesSnapshot(directoryPath, limit) {
         const resolved = expandUserPath(directoryPath);
-        const entries = await readdir(resolved, { withFileTypes: true });
-        const items = await Promise.all(entries.slice(0, limit).map(async (entry) => {
+        const allEntries = await readdir(resolved, { withFileTypes: true });
+        const sortedEntries = allEntries.sort((left, right) => {
+            if (left.isDirectory() !== right.isDirectory()) {
+                return left.isDirectory() ? -1 : 1;
+            }
+            return left.name.localeCompare(right.name);
+        });
+        const effectiveLimit = typeof limit === "number" && Number.isFinite(limit) ? Math.max(1, Math.min(Math.round(limit), 5_000)) : null;
+        const selectedEntries = effectiveLimit ? sortedEntries.slice(0, effectiveLimit) : sortedEntries;
+        const items = await Promise.all(selectedEntries.map(async (entry) => {
             const entryPath = path.join(resolved, entry.name);
-            let suffix = "";
+            let sizeBytes;
+            let modifiedAt;
             try {
                 const entryStat = await stat(entryPath);
-                suffix = entry.isDirectory() ? "/" : ` (${entryStat.size} bytes)`;
+                if (!entry.isDirectory()) {
+                    sizeBytes = entryStat.size;
+                }
+                modifiedAt = entryStat.mtime.toISOString();
             }
             catch {
-                suffix = entry.isDirectory() ? "/" : "";
+                // Ignore stat failures and return the visible entry metadata we have.
             }
-            return `${entry.name}${suffix}`;
+            return {
+                name: entry.name,
+                path: entryPath,
+                kind: entry.isDirectory() ? "directory" : (entry.isFile() ? "file" : "other"),
+                size_bytes: sizeBytes,
+                modified_at: modifiedAt,
+            };
         }));
-        return items.length > 0 ? items.join("\n") : "(pasta vazia)";
+        const summary = items.length === 0
+            ? `A pasta ${directoryPath} esta vazia.`
+            : effectiveLimit && allEntries.length > items.length
+                ? `Listei ${items.length} itens visiveis em ${directoryPath} agora. A pasta tem ${allEntries.length} itens no total.`
+                : `Listei ${items.length} itens de ${directoryPath} por completo.`;
+        return {
+            captured_at: new Date().toISOString(),
+            path: directoryPath,
+            resolved_path: resolved,
+            name: path.basename(resolved) || resolved,
+            item_count: items.length,
+            total_item_count: allEntries.length,
+            limit_applied: effectiveLimit || undefined,
+            entries: items,
+            summary,
+        };
     }
     async countLocalFiles(directoryPath, extensions, recursive = true) {
         const resolved = expandUserPath(directoryPath);

package/dist/types.js

@@ -1,5 +1,5 @@
 export const BRIDGE_CONFIG_VERSION = 1;
-export const BRIDGE_VERSION = "0.9.0";
+export const BRIDGE_VERSION = "0.9.1";
 export const BRIDGE_PACKAGE_NAME = "@leg3ndy/otto-bridge";
 export const DEFAULT_API_BASE_URL = "http://localhost:8000";
 export const DEFAULT_POLL_INTERVAL_MS = 3000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leg3ndy/otto-bridge",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "private": false,
   "type": "module",
   "description": "Local companion for Otto Bridge device pairing and WebSocket runtime.",