canary-test-cli 5.15.0 → 6.0.0

package/dist/engine/core/fixture-scanner.js

@@ -0,0 +1,173 @@
+/**
+ * Project test-fixture / helper symbol scanner — faithful TS port of
+ * `agent/core/fixture_scanner.py`.
+ *
+ * Extracts named exports from files under conventional fixture/helper dirs so
+ * downstream generation imports real identifiers. Regex-based, no AST.
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { relative, resolve } from 'node:path';
+const FIXTURE_DIRS = [
+    'tests/fixtures',
+    'tests/test-utils',
+    'tests/helpers',
+    'tests/support',
+    'test/fixtures',
+    'test/test-utils',
+    'test/helpers',
+    'e2e/fixtures',
+    'e2e/helpers',
+    '__tests__/fixtures',
+    '__tests__/helpers',
+    'fixtures',
+    'test-utils',
+];
+const IGNORED_DIRS = new Set([
+    'node_modules',
+    '.git',
+    '__pycache__',
+    '.venv',
+    'venv',
+    'dist',
+    'build',
+    '.next',
+    '.nuxt',
+    'coverage',
+]);
+const SUPPORTED_EXTS = ['.ts', '.tsx', '.js', '.jsx', '.py'];
+const MAX_FILES = 20;
+const MAX_FILE_BYTES = 32_768;
+const MAX_SYMBOLS_PER_FILE = 12;
+const TS_DECL_RE = /^\s*export\s+(?:default\s+)?(?:async\s+)?(?:const|let|var|function|class|interface|type|enum)\s+([A-Za-z_$][\w$]*)/gm;
+const TS_NAMED_RE = /^\s*export\s*\{([^}]+)\}/gm;
+const PY_DECL_RE = /^(?:def|class)\s+([A-Za-z][\w]*)/gm;
+export function isEmpty(s) {
+    return Object.keys(s.byModule).length === 0;
+}
+export class FixtureScanner {
+    scan(projectRoot = '.') {
+        const root = resolve(projectRoot);
+        const result = { byModule: {}, filesScanned: 0 };
+        if (!existsSync(root))
+            return result;
+        const candidates = this.collectCandidates(root);
+        for (const path of candidates) {
+            let text = safeRead(path);
+            if (text === null)
+                continue;
+            if (text.length > MAX_FILE_BYTES)
+                text = text.slice(0, MAX_FILE_BYTES);
+            const symbols = path.endsWith('.py')
+                ? extractPython(text)
+                : extractTs(text);
+            if (symbols.length === 0)
+                continue;
+            const relPath = relative(root, path).split(/[/\\]/).join('/');
+            result.byModule[relPath] = symbols.slice(0, MAX_SYMBOLS_PER_FILE);
+            result.filesScanned += 1;
+        }
+        return result;
+    }
+    collectCandidates(root) {
+        const candidates = [];
+        const seen = new Set();
+        for (const rel of FIXTURE_DIRS) {
+            const fixtureDir = resolve(root, rel);
+            if (!isDir(fixtureDir) || seen.has(fixtureDir))
+                continue;
+            seen.add(fixtureDir);
+            for (const path of rglobFilesSorted(fixtureDir)) {
+                if (path.split(/[/\\]/).some((part) => IGNORED_DIRS.has(part)))
+                    continue;
+                if (!SUPPORTED_EXTS.some((e) => path.endsWith(e)))
+                    continue;
+                candidates.push(path);
+                if (candidates.length >= MAX_FILES)
+                    return candidates;
+            }
+            if (candidates.length >= MAX_FILES)
+                break;
+        }
+        return candidates;
+    }
+}
+/** Recursive file list, sorted — mirrors Python's `sorted(dir.rglob("*"))`. */
+function rglobFilesSorted(dir) {
+    const files = [];
+    const walk = (d) => {
+        let entries;
+        try {
+            entries = readdirSync(d, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = resolve(d, entry.name);
+            if (entry.isDirectory())
+                walk(full);
+            else if (entry.isFile())
+                files.push(full);
+        }
+    };
+    walk(dir);
+    return files.sort(cmp);
+}
+function extractTs(text) {
+    const seen = new Set();
+    const out = [];
+    const add = (nameRaw) => {
+        const name = nameRaw.trim();
+        if (!name || seen.has(name))
+            return;
+        seen.add(name);
+        out.push(name);
+    };
+    for (const m of text.matchAll(TS_DECL_RE))
+        add(m[1]);
+    for (const m of text.matchAll(TS_NAMED_RE)) {
+        for (const pieceRaw of m[1].split(',')) {
+            const piece = pieceRaw.trim();
+            if (!piece)
+                continue;
+            const asIdx = piece.indexOf(' as ');
+            if (asIdx !== -1)
+                add(piece.slice(asIdx + 4));
+            else
+                add(piece);
+        }
+    }
+    return out;
+}
+function extractPython(text) {
+    const seen = new Set();
+    const out = [];
+    for (const m of text.matchAll(PY_DECL_RE)) {
+        const name = m[1];
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        out.push(name);
+    }
+    return out;
+}
+function isDir(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function cmp(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+function safeRead(path) {
+    try {
+        return readFileSync(path, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=fixture-scanner.js.map

package/dist/engine/core/framework-registry.js

@@ -0,0 +1,123 @@
+/**
+ * Framework Registry — queries the collection of supported testing frameworks.
+ *
+ * Faithful TypeScript port of `agent/core/framework_registry.py`. Reads the same
+ * `agent/frameworks/registry.json` the Python engine uses. The default path is
+ * resolved relative to this file (../../.. → repo root, then agent/frameworks).
+ */
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { def } from '../util/coalesce.js';
+import { scaffoldableFrameworks } from './scaffolder.js';
+/** Default registry path: <repo>/agent/frameworks/registry.json. */
+export function defaultRegistryPath() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    // here = ts/src/core → repo root is three levels up.
+    return resolve(here, '..', '..', '..', 'agent', 'frameworks', 'registry.json');
+}
+export class FrameworkRegistry {
+    frameworks;
+    constructor(registryPath = defaultRegistryPath()) {
+        const raw = JSON.parse(readFileSync(registryPath, 'utf-8'));
+        this.frameworks = def(raw.frameworks, []);
+    }
+    getAllFrameworks() {
+        return this.frameworks;
+    }
+    getByCategory(category) {
+        return this.frameworks.filter((f) => f.category === category || def(f.categories, []).includes(category));
+    }
+    getPreferredByCategory(category) {
+        const frameworks = this.getByCategory(category);
+        const preferred = frameworks.find((f) => f.status === 'preferred');
+        if (preferred)
+            return preferred;
+        return frameworks[0] ?? null;
+    }
+    findByName(name) {
+        return this.frameworks.find((f) => f.name === name) ?? null;
+    }
+    executionInfo(name) {
+        const f = this.findByName(name);
+        if (f === null)
+            return null;
+        return {
+            execution_command: def(f.execution_command, null),
+            ci_flags: def(f.ci_flags, []),
+        };
+    }
+    /**
+     * Whether canary can actually run a framework's command (Python:
+     * `_is_runnable`). The executor substitutes **only** `{file}`, so a command is
+     * runnable iff it carries `{file}` (the test path is injected) or has no
+     * placeholder at all (a whole-suite runner). A command with a *different*
+     * placeholder (e.g. `{target}`) would reach the shell unsubstituted, so it is
+     * NOT counted as executable, however plausible the string looks.
+     *
+     * `if (!cmd)` reproduces Python's `if not cmd` - `null`/`undefined`/`""` all
+     * count as not-runnable.
+     */
+    static isRunnable(cmd) {
+        if (!cmd)
+            return false;
+        return cmd.includes('{file}') || !cmd.includes('{');
+    }
+    /**
+     * Honest, code-DERIVED support level for a framework - never the registry's
+     * subjective `status`/`maturity` prose (Python: `capabilities`).
+     *
+     * - `scaffold`: a Scaffolder template exists (canary can bootstrap it).
+     * - `execute`: the registry carries a command the executor can *run* (see
+     *   {@link isRunnable} - not merely a non-empty string).
+     *
+     * The headline `tier` derives from these two signals: `full` (scaffold +
+     * execute), `executable` (execute only), or `catalog` (neither). Returns
+     * `null` for an unknown framework. Case-insensitive, matching
+     * `Scaffolder.scaffold`.
+     */
+    capabilities(name) {
+        if (!name)
+            return null;
+        const lowered = name.toLowerCase();
+        const f = this.findByName(lowered);
+        if (f === null)
+            return null;
+        const canScaffold = scaffoldableFrameworks().has(lowered);
+        const canExecute = FrameworkRegistry.isRunnable(f.execution_command);
+        let tier;
+        if (canScaffold && canExecute) {
+            tier = 'full';
+        }
+        else if (canExecute) {
+            tier = 'executable';
+        }
+        else {
+            tier = 'catalog';
+        }
+        return { scaffold: canScaffold, execute: canExecute, tier };
+    }
+    summaries() {
+        return this.frameworks.map((f) => {
+            // Python: `self.capabilities(f.get("name"))` - capabilities() lowercases.
+            const caps = this.capabilities(f.name);
+            return {
+                name: f.name,
+                category: def(f.category, null),
+                categories: def(f.categories, []),
+                languages: def(f.languages, []),
+                file_extensions: def(f.file_extensions, []),
+                execution_command: def(f.execution_command, null),
+                ci_flags: def(f.ci_flags, []),
+                status: def(f.status, null),
+                capabilities: caps,
+                // Python: `(caps or {}).get("tier")` - null when caps is null.
+                tier: caps === null ? null : caps.tier,
+            };
+        });
+    }
+    matchByLanguage(language) {
+        return this.frameworks.filter((f) => def(f.languages, []).includes(language));
+    }
+}
+//# sourceMappingURL=framework-registry.js.map

package/dist/engine/core/mcp-validator.js

@@ -0,0 +1,218 @@
+/**
+ * MCP server identifier validation for company knowledge.
+ *
+ * Faithful TypeScript port of `agent/core/mcp_validator.py`. Resolves which MCP
+ * server identifiers are registered in the current Claude Code session by
+ * scanning:
+ *
+ *   1. `<root>/.mcp.json` and `~/.mcp.json`  — plain server keys (e.g. "harness")
+ *   2. Installed Claude Code plugins          — plugin-prefixed keys
+ *      Format: `plugin_{plugin_slug}_{server_key}`
+ *      e.g. atlassian plugin, "atlassian" server → "plugin_atlassian_atlassian"
+ *
+ * No network calls are made; this is a local config scan only.
+ *
+ * Python→TS nuances:
+ *   - **Home injection**: Python's tests `patch("...Path.home")`. The idiomatic
+ *     TS seam is an optional `home` parameter (defaulting to `os.homedir()`),
+ *     threaded down exactly where Python calls `Path.home()`. Production
+ *     behavior is unchanged when omitted; this mirrors the sibling
+ *     `overlays.ts`, which already takes a `home` parameter.
+ *   - A non-object top-level `.mcp.json`/`settings.json` (e.g. a JSON array)
+ *     would make Python's `data.get(...)` raise an *uncaught* `AttributeError`;
+ *     we degrade to "no servers" instead (safer, and never observable via a
+ *     well-formed config).
+ */
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { readJsonWithWarning } from './config-validation.js';
+/** Result of validating one MCP server id (Python `MCPValidationResult`). */
+export class MCPValidationResult {
+    server_id;
+    status; // "registered" | "not_found" | "plugin_disabled"
+    source; // where it was found (for display)
+    note;
+    constructor(serverId, status, source = '', note = '') {
+        this.server_id = serverId;
+        this.status = status;
+        this.source = source;
+        this.note = note;
+    }
+}
+/**
+ * Check each `serverId` against locally registered MCP sources.
+ *
+ * Returns one {@link MCPValidationResult} per id, in input order.
+ */
+export function validateMcpServers(serverIds, root, home) {
+    const registry = buildRegistry(root ?? process.cwd(), home ?? homedir());
+    const results = [];
+    for (const sid of serverIds) {
+        const entry = registry.get(sid);
+        if (entry !== undefined) {
+            const [source, note, status] = entry;
+            results.push(new MCPValidationResult(sid, status, source, note));
+        }
+        else {
+            results.push(new MCPValidationResult(sid, 'not_found'));
+        }
+    }
+    return results;
+}
+/**
+ * Fail-loud (but non-blocking) config-validation pass for `.mcp.json`.
+ *
+ * `validateMcpServers` silently treats a malformed `.mcp.json` the same as an
+ * absent one (each server resolves to "not_found"). This is a separate, explicit
+ * pass a caller can run alongside it to surface the distinction: an
+ * existing-but-unparseable `.mcp.json` (project or home) returns a warning
+ * naming the file and the parse error. A genuinely absent `.mcp.json` is not a
+ * warning. Never raises.
+ */
+export function collectConfigWarnings(root, home) {
+    const r = root ?? process.cwd();
+    const h = home ?? homedir();
+    const warnings = [];
+    for (const path of [join(r, '.mcp.json'), join(h, '.mcp.json')]) {
+        const [, warning] = readJsonWithWarning(path);
+        if (warning)
+            warnings.push(warning);
+    }
+    return warnings;
+}
+// ── registry builder ──────────────────────────────────────────────────────
+/**
+ * Return a `Map` of `server_id -> [source_label, note, status]` for all locally
+ * known MCP servers (Python `_build_registry`).
+ */
+export function buildRegistry(root, home = homedir()) {
+    const registry = new Map();
+    // 1. Project-local .mcp.json
+    ingestMcpJson(join(root, '.mcp.json'), 'project .mcp.json', registry);
+    // 2. Home-dir .mcp.json
+    ingestMcpJson(join(home, '.mcp.json'), '~/.mcp.json', registry);
+    // 3. Installed Claude Code plugins
+    ingestPlugins(registry, home);
+    return registry;
+}
+function ingestMcpJson(path, label, registry) {
+    if (!existsSync(path))
+        return;
+    let data;
+    try {
+        data = JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return;
+    }
+    // INTENTIONAL DIVERGENCE from the oracle: on a valid-JSON-but-non-object top
+    // level (e.g. a bare array `[]`), Python calls `data.get("mcpServers", {})`
+    // on a list → uncaught AttributeError, crashing the caller. We degrade to
+    // "no servers" instead — safer, never reachable via a well-formed config, and
+    // consistent with the accepted-divergence notes in config-validation.ts /
+    // coverage.ts. Pinned by a regression test.
+    const servers = isRecord(data) ? data['mcpServers'] : undefined;
+    if (!isRecord(servers))
+        return;
+    for (const key of Object.keys(servers)) {
+        if (!registry.has(key))
+            registry.set(key, [label, '', 'registered']);
+    }
+}
+/**
+ * Scan installed Claude Code plugins and derive their MCP server identifiers.
+ */
+function ingestPlugins(registry, home) {
+    const pluginsCache = join(home, '.claude', 'plugins', 'cache');
+    if (!isDir(pluginsCache))
+        return;
+    const enabled = loadEnabledPlugins(home);
+    for (const marketplaceSlug of listDirs(pluginsCache)) {
+        const marketplacePath = join(pluginsCache, marketplaceSlug);
+        for (const pluginSlug of listDirs(marketplacePath)) {
+            const pluginPath = join(marketplacePath, pluginSlug);
+            const pluginKey = `${pluginSlug}@${marketplaceSlug}`;
+            const isEnabled = enabled[pluginKey] ?? false;
+            // Each plugin may have multiple version dirs; use the most recent.
+            const versionDirs = listDirs(pluginPath)
+                .map((name) => ({
+                name,
+                mtime: statSync(join(pluginPath, name)).mtimeMs,
+            }))
+                .sort((a, b) => b.mtime - a.mtime);
+            for (const vd of versionDirs) {
+                const mcpJson = join(pluginPath, vd.name, '.mcp.json');
+                if (!existsSync(mcpJson))
+                    continue;
+                let data;
+                try {
+                    data = JSON.parse(readFileSync(mcpJson, 'utf-8'));
+                }
+                catch {
+                    continue;
+                }
+                const servers = isRecord(data) ? data['mcpServers'] : undefined;
+                if (isRecord(servers)) {
+                    for (const serverKey of Object.keys(servers)) {
+                        // Claude Code tool namespace: plugin_{plugin_slug}_{server_key}
+                        const derivedId = `plugin_${pluginSlug}_${serverKey}`;
+                        if (registry.has(derivedId))
+                            continue;
+                        const status = isEnabled ? 'registered' : 'plugin_disabled';
+                        const note = isEnabled
+                            ? ''
+                            : `plugin ${pyRepr(pluginKey)} is installed but not enabled`;
+                        const source = `plugin ${pyRepr(pluginKey)}`;
+                        registry.set(derivedId, [source, note, status]);
+                    }
+                }
+                break; // only inspect the most recent version dir that has .mcp.json
+            }
+        }
+    }
+}
+/** Load `enabledPlugins` from `~/.claude/settings.json`. */
+function loadEnabledPlugins(home) {
+    const settingsPath = join(home, '.claude', 'settings.json');
+    try {
+        const data = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+        if (isRecord(data)) {
+            const enabled = data['enabledPlugins'];
+            if (isRecord(enabled))
+                return enabled;
+        }
+    }
+    catch {
+        // OSError / JSON parse error → empty map.
+    }
+    return {};
+}
+// ── small helpers ─────────────────────────────────────────────────────────
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isDir(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Sorted directory names under `path` that are themselves directories. */
+function listDirs(path) {
+    try {
+        return readdirSync(path, { withFileTypes: true })
+            .filter((e) => e.isDirectory())
+            .map((e) => e.name);
+    }
+    catch {
+        return [];
+    }
+}
+/** Python `repr()` of a simple string: single-quote wrapped. */
+function pyRepr(s) {
+    return `'${s}'`;
+}
+//# sourceMappingURL=mcp-validator.js.map

package/dist/engine/core/metadata-scanner.js

@@ -0,0 +1,147 @@
+/**
+ * Project metadata scanner — faithful TS port of
+ * `agent/core/metadata_scanner.py`.
+ *
+ * Scans a project root for package.json / requirements.txt / pyproject.toml /
+ * tsconfig.json and surfaces dependency versions. Pure filesystem reads; no
+ * network, no execution.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+export function isEmpty(m) {
+    return (Object.keys(m.jsDependencies).length === 0 &&
+        Object.keys(m.pythonPackages).length === 0 &&
+        Object.keys(m.tsconfig).length === 0);
+}
+/** Infer project languages from detected metadata (matches Python's set). */
+export function detectedLanguages(m) {
+    const langs = new Set();
+    if (Object.keys(m.jsDependencies).length > 0) {
+        langs.add('typescript');
+        langs.add('javascript');
+    }
+    if (Object.keys(m.tsconfig).length > 0)
+        langs.add('typescript');
+    if (Object.keys(m.pythonPackages).length > 0)
+        langs.add('python');
+    return langs;
+}
+const _VERSION_SEPARATORS = ['==', '>=', '<=', '~=', '!=', '>', '<'];
+export class MetadataScanner {
+    scan(projectRoot = '.') {
+        const root = resolve(projectRoot);
+        const metadata = {
+            jsDependencies: {},
+            pythonPackages: {},
+            tsconfig: {},
+        };
+        this.readPackageJson(root, metadata);
+        this.readRequirementsTxt(root, metadata);
+        if (Object.keys(metadata.pythonPackages).length === 0) {
+            this.readPyprojectToml(root, metadata);
+        }
+        this.readTsconfig(root, metadata);
+        return metadata;
+    }
+    readPackageJson(root, metadata) {
+        const pkg = readJson(resolve(root, 'package.json'));
+        if (!pkg)
+            return;
+        const deps = {};
+        const rawDeps = pkg['dependencies'];
+        const rawDev = pkg['devDependencies'];
+        if (isPlainObject(rawDeps))
+            Object.assign(deps, rawDeps);
+        if (isPlainObject(rawDev))
+            Object.assign(deps, rawDev);
+        metadata.jsDependencies = deps;
+    }
+    readRequirementsTxt(root, metadata) {
+        const text = readText(resolve(root, 'requirements.txt'));
+        if (text === null)
+            return;
+        metadata.pythonPackages = parseRequirements(text);
+    }
+    readPyprojectToml(root, metadata) {
+        const text = readText(resolve(root, 'pyproject.toml'));
+        if (text === null)
+            return;
+        metadata.pythonPackages = parsePyprojectDeps(text);
+    }
+    readTsconfig(root, metadata) {
+        const cfg = readJson(resolve(root, 'tsconfig.json'));
+        if (!cfg)
+            return;
+        const opts = cfg['compilerOptions'];
+        metadata.tsconfig = isPlainObject(opts) ? opts : {};
+    }
+}
+function splitDependency(spec) {
+    for (const sep of _VERSION_SEPARATORS) {
+        const idx = spec.indexOf(sep);
+        if (idx !== -1) {
+            const name = spec.slice(0, idx);
+            const version = spec.slice(idx + sep.length);
+            return [name.trim(), sep + version.trim()];
+        }
+    }
+    return null;
+}
+export function parseRequirements(text) {
+    const packages = {};
+    for (const raw of text.split('\n')) {
+        const line = raw.trim();
+        if (!line || line.startsWith('#') || line.startsWith('-'))
+            continue;
+        const split = splitDependency(line);
+        if (split)
+            packages[split[0]] = split[1];
+        else
+            packages[line] = '';
+    }
+    return packages;
+}
+export function parsePyprojectDeps(text) {
+    const section = text.match(/^\[project\]$([\s\S]*?)(?=^\[|$(?![\s\S]))/m);
+    if (!section)
+        return {};
+    const deps = section[1].match(/^dependencies\s*=\s*\[([\s\S]*?)\]/m);
+    if (!deps)
+        return {};
+    const packages = {};
+    for (const m of deps[1].matchAll(/"([^"]+)"/g)) {
+        const depStr = m[1];
+        const split = splitDependency(depStr);
+        if (split)
+            packages[split[0]] = split[1];
+        else if (depStr.trim())
+            packages[depStr.trim()] = '';
+    }
+    return packages;
+}
+function readText(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        return readFileSync(path, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+function readJson(path) {
+    const text = readText(path);
+    if (text === null)
+        return null;
+    try {
+        const parsed = JSON.parse(text);
+        return isPlainObject(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isPlainObject(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+//# sourceMappingURL=metadata-scanner.js.map