swarmdo 1.16.0 → 1.17.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.16.0';
+  let ver = '1.17.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.16.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.17.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)
@@ -285,6 +285,7 @@ The recent release train added a full day-to-day operations layer around the swa
 | `swarmdo sbom` | **Software Bill of Materials from the lockfile** — emit a CycloneDX (default) or SPDX JSON manifest of every dependency with version, purl, license, and integrity hash, for compliance/vuln tooling. `--spec spdx`, `-o sbom.json`, `--production`. Completes the env/license/sbom supply-chain trio. Deterministic |
 | `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 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.16.0",
+  "version": "1.17.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/affected/affected.d.ts

@@ -0,0 +1,36 @@
+/**
+ * affected.ts — given changed files, compute the transitive set of files that
+ * (directly or indirectly) import them, and the minimal set of TEST files worth
+ * running. The deterministic core behind "only run what my change could break",
+ * à la `nx affected` / `jest --findRelatedTests` / `turbo --filter`.
+ *
+ * Composes codegraph's import graph: a change to X affects X, everything that
+ * imports X, everything that imports those, and so on (reverse-dependency
+ * closure). Pure — CodeIndex + changed paths in, affected/tests out; the git
+ * diff and index load live in ../commands/affected.ts, so it's fixture-testable.
+ */
+import type { CodeIndex } from '../codegraph/codegraph.js';
+/** Default matcher for test files (Jest/Vitest/Mocha conventions). */
+export declare function isTestFile(path: string): boolean;
+/** file it resolves to → files that import it (reverse of the import edges). Pure. */
+export declare function reverseDeps(index: CodeIndex): Map<string, string[]>;
+export interface AffectedOptions {
+    /** custom test-file matcher (default isTestFile) */
+    isTest?: (path: string) => boolean;
+}
+export interface AffectedResult {
+    /** every file transitively impacted, including the changed files (sorted) */
+    affected: string[];
+    /** the subset of `affected` that are test files (sorted) */
+    tests: string[];
+    /** changed files that the index knows nothing about (sorted) — may under-report */
+    unknown: string[];
+}
+/**
+ * Reverse-dependency closure from `changed` up the import graph. Deterministic:
+ * BFS over reverse edges, output sorted. A changed file not present anywhere in
+ * the index (never imported, declares nothing) is still reported as affected
+ * (it changed) but flagged in `unknown` since we can't see its dependents.
+ */
+export declare function computeAffected(changed: string[], index: CodeIndex, opts?: AffectedOptions): AffectedResult;
+//# sourceMappingURL=affected.d.ts.map

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

@@ -0,0 +1,78 @@
+/**
+ * affected.ts — given changed files, compute the transitive set of files that
+ * (directly or indirectly) import them, and the minimal set of TEST files worth
+ * running. The deterministic core behind "only run what my change could break",
+ * à la `nx affected` / `jest --findRelatedTests` / `turbo --filter`.
+ *
+ * Composes codegraph's import graph: a change to X affects X, everything that
+ * imports X, everything that imports those, and so on (reverse-dependency
+ * closure). Pure — CodeIndex + changed paths in, affected/tests out; the git
+ * diff and index load live in ../commands/affected.ts, so it's fixture-testable.
+ */
+/** Default matcher for test files (Jest/Vitest/Mocha conventions). */
+export function isTestFile(path) {
+    return /(^|\/)__tests__\//.test(path) || /\.(test|spec)\.[cm]?[jt]sx?$/.test(path);
+}
+/** file it resolves to → files that import it (reverse of the import edges). Pure. */
+export function reverseDeps(index) {
+    const rev = new Map();
+    for (const e of index.imports) {
+        if (!e.resolved)
+            continue; // external/unresolved — no internal reverse edge
+        let importers = rev.get(e.resolved);
+        if (!importers) {
+            importers = [];
+            rev.set(e.resolved, importers);
+        }
+        if (!importers.includes(e.from))
+            importers.push(e.from);
+    }
+    return rev;
+}
+/**
+ * Reverse-dependency closure from `changed` up the import graph. Deterministic:
+ * BFS over reverse edges, output sorted. A changed file not present anywhere in
+ * the index (never imported, declares nothing) is still reported as affected
+ * (it changed) but flagged in `unknown` since we can't see its dependents.
+ */
+export function computeAffected(changed, index, opts = {}) {
+    const isTest = opts.isTest ?? isTestFile;
+    const rev = reverseDeps(index);
+    // Files the index actually knows about (declares symbols or participates in imports).
+    const known = new Set();
+    for (const s of index.symbols)
+        known.add(s.file);
+    for (const e of index.imports) {
+        known.add(e.from);
+        if (e.resolved)
+            known.add(e.resolved);
+    }
+    const affected = new Set();
+    const queue = [];
+    for (const c of changed) {
+        if (!affected.has(c)) {
+            affected.add(c);
+            queue.push(c);
+        }
+    }
+    // BFS: for each affected file, add everyone who imports it.
+    while (queue.length > 0) {
+        const file = queue.shift();
+        const importers = rev.get(file);
+        if (!importers)
+            continue;
+        for (const imp of importers) {
+            if (!affected.has(imp)) {
+                affected.add(imp);
+                queue.push(imp);
+            }
+        }
+    }
+    const affectedList = [...affected].sort();
+    return {
+        affected: affectedList,
+        tests: affectedList.filter(isTest),
+        unknown: changed.filter((c) => !known.has(c)).sort(),
+    };
+}
+//# sourceMappingURL=affected.js.map

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

@@ -0,0 +1,17 @@
+/**
+ * `swarmdo affected` — from a git diff, list the files (and the test files)
+ * that a change could break, by walking codegraph's import graph. The "only run
+ * what my change touches" query, à la `nx affected` / `jest --findRelatedTests`.
+ *
+ *   swarmdo affected                       # vs working tree (staged+unstaged)
+ *   swarmdo affected --base main           # vs a ref
+ *   swarmdo affected --tests               # just the test files to run
+ *   swarmdo affected --tests --format json # feed a test runner
+ *
+ * Engine (../affected/affected.ts) is pure + tested; this captures the diff and
+ * loads (or builds) the index. Composes `codegraph`.
+ */
+import type { Command } from '../types.js';
+export declare const affectedCommand: Command;
+export default affectedCommand;
+//# sourceMappingURL=affected.d.ts.map

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

@@ -0,0 +1,100 @@
+/**
+ * `swarmdo affected` — from a git diff, list the files (and the test files)
+ * that a change could break, by walking codegraph's import graph. The "only run
+ * what my change touches" query, à la `nx affected` / `jest --findRelatedTests`.
+ *
+ *   swarmdo affected                       # vs working tree (staged+unstaged)
+ *   swarmdo affected --base main           # vs a ref
+ *   swarmdo affected --tests               # just the test files to run
+ *   swarmdo affected --tests --format json # feed a test runner
+ *
+ * Engine (../affected/affected.ts) is pure + tested; this captures the diff and
+ * loads (or builds) the index. Composes `codegraph`.
+ */
+import { execFileSync } from 'node:child_process';
+import { output } from '../output.js';
+import { computeAffected } from '../affected/affected.js';
+import { loadIndex, scanRepo, saveIndex } from '../codegraph/store.js';
+/** Collect changed repo-relative files: vs a base ref, or the working tree. */
+function changedFiles(root, base) {
+    const run = (args) => {
+        try {
+            return execFileSync('git', args, { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+        }
+        catch {
+            return '';
+        }
+    };
+    let out;
+    if (base) {
+        // Everything that differs from the base ref (three-dot: since the merge-base).
+        out = run(['diff', '--name-only', `${base}...`]);
+        if (!out.trim())
+            out = run(['diff', '--name-only', base]); // fallback: two-dot
+    }
+    else {
+        // Working tree: staged + unstaged + untracked.
+        out = run(['diff', '--name-only', 'HEAD']);
+        out += run(['ls-files', '--others', '--exclude-standard']);
+    }
+    return [...new Set(out.split('\n').map((l) => l.trim()).filter(Boolean))]
+        // Never count swarmdo's own state dir (incl. the codegraph.json we may write).
+        .filter((f) => f !== '.swarm' && !f.startsWith('.swarm/'))
+        .sort();
+}
+async function run(ctx) {
+    const root = ctx.cwd || process.cwd();
+    const base = typeof ctx.flags.base === 'string' ? ctx.flags.base : undefined;
+    const testsOnly = ctx.flags.tests === true;
+    const asJson = ctx.flags.format === 'json';
+    const changed = changedFiles(root, base);
+    if (changed.length === 0) {
+        if (asJson)
+            process.stdout.write(JSON.stringify({ changed: [], affected: [], tests: [], unknown: [] }, null, 2) + '\n');
+        else
+            output.writeln(output.dim(base ? `no changes vs ${base}` : 'no working-tree changes'));
+        return { success: true, exitCode: 0 };
+    }
+    // Prefer a saved codegraph index; build a fresh one if absent.
+    let index = loadIndex(root);
+    if (!index) {
+        index = scanRepo(root);
+        try {
+            saveIndex(root, index);
+        }
+        catch { /* read-only fs — fine, we have it in memory */ }
+    }
+    const result = computeAffected(changed, index);
+    const list = testsOnly ? result.tests : result.affected;
+    if (asJson) {
+        process.stdout.write(JSON.stringify({ changed, ...result }, null, 2) + '\n');
+    }
+    else if (testsOnly) {
+        // Plain list on stdout so it pipes straight into a test runner.
+        if (list.length)
+            process.stdout.write(list.join('\n') + '\n');
+        process.stderr.write(output.dim(`${result.tests.length} affected test file(s) from ${changed.length} changed\n`));
+    }
+    else {
+        output.writeln(output.bold(`Affected by ${changed.length} changed file(s)${base ? ` vs ${base}` : ''}:`));
+        for (const f of list)
+            output.writeln(`  ${f}`);
+        output.writeln(output.dim(`${result.affected.length} affected · ${result.tests.length} test file(s)${result.unknown.length ? ` · ${result.unknown.length} not in index` : ''}`));
+    }
+    return { success: true, exitCode: 0 };
+}
+export const affectedCommand = {
+    name: 'affected',
+    description: 'List files (and test files) a change could break, via the import graph — run only the tests your diff impacts (nx/turbo-style)',
+    options: [
+        { name: 'base', description: 'diff against a git ref (e.g. main); default is the working tree', type: 'string' },
+        { name: 'tests', description: 'output only the affected test files (one per line, for a test runner)', type: 'boolean' },
+    ],
+    examples: [
+        { command: 'swarmdo affected --base main', description: 'Files impacted since branching from main' },
+        { command: 'swarmdo affected --tests | xargs vitest run', description: 'Run only the tests your change affects' },
+    ],
+    action: run,
+};
+export default affectedCommand;
+//# sourceMappingURL=affected.js.map

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

@@ -44,6 +44,9 @@ const commandLoaders = {
     // Change-risk hotspots from git history (code-maat demand) — rank files by
     // churn × recency × author-spread; "where is the tech debt?" from data.
     hotspots: () => import('./hotspots.js'),
+    // 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'),
     // Queryable exported-symbol index (codegraph demand) — where things are
     // defined without grep+read round-trips.
     codegraph: () => import('./codegraph.js'),
@@ -277,7 +280,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,] = 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,] = 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'),
@@ -285,7 +288,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('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'),
     ]);
     return {
         primary: [
@@ -301,7 +304,7 @@ export async function getCommandsByCategory() {
         utility: [
             configCmd, doctorCmd, daemonCmd, completionsCmd,
             migrateCmd, workflowCmd, demoCmd,
-            statuslineCmd, compressCmd, compactCmd, redactCmd, packCmd, envCmd, licenseCmd, sbomCmd, applyCmd, hotspotsCmd, efficiencyCmd,
+            statuslineCmd, compressCmd, compactCmd, redactCmd, packCmd, envCmd, licenseCmd, sbomCmd, applyCmd, hotspotsCmd, affectedCmd, efficiencyCmd,
         ].filter(Boolean),
         analysis: [
             analyzeCmd, routeCmd, progressCmd, usageCmd, hudCmd, codegraphCmd,

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

@@ -25,6 +25,7 @@ import { envTools } from './mcp-tools/env-tools.js';
 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 { progressTools } from './mcp-tools/progress-tools.js';
 import { embeddingsTools } from './mcp-tools/embeddings-tools.js';
 import { claimsTools } from './mcp-tools/claims-tools.js';
@@ -114,6 +115,7 @@ const TOOL_GROUPS = {
     license: () => licenseTools,
     apply: () => applyTools,
     hotspots: () => hotspotsTools,
+    affected: () => affectedTools,
     progress: () => progressTools,
     embeddings: () => embeddingsTools,
     claims: () => claimsTools,

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

@@ -0,0 +1,12 @@
+/**
+ * Affected MCP Tool
+ *
+ * Given the files an agent just changed, return the transitive set of files —
+ * and the test files — that the change could break, by walking codegraph's
+ * import graph. Lets an agent run only the relevant tests after an edit instead
+ * of the whole suite. Shares the pure engine in ../affected/affected.ts; loads
+ * (or builds) the codegraph index for the repo.
+ */
+import type { MCPTool } from './types.js';
+export declare const affectedTools: MCPTool[];
+//# sourceMappingURL=affected-tools.d.ts.map

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

@@ -0,0 +1,36 @@
+/**
+ * Affected MCP Tool
+ *
+ * Given the files an agent just changed, return the transitive set of files —
+ * and the test files — that the change could break, by walking codegraph's
+ * import graph. Lets an agent run only the relevant tests after an edit instead
+ * of the whole suite. Shares the pure engine in ../affected/affected.ts; loads
+ * (or builds) the codegraph index for the repo.
+ */
+import { computeAffected } from '../affected/affected.js';
+import { loadIndex, scanRepo } from '../codegraph/store.js';
+const affectedTool = {
+    name: 'affected',
+    description: 'Given the repo-relative files you just changed, return the transitive set of files (and the test files) that the change could break, via the import graph. Call this after editing to run only the relevant tests instead of the whole suite. Composes codegraph.',
+    category: 'affected',
+    tags: ['tests', 'impact', 'import-graph', 'diff'],
+    inputSchema: {
+        type: 'object',
+        properties: {
+            changed: { type: 'array', items: { type: 'string' }, description: 'repo-relative paths you changed' },
+            path: { type: 'string', description: 'repo root to resolve the import graph in (default cwd)' },
+        },
+        required: ['changed'],
+    },
+    handler: async (params) => {
+        if (!Array.isArray(params.changed) || params.changed.some((c) => typeof c !== 'string')) {
+            return { error: true, message: 'changed (string[]) is required' };
+        }
+        const root = typeof params.path === 'string' ? params.path : process.cwd();
+        const index = loadIndex(root) ?? scanRepo(root);
+        const result = computeAffected(params.changed, index);
+        return { changed: params.changed, ...result };
+    },
+};
+export const affectedTools = [affectedTool];
+//# sourceMappingURL=affected-tools.js.map

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

@@ -21,6 +21,7 @@ export { envTools } from './env-tools.js';
 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 { 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

@@ -20,6 +20,7 @@ export { envTools } from './env-tools.js';
 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 { 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

@@ -27,6 +27,7 @@ const LEAN_GROUPS = [
     'env', // env_check — env-var drift (missing/unused/undocumented)
     '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
 ];
 /** 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.16.0",
+  "version": "1.17.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",