@elmundi/ship-cli 0.8.1 → 0.12.0

package/lib/artifacts/fs-index.mjs

@@ -0,0 +1,230 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * Shared filesystem index for v2 artifact trees: walks
+ * `<repoRoot>/artifacts/<plural>/<id>/ARTIFACT.md` and parses just enough YAML
+ * front-matter to reconstruct the same entry shape we used to read out of the
+ * legacy `<plural>/manifest.json` files.
+ *
+ * Zero dependencies — only node builtins. Anything we cannot parse falls
+ * through (the entry still gets emitted with whatever fields we recovered).
+ */
+
+const KIND_TO_PLURAL = {
+  pattern: "patterns",
+  tool: "tools",
+  collection: "collections",
+};
+
+/**
+ * @param {"pattern"|"tool"|"collection"} kind
+ */
+export function pluralFor(kind) {
+  return KIND_TO_PLURAL[kind] || `${kind}s`;
+}
+
+/**
+ * Walk `artifacts/<plural>/*` and return the parsed entries (same shape as the
+ * legacy manifest).
+ *
+ * @param {string} repoRoot
+ * @param {"pattern"|"tool"|"collection"} kind
+ * @returns {Array<Record<string, any>>}
+ */
+export function scanArtifacts(repoRoot, kind) {
+  const plural = pluralFor(kind);
+  const dir = path.join(repoRoot, "artifacts", plural);
+  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) return [];
+
+  const ids = fs.readdirSync(dir, { withFileTypes: true })
+    .filter((e) => e.isDirectory())
+    .map((e) => e.name)
+    .sort();
+
+  /** @type {Array<Record<string, any>>} */
+  const out = [];
+  for (const id of ids) {
+    const file = path.join(dir, id, "ARTIFACT.md");
+    if (!fs.existsSync(file)) continue;
+    let raw;
+    try {
+      raw = fs.readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    const { fm } = parseFrontMatter(raw);
+    const entry = entryFromFrontmatter(fm, kind, id);
+    out.push(entry);
+  }
+  return out;
+}
+
+/**
+ * Read the full ARTIFACT.md (frontmatter + body) for a specific id. Returns
+ * null when the file is absent so callers can emit the same "Unknown id"
+ * messages they did before.
+ *
+ * @param {string} repoRoot
+ * @param {"pattern"|"tool"|"collection"} kind
+ * @param {string} id
+ */
+export function readArtifactFile(repoRoot, kind, id) {
+  const plural = pluralFor(kind);
+  const file = path.join(repoRoot, "artifacts", plural, id, "ARTIFACT.md");
+  if (!fs.existsSync(file) || !fs.statSync(file).isFile()) return null;
+  return { absPath: file, content: fs.readFileSync(file, "utf8") };
+}
+
+function entryFromFrontmatter(fm, kind, id) {
+  const plural = pluralFor(kind);
+  const description = typeof fm.description === "string" ? fm.description : "";
+  const summary = description ? firstSentence(description) : "";
+  return {
+    id: typeof fm.id === "string" && fm.id ? fm.id : id,
+    title: typeof fm.name === "string" ? fm.name : id,
+    summary,
+    path: `artifacts/${plural}/${id}/ARTIFACT.md`,
+    tags: Array.isArray(fm.tags) ? fm.tags : [],
+    group: typeof fm.group === "string" ? fm.group : null,
+    version: typeof fm.version === "string" ? fm.version : null,
+    content_sha256: typeof fm.content_sha256 === "string" ? fm.content_sha256 : null,
+    updated_at: typeof fm.updated_at === "string" ? fm.updated_at : null,
+    channel: typeof fm.channel === "string" ? fm.channel : null,
+    min_shipctl: typeof fm.min_shipctl === "string" ? fm.min_shipctl : null,
+    deprecated: fm.deprecated === true || fm.deprecated === "true",
+    replaced_by: fm.replaced_by ?? null,
+    yanked: fm.yanked === true || fm.yanked === "true",
+  };
+}
+
+function firstSentence(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return "";
+  const m = /[.!?](\s|$)/.exec(trimmed);
+  if (!m) return trimmed;
+  return trimmed.slice(0, m.index + 1).trim();
+}
+
+/**
+ * Tiny YAML front-matter parser tailored for v2 ARTIFACT.md files.
+ *
+ * Supports:
+ *   - simple `key: value`
+ *   - inline lists `key: [a, b]`
+ *   - folded scalars `key: >` / `key: >-` with indented continuation lines
+ *   - quoted strings (single or double)
+ *   - one level of nested mapping (used by `spec:`)
+ *   - comments (`# …`)
+ *
+ * Anything else is best-effort: the value is captured as the trimmed string.
+ *
+ * @param {string} source
+ * @returns {{fm: Record<string, any>, body: string}}
+ */
+export function parseFrontMatter(source) {
+  if (typeof source !== "string") return { fm: {}, body: "" };
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(source);
+  if (!match) return { fm: {}, body: source };
+  const block = match[1];
+  const body = source.slice(match[0].length);
+  /** @type {Record<string, any>} */
+  const fm = {};
+  const lines = block.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length) {
+    const rawLine = lines[i];
+    const line = rawLine.replace(/\s+$/, "");
+    if (!line || /^\s*#/.test(line)) {
+      i += 1;
+      continue;
+    }
+    const top = /^([A-Za-z_][A-Za-z0-9_.-]*)\s*:\s*(.*)$/.exec(line);
+    if (!top) {
+      i += 1;
+      continue;
+    }
+    const key = top[1];
+    const value = top[2];
+
+    if (value === ">" || value === ">-") {
+      const folded = [];
+      i += 1;
+      while (i < lines.length) {
+        const cont = lines[i];
+        if (cont === "" || cont === "\r") {
+          // Preserve paragraph breaks as a single space in folded scalars.
+          folded.push("");
+          i += 1;
+          continue;
+        }
+        const m = /^(\s+)(.*)$/.exec(cont);
+        if (!m) break;
+        folded.push(m[2]);
+        i += 1;
+      }
+      let joined = folded.join(" ").replace(/\s+/g, " ").trim();
+      if (value === ">-") joined = joined.replace(/\s+$/, "");
+      fm[key] = joined;
+      continue;
+    }
+
+    if (/^\[.*\]$/.test(value.trim())) {
+      const inner = value.trim().slice(1, -1).trim();
+      fm[key] = inner.length ? inner.split(/\s*,\s*/).map(unquote) : [];
+      i += 1;
+      continue;
+    }
+
+    if (value === "") {
+      // Possible nested mapping or empty scalar. Peek ahead.
+      const child = {};
+      let saw = false;
+      let j = i + 1;
+      while (j < lines.length) {
+        const cont = lines[j];
+        if (!cont.trim()) { j += 1; continue; }
+        const indented = /^(\s{2,})([A-Za-z_][A-Za-z0-9_.-]*)\s*:\s*(.*)$/.exec(cont);
+        if (!indented) break;
+        const [, , subKey, subVal] = indented;
+        if (/^\[.*\]$/.test(subVal.trim())) {
+          const inner = subVal.trim().slice(1, -1).trim();
+          child[subKey] = inner.length ? inner.split(/\s*,\s*/).map(unquote) : [];
+        } else {
+          child[subKey] = coerceScalar(subVal);
+        }
+        saw = true;
+        j += 1;
+      }
+      if (saw) {
+        fm[key] = child;
+        i = j;
+        continue;
+      }
+      fm[key] = "";
+      i += 1;
+      continue;
+    }
+
+    fm[key] = coerceScalar(value);
+    i += 1;
+  }
+  return { fm, body };
+}
+
+function unquote(value) {
+  if (typeof value !== "string") return value;
+  const v = value.trim();
+  if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) {
+    return v.slice(1, -1);
+  }
+  return v;
+}
+
+function coerceScalar(rawValue) {
+  const v = unquote(String(rawValue).trim());
+  if (v === "true") return true;
+  if (v === "false") return false;
+  if (v === "null" || v === "~") return null;
+  return v;
+}

