@jaimevalasek/aioson 1.4.0 → 1.6.0

package/src/commands/squad-score.js

@@ -0,0 +1,250 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+async function readJsonIfExists(filePath) {
+  try {
+    const raw = await fs.readFile(filePath, 'utf8');
+    return JSON.parse(raw);
+  } catch { return null; }
+}
+
+function scoreCompletude(manifest) {
+  let score = 0;
+  const details = {};
+  const executors = Array.isArray(manifest.executors) ? manifest.executors : [];
+  const workflows = Array.isArray(manifest.workflows) ? manifest.workflows : [];
+  const checklists = Array.isArray(manifest.checklists) ? manifest.checklists : [];
+
+  // Executors typed (5pts)
+  const allTyped = executors.length > 0 && executors.every(e => e.type);
+  if (allTyped) { score += 5; details.executorsTyped = true; }
+
+  // Workflow defined (5pts)
+  const hasWorkflow = workflows.some(w => Array.isArray(w.phases) && w.phases.length >= 2);
+  if (hasWorkflow) { score += 5; details.workflowDefined = true; }
+
+  // Checklists present (3pts)
+  if (checklists.length > 0) { score += 3; details.checklistsPresent = true; }
+
+  // Tasks decomposed (5pts)
+  const hasTask = executors.some(e => Array.isArray(e.tasks) && e.tasks.length > 0);
+  if (hasTask) { score += 5; details.tasksDecomposed = true; }
+
+  // Workers present (2pts)
+  const hasWorker = executors.some(e => e.type === 'worker' || e.usesLLM === false);
+  if (hasWorker) { score += 2; details.workersPresent = true; }
+
+  // Investigation report (3pts)
+  if (manifest._investigationPath) { score += 3; details.investigationReport = true; }
+
+  // Model tiering (2pts)
+  const allTiered = executors.length > 0 && executors.every(e => e.modelTier);
+  if (allTiered) { score += 2; details.modelTiering = true; }
+
+  return { score, max: 25, details };
+}
+
+function scoreProfundidade(manifest) {
+  let score = 0;
+  const details = {};
+  const executors = Array.isArray(manifest.executors) ? manifest.executors : [];
+
+  // Executor focus areas avg >= 3 (5pts)
+  const focusCounts = executors.map(e => (Array.isArray(e.focus) ? e.focus : []).length);
+  const avgFocus = focusCounts.length > 0 ? focusCounts.reduce((a, b) => a + b, 0) / focusCounts.length : 0;
+  if (avgFocus >= 3) { score += 5; details.focusAreas = true; }
+
+  // Task quality criteria avg >= 3 (5pts)
+  const allTasks = executors.flatMap(e => Array.isArray(e.tasks) ? e.tasks : []);
+  if (allTasks.length > 0) { score += 5; details.taskCriteria = true; }
+
+  // Veto conditions (5pts)
+  const workflows = Array.isArray(manifest.workflows) ? manifest.workflows : [];
+  const hasVeto = workflows.some(w =>
+    (Array.isArray(w.phases) ? w.phases : []).some(p =>
+      Array.isArray(p.vetoConditions) && p.vetoConditions.length > 0
+    )
+  );
+  if (hasVeto) { score += 5; details.vetoConditions = true; }
+
+  // Content blueprints with 3+ sections (5pts)
+  const blueprints = Array.isArray(manifest.contentBlueprints) ? manifest.contentBlueprints : [];
+  const hasBp = blueprints.some(bp => Array.isArray(bp.sections) && bp.sections.length >= 3);
+  if (hasBp) { score += 5; details.contentBlueprints = true; }
+
+  // Skills declared >= 2 (5pts)
+  const skills = Array.isArray(manifest.skills) ? manifest.skills : [];
+  if (skills.length >= 2) { score += 5; details.skillsDeclared = true; }
+
+  return { score, max: 25, details };
+}
+
+function scoreQualidadeEstrutural(manifest) {
+  let score = 0;
+  const details = {};
+  const executors = Array.isArray(manifest.executors) ? manifest.executors : [];
+  const workflows = Array.isArray(manifest.workflows) ? manifest.workflows : [];
+
+  // Review loops (5pts)
+  const hasReview = workflows.some(w =>
+    (Array.isArray(w.phases) ? w.phases : []).some(p => p.review)
+  );
+  if (hasReview) { score += 5; details.reviewLoops = true; }
+
+  // Human gates (5pts)
+  const hasGate = workflows.some(w =>
+    (Array.isArray(w.phases) ? w.phases : []).some(p => p.humanGate)
+  );
+  if (hasGate) { score += 5; details.humanGates = true; }
+
+  // Cross-squad awareness (3pts) — orchestrator mentions cross-squad
+  // Simplified: check if ports are defined
+  if (manifest.ports && (Array.isArray(manifest.ports.inputs) || Array.isArray(manifest.ports.outputs))) {
+    score += 3; details.crossSquad = true;
+  }
+
+  // Output strategy configured (4pts)
+  const os = manifest.outputStrategy;
+  if (os && os.mode && os.mode !== 'hybrid') { score += 4; details.outputStrategy = true; }
+  else if (os && os.mode === 'hybrid') { score += 4; details.outputStrategy = true; }
+
+  // Genome bindings (3pts)
+  const genomes = manifest.genomes;
+  const hasGenome = genomes && (
+    (Array.isArray(genomes) && genomes.length > 0) ||
+    (typeof genomes === 'object' && !Array.isArray(genomes))
+  );
+  if (hasGenome) { score += 3; details.genomeBindings = true; }
+
+  // Format references (5pts)
+  const hasFormat = executors.some(e => Array.isArray(e.formats) && e.formats.length > 0);
+  if (hasFormat) { score += 5; details.formatReferences = true; }
+
+  return { score, max: 25, details };
+}
+
+function scorePotencial(manifest) {
+  let score = 0;
+  const details = {};
+  const workflows = Array.isArray(manifest.workflows) ? manifest.workflows : [];
+
+  // Anti-pattern guards via veto conditions (5pts)
+  const hasVeto = workflows.some(w =>
+    (Array.isArray(w.phases) ? w.phases : []).some(p =>
+      Array.isArray(p.vetoConditions) && p.vetoConditions.length > 0
+    )
+  );
+  if (hasVeto) { score += 5; details.antiPatternGuards = true; }
+
+  // Domain vocabulary — investigation (5pts)
+  if (manifest._investigationPath) { score += 5; details.domainVocabulary = true; }
+
+  // Structural patterns — content blueprints (5pts)
+  const blueprints = Array.isArray(manifest.contentBlueprints) ? manifest.contentBlueprints : [];
+  if (blueprints.length > 0) { score += 5; details.structuralPatterns = true; }
+
+  // Executor coherence + Output realism (10pts) → LLM-only, mark as partial
+  details.llmAssessmentPending = true;
+
+  return { score, max: 25, details };
+}
+
+function gradeFromScore(total) {
+  if (total >= 90) return 'S (Exceptional)';
+  if (total >= 80) return 'A (Excellent)';
+  if (total >= 70) return 'B (Good)';
+  if (total >= 50) return 'C (Adequate)';
+  return 'D (Needs work)';
+}
+
+function suggestQuickWins(d1, d2, d3, d4) {
+  const wins = [];
+  if (!d3.details.reviewLoops) wins.push({ action: 'Add review loop to a workflow phase', pts: 5 });
+  if (!d1.details.tasksDecomposed) wins.push({ action: 'Decompose at least 1 executor into tasks', pts: 5 });
+  if (!d3.details.formatReferences) wins.push({ action: 'Add a format reference to an executor', pts: 5 });
+  if (!d2.details.vetoConditions) wins.push({ action: 'Add veto conditions to a workflow phase', pts: 5 });
+  if (!d1.details.modelTiering) wins.push({ action: 'Assign modelTier to all executors', pts: 2 });
+  if (!d1.details.workersPresent) wins.push({ action: 'Add a worker executor (no LLM)', pts: 2 });
+  return wins.slice(0, 3);
+}
+
+async function runSquadScore({ args = [], options = {}, logger = console, translator } = {}) {
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+  const slug = options.squad || args[1];
+
+  if (!slug) {
+    logger.error('Usage: aioson squad:score [path] --squad=<slug>');
+    return { valid: false, error: 'No slug provided' };
+  }
+
+  const manifestPath = path.join(projectDir, '.aioson', 'squads', slug, 'squad.manifest.json');
+  const manifest = await readJsonIfExists(manifestPath);
+
+  if (!manifest) {
+    logger.error(`Squad "${slug}" not found or invalid manifest`);
+    return { valid: false, error: 'Manifest not found' };
+  }
+
+  // Check for investigation
+  const squadSearchDir = path.join(projectDir, 'squad-searches', slug);
+  try {
+    await fs.access(squadSearchDir);
+    manifest._investigationPath = squadSearchDir;
+  } catch { /* no investigation */ }
+
+  const d1 = scoreCompletude(manifest);
+  const d2 = scoreProfundidade(manifest);
+  const d3 = scoreQualidadeEstrutural(manifest);
+  const d4 = scorePotencial(manifest);
+
+  const total = d1.score + d2.score + d3.score + d4.score;
+  const maxTotal = d1.max + d2.max + d3.max + d4.max;
+  const grade = gradeFromScore(total);
+  const wins = suggestQuickWins(d1, d2, d3, d4);
+
+  logger.log('');
+  logger.log(`  Squad: ${slug}`);
+  logger.log('');
+  logger.log(`  Completude:              ${String(d1.score).padStart(2)}/${d1.max}`);
+  logger.log(`  Profundidade:            ${String(d2.score).padStart(2)}/${d2.max}`);
+  logger.log(`  Qualidade Estrutural:    ${String(d3.score).padStart(2)}/${d3.max}`);
+  logger.log(`  Potencial de Resultado:  ${String(d4.score).padStart(2)}/${d4.max}*`);
+  logger.log(`  ${'─'.repeat(40)}`);
+  logger.log(`  TOTAL:                   ${String(total).padStart(2)}/${maxTotal}`);
+  logger.log(`  Grade: ${grade}`);
+  logger.log('');
+  logger.log('  * Dimensão 4 parcial (sem LLM assessment)');
+
+  if (wins.length > 0) {
+    logger.log('');
+    logger.log('  Quick wins:');
+    wins.forEach((w, i) => logger.log(`    ${i + 1}. ${w.action} → +${w.pts} pts`));
+  }
+
+  logger.log('');
+
+  // Store in runtime if available
+  try {
+    const { openRuntimeDb } = require('../runtime-store');
+    const { db } = openRuntimeDb(projectDir);
+    const now = new Date().toISOString();
+    const stmt = db.prepare('INSERT OR REPLACE INTO squad_scores (squad_slug, dimension, score, max_score, details_json, scored_at) VALUES (?, ?, ?, ?, ?, ?)');
+    stmt.run(slug, 'completude', d1.score, d1.max, JSON.stringify(d1.details), now);
+    stmt.run(slug, 'profundidade', d2.score, d2.max, JSON.stringify(d2.details), now);
+    stmt.run(slug, 'qualidade', d3.score, d3.max, JSON.stringify(d3.details), now);
+    stmt.run(slug, 'potencial', d4.score, d4.max, JSON.stringify(d4.details), now);
+  } catch { /* runtime not available */ }
+
+  return {
+    slug,
+    total,
+    max: maxTotal,
+    grade,
+    dimensions: { completude: d1, profundidade: d2, qualidade: d3, potencial: d4 },
+    quickWins: wins
+  };
+}
+
+module.exports = { runSquadScore, scoreCompletude, scoreProfundidade, scoreQualidadeEstrutural, scorePotencial, gradeFromScore };

