yunta-harness 1.0.2__py3-none-any.whl

yunta/__init__.py

@@ -0,0 +1,25 @@
+from .agent import Agent
+from .api import Block, BlockType, Message, Response, Role, StopReason, ToolDef, Usage
+from .compact import NoCompaction, SlidingWindow
+from .provider import LiteLLMProvider
+from .feedback import FeedbackStore
+
+__all__ = [
+    # Núcleo (estable desde v0.1)
+    "Agent",
+    "Block",
+    "BlockType",
+    "Message",
+    "Response",
+    "Role",
+    "StopReason",
+    "ToolDef",
+    "Usage",
+    # Compactación (estable desde v0.1)
+    "NoCompaction",
+    "SlidingWindow",
+    # Provider (estable desde v0.1; send/on_text desde v0.7)
+    "LiteLLMProvider",
+    # Auto-feedback (estable desde v0.3)
+    "FeedbackStore",
+]

yunta/agent.py

@@ -0,0 +1,181 @@
+import difflib
+import inspect
+import json
+from pathlib import Path
+
+from .api import Block, BlockType, Message, Response, Role, StopReason, Usage
+from .tools import registry
+
+
+class Agent:
+    def __init__(
+        self,
+        provider,
+        system: str,
+        compactor=None,
+        max_turns: int = 30,
+        confirm=None,
+        tools: list | None = None,
+    ):
+        self.provider = provider
+        self.system = system
+        self.compactor = compactor
+        self.max_turns = max_turns
+        self.confirm = confirm
+        self.messages: list[Message] = []
+        self._tools_subset = list(tools) if tools is not None else None
+        self.usage = Usage()
+
+    def send(self, prompt: str) -> str:
+        self.usage.turns += 1
+        self.messages.append(
+            Message(role=Role.USER, content=[Block(type=BlockType.TEXT, text=prompt)])
+        )
+        return self._loop()
+
+    def _definitions(self) -> list:
+        if self._tools_subset is None:
+            return registry.definitions()
+        return [
+            t for t in registry.definitions() if t.name in {tool.name for tool in self._tools_subset}
+        ]
+
+    def _loop(self) -> str:
+        final_text = []
+        try:
+            for _ in range(self.max_turns):
+                if self.compactor:
+                    self.messages = self.compactor.compact(self.messages)
+
+                try:
+                    supports_stream = (
+                        "on_text" in inspect.signature(self.provider.send).parameters
+                    )
+                except (TypeError, ValueError):
+                    supports_stream = False
+                self._streamed = False
+                if supports_stream:
+                    resp = self.provider.send(self.messages, self._definitions(), on_text=self._stream_text)
+                else:
+                    resp = self.provider.send(self.messages, self._definitions())
+                if not hasattr(self.provider, "total_usage") and getattr(resp, "usage", None):
+                    self.usage = self.usage.add(resp.usage)
+                self.messages.append(Message(role=Role.ASSISTANT, content=resp.content))
+
+                tool_results = []
+                has_tool_call = False
+                for b in resp.content:
+                    if b.type == BlockType.TEXT and b.text:
+                        if self._streamed:
+                            print()
+                        else:
+                            print(b.text)
+                        final_text.append(b.text)
+                    elif b.type == BlockType.TOOL_USE:
+                        has_tool_call = True
+                        result, is_err = self._execute_tool(b.tool_name, b.tool_input)
+                        tool_results.append(
+                            Block(
+                                type=BlockType.TOOL_RESULT,
+                                tool_use_id=b.tool_use_id,
+                                tool_result=result,
+                                is_error=is_err,
+                            )
+                        )
+
+                if resp.stop_reason != StopReason.TOOL_USE or not has_tool_call:
+                    return "\n".join(final_text).strip()
+
+                self.messages.append(Message(role=Role.USER, content=tool_results))
+        except KeyboardInterrupt:
+            print("\n(interrumpido por el usuario)")
+            if self.messages and self.messages[-1].role == Role.USER:
+                self.messages.append(
+                    Message(
+                        role=Role.ASSISTANT,
+                        content=[Block(type=BlockType.TEXT, text="[interrumpido por el usuario]")],
+                    )
+                )
+            return "\n".join(final_text).strip() or "[interrumpido por el usuario]"
+
+        return "\n".join(final_text).strip()
+
+    def _stream_text(self, delta: str) -> None:
+        print(delta, end="", flush=True)
+        self._streamed = True
+
+    def _execute_tool(self, name: str, raw_input: str) -> tuple[str, bool]:
+        self.usage.tool_counts[name] = self.usage.tool_counts.get(name, 0) + 1
+        tool = registry.get(name)
+        if tool is None:
+            self.usage.tool_errors += 1
+            return f"unknown tool: {name}", True
+
+        detail = self._tool_detail(name, raw_input)
+        print(f"[tool] {name} {raw_input}")
+        if tool.requires_approval and not self._approve(name, detail):
+            self.usage.tool_errors += 1
+            return "user denied this tool call", True
+
+        try:
+            res = tool.fn(raw_input)
+            return res, False
+        except Exception as e:
+            self.usage.tool_errors += 1
+            return f"{type(e).__name__}: {e}", True
+
+    @staticmethod
+    def _tool_detail(name: str, raw_input: str) -> str:
+        if name not in ("write_file", "str_replace"):
+            return ""
+        try:
+            args = json.loads(raw_input or "{}")
+        except json.JSONDecodeError:
+            return ""
+
+        path = args.get("path", "")
+        if not path:
+            return ""
+
+        p = Path(path)
+        old = p.read_text(encoding="utf-8", errors="replace") if p.exists() else ""
+
+        if name == "write_file":
+            new_content = args.get("content", "")
+        elif name == "str_replace":
+            old_str = args.get("old_str", "")
+            new_str = args.get("new_str", "")
+            if not old_str or old.count(old_str) != 1:
+                return ""
+            new_content = old.replace(old_str, new_str, 1)
+
+        diff = difflib.unified_diff(
+            old.splitlines(keepends=True),
+            new_content.splitlines(keepends=True),
+            fromfile=f"a/{path}",
+            tofile=f"b/{path}",
+        )
+        return "".join(diff)
+
+    def _approve(self, name: str, detail: str) -> bool:
+        if self.confirm is not None:
+            return self.confirm(name, detail)
+        if detail:
+            print(detail)
+        answer = input(f"¿Ejecutar {name}? [y/N] ").strip().lower()
+        return answer == "y"
+
+    @property
+    def total_usage(self) -> Usage:
+        p_usage = getattr(self.provider, "total_usage", None)
+        in_tok = p_usage.input_tokens if p_usage else self.usage.input_tokens
+        out_tok = p_usage.output_tokens if p_usage else self.usage.output_tokens
+        cached_tok = p_usage.cached_tokens if p_usage else self.usage.cached_tokens
+        return Usage(
+            input_tokens=in_tok,
+            output_tokens=out_tok,
+            cached_tokens=cached_tok,
+            tool_counts=dict(self.usage.tool_counts),
+            tool_errors=self.usage.tool_errors,
+            turns=self.usage.turns,
+        )

