@houwert/conductor 0.28.0 → 0.29.1

package/dist/commands/cases.js

@@ -1,260 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HELP = void 0;
-exports.storeDir = storeDir;
-exports.loadCases = loadCases;
-exports.casesList = casesList;
-exports.parseJunit = parseJunit;
-exports.casesReport = casesReport;
-exports.casesResult = casesResult;
-exports.HELP = `  cases list                          List the repo's test cases and their coverage
-  cases report --junit <file>         File a JUnit report as test-case results
-  cases result <id> --verdict <v>     Record one case result (passed/failed/blocked/skipped)`;
-const promises_1 = require("node:fs/promises");
-const node_fs_1 = require("node:fs");
-const node_os_1 = require("node:os");
-const node_path_1 = __importDefault(require("node:path"));
-const output_js_1 = require("../output.js");
-/**
- * Test cases from the CLI, so CI can file results without Studio running.
- *
- * Cases and their results live under `~/.conductor/studio/cases/<project>/`,
- * outside the repo under test — testing a project never adds files to it. The
- * project is identified by its path, the same way Studio scopes its own store,
- * so both see the same cases for the same checkout.
- */
-const RESULTS = 'results.jsonl';
-/** Legacy in-repo location, still read so an older checkout keeps working. */
-const IN_REPO_CASES = 'test-cases';
-function studioRoot() {
-    // __CONDUCTOR_STUDIO_DIR keeps tests (and CI sandboxes) out of the real home.
-    return process.env.__CONDUCTOR_STUDIO_DIR ?? node_path_1.default.join((0, node_os_1.homedir)(), '.conductor', 'studio');
-}
-function slug(text) {
-    return (text
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-|-$/g, '')
-        .slice(0, 48) || 'project');
-}
-function hash(text) {
-    let h = 0;
-    for (let i = 0; i < text.length; i++)
-        h = (h * 31 + text.charCodeAt(i)) | 0;
-    return Math.abs(h).toString(36);
-}
-/** `<basename>-<hash of path>`, matching Studio's own project scoping. */
-function storeDir(root) {
-    const resolved = node_path_1.default.resolve(root);
-    return node_path_1.default.join(studioRoot(), 'cases', `${slug(node_path_1.default.basename(resolved))}-${hash(resolved)}`);
-}
-/** Where cases are read from: the store, falling back to a legacy in-repo dir. */
-function casesDir(root) {
-    const store = storeDir(root);
-    if ((0, node_fs_1.existsSync)(store))
-        return store;
-    const legacy = node_path_1.default.join(root, IN_REPO_CASES);
-    return (0, node_fs_1.existsSync)(legacy) ? legacy : store;
-}
-/** Minimal YAML reader for the case fields we need — no dependency for one shape. */
-function readCase(text) {
-    const lines = text.split(/\r?\n/);
-    const scalar = (key) => {
-        const hit = lines.find((l) => l.startsWith(`${key}:`));
-        return hit
-            ?.slice(key.length + 1)
-            .trim()
-            .replace(/^['"]|['"]$/g, '');
-    };
-    const id = scalar('id');
-    const title = scalar('title');
-    if (!id || !title)
-        return null;
-    // `flows:` is a nested block: read indented `column: path` until the indent ends.
-    const flows = {};
-    const start = lines.findIndex((l) => /^flows:\s*$/.test(l));
-    if (start >= 0) {
-        for (const line of lines.slice(start + 1)) {
-            if (!line.trim())
-                continue;
-            if (!/^\s/.test(line))
-                break;
-            const entry = /^\s+([\w-]+):\s*(.+)$/.exec(line);
-            if (entry)
-                flows[entry[1]] = entry[2].trim().replace(/^['"]|['"]$/g, '');
-        }
-    }
-    return {
-        id,
-        title,
-        flow: scalar('flow'),
-        flows: Object.keys(flows).length ? flows : undefined,
-    };
-}
-async function loadCases(root) {
-    const dir = casesDir(root);
-    if (!(0, node_fs_1.existsSync)(dir))
-        return [];
-    const cases = [];
-    for (const file of (await (0, promises_1.readdir)(dir)).filter((f) => /\.ya?ml$/i.test(f))) {
-        const parsed = readCase(await (0, promises_1.readFile)(node_path_1.default.join(dir, file), 'utf8'));
-        if (parsed)
-            cases.push(parsed);
-    }
-    return cases.sort((a, b) => a.id.localeCompare(b.id));
-}
-function flowsOf(c) {
-    const entries = Object.entries(c.flows ?? {}).map(([column, flow]) => ({ column, flow }));
-    if (c.flow)
-        entries.push({ flow: c.flow });
-    return entries;
-}
-let seq = 0;
-async function append(root, results) {
-    const file = node_path_1.default.join(storeDir(root), RESULTS);
-    await (0, promises_1.mkdir)(node_path_1.default.dirname(file), { recursive: true });
-    await (0, promises_1.appendFile)(file, results.map((r) => JSON.stringify(r)).join('\n') + '\n', 'utf8');
-}
-function result(fields) {
-    seq += 1;
-    return { id: `res-${Date.now()}-${seq}`, at: Date.now(), ...fields };
-}
-async function casesList(root, opts = {}) {
-    const cases = await loadCases(root);
-    if (!cases.length) {
-        (0, output_js_1.printError)(`No test cases found under ${casesDir(root)}.`, opts);
-        return 1;
-    }
-    if (opts.json) {
-        (0, output_js_1.printData)({
-            status: 'ok',
-            total: cases.length,
-            automated: cases.filter((c) => flowsOf(c).length).length,
-            cases: cases.map((c) => ({ id: c.id, title: c.title, flows: flowsOf(c) })),
-        }, opts);
-    }
-    else {
-        console.log(`${cases.length} cases, ${cases.filter((c) => flowsOf(c).length).length} with a flow`);
-        for (const c of cases) {
-            console.log(`  ${c.id.padEnd(10)} ${c.title}${flowsOf(c).length ? '' : '   (no flow)'}`);
-        }
-    }
-    return 0;
-}
-/** `<testcase name="…" classname="…">` plus its failure/skipped child, if any. */
-function parseJunit(xml) {
-    const out = [];
-    const re = /<testcase\b([^>]*?)(\/>|>([\s\S]*?)<\/testcase>)/g;
-    let match;
-    while ((match = re.exec(xml))) {
-        const attrs = match[1];
-        const body = match[3] ?? '';
-        const name = /\bname="([^"]*)"/.exec(attrs)?.[1] ?? '';
-        const classname = /\bclassname="([^"]*)"/.exec(attrs)?.[1] ?? '';
-        out.push({
-            name: [classname, name].filter(Boolean).join(' '),
-            failed: /<(failure|error)\b/.test(body),
-            skipped: /<skipped\b/.test(body),
-        });
-    }
-    return out;
-}
-/** Whole-word id match, so DT-9 doesn't claim a test named for DT-97. */
-function mentionsId(entry, id) {
-    const escaped = id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    return new RegExp(`(^|[^A-Za-z0-9])${escaped}([^A-Za-z0-9]|$)`, 'i').test(entry);
-}
-/** A report entry belongs to a flow when it names the file or its basename. */
-function matchesFlow(entry, flow) {
-    const name = entry.toLowerCase();
-    const base = (flow.split('/').pop() ?? flow).toLowerCase();
-    return (name.includes(flow.toLowerCase()) ||
-        name.includes(base) ||
-        name.includes(base.replace(/\.[^.]+$/, '')));
-}
-async function casesReport(root, junitPath, opts = {}) {
-    if (!junitPath) {
-        (0, output_js_1.printError)('Usage: conductor cases report --junit <file.xml>', opts);
-        return 1;
-    }
-    if (!(0, node_fs_1.existsSync)(junitPath)) {
-        (0, output_js_1.printError)(`No such JUnit file: ${junitPath}`, opts);
-        return 1;
-    }
-    const entries = parseJunit(await (0, promises_1.readFile)(junitPath, 'utf8'));
-    const cases = await loadCases(root);
-    const records = [];
-    const unmatched = [];
-    for (const entry of entries) {
-        // Prefer the flow: it says which platform column ran. An id in the test
-        // name only identifies the case, so it files one case-level result.
-        const byFlow = [];
-        for (const c of cases) {
-            for (const { column, flow } of flowsOf(c)) {
-                if (matchesFlow(entry.name, flow))
-                    byFlow.push({ c, column, flow });
-            }
-        }
-        const targets = byFlow.length
-            ? byFlow
-            : cases
-                .filter((c) => mentionsId(entry.name, c.id))
-                .map((c) => ({ c, column: undefined, flow: undefined }));
-        if (!targets.length) {
-            unmatched.push(entry.name);
-            continue;
-        }
-        for (const target of targets) {
-            records.push(result({
-                caseId: target.c.id,
-                column: target.column,
-                flow: target.flow,
-                verdict: entry.skipped ? 'skipped' : entry.failed ? 'failed' : 'passed',
-                source: 'ci',
-                note: entry.name,
-                build: opts.build,
-                environment: opts.environment,
-            }));
-        }
-    }
-    if (records.length)
-        await append(root, records);
-    if (opts.json) {
-        (0, output_js_1.printData)({ status: 'ok', reported: records.length, tests: entries.length, unmatched }, opts);
-    }
-    else {
-        console.log(`Filed ${records.length} results from ${entries.length} tests` +
-            (unmatched.length ? `; ${unmatched.length} matched no case` : ''));
-    }
-    return 0;
-}
-async function casesResult(root, caseId, verdict, opts = {}) {
-    if (!caseId || !verdict) {
-        (0, output_js_1.printError)('Usage: conductor cases result <case-id> --verdict passed|failed|blocked|skipped', opts);
-        return 1;
-    }
-    const known = await loadCases(root);
-    if (known.length && !known.some((c) => c.id === caseId)) {
-        (0, output_js_1.printError)(`No case "${caseId}" under ${casesDir(root)}.`, opts);
-        return 1;
-    }
-    await append(root, [
-        result({
-            caseId,
-            verdict,
-            column: opts.column,
-            source: 'ci',
-            note: opts.note,
-            build: opts.build,
-            environment: opts.environment,
-        }),
-    ]);
-    if (opts.json)
-        (0, output_js_1.printData)({ status: 'ok', caseId, verdict }, opts);
-    else
-        console.log(`Recorded ${caseId}: ${verdict}`);
-    return 0;
-}

