wordpress-agent-kit 0.5.1 → 0.6.0

package/dist/commands/bootstrap.js

@@ -0,0 +1,105 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Command } from 'commander';
+import { bootstrapApi } from '../lib/api.js';
+import { OutputFormatter, createFormatter } from '../utils/output.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Bootstrap command — probe, configure, and wire up a WordPress project.
+ * Supports single plugins/themes and monorepos (multiple WP packages).
+ * Supports --detect-only, --auto (non-interactive), --dry-run, --json.
+ */
+export const bootstrapCommand = new Command('bootstrap')
+    .description('Bootstrap a WordPress project: detect structure, install agent kit, scaffold tooling')
+    .argument('[dir]', 'Target directory (defaults to cwd)', process.cwd())
+    .option('--detect-only', 'Only run structure detection and output result', false)
+    .option('--auto', 'Non-interactive: use detected values without prompting', false)
+    .option('--platform <platform>', 'Agent kit platform (github, pi, cursor, claude)', 'github')
+    .option('--wp-root <path>', 'WordPress root path relative to repo root (overrides detection)')
+    .option('--wp-packages <dirs>', 'Comma-separated list of WP package dirs (overrides detection)')
+    .option('--package-manager <pm>', 'Package manager: npm, pnpm, yarn (overrides detection)')
+    .option('--wpe-prod <slug>', 'WP Engine production install slug')
+    .option('--wpe-staging <slug>', 'WP Engine staging install slug')
+    .option('--wpe-dev <slug>', 'WP Engine development install slug')
+    .option('--with-satispress <url>', 'Add SatisPress repository URL to composer.json')
+    .option('--with-wpackagist', 'Add WPackagist repository to composer.json', false)
+    .option('--skip-install', 'Skip running wp-agent-kit install after scaffolding', false)
+    .action(async (dir, options, command) => {
+    const globalOpts = command.parent?.opts() || {};
+    const targetDir = path.resolve(dir);
+    const formatter = createFormatter(globalOpts, 'bootstrap', '0.0.0');
+    if (!fs.existsSync(targetDir)) {
+        const result = formatter.fail({
+            code: 'NOT_FOUND',
+            message: `Directory does not exist: ${targetDir}`,
+            exitCode: 3,
+        });
+        process.exit(OutputFormatter.getExitCode(result));
+    }
+    // ── 1. Structure detection ───────────────────────────────────────────
+    if (!globalOpts.json && !globalOpts.quiet) {
+        console.log(`\n▶ Detecting project structure in ${targetDir}...`);
+    }
+    const result = await bootstrapApi({
+        targetDir,
+        platform: options.platform,
+        detectOnly: options.detectOnly,
+        auto: options.auto,
+        dryRun: globalOpts.dryRun ?? false,
+        wpRoot: options.wpRoot,
+        wpPackages: options.wpPackages?.split(',').map((s) => s.trim()),
+        packageManager: options.packageManager,
+        wpeEnvironments: {
+            production: options.wpeProd,
+            staging: options.wpeStaging,
+            development: options.wpeDev,
+        },
+        withSatispress: options.withSatispress,
+        withWpackagist: options.withWpackagist,
+        skipInstall: options.skipInstall,
+    });
+    if (globalOpts.json || globalOpts.quiet) {
+        process.exit(OutputFormatter.getExitCode(result));
+    }
+    if (!result.success) {
+        console.error(`\n✗ Bootstrap failed: ${result.error?.message}`);
+        process.exit(1);
+    }
+    const data = result.data;
+    if (data.detectOnly) {
+        // Pretty-print structure
+        const s = data.structure;
+        console.log('\n── Detected structure ──────────────────────────────────────');
+        console.log(`  Monorepo:    ${s.isMonorepo ? 'yes' : 'no'}`);
+        console.log(`  Pkg mgr:     ${s.packageManager ?? 'none'}`);
+        console.log(`  WP root:     ${s.wpRoot ?? 'none (Playground-only)'}`);
+        console.log(`  WP packages: ${s.wpPackages.length}`);
+        for (const p of s.wpPackages) {
+            console.log(`    ${p.type === 'plugin' ? '🔌' : '🎨'} ${p.name ?? p.path} (${p.path}) v${p.version ?? '?'}`);
+        }
+        console.log(`  WPE remotes: ${s.wpeRemotes.length}`);
+        for (const r of s.wpeRemotes) {
+            console.log(`    → ${r.name} (${r.install})`);
+        }
+        console.log(`  PHP:         PHPCS=${s.php.hasPhpcs}  PHPStan=${s.php.hasPhpstan}`);
+        console.log(`  JS:          Biome=${s.js.hasBiome}  Vitest=${s.js.hasVitest}`);
+        console.log(`  Playground:  ${s.playground.hasPlayground ? 'configured' : 'not configured'}`);
+        console.log(`  Agent kit:   ${s.hasAgentKit ? 'installed' : 'not installed'}`);
+        console.log('');
+    }
+    else {
+        console.log('\n── Bootstrap complete ──────────────────────────────────────');
+        for (const action of data.actions) {
+            console.log(`  ${action}`);
+        }
+        console.log('\nNext steps:');
+        console.log('  1. Run: bash tools/setup.sh           (install dev deps + activate hooks)');
+        console.log('  2. Run: bash tools/playground/run-playground.sh  (start local WP)');
+        console.log('  3. Review AGENTS.md and the generated wp-cli.yml');
+        console.log('  4. Add WP Engine secrets to GitHub (see .agents/skills/wp-wpengine/SKILL.md)');
+        console.log('');
+    }
+    process.exit(0);
+});

