@jaimevalasek/aioson 1.4.0 → 1.5.1

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,8 @@ 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 */ }
 }
 
 function insertEvent(db, record) {
@@ -2019,7 +2115,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 +2281,150 @@ 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);
+}
+
 module.exports = {
   resolveRuntimePaths,
   runtimeStoreExists,
@@ -2261,5 +2501,22 @@ 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
 };

package/src/squad/external-session.js

@@ -0,0 +1,180 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+const SESSIONS_DIR = path.join('.aioson', 'sessions');
+const DEFAULT_TTL_HOURS = 24;
+
+function sanitizeSessionId(sessionId) {
+  // Replace anything that isn't alphanumeric, hyphen, or underscore with a dash
+  return String(sessionId)
+    .replace(/[^a-zA-Z0-9_-]/g, '-')
+    .replace(/-{2,}/g, '-')
+    .replace(/^-|-$/g, '')
+    .slice(0, 128);
+}
+
+function sessionPath(projectDir, sessionId) {
+  return path.join(projectDir, SESSIONS_DIR, `${sanitizeSessionId(sessionId)}.json`);
+}
+
+async function ensureSessionsDir(projectDir) {
+  const dir = path.join(projectDir, SESSIONS_DIR);
+  await fs.mkdir(dir, { recursive: true });
+  return dir;
+}
+
+/**
+ * Load a session by ID. Returns null if not found or expired.
+ * @param {string} projectDir
+ * @param {string} sessionId
+ * @param {number} [ttlHours]
+ * @returns {Promise<object|null>}
+ */
+async function loadSession(projectDir, sessionId, ttlHours = DEFAULT_TTL_HOURS) {
+  const filePath = sessionPath(projectDir, sessionId);
+  let raw;
+  try {
+    raw = await fs.readFile(filePath, 'utf8');
+  } catch {
+    return null;
+  }
+
+  let session;
+  try {
+    session = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+
+  // Check TTL
+  if (ttlHours > 0 && session.last_active) {
+    const idleMs = Date.now() - new Date(session.last_active).getTime();
+    if (idleMs > ttlHours * 3_600_000) {
+      // Expired — delete and return null
+      await fs.unlink(filePath).catch(() => {});
+      return null;
+    }
+  }
+
+  return session;
+}
+
+/**
+ * Save (overwrite) a session file atomically.
+ * @param {string} projectDir
+ * @param {object} session  Must have session.session_id
+ */
+async function saveSession(projectDir, session) {
+  await ensureSessionsDir(projectDir);
+  const filePath = sessionPath(projectDir, session.session_id);
+  const tmpPath = filePath + '.tmp';
+  await fs.writeFile(tmpPath, JSON.stringify(session, null, 2), 'utf8');
+  await fs.rename(tmpPath, filePath);
+}
+
+/**
+ * Append a turn to a session. Creates the session file if it doesn't exist.
+ * @param {string} projectDir
+ * @param {string} sessionId
+ * @param {'user'|'assistant'} role
+ * @param {string} content
+ * @param {object} [metadata]  Merged into session.metadata on first creation
+ * @param {number} [ttlHours]
+ * @returns {Promise<object>} Updated session
+ */
+async function appendTurn(projectDir, sessionId, role, content, metadata = {}, ttlHours = DEFAULT_TTL_HOURS) {
+  let session = await loadSession(projectDir, sessionId, ttlHours);
+  const now = new Date().toISOString();
+
+  if (!session) {
+    session = {
+      session_id: sessionId,
+      channel: metadata.channel || 'webhook',
+      created_at: now,
+      last_active: now,
+      turns: [],
+      metadata: { ...metadata }
+    };
+  }
+
+  session.last_active = now;
+  session.turns.push({ role, content, ts: now });
+
+  // Merge any new metadata fields without overwriting existing ones
+  if (metadata && typeof metadata === 'object') {
+    for (const [k, v] of Object.entries(metadata)) {
+      if (session.metadata[k] === undefined) session.metadata[k] = v;
+    }
+  }
+
+  await saveSession(projectDir, session);
+  return session;
+}
+
+/**
+ * Build a context string from session history to inject into the squad input.
+ * @param {object} session
+ * @param {string} currentInput
+ * @returns {string}
+ */
+function buildContextualInput(session, currentInput) {
+  if (!session || !session.turns || session.turns.length === 0) {
+    return currentInput;
+  }
+
+  const history = session.turns
+    .map(t => `${t.role}: ${t.content}`)
+    .join('\n');
+
+  return `[Conversation history]\n${history}\n\n[Current message]\n${currentInput}`;
+}
+
+/**
+ * Delete all session files that have been inactive for longer than ttlHours.
+ * @param {string} projectDir
+ * @param {number} [ttlHours]
+ * @returns {Promise<number>} Number of sessions deleted
+ */
+async function cleanExpiredSessions(projectDir, ttlHours = DEFAULT_TTL_HOURS) {
+  const dir = path.join(projectDir, SESSIONS_DIR);
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+
+  let deleted = 0;
+  const cutoff = Date.now() - ttlHours * 3_600_000;
+
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith('.json')) continue;
+    const filePath = path.join(dir, entry.name);
+    try {
+      const raw = await fs.readFile(filePath, 'utf8');
+      const session = JSON.parse(raw);
+      const lastActive = session.last_active ? new Date(session.last_active).getTime() : 0;
+      if (lastActive < cutoff) {
+        await fs.unlink(filePath);
+        deleted++;
+      }
+    } catch {
+      // Corrupt file — remove it
+      await fs.unlink(filePath).catch(() => {});
+      deleted++;
+    }
+  }
+
+  return deleted;
+}
+
+module.exports = {
+  loadSession,
+  saveSession,
+  appendTurn,
+  buildContextualInput,
+  cleanExpiredSessions,
+  sanitizeSessionId
+};

