@autonsh/cli 0.17.2 → 0.19.0

package/templates/coding/task.yaml

@@ -0,0 +1,36 @@
+name: coding
+description: Agente de código — refatorar, testar, migrar, corrigir
+goal: ""
+entry: agent.ts
+models:
+  default: ollama:qwen2.5-coder:14b-instruct-q4_K_M
+env:
+  - GITHUB_TOKEN
+mode: build
+skills:
+  - typescript
+  - refactoring
+  - testing
+verify:
+  typecheck: "tsc --noEmit"
+  test: "vitest run"
+  lint: "eslint ."
+genesis: |
+  Você é um engenheiro de software sênior especializado em TypeScript.
+  
+  Princípios:
+  1. Entenda o código ANTES de mudar — leia, trace dependências
+  2. Mudanças pequenas, atômicas, testáveis
+  3. Tipos estritos: `strict: true`, `noImplicitAny`, `exactOptionalPropertyTypes`
+  4. Testes obrigatórios: unit + integration para lógica de negócio
+  5. Nunca quebre API pública sem migração + depreciação
+  6. Performance: evite alocações desnecessárias, use `const`, `readonly`
+  7. Documentação: JSDoc em exports públicos, comentários "por que" não "o que"
+  
+  Fluxo por task:
+  - PLAN: analise impacto, liste arquivos, defina testes
+  - IMPLEMENT: edite um arquivo por vez, rode typecheck a cada passo
+  - VERIFY: tsc --noEmit → vitest run → eslint
+  - CHECKPOINT: salve evidência (diff, testes, coverage)
+  
+  Responda em PT-BR. Seja conciso.

package/templates/cron-digester/task.yaml

@@ -2,6 +2,4 @@ name: cron-digester
 description: Resumo periódico (cron)
 goal: "resume os eventos do período"
 entry: agent.ts
-models:
-  default: mock:local
 cron: "*/3 * * * * *"

package/templates/harness/agent.md

@@ -0,0 +1,43 @@
+# Harness Agent — Loop Local
+
+Você é um agente autônomo que roda **local** (sem Control Plane).
+Seu ciclo: **PLAN → ACT → VERIFY → CHECKPOINT** até `done: true`.
+
+## Princípios
+- **Pequenos passos**: uma ação por turno, verificável
+- **Checkpoint sempre**: estado salvo em `.auton/checkpoints/` para resume
+- **Ferramentas primeiro**: use `ctx.tools` para ler/escrever/correr código
+- **Verificação honesta**: se não passou, explica o que falta
+
+## Ferramentas disponíveis
+- `ctx.tools.list(dir)` — lista arquivos
+- `ctx.tools.read(file)` — lê arquivo
+- `ctx.tools.write(file, content)` — escreve arquivo
+- `ctx.tools.exec(cmd)` — roda comando shell (tsc, vitest, etc.)
+- `ctx.tools.patch(file, oldStr, newStr)` — edita cirúrgico
+- `ctx.storage.get/set(key, value)` — KV persistente
+- `ctx.work.add(type, title, payload)` — work context (findings/artifacts)
+
+## Formato de resposta (JSON)
+```json
+{
+  "plan": "Uma frase: o que vou fazer agora",
+  "action": "comando ou código para ctx.tools.exec / ctx.tools.write",
+  "done": false
+}
+```
+Se `done: true`, o loop para e emite `TASK:DONE`.
+
+## Modo harness
+- `loop: true` — continua até `done: true` ou `maxTurns`
+- `maxTurns: 10` — segurança contra loops infinitos
+- `checkpointDir: ".auton/checkpoints"` — resume automático no próximo `auton run`
+
+## Exemplo
+```json
+{
+  "plan": "Ler src/auth.ts para entender a estrutura",
+  "action": "read src/auth.ts",
+  "done": false
+}
+```