package/src/commands/squad-status.js

@@ -4,6 +4,34 @@ const fs = require('node:fs/promises');
 const path = require('node:path');
 const { flattenGenomeBindings, mergeGenomeBindings } = require('../genomes/bindings');
 
+const TIER_COSTS = {
+  powerful: { inputPer1k: 0.015, outputPer1k: 0.075 },
+  balanced: { inputPer1k: 0.003, outputPer1k: 0.015 },
+  fast:     { inputPer1k: 0.0008, outputPer1k: 0.004 },
+  none:     { inputPer1k: 0, outputPer1k: 0 }
+};
+
+function estimateRunCost(executors) {
+  if (!Array.isArray(executors) || executors.length === 0) return null;
+  let total = 0;
+  for (const ex of executors) {
+    const tier = ex.modelTier || (ex.usesLLM === false ? 'none' : 'balanced');
+    const cost = TIER_COSTS[tier] || TIER_COSTS.balanced;
+    total += (cost.inputPer1k * 2) + (cost.outputPer1k * 1);
+  }
+  return Math.round(total * 1000) / 1000;
+}
+
+function buildTierSummary(executors) {
+  if (!Array.isArray(executors) || executors.length === 0) return null;
+  const counts = {};
+  for (const ex of executors) {
+    const tier = ex.modelTier || (ex.usesLLM === false ? 'none' : 'balanced');
+    counts[tier] = (counts[tier] || 0) + 1;
+  }
+  return Object.entries(counts).map(([t, n]) => `${t}×${n}`).join(' / ');
+}
+
 const SQUADS_DIR = '.aioson/squads';
 const AGENTS_ROOT = 'agents';
 const OUTPUT_ROOT = 'output';
