claude-flow 3.50.0 → 3.51.0

package/v3/@claude-flow/cli/dist/src/mods/command-registry/generate.d.ts

@@ -0,0 +1,51 @@
+/**
+ * ADR-406 P0/P1 — gather inputs (git history, packed npm contents, engine
+ * probes) and produce the inventory report, engine report and catalog.
+ *
+ * Reads command sources; writes only the catalog and report files it is given.
+ * External programs run through fixed argv with no shell (`execFileSync`).
+ */
+import { type EngineReport, type Runner } from './engine-report.js';
+import { type RawCommand } from './inventory.js';
+import type { CommandCatalog } from './schema.js';
+export declare const CATALOG_RELATIVE_PATH = "v3/@claude-flow/cli/src/mods/command-registry/catalog.generated.json";
+export declare const ENGINE_REPORT_RELATIVE_PATH = "v3/@claude-flow/cli/src/mods/command-registry/engine-report.generated.json";
+export declare const PROPOSED_NAMES: readonly ["ruflo", "ruflo-workbench", "ruflo-console"];
+export declare const defaultRunner: Runner;
+/**
+ * Last commit per repository-relative path, in one `git log` pass; dirty paths
+ * are dropped (they read as `uncommitted`). `order` lists commits newest first.
+ */
+export declare function lastCommits(repoRoot: string, roots: readonly string[], run?: Runner): {
+    byPath: Record<string, string>;
+    order: string[];
+    dirty: Set<string>;
+};
+/**
+ * The catalog's anchor: the newest commit that touched a file the catalog
+ * actually inventories, so unrelated plugin commits do not make it stale.
+ */
+export declare function anchorCommit(paths: readonly string[], commits: ReturnType<typeof lastCommits>): string;
+/** `npm pack --dry-run --json` file list for a package directory, made repository-relative. */
+export declare function packedFiles(repoRoot: string, packageDir: string, run?: Runner): {
+    name: string;
+    files: string[];
+} | null;
+export interface GenerateInput {
+    readonly repoRoot: string;
+    readonly engineExecutable: string | null;
+    readonly run?: Runner;
+    /** Skip `npm pack` (tests); shipped status is then not asserted. */
+    readonly inspectPackages?: boolean;
+}
+export interface GenerateResult {
+    readonly inventory: readonly RawCommand[];
+    readonly catalog: CommandCatalog;
+    readonly engine: EngineReport;
+    readonly modHookSource: 'engine-validate' | 'source-scan';
+    readonly packages: readonly string[];
+}
+export declare function generate(input: GenerateInput): GenerateResult;
+/** Counts for the P0 exit gate: every inventoried command is classified. */
+export declare function summarize(result: GenerateResult): Record<string, number | string>;
+//# sourceMappingURL=generate.d.ts.map

package/v3/@claude-flow/cli/dist/src/mods/command-registry/generate.js