yunta/api.py

@@ -0,0 +1,123 @@
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class Role(str, Enum):
+    USER = "user"
+    ASSISTANT = "assistant"
+
+
+class BlockType(str, Enum):
+    TEXT = "text"
+    TOOL_USE = "tool_use"
+    TOOL_RESULT = "tool_result"
+
+
+class StopReason(str, Enum):
+    END_TURN = "end_turn"
+    TOOL_USE = "tool_use"
+    OTHER = "other"
+
+
+@dataclass
+class Block:
+    type: BlockType
+    text: str = ""
+    tool_use_id: str = ""
+    tool_name: str = ""
+    tool_input: str = ""
+    tool_result: str = ""
+    is_error: bool = False
+
+
+@dataclass
+class Message:
+    role: Role
+    content: list[Block] = field(default_factory=list)
+
+    def has_tool_result(self) -> bool:
+        return any(b.type == BlockType.TOOL_RESULT for b in self.content)
+
+
+@dataclass
+class ToolDef:
+    name: str
+    description: str
+    parameters: dict
+
+
+@dataclass
+class Usage:
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cached_tokens: int = 0
+    tool_counts: dict[str, int] = field(default_factory=dict)
+    tool_errors: int = 0
+    turns: int = 0
+
+    def add(self, other: "Usage") -> "Usage":
+        merged_tools = dict(self.tool_counts)
+        for k, v in other.tool_counts.items():
+            merged_tools[k] = merged_tools.get(k, 0) + v
+        return Usage(
+            input_tokens=self.input_tokens + other.input_tokens,
+            output_tokens=self.output_tokens + other.output_tokens,
+            cached_tokens=self.cached_tokens + other.cached_tokens,
+            tool_counts=merged_tools,
+            tool_errors=self.tool_errors + other.tool_errors,
+            turns=self.turns + other.turns,
+        )
+
+    @property
+    def cache_rate(self) -> float:
+        """Porcentaje de tokens de entrada que vinieron de caché."""
+        total_in = self.input_tokens + self.cached_tokens
+        return (self.cached_tokens / total_in * 100.0) if total_in else 0.0
+
+    @property
+    def theoretical_raw_tokens(self) -> int:
+        """Tokens de entrada brutos que habrías transferido en un chat crudo sin caching."""
+        return self.input_tokens + self.cached_tokens
+
+    @property
+    def total_tool_calls(self) -> int:
+        """Total acumulado de llamadas a herramientas."""
+        return sum(self.tool_counts.values())
+
+    def format_summary(self) -> str:
+        """Formatea un resumen legible y comparativo en 2-3 líneas limpias."""
+        total_in = self.theoretical_raw_tokens
+        cached_info = f" (⚡ {self.cache_rate:.1f}% ahorro de caché)" if self.cached_tokens else ""
+        lines = [
+            f"Tokens: entrada={self.input_tokens:,} | cacheados={self.cached_tokens:,}{cached_info} | salida={self.output_tokens:,}",
+            f"Sin Harness habrías transferido: {total_in:,} tokens de entrada",
+        ]
+        if self.tool_counts:
+            breakdown = ", ".join(f"{k}: {v}" for k, v in sorted(self.tool_counts.items()))
+            err_info = f" (errores/rechazos: {self.tool_errors})" if self.tool_errors else ""
+            lines.append(f"Herramientas ({self.total_tool_calls} llamadas): {breakdown}{err_info}")
+        if self.turns:
+            lines.append(f"Turnos de interacción: {self.turns}")
+        return "\n".join(lines)
+
+
+@dataclass
+class Response:
+    content: list[Block] = field(default_factory=list)
+    stop_reason: StopReason = StopReason.OTHER
+    usage: Usage = field(default_factory=Usage)
+
+
+def render_transcript(messages: list[Message]) -> str:
+    lines = []
+    for m in messages:
+        parts = []
+        for b in m.content:
+            if b.type == BlockType.TEXT:
+                parts.append(b.text)
+            elif b.type == BlockType.TOOL_USE:
+                parts.append(f"[called {b.tool_name} with {b.tool_input}]")
+            else:
+                parts.append(f"[tool result: {b.tool_result}]")
+        lines.append(f"{m.role.value}: " + "\n".join(parts))
+    return "\n".join(lines)

