canary-test-cli 5.15.0 → 6.0.0

package/dist/engine/cli.core.js

@@ -0,0 +1,208 @@
+/**
+ * The main `canary` command -- faithful commander port of `agent/cli.py`
+ * (`app`), the culmination of the CLI wave. Mounts the already-ported sub-apps
+ * (`guardian`, `history`, `analyze`) plus the inline `skills` / `workflow` /
+ * `company-knowledge` sub-apps, and the ~15 top-level commands. Additive: the
+ * Python `agent.cli:app` stays the shipping entry point until a later cutover.
+ *
+ * Conventions follow `guardian/cli.ts` (see `cli-common.ts`): a
+ * {@link createCanaryCommand} factory wired to an injectable {@link MainDeps},
+ * `CliExit` for business exits, `normalizeUsageExit` on the program AND every
+ * subcommand so usage errors exit 2 (typer/click) not commander's default 1, and
+ * an eager `-V/--version` global option + `_main` callback analog.
+ *
+ * Sub-app mounting note: `guardian`/`history`/`analyze` are mounted as FRESH
+ * instances via their `createXCommand()` factories (functionally identical to
+ * the `guardianCommand`/`historyCommand`/`analyzeCommand` singletons but safe to
+ * mount into multiple `createCanaryCommand()` calls, e.g. across tests).
+ */
+import { Command, Option } from 'commander';
+import { CliExit, normalizeUsageExit } from './cli-common.js';
+import { createAnalyzeCommand } from './analysis/cli.js';
+import { doctorStub, feedbackCmd, flakeCheckCmd, frameworksCmd, healTestCmd, initCmd, migrateCmd, overlayStub, recommendCmd, reviewTestCmd, runCmd, setupCmd, ticketUpdateCmd, upgradeCmd, versionCmd, } from './cli-commands.js';
+import { buildCompanyKnowledgeCommand } from './company-knowledge-cli.js';
+import { createGuardianCommand } from './guardian/cli.js';
+import { createHistoryCommand } from './history/cli.js';
+import { buildSkillsCommand } from './skills-cli.js';
+import { buildWorkflowCommand } from './workflow-cli.js';
+import { defaultMainDeps } from './main-deps.js';
+/** Build a fresh `canary` command wired to `depsInit` (defaults fill any gap). */
+export function createCanaryCommand(depsInit = {}) {
+    const deps = { ...defaultMainDeps(), ...depsInit };
+    const program = new Command();
+    program
+        .name('canary')
+        .description('Canary -- AI-powered test automation agent.')
+        .option('-V, --version', 'Show version and exit.')
+        .exitOverride(normalizeUsageExit)
+        .hook('preAction', () => {
+        if (program.opts()['version']) {
+            versionCmd(deps);
+            throw new CliExit(0);
+        }
+    })
+        .action(() => {
+        if (program.opts()['version']) {
+            versionCmd(deps);
+            throw new CliExit(0);
+        }
+        // Python `typer.Typer(no_args_is_help=True)` prints help and exits 2 on a
+        // bare `canary` invocation (a usage exit), NOT 0.
+        program.outputHelp();
+        throw new CliExit(2);
+    });
+    program
+        .command('recommend')
+        .description('Classify a test prompt and recommend the best framework -- no API key required.')
+        .argument('<prompt>')
+        .option('--json', 'Output as JSON for tool integration.')
+        .action((prompt, opts) => {
+        recommendCmd(prompt, opts, deps);
+    });
+    program
+        .command('frameworks')
+        .description('List the supported testing frameworks and how to run each.')
+        .option('--json', 'Dump the registry as JSON for tool integration.')
+        .action((opts) => {
+        frameworksCmd(opts, deps);
+    });
+    program
+        .command('feedback')
+        .description('Report a bug, UX issue, doc gap, or idea.')
+        .argument('[message]', 'Your feedback message.')
+        .addOption(new Option('--category <category>', 'bug | ux | docs | idea').default('idea'))
+        .option('--json', 'Emit the payload + issue URL as JSON.')
+        .option('--open', 'Open the pre-filled issue in a browser.')
+        .action((message, opts) => {
+        feedbackCmd(message, opts, deps);
+    });
+    program
+        .command('run')
+        .description("Execute a test file using Canary's integrated executor.")
+        .argument('<file_path>')
+        .argument('<framework>', 'Framework to use (e.g., playwright, pytest)')
+        .action((filePath, framework) => {
+        runCmd(filePath, framework, deps);
+    });
+    program
+        .command('init')
+        .description('Scaffold a test suite, or -- with no framework -- show setup options.')
+        .argument('[framework]', 'Framework to scaffold (playwright, vitest, pytest, k6). Omit to see options.')
+        .action((framework) => {
+        initCmd(framework, deps);
+    });
+    program
+        .command('setup')
+        .description('Set up canary in this repo -- interactive .canary/company.json wizard.')
+        .option('--force', 'Overwrite an existing .canary/company.json.')
+        .action((opts) => {
+        setupCmd(opts, deps);
+    });
+    program
+        .command('migrate')
+        .description("Migrate a harness-scaffolded test-suite project to Canary's layout.")
+        .addOption(new Option('-p, --path <path>', 'Project root to migrate (default: current directory).').default('.'))
+        .option('-f, --framework <framework>', 'Override auto-detected framework.')
+        .option('--from <overlay>', 'Tracked overlay (name or path) whose .canary/skills/ are deployed into the target.')
+        .option('-o, --overlay <path>', '[deprecated: use --from] Path to an overlay repo whose .canary/skills/ are deployed.')
+        .option('--apply', 'Write files. Without this flag the command is a dry run.')
+        .option('--check', 'Freshness gate: report drift without writing.')
+        .option('--json', 'Emit the report as JSON.')
+        .action((opts) => {
+        migrateCmd(opts, deps);
+    });
+    program
+        .command('review-test')
+        .description('Lint test files for quality issues -- no LLM or API key required.')
+        .argument('<path>', 'Test file or directory to lint.')
+        .option('--static', 'Run static-only analysis (no LLM).')
+        .option('--no-static', 'Disable static-only analysis.')
+        .option('-f, --framework <framework>', 'Force framework: pytest, playwright, vitest, k6.')
+        .option('--json', 'Output findings as JSON.')
+        .action((path, opts) => {
+        reviewTestCmd(path, opts, deps);
+    });
+    program
+        .command('flake-check')
+        .description('Detect flakiness patterns in test files -- no LLM or API key required.')
+        .argument('<path>', 'Test file or directory to check.')
+        .option('--json', 'Output findings as JSON.')
+        .action((path, opts) => {
+        flakeCheckCmd(path, opts, deps);
+    });
+    program
+        .command('heal-test')
+        .description('Apply deterministic pattern fixes to a test file -- no LLM required.')
+        .argument('<path>', 'Test file to heal.')
+        .option('--pattern', 'Apply regex-safe pattern fixes (no LLM).')
+        .option('--no-pattern', 'Disable pattern fixes.')
+        .option('--dry-run', 'Show what would change without writing.')
+        .option('--json', 'Output results as JSON.')
+        .action((path, opts) => {
+        healTestCmd(path, opts, deps);
+    });
+    program
+        .command('version')
+        .description('Show Canary version info.')
+        .action(() => {
+        versionCmd(deps);
+    });
+    program
+        .command('upgrade')
+        .description('Upgrade Canary to the latest published version.')
+        .option('--dry-run', 'Show what would change without upgrading.')
+        .action((opts) => {
+        upgradeCmd(opts, deps);
+    });
+    program
+        .command('overlay')
+        .description('Manage tracked overlays (requires the npm install of Canary).')
+        .allowUnknownOption(true)
+        .allowExcessArguments(true)
+        .argument('[args...]')
+        .action(() => {
+        overlayStub(deps);
+    });
+    program
+        .command('doctor')
+        .description('Diagnose your Canary setup (requires the npm install of Canary).')
+        .allowUnknownOption(true)
+        .allowExcessArguments(true)
+        .argument('[args...]')
+        .action(() => {
+        doctorStub(deps);
+    });
+    program
+        .command('ticket-update')
+        .description('Post a run comment and/or transition the linked ticket after a test run.')
+        .option('--test-file <path>', 'Test file to extract linkage from (default: last run).')
+        .option('--result <path>', 'Path to canary report JSON (default: auto-detect).')
+        .option('--dry-run', "Show what would be posted/transitioned; don't write.")
+        .option('--comment-only', 'Post comment but skip transition.')
+        .option('--transition-only', 'Transition only, skip comment.')
+        .option('--project <project>', 'Override auto-detected project key.')
+        .option('--ticket <ticket>', 'Override auto-detected ticket key (e.g. PROJ-1234).')
+        .action(async (opts) => {
+        await ticketUpdateCmd(opts, deps);
+    });
+    // Sub-apps (fresh instances -- see module docstring). The already-ported
+    // guardian/history/analyze factories carry their own deps; we forward the main
+    // out/err sinks so their output flows through the same channel (captured in
+    // tests, process.stdout in production).
+    const sinks = { out: deps.out, err: deps.err };
+    program.addCommand(createHistoryCommand(sinks));
+    program.addCommand(createAnalyzeCommand(sinks));
+    program.addCommand(createGuardianCommand(sinks));
+    program.addCommand(buildSkillsCommand(deps));
+    program.addCommand(buildWorkflowCommand(deps));
+    program.addCommand(buildCompanyKnowledgeCommand(deps));
+    // Propagate the usage-exit normalization to every top-level command (the
+    // sub-apps also set it on their own subcommands internally).
+    for (const sub of program.commands) {
+        sub.exitOverride(normalizeUsageExit);
+    }
+    return program;
+}
+/** The production `canary` command (process-backed defaults). */
+export const canaryCommand = createCanaryCommand();
+//# sourceMappingURL=cli.js.map

