aru-code 0.59.0__tar.gz → 0.61.0__tar.gz

{aru_code-0.59.0/aru_code.egg-info → aru_code-0.61.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aru-code
-Version: 0.59.0
+Version: 0.61.0
 Summary: A Claude Code clone built with Agno agents
 Author-email: Estevao <estevaofon@gmail.com>
 License-Expression: MIT

aru_code-0.61.0/aru/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.61.0"

{aru_code-0.59.0 → aru_code-0.61.0}/aru/agents/base.py

@@ -3,6 +3,33 @@
 # Common rules shared across all agents (planner, executor, general).
 # Each agent appends its role-specific instructions to this base.
 BASE_INSTRUCTIONS = """\
+## Autonomy and Persistence
+
+Persist until the task is fully handled end-to-end within the current turn whenever feasible: \
+do not stop at analysis or partial fixes; carry changes through implementation, verification, \
+and a clear explanation of outcomes unless the user explicitly pauses or redirects you. \
+Assume the user wants you to make code changes or run tools to solve the problem — \
+it is bad to output your proposed solution in a message and stop; go ahead and actually \
+implement the change. If you encounter challenges or blockers, attempt to resolve them yourself.
+
+## Task execution
+
+You are a coding agent. Please keep going until the query is completely resolved, before \
+ending your turn and yielding back to the user. Only terminate your turn when you are sure \
+that the problem is solved. Autonomously resolve the query to the best of your ability, \
+using the tools available to you, before coming back to the user. Do NOT guess or make up \
+an answer.
+
+If a review, test run, plan step, or check surfaces concrete follow-up work that is clearly \
+in scope, resolve it in the same turn. "More work I identified" is NOT a blocker — it is the \
+next thing to do. The turn ends only when (a) the task is completely resolved and verified, \
+(b) you hit a real blocker that needs information only the user has, or (c) the plan / task \
+list is exhausted with every item terminal (completed / skipped / failed).
+
+End your turn by reporting what you DID, not by previewing what should happen next. Phrases \
+like "Próximo passo objetivo é…", "Next step is…", "I will now…" are forbidden as turn-end \
+content — if you write them you must execute them in the same turn.
+
 ## Output rules — CRITICAL for token efficiency
 
 Minimize output tokens. Your responses should be fewer than 4 lines unless the user \
@@ -144,7 +171,10 @@ You are a software engineer agent. Your job is to implement code changes.
 You MUST call `create_task_list` as your FIRST action before any other tool call. \
 Define 1-10 concrete subtasks for the current step. Then execute them in order, \
 calling `update_task` to mark each as "completed" or "failed" as you go. \
-When all subtasks are done, STOP. Do not add extra actions beyond the task list.
+When all subtasks finish, output a brief summary of what changed. The turn ends \
+only when the macro plan / multi-task workflow is also exhausted; if there are \
+more plan steps or skill-driven tasks pending, continue executing them in the \
+same turn — finishing a subtask list is not finishing the user's request.
 
 ## Subtask granularity — CRITICAL
 Each subtask should touch at most **3-4 files**. If the step involves many files, \
@@ -212,8 +242,10 @@ response. Read-only fan-out has no write-path hazards.
 When given a plan, execute it step by step. When given a direct task, figure out what needs to be done and do it.
 **ZERO narration between tool calls.** No "Now I have enough context...", \
 "Let me check...", "Now I understand...", "I need to...". Just call the next tool silently. \
-Only output text AFTER all subtasks are finished — a brief summary of what was done. \
-Text output is ONLY for the final result or when you hit a blocker that needs user input.
+Output text only when (a) the user's full request is resolved — including all macro plan \
+steps and skill-driven tasks — or (b) you hit a blocker that needs user input. Completing \
+a single subtask list or a single delegated task is NOT a turn boundary; continue with the \
+next pending item in the same turn.
 
 **Never retry failed shell commands with alternative syntax.** If a command fails, diagnose \
 the error — do not try `cmd /c`, absolute paths, or other wrappers hoping one works.
@@ -352,6 +384,23 @@ those tools — finish the plan and call exit_plan_mode instead.
 For simple tasks (1-2 file changes) where the user did NOT ask for a plan, \
 execute directly without entering plan mode.
 
+## Subtask lists vs the user's request — CRITICAL
+
+`create_task_list` / `update_task` track subtasks for ONE unit of work — \
+typically a single plan step, a single delegated task, or a single Task in a \
+multi-task skill workflow (e.g. /subagent-driven-development). Finishing a \
+subtask list is NOT finishing the user's request. When the `update_task` \
+tool_result says "All subtasks finished. Output a brief summary", that summary \
+is the summary of THAT unit only — not the whole turn.
+
+Before yielding, check: is there a pending plan step? A skill workflow that \
+declares more Tasks (Task 1..N)? A check that surfaced more work? If yes, \
+keep going in the same turn — call `create_task_list` again for the next \
+unit, or dispatch the next subagent, or call `update_plan_step` and move on. \
+Phrases like "Se quiser, continuo direto para a Task N", "Próximo passo \
+objetivo é…", "Next step is…" are forbidden as turn-end content. The turn \
+ends only when the user's full request is exhausted.
+
 ## Plan execution
 
 When you see a `<system-reminder>` listing PLAN ACTIVE steps, work through them in order:
@@ -384,8 +433,14 @@ Safe parallel-write pattern (only when ALL three hold):
 2. The tasks touch disjoint file sets.
 3. No task's output is another task's input inside the same batch.
 
-If any of the three fails, run tasks sequentially — one `delegate_task` per \
-response, or stay in-session and execute the step yourself. Parallel fan-out \
+If any of the three fails, run tasks sequentially — dispatch one \
+`delegate_task` per assistant response (so the next one only starts after the \
+previous returns), but keep doing this within the same turn until the multi-task \
+plan/skill workflow is exhausted. "Sequential" means "not in parallel"; it does \
+NOT mean "one task per turn" — finishing a single delegated task and then \
+yielding to the user defeats skills like /subagent-driven-development that \
+dispatch a fresh implementer per task. After each subagent returns, immediately \
+dispatch the next pending task in the same turn. Parallel fan-out \
 for read-only research (explorer) follows the Delegation strategy rules above; \
 it does not carry these write-path hazards.\
 """

{aru_code-0.59.0 → aru_code-0.61.0}/aru/agents/planner.py

@@ -42,9 +42,10 @@ async def review_plan(request: str, plan: str) -> str:
     )
     prompt = f"## User Request\n{request}\n\n## Generated Plan\n{plan}"
     try:
-        response = await reviewer.arun(prompt)
-        if response and response.content and response.content.strip():
-            return response.content.strip()
+        from aru.runner import arun_text_only
+        content = await arun_text_only(reviewer, prompt)
+        if content and content.strip():
+            return content.strip()
     except Exception:
         pass
     return plan

{aru_code-0.59.0 → aru_code-0.61.0}/aru/auth.py

@@ -13,6 +13,9 @@ Schema (``info``) — a tagged union on ``type`` so future auth methods
      "provider_type": "openai", "default_model": "...",  # custom provider
      "context_limit": 128000}
     {"type": "local", "base_url": "http://..."}   # keyless (e.g. Ollama)
+    {"type": "oauth", "refresh": "...",            # ChatGPT (Codex) — wired
+     "access": "...", "expires": 1735689600000,   # by /connect → "ChatGPT
+     "accountId": "acc-..."}                      # Pro/Plus (browser)"
 
 Consumption lives in :func:`aru.providers.apply_stored_credentials`, which
 layers these onto the in-memory provider registry at startup (and again

{aru_code-0.59.0 → aru_code-0.61.0}/aru/cli.py

@@ -179,23 +179,27 @@ async def run_oneshot(prompt: str, print_only: bool = False, skip_permissions: b
     from aru.tools.skill import _update_invoke_skill_docstring
     _update_invoke_skill_docstring(config.skills)
     session = Session()
+    # Same precedence as run_tui: aru.json default_model wins, otherwise
+    # fall back to the most-recent /connect or /model selection persisted
+    # in ~/.aru/state.json. Built-in default kicks in only when neither
+    # source provides a usable ref.
     if config.default_model:
         session.model_ref = config.default_model
+    else:
+        try:
+            from aru import state as _state
+            last = _state.get_last_model()
+        except Exception:
+            last = None
+        if last:
+            session.model_ref = last
 
     ctx.session = session
     ctx.model_id = session.model_id
     small_ref = config.model_aliases.get("small") if config else None
     if not small_ref:
-        from aru.providers import resolve_model_ref
-        provider_key, _ = resolve_model_ref(session.model_ref)
-        _small_defaults = {
-            "anthropic": "anthropic/claude-haiku-4-5",
-            "openai": "openai/gpt-4o-mini",
-            "groq": "groq/llama-3.1-8b-instant",
-            "deepseek": "deepseek/deepseek-chat",
-            "ollama": "ollama/llama3.1",
-        }
-        small_ref = _small_defaults.get(provider_key, session.model_ref)
+        from aru.providers import default_small_model_ref
+        small_ref = default_small_model_ref(session.model_ref)
     ctx.small_model_ref = small_ref
 
     extra_instructions = config.get_extra_instructions()
@@ -213,10 +217,11 @@ async def run_oneshot(prompt: str, print_only: bool = False, skip_permissions: b
             instructions=build_instructions("general", extra_instructions),
             markdown=True,
         )
-        response = await agent.arun(prompt)
-        if response and response.content:
+        from aru.runner import arun_text_only
+        content = await arun_text_only(agent, prompt)
+        if content:
             # Print raw text to stdout for piping
-            print(response.content)
+            print(content)
     else:
         # Full mode with tools
         from aru.runner import build_env_context