@jaimevalasek/aioson 1.6.0 → 1.7.0

package/src/commands/squad-bus.js

@@ -0,0 +1,217 @@
+'use strict';
+
+/**
+ * aioson squad:bus — Intra-squad message bus CLI
+ *
+ * Subcommands:
+ *   post    — Post a message to the bus
+ *   read    — Read messages from the bus
+ *   watch   — Watch for new messages in real time (polls)
+ *   summary — Show bus activity summary for a session
+ *   clear   — Delete the bus file for a session
+ *   list    — List sessions with active bus files
+ *
+ * Usage:
+ *   aioson squad:bus . --squad=content-team post --from=researcher --type=finding --content="..."
+ *   aioson squad:bus . --squad=content-team read --session=SESSION_ID [--to=writer] [--type=finding]
+ *   aioson squad:bus . --squad=content-team watch --session=SESSION_ID [--to=writer]
+ *   aioson squad:bus . --squad=content-team summary --session=SESSION_ID
+ *   aioson squad:bus . --squad=content-team clear --session=SESSION_ID
+ *   aioson squad:bus . --squad=content-team list
+ */
+
+const path = require('node:path');
+const bus = require('../squad/intra-bus');
+
+function formatMessage(msg, { compact = false } = {}) {
+  if (compact) {
+    return `[${msg.ts.slice(0, 19)}] ${msg.from}→${msg.to} (${msg.type}): ${String(msg.content).slice(0, 120)}`;
+  }
+  return [
+    `id:      ${msg.id}`,
+    `from:    ${msg.from}`,
+    `to:      ${msg.to}`,
+    `type:    ${msg.type}`,
+    `ts:      ${msg.ts}`,
+    `content: ${msg.content}`,
+    msg.metadata && Object.keys(msg.metadata).length > 0
+      ? `meta:    ${JSON.stringify(msg.metadata)}`
+      : null
+  ].filter(Boolean).join('\n');
+}
+
+async function runSquadBus({ args, options = {}, logger }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const sub = String(options.sub || args[1] || 'read').trim();
+  const squadSlug = String(options.squad || options.s || '').trim();
+  const sessionId = String(options.session || '').trim();
+
+  if (!squadSlug) {
+    logger.error('Error: --squad is required');
+    return { ok: false, error: 'missing_squad' };
+  }
+
+  // ── POST ──────────────────────────────────────────────────────────────────
+  if (sub === 'post') {
+    const from = String(options.from || '').trim();
+    const to = String(options.to || '*').trim();
+    const type = String(options.type || 'finding').trim();
+    const content = String(options.content || options.message || '').trim();
+    const sid = sessionId || String(options.s || 'default').trim();
+
+    if (!from) { logger.error('Error: --from is required for post'); return { ok: false }; }
+    if (!content) { logger.error('Error: --content is required for post'); return { ok: false }; }
+
+    let metadata = {};
+    if (options.meta) {
+      try { metadata = JSON.parse(options.meta); } catch { /* ignore */ }
+    }
+
+    const msg = await bus.post(targetDir, squadSlug, sid, { from, to, type, content, metadata });
+
+    if (options.json) return { ok: true, message: msg };
+
+    logger.log(`✓ Posted to bus [${sid}]`);
+    logger.log(formatMessage(msg));
+    return { ok: true, message: msg };
+  }
+
+  // ── READ ──────────────────────────────────────────────────────────────────
+  if (sub === 'read') {
+    if (!sessionId) { logger.error('Error: --session is required for read'); return { ok: false }; }
+
+    const filters = {
+      from: options.from || undefined,
+      to: options.to || undefined,
+      type: options.type || undefined,
+      since: options.since || undefined,
+      last: options.last ? Number(options.last) : undefined
+    };
+
+    const messages = await bus.read(targetDir, squadSlug, sessionId, filters);
+
+    if (options.json) return { ok: true, messages };
+
+    if (messages.length === 0) {
+      logger.log('No messages found.');
+      return { ok: true, messages: [] };
+    }
+
+    logger.log(`Bus [${sessionId}] — ${messages.length} message(s):`);
+    logger.log('─'.repeat(60));
+    for (const msg of messages) {
+      logger.log(formatMessage(msg, { compact: !!options.compact }));
+      logger.log('─'.repeat(60));
+    }
+    return { ok: true, messages };
+  }
+
+  // ── WATCH ─────────────────────────────────────────────────────────────────
+  if (sub === 'watch') {
+    if (!sessionId) { logger.error('Error: --session is required for watch'); return { ok: false }; }
+
+    const pollMs = options.poll ? Number(options.poll) : 1500;
+    const timeoutMs = options.timeout ? Number(options.timeout) * 1000 : 10 * 60 * 1000; // 10m default
+
+    logger.log(`Watching bus [${sessionId}] (Ctrl+C to stop, timeout ${Math.round(timeoutMs / 60000)}m)...`);
+
+    const filters = {
+      to: options.to || undefined,
+      type: options.type || undefined
+    };
+
+    let count = 0;
+    const stop = bus.watch(targetDir, squadSlug, sessionId, (msg) => {
+      count++;
+      logger.log(formatMessage(msg, { compact: false }));
+      logger.log('─'.repeat(60));
+    }, { pollMs, timeoutMs, ...filters });
+
+    await new Promise((resolve) => {
+      process.on('SIGINT', resolve);
+      process.on('SIGTERM', resolve);
+      setTimeout(resolve, timeoutMs);
+    });
+
+    stop();
+    logger.log(`Watch ended. ${count} message(s) received.`);
+    return { ok: true, count };
+  }
+
+  // ── SUMMARY ───────────────────────────────────────────────────────────────
+  if (sub === 'summary') {
+    if (!sessionId) { logger.error('Error: --session is required for summary'); return { ok: false }; }
+
+    const s = await bus.summary(targetDir, squadSlug, sessionId);
+
+    if (options.json) return { ok: true, summary: s };
+
+    logger.log(`Bus summary [${sessionId}]`);
+    logger.log('─'.repeat(50));
+    logger.log(`Total messages : ${s.total}`);
+    if (s.total === 0) {
+      logger.log('No messages yet.');
+      return { ok: true, summary: s };
+    }
+    logger.log(`First message  : ${s.first_ts}`);
+    logger.log(`Last message   : ${s.last_ts}`);
+    logger.log('');
+    logger.log('By type:');
+    for (const [type, count] of Object.entries(s.by_type)) {
+      logger.log(`  ${type.padEnd(12)} ${count}`);
+    }
+    logger.log('');
+    logger.log('By executor:');
+    for (const [exec, count] of Object.entries(s.by_executor)) {
+      logger.log(`  ${exec.padEnd(20)} ${count}`);
+    }
+    if (s.blocks.length > 0) {
+      logger.log('');
+      logger.log(`⚠ Blocks (${s.blocks.length}):`);
+      for (const b of s.blocks) {
+        logger.log(`  [${b.ts.slice(0, 19)}] ${b.from}: ${b.content}`);
+      }
+    }
+    return { ok: true, summary: s };
+  }
+
+  // ── CLEAR ─────────────────────────────────────────────────────────────────
+  if (sub === 'clear') {
+    if (!sessionId) { logger.error('Error: --session is required for clear'); return { ok: false }; }
+
+    const result = await bus.clear(targetDir, squadSlug, sessionId);
+
+    if (options.json) return result;
+
+    if (result.ok) {
+      logger.log(`✓ Bus cleared for session [${sessionId}]`);
+    } else {
+      logger.log(`No bus file found for session [${sessionId}]`);
+    }
+    return result;
+  }
+
+  // ── LIST ──────────────────────────────────────────────────────────────────
+  if (sub === 'list') {
+    const sessions = await bus.listSessions(targetDir, squadSlug);
+
+    if (options.json) return { ok: true, sessions };
+
+    if (sessions.length === 0) {
+      logger.log('No bus sessions found.');
+      return { ok: true, sessions: [] };
+    }
+
+    logger.log(`Bus sessions for squad "${squadSlug}" (${sessions.length}):`);
+    logger.log('─'.repeat(60));
+    for (const s of sessions) {
+      logger.log(`  ${s.session_id.padEnd(36)}  ${(s.size_bytes / 1024).toFixed(1)}KB  ${s.modified_at.slice(0, 19)}`);
+    }
+    return { ok: true, sessions };
+  }
+
+  logger.error(`Unknown subcommand: ${sub}. Valid: post, read, watch, summary, clear, list`);
+  return { ok: false, error: 'unknown_subcommand' };
+}
+
+module.exports = { runSquadBus };