@@ -0,0 +1,166 @@
+/**
+ * ADR-406 P0/P1 — gather inputs (git history, packed npm contents, engine
+ * probes) and produce the inventory report, engine report and catalog.
+ *
+ * Reads command sources; writes only the catalog and report files it is given.
+ * External programs run through fixed argv with no shell (`execFileSync`).
+ */
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { buildCatalog } from './catalog.js';
+import { probeEngine, hooksFromValidations } from './engine-report.js';
+import { CLI_TEMPLATE_COMMANDS_DIR, PROJECT_COMMANDS_DIR, collectInventory, scanModHooksFromSource, } from './inventory.js';
+export const CATALOG_RELATIVE_PATH = 'v3/@claude-flow/cli/src/mods/command-registry/catalog.generated.json';
+export const ENGINE_REPORT_RELATIVE_PATH = 'v3/@claude-flow/cli/src/mods/command-registry/engine-report.generated.json';
+export const PROPOSED_NAMES = ['ruflo', 'ruflo-workbench', 'ruflo-console'];
+export const defaultRunner = (file, args, env) => {
+    try {
+        const stdout = execFileSync(file, [...args], { env, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 120_000, maxBuffer: 64 * 1024 * 1024 });
+        return { status: 0, stdout, stderr: '' };
+    }
+    catch (error) {
+        const e = error;
+        return { status: e.status ?? null, stdout: String(e.stdout ?? ''), stderr: String(e.stderr ?? '') };
+    }
+};
+/**
+ * Last commit per repository-relative path, in one `git log` pass; dirty paths
+ * are dropped (they read as `uncommitted`). `order` lists commits newest first.
+ */
+export function lastCommits(repoRoot, roots, run = defaultRunner) {
+    const log = run('git', ['-C', repoRoot, 'log', '--format=%x00%H', '--name-only', '--', ...roots], process.env);
+    const byPath = {};
+    const order = [];
+    let current = '';
+    for (const line of log.stdout.split('\n')) {
+        if (line.startsWith('\u0000')) {
+            current = line.slice(1).trim();
+            order.push(current);
+            continue;
+        }
+        const path = line.trim();
+        if (path && current && !(path in byPath))
+            byPath[path] = current;
+    }
+    const status = run('git', ['-C', repoRoot, 'status', '--porcelain', '--untracked-files=all', '--', ...roots], process.env);
+    const dirty = new Set();
+    for (const line of status.stdout.split('\n')) {
+        const path = line.slice(3).trim();
+        if (path) {
+            delete byPath[path];
+            dirty.add(path);
+        }
+    }
+    return { byPath, order, dirty };
+}
+/**
+ * The catalog's anchor: the newest commit that touched a file the catalog
+ * actually inventories, so unrelated plugin commits do not make it stale.
+ */
+export function anchorCommit(paths, commits) {
+    if (paths.some((p) => commits.dirty.has(p) || !commits.byPath[p]))
+        return 'uncommitted';
+    const used = new Set(paths.map((p) => commits.byPath[p]));
+    return commits.order.find((c) => used.has(c)) ?? 'uncommitted';
+}
+/** `npm pack --dry-run --json` file list for a package directory, made repository-relative. */
+export function packedFiles(repoRoot, packageDir, run = defaultRunner) {
+    // The runner has no cwd; `npm pack <folder>` packs that folder's package.
+    const out = run('npm', ['pack', '--dry-run', '--json', '--ignore-scripts', join(repoRoot, packageDir)], process.env);
+    if (out.status !== 0)
+        return null;
+    try {
+        const parsed = JSON.parse(out.stdout.slice(out.stdout.indexOf('[')));
+        const prefix = packageDir === '.' ? '' : `${packageDir.replace(/\/$/, '')}/`;
+        return { name: parsed[0].name, files: parsed[0].files.map((f) => `${prefix}${f.path}`) };
+    }
+    catch {
+        return null;
+    }
+}
+export function generate(input) {
+    const run = input.run ?? defaultRunner;
+    const configDir = mkdtempSync(join(tmpdir(), 'ruflo-engine-probe-'));
+    try {
+        const roots = [PROJECT_COMMANDS_DIR, CLI_TEMPLATE_COMMANDS_DIR, 'plugins'].filter((r) => existsSync(join(input.repoRoot, r)));
+        const packed = {};
+        if (input.inspectPackages !== false) {
+            for (const dir of ['v3/@claude-flow/cli', '.', 'ruflo']) {
+                if (!existsSync(join(input.repoRoot, dir, 'package.json')))
+                    continue;
+                const p = packedFiles(input.repoRoot, dir, run);
+                if (p)
+                    packed[p.name] = p.files;
+            }
+        }
+        // First pass without hooks to know every existing name for collisions.
+        const sourceHooks = scanModHooksFromSource(input.repoRoot);
+        const preliminary = collectInventory({ repoRoot: input.repoRoot, modHooks: sourceHooks });
+        const engine = probeEngine({
+            repoRoot: input.repoRoot,
+            executable: input.engineExecutable,
+            isolatedConfigDir: configDir,
+            run,
+            proposedNames: PROPOSED_NAMES,
+            existingNames: new Set(preliminary.map((r) => r.key)),
+        });
+        // The engine confirms which command hooks exist; the source scan knows which
+        // file declares each. Prefer the declaring file so the catalog is the same
+        // whether or not an engine was available to confirm it.
+        const engineHooks = hooksFromValidations(engine.validations)
+            .map((h) => sourceHooks.find((s) => s.plugin === h.plugin && s.command === h.command) ?? h);
+        // A plugin whose matcher the engine reports as `?` names its commands only in source: keep those.
+        const dynamicPlugins = new Set(engine.validations.filter((v) => v.dynamicCommandHook).map((v) => v.plugin));
+        for (const s of sourceHooks) {
+            if (dynamicPlugins.has(s.plugin) && !engineHooks.some((h) => h.plugin === s.plugin && h.command === s.command))
+                engineHooks.push(s);
+        }
+        const useEngine = engine.validations.length > 0 && engine.validations.every((v) => v.passed === true);
+        const inventory = collectInventory({
+            repoRoot: input.repoRoot,
+            packedFiles: Object.keys(packed).length ? packed : undefined,
+            modHooks: useEngine ? engineHooks : sourceHooks,
+        });
+        const commits = lastCommits(input.repoRoot, roots, run);
+        const options = {
+            commits: commits.byPath,
+            packageContentsInspected: Object.keys(packed).length > 0,
+            sourceCommit: anchorCommit([...new Set(inventory.map((r) => r.source.sourcePath))], commits),
+        };
+        return {
+            inventory,
+            catalog: buildCatalog(inventory, options),
+            engine,
+            modHookSource: useEngine ? 'engine-validate' : 'source-scan',
+            packages: Object.keys(packed).sort(),
+        };
+    }
+    finally {
+        rmSync(configDir, { recursive: true, force: true });
+    }
+}
+/** Counts for the P0 exit gate: every inventoried command is classified. */
+export function summarize(result) {
+    const byStatus = {};
+    const byDisposition = {};
+    const byChannel = {};
+    for (const e of result.catalog.entries) {
+        byStatus[e.status] = (byStatus[e.status] ?? 0) + 1;
+        byDisposition[e.definition.disposition] = (byDisposition[e.definition.disposition] ?? 0) + 1;
+        for (const s of e.sources)
+            byChannel[s.channel] = (byChannel[s.channel] ?? 0) + 1;
+    }
+    return {
+        occurrences: result.inventory.length,
+        entries: result.catalog.entries.length,
+        divergent: result.catalog.entries.filter((e) => e.divergent).length,
+        modHookSource: result.modHookSource,
+        packages: result.packages.join(',') || 'none',
+        ...Object.fromEntries(Object.entries(byStatus).map(([k, v]) => [`status.${k}`, v])),
+        ...Object.fromEntries(Object.entries(byDisposition).map(([k, v]) => [`disposition.${k}`, v])),
+        ...Object.fromEntries(Object.entries(byChannel).map(([k, v]) => [`channel.${k}`, v])),
+    };
+}
+//# sourceMappingURL=generate.js.map