package/dist/lib/api.js

@@ -692,3 +692,4 @@ export async function cleanSkillsApi(options) {
 export { ExitCode } from '../utils/exit-codes.js';
 export { OutputFormatter, createFormatter, parseOutputFormat } from '../utils/output.js';
 export { computeChanges, isKitInstalled, loadManifest, updateKit } from './updater.js';
+export { bootstrapApi } from './bootstrap.js';

package/dist/lib/bootstrap.js

@@ -0,0 +1,352 @@
+/**
+ * Bootstrap API — detects WordPress project structure and scaffolds
+ * the full wp-agent-kit system (agent kit, Composer, WP-CLI, Playground,
+ * WP Engine CI/CD, git hooks). Supports single plugins/themes and monorepos.
+ */
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { ExitCode } from '../utils/exit-codes.js';
+import { OutputFormatter } from '../utils/output.js';
+import { PACKAGE_ROOT } from '../utils/paths.js';
+import { installKit } from './installer.js';
+// ── Detection ─────────────────────────────────────────────────────────────
+/**
+ * Run the detect-structure.mjs probe script and return the parsed result.
+ */
+export function detectStructure(targetDir) {
+    const detectScript = path.join(PACKAGE_ROOT, '.agents', 'skills', 'wp-bootstrap', 'scripts', 'detect-structure.mjs');
+    if (!fs.existsSync(detectScript)) {
+        // Fallback: minimal detection without the full script
+        return minimalDetect(targetDir);
+    }
+    const result = spawnSync('node', [detectScript, targetDir], {
+        encoding: 'utf-8',
+        cwd: targetDir,
+    });
+    if (result.status !== 0) {
+        return minimalDetect(targetDir);
+    }
+    try {
+        return JSON.parse(result.stdout.trim());
+    }
+    catch {
+        return minimalDetect(targetDir);
+    }
+}
+/** Minimal structure detection without the full probe script */
+function minimalDetect(targetDir) {
+    const exists = (...parts) => fs.existsSync(path.join(targetDir, ...parts));
+    const pm = exists('pnpm-lock.yaml')
+        ? 'pnpm'
+        : exists('yarn.lock')
+            ? 'yarn'
+            : exists('package.json')
+                ? 'npm'
+                : null;
+    return {
+        repoRoot: targetDir,
+        isMonorepo: false,
+        packageManager: pm,
+        jsWorkspaces: [],
+        wpPackages: [],
+        wpRoot: exists('wp-config.php') ? '.' : null,
+        wpRootExists: exists('wp-config.php'),
+        playgroundOnly: !exists('wp-config.php'),
+        wpeRemotes: [],
+        hasWpeRemote: false,
+        php: {
+            hasComposer: exists('composer.json'),
+            hasPhpcs: exists('vendor/bin/phpcs'),
+            hasWpcs: false,
+            hasPhpstan: exists('vendor/bin/phpstan'),
+            hasPhpstanWp: false,
+            hasPest: false,
+            phpcsConfig: exists('phpcs.xml.dist') ? 'phpcs.xml.dist' : null,
+            phpstanConfig: exists('phpstan.neon.dist') ? 'phpstan.neon.dist' : null,
+            composerScripts: [],
+        },
+        js: {
+            hasBiome: exists('biome.json'),
+            biomeVersion: null,
+            hasEslint: exists('eslint.config.mjs') || exists('.eslintrc.js'),
+            hasPrettier: exists('.prettierrc'),
+            hasVitest: false,
+            hasJest: false,
+            hasPlaywright: exists('playwright.config.ts') || exists('playwright.config.js'),
+            hasWpScripts: false,
+            rootScripts: [],
+        },
+        playground: {
+            hasPlayground: exists('tools/playground') || exists('playground'),
+            blueprints: [],
+            scripts: [],
+            hasWpEnv: exists('.wp-env.json'),
+        },
+        satispress: { configured: false, url: null, hasAuthJson: false },
+        wpackagist: false,
+        gitHooks: exists('.githooks') ? '.githooks' : exists('.husky') ? '.husky' : null,
+        hasAgentKit: exists('.wp-agent-kit-manifest.github.json') || exists('.agents', 'skills'),
+        hasAgentsDir: exists('.agents'),
+        hasAgentsMd: exists('AGENTS.md'),
+        gitBranch: null,
+        gitRemotes: [],
+    };
+}
+// ── Scaffolding helpers ────────────────────────────────────────────────────
+function writeIfMissing(filePath, content, dryRun) {
+    if (fs.existsSync(filePath))
+        return false;
+    if (!dryRun) {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, content, 'utf-8');
+    }
+    return true;
+}
+function scaffoldWpCliYml(targetDir, structure, wpeEnvironments, dryRun) {
+    const wpCliPath = path.join(targetDir, 'wp-cli.yml');
+    if (fs.existsSync(wpCliPath))
+        return [];
+    const localPath = structure.wpRoot && structure.wpRoot !== '.' ? `path: ./${structure.wpRoot}\n\n` : '';
+    const prod = wpeEnvironments?.production;
+    const staging = wpeEnvironments?.staging;
+    const dev = wpeEnvironments?.development;
+    const content = [
+        '# wp-cli.yml — WP-CLI targeting. Commit to repo.',
+        '# Get exact git push URLs from: https://my.wpengine.com/installs/<ENV>/git_push',
+        '',
+        localPath,
+        prod
+            ? `@production:\n  ssh: ${prod}@${prod}.ssh.wpengine.net\n  path: /home/wpe-user/sites/${prod}\n`
+            : '',
+        staging
+            ? `\n@staging:\n  ssh: ${staging}@${staging}.ssh.wpengine.net\n  path: /home/wpe-user/sites/${staging}\n`
+            : '',
+        dev
+            ? `\n@development:\n  ssh: ${dev}@${dev}.ssh.wpengine.net\n  path: /home/wpe-user/sites/${dev}\n`
+            : '',
+    ].join('');
+    if (writeIfMissing(wpCliPath, content, dryRun)) {
+        return ['wp-cli.yml'];
+    }
+    return [];
+}
+function scaffoldGitHooks(targetDir, dryRun) {
+    const hooksDir = path.join(targetDir, '.githooks');
+    const prePush = path.join(hooksDir, 'pre-push');
+    const readme = path.join(hooksDir, 'README.md');
+    const created = [];
+    const prePushContent = `#!/usr/bin/env bash
+# .githooks/pre-push — CI gate before every push.
+# Activate once: git config core.hooksPath .githooks
+# Generated by wp-agent-kit bootstrap.
+set -uo pipefail
+root="$(git rev-parse --show-toplevel)"
+cd "$root"
+
+# Run the CI gate (PHP + JS/TS)
+GATE_SCRIPT=".agents/skills/wp-bootstrap/scripts/ci-gate.sh"
+if [ -f "$GATE_SCRIPT" ]; then
+  bash "$GATE_SCRIPT" || exit 1
+else
+  echo "⚠  CI gate script not found at $GATE_SCRIPT" >&2
+  echo "   Run wp-agent-kit install to set up .agents/skills/" >&2
+fi
+`;
+    const readmeContent = `# Git hooks (versioned)
+
+Activate once per clone:
+\`\`\`bash
+git config core.hooksPath .githooks
+chmod +x .githooks/pre-push
+\`\`\`
+Or run: \`pnpm run setup\` / \`bash tools/setup.sh\` if that exists.
+
+## What runs
+
+- **pre-push**: PHP gate (php -l + phpcs + phpstan) + JS gate (biome check).
+  Fix failures with \`composer fix && composer lint\` (PHP) or \`npx biome check --write .\` (JS).
+  --no-verify is not allowed on deploy branches; CI will catch it anyway.
+`;
+    if (!fs.existsSync(hooksDir) && !dryRun) {
+        fs.mkdirSync(hooksDir, { recursive: true });
+    }
+    if (writeIfMissing(prePush, prePushContent, dryRun)) {
+        if (!dryRun)
+            fs.chmodSync(prePush, 0o755);
+        created.push('.githooks/pre-push');
+    }
+    if (writeIfMissing(readme, readmeContent, dryRun)) {
+        created.push('.githooks/README.md');
+    }
+    return created;
+}
+function scaffoldSetupSh(targetDir, dryRun) {
+    const toolsDir = path.join(targetDir, 'tools');
+    const setupSh = path.join(toolsDir, 'setup.sh');
+    if (fs.existsSync(setupSh))
+        return [];
+    const content = `#!/usr/bin/env bash
+# tools/setup.sh — one-command dev setup. Idempotent: safe to re-run.
+# Generated by wp-agent-kit bootstrap.
+set -uo pipefail
+root="$(cd "$(dirname "$0")/.." && pwd)"
+bash "$root/.agents/skills/wp-bootstrap/scripts/bootstrap.sh" "$@"
+`;
+    if (writeIfMissing(setupSh, content, dryRun)) {
+        if (!dryRun)
+            fs.chmodSync(setupSh, 0o755);
+        return ['tools/setup.sh'];
+    }
+    return [];
+}
+function scaffoldBootstrapConfig(targetDir, structure, options, dryRun) {
+    const configPath = path.join(targetDir, 'wp-bootstrap.config.json');
+    if (fs.existsSync(configPath))
+        return [];
+    const config = {
+        packageManager: options.packageManager ?? structure.packageManager ?? 'npm',
+        jsWorkspaces: structure.jsWorkspaces,
+        phpDirs: ['.', ...structure.wpPackages.filter((p) => p.hasComposer).map((p) => p.path)],
+        hooksDir: '.githooks',
+        wpPackages: structure.wpPackages.map((p) => ({
+            path: p.path,
+            type: p.type,
+            slug: p.slug,
+            ...(p.mainFile ? { mainFile: p.mainFile } : {}),
+        })),
+        ...(structure.wpeRemotes.length > 0 || options.wpeEnvironments
+            ? {
+                wpeEnvironments: {
+                    ...(options.wpeEnvironments?.production
+                        ? {
+                            production: { install: options.wpeEnvironments.production },
+                        }
+                        : {}),
+                    ...(options.wpeEnvironments?.staging
+                        ? {
+                            staging: { install: options.wpeEnvironments.staging },
+                        }
+                        : {}),
+                    ...(options.wpeEnvironments?.development
+                        ? {
+                            development: { install: options.wpeEnvironments.development },
+                        }
+                        : {}),
+                },
+            }
+            : {}),
+    };
+    if (writeIfMissing(configPath, `${JSON.stringify(config, null, 2)}
+`, dryRun)) {
+        return ['wp-bootstrap.config.json'];
+    }
+    return [];
+}
+// ── Main API ───────────────────────────────────────────────────────────────
+export async function bootstrapApi(options) {
+    const formatter = new OutputFormatter('json', 'bootstrap', '0.0.0');
+    const { targetDir, platform = 'github', detectOnly = false, dryRun = false, skipInstall = false, } = options;
+    try {
+        // 1. Detect structure
+        const structure = detectStructure(targetDir);
+        if (!structure) {
+            return formatter.fail({
+                code: 'DETECT_FAILED',
+                message: 'Failed to detect project structure',
+                exitCode: ExitCode.ERROR,
+            });
+        }
+        // Apply overrides
+        if (options.wpRoot)
+            structure.wpRoot = options.wpRoot;
+        if (options.packageManager)
+            structure.packageManager = options.packageManager;
+        if (detectOnly) {
+            return formatter.success({
+                structure,
+                detectOnly: true,
+                actions: [],
+                filesCreated: [],
+                dryRun,
+            });
+        }
+        const actions = [];
+        const filesCreated = [];
+        // 2. Install agent kit
+        if (!skipInstall && !structure.hasAgentKit) {
+            if (!dryRun) {
+                installKit(targetDir, platform, { safe: true, backup: false });
+            }
+            actions.push(`✅ wp-agent-kit installed (platform: ${platform})`);
+            filesCreated.push('.agents/skills/', `${platform === 'github' ? '.github' : `.${platform}`}/`);
+        }
+        else if (structure.hasAgentKit) {
+            actions.push('✓ wp-agent-kit already installed');
+        }
+        // 3. Generate wp-cli.yml
+        const wpeEnvs = options.wpeEnvironments;
+        const hasWpeConfig = wpeEnvs?.production || wpeEnvs?.staging || wpeEnvs?.development;
+        if (hasWpeConfig || structure.wpRoot) {
+            const created = scaffoldWpCliYml(targetDir, structure, wpeEnvs, dryRun);
+            if (created.length > 0) {
+                actions.push('✅ wp-cli.yml created');
+                filesCreated.push(...created);
+            }
+            else {
+                actions.push('✓ wp-cli.yml already exists');
+            }
+        }
+        // 4. Git hooks
+        const hookFiles = scaffoldGitHooks(targetDir, dryRun);
+        if (hookFiles.length > 0) {
+            actions.push('✅ .githooks/pre-push created');
+            filesCreated.push(...hookFiles);
+            if (!dryRun) {
+                // Activate hooks
+                spawnSync('git', ['config', 'core.hooksPath', '.githooks'], { cwd: targetDir });
+            }
+            actions.push('✅ git config core.hooksPath .githooks');
+        }
+        // 5. tools/setup.sh
+        const setupFiles = scaffoldSetupSh(targetDir, dryRun);
+        if (setupFiles.length > 0) {
+            actions.push('✅ tools/setup.sh created');
+            filesCreated.push(...setupFiles);
+        }
+        // 6. wp-bootstrap.config.json
+        const configFiles = scaffoldBootstrapConfig(targetDir, structure, options, dryRun);
+        if (configFiles.length > 0) {
+            actions.push('✅ wp-bootstrap.config.json created');
+            filesCreated.push(...configFiles);
+        }
+        // 7. Report what still needs manual setup
+        if (!structure.php.hasComposer) {
+            actions.push('⚠  composer.json missing — run: composer init (see wp-bootstrap skill references/composer-setup.md)');
+        }
+        if (!structure.js.hasBiome) {
+            actions.push('⚠  biome.json missing — run: npm install --save-dev @biomejs/biome && npx biome init');
+        }
+        if (!structure.playground.hasPlayground) {
+            actions.push('⚠  Playground not configured — run playground-start.sh to get started');
+        }
+        if (!structure.hasWpeRemote && !hasWpeConfig) {
+            actions.push('⚠  No WP Engine remotes — add --wpe-prod/--wpe-staging/--wpe-dev or configure manually');
+        }
+        return formatter.success({
+            structure,
+            detectOnly: false,
+            actions,
+            filesCreated,
+            dryRun,
+        });
+    }
+    catch (error) {
+        const err = error;
+        return formatter.fail({
+            code: 'BOOTSTRAP_FAILED',
+            message: err.message || 'Bootstrap failed',
+            exitCode: err.exitCode ?? ExitCode.ERROR,
+        });
+    }
+}

