@jaimevalasek/aioson 1.3.0

package/src/execution-gateway.js

@@ -0,0 +1,461 @@
+'use strict';
+
+const {
+  openRuntimeDb,
+  startTask,
+  updateTask,
+  startRun,
+  updateRun,
+  appendRunEvent
+} = require('./runtime-store');
+
+function normalizeText(value) {
+  return String(value || '').trim();
+}
+
+function normalizeAgentName(value) {
+  const text = normalizeText(value).toLowerCase();
+  return text ? (text.startsWith('@') ? text : `@${text}`) : '';
+}
+
+function classifyDirectAgentRuntime(agentName) {
+  const normalized = normalizeAgentName(agentName);
+
+  if (normalized === '@squad') {
+    return {
+      agentName: normalized,
+      agentKind: 'squad',
+      source: 'squad_session'
+    };
+  }
+
+  if (normalized === '@workflow') {
+    return {
+      agentName: normalized,
+      agentKind: 'workflow',
+      source: 'workflow'
+    };
+  }
+
+  if (normalized === '@orchestrator') {
+    return {
+      agentName: normalized,
+      agentKind: 'official',
+      source: 'orchestration'
+    };
+  }
+
+  return {
+    agentName: normalized,
+    agentKind: 'official',
+    source: 'direct'
+  };
+}
+
+function makeWorkflowSessionKey(state) {
+  const scope = state.featureSlug ? `feature:${state.featureSlug}` : 'project:default';
+  return `workflow:${normalizeText(state.mode || 'project')}:${scope}`;
+}
+
+function makeWorkflowTaskTitle(state) {
+  return state.featureSlug
+    ? `Workflow da feature ${state.featureSlug}`
+    : 'Workflow do projeto';
+}
+
+function makeWorkflowTaskGoal(state) {
+  return state.featureSlug
+    ? `Governar a execucao da feature ${state.featureSlug}`
+    : 'Governar a execucao do projeto';
+}
+
+function makeWorkflowControllerTitle(state) {
+  return state.featureSlug
+    ? `Workflow controller (${state.featureSlug})`
+    : 'Workflow controller';
+}
+
+function makeWorkflowStageTitle(agentName) {
+  return `Workflow stage ${agentName}`;
+}
+
+function findTaskBySession(db, sessionKey) {
+  return db
+    .prepare(
+      `
+        SELECT task_key, status
+        FROM tasks
+        WHERE session_key = ?
+        ORDER BY updated_at DESC, created_at DESC
+        LIMIT 1
+      `
+    )
+    .get(sessionKey);
+}
+
+function findRunByTaskAndAgent(db, taskKey, agentName, options = {}) {
+  const statuses = Array.isArray(options.statuses) && options.statuses.length > 0
+    ? options.statuses
+    : null;
+  const workflowStage = options.workflowStage ? normalizeText(options.workflowStage) : null;
+
+  let sql = `
+    SELECT run_key, status
+    FROM agent_runs
+    WHERE task_key = ?
+      AND agent_name = ?
+  `;
+  const params = [taskKey, agentName];
+
+  if (workflowStage) {
+    sql += ' AND workflow_stage = ?';
+    params.push(workflowStage);
+  }
+
+  if (statuses) {
+    sql += ` AND status IN (${statuses.map(() => '?').join(', ')})`;
+    params.push(...statuses);
+  }
+
+  sql += ' ORDER BY updated_at DESC, started_at DESC LIMIT 1';
+  return db.prepare(sql).get(...params);
+}
+
+async function ensureProjectRuntime(targetDir) {
+  const handle = await openRuntimeDb(targetDir);
+  try {
+    return {
+      runtimeDir: handle.runtimeDir,
+      dbPath: handle.dbPath
+    };
+  } finally {
+    handle.db.close();
+  }
+}
+
+async function recordRuntimeOperation(targetDir, input) {
+  const handle = await openRuntimeDb(targetDir);
+  const { db, dbPath } = handle;
+
+  try {
+    const classification = classifyDirectAgentRuntime(input.agentName || 'orchestrator');
+    const sessionKey = normalizeText(input.sessionKey) || `operation:${Date.now()}:${classification.agentName}`;
+    const title = normalizeText(input.title) || `Runtime operation ${classification.agentName}`;
+    const goal = normalizeText(input.goal) || `Registrar operacao ${classification.agentName}`;
+    const phase = normalizeText(input.phase) || 'operation';
+    const source = normalizeText(input.source) || classification.source;
+    const finalStatus = normalizeText(input.status) || 'completed';
+    const failure = finalStatus === 'failed';
+
+    let task = findTaskBySession(db, sessionKey);
+    if (!task) {
+      task = {
+        task_key: startTask(db, {
+          sessionKey,
+          title,
+          goal,
+          createdBy: classification.agentName,
+          status: 'running'
+        }),
+        status: 'running'
+      };
+    } else {
+      updateTask(db, { taskKey: task.task_key, status: 'running' });
+    }
+
+    const runTitle = normalizeText(input.runTitle) || normalizeText(input.commandName) || title;
+    const startMessage = normalizeText(input.message) || `Operation started: ${runTitle}`;
+    const summary = normalizeText(input.summary) || startMessage;
+    const runKey = startRun(db, {
+      taskKey: task.task_key,
+      agentName: classification.agentName,
+      agentKind: normalizeText(input.agentKind) || classification.agentKind,
+      sessionKey,
+      source,
+      workflowId: normalizeText(input.workflowId) || null,
+      workflowStage: normalizeText(input.workflowStage) || null,
+      parentRunKey: normalizeText(input.parentRunKey) || null,
+      title: runTitle,
+      status: 'running',
+      message: startMessage,
+      payload: input.payload || null,
+      phase
+    });
+
+    updateRun(db, {
+      runKey,
+      status: finalStatus,
+      eventType: normalizeText(input.eventType) || (failure ? 'failed' : 'completed'),
+      phase,
+      source,
+      workflowId: normalizeText(input.workflowId) || null,
+      workflowStage: normalizeText(input.workflowStage) || null,
+      parentRunKey: normalizeText(input.parentRunKey) || null,
+      message: summary,
+      summary,
+      payload: input.payload || null,
+      toolName: normalizeText(input.toolName) || null
+    });
+
+    updateTask(db, {
+      taskKey: task.task_key,
+      status: failure ? 'failed' : 'completed'
+    });
+
+    return {
+      ok: true,
+      dbPath,
+      taskKey: task.task_key,
+      runKey
+    };
+  } finally {
+    db.close();
+  }
+}
+
+async function syncWorkflowRuntime(targetDir, input) {
+  const handle = await openRuntimeDb(targetDir);
+  const { db, dbPath } = handle;
+
+  try {
+    const state = input.state || {};
+    const eventPayload = input.eventPayload || {};
+    const activationAgent = normalizeText(input.activationAgent);
+    const completedStage = normalizeText(input.completedStage);
+    const sessionKey = makeWorkflowSessionKey(state);
+    const workflowId = sessionKey;
+
+    let task = findTaskBySession(db, sessionKey);
+    if (!task) {
+      task = {
+        task_key: startTask(db, {
+          sessionKey,
+          title: makeWorkflowTaskTitle(state),
+          goal: makeWorkflowTaskGoal(state),
+          createdBy: '@workflow',
+          status: activationAgent ? 'running' : 'queued'
+        }),
+        status: activationAgent ? 'running' : 'queued'
+      };
+    }
+
+    const taskKey = task.task_key;
+    const controllerAgent = '@workflow';
+    let controllerRun = findRunByTaskAndAgent(db, taskKey, controllerAgent, {
+      statuses: ['queued', 'running']
+    });
+
+    if (!controllerRun) {
+      controllerRun = {
+        run_key: startRun(db, {
+          taskKey,
+          agentName: controllerAgent,
+          agentKind: 'workflow',
+          sessionKey,
+          source: 'workflow',
+          workflowId,
+          workflowStage: activationAgent || completedStage || normalizeText(state.current || state.next),
+          title: makeWorkflowControllerTitle(state),
+          message: eventPayload.message || 'Workflow initialized'
+        })
+      };
+    } else {
+      appendRunEvent(db, {
+        runKey: controllerRun.run_key,
+        eventType: eventPayload.eventType || 'workflow',
+        phase: 'workflow',
+        status: activationAgent ? 'running' : 'queued',
+        message: eventPayload.message || 'Workflow updated',
+        payload: eventPayload
+      });
+    }
+
+    if (controllerRun.run_key && eventPayload.eventType && eventPayload.eventType !== 'start' && eventPayload.eventType !== 'completed') {
+      appendRunEvent(db, {
+        runKey: controllerRun.run_key,
+        eventType: eventPayload.eventType,
+        phase: 'workflow',
+        status: activationAgent ? 'running' : 'queued',
+        message: eventPayload.message || 'Workflow updated',
+        payload: eventPayload
+      });
+    }
+
+    if (completedStage) {
+      const completedAgent = normalizeAgentName(completedStage);
+      let completedRun = findRunByTaskAndAgent(db, taskKey, completedAgent, {
+        workflowStage: completedStage,
+        statuses: ['queued', 'running']
+      });
+
+      if (!completedRun) {
+        completedRun = {
+          run_key: startRun(db, {
+            taskKey,
+            agentName: completedAgent,
+            agentKind: 'official',
+            sessionKey,
+            source: 'workflow',
+            workflowId,
+            workflowStage: completedStage,
+            parentRunKey: controllerRun.run_key,
+            title: makeWorkflowStageTitle(completedAgent),
+            message: `Stage ${completedAgent} restored for completion`
+          })
+        };
+      }
+
+      updateRun(db, {
+        runKey: completedRun.run_key,
+        status: 'completed',
+        eventType: 'completed',
+        phase: 'workflow',
+        source: 'workflow',
+        workflowId,
+        workflowStage: completedStage,
+        parentRunKey: controllerRun.run_key,
+        message: `Workflow stage completed: ${completedAgent}`,
+        summary: eventPayload.message || `Stage ${completedAgent} completed`,
+        payload: eventPayload
+      });
+    }
+
+    let stageRunKey = null;
+    if (activationAgent) {
+      const stageAgent = normalizeAgentName(activationAgent);
+      let stageRun = findRunByTaskAndAgent(db, taskKey, stageAgent, {
+        workflowStage: activationAgent,
+        statuses: ['queued', 'running']
+      });
+
+      if (!stageRun) {
+        stageRun = {
+          run_key: startRun(db, {
+            taskKey,
+            agentName: stageAgent,
+            agentKind: 'official',
+            sessionKey,
+            source: 'workflow',
+            workflowId,
+            workflowStage: activationAgent,
+            parentRunKey: controllerRun.run_key,
+            title: makeWorkflowStageTitle(stageAgent),
+            message: eventPayload.message || `Workflow routed to ${stageAgent}`
+          })
+        };
+      } else {
+        appendRunEvent(db, {
+          runKey: stageRun.run_key,
+          eventType: eventPayload.eventType || 'workflow',
+          phase: 'workflow',
+          status: 'running',
+          message: eventPayload.message || `Workflow stage active: ${stageAgent}`,
+          payload: eventPayload
+        });
+      }
+
+      stageRunKey = stageRun.run_key;
+      if (eventPayload.eventType && eventPayload.eventType !== 'start' && eventPayload.eventType !== 'completed') {
+        appendRunEvent(db, {
+          runKey: stageRun.run_key,
+          eventType: eventPayload.eventType,
+          phase: 'workflow',
+          status: 'running',
+          message: eventPayload.message || `Workflow stage active: ${stageAgent}`,
+          payload: eventPayload
+        });
+      }
+      updateTask(db, { taskKey, status: 'running' });
+    } else {
+      updateRun(db, {
+        runKey: controllerRun.run_key,
+        status: 'completed',
+        eventType: 'completed',
+        phase: 'workflow',
+        source: 'workflow',
+        workflowId,
+        workflowStage: normalizeText(state.current || state.next),
+        message: eventPayload.message || 'Workflow completed',
+        summary: eventPayload.message || 'Workflow completed',
+        payload: eventPayload
+      });
+      updateTask(db, { taskKey, status: 'completed' });
+    }
+
+    return {
+      ok: true,
+      dbPath,
+      taskKey,
+      controllerRunKey: controllerRun.run_key,
+      stageRunKey
+    };
+  } finally {
+    db.close();
+  }
+}
+
+async function bootstrapDirectAgentPrompt(targetDir, input) {
+  const handle = await openRuntimeDb(targetDir);
+  const { db, dbPath } = handle;
+
+  try {
+    const classification = classifyDirectAgentRuntime(input.agentName);
+    const agentName = classification.agentName;
+    const title = normalizeText(input.title) || `Direct handoff for ${agentName}`;
+    const taskKey = startTask(db, {
+      sessionKey: normalizeText(input.sessionKey) || `direct:${Date.now()}:${agentName}`,
+      title,
+      goal: normalizeText(input.goal) || `Entregar prompt e handoff para ${agentName}`,
+      createdBy: '@runtime',
+      status: 'queued'
+    });
+
+    const runKey = startRun(db, {
+      taskKey,
+      agentName,
+      agentKind: normalizeText(input.agentKind) || classification.agentKind,
+      sessionKey: normalizeText(input.sessionKey) || null,
+      source: normalizeText(input.source) || classification.source,
+      workflowId: null,
+      workflowStage: null,
+      title,
+      status: 'queued',
+      message: input.message || `Prompt generated for ${agentName}`,
+      payload: input.payload || null,
+      phase: 'handoff'
+    });
+
+    appendRunEvent(db, {
+      runKey,
+      eventType: 'prompt.generated',
+      phase: 'handoff',
+      status: 'queued',
+      message: input.message || `Prompt generated for ${agentName}`,
+      payload: {
+        tool: input.tool || 'codex',
+        locale: input.locale || 'en',
+        instructionPath: input.instructionPath || null,
+        prompt: input.prompt || null,
+        requestedAgent: agentName
+      }
+    });
+
+    return {
+      ok: true,
+      dbPath,
+      taskKey,
+      runKey
+    };
+  } finally {
+    db.close();
+  }
+}
+
+module.exports = {
+  ensureProjectRuntime,
+  syncWorkflowRuntime,
+  makeWorkflowSessionKey,
+  classifyDirectAgentRuntime,
+  bootstrapDirectAgentPrompt,
+  recordRuntimeOperation
+};

