@jaimevalasek/aioson 1.4.0 → 1.6.0

package/src/commands/context-search.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const path = require('node:path');
+const { withIndex } = require('../context-search');
+
+async function runContextSearch({ args, options, logger }) {
+  const query = args[0] || options.query || '';
+  const cwd = path.resolve(process.cwd(), options.cwd || '.');
+  const limit = Number(options.limit) || 10;
+
+  if (!query) {
+    logger.log('Usage: aioson context:search <query> [--limit=10] [--cwd=.]');
+    return { ok: false, error: 'missing_query' };
+  }
+
+  const results = await withIndex(async (idx) => {
+    return idx.search(query, { limit, projectDir: cwd });
+  });
+
+  if (options.json) {
+    return { ok: true, results };
+  }
+
+  if (results.length === 0) {
+    logger.log(`No results for: ${query}`);
+    return { ok: true, results: [] };
+  }
+
+  logger.log(`\n  Search results for: "${query}"\n`);
+  for (let i = 0; i < results.length; i++) {
+    const r = results[i];
+    logger.log(`  ${i + 1}. ${r.title}`);
+    logger.log(`     ${r.relPath}`);
+    if (r.snippet) {
+      logger.log(`     ${r.snippet.replace(/\n/g, ' ')}`);
+    }
+    logger.log('');
+  }
+
+  return { ok: true, results };
+}
+
+async function runContextSearchIndex({ args, options, logger }) {
+  const cwd = path.resolve(process.cwd(), args[0] || '.');
+  const force = Boolean(options.force);
+
+  logger.log(`Indexing: ${cwd} ...`);
+
+  const result = await withIndex(async (idx) => {
+    const r = await idx.indexDirectory(cwd, { force });
+    const stats = idx.stats();
+    return { ...r, stats };
+  });
+
+  if (options.json) {
+    return { ok: true, ...result };
+  }
+
+  logger.log(`  Indexed: ${result.indexed} files`);
+  logger.log(`  Skipped: ${result.skipped} files (already indexed)`);
+  logger.log(`  Total in index: ${result.stats.totalDocs} docs`);
+
+  return { ok: true, ...result };
+}
+
+module.exports = { runContextSearch, runContextSearchIndex };

package/src/commands/design-hybrid-options.js

