agent-devkit 0.2.0 → 0.3.1

package/runtime/cli/aikit/model_router.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import re
 from typing import Any
 
+from cli.aikit.embedded_mini_brain import EMBEDDED_BACKEND_ID
 from cli.aikit.llm import BACKENDS, doctor_backend, llm_preference, load_config
 from cli.aikit.mini_brain import mini_brain_contract
 from cli.aikit.ollama import ollama_status
@@ -14,6 +15,9 @@ from cli.aikit.write_policy import normalize_write_policy, write_policy_public_f
 OPERATIONAL_PATTERN = re.compile(
     r"(?i)\b(resum\w*|sumari\w*|classifi\w*|extra(?:i|ir|ia|cao|ção)\w*|normaliz\w*|compar\w*|logs?|rascunho|agrupe|agrupar)\b"
 )
+SIMPLE_CHAT_SETUP_PATTERN = re.compile(
+    r"(?i)\b(ol[aá]|oi|bom dia|boa tarde|boa noite|ajuda|help|comec(?:ar|o)|começ(?:ar|o)|setup|onboard|configur|instal|usar)\b"
+)
 HIGH_LEVEL_PATTERN = re.compile(
     r"(?i)\b(arquitet|decid|aprovar|reprovar|especifica|requisit|implemente|codigo|c[oó]digo|documento|automac|deploy|seguran)\b"
 )