package/src/genome-files.js

@@ -0,0 +1,198 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const {
+  isGenomeV2,
+  normalizeGenome,
+  normalizeGenomeMeta
+} = require('./genomes');
+const { parseGenomeMarkdown, serializeGenomeMarkdown } = require('./genome-format');
+const { assertValidGenome, assertValidGenomeMeta } = require('./genome-schema');
+const { ensureDir, exists } = require('./utils');
+
+function getGenomeDir(projectRoot) {
+  return path.join(projectRoot, '.aioson', 'genomas');
+}
+
+function getGenomeMarkdownPath(projectRoot, slug) {
+  return path.join(getGenomeDir(projectRoot), `${slug}.md`);
+}
+
+function getGenomeMetaPath(projectRoot, slug) {
+  return path.join(getGenomeDir(projectRoot), `${slug}.meta.json`);
+}
+
+async function readMetaFile(filePath, slug) {
+  try {
+    const text = await fs.readFile(filePath, 'utf8');
+    return JSON.parse(text);
+  } catch (error) {
+    if (error && error.code === 'ENOENT') return null;
+    throw new Error(`Invalid genome meta JSON for "${slug}" at ${filePath}: ${error.message}`);
+  }
+}
+
+function mergeGenomeWithMeta(genome, rawMeta, slug) {
+  if (!rawMeta) {
+    return normalizeGenome({
+      ...genome,
+      slug: genome.slug || slug
+    });
+  }
+
+  return normalizeGenome({
+    ...genome,
+    slug: genome.slug || rawMeta.slug || slug,
+    domain: genome.domain || rawMeta.domain,
+    type: genome.hasFrontmatter ? genome.type : rawMeta.type,
+    language: genome.hasFrontmatter ? genome.language : rawMeta.language,
+    depth: genome.hasFrontmatter ? genome.depth : rawMeta.depth,
+    version: genome.hasFrontmatter ? genome.version : rawMeta.version,
+    format: genome.hasFrontmatter ? genome.format : rawMeta.format,
+    evidenceMode: genome.hasFrontmatter ? genome.evidenceMode : rawMeta.evidenceMode,
+    sourceCount: genome.hasFrontmatter ? genome.sourceCount : rawMeta.sourceCount,
+    personaSource: genome.hasFrontmatter ? genome.personaSource : rawMeta.personaSource,
+    personaSources: genome.hasFrontmatter ? genome.personaSources : rawMeta.personaSources,
+    disc: genome.hasFrontmatter ? genome.disc : rawMeta.disc,
+    enneagram: genome.hasFrontmatter ? genome.enneagram : rawMeta.enneagram,
+    bigFive: genome.hasFrontmatter ? genome.bigFive : rawMeta.bigFive,
+    mbti: genome.hasFrontmatter ? genome.mbti : rawMeta.mbti,
+    confidence: genome.hasFrontmatter ? genome.confidence : rawMeta.confidence,
+    profilerReport: genome.hasFrontmatter ? genome.profilerReport : rawMeta.profilerReport,
+    hybridMode: genome.hasFrontmatter ? genome.hybridMode : rawMeta.hybridMode
+  });
+}
+
+async function readGenome(projectRoot, slug) {
+  const markdownPath = getGenomeMarkdownPath(projectRoot, slug);
+  const metaPath = getGenomeMetaPath(projectRoot, slug);
+
+  if (!(await exists(markdownPath))) {
+    throw new Error(`Genome "${slug}" not found at ${markdownPath}`);
+  }
+
+  const markdown = await fs.readFile(markdownPath, 'utf8');
+  const parsedGenome = parseGenomeMarkdown(markdown);
+  const rawMeta = await readMetaFile(metaPath, slug);
+  const genome = assertValidGenome(mergeGenomeWithMeta(parsedGenome, rawMeta, slug));
+
+  let meta;
+  if (rawMeta) {
+    meta = assertValidGenomeMeta({
+      ...rawMeta,
+      genome,
+      compat: {
+        ...(rawMeta.compat || {}),
+        legacyMarkdownCompatible: true
+      }
+    });
+  } else {
+    meta = assertValidGenomeMeta(
+      normalizeGenomeMeta({
+        genome,
+        compat: {
+          legacyMarkdownCompatible: true,
+          synthesizedFromLegacy: !isGenomeV2(parsedGenome)
+        }
+      })
+    );
+  }
+
+  return {
+    genome,
+    meta,
+    paths: {
+      markdownPath,
+      metaPath
+    }
+  };
+}
+
+async function loadExistingMeta(projectRoot, slug) {
+  const metaPath = getGenomeMetaPath(projectRoot, slug);
+  const rawMeta = await readMetaFile(metaPath, slug);
+  if (!rawMeta) return null;
+  try {
+    return normalizeGenomeMeta(rawMeta);
+  } catch {
+    return null;
+  }
+}
+
+async function writeGenome(projectRoot, genomeInput, metaInput) {
+  const normalizedGenome = assertValidGenome(
+    normalizeGenome({
+      ...genomeInput,
+      generated: genomeInput && genomeInput.generated ? genomeInput.generated : new Date().toISOString().slice(0, 10),
+      legacyFormat: false,
+      hasFrontmatter: true
+    })
+  );
+  const markdownPath = getGenomeMarkdownPath(projectRoot, normalizedGenome.slug);
+  const metaPath = getGenomeMetaPath(projectRoot, normalizedGenome.slug);
+  const existingMeta = await loadExistingMeta(projectRoot, normalizedGenome.slug);
+
+  const normalizedMeta = assertValidGenomeMeta(
+    normalizeGenomeMeta({
+      ...(existingMeta || {}),
+      ...(metaInput || {}),
+      schemaVersion: normalizedGenome.version,
+      version: normalizedGenome.version,
+      format: normalizedGenome.format,
+      genome: normalizedGenome,
+      compat: {
+        ...((existingMeta && existingMeta.compat) || {}),
+        ...((metaInput && metaInput.compat) || {}),
+        legacyMarkdownCompatible: true,
+        synthesizedFromLegacy: false
+      },
+      createdAt:
+        (metaInput && metaInput.createdAt) ||
+        (existingMeta && existingMeta.createdAt) ||
+        `${normalizedGenome.generated}T00:00:00.000Z`,
+      updatedAt: new Date().toISOString()
+    })
+  );
+
+  await ensureDir(getGenomeDir(projectRoot));
+  await fs.writeFile(markdownPath, serializeGenomeMarkdown(normalizedGenome), 'utf8');
+  await fs.writeFile(metaPath, `${JSON.stringify(normalizedMeta, null, 2)}\n`, 'utf8');
+
+  return {
+    genome: normalizedGenome,
+    meta: normalizedMeta,
+    paths: {
+      markdownPath,
+      metaPath
+    }
+  };
+}
+
+async function listGenomes(projectRoot) {
+  const genomeDir = getGenomeDir(projectRoot);
+  try {
+    const entries = await fs.readdir(genomeDir, { withFileTypes: true });
+    return entries
+      .filter((entry) => entry.isFile() && entry.name.endsWith('.md') && !entry.name.endsWith('.meta.json'))
+      .map((entry) => entry.name.slice(0, -3))
+      .sort();
+  } catch (error) {
+    if (error && error.code === 'ENOENT') return [];
+    throw error;
+  }
+}
+
+async function genomeExists(projectRoot, slug) {
+  return exists(getGenomeMarkdownPath(projectRoot, slug));
+}
+
+module.exports = {
+  getGenomeDir,
+  getGenomeMarkdownPath,
+  getGenomeMetaPath,
+  readGenome,
+  writeGenome,
+  listGenomes,
+  genomeExists
+};