yunta/cli.py

@@ -0,0 +1,103 @@
+import os
+import sys
+from pathlib import Path
+
+from .agent import Agent
+from .feedback import FeedbackStore
+from .mcp import load_mcp_servers
+from .provider import LiteLLMProvider
+from .tools import bash, delegate, files, memory, search  # noqa: F401 — registro vía decoradores
+
+SYSTEM_PROMPT = """Eres un ingeniero de software que programa en pareja a través del harness Yunta.
+Trabajas iterando: lees archivos, ejecutas comandos y editas código usando tus tools.
+Sé conciso. Si un tool falla, el error vuelve a tu contexto: ajústalo y reintenta.
+Responde en el idioma del usuario.
+
+Frontera de rol y entorno de ejecución:
+- Yunta es tu banco de herramientas en terminal (read_file, str_replace, bash), NO el runtime de la aplicación.
+- Tu objetivo es desarrollar el código del proyecto del usuario en este espacio de trabajo.
+- NUNCA crees servicios, daemons ni plugins que corran "dentro de Yunta". El software desarrollado vivirá en su propio entorno de producción (ej. nube, contenedor, Power Automate, web, CLI propio, etc.).
+
+Reglas de honestidad y verificación:
+- NUNCA afirmes haber ejecutado o editado algo sin haberlo hecho con una tool
+  real en esta conversación. Narrar acciones imaginarias es un fallo grave.
+- Verifica tu trabajo: tras editar código, ejecuta los tests o el comando
+  que demuestre el resultado antes de declararlo resuelto."""
+
+
+def load_system_prompt(feedback: FeedbackStore | None = None) -> str:
+    env_prompt = os.environ.get("YUNTA_SYSTEM_PROMPT")
+    user_prompt_file = Path.home() / ".yunta" / "system_prompt.md"
+    if env_prompt:
+        prompt = env_prompt
+    elif user_prompt_file.exists():
+        prompt = user_prompt_file.read_text(encoding="utf-8")
+    else:
+        prompt = SYSTEM_PROMPT
+
+    agents_md = Path("AGENTS.md")
+    if agents_md.exists():
+        prompt += "\n\n# Contexto del proyecto (AGENTS.md)\n\n" + agents_md.read_text(
+            encoding="utf-8"
+        )
+    if feedback is not None:
+        prompt += feedback.preamble()
+    return prompt
+
+
+def main():
+    if sys.platform == "win32":
+        try:
+            sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+            sys.stderr.reconfigure(encoding="utf-8", errors="replace")
+        except Exception:
+            pass
+    feedback = FeedbackStore()
+    system = load_system_prompt(feedback)
+    provider = LiteLLMProvider(system=system)
+    delegate.set_provider(provider)
+    mcp_clients = load_mcp_servers()
+    agent = Agent(provider=provider, system=system)
+
+    print(f"yunta — modelo: {provider.model()}")
+    print("Escribe tu consulta, /tokens o /metrics para telemetría, /clear para limpiar, /exit para salir.\n")
+
+    try:
+        while True:
+            try:
+                prompt = input("> ").strip()
+            except (EOFError, KeyboardInterrupt):
+                print()
+                break
+
+            if not prompt:
+                continue
+            if prompt == "/exit":
+                if agent.messages:
+                    feedback.summarize(provider, agent.messages)
+                break
+            if prompt == "/clear":
+                agent.messages.clear()
+                print("(historial limpio)\n")
+                continue
+            if prompt in ("/tokens", "/metrics"):
+                u = agent.total_usage
+                print(u.format_summary() + "\n")
+                continue
+
+            try:
+                agent.send(prompt)
+            except KeyboardInterrupt:
+                print()
+            except SystemExit:
+                raise
+            except Exception as e:
+                print(f"error: {e}", file=sys.stderr)
+            print()
+    finally:
+        for c in mcp_clients:
+            c.close()
+
+
+if __name__ == "__main__":
+    main()

