dulus 3.10.1__tar.gz → 3.10.2__tar.gz

{dulus-3.10.1/dulus.egg-info → dulus-3.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dulus
-Version: 3.10.1
+Version: 3.10.2
 Summary: Use IA as an agent without an API key. $0. Harvest your browser session for Gemini (guest, no login), Claude.ai, Claude Code, Kimi.com, Qwen, DeepSeek — drive them like an API, no per-token billing. Plus LiteLLM (100+ paid providers), local models via Ollama, /lang in 34 languages, Mesa Redonda, voice, OCR, MemPalace, embedded sandbox OS.
 Author: KevRojo
 License: GPL-3.0

dulus-3.10.2/display_blocks.py

@@ -0,0 +1,529 @@
+"""Display Blocks System - Visual representations of agent actions.
+
+Provides a structured way to represent agent actions visually across multiple
+frontends: CLI (dulus.py), WebChat (webchat_server.py), and Telegram.
+
+Display blocks are dict-based and can be rendered in various formats.
+"""
+from __future__ import annotations
+
+import difflib
+import html
+from typing import Literal
+
+
+# ── Display block type hints ─────────────────────────────────────────────────
+
+# These are the supported display block types
+DisplayBlockType = Literal[
+    "diff",
+    "todo",
+    "shell",
+    "background_task",
+    "think",
+    "code",
+    "table",
+    "error",
+]
+
+
+# ── CLI Renderer ─────────────────────────────────────────────────────────────
+
+
+class DisplayBlockRenderer:
+    """Render display blocks in various formats for different frontends.
+
+    Supports CLI (terminal), HTML (WebChat), and Telegram (Markdown) output formats.
+    Each render method takes a display block dict and returns a formatted string.
+    """
+
+    # ── Public API ──────────────────────────────────────────────────────────
+
+    @staticmethod
+    def render_cli(block: dict) -> str:
+        """Render a display block for CLI (terminal) output.
+
+        Args:
+            block: Display block dict with at least a 'type' key.
+
+        Returns:
+            Formatted string suitable for terminal display.
+        """
+        block_type = block.get("type", "unknown")
+        renderer = _CLI_RENDERERS.get(block_type, _CLI_RENDERERS["unknown"])
+        return renderer(block)
+
+    @staticmethod
+    def render_html(block: dict) -> str:
+        """Render a display block as HTML for WebChat.
+
+        Args:
+            block: Display block dict with at least a 'type' key.
+
+        Returns:
+            HTML string suitable for web display.
+        """
+        block_type = block.get("type", "unknown")
+        renderer = _HTML_RENDERERS.get(block_type, _HTML_RENDERERS["unknown"])
+        return renderer(block)
+
+    @staticmethod
+    def render_telegram(block: dict) -> str:
+        """Render a display block for Telegram (Markdown V2).
+
+        Args:
+            block: Display block dict with at least a 'type' key.
+
+        Returns:
+            Formatted string using Telegram Markdown V2 syntax.
+        """
+        block_type = block.get("type", "unknown")
+        renderer = _TG_RENDERERS.get(block_type, _TG_RENDERERS["unknown"])
+        return renderer(block)
+
+    @staticmethod
+    def render(block: dict, format: Literal["cli", "html", "telegram"] = "cli") -> str:
+        """Render a display block in the specified format.
+
+        Args:
+            block: Display block dict with at least a 'type' key.
+            format: Target format - "cli", "html", or "telegram".
+
+        Returns:
+            Formatted string in the requested format.
+        """
+        if format == "cli":
+            return DisplayBlockRenderer.render_cli(block)
+        elif format == "html":
+            return DisplayBlockRenderer.render_html(block)
+        elif format == "telegram":
+            return DisplayBlockRenderer.render_telegram(block)
+        return str(block)
+
+
+# ── CLI Renderers ────────────────────────────────────────────────────────────
+
+
+def _render_diff_cli(block: dict) -> str:
+    """Render a diff display block for CLI.
+
+    Shows a unified diff between old and new text.
+    """
+    path = block.get("path", "<unknown>")
+    old_text = block.get("old_text", "")
+    new_text = block.get("new_text", "")
+    old_start = block.get("old_start", 1)
+    new_start = block.get("new_start", 1)
+    is_summary = block.get("is_summary", False)
+
+    if is_summary:
+        return f"[Diff: {path}] (summary)"
+
+    old_lines = old_text.splitlines(keepends=True)
+    new_lines = new_text.splitlines(keepends=True)
+
+    # Generate unified diff
+    diff = difflib.unified_diff(
+        old_lines,
+        new_lines,
+        fromfile=f"a/{path}",
+        tofile=f"b/{path}",
+        lineterm="",
+    )
+    diff_text = "\n".join(diff)
+
+    if not diff_text:
+        return f"[Diff: {path}] No changes"
+
+    return f"[Diff: {path}]\n{diff_text}"
+
+
+def _render_todo_cli(block: dict) -> str:
+    """Render a todo display block for CLI."""
+    items = block.get("items", [])
+    if not items:
+        return "[Todo] No items"
+
+    lines = ["Todo List:"]
+    icons = {"pending": "[ ]", "in_progress": "[/]", "done": "[x]"}
+    for item in items:
+        status = item.get("status", "pending")
+        icon = icons.get(status, "[ ]")
+        lines.append(f"  {icon} {item.get('title', '')}")
+    return "\n".join(lines)
+
+
+def _render_shell_cli(block: dict) -> str:
+    """Render a shell command display block for CLI."""
+    command = block.get("command", "")
+    language = block.get("language", "bash")
+    return f"$ {command}"
+
+
+def _render_bg_task_cli(block: dict) -> str:
+    """Render a background task display block for CLI."""
+    task_id = block.get("task_id", "?")
+    kind = block.get("kind", "?")
+    status = block.get("status", "?")
+    description = block.get("description", "")
+
+    icons = {
+        "running": "●",
+        "completed": "✓",
+        "failed": "✗",
+        "stopped": "■",
+    }
+    icon = icons.get(status, "?")
+    return f"{icon} [{task_id}] {description} ({kind}, {status})"
+
+
+def _render_think_cli(block: dict) -> str:
+    """Render a think display block for CLI."""
+    thought = block.get("thought", "")
+    lines = thought.splitlines()
+    # Indent thought content for visual distinction
+    indented = "\n".join(f"  | {line}" for line in lines)
+    return f"[Thinking...]\n{indented}"
+
+
+def _render_code_cli(block: dict) -> str:
+    """Render a code display block for CLI."""
+    code = block.get("code", "")
+    language = block.get("language", "")
+    header = f"```{language}" if language else "```"
+    return f"{header}\n{code}\n```"
+
+
+def _render_table_cli(block: dict) -> str:
+    """Render a table display block for CLI."""
+    headers = block.get("headers", [])
+    rows = block.get("rows", [])
+    if not headers and not rows:
+        return "[Table] Empty"
+
+    # Simple text table rendering
+    all_rows = [headers] + rows if headers else rows
+    # Calculate column widths
+    col_count = max(len(r) for r in all_rows) if all_rows else 0
+    widths = [0] * col_count
+    for row in all_rows:
+        for i, cell in enumerate(row):
+            widths[i] = max(widths[i], len(str(cell)))
+
+    def _fmt_row(row: list) -> str:
+        cells = [str(cell).ljust(widths[i]) for i, cell in enumerate(row)]
+        return " | ".join(cells)
+
+    lines = []
+    if headers:
+        lines.append(_fmt_row(headers))
+        lines.append("-" * (sum(widths) + 3 * (col_count - 1)))
+    for row in rows:
+        lines.append(_fmt_row(row))
+    return "\n".join(lines)
+
+
+def _render_error_cli(block: dict) -> str:
+    """Render an error display block for CLI."""
+    message = block.get("message", "Unknown error")
+    return f"[Error] {message}"
+
+
+def _render_unknown_cli(block: dict) -> str:
+    """Render an unknown display block type for CLI."""
+    return f"[Display Block: {block.get('type', 'unknown')}]\n{str(block)}"
+
+
+_CLI_RENDERERS: dict[str, callable] = {
+    "diff": _render_diff_cli,
+    "todo": _render_todo_cli,
+    "shell": _render_shell_cli,
+    "background_task": _render_bg_task_cli,
+    "think": _render_think_cli,
+    "code": _render_code_cli,
+    "table": _render_table_cli,
+    "error": _render_error_cli,
+    "unknown": _render_unknown_cli,
+}
+
+
+# ── HTML Renderers ───────────────────────────────────────────────────────────
+
+
+def _render_diff_html(block: dict) -> str:
+    """Render a diff display block as HTML."""
+    path = html.escape(block.get("path", "<unknown>"))
+    old_text = html.escape(block.get("old_text", ""))
+    new_text = html.escape(block.get("new_text", ""))
+
+    return (
+        f'<div class="display-block diff-block">\n'
+        f'  <div class="diff-header">{path}</div>\n'
+        f'  <pre class="diff-old"><code>{old_text}</code></pre>\n'
+        f'  <pre class="diff-new"><code>{new_text}</code></pre>\n'
+        f"</div>"
+    )
+
+
+def _render_todo_html(block: dict) -> str:
+    """Render a todo display block as HTML."""
+    items = block.get("items", [])
+    if not items:
+        return '<div class="display-block todo-block"><p>No items</p></div>'
+
+    lines = ['<div class="display-block todo-block"><ul>']
+    icons = {
+        "pending": "⬜",
+        "in_progress": "🔄",
+        "done": "✅",
+    }
+    for item in items:
+        status = item.get("status", "pending")
+        icon = icons.get(status, "⬜")
+        title = html.escape(item.get("title", ""))
+        css_class = f"todo-{status}"
+        lines.append(f'  <li class="{css_class}">{icon} {title}</li>')
+    lines.append("</ul></div>")
+    return "\n".join(lines)
+
+
+def _render_shell_html(block: dict) -> str:
+    """Render a shell command display block as HTML."""
+    command = html.escape(block.get("command", ""))
+    language = html.escape(block.get("language", "bash"))
+    return (
+        f'<div class="display-block shell-block">\n'
+        f'  <pre><code class="language-{language}">${command}</code></pre>\n'
+        f"</div>"
+    )
+
+
+def _render_bg_task_html(block: dict) -> str:
+    """Render a background task display block as HTML."""
+    task_id = html.escape(block.get("task_id", "?"))
+    kind = html.escape(block.get("kind", "?"))
+    status = html.escape(block.get("status", "?"))
+    description = html.escape(block.get("description", ""))
+
+    status_colors = {
+        "running": "#2196F3",
+        "completed": "#4CAF50",
+        "failed": "#f44336",
+        "stopped": "#FF9800",
+    }
+    color = status_colors.get(status, "#9E9E9E")
+
+    return (
+        f'<div class="display-block bg-task-block">\n'
+        f'  <span class="task-id">[{task_id}]</span>\n'
+        f'  <span class="task-desc">{description}</span>\n'
+        f'  <span class="task-kind">({kind})</span>\n'
+        f'  <span class="task-status" style="color: {color};">{status}</span>\n'
+        f"</div>"
+    )
+
+
+def _render_think_html(block: dict) -> str:
+    """Render a think display block as HTML."""
+    thought = html.escape(block.get("thought", ""))
+    return (
+        f'<div class="display-block think-block">\n'
+        f'  <div class="think-header">💭 Thinking</div>\n'
+        f'  <pre class="think-content">{thought}</pre>\n'
+        f"</div>"
+    )
+
+
+def _render_code_html(block: dict) -> str:
+    """Render a code display block as HTML."""
+    code = html.escape(block.get("code", ""))
+    language = html.escape(block.get("language", ""))
+    return (
+        f'<div class="display-block code-block">\n'
+        f'  <pre><code class="language-{language}">{code}</code></pre>\n'
+        f"</div>"
+    )
+
+
+def _render_table_html(block: dict) -> str:
+    """Render a table display block as HTML."""
+    headers = block.get("headers", [])
+    rows = block.get("rows", [])
+    if not headers and not rows:
+        return '<div class="display-block table-block"><p>Empty table</p></div>'
+
+    lines = ['<div class="display-block table-block">', "<table>"]
+    if headers:
+        lines.append("  <tr>" + "".join(f"<th>{html.escape(str(h))}</th>" for h in headers) + "</tr>")
+    for row in rows:
+        lines.append("  <tr>" + "".join(f"<td>{html.escape(str(c))}</td>" for c in row) + "</tr>")
+    lines.extend(["</table>", "</div>"])
+    return "\n".join(lines)
+
+
+def _render_error_html(block: dict) -> str:
+    """Render an error display block as HTML."""
+    message = html.escape(block.get("message", "Unknown error"))
+    return (
+        f'<div class="display-block error-block" style="color: #f44336;">\n'
+        f'  <strong>Error:</strong> {message}\n'
+        f"</div>"
+    )
+
+
+def _render_unknown_html(block: dict) -> str:
+    """Render an unknown display block type as HTML."""
+    content = html.escape(str(block))
+    return f'<div class="display-block unknown-block"><pre>{content}</pre></div>'
+
+
+_HTML_RENDERERS: dict[str, callable] = {
+    "diff": _render_diff_html,
+    "todo": _render_todo_html,
+    "shell": _render_shell_html,
+    "background_task": _render_bg_task_html,
+    "think": _render_think_html,
+    "code": _render_code_html,
+    "table": _render_table_html,
+    "error": _render_error_html,
+    "unknown": _render_unknown_html,
+}
+
+
+# ── Telegram Renderers ───────────────────────────────────────────────────────
+
+
+def _render_diff_telegram(block: dict) -> str:
+    """Render a diff display block for Telegram (Markdown V2).
+
+    Note: Telegram has limited formatting for diffs, so we keep it simple.
+    """
+    path = block.get("path", "<unknown>")
+    old_text = block.get("old_text", "")
+    new_text = block.get("new_text", "")
+
+    # Escape Telegram Markdown V2 special chars
+    def _esc(text: str) -> str:
+        for c in "_[]()~`>#+-=|{}.!":
+            text = text.replace(c, f"\\{c}")
+        return text
+
+    return f"📝 *{_esc(path)}*\n```diff\n- {_esc('Old')}\n+ {_esc('New')}\n```"
+
+
+def _render_todo_telegram(block: dict) -> str:
+    """Render a todo display block for Telegram (Markdown V2)."""
+    items = block.get("items", [])
+    if not items:
+        return "📋 *Todo List:* Empty"
+
+    def _esc(text: str) -> str:
+        for c in "_[]()~`>#+-=|{}.!":
+            text = text.replace(c, f"\\{c}")
+        return text
+
+    icons = {
+        "pending": "⬜",
+        "in_progress": "🔄",
+        "done": "✅",
+    }
+    lines = ["📋 *Todo List:*"]
+    for item in items:
+        status = item.get("status", "pending")
+        icon = icons.get(status, "⬜")
+        title = _esc(item.get("title", ""))
+        lines.append(f"{icon} {title}")
+    return "\n".join(lines)
+
+
+def _render_shell_telegram(block: dict) -> str:
+    """Render a shell command display block for Telegram."""
+    command = block.get("command", "")
+    return f"```bash\n$ {command}\n```"
+
+
+def _render_bg_task_telegram(block: dict) -> str:
+    """Render a background task display block for Telegram."""
+    task_id = block.get("task_id", "?")
+    kind = block.get("kind", "?")
+    status = block.get("status", "?")
+    description = block.get("description", "")
+
+    icons = {
+        "running": "🔄",
+        "completed": "✅",
+        "failed": "❌",
+        "stopped": "🛑",
+    }
+    icon = icons.get(status, "❓")
+
+    def _esc(text: str) -> str:
+        for c in "_[]()~`>#+-=|{}.!":
+            text = text.replace(c, f"\\{c}")
+        return text
+
+    return f"{icon} *Task `{task_id}`*\n{_esc(description)}\n({_esc(kind)}, {_esc(status)})"
+
+
+def _render_think_telegram(block: dict) -> str:
+    """Render a think display block for Telegram."""
+    thought = block.get("thought", "")
+    return f"💭 *Thinking*\n```\n{thought[:3000]}\n```"
+
+
+def _render_code_telegram(block: dict) -> str:
+    """Render a code display block for Telegram."""
+    code = block.get("code", "")
+    language = block.get("language", "")
+    return f"```{language}\n{code[:3000]}\n```"
+
+
+def _render_table_telegram(block: dict) -> str:
+    """Render a table display block for Telegram."""
+    headers = block.get("headers", [])
+    rows = block.get("rows", [])
+    if not headers and not rows:
+        return "📊 *Table:* Empty"
+
+    def _esc(text: str) -> str:
+        for c in "_[]()~`>#+-=|{}.!":
+            text = text.replace(c, f"\\{c}")
+        return text
+
+    lines = []
+    if headers:
+        lines.append(" | ".join(_esc(str(h)) for h in headers))
+        lines.append("—" * 20)
+    for row in rows:
+        lines.append(" | ".join(_esc(str(c)) for c in row))
+    return "\n".join(lines)
+
+
+def _render_error_telegram(block: dict) -> str:
+    """Render an error display block for Telegram."""
+    message = block.get("message", "Unknown error")
+
+    def _esc(text: str) -> str:
+        for c in "_[]()~`>#+-=|{}.!":
+            text = text.replace(c, f"\\{c}")
+        return text
+
+    return f"❌ *Error:* {_esc(message)}"
+
+
+def _render_unknown_telegram(block: dict) -> str:
+    """Render an unknown display block type for Telegram."""
+    return f"```\n{str(block)[:1000]}\n```"
+
+
+_TG_RENDERERS: dict[str, callable] = {
+    "diff": _render_diff_telegram,
+    "todo": _render_todo_telegram,
+    "shell": _render_shell_telegram,
+    "background_task": _render_bg_task_telegram,
+    "think": _render_think_telegram,
+    "code": _render_code_telegram,
+    "table": _render_table_telegram,
+    "error": _render_error_telegram,
+    "unknown": _render_unknown_telegram,
+}

{dulus-3.10.1 → dulus-3.10.2/dulus.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dulus
-Version: 3.10.1
+Version: 3.10.2
 Summary: Use IA as an agent without an API key. $0. Harvest your browser session for Gemini (guest, no login), Claude.ai, Claude Code, Kimi.com, Qwen, DeepSeek — drive them like an API, no per-token billing. Plus LiteLLM (100+ paid providers), local models via Ollama, /lang in 34 languages, Mesa Redonda, voice, OCR, MemPalace, embedded sandbox OS.
 Author: KevRojo
 License: GPL-3.0

{dulus-3.10.1 → dulus-3.10.2}/dulus.egg-info/SOURCES.txt

@@ -11,26 +11,34 @@ common.py
 compaction.py
 config.py
 context.py
+display_blocks.py
 dulus.py
 dulus_gui.py
 dulus_gui_web.py
+file_filter.py
 governance.py
 input.py
 license_manager.py
 offload_helper.py
+paste_placeholders.py
 personality_config.py
+profiles.py
 providers.py
 pyproject.toml
 sandbox_bootstrap.py
 skills.py
 soul.py
 spinner.py
+steer_input.py
 string_utils.py
 subagent.py
 tmux_offloader.py
 tmux_tools.py
 tool_registry.py
 tools.py
+tools_background.py
+tools_think.py
+tools_todo.py
 updater.py
 webchat.py
 webchat_server.py

{dulus-3.10.1 → dulus-3.10.2}/dulus.egg-info/top_level.txt

@@ -11,12 +11,14 @@ compaction
 config
 context
 data
+display_blocks
 docs
 dulus
 dulus_gui
 dulus_gui_web
 dulus_mcp
 dulus_tools
+file_filter
 governance
 gui
 input
@@ -24,8 +26,10 @@ license_manager
 memory
 multi_agent
 offload_helper
+paste_placeholders
 personality_config
 plugin
+profiles
 providers
 sandbox
 sandbox_bootstrap
@@ -33,6 +37,7 @@ skill
 skills
 soul
 spinner
+steer_input
 string_utils
 subagent
 task
@@ -40,6 +45,9 @@ tmux_offloader
 tmux_tools
 tool_registry
 tools
+tools_background
+tools_think
+tools_todo
 ui
 updater
 voice