swarmdo 1.7.0 → 1.8.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.7.0';
+  let ver = '1.8.0';
   try {
     const home = os.homedir();
     const pkgPaths = [

package/README.md

@@ -2,7 +2,7 @@
 
 [![swarmdo](swarmdo/assets/swarmdo-banner.svg)](https://swarmdo.com)
 
-[![npm version (swarmdo)](https://img.shields.io/badge/npx%20swarmdo-v1.7.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.8.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)
@@ -277,7 +277,7 @@ The recent release train added a full day-to-day operations layer around the swa
 | `swarmdo worktree` (alias `wt`) | **Parallel-agent isolation** on git worktrees — add / list / diff / merge / remove |
 | `swarmdo transcript` (alias `tx`) | **Export any Claude Code session** to clean markdown — system noise stripped, ready to share; `transcript search <query>` full-text-searches every session |
 | `swarmdo compact` | **Compress noisy command output** before it reaches an LLM — strip ANSI, collapse repeats, fold `node_modules` stack frames, window long logs. `npm test 2>&1 \| swarmdo compact` or `swarmdo compact -- npm test` (exit code propagates). Deterministic, zero tokens |
-| `swarmdo codegraph` (alias `cg`) | **Queryable symbol index** — `codegraph index` scans TS/JS for exported symbols; `query <name>` (with `--fuzzy`/`--kind`) and `file <path>` answer "where is X defined / what does this file export" from `.swarm/codegraph.json` instead of grep+read round-trips. 1,750 symbols across 289 files in <1s |
+| `swarmdo codegraph` (alias `cg`) | **Queryable symbol index** — `codegraph index` scans TS/JS for exported symbols; `query <name>` (with `--fuzzy`/`--kind`) and `file <path>` answer "where is X defined / what does this file export" from `.swarm/codegraph.json` instead of grep+read round-trips. 1,750 symbols across 289 files in <1s. Also exposed as MCP tools (`codegraph_query`/`file`/`index`/`stats`) so agents query the index in-session |
 | `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.7.0",
+  "version": "1.8.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/codegraph/store.d.ts

@@ -0,0 +1,19 @@
+/**
+ * store.ts — the filesystem layer for codegraph: walk the tree, read sources,
+ * build the index (via the pure engine), and persist/load .swarm/codegraph.json.
+ * Shared by the `codegraph` CLI command and the codegraph MCP tools so the
+ * scan/persist behaviour can't drift between them.
+ */
+import { type CodeIndex } from './codegraph.js';
+export declare const INDEX_REL: string;
+/** Recursively collect source files under `root`, skipping vendor/build dirs and .d.ts. */
+export declare function walkSourceFiles(root: string): string[];
+export declare function indexPath(root: string): string;
+/** Scan a repo (or a subpath of it) and build the index. `root` is the repo
+ * root used for relative paths; `scanRoot` (default = root) is where to walk. */
+export declare function scanRepo(root: string, scanRoot?: string): CodeIndex;
+/** Persist the index to .swarm/codegraph.json under `root`. */
+export declare function saveIndex(root: string, index: CodeIndex): void;
+/** Load the persisted index, or null if none/unreadable. */
+export declare function loadIndex(root: string): CodeIndex | null;
+//# sourceMappingURL=store.d.ts.map

package/v3/@swarmdo/cli/dist/src/codegraph/store.js

@@ -0,0 +1,80 @@
+/**
+ * store.ts — the filesystem layer for codegraph: walk the tree, read sources,
+ * build the index (via the pure engine), and persist/load .swarm/codegraph.json.
+ * Shared by the `codegraph` CLI command and the codegraph MCP tools so the
+ * scan/persist behaviour can't drift between them.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { buildIndex } from './codegraph.js';
+export const INDEX_REL = path.join('.swarm', 'codegraph.json');
+const SOURCE_EXT = new Set(['.ts', '.tsx', '.js', '.jsx', '.mts', '.cts', '.mjs', '.cjs']);
+const SKIP_DIRS = new Set([
+    'node_modules', '.git', '.swarm', 'dist', 'dist-standalone', 'build',
+    'coverage', '.next', '.turbo', 'out', 'vendor', '.cache',
+]);
+/** Recursively collect source files under `root`, skipping vendor/build dirs and .d.ts. */
+export function walkSourceFiles(root) {
+    const found = [];
+    const stack = [root];
+    while (stack.length) {
+        const dir = stack.pop();
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            const full = path.join(dir, e.name);
+            if (e.isDirectory()) {
+                if (SKIP_DIRS.has(e.name))
+                    continue;
+                stack.push(full);
+            }
+            else if (e.isFile()) {
+                const ext = path.extname(e.name);
+                if (SOURCE_EXT.has(ext) && !e.name.endsWith('.d.ts'))
+                    found.push(full);
+            }
+        }
+    }
+    return found;
+}
+function safeRead(abs) {
+    try {
+        return fs.readFileSync(abs, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+export function indexPath(root) {
+    return path.join(root, INDEX_REL);
+}
+/** Scan a repo (or a subpath of it) and build the index. `root` is the repo
+ * root used for relative paths; `scanRoot` (default = root) is where to walk. */
+export function scanRepo(root, scanRoot = root) {
+    const files = walkSourceFiles(scanRoot);
+    const read = files
+        .map((abs) => ({ file: path.relative(root, abs), source: safeRead(abs) }))
+        .filter((f) => f.source !== null);
+    return buildIndex(read);
+}
+/** Persist the index to .swarm/codegraph.json under `root`. */
+export function saveIndex(root, index) {
+    const p = indexPath(root);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(index));
+}
+/** Load the persisted index, or null if none/unreadable. */
+export function loadIndex(root) {
+    try {
+        return JSON.parse(fs.readFileSync(indexPath(root), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=store.js.map

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

@@ -11,59 +11,10 @@
  * Engine (../codegraph/codegraph.ts) is pure + tested; this layer does the fs
  * walk and JSON persistence. MVP: exported top-level symbols in TS/JS.
  */
-import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { output } from '../output.js';
-import { buildIndex, queryIndex, symbolsInFile, indexStats, } from '../codegraph/codegraph.js';
-const INDEX_REL = path.join('.swarm', 'codegraph.json');
-const SOURCE_EXT = new Set(['.ts', '.tsx', '.js', '.jsx', '.mts', '.cts', '.mjs', '.cjs']);
-const SKIP_DIRS = new Set([
-    'node_modules', '.git', '.swarm', 'dist', 'dist-standalone', 'build',
-    'coverage', '.next', '.turbo', 'out', 'vendor', '.cache',
-]);
-function walkSourceFiles(root) {
-    const found = [];
-    const stack = [root];
-    while (stack.length) {
-        const dir = stack.pop();
-        let entries;
-        try {
-            entries = fs.readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
-        for (const e of entries) {
-            if (e.name.startsWith('.') && e.name !== '.') {
-                if (e.isDirectory() && SKIP_DIRS.has(e.name))
-                    continue;
-            }
-            const full = path.join(dir, e.name);
-            if (e.isDirectory()) {
-                if (SKIP_DIRS.has(e.name))
-                    continue;
-                stack.push(full);
-            }
-            else if (e.isFile()) {
-                const ext = path.extname(e.name);
-                if (SOURCE_EXT.has(ext) && !e.name.endsWith('.d.ts'))
-                    found.push(full);
-            }
-        }
-    }
-    return found;
-}
-function indexPath(root) {
-    return path.join(root, INDEX_REL);
-}
-function loadIndex(root) {
-    try {
-        return JSON.parse(fs.readFileSync(indexPath(root), 'utf8'));
-    }
-    catch {
-        return null;
-    }
-}
+import { queryIndex, symbolsInFile, indexStats, } from '../codegraph/codegraph.js';
+import { INDEX_REL, scanRepo, saveIndex, loadIndex } from '../codegraph/store.js';
 function fmtSymbol(s) {
     return `${s.file}:${s.line}  ${output.dim(`[${s.kind}]`)} ${s.signature}`;
 }
@@ -76,12 +27,8 @@ const indexCommand = {
     action: async (ctx) => {
         const root = ctx.cwd || process.cwd();
         const scanRoot = ctx.args[0] ? path.resolve(root, ctx.args[0]) : root;
-        const files = walkSourceFiles(scanRoot);
-        const read = files.map((abs) => ({ file: path.relative(root, abs), source: safeRead(abs) }));
-        const index = buildIndex(read.filter((f) => f.source !== null));
-        const dir = path.dirname(indexPath(root));
-        fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(indexPath(root), JSON.stringify(index));
+        const index = scanRepo(root, scanRoot);
+        saveIndex(root, index);
         const stats = indexStats(index);
         if (ctx.flags.json === true) {
             output.printJson({ ...stats, path: INDEX_REL });
@@ -92,14 +39,6 @@ const indexCommand = {
         return { success: true, exitCode: 0 };
     },
 };
-function safeRead(abs) {
-    try {
-        return fs.readFileSync(abs, 'utf8');
-    }
-    catch {
-        return null;
-    }
-}
 const queryCommand = {
     name: 'query',
     aliases: ['q'],

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

@@ -19,6 +19,7 @@ import { sessionTools } from './mcp-tools/session-tools.js';
 import { hiveMindTools } from './mcp-tools/hive-mind-tools.js';
 import { workflowTools } from './mcp-tools/workflow-tools.js';
 import { analyzeTools } from './mcp-tools/analyze-tools.js';
+import { codegraphTools } from './mcp-tools/codegraph-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';
@@ -102,6 +103,7 @@ const TOOL_GROUPS = {
     'hive-mind': () => hiveMindTools,
     workflow: () => workflowTools,
     analyze: () => analyzeTools,
+    codegraph: () => codegraphTools,
     progress: () => progressTools,
     embeddings: () => embeddingsTools,
     claims: () => claimsTools,

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

@@ -0,0 +1,11 @@
+/**
+ * Codegraph MCP Tools
+ *
+ * Make the exported-symbol index (see ../codegraph) agent-native: an agent can
+ * ask "where is X defined?" / "what does file Y export?" in-session via MCP
+ * instead of shelling out to `swarmdo codegraph` or grep+read. Reads the same
+ * .swarm/codegraph.json the CLI writes (shared fs layer in codegraph/store.ts).
+ */
+import type { MCPTool } from './types.js';
+export declare const codegraphTools: MCPTool[];
+//# sourceMappingURL=codegraph-tools.d.ts.map

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

@@ -0,0 +1,122 @@
+/**
+ * Codegraph MCP Tools
+ *
+ * Make the exported-symbol index (see ../codegraph) agent-native: an agent can
+ * ask "where is X defined?" / "what does file Y export?" in-session via MCP
+ * instead of shelling out to `swarmdo codegraph` or grep+read. Reads the same
+ * .swarm/codegraph.json the CLI writes (shared fs layer in codegraph/store.ts).
+ */
+import { queryIndex, symbolsInFile, indexStats } from '../codegraph/codegraph.js';
+import { INDEX_REL, scanRepo, saveIndex, loadIndex } from '../codegraph/store.js';
+const KINDS = ['function', 'class', 'interface', 'type', 'const', 'enum', 'default'];
+/** Resolve the repo root for scan/load. Params may override; default = cwd. */
+function rootOf(params) {
+    const p = params.root;
+    return typeof p === 'string' && p ? p : process.cwd();
+}
+const codegraphIndexTool = {
+    name: 'codegraph_index',
+    description: 'Scan the codebase for exported symbols and persist a queryable index to .swarm/codegraph.json. Run this once before codegraph_query/codegraph_file (or when files have changed). Use instead of a manual grep sweep when you want a structured symbol map.',
+    category: 'codegraph',
+    tags: ['code', 'symbols', 'index', 'navigation'],
+    inputSchema: {
+        type: 'object',
+        properties: {
+            root: { type: 'string', description: 'Repo root (default: current working directory)' },
+            path: { type: 'string', description: 'Subpath to scan, relative to root (default: whole repo)' },
+        },
+    },
+    handler: async (params) => {
+        const root = rootOf(params);
+        const scanRoot = typeof params.path === 'string' && params.path ? `${root}/${params.path}` : root;
+        try {
+            const index = scanRepo(root, scanRoot);
+            saveIndex(root, index);
+            return { ok: true, indexPath: INDEX_REL, ...indexStats(index) };
+        }
+        catch (e) {
+            return { error: true, message: e instanceof Error ? e.message : String(e) };
+        }
+    },
+};
+const codegraphQueryTool = {
+    name: 'codegraph_query',
+    description: 'Find where a symbol is defined by name — returns file, line, kind, and signature. Prefer this over grep for "where is X defined": it hits a prebuilt index (no file reads) and disambiguates by kind. Requires a prior codegraph_index. Use fuzzy for substring/partial names.',
+    category: 'codegraph',
+    tags: ['code', 'symbols', 'query', 'navigation'],
+    inputSchema: {
+        type: 'object',
+        properties: {
+            name: { type: 'string', description: 'Symbol name to find' },
+            fuzzy: { type: 'boolean', description: 'Substring, case-insensitive match instead of exact', default: false },
+            kind: { type: 'string', description: `Restrict to one kind: ${KINDS.join(', ')}`, enum: KINDS },
+            root: { type: 'string', description: 'Repo root (default: current working directory)' },
+        },
+        required: ['name'],
+    },
+    handler: async (params) => {
+        const root = rootOf(params);
+        const name = params.name;
+        if (typeof name !== 'string' || !name)
+            return { error: true, message: 'name is required' };
+        const index = loadIndex(root);
+        if (!index)
+            return { error: true, message: 'no index — run codegraph_index first' };
+        const hits = queryIndex(index, name, {
+            fuzzy: params.fuzzy === true,
+            kind: params.kind,
+        });
+        return { count: hits.length, symbols: hits };
+    },
+};
+const codegraphFileTool = {
+    name: 'codegraph_file',
+    description: 'List the symbols a specific file exports (name, line, kind) from the index — a fast "what does this module expose?" without reading the file. Requires a prior codegraph_index.',
+    category: 'codegraph',
+    tags: ['code', 'symbols', 'file', 'navigation'],
+    inputSchema: {
+        type: 'object',
+        properties: {
+            file: { type: 'string', description: 'Repo-relative file path (as indexed, e.g. src/index.ts)' },
+            root: { type: 'string', description: 'Repo root (default: current working directory)' },
+        },
+        required: ['file'],
+    },
+    handler: async (params) => {
+        const root = rootOf(params);
+        const file = params.file;
+        if (typeof file !== 'string' || !file)
+            return { error: true, message: 'file is required' };
+        const index = loadIndex(root);
+        if (!index)
+            return { error: true, message: 'no index — run codegraph_index first' };
+        const hits = symbolsInFile(index, file);
+        return { file, count: hits.length, symbols: hits };
+    },
+};
+const codegraphStatsTool = {
+    name: 'codegraph_stats',
+    description: 'Summary of the current symbol index: file count, symbol count, and a breakdown by kind. Requires a prior codegraph_index.',
+    category: 'codegraph',
+    tags: ['code', 'symbols', 'stats'],
+    inputSchema: {
+        type: 'object',
+        properties: {
+            root: { type: 'string', description: 'Repo root (default: current working directory)' },
+        },
+    },
+    handler: async (params) => {
+        const root = rootOf(params);
+        const index = loadIndex(root);
+        if (!index)
+            return { error: true, message: 'no index — run codegraph_index first' };
+        return indexStats(index);
+    },
+};
+export const codegraphTools = [
+    codegraphIndexTool,
+    codegraphQueryTool,
+    codegraphFileTool,
+    codegraphStatsTool,
+];
+//# sourceMappingURL=codegraph-tools.js.map

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

@@ -15,6 +15,7 @@ export { hiveMindTools } from './hive-mind-tools.js';
 export { workflowTools } from './workflow-tools.js';
 export { coverageRouterTools } from '../swarmvector/coverage-tools.js';
 export { analyzeTools } from './analyze-tools.js';
+export { codegraphTools } from './codegraph-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

@@ -14,6 +14,7 @@ export { hiveMindTools } from './hive-mind-tools.js';
 export { workflowTools } from './workflow-tools.js';
 export { coverageRouterTools } from '../swarmvector/coverage-tools.js';
 export { analyzeTools } from './analyze-tools.js';
+export { codegraphTools } from './codegraph-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

@@ -22,6 +22,7 @@ const LEAN_GROUPS = [
     'hooks', // hooks_route / pre-task / post-edit / codemod ...
     'agentdb', // agentdb pattern store/search
     'embeddings', // embeddings_generate / search / compare
+    'codegraph', // codegraph_query / file / index — "where is X defined?"
 ];
 /** 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.7.0",
+  "version": "1.8.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",