@@ -278,7 +306,9 @@ async function buildSquadRecordFromPackageDir(targetDir, slug) {
       : outputExists && (await pathExists(path.join(targetDir, outputDir, 'session.html')))
         ? normalizeRel(path.join(outputDir, 'session.html'))
         : '—',
-    mtime: latestHtml?.mtime || manifestStat?.mtime || null
+    mtime: latestHtml?.mtime || manifestStat?.mtime || null,
+    tierSummary: buildTierSummary(manifest.executors),
+    estimatedCost: estimateRunCost(manifest.executors)
   };
 }
 
@@ -410,6 +440,12 @@ async function runSquadStatus({ args, logger, t }) {
         agent_count: squad.agentGenomes.length
       })
     );
+    if (squad.tierSummary) {
+      logger.log(t('squad_status.model_tiers', { value: squad.tierSummary }));
+    }
+    if (squad.estimatedCost != null) {
+      logger.log(t('squad_status.estimated_cost', { value: squad.estimatedCost.toFixed(3) }));
+    }
     if (i < squads.length - 1) logger.log('');
   }
 

package/src/commands/squad-validate.js

@@ -64,6 +64,18 @@ async function validateStructure(projectDir, slug, manifest) {
     }
   }
 
+  // Check api_endpoints workers
+  const apiEndpoints = Array.isArray(manifest.api_endpoints) ? manifest.api_endpoints : [];
+  for (const ep of apiEndpoints) {
+    if (ep.worker) {
+      const workerDir = path.join(squadDir, 'workers', ep.worker);
+      if (!(await pathExists(workerDir))) {
+        const rel = path.relative(projectDir, workerDir).replace(/\\/g, '/');
+        errors.push(`api_endpoints: worker "${ep.worker}" not found at ${rel}`);
+      }
+    }
+  }
+
   // Check output dir (warning only)
   const outputDir = path.join(projectDir, 'output', slug);
   if (!(await pathExists(outputDir))) {
@@ -197,7 +209,56 @@ async function validateSemanticDeep(projectDir, slug, manifest) {
     }
   }
 