package/dist/engine/cli.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+// GENERATED by npm/scripts/build-engine.mjs -- do not edit by hand.
+// Executable counterpart of the compiled command module (cli.core.js), which
+// only exports createCanaryCommand. Mirrors ts/bin/canary.js.
+import { createRequire } from 'node:module';
+
+import { CommanderError } from 'commander';
+
+import { createCanaryCommand } from './cli.core.js';
+import { CliExit } from './cli-common.js';
+
+const require = createRequire(import.meta.url);
+
+function readVersion() {
+  try {
+    return require('../../package.json').version || 'unknown';
+  } catch {
+    return 'unknown';
+  }
+}
+
+const program = createCanaryCommand({ pkgVersion: () => readVersion() });
+
+try {
+  await program.parseAsync(process.argv.slice(2), { from: 'user' });
+} catch (err) {
+  if (err instanceof CliExit) process.exit(err.code);
+  if (err instanceof CommanderError) process.exit(err.exitCode);
+  console.error(err);
+  process.exit(1);
+}

package/dist/engine/company-knowledge-cli.js

@@ -0,0 +1,201 @@
+/**
+ * `canary company-knowledge` sub-app -- faithful port of the `ck_app` commands
+ * in `agent/cli.py` (`show` + `init`). `init` is exported as {@link ckInitCmd}
+ * so the top-level `setup` alias can call it directly (Python `setup` -> `ck_init`).
+ *
+ * The interactive `init` wizard reads through {@link MainDeps.prompt} (typer.prompt
+ * analog); the production default reads piped stdin lines and falls back to the
+ * shown default, so a non-interactive/CI invocation keeps existing values.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { Command, Option } from 'commander';
+import pc from 'picocolors';
+import { CliExit, jsonIndent2, normalizeUsageExit } from './cli-common.js';
+import { CompanyKnowledge } from './core/company-knowledge.js';
+import { CHECK, CROSS, WARN } from './main-deps.js';
+function ckShowCmd(opts, deps) {
+    const ck = deps.loadCompanyKnowledge(opts.env ?? null);
+    if (ck.error && ck.isEmpty) {
+        deps.out(`${pc.red(CROSS)} ${ck.error}`);
+        throw new CliExit(1);
+    }
+    if (opts.json) {
+        deps.out(jsonIndent2(ck.toDict()));
+        return;
+    }
+    if (ck.isEmpty) {
+        deps.out(`${pc.yellow('No company knowledge configured.')}  Create ${pc.bold('.canary/company.json')} or run ${pc.bold('canary company-knowledge init')}.`);
+        return;
+    }
+    const sourcesStr = ck.sources.length ? ck.sources.join(', ') : 'none';
+    deps.out(`${pc.bold(pc.green(`${CHECK} Company Knowledge`))}  ${pc.dim(`sources: ${sourcesStr}`)}\n`);
+    if (ck.confluence_spaces.length) {
+        deps.out(`${pc.bold('Confluence spaces:')} ${ck.confluence_spaces.join(', ')}`);
+    }
+    if (ck.jira_projects.length) {
+        deps.out(`${pc.bold('Jira projects:')}     ${ck.jira_projects.join(', ')}`);
+    }
+    if (ck.internal_doc_urls.length) {
+        deps.out(pc.bold('Reference docs:'));
+        for (const url of ck.internal_doc_urls)
+            deps.out(`  ${url}`);
+    }
+    if (ck.internal_domains.length) {
+        deps.out(`${pc.bold('Internal domains:')}  ${ck.internal_domains.join(', ')}`);
+    }
+    if (ck.mcp_servers.length) {
+        deps.out(`${pc.bold('MCP servers:')}       ${ck.mcp_servers.join(', ')}`);
+    }
+    if (ck.claude_code_skills.length) {
+        deps.out(`${pc.bold('Claude Code skills:')} ${ck.claude_code_skills.join(', ')}`);
+    }
+    if (ck.dashboard_url) {
+        deps.out(`${pc.bold('Dashboard URL:')}     ${ck.dashboard_url}`);
+    }
+    if (ck.otel_exporter_endpoint) {
+        deps.out(`${pc.bold('OTel endpoint:')}     ${ck.otel_exporter_endpoint}`);
+    }
+    if (ck.notes) {
+        deps.out(`${pc.bold('Notes:')} ${ck.notes}`);
+    }
+    if (!ck.brand.isEmpty) {
+        const label = ck.brand.assets['company_name'] || '(unnamed)';
+        deps.out(`${pc.bold('Brand:')}            ${label}  ${pc.dim('(customer-facing reports)')}`);
+    }
+    if (ck.error) {
+        deps.out(`\n${pc.yellow(WARN)} ${ck.error}`);
+    }
+    if (ck.warnings.length) {
+        deps.out('');
+        for (const w of ck.warnings)
+            deps.out(`${pc.yellow(WARN)} ${w}`);
+    }
+}
+/**
+ * Interactive `.canary/company.json` wizard. Exported so `setup` can alias it.
+ */
+export function ckInitCmd(opts, deps) {
+    const canaryDir = join(deps.cwd(), '.canary');
+    const outPath = join(canaryDir, 'company.json');
+    // Existing values become the shown defaults (load() returns empty when absent).
+    const existing = CompanyKnowledge.load(deps.cwd(), null, deps.home());
+    if (existsSync(outPath) && !opts.force) {
+        deps.out(`${pc.yellow(WARN)}  ${pc.bold(outPath)} already exists.\nExisting values will be shown as defaults. Pass ${pc.bold('--force')} to start from scratch.`);
+        deps.out('');
+    }
+    const promptList = (label, current, hint = '') => {
+        const defaultStr = current.join(', ');
+        const displayDefault = defaultStr ? ` [${defaultStr}]` : '';
+        const text = `${label}${displayDefault} (comma-separated${hint ? ', ' + hint : ''}): `;
+        const raw = deps.prompt(text, defaultStr);
+        if (!raw.trim())
+            return current;
+        return raw
+            .split(',')
+            .map((v) => v.trim())
+            .filter((v) => v);
+    };
+    const promptStr = (label, current, hint = '') => {
+        const displayDefault = current ? ` [${current}]` : '';
+        const text = `${label}${displayDefault}${hint ? ` (${hint}): ` : ': '}`;
+        return deps.prompt(text, current).trim();
+    };
+    deps.out(pc.bold(pc.cyan('Canary Company Knowledge Setup')) + '\n');
+    deps.out('Enter values for each pointer field, or press Enter to keep the current value.');
+    deps.out(`Leave a field empty to skip it. ${pc.dim('Secrets are never accepted here.')}\n`);
+    const confluenceSpaces = promptList('Confluence space keys', existing.confluence_spaces, 'uppercase, e.g. QA');
+    const jiraProjects = promptList('Jira project keys', existing.jira_projects, 'uppercase, e.g. PROJ');
+    deps.out('\nInternal doc URLs (one per line, blank line to finish):');
+    const docUrls = [...existing.internal_doc_urls];
+    if (docUrls.length)
+        deps.out(`  Current: ${docUrls.join(', ')}`);
+    for (;;) {
+        const url = deps.prompt('  URL (or Enter to finish)', '');
+        if (!url.trim())
+            break;
+        docUrls.push(url.trim());
+    }
+    const internalDomains = promptList('\nInternal hostnames', existing.internal_domains, 'e.g. corp.example.com');
+    const mcpServers = promptList('MCP server identifiers', existing.mcp_servers, 'e.g. plugin_atlassian_atlassian');
+    const claudeCodeSkills = promptList('Claude Code skill slugs', existing.claude_code_skills, 'e.g. team:skill-name');
+    const notesRaw = promptStr('\nFree-text notes for the LLM', existing.notes, 'no secrets');
+    const notes = notesRaw ? notesRaw.slice(0, 2048) : '';
+    deps.out(`\n${pc.bold('Brand assets')} ${pc.dim('(for customer-facing reports; all optional)')}`);
+    const existingBrand = existing.brand.assets;
+    const brand = { ...existingBrand };
+    const ba = (k) => existingBrand[k] ?? '';
+    const prompted = {
+        company_name: promptStr('Company name', ba('company_name'), 'e.g. Acme Corp'),
+        logo_path: promptStr('Logo path (in-repo)', ba('logo_path'), 'e.g. assets/logo.svg'),
+        logo_url: promptStr('Logo URL (if hosted)', ba('logo_url'), 'https://...'),
+        primary_color: promptStr('Primary color', ba('primary_color'), '#RRGGBB'),
+        secondary_color: promptStr('Secondary color', ba('secondary_color'), '#RRGGBB'),
+        text_color: promptStr('Text color', ba('text_color'), '#RRGGBB'),
+        background_color: promptStr('Background color', ba('background_color'), '#RRGGBB'),
+        footer_note: promptStr('Report footer note', ba('footer_note'), 'e.g. Acme QA report'),
+    };
+    for (const [k, v] of Object.entries(prompted)) {
+        if (v)
+            brand[k] = v;
+    }
+    const out = {};
+    if (confluenceSpaces.length) {
+        out['confluence_spaces'] = confluenceSpaces.map((v) => v.toUpperCase());
+    }
+    if (jiraProjects.length) {
+        out['jira_projects'] = jiraProjects.map((v) => v.toUpperCase());
+    }
+    if (docUrls.length)
+        out['internal_doc_urls'] = docUrls;
+    if (internalDomains.length) {
+        out['internal_domains'] = internalDomains.map((v) => v.toLowerCase());
+    }
+    if (mcpServers.length)
+        out['mcp_servers'] = mcpServers;
+    if (claudeCodeSkills.length) {
+        out['claude_code_skills'] = claudeCodeSkills.map((v) => v.toLowerCase());
+    }
+    if (notes)
+        out['notes'] = notes;
+    if (Object.keys(brand).length)
+        out['brand'] = brand;
+    mkdirSync(canaryDir, { recursive: true });
+    const gitignore = join(deps.cwd(), '.gitignore');
+    if (existsSync(gitignore)) {
+        const content = readFileSync(gitignore, 'utf-8');
+        if (!content.includes('.canary/')) {
+            writeFileSync(gitignore, content.replace(/\s+$/, '') + '\n.canary/\n', 'utf-8');
+        }
+    }
+    writeFileSync(outPath, jsonIndent2(out) + '\n', 'utf-8');
+    deps.out(`\n${pc.green(CHECK)} Written to ${pc.bold(outPath)}`);
+    deps.out(pc.dim('Verify with: canary company-knowledge show'));
+}
+/** Build the `company-knowledge` sub-app wired to `deps`. */
+export function buildCompanyKnowledgeCommand(deps) {
+    const program = new Command('company-knowledge');
+    program
+        .description('Manage company-knowledge pointers in .canary/company.json.')
+        .exitOverride(normalizeUsageExit);
+    program
+        .command('show')
+        .description('Print the merged company-knowledge view.')
+        .option('-e, --env <env>', "Environment override layer to load (e.g. 'uat'). Defaults to CANARY_ENV.")
+        .option('--json', 'Emit raw JSON.')
+        .action((opts) => {
+        ckShowCmd(opts, deps);
+    });
+    program
+        .command('init')
+        .description('Interactively scaffold .canary/company.json.')
+        .addOption(new Option('--force', 'Overwrite an existing .canary/company.json.'))
+        .action((opts) => {
+        ckInitCmd(opts, deps);
+    });
+    for (const sub of program.commands) {
+        sub.exitOverride(normalizeUsageExit);
+    }
+    return program;
+}
+//# sourceMappingURL=company-knowledge-cli.js.map

