@webpresso/agent-kit 0.21.0

package/dist/esm/cli/commands/config.js

@@ -0,0 +1,272 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+function commandError(message, exitCode = 1) {
+    const error = new Error(message);
+    error.exitCode = exitCode;
+    return error;
+}
+const secretManagerRegistry = new Map([
+    ['doppler', createCliDiagnosticAdapter({ binary: 'doppler', displayName: 'Doppler' })],
+    ['infisical', createCliDiagnosticAdapter({ binary: 'infisical', displayName: 'Infisical' })],
+]);
+const localSecretsRuntime = {
+    getSecretsConfigPath,
+    readSecretsConfig,
+    writeSecretsConfig,
+    runSecretManagerSetup: async () => {
+        throw commandError([
+            'Interactive secret-manager setup is not bundled with agent-kit.',
+            'Configure your manager CLI, then run: wp config secrets set <doppler|infisical> <project-id>',
+        ].join(' '));
+    },
+    secretManagerRegistry,
+};
+function createCliDiagnosticAdapter(options) {
+    return {
+        displayName: options.displayName,
+        async checkAvailability() {
+            const result = spawnSync(options.binary, ['--version'], { stdio: 'ignore' });
+            if (!result.error && result.status === 0)
+                return { available: true };
+            return {
+                available: false,
+                detail: `${options.displayName} CLI is not available on PATH.`,
+            };
+        },
+        async checkAuthentication() {
+            return {
+                authenticated: false,
+                detail: [
+                    `${options.displayName} CLI is installed, but agent-kit does not inspect manager auth state or fetch secrets.`,
+                    `Run the manager login flow, then verify execution with: with-secrets -- <cmd>`,
+                ].join(' '),
+            };
+        },
+    };
+}
+function getSecretsConfigPath(cwd = process.cwd()) {
+    return join(findConfigRoot(cwd), 'webpresso', 'secrets.json');
+}
+function readSecretsConfig(cwd) {
+    const path = getSecretsConfigPath(cwd);
+    if (!existsSync(path))
+        return null;
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    if (!isSecretManagerName(parsed.manager) || typeof parsed.projectId !== 'string') {
+        throw commandError(`Invalid secret manager config at ${path}`);
+    }
+    return {
+        manager: parsed.manager,
+        projectId: parsed.projectId,
+        ...(typeof parsed.projectLabel === 'string' ? { projectLabel: parsed.projectLabel } : {}),
+    };
+}
+function writeSecretsConfig(config, cwd) {
+    const path = getSecretsConfigPath(cwd);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+}
+function findConfigRoot(cwd) {
+    const start = resolve(cwd);
+    let current = start;
+    while (true) {
+        const gitPath = join(current, '.git');
+        if (existsSync(gitPath)) {
+            const resolvedGitPath = resolveGitPath(gitPath, current);
+            if (resolvedGitPath)
+                return resolvedGitPath;
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            return join(start, '.webpresso');
+        current = parent;
+    }
+}
+function resolveGitPath(gitPath, repositoryPath) {
+    try {
+        const text = readFileSync(gitPath, 'utf8');
+        const match = /^gitdir:\\s*(.+)$/u.exec(text.trim());
+        if (!match)
+            return undefined;
+        return resolve(repositoryPath, match[1]);
+    }
+    catch {
+        return gitPath;
+    }
+}
+function isSecretManagerName(value) {
+    return value === 'doppler' || value === 'infisical';
+}
+function writeJson(writer, payload) {
+    writer.write(`${JSON.stringify(payload, null, 2)}\n`);
+}
+function writeLine(writer, message) {
+    writer.write(`${message}\n`);
+}
+async function getStatus(cwd, deps) {
+    const runtime = localSecretsRuntime;
+    const path = (deps.getPath ?? runtime.getSecretsConfigPath)(cwd);
+    const config = (deps.readConfig ?? runtime.readSecretsConfig)(cwd);
+    if (!config) {
+        return {
+            configured: false,
+            path,
+            config: null,
+            registered: false,
+            detail: 'No secret manager configured.',
+        };
+    }
+    const adapter = (deps.registry ?? runtime.secretManagerRegistry).get(config.manager) ?? null;
+    if (!adapter) {
+        return {
+            configured: true,
+            path,
+            config,
+            registered: false,
+            detail: `Secret manager "${config.manager}" is not registered.`,
+        };
+    }
+    const availability = await adapter.checkAvailability();
+    if (!availability.available) {
+        return {
+            configured: true,
+            path,
+            config,
+            registered: true,
+            available: false,
+            authenticated: false,
+            detail: availability.detail ?? `${adapter.displayName} CLI is not available.`,
+        };
+    }
+    const auth = await adapter.checkAuthentication({ workspace: config.projectId });
+    return {
+        configured: true,
+        path,
+        config,
+        registered: true,
+        available: true,
+        authenticated: auth.authenticated,
+        detail: auth.detail,
+    };
+}
+function formatShowMessage(status) {
+    if (!status.configured || !status.config) {
+        return `No secret manager configured.\nRun: wp config secrets setup`;
+    }
+    return [
+        `manager: ${status.config.manager}`,
+        `projectId: ${status.config.projectId}`,
+        ...(status.config.projectLabel ? [`projectLabel: ${status.config.projectLabel}`] : []),
+        `path: ${status.path}`,
+    ].join('\n');
+}
+function formatStatusMessage(status) {
+    if (!status.configured || !status.config) {
+        return `configured: no\npath: ${status.path}\naction: run 'wp config secrets setup'`;
+    }
+    return [
+        `configured: yes`,
+        `manager: ${status.config.manager}`,
+        `projectId: ${status.config.projectId}`,
+        `registered: ${status.registered ? 'yes' : 'no'}`,
+        `available: ${status.available === true ? 'yes' : 'no'}`,
+        `authenticated: ${status.authenticated === true ? 'yes' : 'no'}`,
+        `path: ${status.path}`,
+        ...(status.detail ? [`detail: ${status.detail}`] : []),
+    ].join('\n');
+}
+export async function runSecretsConfigCommand(action, positional, options = {}, deps = {}) {
+    const stdout = deps.stdout ?? process.stdout;
+    const stderr = deps.stderr ?? process.stderr;
+    const cwd = options.cwd ?? process.cwd();
+    switch (action) {
+        case 'show': {
+            const status = await getStatus(cwd, deps);
+            if (options.json)
+                writeJson(stdout, status);
+            else
+                writeLine(stdout, formatShowMessage(status));
+            return status.configured ? 0 : 1;
+        }
+        case 'status': {
+            const status = await getStatus(cwd, deps);
+            if (options.json)
+                writeJson(stdout, status);
+            else
+                writeLine(stdout, formatStatusMessage(status));
+            return status.configured && status.registered && status.available && status.authenticated
+                ? 0
+                : 1;
+        }
+        case 'set': {
+            const manager = positional[0];
+            const projectId = positional[1];
+            if (!isSecretManagerName(manager) || !projectId) {
+                throw commandError('Usage: wp config secrets set <doppler|infisical> <project-id>');
+            }
+            const config = {
+                manager,
+                projectId,
+                ...(options.label ? { projectLabel: options.label } : {}),
+            };
+            const runtime = localSecretsRuntime;
+            (deps.writeConfig ?? runtime.writeSecretsConfig)(config, cwd);
+            const payload = {
+                ok: true,
+                path: (deps.getPath ?? runtime.getSecretsConfigPath)(cwd),
+                config,
+            };
+            if (options.json)
+                writeJson(stdout, payload);
+            else
+                writeLine(stdout, `Configured ${manager} project ${projectId}`);
+            return 0;
+        }
+        case 'setup': {
+            const runtime = localSecretsRuntime;
+            const result = await (deps.setup ?? runtime.runSecretManagerSetup)({ cwd });
+            const payload = {
+                ok: true,
+                path: (deps.getPath ?? runtime.getSecretsConfigPath)(cwd),
+                config: { manager: result.manager, projectId: result.projectId },
+            };
+            if (options.json)
+                writeJson(stdout, payload);
+            else
+                writeLine(stdout, `Configured ${result.manager} project ${result.projectId}`);
+            return 0;
+        }
+        default:
+            stderr.write([
+                'Usage: wp config secrets <action> [options]',
+                '',
+                'Actions:',
+                '  setup                           Interactive secret-manager setup',
+                '  set <manager> <project-id>      Persist an explicit manager/project selection',
+                '  show                            Show the current selection',
+                '  status                          Check selection + local CLI auth state',
+                '',
+                'Options:',
+                '  --json                          Print JSON',
+                '  --label <label>                 Optional project label for `set`',
+            ].join('\n') + '\n');
+            return 1;
+    }
+}
+export function registerConfigCommand(cli) {
+    cli
+        .command('config <scope> [action] [...rest]', 'Repo configuration (supported: secrets)')
+        .option('--json', 'Print JSON output')
+        .option('--label <label>', 'Optional project label for `config secrets set`')
+        .action(async (scope, action, rest, options) => {
+        if (scope !== 'secrets') {
+            throw commandError(`Unknown config scope: ${scope}. Use 'secrets'.`);
+        }
+        return runSecretsConfigCommand(action, typeof rest === 'string' ? [rest] : (rest ?? []), {
+            json: options.json,
+            label: options.label,
+        });
+    });
+}
+//# sourceMappingURL=config.js.map

package/dist/esm/cli/commands/dev.d.ts

@@ -0,0 +1,17 @@
+import type { CAC } from 'cac';
+import { type AkDevMode } from '#dev/index';
+export interface RunDevCommandInput {
+    cwd?: string;
+    manifestPath?: string;
+    mode?: AkDevMode;
+    target?: string;
+}
+export interface RunDevCommandResult {
+    mode: AkDevMode;
+    manifestPath: string;
+    services: string[];
+}
+export declare function getDevHelpText(): string;
+export declare function runDevCommand(input: RunDevCommandInput): Promise<RunDevCommandResult>;
+export declare function registerDevCommand(cli: CAC): void;
+//# sourceMappingURL=dev.d.ts.map

package/dist/esm/cli/commands/dev.js

@@ -0,0 +1,56 @@
+import { loadDevManifest, resolveDevServices } from '#dev/index';
+export function getDevHelpText() {
+    return [
+        'Usage: wp dev [target] [options]',
+        '',
+        'Options:',
+        '  --manifest <path>  Dev manifest path',
+        '  --doctor           Validate manifest and print resolved services',
+        '  --clean            Clean supervisor-owned state for the target',
+        '  --restart          Restart the target',
+        '  -h, --help         Display this message',
+        '',
+        'Manifest precedence: --manifest -> WP_APP_MANIFEST -> ./app-manifest.yaml -> error',
+    ].join('\n');
+}
+export async function runDevCommand(input) {
+    const mode = input.mode ?? 'start';
+    const { manifestPath, manifest } = loadDevManifest({
+        cwd: input.cwd,
+        manifestPath: input.manifestPath,
+    });
+    const services = resolveDevServices(manifest, input.target);
+    return { mode, manifestPath, services };
+}
+export function registerDevCommand(cli) {
+    cli
+        .command('dev [target]', 'Run a manifest-backed development target')
+        .option('--manifest <path>', 'Dev manifest path (precedence: --manifest -> WP_APP_MANIFEST -> ./app-manifest.yaml -> error)')
+        .option('--doctor', 'Validate manifest and print resolved services')
+        .option('--clean', 'Clean supervisor-owned state for the target')
+        .option('--restart', 'Restart the target')
+        .action(async (target, options) => {
+        if (options.clean && options.restart) {
+            throw new Error('Use either --clean or --restart, not both.');
+        }
+        const mode = options.doctor
+            ? 'doctor'
+            : options.clean
+                ? 'clean'
+                : options.restart
+                    ? 'restart'
+                    : 'start';
+        const result = await runDevCommand({
+            manifestPath: options.manifest,
+            mode,
+            target,
+        });
+        console.log(JSON.stringify({
+            mode: result.mode,
+            manifest: result.manifestPath,
+            services: result.services,
+        }, null, 2));
+        process.exit(0);
+    });
+}
+//# sourceMappingURL=dev.js.map

package/dist/esm/cli/commands/docs-core.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Pure core for `wp docs lint` — no process.exit, no console.log.
+ *
+ * Reads markdown files, detects `doc-type: blueprint` frontmatter, runs
+ * `validateBlueprintPlan`, and returns a structured result. All I/O is
+ * injected for testability.
+ */
+export interface DocsLintResult {
+    files: number;
+    violations: Array<{
+        file: string;
+        message: string;
+        rule: string;
+    }>;
+    exitCode: 0 | 1;
+}
+type ReadFileFn = (p: string) => Promise<string>;
+type GlobFn = (pattern: string, options: {
+    cwd: string;
+}) => Promise<string[]>;
+export declare function runDocsLint(target: string, deps?: {
+    readFile?: ReadFileFn;
+    glob?: GlobFn;
+}): Promise<DocsLintResult>;
+export {};
+//# sourceMappingURL=docs-core.d.ts.map

package/dist/esm/cli/commands/docs-core.js

@@ -0,0 +1,88 @@
+/**
+ * Pure core for `wp docs lint` — no process.exit, no console.log.
+ *
+ * Reads markdown files, detects `doc-type: blueprint` frontmatter, runs
+ * `validateBlueprintPlan`, and returns a structured result. All I/O is
+ * injected for testability.
+ */
+import matter from 'gray-matter';
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { validateBlueprintPlan } from '#docs-linter/blueprint-plan';
+function isMarkdownFile(filePath) {
+    return filePath.endsWith('.md') || filePath.endsWith('.mdx');
+}
+function walkMarkdownFiles(root) {
+    const out = [];
+    const stat = statSync(root);
+    if (stat.isFile()) {
+        if (isMarkdownFile(root))
+            out.push(root);
+        return out;
+    }
+    if (!stat.isDirectory())
+        return out;
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        if (entry.name.startsWith('.') || entry.name === 'node_modules')
+            continue;
+        const child = path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            out.push(...walkMarkdownFiles(child));
+        }
+        else if (entry.isFile() && isMarkdownFile(child)) {
+            out.push(child);
+        }
+    }
+    return out;
+}
+function detectDocType(content) {
+    try {
+        const parsed = matter(content);
+        const data = parsed.data;
+        return data['doc-type'] ?? data.docType ?? data.type ?? '';
+    }
+    catch {
+        return '';
+    }
+}
+export async function runDocsLint(target, deps = {}) {
+    const absoluteTarget = path.resolve(process.cwd(), target);
+    let files;
+    if (deps.glob) {
+        const matches = await deps.glob('**/*.{md,mdx}', { cwd: absoluteTarget });
+        files = matches.map((f) => path.join(absoluteTarget, f));
+    }
+    else {
+        files = walkMarkdownFiles(absoluteTarget);
+    }
+    if (!files.length) {
+        return { files: 0, violations: [], exitCode: 0 };
+    }
+    const defaultReadFile = async (p) => readFileSync(p, 'utf-8');
+    const read = deps.readFile ?? defaultReadFile;
+    const allErrors = [];
+    let blueprintFiles = 0;
+    for (const file of files) {
+        const raw = await read(file);
+        const docType = detectDocType(raw);
+        if (docType !== 'blueprint')
+            continue;
+        blueprintFiles++;
+        allErrors.push(...validateBlueprintPlan(file, raw, docType));
+    }
+    if (!blueprintFiles) {
+        return { files: files.length, violations: [], exitCode: 0 };
+    }
+    const errorCount = allErrors.filter((e) => e.severity === 'error').length;
+    const violations = allErrors.map((e) => ({
+        file: e.file,
+        message: e.message,
+        rule: e.ruleId ?? '',
+    }));
+    return {
+        files: blueprintFiles,
+        violations,
+        exitCode: errorCount > 0 ? 1 : 0,
+    };
+}
+//# sourceMappingURL=docs-core.js.map

package/dist/esm/cli/commands/docs.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `wp docs lint <path>` — run the blueprint-plan validator over a markdown
+ * file or directory.
+ *
+ * Thin CLI shell: parse args → call runDocsLint → print results → exit.
+ */
+import type { CAC } from 'cac';
+export declare function registerDocsCommand(cli: CAC): void;
+//# sourceMappingURL=docs.d.ts.map

package/dist/esm/cli/commands/docs.js

@@ -0,0 +1,46 @@
+/**
+ * `wp docs lint <path>` — run the blueprint-plan validator over a markdown
+ * file or directory.
+ *
+ * Thin CLI shell: parse args → call runDocsLint → print results → exit.
+ */
+import { runDocsLint } from './docs-core.js';
+function handleDocsError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process.exit(1);
+}
+export function registerDocsCommand(cli) {
+    cli
+        .command('docs <action> [target]', 'Documentation tooling (lint)')
+        .action(async (action, target) => {
+        try {
+            if (action !== 'lint') {
+                throw new Error(`Unknown docs action: ${action}. Use 'lint'.`);
+            }
+            if (!target) {
+                throw new Error('Usage: wp docs lint <path>');
+            }
+            const result = await runDocsLint(target);
+            if (result.files === 0) {
+                console.log(`No markdown files found at ${target}.`);
+                process.exit(0);
+            }
+            if (result.violations.length === 0) {
+                console.log(`✓ ${result.files} blueprint document(s) passed.`);
+                process.exit(0);
+            }
+            for (const v of result.violations) {
+                const ruleId = v.rule ? ` [${v.rule}]` : '';
+                console.log(`${v.file} ERROR${ruleId} ${v.message}`);
+            }
+            const errorCount = result.violations.length;
+            console.log(`\n${errorCount} error(s) across ${result.files} blueprint(s).`);
+            process.exit(result.exitCode);
+        }
+        catch (error) {
+            handleDocsError(error);
+        }
+    });
+}
+//# sourceMappingURL=docs.js.map

package/dist/esm/cli/commands/doctor.d.ts

@@ -0,0 +1,10 @@
+import type { CAC } from 'cac';
+export interface RunDoctorOptions {
+    root?: string;
+    docsRoot?: string;
+    fix?: boolean;
+    legacyOmx?: boolean;
+}
+export declare function runDoctor(options?: RunDoctorOptions): Promise<number>;
+export declare function registerDoctorCommand(cli: CAC): void;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/esm/cli/commands/doctor.js

@@ -0,0 +1,53 @@
+import { auditBlueprintLifecycle, auditCatalogDrift, auditDocsFrontmatter, formatRepoAuditReport, } from '#audit/repo-guardrails';
+const REMEDIATIONS = {
+    'Catalog drift': 'wp audit catalog-drift',
+    'Catalog drift — single package (no workspace file)': 'none needed',
+    'Docs frontmatter': 'wp audit docs-frontmatter --fix',
+    'Blueprint lifecycle': 'wp audit blueprint-lifecycle',
+};
+export async function runDoctor(options = {}) {
+    try {
+        const root = options.root ?? process.cwd();
+        const results = [
+            auditCatalogDrift(root),
+            auditDocsFrontmatter(root, {
+                docsRoot: options.docsRoot,
+                fix: options.fix,
+            }),
+            auditBlueprintLifecycle(root, {
+                includeLegacyOmx: options.legacyOmx,
+            }),
+        ];
+        let failed = false;
+        for (const result of results) {
+            console.log(formatRepoAuditReport(result));
+            if (!result.ok) {
+                failed = true;
+                const remediation = REMEDIATIONS[result.title] ??
+                    `wp audit ${result.title.toLowerCase().replace(/\s+/g, '-')}`;
+                console.log(`→ remediation: ${remediation}`);
+            }
+            console.log('');
+        }
+        console.log('Hook/plugin health remains separate: run `wp hooks doctor`.');
+        return failed ? 1 : 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`wp doctor failed: ${message}`);
+        return 2;
+    }
+}
+export function registerDoctorCommand(cli) {
+    cli
+        .command('doctor', 'Run repo audit health checks (hook/plugin health stays under `wp hooks doctor`)')
+        .option('--root <dir>', 'Repository root to inspect')
+        .option('--docs-root <dir>', 'Docs directory for docs-frontmatter')
+        .option('--fix', 'Apply supported safe fixes during doctor (currently docs-frontmatter)')
+        .option('--legacy-omx', 'Include legacy .omx plan checks for blueprint-lifecycle')
+        .action(async (options) => {
+        const code = await runDoctor(options);
+        return code;
+    });
+}
+//# sourceMappingURL=doctor.js.map

package/dist/esm/cli/commands/e2e.d.ts

@@ -0,0 +1,22 @@
+import type { CommandConfig, E2eRunnerKind, PlannedE2eRunGroup } from '#e2e';
+import type { CAC } from 'cac';
+import { plannedGroupsToCommandConfigs } from '#e2e/execution';
+export declare const E2E_COMMAND_HELP: string;
+export interface AkE2eCommandInput {
+    suite?: string;
+    runner?: E2eRunnerKind;
+    config?: string;
+    file?: readonly string[] | string;
+    headed?: boolean;
+    debug?: boolean;
+    reuseReset?: boolean;
+    noSupervisor?: boolean;
+    workers?: number | string;
+    testList?: string;
+    passthrough?: readonly string[];
+}
+export declare function createAkE2eCommandConfig(input: AkE2eCommandInput): CommandConfig;
+export declare function createAkE2eExecutionPlan(input: AkE2eCommandInput, cwd?: string): Promise<PlannedE2eRunGroup[]>;
+export declare function registerE2eCommand(cli: CAC): void;
+export { plannedGroupsToCommandConfigs };
+//# sourceMappingURL=e2e.d.ts.map