@jaimevalasek/aioson 1.5.1 → 1.6.0

package/src/commands/install.js

@@ -2,14 +2,19 @@
 
 const path = require('node:path');
 const { detectFramework } = require('../detector');
-const { installTemplate } = require('../installer');
+const { installTemplate, readInstallProfile } = require('../installer');
 const { applyAgentLocale } = require('../locales');
 const { resolvePromptTool } = require('../prompt-tool');
+const { runInstallWizard } = require('../install-wizard');
+const { renderRevealAnimation, renderInstallSummary, renderProgress } = require('../install-animation');
+const { getCliVersion } = require('../version');
 
 async function runInstall({ args, options, logger, t }) {
   const targetDir = path.resolve(process.cwd(), args[0] || '.');
   const force = Boolean(options.force);
   const dryRun = Boolean(options['dry-run']);
+  const noInteractive = Boolean(options['no-interactive']);
+  const reconfigure = Boolean(options.reconfigure);
   const requestedLanguage = options.lang || options.language;
   const promptTool = resolvePromptTool(options.tool);
 
@@ -23,16 +28,42 @@ async function runInstall({ args, options, logger, t }) {
     logger.log(t('install.framework_not_detected'));
   }
 
+  // Decide install profile
+  let installProfile = null;
+  const isTTY = process.stdin.isTTY && process.stdout.isTTY;
+
+  if (!noInteractive && isTTY && !dryRun) {
+    const existingProfile = await readInstallProfile(targetDir);
+    if (!existingProfile || reconfigure) {
+      installProfile = await runInstallWizard({
+        noInteractive,
+        existingProfile: reconfigure ? existingProfile : null,
+        t
+      });
+      // null = user cancelled → fall back to full install
+    } else {
+      installProfile = existingProfile;
+      logger.log(t('install.using_saved_profile'));
+    }
+  }
+
+  // When reconfigure, we need overwrite=true so changed profile is reflected
+  const overwrite = force || reconfigure;
+
   const result = await installTemplate(targetDir, {
-    overwrite: force,
+    overwrite,
     dryRun,
     mode: 'install',
-    frameworkDetection: detection.framework
+    frameworkDetection: detection.framework,
+    installProfile,
+    onProgress: isTTY && !dryRun ? renderProgress : null
   });
 
+  // Locale: explicit --lang flag wins over profile, profile wins over nothing
+  const effectiveLocale = requestedLanguage || (installProfile && installProfile.locale) || null;
   let localeApply = null;
-  if (requestedLanguage) {
-    localeApply = await applyAgentLocale(targetDir, requestedLanguage, { dryRun });
+  if (effectiveLocale) {
+    localeApply = await applyAgentLocale(targetDir, effectiveLocale, { dryRun });
     if (dryRun) {
       logger.log(t('locale_apply.dry_run_applied', { locale: localeApply.locale }));
     } else {
@@ -40,13 +71,20 @@ async function runInstall({ args, options, logger, t }) {
     }
   }
 
-  logger.log(t('install.done_at', { targetDir }));
-  logger.log(t('install.files_copied', { count: result.copied.length }));
-  logger.log(t('install.files_skipped', { count: result.skipped.length }));
-  logger.log(t('install.next_steps'));
-  logger.log(t('install.step_setup_context'));
-  logger.log(t('install.step_agents'));
-  logger.log(t('install.step_agent_prompt', { tool: promptTool }));
+  // Reveal animation + summary (TTY only, not dry-run)
+  if (isTTY && !dryRun) {
+    const version = await getCliVersion();
+    await renderRevealAnimation(version);
+    renderInstallSummary({ result, installProfile });
+  } else {
+    logger.log(t('install.done_at', { targetDir }));
+    logger.log(t('install.files_copied', { count: result.copied.length }));
+    logger.log(t('install.files_skipped', { count: result.skipped.length }));
+    logger.log(t('install.next_steps'));
+    logger.log(t('install.step_setup_context'));
+    logger.log(t('install.step_agents'));
+    logger.log(t('install.step_agent_prompt', { tool: promptTool }));
+  }
 
   if (result.isExistingProject) {
     logger.log('');
@@ -59,7 +97,8 @@ async function runInstall({ args, options, logger, t }) {
     targetDir,
     detection,
     ...result,
-    localeApply
+    localeApply,
+    installProfile
   };
 }
 

package/src/commands/learning-evolve.js

@@ -0,0 +1,355 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { openRuntimeDb, listSquadLearnings, listProjectLearnings, promoteSquadLearning, promoteProjectLearning } = require('../runtime-store');
+
+const AGENTS_DIR = path.join('.aioson', 'agents');
+const EVOLUTION_DIR = path.join('.aioson', 'evolution');
+const CONTEXT_FILE = path.join('.aioson', 'context', 'project.context.md');
+const MAX_FILE_LINES = 300;
+const MIN_FREQUENCY = 2;
+
+/**
+ * Mapeia tipo de learning para seção e arquivo alvo.
+ */
+function resolveDeltaTarget(type, squadSlug) {
+  const rulesDir = path.join('.aioson', 'rules');
+  if (type === 'preference') {
+    return { file: CONTEXT_FILE, section: '## Preferências dos Agentes' };
+  }
+  if (type === 'process') {
+    const filename = squadSlug ? `${squadSlug}-process.md` : 'project-process.md';
+    return { file: path.join(rulesDir, filename), section: null };
+  }
+  if (type === 'domain') {
+    return { file: CONTEXT_FILE, section: '## Conhecimento de Domínio' };
+  }
+  if (type === 'quality') {
+    return { file: CONTEXT_FILE, section: '## Padrões de Qualidade' };
+  }
+  return { file: CONTEXT_FILE, section: '## Observações' };
+}
+
+/**
+ * Gate 1: arquivo não pode estar dentro de .aioson/agents/
+ */
+function passesConstitutionGate(filePath, projectDir) {
+  const absolute = path.isAbsolute(filePath) ? filePath : path.resolve(projectDir, filePath);
+  const agentsAbsolute = path.resolve(projectDir, AGENTS_DIR);
+  return !absolute.startsWith(agentsAbsolute + path.sep) && absolute !== agentsAbsolute;
+}
+
+/**
+ * Gate 2: arquivo alvo não pode ultrapassar MAX_FILE_LINES após append.
+ */
+async function passesSizeGate(filePath, projectDir, newContent) {
+  const absolute = path.isAbsolute(filePath) ? filePath : path.resolve(projectDir, filePath);
+  let existingLines = 0;
+  try {
+    const content = await fs.readFile(absolute, 'utf8');
+    existingLines = content.split('\n').length;
+  } catch {
+    existingLines = 0;
+  }
+  const newLines = String(newContent || '').split('\n').length;
+  return (existingLines + newLines) <= MAX_FILE_LINES;
+}
+
+/**
+ * Gera o conteúdo textual de um delta a partir de um grupo de learnings.
+ */
+function buildDeltaContent(learnings, section) {
+  const lines = [];
+  if (section) {
+    lines.push('');
+  }
+  for (const l of learnings) {
+    const confidence = l.confidence === 'high' ? '(alta confiança)' : l.confidence === 'low' ? '(baixa confiança)' : '';
+    lines.push(`- ${l.title} ${confidence}`.trim());
+    if (l.evidence) {
+      lines.push(`  > ${l.evidence}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Aplica um delta aprovado no sistema de arquivos.
+ */
+async function applyDelta(delta, projectDir) {
+  const absolute = path.isAbsolute(delta.file) ? delta.file : path.resolve(projectDir, delta.file);
+
+  await fs.mkdir(path.dirname(absolute), { recursive: true });
+
+  let existing = '';
+  try {
+    existing = await fs.readFile(absolute, 'utf8');
+  } catch {
+    existing = '';
+  }
+
+  if (delta.section && existing) {
+    if (existing.includes(delta.section)) {
+      // Insere após o cabeçalho da seção
+      const updated = existing.replace(delta.section, `${delta.section}\n${delta.content}`);
+      await fs.writeFile(absolute, updated, 'utf8');
+    } else {
+      // Adiciona a seção no final
+      await fs.writeFile(absolute, `${existing}\n${delta.section}\n${delta.content}\n`, 'utf8');
+    }
+  } else {
+    // Append simples
+    await fs.writeFile(absolute, `${existing}\n${delta.content}\n`, 'utf8');
+  }
+}
+
+/**
+ * Ponto de entrada principal.
+ */
+async function runLearningEvolve({ args = [], options = {}, logger = console, t = (k) => k } = {}) {
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+  const squadSlug = options.squad || null;
+  const dryRun = Boolean(options['dry-run'] || options.dry);
+  const autoApply = Boolean(options['auto-apply'] || options.auto);
+  const quiet = Boolean(options.quiet);
+
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error('Runtime store não encontrado. Execute aioson runtime:init primeiro.');
+    return { ok: false, error: 'no_runtime' };
+  }
+  const { db } = handle;
+
+  let learnings;
+  try {
+    if (squadSlug) {
+      learnings = listSquadLearnings(db, squadSlug, 'active');
+    } else {
+      const squad = listSquadLearnings(db, null, 'active');
+      const project = listProjectLearnings(db, 'active');
+      learnings = [...squad, ...project];
+    }
+  } finally {
+    db.close();
+  }
+
+  // Filtra por frequência mínima
+  const eligible = learnings.filter((l) => Number(l.frequency || 1) >= MIN_FREQUENCY);
+
+  if (eligible.length === 0) {
+    if (!quiet) logger.log('Nenhum learning com frequência suficiente para evoluir (mínimo: 2 ocorrências).');
+    return { ok: true, evolved: 0, skipped: 0, proposed: [] };
+  }
+
+  if (!quiet) logger.log(`Analisando ${eligible.length} learnings elegíveis...`);
+
+  // Agrupa por tipo
+  const grouped = {};
+  for (const l of eligible) {
+    const key = l.type;
+    if (!grouped[key]) grouped[key] = [];
+    grouped[key].push(l);
+  }
+
+  // Gera deltas
+  const proposed = [];
+  const rejected = [];
+
+  for (const [type, group] of Object.entries(grouped)) {
+    const { file, section } = resolveDeltaTarget(type, group[0].squad_slug || null);
+    const content = buildDeltaContent(group, section);
+
+    // Gate 1: Constitution
+    if (!passesConstitutionGate(file, projectDir)) {
+      rejected.push({ type, reason: 'constitution_gate', file, count: group.length });
+      continue;
+    }
+
+    // Gate 2: Size
+    const sizeOk = await passesSizeGate(file, projectDir, content);
+    if (!sizeOk) {
+      rejected.push({ type, reason: 'size_gate', file, count: group.length });
+      continue;
+    }
+
+    proposed.push({
+      type,
+      file,
+      section,
+      content,
+      sourceIds: group.map((l) => l.learning_id),
+      count: group.length
+    });
+  }
+
+  // Exibe resultados
+  if (!quiet) {
+    logger.log('');
+    logger.log(`Deltas propostos: ${proposed.length} aprovados, ${rejected.length} rejeitados`);
+    logger.log('');
+
+    for (let i = 0; i < proposed.length; i++) {
+      const d = proposed[i];
+      logger.log(`  [${i + 1}] APPEND → ${d.file}`);
+      if (d.section) logger.log(`      Seção: ${d.section}`);
+      logger.log(`      Learnings: ${d.count} (${d.type})`);
+      logger.log(d.content.split('\n').map((l) => `      ${l}`).join('\n'));
+      logger.log('');
+    }
+
+    for (const r of rejected) {
+      const reason = r.reason === 'constitution_gate' ? 'gate constitucional (arquivo imutável)' : `gate de tamanho (>${MAX_FILE_LINES} linhas)`;
+      logger.log(`  ✗ Rejeitado [${r.type}] → ${r.file}: ${reason}`);
+    }
+  }
+
+  if (proposed.length === 0) {
+    return { ok: true, evolved: 0, skipped: rejected.length, proposed: [] };
+  }
+
+  // Dry-run: só exibe, não aplica
+  if (dryRun) {
+    logger.log('Modo dry-run: nenhuma alteração foi feita.');
+    return { ok: true, evolved: 0, skipped: rejected.length, proposed };
+  }
+
+  // Auto-apply: aplica diretamente
+  if (autoApply) {
+    return applyProposed(proposed, projectDir, db, logger, quiet, squadSlug);
+  }
+
+  // Modo padrão: salva arquivo pendente
+  const evolutionDir = path.resolve(projectDir, EVOLUTION_DIR);
+  await fs.mkdir(evolutionDir, { recursive: true });
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const pendingFile = path.join(evolutionDir, `pending-${timestamp}.json`);
+  await fs.writeFile(pendingFile, JSON.stringify({ createdAt: new Date().toISOString(), projectDir, proposed, rejected }, null, 2), 'utf8');
+
+  if (!quiet) {
+    logger.log(`Proposta salva em: ${pendingFile}`);
+    logger.log('Para aplicar: aioson learning:apply . --file=' + path.relative(projectDir, pendingFile));
+    logger.log('Para aplicar automaticamente: aioson learning:evolve . --auto-apply');
+  }
+
+  return { ok: true, evolved: 0, skipped: rejected.length, proposed, pendingFile };
+}
+
+async function applyProposed(proposed, projectDir, db, logger, quiet, squadSlug) {
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) return { ok: false, error: 'no_runtime' };
+  const applyDb = handle.db;
+
+  let evolved = 0;
+  try {
+    for (const delta of proposed) {
+      await applyDelta(delta, projectDir);
+
+      // Promove learnings no DB
+      for (const id of delta.sourceIds) {
+        try {
+          if (id.startsWith('sl-') || id.startsWith('pl-')) {
+            if (id.startsWith('sl-')) {
+              promoteSquadLearning(applyDb, id, delta.file);
+            } else {
+              promoteProjectLearning(applyDb, id, delta.file);
+            }
+          } else {
+            promoteSquadLearning(applyDb, id, delta.file);
+          }
+        } catch { /* learning pode já ter sido promovido */ }
+      }
+
+      evolved++;
+      if (!quiet) logger.log(`  ✓ Aplicado: ${delta.file} (+${delta.count} learnings)`);
+    }
+
+    // Registra no log de evolução
+    const evolutionDir = path.resolve(projectDir, EVOLUTION_DIR);
+    await fs.mkdir(evolutionDir, { recursive: true });
+    const logFile = path.join(evolutionDir, 'log.jsonl');
+    const logEntry = JSON.stringify({
+      appliedAt: new Date().toISOString(),
+      deltasCount: evolved,
+      squad: squadSlug || null,
+      files: proposed.map((d) => d.file)
+    });
+    await fs.appendFile(logFile, `${logEntry}\n`, 'utf8');
+
+    if (!quiet) logger.log(`\n${evolved} delta(s) aplicado(s) com sucesso.`);
+  } finally {
+    applyDb.close();
+  }
+
+  return { ok: true, evolved, skipped: 0, proposed };
+}
+
+/**
+ * Subcomando: apply — aplica um arquivo de deltas pendentes.
+ */
+async function runLearningApply({ args = [], options = {}, logger = console } = {}) {
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+  const filePath = options.file ? String(options.file) : null;
+
+  if (!filePath) {
+    logger.error('--file é obrigatório. Exemplo: aioson learning:apply . --file=.aioson/evolution/pending-XXX.json');
+    return { ok: false, error: 'file_required' };
+  }
+
+  const absolute = path.isAbsolute(filePath) ? filePath : path.resolve(projectDir, filePath);
+
+  let pendingData;
+  try {
+    pendingData = JSON.parse(await fs.readFile(absolute, 'utf8'));
+  } catch (err) {
+    logger.error(`Não foi possível ler o arquivo: ${absolute}\n${err.message}`);
+    return { ok: false, error: 'file_not_readable' };
+  }
+
+  const { proposed = [], rejected = [] } = pendingData;
+
+  if (proposed.length === 0) {
+    logger.log('Nenhum delta para aplicar neste arquivo.');
+    return { ok: true, evolved: 0 };
+  }
+
+  logger.log(`Aplicando ${proposed.length} delta(s)...`);
+
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  const db = handle ? handle.db : null;
+
+  let evolved = 0;
+  for (const delta of proposed) {
+    try {
+      await applyDelta(delta, projectDir);
+      if (db) {
+        for (const id of (delta.sourceIds || [])) {
+          try {
+            if (id.startsWith('pl-')) {
+              promoteProjectLearning(db, id, delta.file);
+            } else {
+              promoteSquadLearning(db, id, delta.file);
+            }
+          } catch { /* ok */ }
+        }
+      }
+      evolved++;
+      logger.log(`  ✓ ${delta.file}`);
+    } catch (err) {
+      logger.error(`  ✗ Falha em ${delta.file}: ${err.message}`);
+    }
+  }
+
+  if (db) db.close();
+
+  // Remove o arquivo pendente após aplicar
+  try { await fs.unlink(absolute); } catch { /* ok */ }
+
+  logger.log(`\n${evolved}/${proposed.length} delta(s) aplicado(s).`);
+  if (rejected.length > 0) logger.log(`${rejected.length} rejeitado(s) previamente pelos gates.`);
+
+  return { ok: true, evolved };
+}
+
+module.exports = { runLearningEvolve, runLearningApply };

package/src/commands/live.js

@@ -1062,6 +1062,23 @@ async function runLiveStart({ args, options = {}, logger, t }) {
       logger.log(t('live.session_started', { agent: agentName, tool, session: sessionKey, dbPath }));
     }
 
+    // Ambient Intelligence: exibe digest de saúde ao iniciar sessão
+    if (!options.json && !options['no-health']) {
+      try {
+        const { getHealthDigest } = require('./health');
+        const items = await getHealthDigest(targetDir);
+        if (items && items.length > 0) {
+          logger.log('');
+          logger.log('AIOSON Health — itens pendentes:');
+          for (const item of items) {
+            logger.log(`  ● ${item}`);
+          }
+          logger.log('  → aioson health . para detalhes');
+          logger.log('');
+        }
+      } catch { /* não bloqueia o start */ }
+    }
+
     if (child) {
       childResult = await waitForChild(child);
     }
@@ -1508,6 +1525,23 @@ async function runLiveClose({ args, options = {}, logger, t }) {
       logger.log(t('live.session_closed', { agent: context.agentName, session: context.sessionKey, dbPath }));
     }
 
+    // Ambient Intelligence: sugere evolução se há learnings acumulados
+    if (!options.json && !options['no-health']) {
+      try {
+        const { getHealthDigest } = require('./health');
+        const items = await getHealthDigest(targetDir);
+        if (items && items.length > 0) {
+          logger.log('');
+          logger.log('AIOSON Health — itens após sessão:');
+          for (const item of items) {
+            logger.log(`  ● ${item}`);
+          }
+          logger.log('  → aioson health . para detalhes e ações');
+          logger.log('');
+        }
+      } catch { /* não bloqueia o close */ }
+    }
+
     return {
       ok: true,
       targetDir,

package/src/commands/recovery.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const path = require('node:path');
+const { generateSessionRecovery, readSessionRecovery } = require('../recovery-context-session');
+
+async function runRecoveryGenerate({ args, options, logger }) {
+  const cwd = path.resolve(process.cwd(), args[0] || '.');
+  const sessionState = {
+    goal: options.goal || undefined,
+    agent: options.agent || undefined,
+    tasks: [],
+    notes: []
+  };
+
+  const result = await generateSessionRecovery(cwd, sessionState);
+
+  if (!result.ok) {
+    logger.error(`recovery:generate failed: ${result.error}`);
+    return result;
+  }
+
+  logger.log(`Recovery context generated: ${result.path} (${result.tokens} tokens)`);
+  return result;
+}
+
+async function runRecoveryShow({ args, options, logger }) {
+  const cwd = path.resolve(process.cwd(), args[0] || '.');
+  const content = await readSessionRecovery(cwd);
+
+  if (!content) {
+    logger.log('No recovery context found. Run: aioson recovery:generate');
+    return { ok: false, error: 'not_found' };
+  }
+
+  if (options.json) {
+    return { ok: true, content };
+  }
+
+  logger.log(content);
+  return { ok: true, content };
+}
+
+module.exports = { runRecoveryGenerate, runRecoveryShow };

package/src/commands/sandbox.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const path = require('node:path');
+const { executeInSandbox } = require('../sandbox');
+
+async function runSandboxExec({ args, options, logger }) {
+  const command = args[0] || options.command || '';
+  const cwd = path.resolve(process.cwd(), options.cwd || '.');
+  const timeout = Number(options.timeout) || 30_000;
+  const intent = options.intent || undefined;
+
+  if (!command) {
+    logger.error('Usage: aioson sandbox:exec "<command>" [--timeout=30000] [--cwd=.]');
+    return { ok: false, error: 'missing_command' };
+  }
+
+  const result = await executeInSandbox(command, { cwd, timeout, intent });
+
+  if (options.json) {
+    return { ok: result.ok, ...result };
+  }
+
+  if (result.stdout) {
+    logger.log(result.stdout);
+  }
+  if (result.stderr) {
+    logger.error(result.stderr);
+  }
+
+  if (result.timedOut) {
+    logger.error(`Command timed out after ${timeout}ms`);
+  }
+
+  return { ok: result.ok, ...result };
+}
+
+module.exports = { runSandboxExec };

package/src/commands/setup-context.js

@@ -3,6 +3,25 @@
 const path = require('node:path');
 const readline = require('node:readline/promises');
 const { detectFramework, isMonorepoDetection } = require('../detector');
+
+/**
+ * Infer conversation language from the OS locale environment variables.
+ * Supports LANGUAGE, LANG, and LC_ALL in priority order.
+ * Maps POSIX locale codes (e.g. pt_BR.UTF-8) to AIOSON locale codes (e.g. pt-BR).
+ */
+function detectSystemLanguage() {
+  const raw = process.env.LANGUAGE || process.env.LANG || process.env.LC_ALL || '';
+  const base = raw.split(':')[0].split('.')[0].trim();
+  if (!base || base === 'C' || base === 'POSIX') return 'en';
+  const normalized = base.replace('_', '-');
+  const supported = ['en', 'pt-BR', 'es', 'fr'];
+  if (supported.includes(normalized)) return normalized;
+  const lang = normalized.split('-')[0].toLowerCase();
+  if (lang === 'pt') return 'pt-BR';
+  if (lang === 'es') return 'es';
+  if (lang === 'fr') return 'fr';
+  return 'en';
+}
 const { getCliVersionSync } = require('../version');
 const {
   calculateClassification,
@@ -469,7 +488,7 @@ async function runSetupContext({ args, options, logger, t }) {
     profile: 'developer',
     framework: detectedFramework,
     frameworkInstalled: detectedInstalled,
-    conversationLanguage: 'en',
+    conversationLanguage: detectSystemLanguage(),
     designSkill: '',
     testRunner: '',
     web3Enabled: inferredWeb3Enabled,
@@ -674,5 +693,6 @@ module.exports = {
   runSetupContext,
   servicesToContextFields,
   mergeProfileData,
-  applyExplicitOverrides
+  applyExplicitOverrides,
+  detectSystemLanguage
 };