package/dist/engine/core/ci-env.js

@@ -0,0 +1,33 @@
+/**
+ * CI environment detection for Canary headless optimizations.
+ *
+ * Faithful TypeScript port of `agent/core/ci_env.py`.
+ *
+ * Python→TS nuances:
+ *   - `os.environ.get(v)` → `process.env[v]` (an unset var is `undefined`).
+ *   - Python's `any(os.environ.get(v) ...)` uses truthiness: a non-empty
+ *     string is truthy, `""` is falsy, and `"0"` is truthy (non-empty). JS
+ *     `Boolean(process.env[v])` matches exactly — `undefined`/`""` → false,
+ *     `"0"`/`"true"` → true.
+ */
+// Most platforms set CI=true; GitLab sets CI_SERVER; Bitbucket sets
+// BITBUCKET_BUILD_NUMBER.
+const CI_VARS = [
+    'CI',
+    'GITHUB_ACTIONS',
+    'CIRCLECI',
+    'TRAVIS',
+    'CI_SERVER',
+    'BITBUCKET_BUILD_NUMBER',
+    'JENKINS_URL',
+    'TEAMCITY_VERSION',
+];
+/**
+ * Return true when a recognized CI environment variable is set and non-empty.
+ *
+ * Python: `is_ci`.
+ */
+export function isCi() {
+    return CI_VARS.some((v) => Boolean(process.env[v]));
+}
+//# sourceMappingURL=ci-env.js.map

