theus-cli-linux-x64 1.2.2 → 1.4.0

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

@@ -1,22 +0,0 @@
-'use strict';
-
-// Punto de entrada del módulo de evolución de skills del arsenal de Theus.
-
-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,
-};

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

@@ -1,200 +0,0 @@
-'use strict';
-
-/**
- * Procedencia de skills del arsenal de Theus.
- *
- * Clasifica cada skill según su raíz de origen:
- *   - curated:  skills/ del propio plugin (curadas por Theus).
- *   - learned:  <raíz de datos>/skills/learned (generadas por /aprender).
- *   - imported: <raíz de datos>/skills/imported (importadas por el usuario).
- *
- * La raíz de datos es ~/.theus/arsenal (ver scripts/lib/agent-data-home.js).
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const { ensureDir } = require('../utils');
-const { resolveAgentDataHome } = require('../agent-data-home');
-
-const PROVENANCE_FILE_NAME = '.provenance.json';
-const SKILL_TYPES = Object.freeze({
-  CURATED: 'curated',
-  LEARNED: 'learned',
-  IMPORTED: 'imported',
-  UNKNOWN: 'unknown',
-});
-
-function resolveRepoRoot(repoRoot) {
-  if (repoRoot) {
-    return path.resolve(repoRoot);
-  }
-
-  // scripts/lib/skill-evolution → raíz del plugin theus-arsenal.
-  return path.resolve(__dirname, '..', '..', '..');
-}
-
-function resolveDataHome(options = {}) {
-  // `homeDir`/`--home` sobrescribe la raíz de datos del arsenal para pruebas.
-  return options.homeDir ? path.resolve(options.homeDir) : resolveAgentDataHome();
-}
-
-function normalizeSkillDir(skillPath) {
-  if (!skillPath || typeof skillPath !== 'string') {
-    throw new Error('skillPath es obligatorio');
-  }
-
-  const resolvedPath = path.resolve(skillPath);
-  if (path.basename(resolvedPath) === 'SKILL.md') {
-    return path.dirname(resolvedPath);
-  }
-
-  return resolvedPath;
-}
-
-function isWithinRoot(targetPath, rootPath) {
-  const relativePath = path.relative(rootPath, targetPath);
-  return relativePath === '' || (
-    !relativePath.startsWith('..')
-    && !path.isAbsolute(relativePath)
-  );
-}
-
-function getSkillRoots(options = {}) {
-  const repoRoot = resolveRepoRoot(options.repoRoot);
-  const dataHome = resolveDataHome(options);
-
-  return {
-    curated: path.join(repoRoot, 'skills'),
-    learned: path.join(dataHome, 'skills', 'learned'),
-    imported: path.join(dataHome, 'skills', 'imported'),
-  };
-}
-
-function classifySkillPath(skillPath, options = {}) {
-  const skillDir = normalizeSkillDir(skillPath);
-  const roots = getSkillRoots(options);
-
-  if (isWithinRoot(skillDir, roots.curated)) {
-    return SKILL_TYPES.CURATED;
-  }
-
-  if (isWithinRoot(skillDir, roots.learned)) {
-    return SKILL_TYPES.LEARNED;
-  }
-
-  if (isWithinRoot(skillDir, roots.imported)) {
-    return SKILL_TYPES.IMPORTED;
-  }
-
-  return SKILL_TYPES.UNKNOWN;
-}
-
-function requiresProvenance(skillPath, options = {}) {
-  const skillType = classifySkillPath(skillPath, options);
-  return skillType === SKILL_TYPES.LEARNED || skillType === SKILL_TYPES.IMPORTED;
-}
-
-function getProvenancePath(skillPath) {
-  return path.join(normalizeSkillDir(skillPath), PROVENANCE_FILE_NAME);
-}
-
-function isIsoTimestamp(value) {
-  if (typeof value !== 'string' || value.trim().length === 0) {
-    return false;
-  }
-
-  const timestamp = Date.parse(value);
-  return !Number.isNaN(timestamp);
-}
-
-function validateProvenance(record) {
-  const errors = [];
-
-  if (!record || typeof record !== 'object' || Array.isArray(record)) {
-    errors.push('el registro de procedencia debe ser un objeto');
-    return {
-      valid: false,
-      errors,
-    };
-  }
-
-  if (typeof record.source !== 'string' || record.source.trim().length === 0) {
-    errors.push('source es obligatorio');
-  }
-
-  if (!isIsoTimestamp(record.created_at)) {
-    errors.push('created_at debe ser una marca de tiempo ISO');
-  }
-
-  if (typeof record.confidence !== 'number' || Number.isNaN(record.confidence)) {
-    errors.push('confidence debe ser un número');
-  } else if (record.confidence < 0 || record.confidence > 1) {
-    errors.push('confidence debe estar entre 0 y 1');
-  }
-
-  if (typeof record.author !== 'string' || record.author.trim().length === 0) {
-    errors.push('author es obligatorio');
-  }
-
-  return {
-    valid: errors.length === 0,
-    errors,
-  };
-}
-
-function assertValidProvenance(record) {
-  const validation = validateProvenance(record);
-  if (!validation.valid) {
-    throw new Error(`Metadatos de procedencia inválidos: ${validation.errors.join('; ')}`);
-  }
-}
-
-function readProvenance(skillPath, options = {}) {
-  const skillDir = normalizeSkillDir(skillPath);
-  const provenancePath = getProvenancePath(skillDir);
-  const provenanceRequired = options.required === true || requiresProvenance(skillDir, options);
-
-  if (!fs.existsSync(provenancePath)) {
-    if (provenanceRequired) {
-      throw new Error(`Faltan metadatos de procedencia para ${skillDir}`);
-    }
-
-    return null;
-  }
-
-  const record = JSON.parse(fs.readFileSync(provenancePath, 'utf8'));
-  assertValidProvenance(record);
-  return record;
-}
-
-function writeProvenance(skillPath, record, options = {}) {
-  const skillDir = normalizeSkillDir(skillPath);
-
-  if (!requiresProvenance(skillDir, options)) {
-    throw new Error(`Los metadatos de procedencia solo aplican a skills aprendidas o importadas: ${skillDir}`);
-  }
-
-  assertValidProvenance(record);
-
-  const provenancePath = getProvenancePath(skillDir);
-  ensureDir(skillDir);
-  fs.writeFileSync(provenancePath, `${JSON.stringify(record, null, 2)}\n`, 'utf8');
-
-  return {
-    path: provenancePath,
-    record: { ...record },
-  };
-}
-
-module.exports = {
-  PROVENANCE_FILE_NAME,
-  SKILL_TYPES,
-  classifySkillPath,
-  getProvenancePath,
-  getSkillRoots,
-  readProvenance,
-  requiresProvenance,
-  validateProvenance,
-  writeProvenance,
-};

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

@@ -1,157 +0,0 @@
-'use strict';
-
-/**
- * Registro de ejecuciones de skills (métricas del arsenal de Theus).
- *
- * Los registros se persisten en formato JSONL bajo la raíz de datos del
- * arsenal: <raíz de datos>/state/skill-runs.jsonl (por defecto,
- * ~/.theus/arsenal/state/skill-runs.jsonl). Si el archivo no existe todavía
- * (ningún hook lo ha escrito aún), la lectura devuelve una lista vacía en
- * lugar de fallar: la analítica es siempre de mejor esfuerzo.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const { appendFile } = require('../utils');
-const { resolveAgentDataHome } = require('../agent-data-home');
-
-const VALID_OUTCOMES = new Set(['success', 'failure', 'partial']);
-const VALID_FEEDBACK = new Set(['accepted', 'corrected', 'rejected']);
-
-function resolveDataHome(options = {}) {
-  // `homeDir`/`--home` sobrescribe la raíz de datos del arsenal para pruebas.
-  return options.homeDir ? path.resolve(options.homeDir) : resolveAgentDataHome();
-}
-
-function getRunsFilePath(options = {}) {
-  if (options.runsFilePath) {
-    return path.resolve(options.runsFilePath);
-  }
-
-  return path.join(resolveDataHome(options), 'state', 'skill-runs.jsonl');
-}
-
-function toNullableNumber(value, fieldName) {
-  if (value === null || typeof value === 'undefined') {
-    return null;
-  }
-
-  const numericValue = Number(value);
-  if (!Number.isFinite(numericValue)) {
-    throw new Error(`${fieldName} debe ser un número`);
-  }
-
-  return numericValue;
-}
-
-function normalizeExecutionRecord(input, options = {}) {
-  if (!input || typeof input !== 'object' || Array.isArray(input)) {
-    throw new Error('el payload de ejecución de skill debe ser un objeto');
-  }
-
-  const skillId = input.skill_id || input.skillId;
-  const skillVersion = input.skill_version || input.skillVersion;
-  const taskDescription = input.task_description || input.task_attempted || input.taskAttempted;
-  const outcome = input.outcome;
-  const recordedAt = input.recorded_at || options.now || new Date().toISOString();
-  const userFeedback = input.user_feedback || input.userFeedback || null;
-
-  if (typeof skillId !== 'string' || skillId.trim().length === 0) {
-    throw new Error('skill_id es obligatorio');
-  }
-
-  if (typeof skillVersion !== 'string' || skillVersion.trim().length === 0) {
-    throw new Error('skill_version es obligatorio');
-  }
-
-  if (typeof taskDescription !== 'string' || taskDescription.trim().length === 0) {
-    throw new Error('task_description es obligatorio');
-  }
-
-  if (!VALID_OUTCOMES.has(outcome)) {
-    throw new Error('outcome debe ser success, failure o partial');
-  }
-
-  if (userFeedback !== null && !VALID_FEEDBACK.has(userFeedback)) {
-    throw new Error('user_feedback debe ser accepted, corrected, rejected o null');
-  }
-
-  if (Number.isNaN(Date.parse(recordedAt))) {
-    throw new Error('recorded_at debe ser una marca de tiempo ISO');
-  }
-
-  return {
-    skill_id: skillId,
-    skill_version: skillVersion,
-    task_description: taskDescription,
-    outcome,
-    failure_reason: input.failure_reason || input.failureReason || null,
-    tokens_used: toNullableNumber(input.tokens_used ?? input.tokensUsed, 'tokens_used'),
-    duration_ms: toNullableNumber(input.duration_ms ?? input.durationMs, 'duration_ms'),
-    user_feedback: userFeedback,
-    recorded_at: recordedAt,
-  };
-}
-
-function readJsonl(filePath) {
-  if (!fs.existsSync(filePath)) {
-    return [];
-  }
-
-  return fs.readFileSync(filePath, 'utf8')
-    .split('\n')
-    .map(line => line.trim())
-    .filter(Boolean)
-    .reduce((rows, line) => {
-      try {
-        rows.push(JSON.parse(line));
-      } catch {
-        // Se ignoran las filas malformadas para que la analítica siga siendo de mejor esfuerzo.
-      }
-      return rows;
-    }, []);
-}
-
-function recordSkillExecution(input, options = {}) {
-  const record = normalizeExecutionRecord(input, options);
-
-  if (options.stateStore && typeof options.stateStore.recordSkillExecution === 'function') {
-    try {
-      const result = options.stateStore.recordSkillExecution(record);
-      return {
-        storage: 'state-store',
-        record,
-        result,
-      };
-    } catch {
-      // Repliegue a JSONL mientras no exista un almacén de estado formal.
-    }
-  }
-
-  const runsFilePath = getRunsFilePath(options);
-  appendFile(runsFilePath, `${JSON.stringify(record)}\n`);
-
-  return {
-    storage: 'jsonl',
-    path: runsFilePath,
-    record,
-  };
-}
-
-function readSkillExecutionRecords(options = {}) {
-  if (options.stateStore && typeof options.stateStore.listSkillExecutionRecords === 'function') {
-    return options.stateStore.listSkillExecutionRecords();
-  }
-
-  return readJsonl(getRunsFilePath(options));
-}
-
-module.exports = {
-  VALID_FEEDBACK,
-  VALID_OUTCOMES,
-  getRunsFilePath,
-  normalizeExecutionRecord,
-  readSkillExecutionRecords,
-  recordSkillExecution,
-};

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

@@ -1,246 +0,0 @@
-'use strict';
-
-/**
- * Versionado y bitácora de evolución de skills (arsenal de Theus).
- *
- * Cada skill guarda sus snapshots en <skill>/.versions/vN.md y sus registros
- * de evolución (observaciones, inspecciones y enmiendas) en
- * <skill>/.evolution/<tipo>.jsonl. Las lecturas degradan con gracia: si los
- * directorios no existen todavía, devuelven listas vacías.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const { appendFile, ensureDir } = require('../utils');
-
-const VERSION_DIRECTORY_NAME = '.versions';
-const EVOLUTION_DIRECTORY_NAME = '.evolution';
-const EVOLUTION_LOG_TYPES = Object.freeze([
-  'observations',
-  'inspections',
-  'amendments',
-]);
-
-function normalizeSkillDir(skillPath) {
-  if (!skillPath || typeof skillPath !== 'string') {
-    throw new Error('skillPath es obligatorio');
-  }
-
-  const resolvedPath = path.resolve(skillPath);
-  if (path.basename(resolvedPath) === 'SKILL.md') {
-    return path.dirname(resolvedPath);
-  }
-
-  return resolvedPath;
-}
-
-function getSkillFilePath(skillPath) {
-  return path.join(normalizeSkillDir(skillPath), 'SKILL.md');
-}
-
-function ensureSkillExists(skillPath) {
-  const skillFilePath = getSkillFilePath(skillPath);
-  if (!fs.existsSync(skillFilePath)) {
-    throw new Error(`Archivo de skill no encontrado: ${skillFilePath}`);
-  }
-
-  return skillFilePath;
-}
-
-function getVersionsDir(skillPath) {
-  return path.join(normalizeSkillDir(skillPath), VERSION_DIRECTORY_NAME);
-}
-
-function getEvolutionDir(skillPath) {
-  return path.join(normalizeSkillDir(skillPath), EVOLUTION_DIRECTORY_NAME);
-}
-
-function getEvolutionLogPath(skillPath, logType) {
-  if (!EVOLUTION_LOG_TYPES.includes(logType)) {
-    throw new Error(`Tipo de bitácora de evolución desconocido: ${logType}`);
-  }
-
-  return path.join(getEvolutionDir(skillPath), `${logType}.jsonl`);
-}
-
-function ensureSkillVersioning(skillPath) {
-  ensureSkillExists(skillPath);
-
-  const versionsDir = getVersionsDir(skillPath);
-  const evolutionDir = getEvolutionDir(skillPath);
-
-  ensureDir(versionsDir);
-  ensureDir(evolutionDir);
-
-  for (const logType of EVOLUTION_LOG_TYPES) {
-    const logPath = getEvolutionLogPath(skillPath, logType);
-    if (!fs.existsSync(logPath)) {
-      fs.writeFileSync(logPath, '', 'utf8');
-    }
-  }
-
-  return {
-    versionsDir,
-    evolutionDir,
-  };
-}
-
-function parseVersionNumber(fileName) {
-  const match = /^v(\d+)\.md$/.exec(fileName);
-  if (!match) {
-    return null;
-  }
-
-  return Number(match[1]);
-}
-
-function listVersions(skillPath) {
-  const versionsDir = getVersionsDir(skillPath);
-  if (!fs.existsSync(versionsDir)) {
-    return [];
-  }
-
-  return fs.readdirSync(versionsDir)
-    .map(fileName => {
-      const version = parseVersionNumber(fileName);
-      if (version === null) {
-        return null;
-      }
-
-      const filePath = path.join(versionsDir, fileName);
-      const stats = fs.statSync(filePath);
-
-      return {
-        version,
-        path: filePath,
-        created_at: stats.mtime.toISOString(),
-      };
-    })
-    .filter(Boolean)
-    .sort((left, right) => left.version - right.version);
-}
-
-function getCurrentVersion(skillPath) {
-  const skillFilePath = getSkillFilePath(skillPath);
-  if (!fs.existsSync(skillFilePath)) {
-    return 0;
-  }
-
-  const versions = listVersions(skillPath);
-  if (versions.length === 0) {
-    return 1;
-  }
-
-  return versions[versions.length - 1].version;
-}
-
-function appendEvolutionRecord(skillPath, logType, record) {
-  ensureSkillVersioning(skillPath);
-  appendFile(getEvolutionLogPath(skillPath, logType), `${JSON.stringify(record)}\n`);
-  return { ...record };
-}
-
-function readJsonl(filePath) {
-  if (!fs.existsSync(filePath)) {
-    return [];
-  }
-
-  return fs.readFileSync(filePath, 'utf8')
-    .split('\n')
-    .map(line => line.trim())
-    .filter(Boolean)
-    .reduce((rows, line) => {
-      try {
-        rows.push(JSON.parse(line));
-      } catch {
-        // Se ignoran las filas malformadas: la bitácora es de solo anexado y resiliente.
-      }
-      return rows;
-    }, []);
-}
-
-function getEvolutionLog(skillPath, logType) {
-  return readJsonl(getEvolutionLogPath(skillPath, logType));
-}
-
-function createVersion(skillPath, options = {}) {
-  const skillFilePath = ensureSkillExists(skillPath);
-  ensureSkillVersioning(skillPath);
-
-  const versions = listVersions(skillPath);
-  const nextVersion = versions.length === 0 ? 1 : versions[versions.length - 1].version + 1;
-  const snapshotPath = path.join(getVersionsDir(skillPath), `v${nextVersion}.md`);
-  const skillContent = fs.readFileSync(skillFilePath, 'utf8');
-  const createdAt = options.timestamp || new Date().toISOString();
-
-  fs.writeFileSync(snapshotPath, skillContent, 'utf8');
-  appendEvolutionRecord(skillPath, 'amendments', {
-    event: 'snapshot',
-    version: nextVersion,
-    reason: options.reason || null,
-    author: options.author || null,
-    status: 'applied',
-    created_at: createdAt,
-  });
-
-  return {
-    version: nextVersion,
-    path: snapshotPath,
-    created_at: createdAt,
-  };
-}
-
-function rollbackTo(skillPath, targetVersion, options = {}) {
-  const normalizedTargetVersion = Number(targetVersion);
-  if (!Number.isInteger(normalizedTargetVersion) || normalizedTargetVersion <= 0) {
-    throw new Error(`Versión objetivo inválida: ${targetVersion}`);
-  }
-
-  ensureSkillExists(skillPath);
-  ensureSkillVersioning(skillPath);
-
-  const targetPath = path.join(getVersionsDir(skillPath), `v${normalizedTargetVersion}.md`);
-  if (!fs.existsSync(targetPath)) {
-    throw new Error(`Versión no encontrada: v${normalizedTargetVersion}`);
-  }
-
-  const currentVersion = getCurrentVersion(skillPath);
-  const targetContent = fs.readFileSync(targetPath, 'utf8');
-  fs.writeFileSync(getSkillFilePath(skillPath), targetContent, 'utf8');
-
-  const createdVersion = createVersion(skillPath, {
-    timestamp: options.timestamp,
-    reason: options.reason || `rollback a v${normalizedTargetVersion}`,
-    author: options.author || null,
-  });
-
-  appendEvolutionRecord(skillPath, 'amendments', {
-    event: 'rollback',
-    version: createdVersion.version,
-    source_version: currentVersion,
-    target_version: normalizedTargetVersion,
-    reason: options.reason || null,
-    author: options.author || null,
-    status: 'applied',
-    created_at: options.timestamp || new Date().toISOString(),
-  });
-
-  return createdVersion;
-}
-
-module.exports = {
-  EVOLUTION_DIRECTORY_NAME,
-  EVOLUTION_LOG_TYPES,
-  VERSION_DIRECTORY_NAME,
-  appendEvolutionRecord,
-  createVersion,
-  ensureSkillVersioning,
-  getCurrentVersion,
-  getEvolutionDir,
-  getEvolutionLog,
-  getEvolutionLogPath,
-  getVersionsDir,
-  listVersions,
-  rollbackTo,
-};