kodelyth-ecc 1.2.0

package/scripts/skills-health.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+'use strict';
+
+const { collectSkillHealth, formatHealthReport } = require('./lib/skill-evolution/health');
+const { renderDashboard } = require('./lib/skill-evolution/dashboard');
+
+function showHelp() {
+  console.log(`
+Usage: node scripts/skills-health.js [options]
+
+Options:
+  --json                  Emit machine-readable JSON
+  --skills-root <path>    Override curated skills root
+  --learned-root <path>   Override learned skills root
+  --imported-root <path>  Override imported skills root
+  --home <path>           Override home directory for learned/imported skill roots
+  --runs-file <path>      Override skill run JSONL path
+  --now <timestamp>       Override current time for deterministic reports
+  --dashboard             Show rich health dashboard with charts
+  --panel <name>          Show only a specific panel (success-rate, failures, amendments, versions)
+  --warn-threshold <n>    Decline sensitivity threshold (default: 0.1)
+  --help                  Show this help text
+`);
+}
+
+function requireValue(argv, index, argName) {
+  const value = argv[index + 1];
+  if (!value || value.startsWith('--')) {
+    throw new Error(`Missing value for ${argName}`);
+  }
+
+  return value;
+}
+
+function parseArgs(argv) {
+  const options = {};
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+
+    if (arg === '--json') {
+      options.json = true;
+      continue;
+    }
+
+    if (arg === '--help' || arg === '-h') {
+      options.help = true;
+      continue;
+    }
+
+    if (arg === '--skills-root') {
+      options.skillsRoot = requireValue(argv, index, '--skills-root');
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--learned-root') {
+      options.learnedRoot = requireValue(argv, index, '--learned-root');
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--imported-root') {
+      options.importedRoot = requireValue(argv, index, '--imported-root');
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--home') {
+      options.homeDir = requireValue(argv, index, '--home');
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--runs-file') {
+      options.runsFilePath = requireValue(argv, index, '--runs-file');
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--now') {
+      options.now = requireValue(argv, index, '--now');
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--warn-threshold') {
+      options.warnThreshold = Number(requireValue(argv, index, '--warn-threshold'));
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--dashboard') {
+      options.dashboard = true;
+      continue;
+    }
+
+    if (arg === '--panel') {
+      options.panel = requireValue(argv, index, '--panel');
+      index += 1;
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return options;
+}
+
+function main() {
+  try {
+    const options = parseArgs(process.argv.slice(2));
+
+    if (options.help) {
+      showHelp();
+      process.exit(0);
+    }
+
+    if (options.dashboard || options.panel) {
+      const result = renderDashboard(options);
+      process.stdout.write(options.json ? `${JSON.stringify(result.data, null, 2)}\n` : result.text);
+    } else {
+      const report = collectSkillHealth(options);
+      process.stdout.write(formatHealthReport(report, { json: options.json }));
+    }
+  } catch (error) {
+    process.stderr.write(`Error: ${error.message}\n`);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/status.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+'use strict';
+
+const os = require('os');
+const { createStateStore } = require('./lib/state-store');
+
+function showHelp(exitCode = 0) {
+  console.log(`
+Usage: node scripts/status.js [--db <path>] [--json] [--limit <n>]
+
+Query the ECC SQLite state store for active sessions, recent skill runs,
+install health, and pending governance events.
+`);
+  process.exit(exitCode);
+}
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const parsed = {
+    dbPath: null,
+    json: false,
+    help: false,
+    limit: 5,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === '--db') {
+      parsed.dbPath = args[index + 1] || null;
+      index += 1;
+    } else if (arg === '--json') {
+      parsed.json = true;
+    } else if (arg === '--limit') {
+      parsed.limit = args[index + 1] || null;
+      index += 1;
+    } else if (arg === '--help' || arg === '-h') {
+      parsed.help = true;
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+
+  return parsed;
+}
+
+function printActiveSessions(section) {
+  console.log(`Active sessions: ${section.activeCount}`);
+  if (section.sessions.length === 0) {
+    console.log('  - none');
+    return;
+  }
+
+  for (const session of section.sessions) {
+    console.log(`  - ${session.id} [${session.harness}/${session.adapterId}] ${session.state}`);
+    console.log(`    Repo: ${session.repoRoot || '(unknown)'}`);
+    console.log(`    Started: ${session.startedAt || '(unknown)'}`);
+    console.log(`    Workers: ${session.workerCount}`);
+  }
+}
+
+function printSkillRuns(section) {
+  const summary = section.summary;
+  const successRate = summary.successRate === null ? 'n/a' : `${summary.successRate}%`;
+  const failureRate = summary.failureRate === null ? 'n/a' : `${summary.failureRate}%`;
+
+  console.log(`Skill runs (last ${section.windowSize}):`);
+  console.log(`  Success: ${summary.successCount}`);
+  console.log(`  Failure: ${summary.failureCount}`);
+  console.log(`  Unknown: ${summary.unknownCount}`);
+  console.log(`  Success rate: ${successRate}`);
+  console.log(`  Failure rate: ${failureRate}`);
+
+  if (section.recent.length === 0) {
+    console.log('  Recent runs: none');
+    return;
+  }
+
+  console.log('  Recent runs:');
+  for (const skillRun of section.recent.slice(0, 5)) {
+    console.log(`  - ${skillRun.id} ${skillRun.outcome} ${skillRun.skillId}@${skillRun.skillVersion}`);
+  }
+}
+
+function printInstallHealth(section) {
+  console.log(`Install health: ${section.status}`);
+  console.log(`  Targets recorded: ${section.totalCount}`);
+  console.log(`  Healthy: ${section.healthyCount}`);
+  console.log(`  Warning: ${section.warningCount}`);
+
+  if (section.installations.length === 0) {
+    console.log('  Installations: none');
+    return;
+  }
+
+  console.log('  Installations:');
+  for (const installation of section.installations.slice(0, 5)) {
+    console.log(`  - ${installation.targetId} ${installation.status}`);
+    console.log(`    Root: ${installation.targetRoot}`);
+    console.log(`    Profile: ${installation.profile || '(custom)'}`);
+    console.log(`    Modules: ${installation.moduleCount}`);
+    console.log(`    Source version: ${installation.sourceVersion || '(unknown)'}`);
+  }
+}
+
+function printGovernance(section) {
+  console.log(`Pending governance events: ${section.pendingCount}`);
+  if (section.events.length === 0) {
+    console.log('  - none');
+    return;
+  }
+
+  for (const event of section.events) {
+    console.log(`  - ${event.id} ${event.eventType}`);
+    console.log(`    Session: ${event.sessionId || '(none)'}`);
+    console.log(`    Created: ${event.createdAt}`);
+  }
+}
+
+function printHuman(payload) {
+  console.log('ECC status\n');
+  console.log(`Database: ${payload.dbPath}\n`);
+  printActiveSessions(payload.activeSessions);
+  console.log();
+  printSkillRuns(payload.skillRuns);
+  console.log();
+  printInstallHealth(payload.installHealth);
+  console.log();
+  printGovernance(payload.governance);
+}
+
+async function main() {
+  let store = null;
+
+  try {
+    const options = parseArgs(process.argv);
+    if (options.help) {
+      showHelp(0);
+    }
+
+    store = await createStateStore({
+      dbPath: options.dbPath,
+      homeDir: process.env.HOME || os.homedir(),
+    });
+
+    const payload = {
+      dbPath: store.dbPath,
+      ...store.getStatus({
+        activeLimit: options.limit,
+        recentSkillRunLimit: 20,
+        pendingLimit: options.limit,
+      }),
+    };
+
+    if (options.json) {
+      console.log(JSON.stringify(payload, null, 2));
+    } else {
+      printHuman(payload);
+    }
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  } finally {
+    if (store) {
+      store.close();
+    }
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  main,
+  parseArgs,
+};