package/dist/engine/core/classifier.js

@@ -0,0 +1,192 @@
+/**
+ * Test Classifier — rule-based intent/test-type detection from a prompt.
+ *
+ * Faithful TypeScript port of `agent/core/classifier.py`. Confidence values are
+ * hand-picked heuristic priors (ordinal signal strength), NOT calibrated
+ * probabilities — see the Python module docstring. `TestClassifier` is a domain
+ * class name, not a test suite.
+ */
+// HTTP verb + slash-prefixed path: "GET /users", "POST /items/{id}".
+const HTTP_VERB_PATH_RE = /\b(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+\//i;
+// Bare uppercase HTTP verb (case-sensitive, to avoid English-word false hits).
+const HTTP_VERB_RE = /\b(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\b/;
+// Explicit framework name → implied test_type. Order matters: the alternation
+// is tried leftmost-first at the earliest match position (as in Python).
+const FRAMEWORK_HINTS = [
+    ['playwright', 'e2e_ui'],
+    ['cypress', 'e2e_ui'],
+    ['vitest', 'frontend_unit'],
+    ['jest', 'frontend_unit'],
+    ['pytest', 'api'],
+    ['hurl', 'api'],
+    ['k6', 'performance'],
+    ['axe', 'accessibility'],
+    ['axe-core', 'accessibility'],
+    ['pa11y', 'accessibility'],
+    ['zap', 'security'],
+    ['backstopjs', 'visual'],
+    ['percy', 'visual'],
+    ['pact', 'contract'],
+    ['schemathesis', 'contract'],
+    ['chaos-toolkit', 'chaos'],
+    ['faker', 'synthetic_data'],
+    ['sdv', 'synthetic_data'],
+    ['opentelemetry', 'observability'],
+    ['maestro', 'mobile'],
+    ['appium', 'mobile'],
+    ['wdio', 'mobile'],
+    ['webdriverio', 'mobile'],
+    ['locust', 'load'],
+    ['gatling', 'load'],
+    ['stryker', 'mutation'],
+    ['mutmut', 'mutation'],
+    ['semgrep', 'static_analysis'],
+    ['testcontainers', 'integration'],
+    ['fast-check', 'property'],
+    ['fastcheck', 'property'],
+    ['hypothesis', 'property'],
+    ['promptfoo', 'llm_eval'],
+];
+const HINT_TYPE = new Map(FRAMEWORK_HINTS);
+// Specialized categories keyed by high-specificity phrases; first match wins.
+const CATEGORY_KEYWORDS = [
+    ['accessibility', ['accessibility', 'a11y', 'wcag', 'screen reader']],
+    [
+        'security',
+        [
+            'security test',
+            'pentest',
+            'penetration test',
+            'vulnerability scan',
+            'owasp',
+            'dast',
+            'sast',
+        ],
+    ],
+    [
+        'visual',
+        [
+            'visual regression',
+            'visual test',
+            'screenshot test',
+            'snapshot test',
+            'pixel diff',
+        ],
+    ],
+    [
+        'contract',
+        [
+            'contract test',
+            'consumer-driven contract',
+            'pact test',
+            'openapi contract',
+            'schema contract',
+        ],
+    ],
+    [
+        'chaos',
+        ['chaos engineering', 'chaos test', 'fault injection', 'resilience test'],
+    ],
+    [
+        'synthetic_data',
+        ['synthetic data', 'fake data', 'test data generation', 'data generation'],
+    ],
+    [
+        'observability',
+        [
+            'observability',
+            'telemetry',
+            'distributed tracing',
+            'instrumentation test',
+        ],
+    ],
+    [
+        'mobile',
+        [
+            'mobile test',
+            'android test',
+            'ios test',
+            'react native test',
+            'mobile app test',
+        ],
+    ],
+    ['mutation', ['mutation test', 'mutation testing', 'mutation score']],
+    [
+        'static_analysis',
+        ['static analysis', 'lint rule', 'code smell', 'sonarqube'],
+    ],
+    ['load', ['soak test', 'spike test', 'concurrent users', 'load profile']],
+    [
+        'integration',
+        ['integration test', 'integration testing', 'end-to-end integration'],
+    ],
+    [
+        'property',
+        [
+            'property-based',
+            'property based',
+            'property test',
+            'invariant test',
+            'quickcheck',
+            'generative test',
+        ],
+    ],
+    [
+        'llm_eval',
+        [
+            'llm eval',
+            'llm evaluation',
+            'prompt regression',
+            'prompt eval',
+            'llm behavior',
+            'llm regression',
+        ],
+    ],
+];
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+const FRAMEWORK_HINT_RE = new RegExp('\\b(' + FRAMEWORK_HINTS.map(([k]) => escapeRe(k)).join('|') + ')\\b', 'i');
+/** The lowercase framework name explicitly named in the prompt, if any. */
+export function extractFrameworkHint(prompt) {
+    const m = FRAMEWORK_HINT_RE.exec(prompt);
+    return m ? m[1].toLowerCase() : null;
+}
+function result(testType, confidence) {
+    return { intent: 'generate_tests', test_type: testType, confidence };
+}
+function matchesAny(haystack, needles) {
+    return needles.some((n) => haystack.includes(n));
+}
+const PERFORMANCE_KEYWORDS = ['performance', 'load test', 'stress test'];
+// [keywords, testType, confidence] — the generic fallbacks checked after the
+// framework-hint and HTTP-signal rules; first match wins.
+const TRAILING_RULES = [
+    [['api', 'endpoint', 'request'], 'api', 0.85],
+    [['component', 'react', 'frontend'], 'frontend_unit', 0.9],
+    [['login', 'checkout', 'user flow'], 'e2e_ui', 0.8],
+];
+export class TestClassifier {
+    classify(prompt) {
+        const lower = prompt.toLowerCase();
+        if (matchesAny(lower, PERFORMANCE_KEYWORDS))
+            return result('performance', 0.95);
+        for (const [testType, keywords] of CATEGORY_KEYWORDS) {
+            if (matchesAny(lower, keywords))
+                return result(testType, 0.88);
+        }
+        const hint = FRAMEWORK_HINT_RE.exec(prompt);
+        if (hint)
+            return result(HINT_TYPE.get(hint[1].toLowerCase()), 0.95);
+        if (HTTP_VERB_PATH_RE.test(prompt))
+            return result('api', 0.95);
+        if (HTTP_VERB_RE.test(prompt))
+            return result('api', 0.85);
+        for (const [keywords, testType, confidence] of TRAILING_RULES) {
+            if (matchesAny(lower, keywords))
+                return result(testType, confidence);
+        }
+        return result('e2e_ui', 0.5);
+    }
+}
+//# sourceMappingURL=classifier.js.map