package/extensions/wp-agent-kit/index.ts

@@ -7,7 +7,7 @@ import { fileURLToPath } from 'node:url';
  * Provides Pi Coding Agent with WordPress development tools:
  * - 18 WordPress agent skills (17 upstream + wp-wpengine custom) at .agents/skills/ (AgentSkills.io convention)
  * - Project triage detection
- * - Skill installation, syncing, upgrade, and orphan cleanup
+ * - Skill installation, syncing, upgrade, orphan cleanup, and project bootstrapping
  *
  * Follows Pi Coding Agent SDK conventions (extensions.md, packages.md, skills.md).
  */
@@ -26,8 +26,15 @@ try {
 	apiModule = (await import('../../src/lib/api.js')) as typeof import('../../dist/lib/api.js');
 }
 
-const { installKitApi, syncSkillsApi, runTriageApi, cleanSkillsApi, isKitInstalled, loadManifest } =
-	apiModule;
+const {
+	installKitApi,
+	syncSkillsApi,
+	runTriageApi,
+	cleanSkillsApi,
+	bootstrapApi,
+	isKitInstalled,
+	loadManifest,
+} = apiModule;
 
 export default function (pi: ExtensionAPI) {
 	// =========================================================================
@@ -530,6 +537,113 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
+	// --- wp_bootstrap ---
+	pi.registerTool({
+		name: 'wp_bootstrap',
+		label: 'WP Bootstrap',
+		description:
+			'Bootstrap a WordPress project: detect monorepo structure, install agent kit, scaffold Composer/WPackagist/SatisPress, WP-CLI aliases, git hooks, Playground scripts, and WP Engine CI/CD. Supports single plugins/themes and monorepos (multiple WP packages + JS workspaces).',
+		promptSnippet: 'Detect WordPress project structure and bootstrap full tooling',
+		promptGuidelines: [
+			'Always run wp_bootstrap with detectOnly: true first to understand the project structure.',
+			'Use the structure report to identify monorepo patterns before scaffolding.',
+			'For monorepos, confirm WP package paths before proceeding.',
+		],
+		parameters: Type.Object({
+			targetDir: Type.Optional(
+				Type.String({
+					description: 'Project root directory (defaults to current working directory)',
+				})
+			),
+			detectOnly: Type.Optional(
+				Type.Boolean({
+					description: 'Only detect structure, do not scaffold anything (default: false)',
+				})
+			),
+			platform: Type.Optional(
+				Type.String({
+					description: 'Agent kit platform: github, pi, cursor, claude (default: github)',
+				})
+			),
+			wpeProd: Type.Optional(Type.String({ description: 'WP Engine production install slug' })),
+			wpeStaging: Type.Optional(Type.String({ description: 'WP Engine staging install slug' })),
+			wpeDev: Type.Optional(Type.String({ description: 'WP Engine development install slug' })),
+			withWpackagist: Type.Optional(
+				Type.Boolean({ description: 'Add WPackagist to composer.json' })
+			),
+			withSatispress: Type.Optional(
+				Type.String({ description: 'SatisPress URL to add to composer.json' })
+			),
+			dryRun: Type.Optional(
+				Type.Boolean({ description: 'Preview without making changes (default: false)' })
+			),
+		}),
+		async execute(_callId, params, _signal, onUpdate, _ctx) {
+			const targetDir = params.targetDir || process.cwd();
+
+			onUpdate?.({ content: [{ type: 'text', text: '▶ Detecting project structure...' }] });
+
+			const result = await bootstrapApi({
+				targetDir,
+				platform: (params.platform as 'github' | 'pi' | 'cursor' | 'claude') ?? 'github',
+				detectOnly: params.detectOnly ?? false,
+				dryRun: params.dryRun ?? false,
+				wpeEnvironments: {
+					production: params.wpeProd,
+					staging: params.wpeStaging,
+					development: params.wpeDev,
+				},
+				withWpackagist: params.withWpackagist,
+				withSatispress: params.withSatispress,
+			});
+
+			if (!result.success) {
+				return {
+					content: [
+						{ type: 'text', text: `Bootstrap failed: ${result.error?.message || 'Unknown error'}` },
+					],
+					isError: true,
+				};
+			}
+
+			const data = result.data as {
+				detectOnly: boolean;
+				structure: {
+					isMonorepo: boolean;
+					wpPackages: Array<{ type: string; name: string; path: string }>;
+					wpRoot: string | null;
+					packageManager: string;
+					wpeRemotes: Array<{ name: string; install: string }>;
+				};
+				actions: string[];
+				filesCreated: string[];
+			};
+
+			if (data.detectOnly) {
+				const s = data.structure;
+				const lines = [
+					'# Project Structure',
+					'',
+					`**Monorepo**: ${s.isMonorepo ? 'yes' : 'no'}  |  **Package manager**: ${s.packageManager ?? 'none'}  |  **WP root**: ${s.wpRoot ?? 'Playground-only'}`,
+					'',
+					`**WP packages** (${s.wpPackages.length}):`,
+					...s.wpPackages.map(
+						(p) => `- ${p.type === 'plugin' ? '🔌' : '🎨'} ${p.name ?? p.path} (\`${p.path}\`)`
+					),
+					'',
+					`**WP Engine remotes** (${s.wpeRemotes.length}):`,
+					...s.wpeRemotes.map((r) => `- ${r.name} (${r.install})`),
+				];
+				return { content: [{ type: 'text', text: lines.join('\n') }], details: data.structure };
+			}
+
+			return {
+				content: [{ type: 'text', text: ['# Bootstrap Complete', '', ...data.actions].join('\n') }],
+				details: data,
+			};
+		},
+	});
+
 	// =========================================================================
 	// Commands
 	// =========================================================================
@@ -624,4 +738,30 @@ export default function (pi: ExtensionAPI) {
 			ctx.ui.setStatus('wp-clean', total === 0 ? 'clean' : `${total} issues`);
 		},
 	});