package/src/commands/squad-card.js

@@ -0,0 +1,149 @@
+'use strict';
+
+/**
+ * aioson squad:card — Generate A2A Agent Card from squad manifest
+ *
+ * Creates a Google A2A v1.0 compatible Agent Card that describes a squad's
+ * capabilities, enabling discovery by external A2A-compatible agents.
+ *
+ * Usage:
+ *   aioson squad:card . --squad=content-team
+ *   aioson squad:card . --squad=content-team --output=.well-known/agent.json
+ *   aioson squad:card . --squad=content-team --port=3847 --json
+ */
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+const SQUADS_DIR = path.join('.aioson', 'squads');
+
+/**
+ * Read squad manifest.
+ */
+async function readManifest(projectDir, squadSlug) {
+  const manifestPath = path.join(projectDir, SQUADS_DIR, squadSlug, 'squad.manifest.json');
+  return JSON.parse(await fs.readFile(manifestPath, 'utf8'));
+}
+
+/**
+ * Generate an A2A Agent Card from a squad manifest.
+ *
+ * A2A Agent Card spec (v1.0):
+ *   - name, description, url, version
+ *   - capabilities: streaming, pushNotifications
+ *   - skills[]: id, name, description
+ *   - defaultInputModes, defaultOutputModes
+ */
+function generateAgentCard(manifest, options = {}) {
+  const { port = 3847, host = 'localhost' } = options;
+  const baseUrl = `http://${host}:${port}/a2a/${manifest.slug}`;
+
+  // Map executors to A2A skills
+  const skills = (manifest.executors || []).map((executor) => ({
+    id: executor.slug,
+    name: executor.title || executor.slug,
+    description: executor.role || `Executor: ${executor.slug}`
+  }));
+
+  // Add workflow-level skills
+  if (manifest.workflows) {
+    for (const wf of manifest.workflows) {
+      skills.push({
+        id: `workflow-${wf.slug}`,
+        name: wf.title || wf.slug,
+        description: `Workflow: ${wf.title || wf.slug}`
+      });
+    }
+  }
+
+  const card = {
+    name: manifest.name || manifest.slug,
+    description: manifest.mission || manifest.goal || `AIOSON Squad: ${manifest.slug}`,
+    url: baseUrl,
+    version: manifest.schemaVersion || '1.0.0',
+    provider: {
+      organization: 'AIOSON',
+      url: 'https://aiosforge.dev'
+    },
+    capabilities: {
+      streaming: true,
+      pushNotifications: true,
+      stateTransitionHistory: true
+    },
+    authentication: {
+      schemes: ['none']
+    },
+    skills,
+    defaultInputModes: ['text/plain', 'application/json'],
+    defaultOutputModes: ['text/plain', 'application/json']
+  };
+
+  // Add port information
+  if (manifest.ports) {
+    if (manifest.ports.inputs) {
+      card.inputPorts = manifest.ports.inputs.map((p) => ({
+        key: p.key,
+        dataType: p.dataType || 'any',
+        description: p.description,
+        required: p.required || false
+      }));
+    }
+    if (manifest.ports.outputs) {
+      card.outputPorts = manifest.ports.outputs.map((p) => ({
+        key: p.key,
+        dataType: p.dataType || 'any',
+        description: p.description
+      }));
+    }
+  }
+
+  return card;
+}
+
+/**
+ * CLI handler.
+ */
+async function runSquadCard({ args, options = {}, logger }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const squadSlug = String(options.squad || options.s || '').trim();
+
+  if (!squadSlug) {
+    logger.error('Error: --squad is required');
+    return { ok: false, error: 'missing_squad' };
+  }
+
+  let manifest;
+  try {
+    manifest = await readManifest(targetDir, squadSlug);
+  } catch (err) {
+    logger.error(`Error reading manifest: ${err.message}`);
+    return { ok: false, error: 'manifest_not_found' };
+  }
+
+  const port = Number(options.port || 3847);
+  const host = options.host || 'localhost';
+  const card = generateAgentCard(manifest, { port, host });
+
+  // Write to output path
+  const outputPath = options.output
+    ? path.resolve(targetDir, options.output)
+    : path.join(targetDir, '.well-known', `agent-${squadSlug}.json`);
+
+  await fs.mkdir(path.dirname(outputPath), { recursive: true });
+  await fs.writeFile(outputPath, JSON.stringify(card, null, 2), 'utf8');
+
+  if (options.json) return card;
+
+  logger.log(`A2A Agent Card for "${manifest.name || squadSlug}":`);
+  logger.log(`  URL:    ${card.url}`);
+  logger.log(`  Skills: ${card.skills.length}`);
+  for (const s of card.skills) {
+    logger.log(`    - ${s.id}: ${s.description}`);
+  }
+  logger.log('');
+  logger.log(`Output: ${path.relative(targetDir, outputPath)}`);
+
+  return { ok: true, card, outputPath: path.relative(targetDir, outputPath) };
+}
+
+module.exports = { runSquadCard, generateAgentCard };