@@ -0,0 +1,385 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const readline = require('node:readline');
+const { validateProjectContextFile } = require('../context');
+const { resolveAgentLocale } = require('../locales');
+const { ensureDir } = require('../utils');
+const {
+  getDesignVariationCatalog,
+  getDesignVariationSources
+} = require('../design-variation-catalog');
+
+function resolveTargetDir(args) {
+  return path.resolve(process.cwd(), args[0] || '.');
+}
+
+async function detectProjectLocale(targetDir) {
+  const context = await validateProjectContextFile(targetDir);
+  if (context.parsed && context.data && context.data.conversation_language) {
+    return {
+      locale: resolveAgentLocale(context.data.conversation_language),
+      source: 'project-context'
+    };
+  }
+  return {
+    locale: 'en',
+    source: 'default'
+  };
+}
+
+function resolveLocale(optionsLocale, projectLocale) {
+  return resolveAgentLocale(optionsLocale || projectLocale || 'en');
+}
+
+function formatTimestamp(date = new Date()) {
+  const pad = (value) => String(value).padStart(2, '0');
+  return [
+    date.getUTCFullYear(),
+    pad(date.getUTCMonth() + 1),
+    pad(date.getUTCDate())
+  ].join('') + '-' + [
+    pad(date.getUTCHours()),
+    pad(date.getUTCMinutes()),
+    pad(date.getUTCSeconds())
+  ].join('');
+}
+
+function getUiText(locale) {
+  if (locale === 'pt-BR') {
+    return {
+      title: 'AIOSON — Opções do Design Hybrid',
+      instructions: 'Use ↑/↓ para mover, espaço para marcar, enter para confirmar, q para cancelar.',
+      launching: 'Abrindo seletor de variações de design...',
+      saved: 'Preset de variação salvo.',
+      path: 'Arquivo ativo',
+      history: 'Histórico',
+      promptReady: 'Bloco pronto para usar com @design-hybrid-forge:',
+      presetHeading: '# Preset de Variação de Design',
+      presetIntro: 'Use este arquivo como overlay de variação para `@design-hybrid-forge` ou `/design-hybrid-forge`. O arquivo ativo deve ser arquivado após a skill híbrida ser gerada; a cópia em histórico permanece como trilha de criação.',
+      selectedVariations: '## Variações selecionadas',
+      presetPolicy: '## Política do preset',
+      presetPolicyLines: [
+        '- Este preset é temporário e serve apenas para a próxima geração da skill híbrida.',
+        '- Após a geração, mova ou apague `.aioson/context/design-variation-preset.md`.',
+        '- O histórico em `.aioson/context/history/design-variation-presets/` deve ser preservado.',
+        '- O layout padrão do projeto continua sendo definido pela `design_skill` ativa, não por este preset.'
+      ],
+      promptBlock: '## Bloco para prompt',
+      sources: '## Fontes',
+      none: 'nenhum',
+      ttyError: 'Execute este comando em um terminal interativo, ou use --json para inspecionar o catálogo.'
+    };
+  }
+
+  return {
+    title: 'AIOSON — Design Hybrid Options',
+    instructions: 'Use ↑/↓ to move, space to toggle, enter to confirm, q to cancel.',
+    launching: 'Launching design variation picker...',
+    saved: 'Design variation preset saved.',
+    path: 'Active file',
+    history: 'History',
+    promptReady: 'Prompt block ready for @design-hybrid-forge:',
+    presetHeading: '# Design Variation Preset',
+    presetIntro: 'Use this file as a variation overlay for `@design-hybrid-forge` or `/design-hybrid-forge`. The active file should be archived after the hybrid skill is generated; the history copy remains as the creation trail.',
+    selectedVariations: '## Selected variations',
+    presetPolicy: '## Preset policy',
+    presetPolicyLines: [
+      '- This preset is temporary and should drive only the next hybrid skill generation.',
+      '- After generation, move or delete `.aioson/context/design-variation-preset.md`.',
+      '- Keep the history copy in `.aioson/context/history/design-variation-presets/`.',
+      '- The project default layout still comes from the active `design_skill`, not from this preset.'
+    ],
+    promptBlock: '## Prompt block',
+    sources: '## Sources',
+    none: 'none',
+    ttyError: 'Run this command in an interactive terminal, or use --json to inspect the catalog.'
+  };
+}
+
+function clearScreen(stdout = process.stdout) {
+  stdout.write('\x1Bc');
+}
+
+function renderGroup(group, cursor, selected, ui, stdout = process.stdout) {
+  clearScreen(stdout);
+  stdout.write(`${ui.title}\n\n`);
+  stdout.write(`${group.title}\n`);
+  stdout.write(`${group.guidance}\n`);
+  stdout.write(`${ui.instructions}\n\n`);
+
+  for (let i = 0; i < group.options.length; i++) {
+    const option = group.options[i];
+    const isActive = i === cursor;
+    const isSelected = selected.has(option.id);
+    const marker = isSelected ? '[x]' : '[ ]';
+    const pointer = isActive ? '>' : ' ';
+    stdout.write(`${pointer} ${marker} ${option.label}\n`);
+    stdout.write(`    ${option.description}\n`);
+  }
+}
+
+async function promptMultiSelectGroup(group, ui, io = {}) {
+  const stdin = io.stdin || process.stdin;
+  const stdout = io.stdout || process.stdout;
+
+  if (!stdin.isTTY || !stdout.isTTY) {
+    throw new Error('Interactive design-hybrid:options requires a TTY terminal.');
+  }
+
+  readline.emitKeypressEvents(stdin);
+  const wasRaw = Boolean(stdin.isRaw);
+  const wasPaused = typeof stdin.isPaused === 'function' ? stdin.isPaused() : true;
+  if (typeof stdin.setRawMode === 'function') stdin.setRawMode(true);
+  if (typeof stdin.resume === 'function') stdin.resume();
+
+  let cursor = 0;
+  const selected = new Set();
+
+  return new Promise((resolve, reject) => {
+    let cleanedUp = false;
+
+    function cleanup() {
+      if (cleanedUp) return;
+      cleanedUp = true;
+      stdin.removeListener('keypress', onKeypress);
+      if (stdin.listenerCount('keypress') === 0 && stdin.listenerCount('data') > 0) {
+        stdin.emit('data', Buffer.alloc(0));
+      }
+      if (typeof stdin.setRawMode === 'function') stdin.setRawMode(wasRaw);
+      if (wasPaused && typeof stdin.pause === 'function') stdin.pause();
+      stdout.write('\n');
+    }
+
+    function onKeypress(_str, key) {
+      if (key && key.ctrl && key.name === 'c') {
+        cleanup();
+        reject(new Error('Interrupted'));
+        return;
+      }
+
+      if (key && key.name === 'q') {
+        cleanup();
+        reject(new Error('Cancelled'));
+        return;
+      }
+
+      if (key && key.name === 'up') {
+        cursor = cursor === 0 ? group.options.length - 1 : cursor - 1;
+        renderGroup(group, cursor, selected, ui, stdout);
+        return;
+      }
+
+      if (key && key.name === 'down') {
+        cursor = cursor === group.options.length - 1 ? 0 : cursor + 1;
+        renderGroup(group, cursor, selected, ui, stdout);
+        return;
+      }
+
+      if (key && key.name === 'space') {
+        const id = group.options[cursor].id;
+        if (selected.has(id)) selected.delete(id);
+        else selected.add(id);
+        renderGroup(group, cursor, selected, ui, stdout);
+        return;
+      }
+
+      if (key && key.name === 'return') {
+        cleanup();
+        resolve(group.options.filter((option) => selected.has(option.id)));
+      }
+    }
+
+    stdin.on('keypress', onKeypress);
+    renderGroup(group, cursor, selected, ui, stdout);
+  });
+}
+
+function buildPromptBlock(selections) {
+  const lines = ['variation_overlay:'];
+  for (const group of selections.__groups) {
+    const chosen = selections[group.id] || [];
+    lines.push(`  ${group.id}:`);
+    if (chosen.length === 0) {
+      lines.push('    - none');
+      continue;
+    }
+    for (const option of chosen) {
+      lines.push(`    - ${option.id}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+function buildPresetMarkdown(selections, locale, options = {}) {
+  const generatedAt = new Date().toISOString();
+  const oneShot = options.oneShot !== false;
+  const modifierPolicy = options.advanced ? 'up_to_3_modifiers' : 'up_to_2_modifiers';
+  const ui = getUiText(locale);
+  const lines = [
+    '---',
+    'preset_type: design-variation',
+    `locale: "${locale}"`,
+    `consumption_mode: "${oneShot ? 'archive_after_generation' : 'persistent'}"`,
+    `modifier_policy: "${modifierPolicy}"`,
+    `generated_at: "${generatedAt}"`,
+    '---',
+    '',
+    ui.presetHeading,
+    '',
+    ui.presetIntro,
+    '',
+    ui.selectedVariations
+  ];
+
+  for (const group of selections.__groups) {
+    lines.push('');
+    lines.push(`### ${group.title}`);
+    const chosen = selections[group.id] || [];
+    if (chosen.length === 0) {
+      lines.push(`- ${ui.none}`);
+      continue;
+    }
+    for (const option of chosen) {
+      lines.push(`- ${option.label} — ${option.description}`);
+    }
+  }
+
+  lines.push('');
+  lines.push(ui.presetPolicy);
+  lines.push('');
+  for (const line of ui.presetPolicyLines) {
+    lines.push(line);
+  }
+  lines.push('');
+  lines.push(ui.promptBlock);
+  lines.push('');
+  lines.push('```yaml');
+  lines.push(buildPromptBlock(selections));
+  lines.push('```');
+  lines.push('');
+  lines.push(ui.sources);
+  for (const source of selections.__sources) {
+    lines.push(`- ${source.label}: ${source.url}`);
+  }
+
+  return `${lines.join('\n')}\n`;
+}
+
+function buildSummary(selections) {
+  const parts = [];
+  for (const group of selections.__groups) {
+    const chosen = selections[group.id] || [];
+    if (chosen.length === 0) continue;
+    parts.push(`${group.title}: ${chosen.map((item) => item.label).join(', ')}`);
+  }
+  return parts;
+}
+
+async function runDesignHybridOptions({ args, options = {}, logger, io = {} }) {
+  const targetDir = resolveTargetDir(args);
+  const presetPath = path.join(targetDir, '.aioson/context/design-variation-preset.md');
+  const historyDir = path.join(targetDir, '.aioson/context/history/design-variation-presets');
+  const stdin = io.stdin || process.stdin;
+  const stdout = io.stdout || process.stdout;
+  const projectLocaleResult = await detectProjectLocale(targetDir);
+  const projectLocale = projectLocaleResult.locale;
+  const localeOption = options.locale || options.language || options.lang;
+  const locale = resolveLocale(localeOption, projectLocale);
+  const ui = getUiText(locale);
+  const groups = getDesignVariationCatalog(locale);
+  const sources = getDesignVariationSources(locale);
+  const advanced = Boolean(options.advanced);
+  const modifierPolicy = advanced ? 'up_to_3_modifiers' : 'up_to_2_modifiers';
+  const localeSource = localeOption ? 'option' : projectLocaleResult.source;
+
+  if (options.json) {
+    return {
+      ok: true,
+      targetDir,
+      locale,
+      localeSource,
+      projectLocale,
+      advanced,
+      modifierPolicy,
+      presetPath: path.relative(targetDir, presetPath),
+      historyDir: path.relative(targetDir, historyDir),
+      groups,
+      sources
+    };
+  }
+
+  if (!stdin.isTTY || !stdout.isTTY) {
+    logger.log(ui.ttyError);
+    return {
+      ok: false,
+      error: 'TTY required',
+      message: ui.ttyError
+    };
+  }
+
+  logger.log(ui.launching);
+  const selections = {
+    __groups: groups,
+    __sources: sources
+  };
+
+  for (const group of groups) {
+    const chosen = await promptMultiSelectGroup(group, ui, { stdin, stdout });
+    selections[group.id] = chosen;
+  }
+
+  const content = buildPresetMarkdown(selections, locale, {
+    oneShot: options['persistent'] !== true,
+    advanced
+  });
+  const historyPath = path.join(historyDir, `${formatTimestamp()}.md`);
+  await ensureDir(path.dirname(presetPath));
+  await ensureDir(historyDir);
+  await fs.writeFile(presetPath, content, 'utf8');
+  await fs.writeFile(historyPath, content, 'utf8');
+
+  const summary = buildSummary(selections);
+  logger.log(`${ui.saved}\n`);
+  logger.log(`${ui.path}: ${path.relative(targetDir, presetPath)}\n`);
+  logger.log(`${ui.history}: ${path.relative(targetDir, historyPath)}\n`);
+  if (summary.length > 0) {
+    for (const line of summary) logger.log(`- ${line}`);
+    logger.log('');
+  }
+  logger.log(ui.promptReady);
+  logger.log('');
+  logger.log(buildPromptBlock(selections));
+
+  return {
+    ok: true,
+    targetDir,
+    locale,
+    localeSource,
+    projectLocale,
+    advanced,
+    modifierPolicy,
+    presetPath: path.relative(targetDir, presetPath),
+    historyPath: path.relative(targetDir, historyPath),
+    selections: Object.fromEntries(
+      Object.entries(selections)
+        .filter(([key]) => !key.startsWith('__'))
+        .map(([key, value]) => [
+          key,
+          Array.isArray(value) ? value.map((item) => item.id) : value
+        ])
+    )
+  };
+}
+
+module.exports = {
+  runDesignHybridOptions,
+  __test__: {
+    getUiText,
+    promptMultiSelectGroup,
+    buildPresetMarkdown,
+    buildPromptBlock,
+    buildSummary
+  }
+};

package/src/commands/health.js

@@ -0,0 +1,214 @@
+'use strict';
+
+const path = require('node:path');
+const fs = require('node:fs/promises');
+const { openRuntimeDb, listSquadLearnings, listProjectLearnings, listDynamicTools } = require('../runtime-store');
+
+const MIN_FREQUENCY = 2;
+const INACTIVITY_DAYS = 14;
+const EVOLUTION_DIR = path.join('.aioson', 'evolution');
+
+/**
+ * Verifica se há tools com handlers inválidos.
+ */
+async function checkBrokenTools(tools, projectDir) {
+  const broken = [];
+  for (const tool of tools) {
+    if (tool.handler_type === 'script' && tool.handler_path) {
+      const absPath = path.isAbsolute(tool.handler_path)
+        ? tool.handler_path
+        : path.resolve(projectDir, tool.handler_path);
+      try {
+        await fs.access(absPath);
+      } catch {
+        broken.push(tool.name);
+      }
+    }
+  }
+  return broken;
+}
+
+/**
+ * Conta learnings prontos para evoluir.
+ */
+function countEvolvablelearnings(db) {
+  const squadLearnings = listSquadLearnings(db, null, 'active').filter(
+    (l) => Number(l.frequency || 1) >= MIN_FREQUENCY
+  );
+  const projectLearnings = listProjectLearnings(db, 'active').filter(
+    (l) => Number(l.frequency || 1) >= MIN_FREQUENCY
+  );
+  return squadLearnings.length + projectLearnings.length;
+}
+
+/**
+ * Verifica squads inativos (sem sessão recente).
+ */
+function getInactiveSquads(db) {
+  const cutoff = new Date(Date.now() - INACTIVITY_DAYS * 24 * 60 * 60 * 1000).toISOString();
+  const rows = db.prepare(`
+    SELECT squad_slug, updated_at FROM squads
+    WHERE status = 'active' AND (updated_at IS NULL OR updated_at < ?)
+    ORDER BY updated_at ASC
+    LIMIT 5
+  `).all(cutoff);
+  return rows;
+}
+
+/**
+ * Conta arquivos pendentes de evolução.
+ */
+async function countPendingEvolutions(projectDir) {
+  const evolutionDir = path.resolve(projectDir, EVOLUTION_DIR);
+  try {
+    const files = await fs.readdir(evolutionDir);
+    return files.filter((f) => f.startsWith('pending-') && f.endsWith('.json')).length;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Comando principal: aioson health [project-dir]
+ */
+async function runHealth({ args = [], options = {}, logger = console } = {}) {
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+  const quiet = Boolean(options.quiet);
+  const json = Boolean(options.json);
+
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+
+  const report = {
+    ok: true,
+    projectDir,
+    items: [],
+    evolvableLearnings: 0,
+    brokenTools: [],
+    inactiveSquads: [],
+    pendingEvolutions: 0,
+    hasRuntimeStore: Boolean(handle)
+  };
+
+  if (!handle) {
+    if (!json && !quiet) {
+      logger.log('AIOSON Health — nenhum runtime store encontrado neste projeto.');
+      logger.log('Execute: aioson runtime:init .');
+    }
+    return report;
+  }
+
+  const { db } = handle;
+
+  try {
+    // 1. Learnings evoluíveis
+    report.evolvableLearnings = countEvolvablelearnings(db);
+    if (report.evolvableLearnings > 0) {
+      report.items.push({
+        type: 'learnings',
+        level: 'info',
+        message: `${report.evolvableLearnings} learning(s) prontos para evoluir`,
+        action: 'aioson learning:evolve .'
+      });
+    }
+
+    // 2. Squads inativos
+    const inactiveSquads = getInactiveSquads(db);
+    report.inactiveSquads = inactiveSquads.map((s) => s.squad_slug);
+    if (inactiveSquads.length > 0) {
+      for (const squad of inactiveSquads) {
+        const days = squad.updated_at
+          ? Math.floor((Date.now() - new Date(squad.updated_at).getTime()) / (1000 * 60 * 60 * 24))
+          : '?';
+        report.items.push({
+          type: 'squad_inactive',
+          level: 'warn',
+          message: `Squad "${squad.squad_slug}" inativo há ${days} dia(s)`,
+          action: null
+        });
+      }
+    }
+
+    // 3. Dynamic tools com handlers quebrados
+    const tools = listDynamicTools(db, null);
+    const broken = await checkBrokenTools(tools, projectDir);
+    report.brokenTools = broken;
+    if (broken.length > 0) {
+      report.items.push({
+        type: 'broken_tools',
+        level: 'error',
+        message: `${broken.length} tool(s) com handler inválido: ${broken.join(', ')}`,
+        action: 'aioson tool:unregister . --name=<nome>'
+      });
+    }
+
+    // 4. Evoluções pendentes
+    report.pendingEvolutions = await countPendingEvolutions(projectDir);
+    if (report.pendingEvolutions > 0) {
+      report.items.push({
+        type: 'pending_evolutions',
+        level: 'info',
+        message: `${report.pendingEvolutions} proposta(s) de evolução aguardando revisão`,
+        action: `aioson learning:apply . --file=.aioson/evolution/pending-XXX.json`
+      });
+    }
+  } finally {
+    db.close();
+  }
+
+  if (json) return report;
+
+  // Output formatado
+  if (report.items.length === 0) {
+    if (!quiet) logger.log('AIOSON Health — tudo em ordem. Nenhum item pendente.');
+    return report;
+  }
+
+  logger.log('');
+  logger.log('AIOSON Health — itens que precisam de atenção:');
+  logger.log('');
+
+  const icons = { info: '●', warn: '○', error: '✗' };
+  for (const item of report.items) {
+    const icon = icons[item.level] || '●';
+    logger.log(`  ${icon} ${item.message}`);
+    if (item.action) logger.log(`    → ${item.action}`);
+  }
+  logger.log('');
+
+  return report;
+}
+
+/**
+ * Versão compacta para injeção silenciosa no live:start e live:close.
+ * Retorna string de aviso ou null se tudo ok.
+ */
+async function getHealthDigest(projectDir) {
+  try {
+    const handle = await openRuntimeDb(projectDir, { mustExist: true });
+    if (!handle) return null;
+
+    const { db } = handle;
+    const items = [];
+
+    try {
+      const count = countEvolvablelearnings(db);
+      if (count > 0) items.push(`${count} learning(s) prontos para evoluir`);
+
+      const tools = listDynamicTools(db, null);
+      const broken = await checkBrokenTools(tools, projectDir);
+      if (broken.length > 0) items.push(`${broken.length} tool(s) com handler quebrado`);
+
+      const pending = await countPendingEvolutions(projectDir);
+      if (pending > 0) items.push(`${pending} evolução(ões) pendente(s)`);
+    } finally {
+      db.close();
+    }
+
+    if (items.length === 0) return null;
+    return items;
+  } catch {
+    return null;
+  }
+}
+
+module.exports = { runHealth, getHealthDigest };