@jaimevalasek/aioson 1.4.0 → 1.6.0

package/src/recovery-context-session.js

@@ -0,0 +1,154 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { execFile } = require('node:child_process');
+const { promisify } = require('node:util');
+
+const execFileAsync = promisify(execFile);
+
+const CONTEXT_DIR = path.join('.aioson', 'context');
+const RECOVERY_FILE = 'recovery-context.md';
+const MAX_TOKENS = 2000;
+
+function estimateTokens(str) {
+  return Math.ceil(str.length / 4);
+}
+
+async function readRecentGitLog(cwd, limit = 10) {
+  try {
+    const { stdout } = await execFileAsync('git', [
+      'log', `--max-count=${limit}`, '--oneline', '--no-merges'
+    ], { cwd });
+    return stdout.trim().split('\n').filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+async function readModifiedFiles(cwd) {
+  try {
+    const { stdout } = await execFileAsync('git', [
+      'diff', '--name-only', 'HEAD'
+    ], { cwd });
+    return stdout.trim().split('\n').filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function buildSessionRecoveryMarkdown(sessionState, gitLog, modifiedFiles) {
+  const lines = [];
+
+  lines.push('# Recovery Context — Direct Session');
+  lines.push(`> Generated: ${new Date().toISOString()}`);
+  lines.push('');
+
+  // Session goal/task
+  if (sessionState.goal) {
+    lines.push('## Current Goal');
+    lines.push(sessionState.goal);
+    lines.push('');
+  }
+
+  // Active agent
+  if (sessionState.agent) {
+    lines.push('## Active Agent');
+    lines.push(sessionState.agent);
+    lines.push('');
+  }
+
+  // Tasks
+  const tasks = Array.isArray(sessionState.tasks) ? sessionState.tasks : [];
+  if (tasks.length > 0) {
+    lines.push('## Tasks');
+    for (const t of tasks.slice(-5)) {
+      const status = t.status || 'unknown';
+      const title = t.title || t.id || '(untitled)';
+      lines.push(`- [${status}] ${title}`);
+    }
+    lines.push('');
+  }
+
+  // Notes
+  const notes = Array.isArray(sessionState.notes) ? sessionState.notes : [];
+  if (notes.length > 0) {
+    lines.push('## Notes');
+    for (const note of notes.slice(-5)) {
+      lines.push(`- ${note}`);
+    }
+    lines.push('');
+  }
+
+  // Modified files
+  if (modifiedFiles.length > 0) {
+    lines.push('## Modified Files');
+    for (const f of modifiedFiles.slice(0, 10)) {
+      lines.push(`- ${f}`);
+    }
+    lines.push('');
+  }
+
+  // Recent git commits
+  if (gitLog.length > 0) {
+    lines.push('## Recent Commits');
+    for (const entry of gitLog.slice(0, 5)) {
+      lines.push(`- ${entry}`);
+    }
+    lines.push('');
+  }
+
+  lines.push('---');
+  lines.push('*Inject this file at the top of your next session to restore context after a compact.*');
+
+  return lines.join('\n');
+}
+
+/**
+ * Generate and write recovery-context.md for a direct session (no squad).
+ * @param {string} cwd  — project root directory
+ * @param {object} sessionState  — { goal?, agent?, tasks?, notes? }
+ * @returns {{ ok: boolean, path: string, tokens: number }}
+ */
+async function generateSessionRecovery(cwd, sessionState = {}) {
+  const [gitLog, modifiedFiles] = await Promise.all([
+    readRecentGitLog(cwd),
+    readModifiedFiles(cwd)
+  ]);
+
+  let content = buildSessionRecoveryMarkdown(sessionState, gitLog, modifiedFiles);
+
+  // Enforce token budget
+  if (estimateTokens(content) > MAX_TOKENS) {
+    content = buildSessionRecoveryMarkdown(sessionState, gitLog.slice(0, 3), modifiedFiles.slice(0, 5));
+  }
+
+  const tokens = estimateTokens(content);
+  const outDir = path.join(cwd, CONTEXT_DIR);
+  const outPath = path.join(outDir, RECOVERY_FILE);
+
+  try {
+    await fs.mkdir(outDir, { recursive: true });
+    await fs.writeFile(outPath, content, 'utf8');
+  } catch (err) {
+    return { ok: false, error: err.message, path: outPath, tokens };
+  }
+
+  return { ok: true, path: outPath, tokens };
+}
+
+/**
+ * Read the current session recovery-context.md (returns null if missing).
+ * @param {string} cwd
+ * @returns {string|null}
+ */
+async function readSessionRecovery(cwd) {
+  const p = path.join(cwd, CONTEXT_DIR, RECOVERY_FILE);
+  try {
+    return await fs.readFile(p, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+module.exports = { generateSessionRecovery, readSessionRecovery };

package/src/runtime-store.js

@@ -496,6 +496,100 @@ async function openRuntimeDb(targetDir, options = {}) {
     CREATE INDEX IF NOT EXISTS idx_squad_learnings_status ON squad_learnings(status);
     CREATE INDEX IF NOT EXISTS idx_project_learnings_type ON project_learnings(type);
     CREATE INDEX IF NOT EXISTS idx_project_learnings_status ON project_learnings(status);
+
+    CREATE TABLE IF NOT EXISTS squad_metrics (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      squad_slug TEXT NOT NULL,
+      metric_key TEXT NOT NULL,
+      metric_value REAL NOT NULL,
+      metric_unit TEXT,
+      period TEXT,
+      baseline REAL,
+      target REAL,
+      source TEXT DEFAULT 'manual',
+      notes TEXT,
+      created_at TEXT DEFAULT (datetime('now')),
+      UNIQUE(squad_slug, metric_key, period)
+    );
+    CREATE INDEX IF NOT EXISTS idx_squad_metrics_squad ON squad_metrics(squad_slug, period DESC);
+
+    CREATE TABLE IF NOT EXISTS worker_runs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      squad_slug TEXT NOT NULL,
+      worker_slug TEXT NOT NULL,
+      trigger_type TEXT NOT NULL DEFAULT 'manual',
+      input_json TEXT,
+      output_json TEXT,
+      status TEXT DEFAULT 'running',
+      error_message TEXT,
+      duration_ms INTEGER,
+      attempt INTEGER DEFAULT 1,
+      created_at TEXT DEFAULT (datetime('now')),
+      completed_at TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_worker_runs_squad ON worker_runs(squad_slug, created_at DESC);
+
+    CREATE TABLE IF NOT EXISTS squad_daemons (
+      squad_slug TEXT PRIMARY KEY,
+      status TEXT DEFAULT 'stopped',
+      pid INTEGER,
+      port INTEGER,
+      started_at TEXT,
+      last_heartbeat TEXT,
+      config_json TEXT,
+      error_message TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS mcp_status (
+      squad_slug TEXT NOT NULL,
+      mcp_slug TEXT NOT NULL,
+      connector TEXT NOT NULL,
+      status TEXT DEFAULT 'unconfigured',
+      last_check TEXT,
+      last_error TEXT,
+      calls_total INTEGER DEFAULT 0,
+      calls_failed INTEGER DEFAULT 0,
+      PRIMARY KEY (squad_slug, mcp_slug)
+    );
+
+    CREATE TABLE IF NOT EXISTS workflow_reviews (
+      review_id TEXT PRIMARY KEY,
+      squad_slug TEXT NOT NULL,
+      workflow_slug TEXT NOT NULL,
+      phase_id TEXT NOT NULL,
+      attempt_number INTEGER DEFAULT 1,
+      reviewer_slug TEXT NOT NULL,
+      verdict TEXT NOT NULL,
+      score REAL,
+      feedback TEXT,
+      veto_triggered TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_workflow_reviews_squad ON workflow_reviews(squad_slug, workflow_slug);
+
+    CREATE TABLE IF NOT EXISTS squad_scores (
+      squad_slug TEXT NOT NULL,
+      dimension TEXT NOT NULL,
+      score INTEGER NOT NULL,
+      max_score INTEGER NOT NULL,
+      details_json TEXT,
+      scored_at TEXT DEFAULT (datetime('now')),
+      PRIMARY KEY (squad_slug, dimension, scored_at)
+    );
+    CREATE INDEX IF NOT EXISTS idx_squad_scores_squad ON squad_scores(squad_slug);
+
+    CREATE TABLE IF NOT EXISTS squad_roi_config (
+      squad_slug TEXT PRIMARY KEY,
+      pricing_model TEXT DEFAULT 'fixed',
+      setup_fee REAL,
+      monthly_fee REAL,
+      percentage_fee REAL,
+      percentage_base TEXT,
+      currency TEXT DEFAULT 'BRL',
+      contract_months INTEGER DEFAULT 12,
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    );
   `);
 
   ensureLegacyColumns(db);
@@ -597,6 +691,36 @@ function ensureLegacyColumns(db) {
   if (!contentItemColumnNames.has('used_skills_json')) {
     db.exec('ALTER TABLE content_items ADD COLUMN used_skills_json TEXT');
   }
+
+  try { db.exec('ALTER TABLE worker_runs ADD COLUMN conversation_id TEXT'); } catch { /* já existe */ }
+
+  // Dynamic Tools (Feature: Tool Registry)
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS dynamic_tools (
+      name TEXT PRIMARY KEY,
+      description TEXT NOT NULL,
+      input_schema TEXT NOT NULL DEFAULT '{}',
+      handler_type TEXT NOT NULL DEFAULT 'shell',
+      handler_code TEXT,
+      handler_path TEXT,
+      squad_slug TEXT,
+      registered_at TEXT NOT NULL DEFAULT (datetime('now')),
+      registered_by TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_dynamic_tools_squad ON dynamic_tools(squad_slug);
+  `);
+
+  // Evolution Log (Feature: Learning Evolution Pipeline)
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS evolution_log (
+      id TEXT PRIMARY KEY,
+      applied_at TEXT NOT NULL,
+      deltas_count INTEGER NOT NULL DEFAULT 0,
+      squad_slug TEXT,
+      files_json TEXT,
+      source_learning_ids_json TEXT
+    );
+  `);
 }
 
 function insertEvent(db, record) {
@@ -2019,7 +2143,7 @@ function getSquadPlanRounds(db, planSlug) {
 // --- Squad Learnings CRUD ---
 
 function insertSquadLearning(db, options = {}) {
-  const learningId = options.learningId || `sl-${slugify(options.squadSlug || 'squad')}-${Date.now()}`;
+  const learningId = options.learningId || `sl-${slugify(options.squadSlug || 'squad')}-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
   const now = nowIso();
   db.prepare(`
     INSERT OR REPLACE INTO squad_learnings
@@ -2185,6 +2309,210 @@ function getProjectLearningStats(db) {
   `).all();
 }
 
+// --- Squad Metrics CRUD ---
+
+function upsertSquadMetric(db, { squadSlug, metricKey, value, unit, period, baseline, target, source, notes }) {
+  db.prepare(`
+    INSERT INTO squad_metrics (squad_slug, metric_key, metric_value, metric_unit, period, baseline, target, source, notes)
+    VALUES (@squad_slug, @metric_key, @metric_value, @metric_unit, @period, @baseline, @target, @source, @notes)
+    ON CONFLICT(squad_slug, metric_key, period) DO UPDATE SET
+      metric_value = excluded.metric_value,
+      metric_unit = excluded.metric_unit,
+      baseline = COALESCE(excluded.baseline, squad_metrics.baseline),
+      target = COALESCE(excluded.target, squad_metrics.target),
+      source = excluded.source,
+      notes = COALESCE(excluded.notes, squad_metrics.notes)
+  `).run({
+    squad_slug: String(squadSlug).trim(),
+    metric_key: String(metricKey).trim(),
+    metric_value: Number(value),
+    metric_unit: unit ? String(unit).trim() : null,
+    period: period ? String(period).trim() : null,
+    baseline: baseline != null ? Number(baseline) : null,
+    target: target != null ? Number(target) : null,
+    source: source ? String(source).trim() : 'manual',
+    notes: notes ? String(notes).trim() : null
+  });
+}
+
+function listSquadMetrics(db, squadSlug, period) {
+  if (period) {
+    return db.prepare(
+      'SELECT * FROM squad_metrics WHERE squad_slug = ? AND period = ? ORDER BY metric_key ASC'
+    ).all(squadSlug, period);
+  }
+  return db.prepare(
+    'SELECT * FROM squad_metrics WHERE squad_slug = ? ORDER BY period DESC, metric_key ASC'
+  ).all(squadSlug);
+}
+
+function deleteSquadMetric(db, squadSlug, metricKey, period) {
+  db.prepare(
+    'DELETE FROM squad_metrics WHERE squad_slug = ? AND metric_key = ? AND period = ?'
+  ).run(squadSlug, metricKey, period);
+}
+
+// --- Worker Runs CRUD ---
+
+function insertWorkerRun(db, { squadSlug, workerSlug, triggerType, inputJson, outputJson, status, errorMessage, durationMs, attempt, conversationId }) {
+  const now = nowIso();
+  return db.prepare(`
+    INSERT INTO worker_runs (squad_slug, worker_slug, trigger_type, input_json, output_json, status, error_message, duration_ms, attempt, conversation_id, created_at, completed_at)
+    VALUES (@squad_slug, @worker_slug, @trigger_type, @input_json, @output_json, @status, @error_message, @duration_ms, @attempt, @conversation_id, @created_at, @completed_at)
+  `).run({
+    squad_slug: String(squadSlug).trim(),
+    worker_slug: String(workerSlug).trim(),
+    trigger_type: String(triggerType || 'manual').trim(),
+    input_json: inputJson || null,
+    output_json: outputJson || null,
+    status: String(status || 'running').trim(),
+    error_message: errorMessage || null,
+    duration_ms: durationMs != null ? Number(durationMs) : null,
+    attempt: Number(attempt || 1),
+    conversation_id: conversationId || null,
+    created_at: now,
+    completed_at: (status === 'completed' || status === 'failed') ? now : null
+  });
+}
+
+function listWorkerRuns(db, squadSlug, limit = 50) {
+  return db.prepare(
+    'SELECT * FROM worker_runs WHERE squad_slug = ? ORDER BY created_at DESC, id DESC LIMIT ?'
+  ).all(squadSlug, limit);
+}
+
+function getWorkerRunStats(db, squadSlug) {
+  return db.prepare(`
+    SELECT worker_slug, status, COUNT(*) as count,
+           AVG(duration_ms) as avg_duration_ms
+    FROM worker_runs WHERE squad_slug = ?
+    GROUP BY worker_slug, status
+    ORDER BY worker_slug, status
+  `).all(squadSlug);
+}
+
+// --- MCP Status CRUD ---
+
+function upsertMcpStatus(db, { squadSlug, mcpSlug, connector, status, lastError }) {
+  db.prepare(`
+    INSERT INTO mcp_status (squad_slug, mcp_slug, connector, status, last_check, last_error)
+    VALUES (?, ?, ?, ?, datetime('now'), ?)
+    ON CONFLICT(squad_slug, mcp_slug) DO UPDATE SET
+      connector = excluded.connector,
+      status = excluded.status,
+      last_check = excluded.last_check,
+      last_error = excluded.last_error
+  `).run(squadSlug, mcpSlug, connector, status || 'unconfigured', lastError || null);
+}
+
+function incrementMcpCalls(db, squadSlug, mcpSlug, failed) {
+  if (failed) {
+    db.prepare(`
+      UPDATE mcp_status SET calls_total = calls_total + 1, calls_failed = calls_failed + 1
+      WHERE squad_slug = ? AND mcp_slug = ?
+    `).run(squadSlug, mcpSlug);
+  } else {
+    db.prepare(`
+      UPDATE mcp_status SET calls_total = calls_total + 1
+      WHERE squad_slug = ? AND mcp_slug = ?
+    `).run(squadSlug, mcpSlug);
+  }
+}
+
+function listMcpStatus(db, squadSlug) {
+  return db.prepare('SELECT * FROM mcp_status WHERE squad_slug = ? ORDER BY mcp_slug').all(squadSlug);
+}
+
+function getMcpStatus(db, squadSlug, mcpSlug) {
+  return db.prepare('SELECT * FROM mcp_status WHERE squad_slug = ? AND mcp_slug = ?').get(squadSlug, mcpSlug);
+}
+
+// --- ROI Config CRUD ---
+
+function upsertROIConfig(db, { squadSlug, pricingModel, setupFee, monthlyFee, percentageFee, percentageBase, currency, contractMonths }) {
+  db.prepare(`
+    INSERT INTO squad_roi_config (squad_slug, pricing_model, setup_fee, monthly_fee, percentage_fee, percentage_base, currency, contract_months)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(squad_slug) DO UPDATE SET
+      pricing_model = excluded.pricing_model,
+      setup_fee = excluded.setup_fee,
+      monthly_fee = excluded.monthly_fee,
+      percentage_fee = excluded.percentage_fee,
+      percentage_base = excluded.percentage_base,
+      currency = excluded.currency,
+      contract_months = excluded.contract_months,
+      updated_at = datetime('now')
+  `).run(squadSlug, pricingModel || 'fixed', setupFee || null, monthlyFee || null, percentageFee || null, percentageBase || null, currency || 'BRL', contractMonths || 12);
+}
+
+function getROIConfig(db, squadSlug) {
+  return db.prepare('SELECT * FROM squad_roi_config WHERE squad_slug = ?').get(squadSlug);
+}
+
+function deleteROIConfig(db, squadSlug) {
+  return db.prepare('DELETE FROM squad_roi_config WHERE squad_slug = ?').run(squadSlug);
+}
+
+// ─── Dynamic Tools CRUD ───────────────────────────────────────────────────────
+
+function registerDynamicTool(db, opts) {
+  const now = nowIso();
+  db.prepare(`
+    INSERT OR REPLACE INTO dynamic_tools
+      (name, description, input_schema, handler_type, handler_code, handler_path, squad_slug, registered_at, registered_by)
+    VALUES
+      (@name, @description, @inputSchema, @handlerType, @handlerCode, @handlerPath, @squadSlug, @registeredAt, @registeredBy)
+  `).run({
+    name: String(opts.name),
+    description: String(opts.description),
+    inputSchema: opts.inputSchema ? JSON.stringify(opts.inputSchema) : '{}',
+    handlerType: String(opts.handlerType || 'shell'),
+    handlerCode: opts.handlerCode || null,
+    handlerPath: opts.handlerPath || null,
+    squadSlug: opts.squadSlug || null,
+    registeredAt: now,
+    registeredBy: opts.registeredBy || null
+  });
+  return opts.name;
+}
+
+function unregisterDynamicTool(db, name) {
+  return db.prepare('DELETE FROM dynamic_tools WHERE name = ?').run(name);
+}
+
+function getDynamicTool(db, name) {
+  return db.prepare('SELECT * FROM dynamic_tools WHERE name = ?').get(name) || null;
+}
+
+function listDynamicTools(db, squadSlug = null) {
+  if (squadSlug) {
+    return db.prepare('SELECT * FROM dynamic_tools WHERE squad_slug = ? ORDER BY registered_at DESC').all(squadSlug);
+  }
+  return db.prepare('SELECT * FROM dynamic_tools ORDER BY registered_at DESC').all();
+}
+
+// ─── Evolution Log CRUD ───────────────────────────────────────────────────────
+
+function insertEvolutionLog(db, opts) {
+  const id = `evo-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+  db.prepare(`
+    INSERT INTO evolution_log (id, applied_at, deltas_count, squad_slug, files_json, source_learning_ids_json)
+    VALUES (@id, @appliedAt, @deltasCount, @squadSlug, @filesJson, @sourceIdsJson)
+  `).run({
+    id,
+    appliedAt: nowIso(),
+    deltasCount: Number(opts.deltasCount || 0),
+    squadSlug: opts.squadSlug || null,
+    filesJson: JSON.stringify(opts.files || []),
+    sourceIdsJson: JSON.stringify(opts.sourceLearningIds || [])
+  });
+  return id;
+}
+
+function listEvolutionLog(db, limit = 20) {
+  return db.prepare('SELECT * FROM evolution_log ORDER BY applied_at DESC LIMIT ?').all(limit);
+}
+
 module.exports = {
   resolveRuntimePaths,
   runtimeStoreExists,
@@ -2261,5 +2589,30 @@ module.exports = {
   updateProjectLearningStatus,
   reinforceProjectLearning,
   promoteProjectLearning,
-  getProjectLearningStats
+  getProjectLearningStats,
+  // Squad Metrics CRUD
+  upsertSquadMetric,
+  listSquadMetrics,
+  deleteSquadMetric,
+  // Worker Runs CRUD
+  insertWorkerRun,
+  listWorkerRuns,
+  getWorkerRunStats,
+  // MCP Status CRUD
+  upsertMcpStatus,
+  incrementMcpCalls,
+  listMcpStatus,
+  getMcpStatus,
+  // ROI Config CRUD
+  upsertROIConfig,
+  getROIConfig,
+  deleteROIConfig,
+  // Dynamic Tools CRUD
+  registerDynamicTool,
+  unregisterDynamicTool,
+  getDynamicTool,
+  listDynamicTools,
+  // Evolution Log CRUD
+  insertEvolutionLog,
+  listEvolutionLog
 };