@sdods/cli 0.17.0 → 0.19.0

package/dist/commands/import.d.ts

@@ -0,0 +1,7 @@
+import type { Command } from 'commander';
+import { planCucumberImport } from '@sdods/core';
+import { type CliContext } from '../context.js';
+/** Every file of the proposed project, keyed by its path from the repository root. */
+export declare function cucumberProjectFiles(ctx: Pick<CliContext, 'rootDir' | 'registry'>, plan: ReturnType<typeof planCucumberImport>, envName: string): Record<string, string>;
+export declare function register(program: Command): void;
+//# sourceMappingURL=import.d.ts.map

package/dist/commands/import.js

@@ -0,0 +1,147 @@
+import { existsSync, statSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
+import pc from 'picocolors';
+import { stringify as toYaml } from 'yaml';
+import { ProjectConfigSchema, SlugSchema } from '@sdods/contracts';
+import { PROJECT_FILE, SdodsError, analyzePlaywrightSuite, planCucumberImport } from '@sdods/core';
+import { createContext } from '../context.js';
+import { projectTemplateFiles } from '../templates/project.js';
+import { json, ok, out } from '../ui.js';
+/**
+ * `sdods import cucumber|playwright <dir>`: map an existing suite into an SDODS project, as a
+ * proposal a person accepts (docs/adr/0001-import-existing-suites.md). Never writes the tree.
+ */
+function sourceDir(dir) {
+    const abs = resolve(dir);
+    if (!existsSync(abs) || !statSync(abs).isDirectory()) {
+        throw new SdodsError('CONFIG_INVALID', `${dir} is not a directory.`, { exitCode: 2 });
+    }
+    return abs;
+}
+function checkSlug(ctx, slug) {
+    SlugSchema.parse(slug);
+    if (existsSync(join(ctx.registry.projectsDir, slug, PROJECT_FILE))) {
+        throw new SdodsError('CONFIG_INVALID', `Project "${slug}" already exists.`, {
+            hint: 'Pick another --project slug; an import proposes a new project.',
+            exitCode: 2,
+        });
+    }
+    return slug;
+}
+/** Every file of the proposed project, keyed by its path from the repository root. */
+export function cucumberProjectFiles(ctx, plan, envName) {
+    const config = ProjectConfigSchema.parse({
+        slug: plan.slug,
+        name: plan.slug.replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase()),
+        description: `Imported from a Cucumber-JS suite by sdods import cucumber.`,
+        layers: plan.layers,
+        browsers: ['chromium'],
+        envs: { default: envName, available: [envName] },
+        tags: { extra: plan.extraTags },
+    });
+    const scaffold = projectTemplateFiles({
+        config,
+        envName,
+        uiUrl: 'http://localhost:3000',
+        apiUrl: 'http://localhost:3000/api',
+    });
+    for (const key of Object.keys(scaffold))
+        if (key.startsWith('features/'))
+            delete scaffold[key];
+    const project = {
+        ...scaffold,
+        [PROJECT_FILE]: `# SDODS project, imported by sdods import cucumber. Reference: https://docs.sdods.com/docs/reference/project-yaml\n${toYaml({
+            slug: config.slug,
+            name: config.name,
+            description: config.description,
+            layers: config.layers,
+            browsers: config.browsers,
+            testIdAttribute: config.testIdAttribute,
+            tags: { suites: config.tags.suites, extra: config.tags.extra, roles: config.tags.roles },
+            envs: config.envs,
+            heal: { enabled: true },
+            retries: { ci: 2, local: 0 },
+        }, { lineWidth: 100 })}`,
+        'IMPORT-REPORT.md': plan.report,
+    };
+    for (const f of plan.features)
+        project[f.path] = f.content;
+    if (plan.stepsFile)
+        project['steps/imported.steps.ts'] = plan.stepsFile;
+    const base = relative(ctx.rootDir, join(ctx.registry.projectsDir, plan.slug));
+    return Object.fromEntries(Object.entries(project).map(([k, v]) => [join(base, k), v]));
+}
+export function register(program) {
+    const cmd = program
+        .command('import')
+        .description('Map an existing Cucumber-JS or Playwright suite into an SDODS project (as a proposal)');
+    cmd
+        .command('cucumber <dir>')
+        .description('Read a Cucumber-JS suite (features, step definitions, cucumber.js) and propose an SDODS project')
+        .requiredOption('-p, --project <slug>', 'slug of the new project')
+        .option('--env <name>', 'first environment name', 'local')
+        .option('--module <name>', 'folder under features/ for the imported features', 'imported')
+        .option('--dry-run', 'print the report and write nothing, not even a proposal')
+        .action(async (dir, opts, command) => {
+        const ctx = createContext(command);
+        const slug = checkSlug(ctx, opts.project);
+        const plan = planCucumberImport(sourceDir(dir), { slug, module: opts.module });
+        if (plan.features.length === 0) {
+            throw new SdodsError('CONFIG_INVALID', `No .feature files under ${dir}.`, { exitCode: 2 });
+        }
+        const files = cucumberProjectFiles(ctx, plan, opts.env);
+        if (opts.dryRun) {
+            if (ctx.opts.json)
+                return json({ plan, files: Object.keys(files) });
+            out(plan.report);
+            return;
+        }
+        const { ProposalStore } = await import('@sdods/mcp');
+        const manifest = new ProposalStore(ctx.rootDir).create({
+            role: 'importer',
+            project: slug,
+            env: opts.env,
+            summary: `Import ${plan.mappings.length} scenario(s) from ${plan.features.length} Cucumber-JS feature file(s) into ${slug}: ${plan.steps.core.length} step(s) reuse the SDODS library, ${plan.steps.stubbed.length} stubbed to port.`,
+            files: Object.entries(files).map(([path, content]) => ({
+                path,
+                content,
+                op: 'add',
+            })),
+        });
+        if (ctx.opts.json)
+            return json({ proposal: manifest, plan });
+        ok(`proposal ${manifest.id}: ${manifest.files.length} file(s) for projects/${slug}`);
+        out(pc.dim(`  ${plan.mappings.length} scenario(s), ${plan.steps.stubbed.length} step stub(s), ${plan.manual.length} item(s) to port by hand`));
+        out(`  review: ${pc.cyan(`sdods proposals show ${manifest.id}`)}`);
+        out(`  accept: ${pc.cyan(`sdods proposals accept ${manifest.id}`)}`);
+    });
+    cmd
+        .command('playwright <dir>')
+        .description('Analyse a Playwright Test suite and propose the report (converts nothing yet)')
+        .requiredOption('-p, --project <slug>', 'slug the suite would be imported as')
+        .option('--dry-run', 'print the report and write nothing')
+        .action(async (dir, opts, command) => {
+        const ctx = createContext(command);
+        const slug = checkSlug(ctx, opts.project);
+        const analysis = analyzePlaywrightSuite(sourceDir(dir), slug);
+        if (opts.dryRun) {
+            if (ctx.opts.json)
+                return json(analysis);
+            out(analysis.report);
+            return;
+        }
+        const { ProposalStore } = await import('@sdods/mcp');
+        const base = relative(ctx.rootDir, join(ctx.registry.projectsDir, slug));
+        const manifest = new ProposalStore(ctx.rootDir).create({
+            role: 'importer',
+            project: slug,
+            summary: `Analysis of a Playwright suite (${analysis.specFiles.length} spec file(s), ${analysis.tests} test(s)); converts nothing yet.`,
+            files: [{ path: join(base, 'IMPORT-REPORT.md'), content: analysis.report, op: 'add' }],
+        });
+        if (ctx.opts.json)
+            return json({ proposal: manifest, analysis });
+        ok(`proposal ${manifest.id}: the analysis report for ${slug}`);
+        out(`  review: ${pc.cyan(`sdods proposals show ${manifest.id}`)}`);
+    });
+}
+//# sourceMappingURL=import.js.map