package/lib/bootstrap/render.mjs

@@ -0,0 +1,422 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * Bootstrap renderer for `shipctl init --bootstrap`.
+ *
+ * This is intentionally a v1: full preset-body interpretation (parsing
+ * `## Bootstrap (files to write)` blocks from adapter artifacts) is TODO
+ * and tracked as a templating engine in RFC-0004. For now we:
+ *
+ *   - Always emit a SHIP_BOOTSTRAP_PLAN.md summary so the user has a
+ *     single actionable next-step document.
+ *   - For the common `mobile-app + gh-actions + linear` triple we also
+ *     write minimal CI workflow skeleton, label contract YAML, and
+ *     `.env.example` placeholders. Other combos fall back to plan-only.
+ *
+ * @typedef {Object} PlanFile
+ * @property {string} path     Relative to cwd.
+ * @property {string} content
+ * @property {"create"|"append"|"patch"} mode
+ *
+ * @typedef {Object} PlanSummary
+ * @property {string[]} notes
+ * @property {Array<{path:string, mode:string, detail?:string}>} files
+ *
+ * @typedef {Object} RenderedPlan
+ * @property {PlanFile[]} files
+ * @property {PlanSummary} summary
+ */
+
+const MOBILE_LABELS = [
+  "platform:ios",
+  "platform:android",
+  "store:review",
+  "flag:behind",
+  "flag:ahead",
+  "change-record",
+  "blocked",
+  "preview:ready",
+];
+
+const ENV_EXAMPLE_MARKER_START = "# --- ship-managed ---";
+const ENV_EXAMPLE_MARKER_END = "# --- end ship-managed ---";
+
+/**
+ * @param {object} cfg
+ * @returns {RenderedPlan}
+ */
+export function renderMobileAppGhActionsLinear(cfg) {
+  const preset = cfg.stack?.preset || "mobile-app";
+  const tracker = cfg.stack?.tracker || "linear";
+  const ci = cfg.stack?.ci || "gh-actions";
+  const agents = Array.isArray(cfg.stack?.agents) ? cfg.stack.agents : [];
+
+  const workflow = `# ship-managed: workflow
+# Skeleton written by \`shipctl init --bootstrap\`.
+# shipctl sync (Epic 7) will fill in job bodies from preset:preset-${preset}.
+name: ship-pilot
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+jobs:
+  # ship-managed: workflow
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      # TODO: language-specific lint wired by shipctl sync
+      - run: echo "lint: placeholder"
+
+  # ship-managed: workflow
+  build-ios:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v4
+      # TODO: EAS / Fastlane build steps wired by shipctl sync
+      - run: echo "build-ios: placeholder"
+
+  # ship-managed: workflow
+  build-android:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      # TODO: Gradle / EAS build steps wired by shipctl sync
+      - run: echo "build-android: placeholder"
+`;
+
+  const labelsYml = `# ship-managed: labels
+# Synced to the tracker (${tracker}) by \`shipctl verify\`.
+version: 1
+preset: ${preset}
+labels:
+${MOBILE_LABELS.map((l) => `  - name: "${l}"`).join("\n")}
+`;
+
+  const envBlock = `${ENV_EXAMPLE_MARKER_START}
+# Placeholders for ${preset} / ${tracker} / ${ci}.
+# Fill these in .env.local (not committed) or your platform secret store.
+LINEAR_API_KEY=
+LINEAR_TEAM_ID=
+GITHUB_TOKEN=
+EXPO_TOKEN=
+SENTRY_AUTH_TOKEN=
+${ENV_EXAMPLE_MARKER_END}
+`;
+
+  const plan = renderAdoptionMinimum(cfg, {
+    extraNotes: [
+      "Mobile-app pilot scaffolding was emitted (gh-actions + linear).",
+      "See `.github/workflows/ship-pilot.yml`, `.ship/labels.yml`, `.env.example`.",
+    ],
+  });
+
+  const files = [
+    ...plan.files,
+    {
+      path: ".github/workflows/ship-pilot.yml",
+      content: workflow,
+      mode: /** @type {"create"} */ ("create"),
+    },
+    {
+      path: ".ship/labels.yml",
+      content: labelsYml,
+      mode: /** @type {"create"} */ ("create"),
+    },
+    {
+      path: ".env.example",
+      content: envBlock,
+      mode: /** @type {"append"} */ ("append"),
+    },
+  ];
+
+  const summary = {
+    notes: [
+      ...plan.summary.notes,
+      `bootstrap: mobile-app + ${ci} + ${tracker} triple rendered`,
+      `agents: ${agents.join(", ") || "(none)"}`,
+    ],
+    files: files.map((f) => ({
+      path: f.path,
+      mode: f.mode,
+      detail:
+        f.path === ".ship/labels.yml"
+          ? `${MOBILE_LABELS.length} labels`
+          : f.path === ".env.example"
+            ? "5 placeholders"
+            : undefined,
+    })),
+  };
+
+  return { files, summary };
+}
+
+/**
+ * Generate just the SHIP_BOOTSTRAP_PLAN.md summary. Used as the v1
+ * fallback for preset / CI / tracker combos that don't have a specific
+ * renderer yet.
+ *
+ * @param {object} cfg
+ * @param {{extraNotes?:string[]}} [opts]
+ * @returns {RenderedPlan}
+ */
+export function renderAdoptionMinimum(cfg, opts = {}) {
+  const stack = cfg.stack || {};
+  const preset = stack.preset || "adoption-minimum";
+  const tracker = stack.tracker || "none";
+  const ci = stack.ci || "manual";
+  const agents = Array.isArray(stack.agents) ? stack.agents : [];
+  const language = stack.language || "multi";
+  const channel = cfg.api?.channel || "stable";
+  const telemetry = cfg.telemetry?.share === true ? "on" : "off";
+  const extraNotes = opts.extraNotes || [];
+
+  const todos = buildTodoList({ preset, ci, tracker, agents });
+  const recommendedTools = buildRecommendedTools({ preset });
+  const recommendedSecrets = buildRecommendedSecrets({ tracker, ci });
+
+  const body = `# Ship bootstrap plan
+
+_Generated by \`shipctl init --bootstrap\` on ${new Date().toISOString()}._
+
+## Chosen stack
+
+- **preset**: \`${preset}\`
+- **tracker**: \`${tracker}\`
+- **ci**: \`${ci}\`
+- **language**: \`${language}\`
+- **agents**: ${agents.length ? agents.map((a) => `\`${a}\``).join(", ") : "_(none)_"}
+- **channel**: \`${channel}\`
+- **telemetry**: \`${telemetry}\`
+
+## Recommended tools
+
+${recommendedTools.map((t) => `- ${t}`).join("\n") || "_(none for this preset yet — fill manually.)_"}
+
+## Recommended secrets / env
+
+${recommendedSecrets.map((s) => `- \`${s}\``).join("\n") || "_(none required.)_"}
+
+## Files to create / review
+
+${todos.map((t) => `- [ ] ${t}`).join("\n")}
+
+## Next steps
+
+1. \`shipctl sync\` to refresh \`.ship/cache/\` against the Ship API.
+2. \`shipctl verify\` to confirm tracker labels / CI secrets / rules markers.
+3. Open the preset artifact for full details:
+   \`shipctl collection show preset-${preset}\`.
+
+${
+  extraNotes.length
+    ? `## Notes\n\n${extraNotes.map((n) => `- ${n}`).join("\n")}\n`
+    : ""
+}`;
+
+  return {
+    files: [
+      {
+        path: "SHIP_BOOTSTRAP_PLAN.md",
+        content: body,
+        mode: /** @type {"create"} */ ("create"),
+      },
+    ],
+    summary: {
+      notes: ["bootstrap: plan-only fallback rendered (SHIP_BOOTSTRAP_PLAN.md)"],
+      files: [
+        {
+          path: "SHIP_BOOTSTRAP_PLAN.md",
+          mode: "create",
+          detail: `${todos.length} todo items`,
+        },
+      ],
+    },
+  };
+}
+
+function buildTodoList({ preset, ci, tracker, agents }) {
+  const todos = [];
+  if (ci === "gh-actions") {
+    todos.push("Confirm `.github/workflows/ship-pilot.yml` skeleton (shipctl sync will fill the job bodies).");
+  } else {
+    todos.push(`Author the CI workflow skeleton for \`${ci}\` manually (no renderer yet).`);
+  }
+  if (tracker !== "none") {
+    todos.push(`Create the label contract for \`${tracker}\` (see preset:preset-${preset} for the label set).`);
+  }
+  for (const a of agents) {
+    todos.push(`Agent rules for \`${a}\`: install via \`shipctl init --copy-rules --agents ${a}\`.`);
+  }
+  todos.push("Populate `.env.example` / secret store with the secrets listed above.");
+  todos.push("Run `shipctl verify` after the above to confirm the stack.");
+  return todos;
+}
+
+function buildRecommendedTools({ preset }) {
+  const common = ["`shipctl doctor` — inspect repo and reconcile stack"];
+  const byPreset = {
+    "mobile-app": [
+      "EAS Build / Fastlane for iOS + Android signed builds",
+      "Detox or Maestro for device-farm E2E",
+      "Expo Updates or CodePush for OTA patches",
+    ],
+    "mobile-app-deep": [
+      "EAS Build / Fastlane for iOS + Android signed builds",
+      "Detox or Maestro for device-farm E2E",
+      "Expo Updates or CodePush for OTA patches",
+      "Crashlytics or Sentry for post-release crash-rate tracking",
+      "TestFlight external testing + Play closed-testing tracks",
+    ],
+    "ml-project": [
+      "DVC / LakeFS / Delta Lake for dataset + model versioning",
+      "MLflow or Weights & Biases for eval tracking",
+      "Feast / Tecton / Databricks Feature Store for feature contracts",
+      "Great Expectations / Pandera for data validation",
+    ],
+    platform: [
+      "Terraform + a state backend you can audit (S3 / Terraform Cloud)",
+      "Kyverno / OPA / Conftest for manifest-level policy gating",
+      "Infracost or cloud-pricing API for per-PR cost deltas",
+      "Prometheus / Datadog / CloudWatch for SLO burn-rate queries",
+      "Syft / Trivy / Grype for SBOM generation at release",
+    ],
+    regulated: [
+      "Presidio / Nightfall / Transcend for PII detection helpers",
+      "An audit log store with hash-chain integrity (append-only DB / S3 with object-lock)",
+      "Vault / AWS Secrets Manager for scoped compliance credentials",
+      "Drata / Vanta / Secureframe for evidence-bundle sync (optional)",
+    ],
+    "desktop-app": [
+      "Apple notarytool + Developer ID cert for macOS notarization",
+      "Windows Authenticode / EV code-signing cert + SignTool",
+      "electron-updater / Sparkle / Squirrel for staged auto-update",
+      "A crash-telemetry SDK (Sentry / Bugsnag) scoped to desktop builds",
+      "Per-platform installer toolchain (dmg, msi, deb, AppImage)",
+    ],
+    firmware: [
+      "A cross-toolchain (arm-none-eabi-gcc / clang-embedded / IDF / Zephyr SDK)",
+      "PlatformIO / ESP-IDF / Zephyr / Yocto build system tied into CI",
+      "Renode or QEMU for simulated HIL runs on PR",
+      "An OTA backend (AWS IoT Jobs / Azure IoT Hub / Mender / Balena / Nerves)",
+      "Octopart / Digi-Key / Mouser API for BOM pricing + lifecycle",
+      "A bench power analyzer or logged DMM for power-profile ground truth",
+    ],
+    game: [
+      "Your engine (Unity / Unreal / Godot) hooked into CI with headless builds",
+      "Perforce or Git LFS for binary art assets",
+      "Unity Cloud Build / UGS / Jenkins for per-PR cook builds",
+      "RenderDoc / Tracy / Unreal Insights for frametime capture",
+      "A crash-telemetry SDK (Backtrace / Sentry / Unity Cloud Diagnostics)",
+      "A localization TMS (Crowdin / Lokalise / Smartling) for event strings",
+    ],
+    "web-app": [
+      "Playwright (hosted) for PR preview E2E",
+      "Preview deployments (Vercel / Netlify / Fly) per PR",
+    ],
+    "api-backend": [
+      "Contract tests (Pact / OpenAPI diff)",
+      "Migration discipline (Atlas / Liquibase)",
+    ],
+    cli: ["Cross-platform release matrix (GoReleaser / pkg / esbuild)"],
+    monorepo: ["Turborepo / Nx / pnpm workspaces for per-package CI"],
+    "adoption-minimum": [],
+  };
+  return [...common, ...(byPreset[preset] || [])];
+}
+
+function buildRecommendedSecrets({ tracker, ci }) {
+  const secrets = new Set();
+  if (tracker === "linear") secrets.add("LINEAR_API_KEY").add("LINEAR_TEAM_ID");
+  if (tracker === "jira") secrets.add("JIRA_API_TOKEN").add("JIRA_EMAIL");
+  if (tracker === "github-issues") secrets.add("GITHUB_TOKEN");
+  if (ci === "gh-actions") secrets.add("GITHUB_TOKEN");
+  if (ci === "circleci") secrets.add("CIRCLE_TOKEN");
+  return [...secrets];
+}
+
+/**
+ * Pick the right renderer for this stack. v1 only special-cases
+ * `mobile-app + gh-actions + linear`.
+ *
+ * @param {object} cfg
+ * @returns {RenderedPlan}
+ */
+export function renderPlan(cfg /*, presetArtifact */) {
+  const preset = cfg.stack?.preset;
+  const tracker = cfg.stack?.tracker;
+  const ci = cfg.stack?.ci;
+
+  if (preset === "mobile-app" && ci === "gh-actions" && tracker === "linear") {
+    return renderMobileAppGhActionsLinear(cfg);
+  }
+  return renderAdoptionMinimum(cfg);
+}
+
+/**
+ * Apply a plan to disk. Append-mode files use marker-guarded idempotency.
+ * Create-mode files are skipped when they already exist unless `force`
+ * is set (we never silently stomp a user's file).
+ *
+ * @param {string} cwd
+ * @param {RenderedPlan} plan
+ * @param {{dryRun?:boolean, force?:boolean}} [opts]
+ * @returns {Array<{path:string, action:"wrote"|"skipped"|"appended"|"would_write"|"would_skip"|"would_append"}>}
+ */
+export function applyPlan(cwd, plan, opts = {}) {
+  const { dryRun = false, force = false } = opts;
+  /** @type {Array<{path:string, action:string}>} */
+  const results = [];
+
+  for (const file of plan.files) {
+    const abs = path.join(cwd, file.path);
+
+    if (file.mode === "append") {
+      const current = fs.existsSync(abs) ? fs.readFileSync(abs, "utf8") : "";
+      if (current.includes(ENV_EXAMPLE_MARKER_START)) {
+        results.push({ path: file.path, action: dryRun ? "would_skip" : "skipped" });
+        continue;
+      }
+      if (dryRun) {
+        results.push({ path: file.path, action: "would_append" });
+        continue;
+      }
+      fs.mkdirSync(path.dirname(abs), { recursive: true });
+      const prefix = current.length && !current.endsWith("\n") ? "\n" : "";
+      fs.writeFileSync(abs, current + prefix + file.content, "utf8");
+      results.push({ path: file.path, action: "appended" });
+      continue;
+    }
+
+    if (fs.existsSync(abs) && !force) {
+      results.push({ path: file.path, action: dryRun ? "would_skip" : "skipped" });
+      continue;
+    }
+    if (dryRun) {
+      results.push({ path: file.path, action: "would_write" });
+      continue;
+    }
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, file.content, "utf8");
+    results.push({ path: file.path, action: "wrote" });
+  }
+
+  return results;
+}
+
+/**
+ * Top-level entry point used by `shipctl init --bootstrap`.
+ *
+ * @param {string} cwd
+ * @param {object} config
+ * @param {object|null} presetArtifact   Reserved for v2 when we parse the preset body.
+ * @param {Array<object>} _adapters       Reserved for v2.
+ * @param {{dryRun?:boolean, force?:boolean}} [opts]
+ */
+export function renderBootstrap(cwd, config, presetArtifact, _adapters, opts = {}) {
+  const plan = renderPlan(config, presetArtifact);
+  const results = applyPlan(cwd, plan, opts);
+  return { plan, results };
+}