package/src/squad/inter-squad.js

@@ -0,0 +1,74 @@
+'use strict';
+const { randomUUID } = require('node:crypto');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { openRuntimeDb, insertWorkerRun } = require('../runtime-store');
+
+const INBOX_DIR = (projectDir, squadSlug) =>
+  path.join(projectDir, '.aioson', 'squads', squadSlug, 'inbox');
+
+async function callSquad({ projectDir, from, to, worker, payload, conversationId, depth = 0 }) {
+  // 1. Cascade guard
+  if (depth > 5) return { ok: false, error: 'cascade_guard' };
+
+  conversationId = conversationId || randomUUID();
+
+  // 2. Resolver porta do squad destino no SQLite (manter DB aberto para log)
+  const handle = await openRuntimeDb(projectDir);
+  const db = handle?.db;
+  const port = db
+    ?.prepare("SELECT port FROM squad_daemons WHERE squad_slug = ? AND status = 'running'")
+    .get(to)?.port;
+
+  let result;
+
+  // 3. Tentar chamada direta
+  if (port) {
+    try {
+      const res = await fetch(`http://127.0.0.1:${port}/webhook/${worker}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ ...payload, _inter_squad: { from, conversationId, depth: depth + 1 } }),
+        signal: AbortSignal.timeout(10000)
+      });
+      const json = await res.json();
+      result = { ok: res.ok, result: json, conversationId };
+    } catch {
+      // cai para inbox
+    }
+  }
+
+  // 4. Enfileirar na inbox do squad destino
+  if (!result) {
+    const inboxDir = INBOX_DIR(projectDir, to);
+    await fs.mkdir(inboxDir, { recursive: true });
+    const id = randomUUID();
+    await fs.writeFile(
+      path.join(inboxDir, `${id}.json`),
+      JSON.stringify({ id, from, to, worker, payload, conversationId, depth, created_at: new Date().toISOString() })
+    );
+    result = { ok: false, error: 'offline_queued', conversationId };
+  }
+
+  // 5. Gravar chamada emitida no runtime store (trigger_type = 'inter-squad')
+  if (db) {
+    try {
+      insertWorkerRun(db, {
+        squadSlug: from,
+        workerSlug: worker,
+        triggerType: 'inter-squad',
+        inputJson: JSON.stringify({ to, payload, conversationId }),
+        outputJson: result.ok ? JSON.stringify(result.result) : null,
+        status: result.ok ? 'completed' : 'failed',
+        errorMessage: result.ok ? null : result.error,
+        durationMs: 0,
+        attempt: 1
+      });
+    } catch { /* ignore */ }
+    db.close();
+  }
+
+  return result;
+}
+
+module.exports = { callSquad, INBOX_DIR };