package/dist/commands/run.js

@@ -1,9 +1,9 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync, } from 'node:fs';
 import { isAbsolute, join, relative, resolve as resolvePath } from 'node:path';
 import { execa } from 'execa';
 import pc from 'picocolors';
-import { RecordingModeSchema, newRunId, runFiles, } from '@sdods/contracts';
-import { SdodsError, CLI_OVERRIDES_ENV, VERSION, checkPoolCapacity, collectGateEvidence, effectiveWorkers, evaluateGates, formatFindings, hasGates, lintProject, listGeneratedProjects, moduleByName, moduleDir, normalizeTagExpr, parseTagExpr, poolAccountsFor, poolDemandByRole, poolTooSmallError, redactRunTraces, serializeCliOverrides, setupTierOf, } from '@sdods/core';
+import { RecordingModeSchema, isRunId, newRunId, runFiles, } from '@sdods/contracts';
+import { SdodsError, CLI_OVERRIDES_ENV, VERSION, checkPoolCapacity, ciHealSummary, collectGateEvidence, collectHealEvents, effectiveWorkers, evaluateGates, formatFindings, hasGates, lintProject, listGeneratedProjects, moduleByName, moduleDir, normalizeTagExpr, parseTagExpr, poolAccountsFor, poolDemandByRole, poolTooSmallError, redactRunTraces, serializeCliOverrides, setupTierOf, } from '@sdods/core';
 import { analyzeChangeImpact } from '@sdods/mcp';
 import { createContext } from '../context.js';
 import { toolCommand, workspaceBin } from '../workspace-bin.js';
