canary-test-cli 5.15.0 → 6.0.0

package/dist/engine/core/environment-detect.js

@@ -0,0 +1,410 @@
+/**
+ * Context-aware environment & persona detection (issue #341).
+ *
+ * Faithful TypeScript port of `agent/core/environment_detect.py`.
+ *
+ * Canary tailors which skills load, which user pool it queries, and how it
+ * phrases output based on *who* is driving and *what* they are testing. This
+ * module gathers that context from cheap, local, deterministic signals so a
+ * consumer (currently the MCP `analyze_file` path) can attach it to its
+ * response without any network call or model round-trip.
+ *
+ * Three detection paths are implemented — the concrete, testable ones:
+ *   1. **BASE_URL** — from `.env` (canonical `BASE_URL` plus common aliases),
+ *      falling back to a literal `baseURL` in `playwright.config.*`.
+ *   2. **Suite hints** — parse `playwright.config.*` for `testDir` / project
+ *      names / `testMatch` to classify the suite as e2e / component / api.
+ *   3. **User level (SDET vs manual)** — a transparent, documented heuristic
+ *      over cwd and the caller-supplied list of open files.
+ *
+ * Python→TS nuances:
+ *   - `os.environ` is not touched here; all inputs are paths.
+ *   - `Path(p).resolve()` → `resolve(p)`; `Path.exists()` → `existsSync`;
+ *     `read_text(encoding="utf-8", errors="ignore")` → `readFileSync(p,
+ *     'utf-8')` (Node substitutes U+FFFD on bad bytes rather than dropping).
+ *   - `re.search`/`re.findall` map to a single `.exec` / a global-regex loop.
+ *   - `round(x, 3)` is Python round-half-to-even, reproduced by {@link round3}.
+ *   - `Path(f).suffix` → `extname` (both yield "" for a dotfile like `.env`).
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { extname, join, resolve } from 'node:path';
+// Ordered by trust: the canonical name wins over framework-specific aliases.
+const BASE_URL_KEYS = [
+    'BASE_URL',
+    'PLAYWRIGHT_BASE_URL',
+    'E2E_BASE_URL',
+    'APP_URL',
+];
+const PLAYWRIGHT_CONFIGS = [
+    'playwright.config.ts',
+    'playwright.config.js',
+    'playwright.config.mts',
+    'playwright.config.mjs',
+    'playwright.config.cts',
+    'playwright.config.cjs',
+];
+// Extensions that indicate someone is writing/reading code or automated tests.
+const CODE_SUFFIXES = new Set([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.py',
+    '.java',
+    '.rb',
+    '.go',
+    '.cs',
+]);
+// Extensions that indicate manual test artefacts (plans, case sheets, notes).
+const MANUAL_SUFFIXES = new Set([
+    '.md',
+    '.csv',
+    '.xlsx',
+    '.xls',
+    '.docx',
+    '.doc',
+    '.pdf',
+    '.txt',
+]);
+// Config filenames whose mere presence marks an automation-savvy project.
+const TEST_CONFIG_FILES = [
+    'playwright.config.ts',
+    'playwright.config.js',
+    'vitest.config.ts',
+    'vitest.config.js',
+    'pytest.ini',
+    'jest.config.js',
+    'jest.config.ts',
+    'cypress.config.ts',
+    'cypress.config.js',
+];
+const PROJECT_MANIFESTS = [
+    'package.json',
+    'pyproject.toml',
+    'requirements.txt',
+];
+// cwd path fragments that lean manual.
+const MANUAL_DIR_HINTS = [
+    'manual',
+    'test-case',
+    'testcase',
+    'test-plan',
+    'testplan',
+];
+/** Python-compatible `round(x, 3)` — round-half-to-even at 3 decimal places. */
+function round3(x) {
+    const scaled = x * 1000;
+    const floor = Math.floor(scaled);
+    const diff = scaled - floor;
+    const eps = 1e-9;
+    let rounded;
+    if (Math.abs(diff - 0.5) < eps) {
+        rounded = floor % 2 === 0 ? floor : floor + 1;
+    }
+    else {
+        rounded = Math.round(scaled);
+    }
+    return rounded / 1000;
+}
+/** Split like Python's `str.splitlines()` for the common line endings. */
+function splitLines(text) {
+    return text.split(/\r\n|\r|\n/);
+}
+/** Python `str.strip()` (no args) — trim ASCII whitespace both ends. */
+function stripWs(s) {
+    return s.trim();
+}
+/** Python `str.strip(ch)` — remove all leading/trailing runs of `ch`. */
+function stripChar(s, ch) {
+    let start = 0;
+    let end = s.length;
+    while (start < end && s[start] === ch)
+        start++;
+    while (end > start && s[end - 1] === ch)
+        end--;
+    return s.slice(start, end);
+}
+/**
+ * Detected environment/persona context for the current invocation.
+ *
+ * Python: `EnvironmentContext` (a dataclass). All fields are
+ * optional/degradable: absent signals leave sensible `null` / `"unknown"`
+ * defaults rather than raising.
+ */
+export class EnvironmentContext {
+    base_url;
+    base_url_source; // ".env" | "playwright.config" | null
+    suite_type; // "e2e" | "component" | "api" | null
+    suite_hints;
+    user_level; // "sdet" | "manual" | "unknown"
+    user_level_signals;
+    user_level_confidence;
+    constructor(init = {}) {
+        this.base_url = init.base_url ?? null;
+        this.base_url_source = init.base_url_source ?? null;
+        this.suite_type = init.suite_type ?? null;
+        this.suite_hints = init.suite_hints ?? [];
+        this.user_level = init.user_level ?? 'unknown';
+        this.user_level_signals = init.user_level_signals ?? [];
+        this.user_level_confidence = init.user_level_confidence ?? 0.0;
+    }
+    /**
+     * Return a JSON-serialisable view for embedding in MCP responses.
+     *
+     * Python: `EnvironmentContext.to_dict`.
+     */
+    toDict() {
+        return {
+            base_url: this.base_url,
+            base_url_source: this.base_url_source,
+            suite_type: this.suite_type,
+            suite_hints: [...this.suite_hints],
+            user_level: this.user_level,
+            user_level_signals: [...this.user_level_signals],
+            user_level_confidence: round3(this.user_level_confidence),
+        };
+    }
+}
+// ---------------------------------------------------------------------------
+// Path 2 (issue path b): BASE_URL from .env / playwright.config.*
+// ---------------------------------------------------------------------------
+/**
+ * Return the first BASE_URL-family value from `.env`, or null.
+ *
+ * Python: `_parse_dotenv_base_url`.
+ */
+function parseDotenvBaseUrl(root) {
+    const path = join(root, '.env');
+    if (!existsSync(path))
+        return null;
+    let text;
+    try {
+        text = readFileSync(path, 'utf-8');
+    }
+    catch {
+        // Python catches OSError → None.
+        return null;
+    }
+    const found = {};
+    for (const raw of splitLines(text)) {
+        let line = stripWs(raw);
+        if (!line || line.startsWith('#'))
+            continue;
+        if (line.startsWith('export ')) {
+            line = line.slice('export '.length).replace(/^\s+/, '');
+        }
+        if (!line.includes('='))
+            continue;
+        const idx = line.indexOf('=');
+        const key = stripWs(line.slice(0, idx));
+        let value = stripWs(line.slice(idx + 1));
+        value = stripChar(stripChar(value, '"'), "'");
+        if (BASE_URL_KEYS.includes(key) &&
+            value &&
+            !Object.prototype.hasOwnProperty.call(found, key)) {
+            found[key] = value;
+        }
+    }
+    // Honour trust order regardless of file order.
+    for (const key of BASE_URL_KEYS) {
+        if (Object.prototype.hasOwnProperty.call(found, key))
+            return found[key];
+    }
+    return null;
+}
+/**
+ * Return a *literal* `baseURL` from playwright.config.*, or null.
+ *
+ * A `process.env.*` indirection is deliberately ignored — there is no literal
+ * URL to report, and inventing one would be misleading.
+ *
+ * Python: `_parse_config_base_url`.
+ */
+function parseConfigBaseUrl(root) {
+    for (const name of PLAYWRIGHT_CONFIGS) {
+        const path = join(root, name);
+        if (!existsSync(path))
+            continue;
+        let text;
+        try {
+            text = readFileSync(path, 'utf-8');
+        }
+        catch {
+            // Python catches OSError → continue.
+            continue;
+        }
+        const match = /baseURL\s*:\s*['"]([^'"]+)['"]/.exec(text);
+        if (match)
+            return match[1];
+    }
+    return null;
+}
+/**
+ * Detect the target BASE_URL for the project.
+ *
+ * Precedence: an explicit `.env` value beats a literal in the Playwright
+ * config. Returns `[url, source]` where source is `".env"`,
+ * `"playwright.config"`, or `null` when nothing was found.
+ *
+ * Python: `detect_base_url`.
+ */
+export function detectBaseUrl(projectRoot = '.') {
+    const root = resolve(projectRoot);
+    const envUrl = parseDotenvBaseUrl(root);
+    if (envUrl)
+        return [envUrl, '.env'];
+    const cfgUrl = parseConfigBaseUrl(root);
+    if (cfgUrl)
+        return [cfgUrl, 'playwright.config'];
+    return [null, null];
+}
+// ---------------------------------------------------------------------------
+// Path 2 (issue path b): suite hints from playwright.config.*
+// ---------------------------------------------------------------------------
+/**
+ * Infer suite type and collect free-form hints from a Playwright config.
+ *
+ * Reads `testDir`, `testMatch`, and `projects[].name` and classifies the suite
+ * as `"component"`, `"api"`, or `"e2e"`. Playwright is end-to-end by default,
+ * so a config present but giving no stronger signal is classified `"e2e"`.
+ * Returns `[null, []]` when no Playwright config exists.
+ *
+ * Python: `parse_playwright_suite_hints`.
+ */
+export function parsePlaywrightSuiteHints(projectRoot = '.') {
+    const root = resolve(projectRoot);
+    let configText = null;
+    for (const name of PLAYWRIGHT_CONFIGS) {
+        const path = join(root, name);
+        if (existsSync(path)) {
+            try {
+                configText = readFileSync(path, 'utf-8');
+            }
+            catch {
+                configText = '';
+            }
+            break;
+        }
+    }
+    if (configText === null)
+        return [null, []];
+    const hints = [];
+    const testDirMatch = /testDir\s*:\s*['"]([^'"]+)['"]/.exec(configText);
+    if (testDirMatch)
+        hints.push(testDirMatch[1]);
+    const testMatch = /testMatch\s*:\s*['"]([^'"]+)['"]/.exec(configText);
+    if (testMatch)
+        hints.push(testMatch[1]);
+    const nameRe = /name\s*:\s*['"]([^'"]+)['"]/g;
+    for (let m = nameRe.exec(configText); m !== null; m = nameRe.exec(configText)) {
+        hints.push(m[1]);
+    }
+    const blob = hints.join(' ').toLowerCase();
+    let suiteType;
+    if (blob.includes('component') ||
+        blob.includes('.ct.') ||
+        blob.includes('/ct')) {
+        suiteType = 'component';
+    }
+    else if (blob.includes('api')) {
+        suiteType = 'api';
+    }
+    else {
+        // Config present but no stronger cue: Playwright defaults to e2e.
+        suiteType = 'e2e';
+    }
+    return [suiteType, hints];
+}
+// ---------------------------------------------------------------------------
+// Path 3 (issue path c): SDET-vs-manual user-level heuristic
+// ---------------------------------------------------------------------------
+/**
+ * Classify the driver as an SDET or a manual tester — transparently.
+ *
+ * An intentionally simple, auditable scoring heuristic: each fired signal adds
+ * one point to the SDET or manual tally and is returned so a consumer can see
+ * exactly why the verdict came out. Returns `[level, signals, confidence]`
+ * where `level` is `"sdet"` / `"manual"` / `"unknown"` (a tie or no signal),
+ * and `confidence` is `|sdet - manual| / (sdet + manual)` in `[0, 1]` (`0.0`
+ * when no signal fired).
+ *
+ * Python: `detect_user_level`.
+ */
+export function detectUserLevel(cwd, openFiles = null) {
+    const signals = [];
+    let sdet = 0;
+    let manual = 0;
+    const files = openFiles ?? [];
+    for (const f of files) {
+        const suffix = extname(f).toLowerCase();
+        if (CODE_SUFFIXES.has(suffix)) {
+            sdet += 1;
+            signals.push(`code/test file open: ${f}`);
+        }
+        else if (MANUAL_SUFFIXES.has(suffix)) {
+            manual += 1;
+            signals.push(`manual artefact open: ${f}`);
+        }
+    }
+    // Python: `cwd_path = Path(cwd)`. `Path("")` normalizes to `"."`, so an empty
+    // cwd scans the current directory and its `str()` is `"."` — reproduce that
+    // rather than treating `""` as a non-existent path.
+    const cwdPath = cwd === '' ? '.' : cwd;
+    const cwdLower = cwdPath.toLowerCase();
+    if (MANUAL_DIR_HINTS.some((hint) => cwdLower.includes(hint))) {
+        manual += 1;
+        signals.push('cwd path suggests manual testing');
+    }
+    if (existsSync(cwdPath)) {
+        for (const cfg of TEST_CONFIG_FILES) {
+            if (existsSync(join(cwdPath, cfg))) {
+                sdet += 1;
+                signals.push(`test-framework config present: ${cfg}`);
+                break;
+            }
+        }
+        for (const manifest of PROJECT_MANIFESTS) {
+            if (existsSync(join(cwdPath, manifest))) {
+                sdet += 1;
+                signals.push(`project manifest present: ${manifest}`);
+                break;
+            }
+        }
+    }
+    const total = sdet + manual;
+    if (total === 0)
+        return ['unknown', [], 0.0];
+    const confidence = Math.abs(sdet - manual) / total;
+    if (sdet > manual)
+        return ['sdet', signals, confidence];
+    if (manual > sdet)
+        return ['manual', signals, confidence];
+    return ['unknown', signals, confidence];
+}
+/**
+ * Run every implemented detection path and return the combined context.
+ *
+ * Python: `detect_environment`. `cwd` defaults to `project_root` when omitted;
+ * `open_files` is the caller-supplied list of open/edited paths (this module
+ * never guesses them).
+ */
+export function detectEnvironment(projectRoot = '.', options = {}) {
+    const { cwd = null, openFiles = null } = options;
+    const [baseUrl, baseUrlSource] = detectBaseUrl(projectRoot);
+    const [suiteType, suiteHints] = parsePlaywrightSuiteHints(projectRoot);
+    // Python: `cwd or project_root` — an empty-string cwd is falsy and collapses
+    // to project_root. `??` would wrongly keep `""`, so use `||`.
+    const [level, levelSignals, levelConf] = detectUserLevel(cwd || projectRoot, openFiles);
+    return new EnvironmentContext({
+        base_url: baseUrl,
+        base_url_source: baseUrlSource,
+        suite_type: suiteType,
+        suite_hints: suiteHints,
+        user_level: level,
+        user_level_signals: levelSignals,
+        user_level_confidence: levelConf,
+    });
+}
+//# sourceMappingURL=environment-detect.js.map

