aw-ecc 1.4.21

package/scripts/lib/skill-evolution/dashboard.js

@@ -0,0 +1,401 @@
+'use strict';
+
+const health = require('./health');
+const tracker = require('./tracker');
+const versioning = require('./versioning');
+
+const DAY_IN_MS = 24 * 60 * 60 * 1000;
+const SPARKLINE_CHARS = '\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588';
+const EMPTY_BLOCK = '\u2591';
+const FILL_BLOCK = '\u2588';
+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('\u250C\u2500 ' + title + ' ' + '\u2500'.repeat(Math.max(0, innerWidth - title.length - 4)) + '\u2510');
+
+  for (const line of lines) {
+    const truncated = line.length > innerWidth - 2
+      ? line.slice(0, innerWidth - 2)
+      : line;
+    output.push('\u2502 ' + truncated.padEnd(innerWidth - 2) + '\u2502');
+  }
+
+  output.push('\u2514' + '\u2500'.repeat(innerWidth - 1) + '\u2518');
+  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 '\u2192';
+  }
+
+  const delta = successRate7d - successRate30d;
+  if (delta >= 0.1) {
+    return '\u2197';
+  }
+
+  if (delta <= -0.1) {
+    return '\u2198';
+  }
+
+  return '\u2192';
+}
+
+function formatPercent(value) {
+  if (value === null) {
+    return 'n/a';
+  }
+
+  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('No skill execution data available.');
+  } 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('Success Rate (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 || 'unknown').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('No failure patterns detected.');
+  } 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('Failure Patterns', 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('No pending amendments.');
+  } 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} amendment${amendments.length === 1 ? '' : 's'} pending review`);
+  }
+
+  return {
+    text: panelBox('Pending Amendments', 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('No version history available.');
+  } 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} \u2500\u2500 ${date} \u2500\u2500 ${reason}`);
+      }
+    }
+  }
+
+  return {
+    text: panelBox('Version History', 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(`Invalid now timestamp: ${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(`Unknown panel: ${selectedPanel}. Valid panels: ${Array.from(VALID_PANELS).join(', ')}`);
+  }
+
+  const panels = {};
+  const textParts = [];
+
+  const header = [
+    'ECC Skill Health Dashboard',
+    `Generated: ${now}`,
+    `Skills: ${summary.total_skills} total, ${summary.healthy_skills} healthy, ${summary.declining_skills} declining`,
+    '',
+  ];
+
+  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/scripts/lib/skill-evolution/health.js

@@ -0,0 +1,263 @@
+'use strict';
+
+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']));
+
+function roundRate(value) {
+  if (value === null) {
+    return null;
+  }
+
+  return Math.round(value * 10000) / 10000;
+}
+
+function formatRate(value) {
+  if (value === null) {
+    return 'n/a';
+  }
+
+  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(`Invalid now timestamp: ${now}`);
+  }
+
+  const warnThreshold = typeof options.warnThreshold === 'number'
+    ? options.warnThreshold
+    : Number(options.warnThreshold || 0.1);
+  if (!Number.isFinite(warnThreshold) || warnThreshold < 0) {
+    throw new Error(`Invalid warn threshold: ${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 [
+      'ECC skill health',
+      `Generated: ${report.generated_at}`,
+      '',
+      'No skill execution records found.',
+      '',
+    ].join('\n');
+  }
+
+  const lines = [
+    'ECC skill health',
+    `Generated: ${report.generated_at}`,
+    `Skills: ${summary.total_skills} total, ${summary.healthy_skills} healthy, ${summary.declining_skills} declining`,
+    '',
+    'skill            version   7d     30d    trend       pending   last run',
+    '--------------------------------------------------------------------------',
+  ];
+
+  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),
+      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,
+  calculateSuccessRate,
+  collectSkillHealth,
+  discoverSkills,
+  filterRecordsWithinDays,
+  formatHealthReport,
+  summarizeHealthReport,
+};

package/scripts/lib/skill-evolution/index.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const provenance = require('./provenance');
+const versioning = require('./versioning');
+const tracker = require('./tracker');
+const health = require('./health');
+const dashboard = require('./dashboard');
+
+module.exports = {
+  ...provenance,
+  ...versioning,
+  ...tracker,
+  ...health,
+  ...dashboard,
+  provenance,
+  versioning,
+  tracker,
+  health,
+  dashboard,
+};