@@ -48,7 +52,9 @@ def build_model_plan(
     mini_brain = mini_brain_contract(config=config, ollama_payload=ollama, ollama_backend=ollama_backend)
     local_available = mini_brain.get("available") is True
     operational = bool(OPERATIONAL_PATTERN.search(prompt))
+    simple_chat_setup = bool(SIMPLE_CHAT_SETUP_PATTERN.search(prompt))
     high_level = bool(HIGH_LEVEL_PATTERN.search(prompt))
+    local_provider = select_local_provider(ollama_payload=ollama, ollama_backend=ollama_backend, mini_brain=mini_brain)
     policy = choose_model_strategy(
         prompt,
         route=route,
@@ -56,10 +62,12 @@ def build_model_plan(
         specialist_tasks=specialist_tasks or [],
         configuration_tasks=configuration_tasks or [],
         operational=operational,
+        simple_chat_setup=simple_chat_setup,
         high_level=high_level,
         local_available=local_available,
     )
     use_local = policy["strategy"] == "mini-brain" and local_available
+    delegate_local = use_local and operational
     return {
         "kind": "model-plan",
         "status": "planned",
@@ -73,22 +81,30 @@ def build_model_plan(
         "max_llm_calls": policy["max_llm_calls"],
         "intent": route.get("intent") if route else "llm",
         "primary_coordinators": coordinator_order(preference),
-        "local_llm_role": "operational-worker",
+        "local_llm_role": "operational-worker" if operational else "bootstrap-coordinator",
         "local_llm_available": local_available,
-        "local_llm_provider": mini_brain.get("provider") or "ollama",
-        "local_llm_backend_configured": ollama_backend.get("status") == "ok",
+        "local_llm_provider": local_provider,
+        "local_llm_backend_configured": ollama_backend.get("configured") is True if local_provider == "ollama" else True,
         "local_llm_runtime": {
-            "binary_status": ollama.get("status"),
+            "provider": local_provider,
+            "binary_status": ollama.get("status") if local_provider == "ollama" else "embedded",
             "backend_status": ollama_backend.get("status"),
-            "model": mini_brain.get("ollama_model") or ollama_backend.get("model"),
-            "base_url": ollama_backend.get("base_url"),
+            "model": (mini_brain.get("ollama_model") or ollama_backend.get("model")) if local_provider == "ollama" else mini_brain.get("hf_model"),
+            "base_url": ollama_backend.get("base_url") if local_provider == "ollama" else None,
+        },
+        "optional_local_providers": {
+            "ollama": {
+                "status": ollama.get("status"),
+                "backend_status": ollama_backend.get("status"),
+                "model_count": ollama.get("model_count"),
+            }
         },
         "mini_brain": mini_brain,
         "local_llm_recommended": operational,
         "local_llm_selected": use_local,
         "delegation": {
-            "allowed": policy["strategy"] == "mini-brain",
-            "selected": use_local,
+            "allowed": policy["strategy"] == "mini-brain" and operational,
+            "selected": delegate_local,
             "reason": local_reason(
                 operational=operational,
                 local_available=local_available,
@@ -110,6 +126,7 @@ def choose_model_strategy(
     specialist_tasks: list[dict[str, Any]],
     configuration_tasks: list[dict[str, Any]],
     operational: bool,
+    simple_chat_setup: bool,
     high_level: bool,
     local_available: bool,
 ) -> dict[str, Any]:
@@ -154,7 +171,7 @@ def choose_model_strategy(
             max_llm_calls=0,
             matrix="Conhecida + estruturada + baixo risco -> automacao",
         )
-    if operational and not high_level:
+    if (operational or simple_chat_setup) and not high_level:
         return policy(
             "mini-brain" if local_available else "external-llm",
             "The prompt is operational and low-risk; local mini-brain is preferred when available.",
@@ -241,3 +258,19 @@ def local_reason(*, operational: bool, local_available: bool, high_level: bool,
     if operational and not local_available:
         return "Task is operational, but the local mini-brain is not enabled or available; coordinator/API fallback should execute."
     return "Task requires coordinator-level reasoning or review."
+
+
+def select_local_provider(
+    *,
+    ollama_payload: dict[str, Any],
+    ollama_backend: dict[str, Any],
+    mini_brain: dict[str, Any],
+) -> str:
+    ollama_ready = (
+        ollama_payload.get("status") == "ok"
+        and ollama_backend.get("status") == "ok"
+        and (ollama_backend.get("configured") is True or int(ollama_payload.get("model_count") or 0) > 0)
+    )
+    if ollama_ready:
+        return "ollama"
+    return str(mini_brain.get("provider") or EMBEDDED_BACKEND_ID)

package/runtime/cli/aikit/natural_prompt_runtime.py

@@ -3,9 +3,11 @@
 from __future__ import annotations
 
 import argparse
+import re
 from pathlib import Path
 from typing import Any
 
+from cli.aikit.agent_registry import load_agent_registry
 from cli.aikit.agent_executor import execute_plan_tasks
 from cli.aikit.capability_runtime import load_agent, run_capability
 from cli.aikit.calendar import calendar_summary, calendar_today, calendar_tomorrow
@@ -22,7 +24,7 @@ from cli.aikit.memory import napkin_context, record_usage
 from cli.aikit.model_router import build_model_plan
 from cli.aikit.module_controller import run_module_controller
 from cli.aikit.orchestrator import attach_source_to_primary_task, build_execution_plan, mark_plan_after_execution, mark_review_task
-from cli.aikit.personality import load_personality
+from cli.aikit.personality import load_personality, update_personality
 from cli.aikit.provider_wizard import missing_source_wizard
 from cli.aikit.review_gate import build_review_gate
 from cli.aikit.router import route_prompt
@@ -36,6 +38,142 @@ def effective_dry_run(args: argparse.Namespace) -> bool:
     return bool(getattr(args, "dry_run", False) or getattr(args, "global_dry_run", False))
 
 
+def parse_rename_prompt(prompt: str) -> str | None:
+    text = " ".join(prompt.strip().split())
+    patterns = [
+        r"(?i)\b(?:mude|troque|altere|renomeie)\s+(?:o\s+)?seu\s+nome\s+para\s+(.+)$",
+        r"(?i)\b(?:seu\s+nome\s+agora\s+e|seu\s+nome\s+agora\s+é)\s+(.+)$",
+        r"(?i)\b(?:teu\s+nome\s+agora\s+e|teu\s+nome\s+agora\s+é)\s+(.+)$",
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, text)
+        if not match:
+            continue
+        value = clean_requested_name(match.group(1))
+        if value:
+            return value
+    return None
+
+
+def clean_requested_name(value: str) -> str | None:
+    cleaned = " ".join(value.strip().strip("\"'`.,;:!").split())
+    if not cleaned:
+        return None
+    return cleaned[:80]
+
+
+def is_capabilities_help_prompt(prompt: str) -> bool:
+    normalized = normalize_text(prompt)
+    if normalized in {"ajuda", "help", "o que voce faz", "o que voce consegue fazer"}:
+        return True
+    capability_markers = (
+        "o que voce consegue fazer",
+        "o que voce pode fazer",
+        "como voce pode ajudar",
+        "como usar o agent",
+        "como usar voce",
+        "quais suas capacidades",
+        "quais sao suas capacidades",
+        "quais agentes voce tem",
+        "que agentes voce tem",
+    )
+    return any(marker in normalized for marker in capability_markers)
+
+
+def normalize_text(value: str) -> str:
+    replacements = str.maketrans(
+        {
+            "á": "a",
+            "à": "a",
+            "ã": "a",
+            "â": "a",
+            "é": "e",
+            "ê": "e",
+            "í": "i",
+            "ó": "o",
+            "õ": "o",
+            "ô": "o",
+            "ú": "u",
+            "ç": "c",
+        }
+    )
+    text = value.lower().translate(replacements)
+    return " ".join(re.sub(r"[^a-z0-9._:-]+", " ", text).split())
+
+
+def local_capabilities_help_response(prompt: str, *, name: str) -> dict[str, Any]:
+    registry = load_agent_registry(ROOT)
+    agents = registry.get("agents") if isinstance(registry.get("agents"), dict) else {}
+    capabilities = registry.get("capabilities") if isinstance(registry.get("capabilities"), dict) else {}
+    examples = [
+        'agent "analise o card 7914 do projeto sustentacao no azure"',
+        'agent "mude seu nome para Ianota"',
+        "agent onboard minimal",
+        "agent catalog search pr",
+        "agent mcp tools",
+        "agent memory show",
+    ]
+    response = (
+        f"Eu sou {name}. Posso operar como harness/agente local do Agent DevKit: "
+        "validar onboarding, lembrar preferencias locais, rotear pedidos para agentes especialistas, "
+        "criar wizards de configuracao quando faltar provider/source, executar capabilities deterministicas, "
+        "expor ferramentas via MCP, preparar automacoes locais e usar LLMs configuradas quando a tarefa exigir raciocinio aberto. "
+        f"Neste runtime encontrei {len(agents)} agentes e {len(capabilities)} capabilities."
+    )
+    return {
+        "kind": "agent",
+        "status": "ok",
+        "ok": True,
+        "requires_llm": False,
+        "prompt_received": True,
+        "prompt_length": len(prompt),
+        "mode": "local-capabilities-help",
+        "identity": {"name": name, "source": "local"},
+        "response": response,
+        "catalog": {
+            "agents": len(agents),
+            "capabilities": len(capabilities),
+        },
+        "next_steps": examples,
+    }
+
+
+def embedded_mini_brain_install_response(prompt: str, *, name: str, model_plan: dict[str, Any]) -> dict[str, Any]:
+    embedded = (
+        ((model_plan.get("mini_brain") or {}).get("embedded") or {})
+        if isinstance(model_plan.get("mini_brain"), dict)
+        else {}
+    )
+    status = embedded.get("status") or "not-installed"
+    response = (
+        f"Eu sou {name}. Consigo orientar o setup inicial localmente, mas o mini-cerebro local ainda nao esta instalado "
+        f"(status: {status}). Para habilitar conversa local sem Claude, Codex, Ollama ou API externa, execute "
+        "`agent setup mini-brain --yes`. Sem esse download, posso continuar com onboarding, memoria, wizards e "
+        "capabilities deterministicas."
+    )
+    return {
+        "kind": "agent",
+        "status": "needs-setup",
+        "ok": False,
+        "requires_llm": False,
+        "prompt_received": True,
+        "prompt_length": len(prompt),
+        "mode": "embedded-mini-brain-not-installed",
+        "identity": {"name": name, "source": "local"},
+        "llm_backend": "embedded-mini-brain",
+        "mini_brain": model_plan.get("mini_brain"),
+        "response": response,
+        "message": "Embedded mini-brain is not installed yet.",
+        "next_steps": [
+            "agent setup mini-brain --dry-run",
+            "agent setup mini-brain --yes",
+            "agent llm configure claude-code --set-default",
+            "agent llm configure codex-cli --set-default",
+        ],
+        "exit_code": 2,
+    }
+
+
 def agent_requires_llm(args: argparse.Namespace) -> dict[str, Any]:
     prompt = " ".join(args.prompt).strip()
     return run_agent_prompt_request(
@@ -70,6 +208,21 @@ def run_agent_prompt_request(request: AgentPromptRequest) -> dict[str, Any]:
         raise DevKitError(str(exc)) from exc
     personality = load_personality()
     name = public_name(personality=personality, invoked_as=request.prog_name)
+    rename = parse_rename_prompt(prompt)
+    if rename:
+        updated = update_personality(agent_name=rename)
+        result = {
+            "kind": "agent",
+            "status": "ok",
+            "ok": True,
+            "requires_llm": False,
+            "prompt_received": True,
+            "prompt_length": len(prompt),
+            "identity": {"name": updated.get("agent_name"), "source": "local"},
+            "action": "rename",
+            "response": f"Pronto. Meu nome local agora e {updated.get('agent_name')}.",
+        }
+        return finalize_agent_session(result, session, prompt, backend=request.llm)
     if is_identity_question(prompt):
         result = {
             "kind": "agent",
@@ -82,6 +235,13 @@ def run_agent_prompt_request(request: AgentPromptRequest) -> dict[str, Any]:
             "response": local_identity_response(prompt, name=name),
         }
         return finalize_agent_session(result, session, prompt, backend=request.llm)
+    if is_capabilities_help_prompt(prompt):
+        return finalize_agent_session(
+            local_capabilities_help_response(prompt, name=name),
+            session,
+            prompt,
+            backend=request.llm,
+        )
     natural_result = dispatch_natural_operational_prompt(prompt)
     if natural_result:
         return finalize_agent_session(natural_result, session, prompt, backend=request.llm)
@@ -113,9 +273,15 @@ def run_agent_prompt_request(request: AgentPromptRequest) -> dict[str, Any]:
     )
     local_llm_execution = maybe_delegate_local_llm(prompt, model_plan)
     coordinator_prompt = enrich_prompt_with_local_result(contextual_prompt, local_llm_execution)
+    requested_backend = request.llm
+    if should_prompt_for_embedded_install(model_plan, requested_backend=request.llm):
+        result = embedded_mini_brain_install_response(prompt, name=name, model_plan=model_plan)
+        return finalize_agent_session(result, session, prompt, backend="embedded-mini-brain")
+    if should_use_embedded_coordinator(model_plan, requested_backend=request.llm):
+        requested_backend = "embedded-mini-brain"
     result = invoke_agent_prompt(
         coordinator_prompt,
-        request.llm,
+        requested_backend,
         public_name=name,
         allow_fallback=not request.no_llm_fallback,
     )
@@ -154,6 +320,32 @@ def run_agent_prompt_request(request: AgentPromptRequest) -> dict[str, Any]:
     return finalize_agent_session(result, session, prompt, backend=result.get("llm_backend") or request.llm)
 
 
+def should_use_embedded_coordinator(model_plan: dict[str, Any], *, requested_backend: str | None) -> bool:
+    if requested_backend:
+        return False
+    return (
+        model_plan.get("strategy") == "mini-brain"
+        and model_plan.get("local_llm_provider") == "embedded-mini-brain"
+        and model_plan.get("risk") == "low"
+    )
+
+
+def should_prompt_for_embedded_install(model_plan: dict[str, Any], *, requested_backend: str | None) -> bool:
+    if requested_backend:
+        return False
+    embedded = (
+        ((model_plan.get("mini_brain") or {}).get("embedded") or {})
+        if isinstance(model_plan.get("mini_brain"), dict)
+        else {}
+    )
+    return (
+        model_plan.get("strategy") in {"mini-brain", "external-llm"}
+        and model_plan.get("local_llm_provider") == "embedded-mini-brain"
+        and embedded.get("available") is not True
+        and model_plan.get("fallback") == "configure-local-mini-brain-or-use-external-llm"
+    )
+
+
 def mark_review_task_needs_review(execution_plan: dict[str, Any], review_result: dict[str, Any]) -> dict[str, Any]:
     task = dict(execution_plan.get("review_task") or {})
     if task:

package/runtime/cli/aikit/ollama.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import os
 import platform
 import shutil
 import subprocess
@@ -10,17 +11,31 @@ import urllib.error
 import urllib.request
 from typing import Any
 
+from cli.aikit.app_home import config_path
+
 
 OLLAMA_TIMEOUT_SECONDS = 120
 DEFAULT_BASE_URL = "http://localhost:11434"
+DEFAULT_RECOMMENDED_MODELS = [
+    {"name": "qwen3:0.6b", "family": "mini-brain", "recommended_for": "setup help, short summaries and lightweight intent classification"},
+    {"name": "qwen2.5-coder", "family": "coding", "recommended_for": "operational code reading and generation"},
+    {"name": "deepseek-coder", "family": "coding", "recommended_for": "code analysis and mechanical refactors"},
+    {"name": "deepseek-r1", "family": "reasoning", "recommended_for": "local reasoning drafts with mandatory review"},
+    {"name": "llama3.2", "family": "general", "recommended_for": "general local summaries and classification"},
+    {"name": "mistral", "family": "general", "recommended_for": "lightweight operational summaries"},
+    {"name": "gemma", "family": "classification", "recommended_for": "small extraction and classification tasks"},
+]
 
 
 def ollama_status(*, base_url: str = DEFAULT_BASE_URL) -> dict[str, Any]:
+    base_url = os.environ.get("OLLAMA_BASE_URL") or base_url
     binary = shutil.which("ollama")
     version = command_output(["ollama", "--version"]) if binary else None
     daemon = daemon_status(base_url) if binary else {"status": "unknown", "message": "Ollama binary is not installed."}
     models = list_local_models(binary_available=bool(binary))
-    status = "ok" if binary else "missing"
+    status = "missing"
+    if binary:
+        status = "ok" if daemon.get("status") == "ok" else "partial"
     return {
         "kind": "ollama-status",
         "status": status,
@@ -52,10 +67,12 @@ def ollama_pull(model: str | None, *, yes: bool = False, dry_run: bool = False)
     binary = shutil.which("ollama")
     command = ["ollama", "pull", model]
     if dry_run or not yes:
+        needs_confirmation = not dry_run and not yes
         return {
             "kind": "ollama-pull",
             "status": "planned" if dry_run else "needs-confirmation",
             "ok": bool(dry_run),
+            "exit_code": 2 if needs_confirmation else 0,
             "model": model,
             "binary": binary,
             "command": command,
@@ -91,10 +108,12 @@ def ollama_pull(model: str | None, *, yes: bool = False, dry_run: bool = False)
 def ollama_update(*, yes: bool = False, dry_run: bool = False) -> dict[str, Any]:
     command = update_command()
     if dry_run or not yes:
+        needs_confirmation = not dry_run and not yes
         return {
             "kind": "ollama-update",
             "status": "planned" if dry_run else "needs-confirmation",
             "ok": bool(dry_run),
+            "exit_code": 2 if needs_confirmation else 0,
             "command": command,
             "dry_run": dry_run,
             "yes": yes,
@@ -142,26 +161,56 @@ def parse_ollama_list(output: str) -> list[dict[str, Any]]:
 
 
 def recommended_models(*, installed: set[str]) -> list[dict[str, Any]]:
-    catalog = [
-        ("qwen3:0.6b", "mini-brain", "setup help, short summaries and lightweight intent classification"),
-        ("qwen2.5-coder", "coding", "operational code reading and generation"),
-        ("deepseek-coder", "coding", "code analysis and mechanical refactors"),
-        ("deepseek-r1", "reasoning", "local reasoning drafts with mandatory review"),
-        ("llama3.2", "general", "general local summaries and classification"),
-        ("mistral", "general", "lightweight operational summaries"),
-        ("gemma", "classification", "small extraction and classification tasks"),
-    ]
+    catalog = model_catalog()
     return [
         {
-            "name": name,
-            "family": family,
-            "recommended_for": recommended_for,
-            "installed": any(item == name or item.startswith(f"{name}:") for item in installed),
+            "name": item["name"],
+            "family": item["family"],
+            "recommended_for": item["recommended_for"],
+            "installed": any(model == item["name"] or model.startswith(f"{item['name']}:") for model in installed),
+            "source": item["source"],
         }
-        for name, family, recommended_for in catalog
+        for item in catalog
     ]
 
 
+def model_catalog() -> list[dict[str, str]]:
+    items = {item["name"]: {**item, "source": "default"} for item in DEFAULT_RECOMMENDED_MODELS}
+    for item in configured_model_catalog():
+        name = str(item.get("name") or "").strip()
+        if not name:
+            continue
+        items[name] = {
+            "name": name,
+            "family": str(item.get("family") or "custom").strip() or "custom",
+            "recommended_for": str(item.get("recommended_for") or item.get("purpose") or "configured local model").strip(),
+            "source": "config",
+        }
+    return list(items.values())
+
+
+def configured_model_catalog() -> list[dict[str, Any]]:
+    path = config_path()
+    if not path.exists():
+        return []
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return []
+    if not isinstance(payload, dict):
+        return []
+    local_llm = payload.get("local_llm") if isinstance(payload.get("local_llm"), dict) else {}
+    mini_brain = payload.get("mini_brain") if isinstance(payload.get("mini_brain"), dict) else {}
+    for value in (
+        local_llm.get("recommended_models"),
+        local_llm.get("models"),
+        mini_brain.get("recommended_models"),
+    ):
+        if isinstance(value, list):
+            return [item for item in value if isinstance(item, dict)]
+    return []
+
+
 def daemon_status(base_url: str) -> dict[str, Any]:
     url = base_url.rstrip("/") + "/api/tags"
     try: