@webpresso/agent-kit 0.21.0

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

@@ -0,0 +1,132 @@
+/**
+ * `wp sync` — projects the canonical webpresso rule/skill catalog into the
+ * supported host surfaces.
+ *
+ * Projects unified rule + skill content (catalog ∪ consumer) into per-IDE
+ * surfaces according to `DEFAULT_UNIFIED_CONSUMERS`.
+ *
+ * Flags:
+ *   --kind rules|skills   Filter to a single kind (default: both).
+ *   --check               Dry-run; exit 1 on first drift, no writes.
+ */
+import { runUnifiedSync } from '#symlinker/unified-sync';
+import { resolvePackageAsset } from '#utils/package-assets';
+import { defaultConfig, readConfig } from './init/config.js';
+import { detectConsumer } from './init/detect-consumer.js';
+import { scaffoldAgentsMd } from './init/scaffold-agents-md.js';
+function commandError(message, exitCode = 1) {
+    const err = new Error(message);
+    err.exitCode = exitCode;
+    return err;
+}
+function parseKind(input) {
+    if (input === undefined)
+        return undefined;
+    if (input === 'rules' || input === 'rule')
+        return ['rule'];
+    if (input === 'skills' || input === 'skill')
+        return ['skill'];
+    throw commandError(`Invalid --kind: ${input}. Must be 'rules' or 'skills'.`);
+}
+function formatMismatches(mismatches) {
+    return mismatches.map((m) => `  - [${m.consumerId}] ${m.targetPath}: ${m.reason}`).join('\n');
+}
+function agentsResultToMismatch(result) {
+    switch (result.action) {
+        case 'identical':
+            return null;
+        case 'created':
+        case 'overwritten':
+            return {
+                consumerId: 'agents-md',
+                targetPath: result.targetPath,
+                reason: 'managed AGENTS.md blocks drifted from the current webpresso template',
+            };
+        case 'drifted':
+            return {
+                consumerId: 'agents-md',
+                targetPath: result.targetPath,
+                reason: 'AGENTS.md has no managed block markers; review the drift or rerun setup with overwrite once',
+            };
+        case 'skipped-dry':
+            return {
+                consumerId: 'agents-md',
+                targetPath: result.targetPath,
+                reason: 'managed AGENTS.md blocks would be refreshed',
+            };
+        default:
+            return null;
+    }
+}
+export function registerSyncCommand(cli) {
+    cli
+        .command('sync', 'Sync agent rules + skills across all supported host surfaces')
+        .option('--kind <kind>', 'Filter: rules | skills (default: both)')
+        .option('--check', 'Exit 1 on drift; no writes')
+        .action(async (options = {}) => {
+        const kinds = parseKind(options.kind);
+        const repoRoot = process.cwd();
+        const catalogDir = resolvePackageAsset('catalog/agent');
+        const check = options.check === true;
+        let result;
+        const consumer = detectConsumer(repoRoot);
+        if (!consumer) {
+            throw commandError('wp sync: could not detect the current git repo root.');
+        }
+        const agentsResult = scaffoldAgentsMd({
+            catalogDir: resolvePackageAsset('catalog'),
+            repoRoot,
+            consumer,
+            config: readConfig(repoRoot) ?? defaultConfig(),
+            options: { dryRun: check, overwrite: false },
+        });
+        try {
+            result = runUnifiedSync({
+                catalogDir,
+                consumerRoot: repoRoot,
+                ...(kinds ? { kinds } : {}),
+                check,
+            });
+        }
+        catch (error) {
+            if (error instanceof Error && /catalogDir does not exist/.test(error.message)) {
+                throw commandError('wp sync: webpresso not installed in node_modules. ' + 'Run `vp install` first.');
+            }
+            throw error;
+        }
+        const agentsMismatch = agentsResult === null ? null : agentsResultToMismatch(agentsResult);
+        const combinedFixCount = result.fixCount + (agentsMismatch ? 1 : 0);
+        const combinedMismatches = agentsMismatch
+            ? [...result.mismatches, agentsMismatch]
+            : [...result.mismatches];
+        if (check) {
+            if (combinedFixCount > 0) {
+                const first = combinedMismatches[0];
+                if (first) {
+                    console.error(`wp sync --check: drift detected at ${first.targetPath}`);
+                    console.error(`  reason: ${first.reason}`);
+                    console.error(`  consumer: ${first.consumerId}`);
+                    if (combinedMismatches.length > 1) {
+                        console.error(`(${combinedMismatches.length - 1} additional drift entries follow)`);
+                        console.error(formatMismatches(combinedMismatches.slice(1)));
+                    }
+                    console.error('\nRun `wp sync` to repair, then commit the changes.');
+                }
+                else {
+                    console.error(`wp sync --check: ${combinedFixCount} drift items detected.`);
+                }
+                return 1;
+            }
+            console.log('wp sync --check: in sync.');
+            return 0;
+        }
+        if (combinedFixCount === 0) {
+            console.log('Already up to date.');
+            return 0;
+        }
+        console.log(`wp sync: wrote ${combinedFixCount} entries.`);
+        console.log('Synced. Restart your IDE to load new rules/skills.');
+        return 0;
+    });
+}
+//# sourceMappingURL=sync.js.map

package/dist/esm/cli/commands/tech-debt/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tech-debt command registration entry point.
+ */
+export { registerTechDebtRouter } from './router.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/cli/commands/tech-debt/index.js

@@ -0,0 +1,5 @@
+/**
+ * Tech-debt command registration entry point.
+ */
+export { registerTechDebtRouter } from './router.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/cli/commands/tech-debt/router-dispatch.d.ts

@@ -0,0 +1,22 @@
+import { type TechDebtCategory, type TechDebtSeverity, type TechDebtStatus, type ReviewCadence } from '#tech-debt/index';
+export interface TechDebtNewOptions {
+    severity?: TechDebtSeverity | string;
+    category?: TechDebtCategory | string;
+    reviewCadence?: ReviewCadence | string;
+    status?: TechDebtStatus | string;
+    dryRun?: boolean;
+    cwd?: string;
+    fromAudit?: string;
+}
+export interface TechDebtListOptions {
+    status?: string;
+    severity?: string;
+    category?: string;
+    cwd?: string;
+}
+export interface TechDebtReviewOptions {
+    cwd?: string;
+}
+export type TechDebtCommandOptions = TechDebtNewOptions & TechDebtListOptions & TechDebtReviewOptions;
+export declare function executeTechDebtSubcommand(subcommand: string, args: string[], options: TechDebtCommandOptions): Promise<void>;
+//# sourceMappingURL=router-dispatch.d.ts.map

package/dist/esm/cli/commands/tech-debt/router-dispatch.js

@@ -0,0 +1,436 @@
+/**
+ * Tech-debt subcommand dispatch.
+ *
+ * Handles: new, list, review
+ *
+ * Note: list and review use direct file scanning (not TechDebtService) because
+ * the service uses README.md file pattern for subdirectory-based layout, while
+ * the h-NNN-*.md flat file layout is what we write via `wp tech-debt new`.
+ */
+import { createHash } from 'node:crypto';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import matter from 'gray-matter';
+import { resolveTechDebtRoot } from '#utils/tech-debt-root';
+import { categorySchema, reviewCadenceSchema, severitySchema, techDebtFrontmatterSchema, techDebtStatusSchema, } from '#tech-debt/index';
+const STATUS_DIRS = ['accepted', 'needs-remediation', 'monitoring', 'resolved'];
+/**
+ * Convert a title to kebab-case for file naming.
+ */
+function toKebab(title) {
+    return title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+/**
+ * Find the next available h-NNN number across all status subdirectories.
+ */
+function nextHazardNumber(techDebtRoot) {
+    if (!existsSync(techDebtRoot))
+        return 1;
+    let maxN = 0;
+    for (const statusDir of STATUS_DIRS) {
+        const dir = path.join(techDebtRoot, statusDir);
+        if (!existsSync(dir))
+            continue;
+        try {
+            for (const file of readdirSync(dir)) {
+                const match = /^h-(\d+)-/.exec(file);
+                if (match?.[1]) {
+                    const n = parseInt(match[1], 10);
+                    if (n > maxN)
+                        maxN = n;
+                }
+            }
+        }
+        catch {
+            // ignore unreadable dirs
+        }
+    }
+    return maxN + 1;
+}
+/**
+ * Format a hazard number as zero-padded 3-digit string.
+ */
+function formatHazardNumber(n) {
+    return String(n).padStart(3, '0');
+}
+const SUPPORTED_FROM_AUDIT_NAMES = ['skill-sizes', 'broken-refs', 'memory-rotation'];
+function isSupportedAuditName(name) {
+    return SUPPORTED_FROM_AUDIT_NAMES.includes(name);
+}
+/**
+ * Run the named audit and extract findings.
+ */
+async function runAuditForTechDebt(auditName, cwd) {
+    switch (auditName) {
+        case 'skill-sizes': {
+            const { auditSkillSizes } = await import('#audit/skill-sizes');
+            const result = auditSkillSizes(cwd);
+            return { auditName, findings: result.violations };
+        }
+        case 'broken-refs': {
+            const { auditBrokenRefs } = await import('#audit/broken-refs');
+            const result = auditBrokenRefs(cwd);
+            return { auditName, findings: result.violations };
+        }
+        case 'memory-rotation': {
+            const { auditMemoryRotation } = await import('#audit/memory-rotation');
+            const result = auditMemoryRotation(cwd, { strict: false });
+            // Surface unacked rotations as findings
+            const findings = result.recentEvents
+                .filter((e) => !e.acked)
+                .map((e) => ({
+                file: e.sourcePath,
+                message: `Unacked rotation: section '${e.sectionSlug}' (${e.daysAgo}d ago)`,
+            }));
+            return { auditName, findings };
+        }
+    }
+}
+/**
+ * Compute a content-hash idempotency key: sha256(auditName + JSON.stringify(sortedFindings)).
+ */
+function computeAutoFiledHash(auditName, findings) {
+    const sorted = [...findings].sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+    const input = auditName + JSON.stringify(sorted);
+    return createHash('sha256').update(input).digest('hex').slice(0, 16);
+}
+/**
+ * Check if an existing tech-debt file has the given auto_filed_hash.
+ */
+function findExistingByHash(techDebtRoot, hash) {
+    for (const statusDir of STATUS_DIRS) {
+        const dir = path.join(techDebtRoot, statusDir);
+        if (!existsSync(dir))
+            continue;
+        let entries;
+        try {
+            entries = readdirSync(dir).filter((f) => f.endsWith('.md'));
+        }
+        catch {
+            continue;
+        }
+        for (const filename of entries) {
+            const filePath = path.join(dir, filename);
+            try {
+                const raw = readFileSync(filePath, 'utf8');
+                const parsed = matter(raw);
+                if (parsed.data?.['auto_filed_hash'] === hash) {
+                    return filePath;
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Map audit name to suggested severity.
+ */
+function auditNameToSeverity(auditName) {
+    switch (auditName) {
+        case 'skill-sizes':
+            return 'medium';
+        case 'broken-refs':
+            return 'high';
+        case 'memory-rotation':
+            return 'low';
+    }
+}
+/**
+ * Generate content for an auto-filed tech-debt entry from audit findings.
+ */
+function generateFromAuditContent(title, options) {
+    const today = new Date().toISOString().slice(0, 10);
+    const linkedBlueprintsYaml = options.linkedBlueprints.length > 0
+        ? options.linkedBlueprints.map((b) => `  - ${b}`).join('\n')
+        : '';
+    const findingsSummary = options.findings
+        .slice(0, 10)
+        .map((f) => `- ${f.file ? `\`${f.file}\`: ` : ''}${f.message}`)
+        .join('\n');
+    const moreCount = options.findings.length > 10 ? `\n…and ${options.findings.length - 10} more` : '';
+    return [
+        '---',
+        'type: tech-debt',
+        `status: ${options.status}`,
+        `severity: ${options.severity}`,
+        `category: ${options.category}`,
+        `review_cadence: ${options.reviewCadence}`,
+        `last_reviewed: '${today}'`,
+        `created: '${today}'`,
+        `auto_filed_hash: ${options.autoFiledHash}`,
+        linkedBlueprintsYaml ? `linked_blueprints:\n${linkedBlueprintsYaml}` : 'linked_blueprints: []',
+        'affected_modules: []',
+        '---',
+        '',
+        `# ${title}`,
+        '',
+        '## Findings',
+        '',
+        findingsSummary + moreCount,
+        '',
+        '<!-- Auto-filed from audit. Update this file as issues are resolved. -->',
+        '',
+    ].join('\n');
+}
+async function handleNewFromAudit(auditName, options) {
+    if (!isSupportedAuditName(auditName)) {
+        throw new Error(`Unknown audit name: ${auditName}. Supported: ${SUPPORTED_FROM_AUDIT_NAMES.join(', ')}`);
+    }
+    const cwd = options.cwd ?? process.cwd();
+    const techDebtRoot = resolveTechDebtRoot(cwd);
+    const auditResult = await runAuditForTechDebt(auditName, cwd);
+    const hash = computeAutoFiledHash(auditName, auditResult.findings);
+    // Idempotency check: bail if already filed
+    const existing = findExistingByHash(techDebtRoot, hash);
+    if (existing) {
+        console.log(`Already filed: ${existing}`);
+        return;
+    }
+    const severity = auditNameToSeverity(auditName);
+    const category = 'documentation';
+    const reviewCadence = 'biweekly';
+    const status = 'needs-remediation';
+    const today = new Date().toISOString().slice(0, 10);
+    const title = `Audit: ${auditName} findings — ${today}`;
+    const linkedBlueprints = [
+        'agent-asset-compiler-multi-runtime',
+        'agent-asset-audit-slice',
+    ];
+    const kebabTitle = toKebab(title);
+    const n = nextHazardNumber(techDebtRoot);
+    const filename = `h-${formatHazardNumber(n)}-${kebabTitle}.md`;
+    const statusDir = path.join(techDebtRoot, status);
+    const filePath = path.join(statusDir, filename);
+    if (options.dryRun) {
+        console.log(`Would create: ${filePath}`);
+        return;
+    }
+    await mkdir(statusDir, { recursive: true });
+    const content = generateFromAuditContent(title, {
+        status,
+        severity,
+        category,
+        reviewCadence,
+        autoFiledHash: hash,
+        linkedBlueprints,
+        findings: auditResult.findings,
+    });
+    await writeFile(filePath, content, { flag: 'wx' });
+    console.log(`Created: ${filePath}`);
+}
+/**
+ * Generate the markdown content for a new tech-debt file.
+ */
+function generateTechDebtContent(title, options) {
+    const today = new Date().toISOString().slice(0, 10);
+    return [
+        '---',
+        'type: tech-debt',
+        `status: ${options.status}`,
+        `severity: ${options.severity}`,
+        `category: ${options.category}`,
+        `review_cadence: ${options.reviewCadence}`,
+        `last_reviewed: '${today}'`,
+        `created: '${today}'`,
+        'linked_blueprints: []',
+        'affected_modules: []',
+        '---',
+        '',
+        `# ${title}`,
+        '',
+        '<!-- Describe the technical debt, its impact, and remediation approach. -->',
+        '',
+    ].join('\n');
+}
+/**
+ * Extract the title from the markdown body (first H1).
+ */
+function extractTitle(markdownBody, fallback) {
+    const match = /^#\s+(.+)$/m.exec(markdownBody);
+    return match?.[1]?.trim() ?? fallback;
+}
+/**
+ * Scan all tech-debt .md files from the status subdirectories.
+ */
+function scanTechDebtItems(techDebtRoot) {
+    const items = [];
+    if (!existsSync(techDebtRoot))
+        return items;
+    for (const statusDir of STATUS_DIRS) {
+        const dir = path.join(techDebtRoot, statusDir);
+        if (!existsSync(dir))
+            continue;
+        let entries;
+        try {
+            entries = readdirSync(dir).filter((f) => f.endsWith('.md'));
+        }
+        catch {
+            continue;
+        }
+        for (const filename of entries.sort()) {
+            const filePath = path.join(dir, filename);
+            const slug = `${statusDir}/${filename.replace(/\.md$/, '')}`;
+            try {
+                const raw = readFileSync(filePath, 'utf8');
+                const parsed = matter(raw);
+                const result = techDebtFrontmatterSchema.safeParse(parsed.data);
+                if (!result.success) {
+                    const firstError = result.error.issues[0];
+                    items.push({
+                        slug,
+                        title: parsed.data?.['title'] || filename,
+                        status: parsed.data?.['status'] || statusDir,
+                        severity: parsed.data?.['severity'] || 'unknown',
+                        category: parsed.data?.['category'],
+                        filePath,
+                        malformed: firstError
+                            ? `${firstError.path.join('.')}: ${firstError.message}`
+                            : 'Invalid frontmatter',
+                    });
+                    continue;
+                }
+                items.push({
+                    slug,
+                    title: extractTitle(parsed.content, filename),
+                    status: result.data.status,
+                    severity: result.data.severity,
+                    category: result.data.category,
+                    nextReview: result.data.nextReview,
+                    filePath,
+                });
+            }
+            catch (err) {
+                items.push({
+                    slug,
+                    title: filename,
+                    status: statusDir,
+                    severity: 'unknown',
+                    filePath,
+                    malformed: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+    }
+    return items;
+}
+async function handleNew(title, options) {
+    // Delegate to from-audit path when requested
+    if (options.fromAudit !== undefined) {
+        await handleNewFromAudit(options.fromAudit, options);
+        return;
+    }
+    const cwd = options.cwd ?? process.cwd();
+    const techDebtRoot = resolveTechDebtRoot(cwd);
+    // Validate inputs
+    const severityResult = severitySchema.safeParse(options.severity ?? 'medium');
+    if (!severityResult.success) {
+        throw new Error(`Invalid severity: ${options.severity}. Must be one of: critical, high, medium, low`);
+    }
+    const categoryResult = categorySchema.safeParse(options.category ?? 'complexity');
+    if (!categoryResult.success) {
+        throw new Error(`Invalid category: ${options.category}. Must be one of: complexity, testing, mutation, duplication, dependency, security, documentation`);
+    }
+    const cadenceResult = reviewCadenceSchema.safeParse(options.reviewCadence ?? 'quarterly');
+    if (!cadenceResult.success) {
+        throw new Error(`Invalid review-cadence: ${options.reviewCadence}. Must be one of: weekly, biweekly, monthly, quarterly`);
+    }
+    const statusResult = techDebtStatusSchema.safeParse(options.status ?? 'accepted');
+    if (!statusResult.success) {
+        throw new Error(`Invalid status: ${options.status}. Must be one of: accepted, needs-remediation, monitoring, resolved`);
+    }
+    const severity = severityResult.data;
+    const category = categoryResult.data;
+    const reviewCadence = cadenceResult.data;
+    const status = statusResult.data;
+    // Extra validation: critical must have weekly cadence
+    if (severity === 'critical' && reviewCadence !== 'weekly') {
+        throw new Error('Critical severity technical debt must have weekly review cadence');
+    }
+    const kebabTitle = toKebab(title);
+    const n = nextHazardNumber(techDebtRoot);
+    const filename = `h-${formatHazardNumber(n)}-${kebabTitle}.md`;
+    const statusDir = path.join(techDebtRoot, status);
+    const filePath = path.join(statusDir, filename);
+    if (options.dryRun) {
+        console.log(`Would create: ${filePath}`);
+        return;
+    }
+    await mkdir(statusDir, { recursive: true });
+    const content = generateTechDebtContent(title, { status, severity, category, reviewCadence });
+    await writeFile(filePath, content, { flag: 'wx' }); // O_EXCL: fail if exists
+    console.log(`Created: ${filePath}`);
+}
+async function handleList(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const techDebtRoot = resolveTechDebtRoot(cwd);
+    let items = scanTechDebtItems(techDebtRoot);
+    if (options.status) {
+        items = items.filter((item) => item.status === options.status);
+    }
+    if (options.severity) {
+        items = items.filter((item) => item.severity === options.severity);
+    }
+    if (options.category) {
+        items = items.filter((item) => item.category === options.category);
+    }
+    if (items.length === 0) {
+        console.log(`No tech-debt items found (root: ${techDebtRoot})`);
+        return;
+    }
+    console.log(`Tech-debt items (${items.length}):`);
+    for (const item of items) {
+        const overdue = item.nextReview && new Date(item.nextReview) < new Date() ? ' [OVERDUE]' : '';
+        const malformed = item.malformed ? ` [MALFORMED: ${item.malformed}]` : '';
+        console.log(`  ${item.slug} [${item.status}] [${item.severity}]${overdue}${malformed}`);
+        console.log(`    ${item.title}`);
+    }
+}
+async function handleReview(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const techDebtRoot = resolveTechDebtRoot(cwd);
+    const items = scanTechDebtItems(techDebtRoot);
+    const now = new Date();
+    const overdueItems = items.filter((item) => item.nextReview && new Date(item.nextReview) < now && !item.malformed);
+    if (overdueItems.length === 0) {
+        console.log(`No overdue tech-debt reviews (root: ${techDebtRoot})`);
+        return;
+    }
+    console.log(`Overdue tech-debt reviews (${overdueItems.length}):`);
+    for (const item of overdueItems) {
+        console.log(`  ${item.slug} [${item.status}] [${item.severity}] next review: ${item.nextReview ?? 'unknown'}`);
+        console.log(`    ${item.title}`);
+    }
+    throw Object.assign(new Error(`${overdueItems.length} overdue tech-debt item(s) require review`), { exitCode: 1 });
+}
+export async function executeTechDebtSubcommand(subcommand, args, options) {
+    switch (subcommand) {
+        case 'new': {
+            const title = args[0] ?? '';
+            // --from-audit derives its own title; a user-supplied title is optional in that mode
+            if (!title && !options.fromAudit) {
+                throw new Error('Usage: wp tech-debt new "<title>" --severity <s> --category <c>');
+            }
+            await handleNew(title, options);
+            return;
+        }
+        case 'list': {
+            await handleList(options);
+            return;
+        }
+        case 'review': {
+            await handleReview(options);
+            return;
+        }
+        default: {
+            throw new Error(`Unknown tech-debt subcommand: ${subcommand}\n\nUse one of: new, list, review`);
+        }
+    }
+}
+//# sourceMappingURL=router-dispatch.js.map

package/dist/esm/cli/commands/tech-debt/router.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `wp tech-debt` command router.
+ *
+ * Mirrors the blueprint router pattern:
+ * - router.ts  — registers the CAC command and wires options
+ * - router-dispatch.ts — dispatches subcommands
+ */
+import type { CAC } from 'cac';
+export declare function registerTechDebtRouter(cli: CAC): void;
+//# sourceMappingURL=router.d.ts.map

package/dist/esm/cli/commands/tech-debt/router.js

@@ -0,0 +1,30 @@
+import { executeTechDebtSubcommand } from './router-dispatch.js';
+export function registerTechDebtRouter(cli) {
+    cli
+        .command('tech-debt [subcommand] [...args]', 'Tech-debt lifecycle management (new, list, review)')
+        .option('--severity <severity>', 'Severity level: critical|high|medium|low (for new)')
+        .option('--category <category>', 'Category: complexity|testing|mutation|duplication|dependency|security|documentation (for new)')
+        .option('--review-cadence <cadence>', 'Review cadence: weekly|biweekly|monthly|quarterly (for new)')
+        .option('--status <status>', 'Status: accepted|needs-remediation|monitoring|resolved')
+        .option('--dry-run', 'Print would-be path without writing (for new)')
+        .option('--from-audit <audit>', 'Auto-file from audit findings: skill-sizes|broken-refs|memory-rotation (for new)')
+        .option('--cwd <dir>', 'Consumer repo root (default: process.cwd())')
+        .action(async (subcommand, args, options) => {
+        if (!subcommand) {
+            console.log([
+                'Usage: wp tech-debt <subcommand> [options]',
+                '',
+                'Subcommands:',
+                '  new "<title>" --severity <s> --category <c> [--review-cadence <r>] [--status <s>] [--dry-run]',
+                '  list [--status <s>] [--severity <s>] [--category <c>]',
+                '  review',
+                '',
+                'Options:',
+                '  --cwd <dir>   Consumer repo root (default: process.cwd())',
+            ].join('\n'));
+            return;
+        }
+        await executeTechDebtSubcommand(subcommand, args, options);
+    });
+}
+//# sourceMappingURL=router.js.map

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

@@ -0,0 +1,12 @@
+import type { CommandConfig, TestCommandOptions } from '#test';
+import type { CAC } from 'cac';
+export declare const TEST_COMMAND_HELP: string;
+export interface AkTestCommandInput extends TestCommandOptions {
+    package?: readonly string[] | string;
+    file?: readonly string[] | string;
+    targets?: readonly string[] | string;
+    passthrough?: readonly string[];
+}
+export declare function createAkTestCommandConfig(input: AkTestCommandInput): CommandConfig;
+export declare function registerTestCommand(cli: CAC): void;
+//# sourceMappingURL=test.d.ts.map