package/v3/@claude-flow/cli/dist/src/mods/command-registry/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ADR-406 canonical command registry (P0 inventory, P1 registry + catalog).
+ */
+export * from './schema.js';
+export * from './inventory.js';
+export * from './catalog.js';
+export * from './engine-report.js';
+export * from './generate.js';
+//# sourceMappingURL=index.d.ts.map

package/v3/@claude-flow/cli/dist/src/mods/command-registry/index.js

@@ -0,0 +1,9 @@
+/**
+ * ADR-406 canonical command registry (P0 inventory, P1 registry + catalog).
+ */
+export * from './schema.js';
+export * from './inventory.js';
+export * from './catalog.js';
+export * from './engine-report.js';
+export * from './generate.js';
+//# sourceMappingURL=index.js.map

package/v3/@claude-flow/cli/dist/src/mods/command-registry/inventory.d.ts

@@ -0,0 +1,63 @@
+/**
+ * ADR-406 P0 — command inventory.
+ *
+ * Scans every place a Ruflo slash command can come from and records, per
+ * occurrence, its source path, delivery channel, package, digest, the
+ * invocation spelling the engine exposes, and its runtime binding. It reads
+ * only; nothing here writes a command file.
+ *
+ * Spelling rules recorded here were checked against Claude Code 2.1.287 in a
+ * live session (see the engine report): project commands in a subfolder are
+ * `<dir>:<name>` (`sparc:architect`, `agents:README`), plugin commands are
+ * `<plugin>:<name>` (`ruflo-swarm:swarm`), and a mod's `$.command.register`
+ * name is used verbatim (`ruflo-swarm-status`).
+ *
+ * The loader exposes every `.md` file in a commands folder, including READMEs
+ * and compliance reports (`agents:README`, `analysis:COMMAND_COMPLIANCE_REPORT`
+ * appear in the session command list). Those are inventoried as documentation,
+ * not hidden and not counted as executable workflows.
+ */
+import type { InventorySource } from './schema.js';
+/** Mirror of `COMMANDS_MAP` in `src/init/executor.ts`; a parity test keeps them equal. */
+export declare const INIT_COMMAND_CATEGORIES: Readonly<Record<string, readonly string[]>>;
+export declare const PROJECT_COMMANDS_DIR = ".claude/commands";
+export declare const CLI_TEMPLATE_COMMANDS_DIR = "v3/@claude-flow/cli/.claude/commands";
+export declare const MARKETPLACE_MANIFEST = ".claude-plugin/marketplace.json";
+/** One occurrence of a command in one delivery channel. */
+export interface RawCommand {
+    readonly key: string;
+    readonly ownerPlugin: string;
+    readonly content?: string;
+    readonly source: InventorySource;
+}
+/** A mod `command.run` hook as the engine's static scan reports it. */
+export interface ModCommandHook {
+    readonly plugin: string;
+    readonly command: string;
+    readonly sourcePath: string;
+}
+export interface InventoryInput {
+    readonly repoRoot: string;
+    /** Repository-relative packed file lists per npm package (from `npm pack --dry-run --json`). */
+    readonly packedFiles?: Readonly<Record<string, readonly string[]>>;
+    /** Mod command hooks; from `claude plugin validate` when available, else a source scan. */
+    readonly modHooks?: readonly ModCommandHook[];
+}
+export declare function sha256Hex(data: string | Buffer): string;
+/** `sparc/architect.md` -> `sparc:architect`. */
+export declare function projectInvocation(relativeToCommandsDir: string): string;
+interface MarketplacePlugin {
+    name: string;
+    source: string;
+}
+export declare function readMarketplace(repoRoot: string): MarketplacePlugin[];
+/**
+ * Static fallback for mod hooks when the engine is not available: the
+ * `command.run` matchers written in each plugin's hooks sources. The engine
+ * report replaces this with `claude plugin validate` output when it can run.
+ */
+export declare function scanModHooksFromSource(repoRoot: string): ModCommandHook[];
+/** Everything the repository and its packages expose as a slash command. */
+export declare function collectInventory(input: InventoryInput): RawCommand[];
+export {};
+//# sourceMappingURL=inventory.d.ts.map