yunta/compact.py

@@ -0,0 +1,28 @@
+from .api import BlockType, Message, Role
+
+
+class NoCompaction:
+    def compact(self, messages: list[Message]) -> list[Message]:
+        return messages
+
+
+class SlidingWindow:
+    """Descarta los mensajes más viejos, cortando solo en límites seguros:
+    justo antes de un mensaje user que no contiene tool_results."""
+
+    def __init__(self, max_messages: int = 40):
+        self.max_messages = max_messages
+
+    def compact(self, messages: list[Message]) -> list[Message]:
+        if len(messages) <= self.max_messages:
+            return messages
+        excess = len(messages) - self.max_messages
+        # límite seguro: el índice del primer mensaje user (sin tool_results)
+        # que esté en o después del exceso; nunca deja un assistant o
+        # tool_result huérfano al inicio de lo que queda.
+        cut = excess
+        for i in range(excess, len(messages)):
+            if messages[i].role == Role.USER and not messages[i].has_tool_result():
+                cut = i
+                break
+        return messages[cut:]

yunta/feedback.py

@@ -0,0 +1,74 @@
+from datetime import date
+from pathlib import Path
+
+from .api import Block, BlockType, Message, Role
+
+LESSON_PROMPT = """Auto-evalúa la sesión que termina. Responde EXACTAMENTE en tres líneas:
+
+TAREA: <la tarea principal, en una frase>
+RESULTADO: <logrado / parcial / fallido, con una palabra de por qué>
+LECCION: <una regla concreta y accionable para futuras sesiones; si todo
+salió bien, una práctica que ayudó>
+
+Sin más texto."""
+
+HEADER = "# Lecciones de sesiones anteriores (auto-feedback del harness)\n\n"
+
+
+class FeedbackStore:
+    """Registro persistente de auto-evaluaciones. Las últimas lecciones se
+    inyectan en el system prompt al arrancar: el agente aprende de sí mismo."""
+
+    def __init__(self, path: str = ".yunta/learnings.md"):
+        self.path = Path(path)
+
+    def append(self, task: str, outcome: str, lesson: str) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        if not self.path.exists():
+            self.path.write_text(HEADER, encoding="utf-8")
+        line = f"- [{date.today().isoformat()}] {task} → {outcome}. Lección: {lesson}\n"
+        with self.path.open("a", encoding="utf-8") as f:
+            f.write(line)
+
+    def lessons(self, limit: int = 5) -> list[str]:
+        if not self.path.exists():
+            return []
+        lines = [
+            l.strip("- \n")
+            for l in self.path.read_text(encoding="utf-8").splitlines()
+            if l.startswith("- ")
+        ]
+        return lines[-limit:]
+
+    def preamble(self, limit: int = 5) -> str:
+        lessons = self.lessons(limit)
+        if not lessons:
+            return ""
+        body = "\n".join(f"- {l}" for l in lessons)
+        return (
+            "\n\n# Lecciones de sesiones anteriores (aprendidas por ti mismo)\n\n"
+            f"{body}\n"
+        )
+
+    def summarize(self, provider, messages: list[Message]) -> None:
+        """Pide al modelo la auto-evaluación de la sesión y la persiste.
+        Best-effort: cualquier fallo se ignora silenciosamente."""
+        try:
+            resp = provider.send(
+                [Message(role=Role.USER, content=[Block(type=BlockType.TEXT, text=LESSON_PROMPT)])]
+                + messages,
+                [],
+            )
+            text = {b.type: b.text for b in resp.content if b.type == BlockType.TEXT}
+            parts = {}
+            for line in text.get(BlockType.TEXT, "").splitlines():
+                if ":" in line:
+                    k, v = line.split(":", 1)
+                    parts[k.strip().upper()] = v.strip()
+            task = parts.get("TAREA", "(sin registrar)")
+            outcome = parts.get("RESULTADO", "desconocido")
+            lesson = parts.get("LECCION", "")
+            if lesson:
+                self.append(task, outcome, lesson)
+        except Exception:
+            pass