package/skills/conductor-test-cases/SKILL.md

@@ -1,65 +0,0 @@
----
-name: conductor-test-cases
-description: Read a repo's test cases and file execution results from the command line, including turning a JUnit report from a CI run into per-case results. Use when reporting automated test outcomes back to the test-case matrix, checking which cases have no flow behind them, or recording a case verdict from a script.
----
-
-# Conductor — test cases
-
-A **test case** is the human-readable spec — id, title, business rule, steps,
-tags — kept as a YAML file under `~/.conductor/studio/cases/<project>/`, keyed
-by the project's path. Executions are appended to `results.jsonl` beside them.
-Neither is written into the repo under test: the Maestro flow a case names is
-the implementation, and that is what belongs in git.
-
-Both are plain files — read them, diff them, sync them however you like. Set
-`__CONDUCTOR_STUDIO_DIR` to relocate the store (CI sandboxes, tests). Cases an
-older version wrote to `test-cases/` in the repo are still read.
-
-| Command | Purpose |
-|---|---|
-| `conductor cases list [--project <dir>]` | List every case and the flow behind it |
-| `conductor cases report --junit <file.xml>` | File a JUnit report as per-case results |
-| `conductor cases result <case-id> --verdict <v>` | Record one result by hand |
-
-`--project <dir>` points at the repo root; it defaults to the working directory.
-These commands touch files only — no device, no session.
-
-## Report a CI run
-
-```bash
-conductor cases report --junit maestro-report.xml \
-  --build 2026.17.0 --environment staging
-```
-
-Each `<testcase>` binds to a case by the **flow** it names (`vod-playback.tv.yaml`
-→ the case whose `flows.tv` is that file, recording against the `tv` column) or,
-failing that, by a **case id** appearing in the test name as a whole word
-(`DT-97 search returns results` → case `DT-97`, recorded case-wide). Entries that
-match nothing are reported as unmatched rather than silently dropped.
-
-Add it as the last step of an e2e job, after the report is written:
-
-```yaml
-- run: conductor cases report --junit report.xml --build ${{ github.sha }}
-```
-
-## Record a single result
-
-```bash
-conductor cases result DT-1 --verdict failed --column tv \
-  --note "Subtitles never appear after seek" --build 2026.17.0
-```
-
-`--verdict` is `passed`, `failed`, `blocked` or `skipped`. `--column` scopes the
-result to one platform of a case that has a flow per platform; omit it for a
-case-wide verdict.
-
-## Find work
-
-```bash
-conductor cases list --json | jq '.cases[] | select(.flows | length == 0) | .id'
-```
-
-Cases with no flow are the unautomated ones — the backlog. Write the flow with
-`conductor-create-flow`, then add its path to the case's `flow:` (or `flows:`,
-keyed by platform) so the matrix picks it up.