package/templates/harness/harness.ts

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+/**
+ * Harness local — loop agêntico sem Control Plane.
+ * Roda: plan → act → verify → checkpoint → done.
+ * Checkpoints em .auton/checkpoints/ (resume no próximo run).
+ */
+import { readFile, writeFile, mkdir, readdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { createLlm, createStorage, createTools } from "@autonsh/runtime";
+
+const GOAL = process.env.AUTON_GOAL ?? process.argv.slice(2).join(" ") ?? "";
+const CHECKPOINT_DIR = ".auton/checkpoints";
+const MAX_TURNS = Number(process.env.AUTON_MAX_TURNS ?? 10);
+
+async function main(): Promise<void> {
+  if (!GOAL) {
+    console.error("Erro: goal não fornecido. Use AUTON_GOAL ou passe como argumento.");
+    process.exit(1);
+  }
+
+  // Carrega agent.md como system prompt base
+  const agentMd = await readFile("agent.md", "utf8").catch(() => "");
+  const systemPrompt = `Você é um agente autônomo em modo harness (local).
+${agentMd}
+
+Objetivo: ${GOAL}
+
+Loop: planeje → execute → verifique → checkpoint.
+Responda em JSON: { "plan": "...", "action": "...", "done": false }`;
+
+  const llm = createLlm({ model: process.env.AUTON_MODEL });
+  const storage = createStorage({ dir: ".auton/storage" });
+  const tools = createTools({ cwd: process.cwd() });
+
+  // Resume checkpoint se existir
+  let turn = 0;
+  let context = "";
+  const checkpoints = await listCheckpoints();
+  if (checkpoints.length > 0) {
+    const latest = checkpoints[checkpoints.length - 1];
+    const data = JSON.parse(await readFile(latest, "utf8"));
+    turn = data.turn ?? 0;
+    context = data.context ?? "";
+    console.log(`[harness] Resumindo checkpoint turno ${turn}`);
+  }
+
+  console.log(`[harness] Iniciando: ${GOAL}`);
+
+  while (turn < MAX_TURNS) {
+    turn++;
+    console.log(`[harness] Turno ${turn}/${MAX_TURNS}`);
+
+    // 1. PLAN
+    const planResp = await llm.chat({
+      system: systemPrompt + `\n\nContexto anterior:\n${context}`,
+      prompt: "Planeje o próximo passo. Responda JSON: { plan, action, done }",
+    });
+
+    let parsed: { plan: string; action: string; done: boolean };
+    try {
+      parsed = JSON.parse(planResp.trim());
+    } catch {
+      parsed = { plan: planResp, action: "", done: false };
+    }
+
+    console.log(`[harness] Plan: ${parsed.plan}`);
+    if (parsed.done) {
+      console.log("[harness] Task concluída pelo agente");
+      break;
+    }
+
+    // 2. ACT (executa action via tools se houver, senão LLM)
+    let result: string;
+    if (parsed.action) {
+      try {
+        result = await tools.exec(parsed.action);
+        console.log(`[harness] Action executada`);
+      } catch (e) {
+        result = `Erro ao executar action: ${(e as Error).message}`;
+        console.log(`[harness] ${result}`);
+      }
+    } else {
+      const actResp = await llm.chat({
+        system: systemPrompt + `\n\nContexto:\n${context}`,
+        prompt: `Execute: ${parsed.plan}`,
+      });
+      result = actResp;
+      console.log(`[harness] LLM executou diretamente`);
+    }
+
+    // 3. VERIFY
+    const verifyResp = await llm.chat({
+      system: "Verifique se o resultado atende o objetivo. Responda JSON: { pass: boolean, feedback: string }",
+      prompt: `Objetivo: ${GOAL}\nResultado: ${result}`,
+    });
+
+    let verified: { pass: boolean; feedback: string };
+    try {
+      verified = JSON.parse(verifyResp.trim());
+    } catch {
+      verified = { pass: verifyResp.toLowerCase().includes("sim"), feedback: verifyResp };
+    }
+
+    console.log(`[harness] Verify: ${verified.pass ? "PASS" : "FAIL"} - ${verified.feedback}`);
+
+    // 4. CHECKPOINT
+    context += `\nTurno ${turn}:\nPlan: ${parsed.plan}\nResult: ${result}\nVerify: ${verified.feedback}\n`;
+    await saveCheckpoint(turn, context, result, verified.pass);
+
+    if (verified.pass) {
+      console.log("[harness] Verificação passou - task concluída");
+      break;
+    }
+
+    // Continua loop com feedback
+    context += `Feedback: ${verified.feedback}\n`;
+  }
+
+  // Salva resultado final
+  await storage.set("harness:result", { goal: GOAL, turns: turn, context, finalOutput: context });
+  console.log("[TASK:DONE]", JSON.stringify({ result: context, evidence: { turns: turn } }));
+}
+
+async function listCheckpoints(): Promise<string[]> {
+  try {
+    const files = await readdir(CHECKPOINT_DIR);
+    return files
+      .filter((f) => f.endsWith(".json"))
+      .map((f) => join(CHECKPOINT_DIR, f))
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+async function saveCheckpoint(turn: number, context: string, result: string, pass: boolean): Promise<void> {
+  await mkdir(CHECKPOINT_DIR, { recursive: true });
+  const file = join(CHECKPOINT_DIR, `turn-${turn}-${Date.now()}.json`);
+  await writeFile(file, JSON.stringify({ turn, context, result, pass, timestamp: Date.now() }, null, 2));
+}
+
+main().catch((e) => {
+  console.error("[harness] Erro fatal:", e);
+  process.exit(1);
+});

package/templates/harness/task.yaml

@@ -0,0 +1,4 @@
+name: harness
+description: Modo harness — loop agêntico local (sem CP), checkpoints persistentes
+goal: ""
+entry: harness.ts

package/templates/multi-agent/agent.ts

@@ -1,7 +1,7 @@
 import { agent, TASK_DONE_EVENT } from "@autonsh/runtime";
 
-// Template multi-agent — delega via HTTP nativo ao CP (sem spawn CLI)
-// Modo: build/deploy — usa fetch nativo (policy fetch: true)
+// Template multi-agent — delega via ctx.tools.fetch ao CP (respeita policy)
+// Modo: build/deploy — fetch permitido em ambos (policy fetch: true)
 export default agent(async (ctx) => {
   const goal = ((ctx.input as { prompt?: string } | undefined)?.prompt ?? "").trim()
     || "orquestra agentes";
@@ -11,20 +11,19 @@ export default agent(async (ctx) => {
   if (!api) throw new Error("AUTON_API não definido — delegação requer CP");
   await ctx.logger.info("multi-agent iniciado", { goal, mode });
 
-  // Delega via HTTP nativo ao CP: POST /v1/agents/{name}/invoke
+  // Delega via ctx.tools.fetch ao CP: POST /v1/agents/{name}/invoke
   // Retorna {result, turn, lines} — result é o TASK:DONE estruturado
   async function delegate(toAgent: string, prompt: string): Promise<any> {
     try {
-      const res = await fetch(`${api}/v1/agents/${toAgent}/invoke`, {
+      const res = await ctx.tools.fetch(`${api}/v1/agents/${toAgent}/invoke`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ prompt }),
       });
-      if (!res.ok) {
-        const text = await res.text();
-        return { erro: `HTTP ${res.status}: ${text}` };
+      if (res.status >= 400) {
+        return { erro: `HTTP ${res.status}: ${res.text}` };
       }
-      const data = await res.json();
+      const data = JSON.parse(res.text);
       return data.result ?? { turn: data.turn, lines: data.lines };
     } catch (err) {
       return { erro: (err as Error).message };

package/templates/multi-agent/task.yaml

@@ -1,9 +1,7 @@
 name: multi-agent
-description: Orquestração multi-agent — delega para worker via CLI/HTTP
+description: Orquestração multi-agent — delega para worker via HTTP (ctx.tools.fetch)
 goal: "orquestra agentes"
 entry: agent.ts
-models:
-  default: mock:local
 env:
   - OPENAI_API_KEY
 http: true

package/templates/research/task.yaml

@@ -0,0 +1,4 @@
+name: research
+description: Agente de pesquisa — busca, sumariza, cita fontes, gera relatórios
+goal: ""
+entry: agent.ts

package/templates/support/task.yaml

@@ -2,8 +2,6 @@ name: support
 description: Suporte — responde aos pedidos do trigger com o LLM
 goal: "responde o pedido do usuário"
 entry: agent.ts
-models:
-  default: mock:local
 env:
   - OPENAI_API_KEY
 http: true

package/templates/webhook-echo/task.yaml

@@ -2,6 +2,4 @@ name: webhook-echo
 description: Eco de webhooks
 goal: "ecoa o payload do webhook"
 entry: agent.ts
-models:
-  default: mock:local
 http: true

package/templates/with-approval/task.yaml

@@ -2,8 +2,6 @@ name: with-approval
 description: Demonstra o gate humano — gera algo, pede aprovação, executa só depois
 goal: "gera o relatório e pede aprovação antes de publicar"
 entry: agent.ts
-models:
-  default: mock:local
 env:
   - OPENAI_API_KEY
 approval: true