package/dist/engine/core/executor.js

@@ -0,0 +1,181 @@
+/**
+ * Canary Test Executor — a framework-agnostic execution engine.
+ *
+ * Faithful TypeScript port of `agent/core/executor.py`. Executes generated
+ * test files using the CLI command declared for each supported framework.
+ *
+ * Python→TS nuances:
+ *   - **subprocess → child_process**: Python's `subprocess.run(cmd, ...)` maps
+ *     to Node's `spawnSync(cmd[0], cmd.slice(1), ...)`. `cmd[0]` is the program
+ *     and the rest are argv, so the file path (already a single token after
+ *     `{file}` substitution) never gets re-split by the shell.
+ *   - **shlex.split**: reproduced by {@link shlexSplit} (POSIX mode). The
+ *     template is tokenized *first*, then `{file}` is substituted into each
+ *     token, so a path containing spaces stays exactly one argv element.
+ *   - **timeout**: Python's `subprocess.TimeoutExpired` maps to spawnSync's
+ *     `result.error.code === 'ETIMEDOUT'`; both yield exit code 124 with the
+ *     same byte-exact stderr message. `timeout` is seconds in the API and is
+ *     converted to milliseconds for spawnSync.
+ */
+import { spawnSync } from 'node:child_process';
+import { constants as osConstants } from 'node:os';
+import { isCi } from './ci-env.js';
+import { FrameworkRegistry } from './framework-registry.js';
+/**
+ * POSIX `shlex.split` equivalent: whitespace-separated tokens with `'…'`
+ * (fully literal), `"…"` (literal, but `\"`/`\\` escapes honored), and
+ * backslash escaping of the next char outside quotes. Sufficient for the
+ * framework execution-command templates, which are simple whitespace-separated
+ * strings.
+ *
+ * Python: `shlex.split`.
+ */
+export function shlexSplit(input) {
+    const tokens = [];
+    let cur = '';
+    let hasToken = false;
+    let i = 0;
+    const n = input.length;
+    // Python's `shlex.whitespace` is exactly these four characters — form-feed
+    // (\f) and vertical-tab (\v) are NOT separators, so keep them inside tokens.
+    const isWs = (c) => c === ' ' || c === '\t' || c === '\n' || c === '\r';
+    while (i < n) {
+        const c = input[i];
+        if (isWs(c)) {
+            if (hasToken) {
+                tokens.push(cur);
+                cur = '';
+                hasToken = false;
+            }
+            i++;
+        }
+        else if (c === '\\') {
+            hasToken = true;
+            if (i + 1 < n) {
+                cur += input[i + 1];
+                i += 2;
+            }
+            else {
+                // Python `shlex.split` raises `ValueError: No escaped character` on a
+                // trailing backslash; this call sits outside `execute`'s try, so the
+                // error propagates to the caller. Mirror that rather than silently
+                // dropping the character.
+                throw new Error('No escaped character');
+            }
+        }
+        else if (c === "'") {
+            hasToken = true;
+            i++;
+            while (i < n && input[i] !== "'") {
+                cur += input[i];
+                i++;
+            }
+            i++; // consume the closing quote
+        }
+        else if (c === '"') {
+            hasToken = true;
+            i++;
+            while (i < n && input[i] !== '"') {
+                if (input[i] === '\\' &&
+                    i + 1 < n &&
+                    (input[i + 1] === '"' || input[i + 1] === '\\')) {
+                    cur += input[i + 1];
+                    i += 2;
+                }
+                else {
+                    cur += input[i];
+                    i++;
+                }
+            }
+            i++; // consume the closing quote
+        }
+        else {
+            hasToken = true;
+            cur += c;
+            i++;
+        }
+    }
+    if (hasToken)
+        tokens.push(cur);
+    return tokens;
+}
+/** Render a caught value the way Python's `str(e)` renders an exception. */
+function errStr(err) {
+    if (err instanceof Error)
+        return err.message;
+    return String(err);
+}
+/**
+ * Handles execution of generated tests in a managed subprocess.
+ *
+ * Python: `CanaryTestExecutor`. Coordinates with the {@link FrameworkRegistry}
+ * to determine the correct execution command for a framework and safely
+ * executes the test file.
+ */
+export class CanaryTestExecutor {
+    registry;
+    constructor(registry = new FrameworkRegistry()) {
+        this.registry = registry;
+    }
+    /**
+     * Execute a test file using the specified framework.
+     *
+     * Python: `CanaryTestExecutor.execute`.
+     *
+     * @param filePath Path to the test file.
+     * @param frameworkName Name of the framework (e.g. 'playwright').
+     * @param timeout Maximum execution time in seconds. Defaults to 30.
+     * @returns `[exit_code, stdout, stderr]`.
+     */
+    execute(filePath, frameworkName, timeout = 30) {
+        const framework = this.registry.findByName(frameworkName);
+        if (framework === null) {
+            throw new Error(`Framework '${frameworkName}' not found in registry.`);
+        }
+        const cmdTemplate = framework.execution_command;
+        if (!cmdTemplate) {
+            throw new Error(`No execution command defined for framework '${frameworkName}'.`);
+        }
+        // Split the template first so the file path stays a single argv element
+        // even when it contains spaces or shell metacharacters.
+        const cmd = shlexSplit(cmdTemplate).map((tok) => tok.split('{file}').join(String(filePath)));
+        if (isCi()) {
+            cmd.push(...(framework.ci_flags ?? []));
+        }
+        try {
+            const result = spawnSync(cmd[0], cmd.slice(1), {
+                encoding: 'utf-8',
+                timeout: timeout * 1000,
+                // Python's subprocess.run has no output ceiling; Node defaults
+                // maxBuffer to 1 MiB and, on overflow, kills the child (SIGTERM) and
+                // surfaces ENOBUFS with status=null. Test runners (Playwright, Cypress,
+                // verbose reporters) routinely exceed 1 MiB, which would flip a passing
+                // run into a spurious failure with empty stdout. Remove the cap.
+                maxBuffer: Infinity,
+            });
+            if (result.error) {
+                const err = result.error;
+                // spawnSync surfaces a timeout as ETIMEDOUT rather than raising, the
+                // analog of Python's subprocess.TimeoutExpired.
+                if (err.code === 'ETIMEDOUT') {
+                    return [
+                        124,
+                        result.stdout ?? '',
+                        `Execution timed out after ${timeout} seconds.`,
+                    ];
+                }
+                return [1, '', errStr(err)];
+            }
+            // A signal death (SIGKILL/SIGSEGV, e.g. OOM) yields status=null; Python's
+            // subprocess reports the negative signal number as the return code, so a
+            // caller inspecting the exact code can still distinguish an OOM-kill.
+            const exitCode = result.status ??
+                (result.signal ? -(osConstants.signals[result.signal] ?? 1) : 1);
+            return [exitCode, result.stdout ?? '', result.stderr ?? ''];
+        }
+        catch (e) {
+            return [1, '', errStr(e)];
+        }
+    }
+}
+//# sourceMappingURL=executor.js.map