@@ -68,7 +68,7 @@ function addRunOptions(cmd) {
         .option('--fail-on-flaky', 'exit 1 when any test is flaky')
         .option('--max-failures <n>', 'stop after n failures', parseIntFlag('max-failures'))
         .option('--timeout <ms>', 'per-test timeout override', parseIntFlag('timeout'))
-        .option('--reporter <name>', 'reporter override (repeatable, name=outputFile)', collect, [])
+        .option('--reporter <name>', 'add a reporter: junit (XML), allure (allure-results), json, blob, or any Playwright reporter; name=path sets the output (repeatable)', collect, [])
         .option('--reporter-mode <mode>', 'default | server | quiet')
         .option('--trigger <kind>', 'cli | ui | ci | agent | mcp | schedule', 'cli')
         .option('--allow-empty', 'exit 0 when the selection matches no scenario (by default that is exit 2)')
@@ -87,6 +87,13 @@ export function register(program) {
     });
 }
 export async function runCommand(flags, cmd) {
+    // The run id names `.sdods/generated/<runId>`, which is removed recursively when the run ends,
+    // so `--run-id ../..` must be refused before anything touches the disk.
+    if (flags.runId !== undefined && !isRunId(flags.runId))
+        throw new SdodsError('CONFIG_INVALID', `Invalid run id "${flags.runId}".`, {
+            hint: 'Use letters, digits, ".", "_" or "-", not starting with "." (or omit --run-id).',
+            exitCode: 2,
+        });
     const ctx = createContext(cmd);
     const entry = ctx.registry.pick(flags.project);
     const projectCfg = entry.config;
@@ -469,6 +476,26 @@ export async function runCommand(flags, cmd) {
             warn(`trace redaction failed for ${relative(ctx.rootDir, e.file)}: ${e.error}`);
     }
     const summary = readSummary(runDir, runId, exitCode, Date.now() - started);
+    // A heal in CI means the page changed under the suite. It must never pass silently
+    // (heal.ciMode, default warn), so every one is listed as an annotation and in the step summary.
+    if (cfg.runtime.ci) {
+        const heals = ciHealSummary(collectHealEvents(runDir));
+        if (heals) {
+            if (process.env.GITHUB_ACTIONS === 'true' && !ctx.opts.json)
+                for (const a of heals.annotations)
+                    console.log(a);
+            else
+                warn(heals.line);
+            if (process.env.GITHUB_STEP_SUMMARY) {
+                try {
+                    appendFileSync(process.env.GITHUB_STEP_SUMMARY, `${heals.markdown}\n`);
+                }
+                catch {
+                    // a read-only or missing summary file must not fail the run
+                }
+            }
+        }
+    }
     // Process gates are judged here, from the run that just finished, before anything publishes it.
     // One shard of several holds only part of the run, so its pass rate and its a11y/perf evidence
     // are not the run's; a sharded process is gated where the shards are merged

package/dist/program.js

@@ -40,6 +40,7 @@ import { register as registerUpgrade } from './commands/upgrade.js';
 import { register as registerFeedback } from './commands/feedback.js';
 import { register as registerLoad } from './commands/load.js';
 import { register as registerMatrix } from './commands/matrix.js';
+import { register as registerImport } from './commands/import.js';
 /**
  * All commands are registered eagerly (cheap) but each module keeps heavy imports
  * (server, agents, DB, browser runner) inside its action via dynamic import.
@@ -101,6 +102,7 @@ export function buildProgram() {
     registerFeedback(program);
     registerLoad(program);
     registerMatrix(program);
+    registerImport(program);
     return program;
 }
 //# sourceMappingURL=program.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdods/cli",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "description": "SDODS command line: run, record, analyze, agents, MCP server, scheduler and the web server.",
   "license": "Apache-2.0",
   "funding": "https://sdods.com/sponsor/",
@@ -26,8 +26,8 @@
     "node": ">=22"
   },
   "dependencies": {
-    "@sdods/contracts": "0.17.0",
-    "@sdods/core": "0.17.0",
+    "@sdods/contracts": "0.19.0",
+    "@sdods/core": "0.19.0",
     "commander": "^15.0.0",
     "execa": "^10.2.1",
     "picocolors": "^1.1.1",
@@ -36,12 +36,12 @@
     "zod": "^4.6.7",
     "@playwright/test": "^1.64.0",
     "playwright-core": "^1.64.0",
-    "@sdods/integrations": "0.17.0",
-    "@sdods/mcp": "0.17.0",
-    "@sdods/agents": "0.17.0",
-    "@sdods/db": "0.17.0",
+    "@sdods/integrations": "0.19.0",
+    "@sdods/mcp": "0.19.0",
+    "@sdods/agents": "0.19.0",
+    "@sdods/db": "0.19.0",
     "csv-parse": "^7.0.3",
-    "@sdods/server": "0.17.0"
+    "@sdods/server": "0.19.0"
   },
   "homepage": "https://sdods.com",
   "bugs": {
@@ -49,7 +49,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/YarlisAISolutions/SDODS.git",
+    "url": "git+https://github.com/YarlisAISolutions/sdods.git",
     "directory": "packages/cli"
   },
   "keywords": [