package/v3/@claude-flow/cli/dist/src/mods/command-registry/inventory.js

@@ -0,0 +1,230 @@
+/**
+ * ADR-406 P0 — command inventory.
+ *
+ * Scans every place a Ruflo slash command can come from and records, per
+ * occurrence, its source path, delivery channel, package, digest, the
+ * invocation spelling the engine exposes, and its runtime binding. It reads
+ * only; nothing here writes a command file.
+ *
+ * Spelling rules recorded here were checked against Claude Code 2.1.287 in a
+ * live session (see the engine report): project commands in a subfolder are
+ * `<dir>:<name>` (`sparc:architect`, `agents:README`), plugin commands are
+ * `<plugin>:<name>` (`ruflo-swarm:swarm`), and a mod's `$.command.register`
+ * name is used verbatim (`ruflo-swarm-status`).
+ *
+ * The loader exposes every `.md` file in a commands folder, including READMEs
+ * and compliance reports (`agents:README`, `analysis:COMMAND_COMPLIANCE_REPORT`
+ * appear in the session command list). Those are inventoried as documentation,
+ * not hidden and not counted as executable workflows.
+ */
+import { createHash } from 'node:crypto';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+/** Mirror of `COMMANDS_MAP` in `src/init/executor.ts`; a parity test keeps them equal. */
+export const INIT_COMMAND_CATEGORIES = Object.freeze({
+    core: ['claude-flow-help.md', 'claude-flow-swarm.md', 'claude-flow-memory.md'],
+    analysis: ['analysis'],
+    automation: ['automation'],
+    github: ['github'],
+    hooks: ['hooks'],
+    monitoring: ['monitoring'],
+    optimization: ['optimization'],
+    sparc: ['sparc'],
+    agents: ['agents'],
+    coordination: ['coordination'],
+    hiveMind: ['hive-mind'],
+    memory: ['memory'],
+    swarm: ['swarm'],
+    workflows: ['workflows'],
+    pair: ['pair'],
+    training: ['training'],
+    streamChain: ['stream-chain'],
+    truth: ['truth'],
+    verify: ['verify'],
+});
+export const PROJECT_COMMANDS_DIR = '.claude/commands';
+export const CLI_TEMPLATE_COMMANDS_DIR = 'v3/@claude-flow/cli/.claude/commands';
+export const MARKETPLACE_MANIFEST = '.claude-plugin/marketplace.json';
+export function sha256Hex(data) {
+    return createHash('sha256').update(data).digest('hex');
+}
+function toPosix(path) {
+    return path.split(sep).join('/');
+}
+function listMarkdown(dir) {
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    const walk = (current) => {
+        for (const name of readdirSync(current).sort()) {
+            const full = join(current, name);
+            const stat = statSync(full);
+            if (stat.isDirectory())
+                walk(full);
+            else if (stat.isFile() && name.endsWith('.md'))
+                out.push(full);
+        }
+    };
+    walk(dir);
+    return out;
+}
+/** `sparc/architect.md` -> `sparc:architect`. */
+export function projectInvocation(relativeToCommandsDir) {
+    return toPosix(relativeToCommandsDir).replace(/\.md$/, '').split('/').join(':');
+}
+function initCategoryFor(relativeToCommandsDir) {
+    const top = toPosix(relativeToCommandsDir).split('/')[0];
+    for (const [category, entries] of Object.entries(INIT_COMMAND_CATEGORIES)) {
+        if (entries.includes(top))
+            return category;
+    }
+    return undefined;
+}
+function shippedIn(repoPath, packedFiles) {
+    if (!packedFiles)
+        return [];
+    return Object.entries(packedFiles)
+        .filter(([, files]) => files.includes(repoPath))
+        .map(([name]) => name)
+        .sort();
+}
+function scanCommandsDir(input, commandsDir, channel, pkg, ownerPlugin, prefix) {
+    const absolute = join(input.repoRoot, commandsDir);
+    return listMarkdown(absolute).map((file) => {
+        const relToDir = toPosix(relative(absolute, file));
+        const repoPath = toPosix(relative(input.repoRoot, file));
+        const content = readFileSync(file, 'utf8');
+        const invocation = prefix ? `${prefix}:${projectInvocation(relToDir)}` : projectInvocation(relToDir);
+        return {
+            key: invocation,
+            ownerPlugin,
+            content,
+            source: {
+                channel,
+                package: pkg,
+                sourcePath: repoPath,
+                digest: `sha256:${sha256Hex(content)}`,
+                observedInvocation: `/${invocation}`,
+                binding: 'markdown-loader',
+                ...(channel === 'cli-init-template' && initCategoryFor(relToDir)
+                    ? { initCategory: initCategoryFor(relToDir) }
+                    : {}),
+                shippedIn: shippedIn(repoPath, input.packedFiles),
+            },
+        };
+    });
+}
+export function readMarketplace(repoRoot) {
+    const file = join(repoRoot, MARKETPLACE_MANIFEST);
+    if (!existsSync(file))
+        return [];
+    const parsed = JSON.parse(readFileSync(file, 'utf8'));
+    if (!Array.isArray(parsed.plugins))
+        return [];
+    return parsed.plugins
+        .filter((p) => !!p && typeof p.name === 'string' && typeof p.source === 'string')
+        .map((p) => ({ name: p.name, source: toPosix(p.source).replace(/^\.\//, '').replace(/\/$/, '') }));
+}
+/** Plugin command folders: marketplace-listed sources, then any other `plugins/<p>/commands`. */
+function scanPlugins(input) {
+    const out = [];
+    const listed = new Set();
+    for (const plugin of readMarketplace(input.repoRoot)) {
+        const dir = `${plugin.source}/commands`;
+        listed.add(dir);
+        out.push(...scanCommandsDir(input, dir, 'marketplace-plugin', `${plugin.name}@ruflo`, plugin.name, plugin.name));
+    }
+    const pluginsRoot = join(input.repoRoot, 'plugins');
+    if (!existsSync(pluginsRoot))
+        return out;
+    for (const name of readdirSync(pluginsRoot).sort()) {
+        const dir = `plugins/${name}/commands`;
+        if (listed.has(dir) || !existsSync(join(input.repoRoot, dir)))
+            continue;
+        out.push(...scanCommandsDir(input, dir, 'source-plugin', `plugins/${name}`, name, name));
+    }
+    return out;
+}
+/**
+ * Mod hooks. A `command.run` hook on a name that a Markdown command of the
+ * same plugin already exposes is middleware on that workflow, not a new
+ * command; any other name is a mod registration.
+ */
+function scanModHooks(input, markdown) {
+    const markdownKeys = new Set(markdown.map((m) => m.key));
+    return (input.modHooks ?? []).map((hook) => {
+        const middleware = markdownKeys.has(hook.command);
+        const file = join(input.repoRoot, hook.sourcePath);
+        const digest = existsSync(file) ? sha256Hex(readFileSync(file)) : sha256Hex(hook.command);
+        return {
+            key: hook.command,
+            ownerPlugin: hook.plugin,
+            source: {
+                channel: 'mod-registration',
+                package: `${hook.plugin}@ruflo`,
+                sourcePath: hook.sourcePath,
+                digest: `sha256:${digest}`,
+                observedInvocation: `/${hook.command}`,
+                binding: middleware ? 'mod-middleware-on-markdown' : 'mod-register',
+                shippedIn: [],
+            },
+        };
+    });
+}
+/**
+ * Static fallback for mod hooks when the engine is not available: the
+ * `command.run` matchers written in each plugin's hooks sources. The engine
+ * report replaces this with `claude plugin validate` output when it can run.
+ */
+export function scanModHooksFromSource(repoRoot) {
+    const pluginsRoot = join(repoRoot, 'plugins');
+    if (!existsSync(pluginsRoot))
+        return [];
+    const hooks = [];
+    for (const plugin of readdirSync(pluginsRoot).sort()) {
+        const hooksDir = join(pluginsRoot, plugin, 'hooks');
+        if (!existsSync(join(hooksDir, 'register.ts')))
+            continue;
+        const walk = (dir) => {
+            for (const name of readdirSync(dir).sort()) {
+                const full = join(dir, name);
+                if (statSync(full).isDirectory()) {
+                    walk(full);
+                    continue;
+                }
+                if (!name.endsWith('.ts'))
+                    continue;
+                const text = readFileSync(full, 'utf8');
+                const seen = new Set();
+                for (const m of text.matchAll(/command\.run'\s*,\s*\{\s*command:\s*'([a-z0-9._:-]+)'/gi))
+                    seen.add(m[1]);
+                for (const m of text.matchAll(/\.register(?:Command)?\(\{\s*name:\s*'([a-z0-9._:-]+)'/gi))
+                    seen.add(m[1]);
+                for (const m of text.matchAll(/\{\s*name:\s*'(ruflo-[a-z0-9-]+)'\s*,\s*description:/gi))
+                    seen.add(m[1]);
+                for (const command of [...seen].sort()) {
+                    hooks.push({ plugin, command, sourcePath: toPosix(relative(repoRoot, full)) });
+                }
+            }
+        };
+        walk(hooksDir);
+    }
+    // One hook per (plugin, command): a name both registered and matched is one command.
+    const unique = new Map();
+    for (const hook of hooks) {
+        const key = `${hook.plugin}\u0000${hook.command}`;
+        if (!unique.has(key))
+            unique.set(key, hook);
+    }
+    return [...unique.values()];
+}
+/** Everything the repository and its packages expose as a slash command. */
+export function collectInventory(input) {
+    const markdown = [
+        ...scanCommandsDir(input, PROJECT_COMMANDS_DIR, 'repo-project-commands', 'claude-flow', 'project'),
+        ...scanCommandsDir(input, CLI_TEMPLATE_COMMANDS_DIR, 'cli-init-template', '@claude-flow/cli', 'project'),
+        ...scanPlugins(input),
+    ];
+    return [...markdown, ...scanModHooks(input, markdown)];
+}
+//# sourceMappingURL=inventory.js.map