+
+	pi.registerCommand('wp-bootstrap', {
+		description: 'Detect WordPress project structure and bootstrap the full toolkit',
+		handler: async (args, ctx) => {
+			const targetDir = args?.trim() || ctx.cwd;
+			ctx.ui.setStatus('wp-bootstrap', 'Detecting...');
+			const result = await bootstrapApi({ targetDir, detectOnly: true });
+			if (!result.success) {
+				ctx.ui.notify(`Bootstrap failed: ${result.error?.message}`, 'error');
+				return;
+			}
+			const data = result.data as {
+				structure: {
+					isMonorepo: boolean;
+					wpPackages: Array<{ type: string; name: string; path: string }>;
+				};
+			};
+			const s = data.structure;
+			const pkgCount = s.wpPackages.length;
+			const label = s.isMonorepo
+				? `monorepo (${pkgCount} packages)`
+				: `${s.wpPackages[0]?.type ?? 'unknown'} (${pkgCount} package)`;
+			ctx.ui.notify(`Detected: ${label}`, 'info');
+			ctx.ui.setStatus('wp-bootstrap', label);
+		},
+	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wordpress-agent-kit",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "WordPress-focused AGENTS.md + Agent Skills starter kit for AI coding agents.",
   "license": "GPL-2.0-or-later",
   "author": "Kyle Brodeur <kyle@brodeur.me> (https://brodeur.me)",