theus-cli 0.2.83 → 0.2.84

package/vendor/theus-arsenal/scripts/lib/skill-evolution/dashboard.js

@@ -1,414 +0,0 @@
-'use strict';
-
-/**
- * Panel de salud de skills (arsenal de Theus).
- *
- * Renderiza cuatro paneles en texto plano con recuadros Unicode:
- *   - success-rate: sparklines de tasa de éxito diaria (30 días).
- *   - failures:     patrones de fallo agrupados con barras horizontales.
- *   - amendments:   enmiendas pendientes de revisión.
- *   - versions:     línea de tiempo de snapshots de versión por skill.
- *
- * Los nombres de panel se mantienen en inglés por ser identificadores de la
- * interfaz (--panel <nombre>); todos los textos visibles están en español.
- */
-
-const health = require('./health');
-const tracker = require('./tracker');
-const versioning = require('./versioning');
-
-const DAY_IN_MS = 24 * 60 * 60 * 1000;
-const SPARKLINE_CHARS = '▁▂▃▄▅▆▇█';
-const EMPTY_BLOCK = '░';
-const FILL_BLOCK = '█';
-const DEFAULT_PANEL_WIDTH = 64;
-const VALID_PANELS = new Set(['success-rate', 'failures', 'amendments', 'versions']);
-
-function sparkline(values) {
-  if (!Array.isArray(values) || values.length === 0) {
-    return '';
-  }
-
-  return values.map(value => {
-    if (value === null || value === undefined) {
-      return EMPTY_BLOCK;
-    }
-
-    const clamped = Math.max(0, Math.min(1, value));
-    const index = Math.min(Math.round(clamped * (SPARKLINE_CHARS.length - 1)), SPARKLINE_CHARS.length - 1);
-    return SPARKLINE_CHARS[index];
-  }).join('');
-}
-
-function horizontalBar(value, max, width) {
-  if (max <= 0 || width <= 0) {
-    return EMPTY_BLOCK.repeat(width || 0);
-  }
-
-  const filled = Math.round((Math.min(value, max) / max) * width);
-  const empty = width - filled;
-  return FILL_BLOCK.repeat(filled) + EMPTY_BLOCK.repeat(empty);
-}
-
-function panelBox(title, lines, width) {
-  const innerWidth = width || DEFAULT_PANEL_WIDTH;
-  const output = [];
-  output.push('┌─ ' + title + ' ' + '─'.repeat(Math.max(0, innerWidth - title.length - 4)) + '┐');
-
-  for (const line of lines) {
-    const truncated = line.length > innerWidth - 2
-      ? line.slice(0, innerWidth - 2)
-      : line;
-    output.push('│ ' + truncated.padEnd(innerWidth - 2) + '│');
-  }
-
-  output.push('└' + '─'.repeat(innerWidth - 1) + '┘');
-  return output.join('\n');
-}
-
-function bucketByDay(records, nowMs, days) {
-  const buckets = [];
-  for (let i = days - 1; i >= 0; i -= 1) {
-    const dayEnd = nowMs - (i * DAY_IN_MS);
-    const dayStart = dayEnd - DAY_IN_MS;
-    const dateStr = new Date(dayEnd).toISOString().slice(0, 10);
-    buckets.push({ date: dateStr, start: dayStart, end: dayEnd, records: [] });
-  }
-
-  for (const record of records) {
-    const recordMs = Date.parse(record.recorded_at);
-    if (Number.isNaN(recordMs)) {
-      continue;
-    }
-
-    for (const bucket of buckets) {
-      if (recordMs > bucket.start && recordMs <= bucket.end) {
-        bucket.records.push(record);
-        break;
-      }
-    }
-  }
-
-  return buckets.map(bucket => ({
-    date: bucket.date,
-    rate: bucket.records.length > 0
-      ? health.calculateSuccessRate(bucket.records)
-      : null,
-    runs: bucket.records.length,
-  }));
-}
-
-function getTrendArrow(successRate7d, successRate30d) {
-  if (successRate7d === null || successRate30d === null) {
-    return '→';
-  }
-
-  const delta = successRate7d - successRate30d;
-  if (delta >= 0.1) {
-    return '↗';
-  }
-
-  if (delta <= -0.1) {
-    return '↘';
-  }
-
-  return '→';
-}
-
-function formatPercent(value) {
-  if (value === null) {
-    return 'n/d';
-  }
-
-  return `${Math.round(value * 100)}%`;
-}
-
-function groupRecordsBySkill(records) {
-  return records.reduce((grouped, record) => {
-    const skillId = record.skill_id;
-    if (!grouped.has(skillId)) {
-      grouped.set(skillId, []);
-    }
-
-    grouped.get(skillId).push(record);
-    return grouped;
-  }, new Map());
-}
-
-function renderSuccessRatePanel(records, skills, options = {}) {
-  const nowMs = Date.parse(options.now || new Date().toISOString());
-  const days = options.days || 30;
-  const width = options.width || DEFAULT_PANEL_WIDTH;
-  const recordsBySkill = groupRecordsBySkill(records);
-
-  const skillData = [];
-  const skillIds = Array.from(new Set([
-    ...Array.from(recordsBySkill.keys()),
-    ...skills.map(s => s.skill_id),
-  ])).sort();
-
-  for (const skillId of skillIds) {
-    const skillRecords = recordsBySkill.get(skillId) || [];
-    const dailyRates = bucketByDay(skillRecords, nowMs, days);
-    const rateValues = dailyRates.map(b => b.rate);
-    const records7d = health.filterRecordsWithinDays(skillRecords, nowMs, 7);
-    const records30d = health.filterRecordsWithinDays(skillRecords, nowMs, 30);
-    const current7d = health.calculateSuccessRate(records7d);
-    const current30d = health.calculateSuccessRate(records30d);
-    const trend = getTrendArrow(current7d, current30d);
-
-    skillData.push({
-      skill_id: skillId,
-      daily_rates: dailyRates,
-      sparkline: sparkline(rateValues),
-      current_7d: current7d,
-      trend,
-    });
-  }
-
-  const lines = [];
-  if (skillData.length === 0) {
-    lines.push('Sin datos de ejecución de skills todavía.');
-  } else {
-    for (const skill of skillData) {
-      const nameCol = skill.skill_id.slice(0, 14).padEnd(14);
-      const sparkCol = skill.sparkline.slice(0, 30);
-      const rateCol = formatPercent(skill.current_7d).padStart(5);
-      lines.push(`${nameCol}  ${sparkCol}  ${rateCol} ${skill.trend}`);
-    }
-  }
-
-  return {
-    text: panelBox('Tasa de éxito (30d)', lines, width),
-    data: { skills: skillData },
-  };
-}
-
-function renderFailureClusterPanel(records, options = {}) {
-  const width = options.width || DEFAULT_PANEL_WIDTH;
-  const failures = records.filter(r => r.outcome === 'failure');
-
-  const clusterMap = new Map();
-  for (const record of failures) {
-    const reason = (record.failure_reason || 'desconocido').toLowerCase().trim();
-    if (!clusterMap.has(reason)) {
-      clusterMap.set(reason, { count: 0, skill_ids: new Set() });
-    }
-
-    const cluster = clusterMap.get(reason);
-    cluster.count += 1;
-    cluster.skill_ids.add(record.skill_id);
-  }
-
-  const clusters = Array.from(clusterMap.entries())
-    .map(([pattern, data]) => ({
-      pattern,
-      count: data.count,
-      skill_ids: Array.from(data.skill_ids).sort(),
-      percentage: failures.length > 0
-        ? Math.round((data.count / failures.length) * 100)
-        : 0,
-    }))
-    .sort((a, b) => b.count - a.count || a.pattern.localeCompare(b.pattern));
-
-  const maxCount = clusters.length > 0 ? clusters[0].count : 0;
-  const lines = [];
-
-  if (clusters.length === 0) {
-    lines.push('Sin patrones de fallo detectados.');
-  } else {
-    for (const cluster of clusters) {
-      const label = cluster.pattern.slice(0, 20).padEnd(20);
-      const bar = horizontalBar(cluster.count, maxCount, 16);
-      const skillCount = cluster.skill_ids.length;
-      const suffix = skillCount === 1 ? 'skill' : 'skills';
-      lines.push(`${label} ${bar} ${String(cluster.count).padStart(3)} (${skillCount} ${suffix})`);
-    }
-  }
-
-  return {
-    text: panelBox('Patrones de fallo', lines, width),
-    data: { clusters, total_failures: failures.length },
-  };
-}
-
-function renderAmendmentPanel(skillsById, options = {}) {
-  const width = options.width || DEFAULT_PANEL_WIDTH;
-  const amendments = [];
-
-  for (const [skillId, skill] of skillsById) {
-    if (!skill.skill_dir) {
-      continue;
-    }
-
-    const log = versioning.getEvolutionLog(skill.skill_dir, 'amendments');
-    for (const entry of log) {
-      const status = typeof entry.status === 'string' ? entry.status : null;
-      const isPending = status
-        ? health.PENDING_AMENDMENT_STATUSES.has(status)
-        : entry.event === 'proposal';
-
-      if (isPending) {
-        amendments.push({
-          skill_id: skillId,
-          event: entry.event || 'proposal',
-          status: status || 'pending',
-          created_at: entry.created_at || null,
-        });
-      }
-    }
-  }
-
-  amendments.sort((a, b) => {
-    const timeA = a.created_at ? Date.parse(a.created_at) : 0;
-    const timeB = b.created_at ? Date.parse(b.created_at) : 0;
-    return timeB - timeA;
-  });
-
-  const lines = [];
-  if (amendments.length === 0) {
-    lines.push('Sin enmiendas pendientes.');
-  } else {
-    for (const amendment of amendments) {
-      const name = amendment.skill_id.slice(0, 14).padEnd(14);
-      const event = amendment.event.padEnd(10);
-      const status = amendment.status.padEnd(10);
-      const time = amendment.created_at ? amendment.created_at.slice(0, 19) : '-';
-      lines.push(`${name} ${event} ${status} ${time}`);
-    }
-
-    lines.push('');
-    lines.push(`${amendments.length} enmienda${amendments.length === 1 ? '' : 's'} pendiente${amendments.length === 1 ? '' : 's'} de revisión`);
-  }
-
-  return {
-    text: panelBox('Enmiendas pendientes', lines, width),
-    data: { amendments, total: amendments.length },
-  };
-}
-
-function renderVersionTimelinePanel(skillsById, options = {}) {
-  const width = options.width || DEFAULT_PANEL_WIDTH;
-  const skillVersions = [];
-
-  for (const [skillId, skill] of skillsById) {
-    if (!skill.skill_dir) {
-      continue;
-    }
-
-    const versions = versioning.listVersions(skill.skill_dir);
-    if (versions.length === 0) {
-      continue;
-    }
-
-    const amendmentLog = versioning.getEvolutionLog(skill.skill_dir, 'amendments');
-    const reasonByVersion = new Map();
-    for (const entry of amendmentLog) {
-      if (entry.version && entry.reason) {
-        reasonByVersion.set(entry.version, entry.reason);
-      }
-    }
-
-    skillVersions.push({
-      skill_id: skillId,
-      versions: versions.map(v => ({
-        version: v.version,
-        created_at: v.created_at,
-        reason: reasonByVersion.get(v.version) || null,
-      })),
-    });
-  }
-
-  skillVersions.sort((a, b) => a.skill_id.localeCompare(b.skill_id));
-
-  const lines = [];
-  if (skillVersions.length === 0) {
-    lines.push('Sin historial de versiones disponible.');
-  } else {
-    for (const skill of skillVersions) {
-      lines.push(skill.skill_id);
-      for (const version of skill.versions) {
-        const date = version.created_at ? version.created_at.slice(0, 10) : '-';
-        const reason = version.reason || '-';
-        lines.push(`  v${version.version} ── ${date} ── ${reason}`);
-      }
-    }
-  }
-
-  return {
-    text: panelBox('Historial de versiones', lines, width),
-    data: { skills: skillVersions },
-  };
-}
-
-function renderDashboard(options = {}) {
-  const now = options.now || new Date().toISOString();
-  const nowMs = Date.parse(now);
-  if (Number.isNaN(nowMs)) {
-    throw new Error(`Marca de tiempo inválida para "now": ${now}`);
-  }
-
-  const dashboardOptions = { ...options, now };
-  const records = tracker.readSkillExecutionRecords(dashboardOptions);
-  const skillsById = health.discoverSkills(dashboardOptions);
-  const report = health.collectSkillHealth(dashboardOptions);
-  const summary = health.summarizeHealthReport(report);
-
-  const panelRenderers = {
-    'success-rate': () => renderSuccessRatePanel(records, report.skills, dashboardOptions),
-    'failures': () => renderFailureClusterPanel(records, dashboardOptions),
-    'amendments': () => renderAmendmentPanel(skillsById, dashboardOptions),
-    'versions': () => renderVersionTimelinePanel(skillsById, dashboardOptions),
-  };
-
-  const selectedPanel = options.panel || null;
-  if (selectedPanel && !VALID_PANELS.has(selectedPanel)) {
-    throw new Error(`Panel desconocido: ${selectedPanel}. Paneles válidos: ${Array.from(VALID_PANELS).join(', ')}`);
-  }
-
-  const panels = {};
-  const textParts = [];
-
-  const header = [
-    'Panel de salud de skills de Theus',
-    `Generado: ${now}`,
-    `Skills: ${summary.total_skills} en total, ${summary.healthy_skills} saludables, ${summary.declining_skills} en declive`,
-    '',
-  ];
-
-  textParts.push(header.join('\n'));
-
-  if (selectedPanel) {
-    const result = panelRenderers[selectedPanel]();
-    panels[selectedPanel] = result.data;
-    textParts.push(result.text);
-  } else {
-    for (const [panelName, renderer] of Object.entries(panelRenderers)) {
-      const result = renderer();
-      panels[panelName] = result.data;
-      textParts.push(result.text);
-    }
-  }
-
-  const text = textParts.join('\n\n') + '\n';
-  const data = {
-    generated_at: now,
-    summary,
-    panels,
-  };
-
-  return { text, data };
-}
-
-module.exports = {
-  VALID_PANELS,
-  bucketByDay,
-  horizontalBar,
-  panelBox,
-  renderAmendmentPanel,
-  renderDashboard,
-  renderFailureClusterPanel,
-  renderSuccessRatePanel,
-  renderVersionTimelinePanel,
-  sparkline,
-};