package/src/commands/squad-daemon.js

@@ -4,6 +4,7 @@ const fs = require('node:fs/promises');
 const path = require('node:path');
 const { SquadDaemon } = require('../squad-daemon');
 const { openRuntimeDb } = require('../runtime-store');
+const { consume: consumeInterSquadEvents } = require('../squad/inter-squad-events');
 
 async function handleStart(projectDir, squadSlug, options, { logger, t }) {
   if (!squadSlug) {
@@ -186,11 +187,144 @@ async function handleLogs(projectDir, squadSlug, { logger, t }) {
   }
 }
 
+// ─── Persistent Execution Loop (4.3) ─────────────────────────────────────────
+
+/**
+ * Parse a loop-delay string like '30s', '2m', '1h' into milliseconds.
+ */
+function parseLoopDelay(str, defaultMs = 30_000) {
+  const s = String(str || '').trim().toLowerCase();
+  const match = s.match(/^(\d+)(s|m|h)?$/);
+  if (!match) return defaultMs;
+  const val = parseInt(match[1], 10);
+  const unit = match[2] || 's';
+  if (unit === 'h') return val * 3_600_000;
+  if (unit === 'm') return val * 60_000;
+  return val * 1_000;
+}
+
+/**
+ * Persistent daemon loop for a squad.
+ *
+ * Each iteration:
+ *   1. Check inter_squad_events for this squad (via manifest subscriptions)
+ *   2. If pending events: trigger squad:autorun to process them
+ *   3. Write daemon-alive.json heartbeat
+ *   4. Sleep loop-delay
+ *
+ * Exits gracefully on SIGTERM (waits for current iteration to finish).
+ */
+async function handlePersistent(projectDir, squadSlug, options, { logger }) {
+  if (!squadSlug) {
+    logger.error('Error: --squad is required for --persistent');
+    return { ok: false, error: 'missing_squad' };
+  }
+
+  const loopDelayMs = parseLoopDelay(options['loop-delay'] || options.loopDelay, 30_000);
+
+  // Load manifest for subscriptions
+  let manifest = {};
+  try {
+    const manifestPath = path.join(projectDir, '.aioson', 'squads', squadSlug, 'squad.manifest.json');
+    manifest = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
+  } catch { /* manifest optional */ }
+
+  const subscriptions = [
+    ...(manifest.subscriptions || []),
+    ...(manifest.depends_on || []).map((d) => d.event).filter(Boolean)
+  ];
+
+  const aliveJsonPath = path.join(projectDir, '.aioson', 'squads', squadSlug, 'daemon-alive.json');
+
+  logger.log(`Persistent daemon — squad: ${squadSlug}`);
+  logger.log(`Loop delay: ${loopDelayMs / 1000}s`);
+  logger.log(`Subscriptions: ${subscriptions.length > 0 ? subscriptions.join(', ') : '(none)'}`);
+  logger.log('Press Ctrl+C to stop');
+  logger.log('');
+
+  let running = true;
+  process.on('SIGTERM', () => { running = false; });
+  process.on('SIGINT', () => { running = false; });
+
+  let iteration = 0;
+
+  while (running) {
+    iteration++;
+    const now = new Date().toISOString();
+
+    // Write heartbeat
+    await fs.mkdir(path.dirname(aliveJsonPath), { recursive: true });
+    await fs.writeFile(aliveJsonPath, JSON.stringify({
+      squad: squadSlug,
+      iteration,
+      last_check: now,
+      subscriptions,
+      pid: process.pid
+    }, null, 2), 'utf8').catch(() => {});
+
+    // Check inter-squad events
+    if (subscriptions.length > 0) {
+      const events = await consumeInterSquadEvents(projectDir, {
+        toSquad: squadSlug,
+        subscriptions
+      }).catch(() => []);
+
+      if (events.length > 0) {
+        logger.log(`[${now.slice(11, 19)}] ${events.length} inter-squad event(s) received:`);
+        for (const ev of events) {
+          logger.log(`  ← [${ev.fromSquad}] ${ev.event}`);
+        }
+        logger.log(`  → Triggering squad:autorun for "${squadSlug}"...`);
+
+        // Trigger autorun via CLI subprocess
+        const { spawnSync } = require('node:child_process');
+        const goal = events.map((e) => `Process event: ${e.event} from ${e.fromSquad}`).join('; ');
+        const autorunResult = spawnSync('aioson', [
+          'squad:autorun', projectDir,
+          `--squad=${squadSlug}`,
+          `--goal=${goal}`,
+          '--reflect'
+        ], {
+          encoding: 'utf8',
+          timeout: 300_000, // 5 min per autorun
+          stdio: 'pipe'
+        });
+
+        if (autorunResult.status === 0) {
+          logger.log('  ✓ Autorun completed');
+        } else {
+          logger.log(`  ✗ Autorun exited ${autorunResult.status}: ${(autorunResult.stderr || '').trim().slice(0, 100)}`);
+        }
+      } else {
+        logger.log(`[${now.slice(11, 19)}] No pending events for "${squadSlug}" — sleeping ${loopDelayMs / 1000}s`);
+      }
+    } else {
+      logger.log(`[${now.slice(11, 19)}] Iteration ${iteration} — no subscriptions configured, heartbeat only`);
+    }
+
+    // Sleep loop-delay (interruptible)
+    if (running) {
+      await new Promise((resolve) => setTimeout(resolve, loopDelayMs));
+    }
+  }
+
+  logger.log('');
+  logger.log(`Persistent daemon stopped (${iteration} iteration(s) completed)`);
+  await fs.unlink(aliveJsonPath).catch(() => {});
+
+  return { ok: true, iterations: iteration };
+}
+
 async function runSquadDaemon({ args, options, logger, t }) {
   const targetDir = path.resolve(process.cwd(), args[0] || '.');
   const sub = options.sub || 'status';
   const squadSlug = options.squad;
 
+  // --persistent flag triggers persistent loop mode regardless of sub
+  if (options.persistent) {
+    return handlePersistent(targetDir, squadSlug, options, { logger });
+  }
+
   switch (sub) {
     case 'start':
       return handleStart(targetDir, squadSlug, options, { logger, t });

package/src/commands/squad-dependency-graph.js

@@ -0,0 +1,164 @@
+'use strict';
+
+/**
+ * aioson squad:dependency-graph [projectDir]
+ *
+ * Reads squad manifests and renders a dependency graph showing which squads
+ * depend on outputs from other squads via `depends_on[]` in their manifest.
+ *
+ * Usage:
+ *   aioson squad:dependency-graph .
+ *   aioson squad:dependency-graph . --format=mermaid
+ *   aioson squad:dependency-graph . --json
+ *
+ * Flags:
+ *   --format  Output format: ascii (default) | mermaid
+ *   --json    Return JSON with squads and edges
+ */
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+async function loadSquadManifests(projectDir) {
+  const squadsDir = path.join(projectDir, '.aioson', 'squads');
+  let entries;
+  try {
+    entries = await fs.readdir(squadsDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const manifests = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const manifestPath = path.join(squadsDir, entry.name, 'squad.manifest.json');
+    try {
+      const raw = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
+      manifests.push(raw);
+    } catch { /* skip invalid or missing manifests */ }
+  }
+  return manifests;
+}
+
+function buildEdges(manifests) {
+  const edges = [];
+  for (const manifest of manifests) {
+    for (const dep of manifest.depends_on || []) {
+      edges.push({
+        from: dep.squad,
+        to: manifest.slug,
+        event: dep.event || '*',
+        inputMapping: dep.input_mapping || null
+      });
+    }
+  }
+  return edges;
+}
+
+function renderAscii(manifests, edges) {
+  const lines = [];
+  lines.push('Inter-Squad Dependency Graph');
+  lines.push('─'.repeat(44));
+
+  if (edges.length === 0) {
+    lines.push('(No inter-squad dependencies declared)');
+    lines.push('');
+    lines.push('Declare dependencies in your squad manifest:');
+    lines.push('  "depends_on": [');
+    lines.push('    { "squad": "content-team", "event": "episode.created",');
+    lines.push('      "input_mapping": { "file": "tasks[0].context.episode_file" } }');
+    lines.push('  ]');
+  } else {
+    for (const edge of edges) {
+      const mapping = edge.inputMapping
+        ? `  [maps: ${JSON.stringify(edge.inputMapping)}]`
+        : '';
+      lines.push(`  [${edge.from}] ──(${edge.event})──▶ [${edge.to}]${mapping}`);
+    }
+  }
+
+  const involvedSlugs = new Set([
+    ...edges.map((e) => e.from),
+    ...edges.map((e) => e.to)
+  ]);
+  const isolated = manifests.filter((m) => !involvedSlugs.has(m.slug));
+  if (isolated.length > 0) {
+    lines.push('');
+    lines.push('Isolated squads (no declared dependencies):');
+    for (const m of isolated) {
+      lines.push(`  [${m.slug}]  ${m.mission ? '— ' + m.mission : ''}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+function renderMermaid(manifests, edges) {
+  const lines = ['graph LR'];
+  const slugs = new Set(manifests.map((m) => m.slug));
+
+  // Add squad nodes with labels
+  for (const m of manifests) {
+    lines.push(`  ${m.slug}["${m.name || m.slug}"]`);
+  }
+
+  // Add dependency nodes that might not have manifests in this project
+  for (const edge of edges) {
+    if (!slugs.has(edge.from)) {
+      lines.push(`  ${edge.from}["${edge.from} (external)"]`);
+    }
+  }
+
+  lines.push('');
+
+  // Add edges
+  for (const edge of edges) {
+    lines.push(`  ${edge.from} -->|"${edge.event}"| ${edge.to}`);
+  }
+
+  return lines.join('\n');
+}
+
+async function runSquadDependencyGraph({ args, options = {}, logger }) {
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+  const format = String(options.format || 'ascii').trim().toLowerCase();
+
+  const manifests = await loadSquadManifests(projectDir);
+
+  if (manifests.length === 0) {
+    logger.log('No squad manifests found in .aioson/squads/');
+    logger.log('Create a squad first: aioson squad:create .');
+    return { ok: true, squads: 0, edges: [] };
+  }
+
+  const edges = buildEdges(manifests);
+
+  if (options.json) {
+    return {
+      ok: true,
+      squads: manifests.map((m) => ({ slug: m.slug, name: m.name, dependsOn: m.depends_on || [] })),
+      edges
+    };
+  }
+
+  logger.log('');
+
+  if (format === 'mermaid') {
+    logger.log(renderMermaid(manifests, edges));
+  } else {
+    logger.log(renderAscii(manifests, edges));
+  }
+
+  logger.log('');
+  logger.log(`${manifests.length} squad(s) · ${edges.length} dependency edge(s)`);
+  logger.log('');
+  if (edges.length > 0) {
+    logger.log('Tips:');
+    logger.log('  • Squads publish events via: aioson inter-squad:publish . --from=<squad> --event=<name> --payload=\'{"key":"val"}\'');
+    logger.log('  • Squads consume events automatically at the start of squad:autorun');
+  }
+
+  return { ok: true, squads: manifests.length, edges };
+}
+
+module.exports = { runSquadDependencyGraph };