-  // 6. Readiness não contradiz blockers
+  // 6. Task decomposition validation
+  for (const exec of executors) {
+    const tasks = Array.isArray(exec.tasks) ? exec.tasks : [];
+    if (tasks.length > 0) {
+      const orders = tasks.map(t => t.order).sort((a, b) => a - b);
+      for (let i = 0; i < orders.length; i++) {
+        if (orders[i] !== i + 1) {
+          warnings.push(`Executor "${exec.slug}": task order is not sequential (expected ${i + 1}, got ${orders[i]})`);
+          break;
+        }
+      }
+    }
+  }
+
+  // 6b. Model tiering validation
+  for (const exec of executors) {
+    if (exec.usesLLM === false && exec.modelTier && exec.modelTier !== 'none') {
+      warnings.push(`Executor "${exec.slug}": usesLLM is false but modelTier is "${exec.modelTier}" (expected "none")`);
+    }
+    if (exec.type === 'worker' && exec.modelTier && exec.modelTier !== 'none') {
+      warnings.push(`Executor "${exec.slug}": type is "worker" but modelTier is "${exec.modelTier}" (expected "none")`);
+    }
+  }
+
+  // 7. Review loop validation
+  const workflows = Array.isArray(manifest.workflows) ? manifest.workflows : [];
+  const executorSlugs = executors.map(e => e.slug);
+  for (const wf of workflows) {
+    const phases = Array.isArray(wf.phases) ? wf.phases : [];
+    const phaseIds = phases.map(p => p.id);
+    for (const phase of phases) {
+      if (phase.review) {
+        const rv = phase.review;
+        if (rv.reviewer && !executorSlugs.includes(rv.reviewer)) {
+          errors.push(`Workflow "${wf.slug}" phase "${phase.id}": reviewer "${rv.reviewer}" is not a declared executor`);
+        }
+        if (rv.onReject && !phaseIds.includes(rv.onReject)) {
+          errors.push(`Workflow "${wf.slug}" phase "${phase.id}": onReject target "${rv.onReject}" is not a valid phase ID`);
+        }
+        if (rv.reviewer && rv.reviewer === phase.executor) {
+          warnings.push(`Workflow "${wf.slug}" phase "${phase.id}": reviewer should not be the same as the creator executor`);
+        }
+      }
+      if (phase.review && (!phase.vetoConditions || phase.vetoConditions.length === 0)) {
+        warnings.push(`Workflow "${wf.slug}" phase "${phase.id}": has review but no vetoConditions — consider adding veto guards`);
+      }
+    }
+  }
+
+  // 7. Readiness não contradiz blockers
   if (manifest.readiness) {
     for (const [dim, val] of Object.entries(manifest.readiness)) {
       if (val && val.status === 'ready' && val.blocker) {

package/src/commands/squad-webhook.js

@@ -0,0 +1,160 @@
+'use strict';
+
+const path = require('node:path');
+const fs = require('node:fs/promises');
+const { WebhookServer } = require('../lib/webhook-server');
+const { getCliVersionSync } = require('../version');
+const { listWorkers, runWorker } = require('../worker-runner');
+const {
+  loadSession,
+  appendTurn,
+  buildContextualInput,
+  cleanExpiredSessions
+} = require('../squad/external-session');
+
+const SQUADS_DIR = path.join('.aioson', 'squads');
+
+async function discoverSquads(projectDir) {
+  const squadsDir = path.join(projectDir, SQUADS_DIR);
+  let entries;
+  try {
+    entries = await fs.readdir(squadsDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries.filter(e => e.isDirectory()).map(e => e.name);
+}
+
+async function executeSquad(projectDir, squadSlug, contextualInput) {
+  const workers = await listWorkers(projectDir, squadSlug);
+  if (workers.length === 0) {
+    throw new Error(`No workers found in squad "${squadSlug}"`);
+  }
+
+  // Run the first eligible worker as the squad entry point
+  for (const worker of workers) {
+    const result = await runWorker(
+      projectDir,
+      squadSlug,
+      worker.slug,
+      { input: contextualInput },
+      { triggerType: 'webhook' }
+    );
+    if (result.ok) {
+      const out = result.output;
+      return typeof out === 'string' ? out : JSON.stringify(out);
+    }
+  }
+
+  throw new Error(`All workers in squad "${squadSlug}" failed`);
+}
+
+async function handleStart(projectDir, options, { logger }) {
+  const port = parseInt(options.port || process.env.AIOSON_WEBHOOK_PORT || '3210', 10);
+  const token = options.token || process.env.AIOSON_WEBHOOK_TOKEN || '';
+  const ttlHours = parseInt(options.sessionTtl || process.env.AIOSON_SESSION_TTL_HOURS || '24', 10);
+  const version = getCliVersionSync();
+
+  if (!token) {
+    logger.error('Warning: AIOSON_WEBHOOK_TOKEN not set — server running without authentication.');
+  }
+
+  // Clean up expired sessions on startup
+  const cleaned = await cleanExpiredSessions(projectDir, ttlHours);
+  if (cleaned > 0) logger.log(`Cleaned ${cleaned} expired session(s).`);
+
+  const slugs = await discoverSquads(projectDir);
+  const squads = slugs.map(name => ({ name, timeout_ms: 120000 }));
+
+  const server = new WebhookServer({
+    port,
+    token,
+    squads,
+    version,
+    onTrigger: async ({ squad, input, session_id, metadata }) => {
+      // Load prior session context (if any)
+      const session = session_id
+        ? await loadSession(projectDir, session_id, ttlHours)
+        : null;
+
+      const contextualInput = buildContextualInput(session, input);
+
+      // Save user turn before execution
+      if (session_id) {
+        await appendTurn(projectDir, session_id, 'user', input, metadata || {}, ttlHours);
+      }
+
+      const response = await executeSquad(projectDir, squad, contextualInput);
+
+      // Save assistant turn after execution
+      if (session_id) {
+        await appendTurn(projectDir, session_id, 'assistant', response, {}, ttlHours);
+      }
+
+      return { response };
+    },
+    onQuery: async ({ squad, query, max_results }) => {
+      const raw = await executeSquad(projectDir, squad, query);
+      // Best-effort: if the output is JSON, parse and slice; otherwise wrap as single result
+      let results;
+      try {
+        const parsed = JSON.parse(raw);
+        results = Array.isArray(parsed) ? parsed.slice(0, max_results) : [parsed];
+      } catch {
+        results = [{ text: raw }];
+      }
+      return { results };
+    }
+  });
+
+  await server.start();
+
+  logger.log(`AIOSON squad webhook server started on port ${port}`);
+  if (squads.length > 0) {
+    logger.log(`Available squads: ${squads.map(s => s.name).join(', ')}`);
+  } else {
+    logger.log('No squads discovered in .aioson/squads/');
+  }
+  logger.log('Endpoints: POST /trigger  GET /status/:run_id  GET /health');
+  logger.log('Press Ctrl+C to stop.');
+
+  process.on('SIGINT', async () => {
+    await server.stop();
+    process.exit(0);
+  });
+  process.on('SIGTERM', async () => {
+    await server.stop();
+    process.exit(0);
+  });
+
+  // Keep the process alive until signal
+  await new Promise(() => {});
+}
+
+function handleConfig(options, { logger }) {
+  const channel = options.channel || 'whatsapp';
+  const squad = options.squad || 'atendimento';
+  const port = options.port || '3210';
+
+  logger.log(`OpenClaw configuration for squad "${squad}" via ${channel}:\n`);
+  logger.log(`hooks:\n  ${channel}:\n    auto_reply:\n      - pattern: ".*"\n        action: webhook\n        url: "http://SEU_SERVIDOR:${port}/trigger"\n        headers:\n          Authorization: "Bearer \${AIOSON_WEBHOOK_TOKEN}"\n        body_template: |\n          {\n            "squad": "${squad}",\n            "input": "{{message.text}}",\n            "session_id": "${channel}:{{message.from}}",\n            "callback_url": "{{openclaw.callback_url}}",\n            "metadata": {\n              "channel": "${channel}",\n              "phone": "{{message.from}}",\n              "user_name": "{{message.contact_name}}"\n            }\n          }`);
+
+  return { ok: true };
+}
+
+async function runSquadWebhook({ args, options, logger }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const sub = options.sub || 'start';
+
+  switch (sub) {
+    case 'start':
+      return handleStart(targetDir, options, { logger });
+    case 'config':
+      return handleConfig(options, { logger });
+    default:
+      logger.error(`Unknown subcommand: "${sub}". Use: start, config`);
+      return { ok: false };
+  }
+}
+
+module.exports = { runSquadWebhook };