swarmdo 1.17.0 → 1.18.0

package/.claude/helpers/statusline.cjs

@@ -515,7 +515,7 @@ function getCostFromStdin() {
 // misses, the displayed version is meaningful (matches what the user
 // installed), not a stale hard-coded string.
 function getPkgVersion() {
-  let ver = '1.17.0';
+  let ver = '1.18.0';
   try {
     const home = os.homedir();
     const pkgPaths = [

package/README.md

@@ -2,7 +2,7 @@
 
 [![swarmdo](swarmdo/assets/brand/logo-full.svg)](https://swarmdo.com)
 
-[![npm version (swarmdo)](https://img.shields.io/badge/npx%20swarmdo-v1.17.0-cb3837?style=for-the-badge&logo=npm&logoColor=white)](https://github.com/SwarmDo/swarmdo/releases)
+[![npm version (swarmdo)](https://img.shields.io/badge/npx%20swarmdo-v1.18.0-cb3837?style=for-the-badge&logo=npm&logoColor=white)](https://github.com/SwarmDo/swarmdo/releases)
 [![MIT License](https://img.shields.io/badge/License-MIT-yellow?style=for-the-badge)](https://github.com/SwarmDo/swarmdo/blob/main/LICENSE)
 [![Website](https://img.shields.io/badge/swarmdo.com-e2a33c?style=for-the-badge&logoColor=black)](https://swarmdo.com)
 [![Star on GitHub](https://img.shields.io/github/stars/SwarmDo/swarmdo?style=for-the-badge&logo=github&color=gold)](https://github.com/SwarmDo/swarmdo)
@@ -286,6 +286,7 @@ The recent release train added a full day-to-day operations layer around the swa
 | `swarmdo apply` | **A forgiving `git apply`** — apply a unified diff with fuzzy context matching, so an agent's patch lands even when line numbers have drifted or a context line is slightly off, and reports exactly which hunks couldn't. `--dry-run` to preview, `--fuzz N` to tolerate more drift. Also an MCP tool (`apply_patch`). Deterministic |
 | `swarmdo hotspots` | **Change-risk hotspots from git history** — rank files by churn × recency × author-spread to surface the technical debt worth refactoring or testing, answered from data instead of a guess. `--since 90d`, `--by risk\|churn\|commits\|authors`, `--top N`, `--format json`. Pairs with `codegraph`; also an MCP tool (`hotspots`). Deterministic |
 | `swarmdo affected` | **Run only the tests your change touches** — from a git diff, walk `codegraph`'s import graph to list every file (and test file) a change could break (reverse-dependency closure, nx/turbo/`jest --findRelatedTests` style). `--base main`, `--tests` (pipeable list), `--format json`. Also an MCP tool (`affected`). Deterministic |
+| `swarmdo cycles` | **Find circular import dependencies** — an SCC scan over `codegraph`'s import graph surfaces the mutually-importing file groups (and self-imports) that cause temporal-dead-zone and `undefined`-export bugs, `madge --circular` style. `--ci` exits 1 on any cycle to gate a build; `--format json`. Also an MCP tool (`cycles`). Deterministic |
 | `swarmdo integrations` (alias `integrate`) | **Use swarmdo from Codex CLI, GitHub Copilot CLI, and pi** — one command wires AGENTS.md + each CLI's MCP config (idempotent, dry-run first, never touches your Claude Code setup) |
 | OpenRouter model pool | **Let swarms pick from any models you configure** — declare tier-mapped OpenRouter models in `swarmdo.config.json`; the router Thompson-samples among them per task and the execution layer dispatches the winner |
 | `swarmdo changelog` (alias `notes`) | **Release notes from conventional commits** — `--out NOTES.md` feeds `gh release create --notes-file` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swarmdo",
-  "version": "1.17.0",
+  "version": "1.18.0",
   "description": "Swarmdo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/v3/@swarmdo/cli/dist/src/commands/cycles.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `swarmdo cycles` — find circular import dependencies (madge --circular style).
+ *
+ *   swarmdo cycles              # report circular imports in the repo
+ *   swarmdo cycles --ci         # exit 1 if any cycle exists (gate a build)
+ *   swarmdo cycles --format json
+ *
+ * Composes codegraph's import graph; the detection is a provably-correct SCC
+ * scan (../cycles/cycles.ts, pure + tested). This loads or builds the index.
+ */
+import type { Command } from '../types.js';
+export declare const cyclesCommand: Command;
+export default cyclesCommand;
+//# sourceMappingURL=cycles.d.ts.map

package/v3/@swarmdo/cli/dist/src/commands/cycles.js

@@ -0,0 +1,51 @@
+/**
+ * `swarmdo cycles` — find circular import dependencies (madge --circular style).
+ *
+ *   swarmdo cycles              # report circular imports in the repo
+ *   swarmdo cycles --ci         # exit 1 if any cycle exists (gate a build)
+ *   swarmdo cycles --format json
+ *
+ * Composes codegraph's import graph; the detection is a provably-correct SCC
+ * scan (../cycles/cycles.ts, pure + tested). This loads or builds the index.
+ */
+import { output } from '../output.js';
+import { findCycles, formatCycles } from '../cycles/cycles.js';
+import { loadIndex, scanRepo, saveIndex } from '../codegraph/store.js';
+async function run(ctx) {
+    const root = ctx.cwd || process.cwd();
+    const asJson = ctx.flags.format === 'json';
+    const ci = ctx.flags.ci === true;
+    let index = loadIndex(root);
+    if (!index) {
+        index = scanRepo(root);
+        try {
+            saveIndex(root, index);
+        }
+        catch { /* read-only fs — index is in memory */ }
+    }
+    const res = findCycles(index);
+    const count = res.cycles.length + res.selfLoops.length;
+    if (asJson) {
+        process.stdout.write(JSON.stringify({ count, ...res }, null, 2) + '\n');
+    }
+    else {
+        output.writeln(formatCycles(res));
+    }
+    // In --ci mode, a cycle is a failure; otherwise report and succeed.
+    const code = ci && count > 0 ? 1 : 0;
+    return { success: code === 0, exitCode: code };
+}
+export const cyclesCommand = {
+    name: 'cycles',
+    description: 'Find circular import dependencies via the import graph (madge --circular style) — catch the TDZ/undefined-export bugs they cause',
+    options: [
+        { name: 'ci', description: 'exit 1 if any circular dependency exists (gate a build)', type: 'boolean' },
+    ],
+    examples: [
+        { command: 'swarmdo cycles', description: 'List circular imports in the repo' },
+        { command: 'swarmdo cycles --ci', description: 'Fail CI when a cycle is introduced' },
+    ],
+    action: run,
+};
+export default cyclesCommand;
+//# sourceMappingURL=cycles.js.map

package/v3/@swarmdo/cli/dist/src/commands/index.js

@@ -47,6 +47,9 @@ const commandLoaders = {
     // Affected-file/test set from a git diff (nx/turbo/jest --findRelatedTests
     // demand) — reverse-dependency closure over codegraph's import graph.
     affected: () => import('./affected.js'),
+    // Circular-import detector (madge --circular demand) — SCC scan over
+    // codegraph's import graph; catches TDZ/undefined-export bugs.
+    cycles: () => import('./cycles.js'),
     // Queryable exported-symbol index (codegraph demand) — where things are
     // defined without grep+read round-trips.
     codegraph: () => import('./codegraph.js'),
@@ -280,7 +283,7 @@ export async function getCommandsByCategory() {
     // three slots from 'statusline' onward (completionsCmd received the
     // statusline module, analyzeCmd received completions, …), scrambling the
     // categorized help. Every load now has a named slot.
-    const [daemonCmd, doctorCmd, embeddingsCmd, neuralCmd, performanceCmd, securityCmd, swarmvectorCmd, hiveMindCmd, configCmd, statuslineCmd, compressCmd, efficiencyCmd, completionsCmd, migrateCmd, workflowCmd, analyzeCmd, routeCmd, progressCmd, providersCmd, pluginsCmd, deploymentCmd, claimsCmd, issuesCmd, updateCmd, processCmd, guidanceCmd, applianceCmd, cleanupCmd, autopilotCmd, demoCmd, usageCmd, repairCmd, hudCmd, compactCmd, codegraphCmd, redactCmd, packCmd, envCmd, licenseCmd, sbomCmd, applyCmd, hotspotsCmd, affectedCmd,] = await Promise.all([
+    const [daemonCmd, doctorCmd, embeddingsCmd, neuralCmd, performanceCmd, securityCmd, swarmvectorCmd, hiveMindCmd, configCmd, statuslineCmd, compressCmd, efficiencyCmd, completionsCmd, migrateCmd, workflowCmd, analyzeCmd, routeCmd, progressCmd, providersCmd, pluginsCmd, deploymentCmd, claimsCmd, issuesCmd, updateCmd, processCmd, guidanceCmd, applianceCmd, cleanupCmd, autopilotCmd, demoCmd, usageCmd, repairCmd, hudCmd, compactCmd, codegraphCmd, redactCmd, packCmd, envCmd, licenseCmd, sbomCmd, applyCmd, hotspotsCmd, affectedCmd, cyclesCmd,] = await Promise.all([
         loadCommand('daemon'), loadCommand('doctor'), loadCommand('embeddings'), loadCommand('neural'),
         loadCommand('performance'), loadCommand('security'), loadCommand('swarmvector'), loadCommand('hive-mind'),
         loadCommand('config'), loadCommand('statusline'), loadCommand('compress'), loadCommand('efficiency'),
@@ -288,7 +291,7 @@ export async function getCommandsByCategory() {
         loadCommand('analyze'), loadCommand('route'), loadCommand('progress'), loadCommand('providers'),
         loadCommand('plugins'), loadCommand('deployment'), loadCommand('claims'), loadCommand('issues'),
         loadCommand('update'), loadCommand('process'), loadCommand('guidance'), loadCommand('appliance'),
-        loadCommand('cleanup'), loadCommand('autopilot'), loadCommand('demo'), loadCommand('usage'), loadCommand('repair'), loadCommand('hud'), loadCommand('compact'), loadCommand('codegraph'), loadCommand('redact'), loadCommand('pack'), loadCommand('env'), loadCommand('license'), loadCommand('sbom'), loadCommand('apply'), loadCommand('hotspots'), loadCommand('affected'),
+        loadCommand('cleanup'), loadCommand('autopilot'), loadCommand('demo'), loadCommand('usage'), loadCommand('repair'), loadCommand('hud'), loadCommand('compact'), loadCommand('codegraph'), loadCommand('redact'), loadCommand('pack'), loadCommand('env'), loadCommand('license'), loadCommand('sbom'), loadCommand('apply'), loadCommand('hotspots'), loadCommand('affected'), loadCommand('cycles'),
     ]);
     return {
         primary: [
@@ -304,7 +307,7 @@ export async function getCommandsByCategory() {
         utility: [
             configCmd, doctorCmd, daemonCmd, completionsCmd,
             migrateCmd, workflowCmd, demoCmd,
-            statuslineCmd, compressCmd, compactCmd, redactCmd, packCmd, envCmd, licenseCmd, sbomCmd, applyCmd, hotspotsCmd, affectedCmd, efficiencyCmd,
+            statuslineCmd, compressCmd, compactCmd, redactCmd, packCmd, envCmd, licenseCmd, sbomCmd, applyCmd, hotspotsCmd, affectedCmd, cyclesCmd, efficiencyCmd,
         ].filter(Boolean),
         analysis: [
             analyzeCmd, routeCmd, progressCmd, usageCmd, hudCmd, codegraphCmd,

package/v3/@swarmdo/cli/dist/src/cycles/cycles.d.ts

@@ -0,0 +1,37 @@
+/**
+ * cycles.ts — detect circular import dependencies in codegraph's import graph.
+ *
+ * Circular imports are a real source of bugs: temporal-dead-zone errors,
+ * `undefined` exports at module-eval time, and brittle initialization order.
+ * `madge --circular` / dpdm / skott exist precisely to surface them. This finds
+ * them provably via Tarjan's strongly-connected-components: every SCC with more
+ * than one file is a set of mutually-cyclic modules, and a file that imports
+ * itself is a one-node cycle.
+ *
+ * Pure + deterministic (O(V+E), stable sort) — CodeIndex in, cycle groups out.
+ * The index load lives in ../commands/cycles.ts, so this is fixture-testable.
+ */
+import type { CodeIndex } from '../codegraph/codegraph.js';
+/** Build file → sorted list of internal (resolved) imports. Pure. */
+export declare function buildAdjacency(index: CodeIndex): Map<string, string[]>;
+/**
+ * Tarjan's SCC. Returns every strongly-connected component as a member list.
+ * Iterative (no recursion) so deep graphs don't overflow the stack. Deterministic:
+ * nodes are visited in sorted order and each component is returned sorted.
+ */
+export declare function stronglyConnectedComponents(adj: Map<string, string[]>): string[][];
+export interface CycleResult {
+    /** each group of ≥2 files that are mutually reachable (a real import cycle) */
+    cycles: string[][];
+    /** files that import themselves (one-node cycles) */
+    selfLoops: string[];
+}
+/**
+ * Circular-dependency groups from the import graph. A component is a cycle when
+ * it has ≥2 files (mutual reachability) or a single file with a self-edge.
+ * Deterministic: groups sorted by size desc then first member.
+ */
+export declare function findCycles(index: CodeIndex): CycleResult;
+/** Human-readable summary. Pure. */
+export declare function formatCycles(res: CycleResult): string;
+//# sourceMappingURL=cycles.d.ts.map

package/v3/@swarmdo/cli/dist/src/cycles/cycles.js

@@ -0,0 +1,132 @@
+/**
+ * cycles.ts — detect circular import dependencies in codegraph's import graph.
+ *
+ * Circular imports are a real source of bugs: temporal-dead-zone errors,
+ * `undefined` exports at module-eval time, and brittle initialization order.
+ * `madge --circular` / dpdm / skott exist precisely to surface them. This finds
+ * them provably via Tarjan's strongly-connected-components: every SCC with more
+ * than one file is a set of mutually-cyclic modules, and a file that imports
+ * itself is a one-node cycle.
+ *
+ * Pure + deterministic (O(V+E), stable sort) — CodeIndex in, cycle groups out.
+ * The index load lives in ../commands/cycles.ts, so this is fixture-testable.
+ */
+/** Build file → sorted list of internal (resolved) imports. Pure. */
+export function buildAdjacency(index) {
+    const adj = new Map();
+    const ensure = (f) => {
+        let l = adj.get(f);
+        if (!l) {
+            l = [];
+            adj.set(f, l);
+        }
+        return l;
+    };
+    for (const e of index.imports) {
+        if (!e.resolved)
+            continue; // external — not part of internal cycles
+        const l = ensure(e.from);
+        if (!l.includes(e.resolved))
+            l.push(e.resolved);
+        ensure(e.resolved); // make sure the target is a node too
+    }
+    for (const l of adj.values())
+        l.sort();
+    return adj;
+}
+/**
+ * Tarjan's SCC. Returns every strongly-connected component as a member list.
+ * Iterative (no recursion) so deep graphs don't overflow the stack. Deterministic:
+ * nodes are visited in sorted order and each component is returned sorted.
+ */
+export function stronglyConnectedComponents(adj) {
+    let idx = 0;
+    const index = new Map();
+    const low = new Map();
+    const onStack = new Set();
+    const stack = [];
+    const out = [];
+    const nodes = [...adj.keys()].sort();
+    for (const start of nodes) {
+        if (index.has(start))
+            continue;
+        // Iterative DFS with an explicit work stack of (node, next-child-index).
+        const work = [{ node: start, i: 0 }];
+        while (work.length > 0) {
+            const frame = work[work.length - 1];
+            const { node } = frame;
+            if (frame.i === 0) {
+                index.set(node, idx);
+                low.set(node, idx);
+                idx++;
+                stack.push(node);
+                onStack.add(node);
+            }
+            const children = adj.get(node) ?? [];
+            if (frame.i < children.length) {
+                const next = children[frame.i];
+                frame.i++;
+                if (!index.has(next)) {
+                    work.push({ node: next, i: 0 });
+                }
+                else if (onStack.has(next)) {
+                    low.set(node, Math.min(low.get(node), index.get(next)));
+                }
+            }
+            else {
+                // Done with node — if it's a root, pop its SCC.
+                if (low.get(node) === index.get(node)) {
+                    const comp = [];
+                    for (;;) {
+                        const w = stack.pop();
+                        onStack.delete(w);
+                        comp.push(w);
+                        if (w === node)
+                            break;
+                    }
+                    out.push(comp.sort());
+                }
+                work.pop();
+                if (work.length > 0) {
+                    const parent = work[work.length - 1].node;
+                    low.set(parent, Math.min(low.get(parent), low.get(node)));
+                }
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Circular-dependency groups from the import graph. A component is a cycle when
+ * it has ≥2 files (mutual reachability) or a single file with a self-edge.
+ * Deterministic: groups sorted by size desc then first member.
+ */
+export function findCycles(index) {
+    const adj = buildAdjacency(index);
+    const selfLoops = [];
+    for (const [from, tos] of adj)
+        if (tos.includes(from))
+            selfLoops.push(from);
+    selfLoops.sort();
+    const cycles = stronglyConnectedComponents(adj)
+        .filter((c) => c.length >= 2)
+        .sort((a, b) => b.length - a.length || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
+    return { cycles, selfLoops };
+}
+/** Human-readable summary. Pure. */
+export function formatCycles(res) {
+    if (res.cycles.length === 0 && res.selfLoops.length === 0)
+        return 'no circular imports found ✓';
+    const lines = [];
+    res.cycles.forEach((c, i) => {
+        lines.push(`cycle ${i + 1} (${c.length} files):`);
+        for (const f of c)
+            lines.push(`  ${f}`);
+    });
+    for (const s of res.selfLoops)
+        lines.push(`self-import: ${s}`);
+    const n = res.cycles.length + res.selfLoops.length;
+    lines.push(`${n} circular ${n === 1 ? 'dependency' : 'dependencies'} found`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=cycles.js.map

package/v3/@swarmdo/cli/dist/src/mcp-client.js

@@ -26,6 +26,7 @@ import { licenseTools } from './mcp-tools/license-tools.js';
 import { applyTools } from './mcp-tools/apply-tools.js';
 import { hotspotsTools } from './mcp-tools/hotspots-tools.js';
 import { affectedTools } from './mcp-tools/affected-tools.js';
+import { cyclesTools } from './mcp-tools/cycles-tools.js';
 import { progressTools } from './mcp-tools/progress-tools.js';
 import { embeddingsTools } from './mcp-tools/embeddings-tools.js';
 import { claimsTools } from './mcp-tools/claims-tools.js';
@@ -116,6 +117,7 @@ const TOOL_GROUPS = {
     apply: () => applyTools,
     hotspots: () => hotspotsTools,
     affected: () => affectedTools,
+    cycles: () => cyclesTools,
     progress: () => progressTools,
     embeddings: () => embeddingsTools,
     claims: () => claimsTools,

package/v3/@swarmdo/cli/dist/src/mcp-tools/cycles-tools.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Cycles MCP Tool
+ *
+ * Let an agent check for circular import dependencies before it commits — the
+ * TDZ/undefined-export bugs that `madge --circular` catches. Returns the cycle
+ * groups (and self-imports) found in the repo's import graph. Shares the pure
+ * SCC engine in ../cycles/cycles.ts; loads (or builds) the codegraph index.
+ */
+import type { MCPTool } from './types.js';
+export declare const cyclesTools: MCPTool[];
+//# sourceMappingURL=cycles-tools.d.ts.map

package/v3/@swarmdo/cli/dist/src/mcp-tools/cycles-tools.js

@@ -0,0 +1,30 @@
+/**
+ * Cycles MCP Tool
+ *
+ * Let an agent check for circular import dependencies before it commits — the
+ * TDZ/undefined-export bugs that `madge --circular` catches. Returns the cycle
+ * groups (and self-imports) found in the repo's import graph. Shares the pure
+ * SCC engine in ../cycles/cycles.ts; loads (or builds) the codegraph index.
+ */
+import { findCycles } from '../cycles/cycles.js';
+import { loadIndex, scanRepo } from '../codegraph/store.js';
+const cyclesTool = {
+    name: 'cycles',
+    description: 'Find circular import dependencies in the repo via the import graph (madge --circular style). Returns the cyclic file groups — call this after wiring up modules to catch temporal-dead-zone / undefined-export bugs before they bite. Composes codegraph.',
+    category: 'cycles',
+    tags: ['imports', 'circular', 'graph', 'lint'],
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'repo root to analyze (default cwd)' },
+        },
+    },
+    handler: async (params) => {
+        const root = typeof params.path === 'string' ? params.path : process.cwd();
+        const index = loadIndex(root) ?? scanRepo(root);
+        const res = findCycles(index);
+        return { count: res.cycles.length + res.selfLoops.length, ...res };
+    },
+};
+export const cyclesTools = [cyclesTool];
+//# sourceMappingURL=cycles-tools.js.map

package/v3/@swarmdo/cli/dist/src/mcp-tools/index.d.ts

@@ -22,6 +22,7 @@ export { licenseTools } from './license-tools.js';
 export { applyTools } from './apply-tools.js';
 export { hotspotsTools } from './hotspots-tools.js';
 export { affectedTools } from './affected-tools.js';
+export { cyclesTools } from './cycles-tools.js';
 export { progressTools } from './progress-tools.js';
 export { transferTools } from './transfer-tools.js';
 export { securityTools } from './security-tools.js';

package/v3/@swarmdo/cli/dist/src/mcp-tools/index.js

@@ -21,6 +21,7 @@ export { licenseTools } from './license-tools.js';
 export { applyTools } from './apply-tools.js';
 export { hotspotsTools } from './hotspots-tools.js';
 export { affectedTools } from './affected-tools.js';
+export { cyclesTools } from './cycles-tools.js';
 export { progressTools } from './progress-tools.js';
 export { transferTools } from './transfer-tools.js';
 export { securityTools } from './security-tools.js';

package/v3/@swarmdo/cli/dist/src/mcp-tools/profiles.js

@@ -28,6 +28,7 @@ const LEAN_GROUPS = [
     'apply', // apply_patch — fuzzy unified-diff applier for agent edits
     'hotspots', // hotspots — git-history change-risk ranking ("where's the debt?")
     'affected', // affected — impacted files/tests from a change via the import graph
+    'cycles', // cycles — circular-import detection via the import graph
 ];
 /** Balanced = lean + orchestration/session/system the average user reaches for. */
 const BALANCED_EXTRA = [

package/v3/@swarmdo/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmdo/cli",
-  "version": "1.17.0",
+  "version": "1.18.0",
   "type": "module",
   "description": "Swarmdo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",