package/dist/engine/core/feedback.js

@@ -0,0 +1,93 @@
+/**
+ * In-CLI feedback / issue reporting (#345).
+ *
+ * Faithful TypeScript port of `agent/core/feedback.py`. `canary feedback` lowers
+ * the discoverability barrier that makes feedback evaporate at submission time:
+ * instead of hunting for where the tracker lives, a user runs one command and
+ * gets a **pre-filled GitHub issue** with non-sensitive context already
+ * attached. This module is the pure, testable core — it builds the payload and
+ * URL; the CLI command handles I/O, confirmation, and opening a browser.
+ *
+ * Privacy: context is limited to version / OS / runtime / install method. It
+ * never reads environment variables or file contents.
+ *
+ * Python→TS nuances:
+ *   - **Context shape is a contract**: the four keys `{version, os, python,
+ *     install}` (and their order) are preserved. The `python` value is the JS
+ *     *runtime* version (`process.version`) — the Node analog of Python's
+ *     `platform.python_version()`; the field name is kept for shape fidelity.
+ *   - `urlencode(...)` (which uses `quote_plus`, space -> `+`) maps to
+ *     `URLSearchParams`, which also form-encodes with space -> `+` and preserves
+ *     insertion order. Exotic-character percent-encoding can differ byte-for-byte
+ *     from CPython's `quote_plus`, but the value round-trips identically on
+ *     decode (GitHub decodes it), and no test pins the raw query bytes.
+ */
+import { release, type } from 'node:os';
+/** The public issue tracker (from npm/package.json `repository`). */
+export const TRACKER_URL = 'https://github.com/bop-clocktower/canary';
+export const VALID_CATEGORIES = ['bug', 'ux', 'docs', 'idea'];
+function canaryVersion() {
+    // Python reads `importlib.metadata.version("canary-test-ai")`, falling back to
+    // "unknown". The TS pilot has no equivalent package-metadata lookup wired in,
+    // so we return the same best-effort "unknown" sentinel.
+    return 'unknown';
+}
+/** Best-effort install-method label — never fails, never inspects secrets. */
+function installMethod() {
+    const exe = (process.execPath || '').toLowerCase();
+    if (exe.includes('pipx')) {
+        return 'pipx';
+    }
+    return 'pip/npm';
+}
+/**
+ * Non-sensitive diagnostic context to attach to a report.
+ *
+ * Deliberately excludes environment variables and file contents — only the
+ * coarse runtime facts a maintainer needs to triage a CLI report.
+ */
+export function collectContext() {
+    return {
+        version: canaryVersion(),
+        os: `${type()} ${release()}`.trim(),
+        python: process.version,
+        install: installMethod(),
+    };
+}
+/**
+ * A pre-filled GitHub 'new issue' URL: category in the title, message + context
+ * in the body, category as a label. All parts are URL-encoded.
+ */
+export function buildIssueUrl(category, message, context) {
+    // Python `message[:60]` slices by code point; JS `slice` slices by UTF-16
+    // unit, so an astral char would truncate the title early. Match the oracle.
+    const title = `[${category}] ${Array.from(message).slice(0, 60).join('')}`.trim();
+    const bodyLines = [
+        message,
+        '',
+        '---',
+        '_Submitted via `canary feedback`._',
+        '',
+        '**Environment**',
+    ];
+    for (const [k, v] of Object.entries(context)) {
+        bodyLines.push(`- ${k}: ${v}`);
+    }
+    const query = new URLSearchParams({
+        title,
+        body: bodyLines.join('\n'),
+        labels: category,
+    });
+    return `${TRACKER_URL}/issues/new?${query.toString()}`;
+}
+/** Bundle a report: message, category, context, and the pre-filled URL. */
+export function buildFeedback(message, category) {
+    const context = collectContext();
+    return {
+        message,
+        category,
+        context,
+        issue_url: buildIssueUrl(category, message, context),
+    };
+}
+//# sourceMappingURL=feedback.js.map