package/vendor/theus-arsenal/scripts/lib/skill-evolution/health.js

@@ -1,285 +0,0 @@
-'use strict';
-
-/**
- * Cálculo de salud del portafolio de skills (arsenal de Theus).
- *
- * Cruza los registros de ejecución (tracker) con las skills descubiertas en
- * las raíces curated/learned/imported (provenance) y el estado de versionado
- * (versioning) para producir un informe de tasas de éxito, tendencias y
- * enmiendas pendientes. Sin datos, degrada con gracia a un informe vacío.
- *
- * Nota: los valores del JSON (outcome, failure_trend, skill_type…) se
- * mantienen en inglés por ser identificadores legibles por máquina; la
- * salida visible para el usuario se traduce al formatear.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const provenance = require('./provenance');
-const tracker = require('./tracker');
-const versioning = require('./versioning');
-
-const DAY_IN_MS = 24 * 60 * 60 * 1000;
-const PENDING_AMENDMENT_STATUSES = Object.freeze(new Set(['pending', 'proposed', 'queued', 'open']));
-
-const TREND_LABELS_ES = Object.freeze({
-  worsening: 'en declive',
-  improving: 'mejorando',
-  stable: 'estable',
-});
-
-function roundRate(value) {
-  if (value === null) {
-    return null;
-  }
-
-  return Math.round(value * 10000) / 10000;
-}
-
-function formatRate(value) {
-  if (value === null) {
-    return 'n/d';
-  }
-
-  return `${Math.round(value * 100)}%`;
-}
-
-function summarizeHealthReport(report) {
-  const totalSkills = report.skills.length;
-  const decliningSkills = report.skills.filter(skill => skill.declining).length;
-  const healthySkills = totalSkills - decliningSkills;
-
-  return {
-    total_skills: totalSkills,
-    healthy_skills: healthySkills,
-    declining_skills: decliningSkills,
-  };
-}
-
-function listSkillsInRoot(rootPath) {
-  if (!rootPath || !fs.existsSync(rootPath)) {
-    return [];
-  }
-
-  return fs.readdirSync(rootPath, { withFileTypes: true })
-    .filter(entry => entry.isDirectory())
-    .map(entry => ({
-      skill_id: entry.name,
-      skill_dir: path.join(rootPath, entry.name),
-    }))
-    .filter(entry => fs.existsSync(path.join(entry.skill_dir, 'SKILL.md')));
-}
-
-function discoverSkills(options = {}) {
-  const roots = provenance.getSkillRoots(options);
-  const discoveredSkills = [
-    ...listSkillsInRoot(options.skillsRoot || roots.curated).map(skill => ({
-      ...skill,
-      skill_type: provenance.SKILL_TYPES.CURATED,
-    })),
-    ...listSkillsInRoot(options.learnedRoot || roots.learned).map(skill => ({
-      ...skill,
-      skill_type: provenance.SKILL_TYPES.LEARNED,
-    })),
-    ...listSkillsInRoot(options.importedRoot || roots.imported).map(skill => ({
-      ...skill,
-      skill_type: provenance.SKILL_TYPES.IMPORTED,
-    })),
-  ];
-
-  return discoveredSkills.reduce((skillsById, skill) => {
-    if (!skillsById.has(skill.skill_id)) {
-      skillsById.set(skill.skill_id, skill);
-    }
-    return skillsById;
-  }, new Map());
-}
-
-function calculateSuccessRate(records) {
-  if (records.length === 0) {
-    return null;
-  }
-
-  const successfulRecords = records.filter(record => record.outcome === 'success').length;
-  return roundRate(successfulRecords / records.length);
-}
-
-function filterRecordsWithinDays(records, nowMs, days) {
-  const cutoff = nowMs - (days * DAY_IN_MS);
-  return records.filter(record => {
-    const recordedAtMs = Date.parse(record.recorded_at);
-    return !Number.isNaN(recordedAtMs) && recordedAtMs >= cutoff && recordedAtMs <= nowMs;
-  });
-}
-
-function getFailureTrend(successRate7d, successRate30d, warnThreshold) {
-  if (successRate7d === null || successRate30d === null) {
-    return 'stable';
-  }
-
-  const delta = roundRate(successRate7d - successRate30d);
-  if (delta <= (-1 * warnThreshold)) {
-    return 'worsening';
-  }
-
-  if (delta >= warnThreshold) {
-    return 'improving';
-  }
-
-  return 'stable';
-}
-
-function countPendingAmendments(skillDir) {
-  if (!skillDir) {
-    return 0;
-  }
-
-  return versioning.getEvolutionLog(skillDir, 'amendments')
-    .filter(entry => {
-      if (typeof entry.status === 'string') {
-        return PENDING_AMENDMENT_STATUSES.has(entry.status);
-      }
-
-      return entry.event === 'proposal';
-    })
-    .length;
-}
-
-function getLastRun(records) {
-  if (records.length === 0) {
-    return null;
-  }
-
-  return records
-    .map(record => ({
-      timestamp: record.recorded_at,
-      timeMs: Date.parse(record.recorded_at),
-    }))
-    .filter(entry => !Number.isNaN(entry.timeMs))
-    .sort((left, right) => left.timeMs - right.timeMs)
-    .at(-1)?.timestamp || null;
-}
-
-function collectSkillHealth(options = {}) {
-  const now = options.now || new Date().toISOString();
-  const nowMs = Date.parse(now);
-  if (Number.isNaN(nowMs)) {
-    throw new Error(`Marca de tiempo inválida para "now": ${now}`);
-  }
-
-  const warnThreshold = typeof options.warnThreshold === 'number'
-    ? options.warnThreshold
-    : Number(options.warnThreshold || 0.1);
-  if (!Number.isFinite(warnThreshold) || warnThreshold < 0) {
-    throw new Error(`Umbral de aviso inválido: ${options.warnThreshold}`);
-  }
-
-  const records = tracker.readSkillExecutionRecords(options);
-  const skillsById = discoverSkills(options);
-  const recordsBySkill = records.reduce((groupedRecords, record) => {
-    if (!groupedRecords.has(record.skill_id)) {
-      groupedRecords.set(record.skill_id, []);
-    }
-
-    groupedRecords.get(record.skill_id).push(record);
-    return groupedRecords;
-  }, new Map());
-
-  for (const skillId of recordsBySkill.keys()) {
-    if (!skillsById.has(skillId)) {
-      skillsById.set(skillId, {
-        skill_id: skillId,
-        skill_dir: null,
-        skill_type: provenance.SKILL_TYPES.UNKNOWN,
-      });
-    }
-  }
-
-  const skills = Array.from(skillsById.values())
-    .sort((left, right) => left.skill_id.localeCompare(right.skill_id))
-    .map(skill => {
-      const skillRecords = recordsBySkill.get(skill.skill_id) || [];
-      const records7d = filterRecordsWithinDays(skillRecords, nowMs, 7);
-      const records30d = filterRecordsWithinDays(skillRecords, nowMs, 30);
-      const successRate7d = calculateSuccessRate(records7d);
-      const successRate30d = calculateSuccessRate(records30d);
-      const currentVersionNumber = skill.skill_dir ? versioning.getCurrentVersion(skill.skill_dir) : 0;
-      const failureTrend = getFailureTrend(successRate7d, successRate30d, warnThreshold);
-
-      return {
-        skill_id: skill.skill_id,
-        skill_type: skill.skill_type,
-        current_version: currentVersionNumber > 0 ? `v${currentVersionNumber}` : null,
-        pending_amendments: countPendingAmendments(skill.skill_dir),
-        success_rate_7d: successRate7d,
-        success_rate_30d: successRate30d,
-        failure_trend: failureTrend,
-        declining: failureTrend === 'worsening',
-        last_run: getLastRun(skillRecords),
-        run_count_7d: records7d.length,
-        run_count_30d: records30d.length,
-      };
-    });
-
-  return {
-    generated_at: now,
-    warn_threshold: warnThreshold,
-    skills,
-  };
-}
-
-function formatHealthReport(report, options = {}) {
-  if (options.json) {
-    return `${JSON.stringify(report, null, 2)}\n`;
-  }
-
-  const summary = summarizeHealthReport(report);
-
-  if (!report.skills.length) {
-    return [
-      'Salud de skills de Theus',
-      `Generado: ${report.generated_at}`,
-      '',
-      'No se encontraron skills ni registros de ejecución todavía.',
-      'Las métricas se acumulan en ~/.theus/arsenal/ conforme se usan las skills.',
-      '',
-    ].join('\n');
-  }
-
-  const lines = [
-    'Salud de skills de Theus',
-    `Generado: ${report.generated_at}`,
-    `Skills: ${summary.total_skills} en total, ${summary.healthy_skills} saludables, ${summary.declining_skills} en declive`,
-    '',
-    'skill            versión   7d     30d    tendencia   pend.     última ejecución',
-    '--------------------------------------------------------------------------------',
-  ];
-
-  for (const skill of report.skills) {
-    const statusLabel = skill.declining ? '!' : ' ';
-    lines.push([
-      `${statusLabel}${skill.skill_id}`.padEnd(16),
-      String(skill.current_version || '-').padEnd(9),
-      formatRate(skill.success_rate_7d).padEnd(6),
-      formatRate(skill.success_rate_30d).padEnd(6),
-      (TREND_LABELS_ES[skill.failure_trend] || skill.failure_trend).padEnd(11),
-      String(skill.pending_amendments).padEnd(9),
-      skill.last_run || '-',
-    ].join(' '));
-  }
-
-  return `${lines.join('\n')}\n`;
-}
-
-module.exports = {
-  PENDING_AMENDMENT_STATUSES,
-  TREND_LABELS_ES,
-  calculateSuccessRate,
-  collectSkillHealth,
-  discoverSkills,
-  filterRecordsWithinDays,
-  formatHealthReport,
-  formatRate,
-  summarizeHealthReport,
-};