yunta/mcp.py

@@ -0,0 +1,147 @@
+import json
+import os
+import subprocess
+from pathlib import Path
+from .tools import Tool, _parse, registry
+
+
+class MCPClient:
+    def __init__(self, name: str, command: str, args: list[str] | None = None, env: dict | None = None):
+        self.name = name
+        full_env = {**os.environ, **(env or {})}
+        cmd = [command] + (args or [])
+        self.proc = subprocess.Popen(
+            cmd,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            env=full_env,
+        )
+        self._req_id = 0
+        self._init_server()
+
+    def _next_id(self) -> int:
+        self._req_id += 1
+        return self._req_id
+
+    def _send(self, method: str, params: dict | None = None, is_notification: bool = False) -> dict | None:
+        req_id = None if is_notification else self._next_id()
+        msg = {"jsonrpc": "2.0", "method": method}
+        if req_id is not None:
+            msg["id"] = req_id
+        if params is not None:
+            msg["params"] = params
+        line = json.dumps(msg) + "\n"
+        if not self.proc.stdin:
+            raise RuntimeError(f"MCP server '{self.name}' stdin is closed")
+        self.proc.stdin.write(line)
+        self.proc.stdin.flush()
+        if is_notification:
+            return None
+
+        while True:
+            resp_line = self.proc.stdout.readline()
+            if not resp_line:
+                err = self.proc.stderr.read() if self.proc.stderr else ""
+                raise RuntimeError(f"MCP server '{self.name}' terminated unexpectedly: {err}")
+            resp_line = resp_line.strip()
+            if not resp_line:
+                continue
+            try:
+                data = json.loads(resp_line)
+                if data.get("id") == req_id:
+                    if "error" in data:
+                        err_msg = data["error"].get("message", str(data["error"]))
+                        raise RuntimeError(f"MCP error: {err_msg}")
+                    return data.get("result", {})
+            except json.JSONDecodeError:
+                continue
+
+    def _init_server(self):
+        self._send(
+            "initialize",
+            {
+                "protocolVersion": "2024-11-05",
+                "capabilities": {},
+                "clientInfo": {"name": "yunta", "version": "0.8.0"},
+            },
+        )
+        self._send("notifications/initialized", is_notification=True)
+
+    def list_tools(self) -> list[dict]:
+        res = self._send("tools/list", {}) or {}
+        return res.get("tools", [])
+
+    def call_tool(self, tool_name: str, arguments: dict) -> str:
+        res = self._send("tools/call", {"name": tool_name, "arguments": arguments}) or {}
+        contents = res.get("content", [])
+        parts = []
+        for c in contents:
+            if isinstance(c, dict):
+                parts.append(c.get("text", json.dumps(c)))
+            else:
+                parts.append(str(c))
+        return "\n".join(parts) if parts else json.dumps(res)
+
+    def close(self):
+        try:
+            if self.proc.stdin:
+                self.proc.stdin.close()
+            self.proc.terminate()
+            self.proc.wait(timeout=2)
+        except Exception:
+            try:
+                self.proc.kill()
+            except Exception:
+                pass
+
+
+def load_mcp_servers(config_path: str = ".yunta/mcp.json") -> list[MCPClient]:
+    path = Path(config_path)
+    if not path.exists():
+        return []
+    try:
+        cfg = json.loads(path.read_text(encoding="utf-8"))
+    except Exception as e:
+        print(f"advertencia: fallo al leer {config_path}: {e}")
+        return []
+
+    servers = cfg.get("mcpServers", {})
+    clients = []
+    for s_name, s_cfg in servers.items():
+        cmd = s_cfg.get("command")
+        if not cmd:
+            continue
+        try:
+            client = MCPClient(
+                name=s_name,
+                command=cmd,
+                args=s_cfg.get("args"),
+                env=s_cfg.get("env"),
+            )
+            for t in client.list_tools():
+                original_name = t.get("name", "")
+                tool_name = f"mcp__{s_name}__{original_name}"
+                desc = t.get("description", "")
+                schema = t.get("inputSchema", {"type": "object", "properties": {}})
+
+                def make_handler(c: MCPClient, orig_n: str):
+                    def handler(raw: str) -> str:
+                        args = _parse(raw)
+                        return c.call_tool(orig_n, args)
+                    return handler
+
+                registry._tools[tool_name] = Tool(
+                    name=tool_name,
+                    description=f"[MCP:{s_name}] {desc}",
+                    parameters=schema,
+                    fn=make_handler(client, original_name),
+                    requires_approval=s_cfg.get("requires_approval", False),
+                )
+            clients.append(client)
+        except Exception as e:
+            print(f"advertencia: no se pudo iniciar servidor MCP '{s_name}': {e}")
+    return clients