@intentius/chant 0.80.0 → 0.81.0

package/src/cli/commands/lint.test.ts

@@ -6,7 +6,6 @@ import { join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 import { params, setBuildParams } from "../../params";
-import { resetDiscoveryWarnings } from "../../discovery/convergence";
 
 describe("lintCommand", () => {
   let testDir: string;
@@ -643,58 +642,53 @@ describe("lintCommand — git-ignored files are not linted", () => {
 });
 
 /**
- * chant#2527's warning release for lint: a child project is linted today and
- * stops the converged walk next release; a scan root that is itself ignored
- * lints nothing today and is linted next release. Both still lint exactly
- * what they did, with a warning naming the files and the glob.
+ * chant#2527: lint walks through the one discovery walk. A child project
+ * inside a project is a boundary, `include` re-admits it, and a scan root
+ * that is itself git-ignored is linted.
  */
-describe("lintCommand — files the converged walker reads differently (#2527)", () => {
+describe("lintCommand — the converged discovery walk (#2527)", () => {
   let testDir: string;
-  let stderr: string[];
   const EVL003 = `const t = { a: 1 };\nexport function g(k: string) { return t[k]; }\n`;
 
   beforeEach(async () => {
     testDir = join(tmpdir(), `chant-lint-2527-${Date.now()}-${Math.random()}`);
     await mkdir(testDir, { recursive: true });
     process.env.NO_COLOR = "1";
-    resetDiscoveryWarnings();
-    stderr = [];
-    vi.spyOn(console, "error").mockImplementation((...args: unknown[]) => void stderr.push(args.join(" ")));
   });
 
   afterEach(async () => {
-    vi.restoreAllMocks();
     await rm(testDir, { recursive: true, force: true });
     delete process.env.NO_COLOR;
   });
 
-  test("a nested child project is still linted, and named with its include glob", async () => {
-    await writeFile(join(testDir, "chant.config.json"), JSON.stringify({ knowledge: { dir: "knowledge" } }));
+  async function childProject(config: Record<string, unknown>): Promise<void> {
+    await writeFile(join(testDir, "chant.config.json"), JSON.stringify({ knowledge: { dir: "knowledge" }, ...config }));
     await writeFile(join(testDir, "index.ts"), `export const x = 1;\n`);
     await mkdir(join(testDir, "stacks", "east"), { recursive: true });
     await writeFile(join(testDir, "stacks", "east", "chant.config.ts"), `export default {};\n`);
     await writeFile(join(testDir, "stacks", "east", "east.ts"), EVL003);
+  }
+
+  test("a nested child project is not linted from the parent", async () => {
+    await childProject({});
+    const result = await lintCommand({ path: testDir, format: "stylish" });
+    expect(result.diagnostics.some((d) => d.file.includes("east.ts"))).toBe(false);
+  });
 
+  test("include re-admits the child project", async () => {
+    await childProject({ include: ["stacks/east"] });
     const result = await lintCommand({ path: testDir, format: "stylish" });
     expect(result.diagnostics.some((d) => d.file.includes("east.ts") && d.ruleId === "EVL003")).toBe(true);
-    const warning = stderr.find((l) => l.startsWith("warning: chant lint under"));
-    expect(warning).toContain("  stacks/east/chant.config.ts, stacks/east/east.ts: stacks/east/ is a child project");
-    expect(warning).toContain('To keep reading them after the change, add "stacks/east" to include in');
   });
 
-  test("an ignored scan root lints nothing today, and says it will be linted", async () => {
+  test("an ignored scan root is linted: ignore rules apply below the root only", async () => {
     execFileSync("git", ["init", "-q"], { cwd: testDir });
     await writeFile(join(testDir, ".gitignore"), "/carveout/\n");
     await mkdir(join(testDir, "carveout", "src"), { recursive: true });
     await writeFile(join(testDir, "carveout", "src", "main.ts"), EVL003);
 
     const result = await lintCommand({ path: join(testDir, "carveout", "src"), format: "stylish" });
-    expect(result.diagnostics.filter((d) => d.file.includes("main.ts"))).toHaveLength(0);
-    const warning = stderr.find((l) => l.startsWith("warning: chant lint under"));
-    expect(warning).toContain("  main.ts: ");
-    expect(warning).toContain("is itself git-ignored, so today nothing under it is linted. ");
-    expect(warning).toContain("so the files under it are linted.");
-    expect(warning).toContain('To keep skipping it, add "**" to exclude in');
+    expect(result.diagnostics.some((d) => d.file.includes("main.ts") && d.ruleId === "EVL003")).toBe(true);
   });
 });
 

package/src/cli/commands/lint.ts

@@ -1,7 +1,6 @@
 import { resolve, join, relative } from "path";
 import type { BuildParamProvenance } from "../../provenance";
-import { readFileSync, writeFileSync, readdirSync, statSync } from "fs";
-import { execFileSync } from "child_process";
+import { readFileSync, writeFileSync, readdirSync } from "fs";
 import { runLint, parseDisableComments } from "../../lint/engine";
 import type { LintRule, LintDiagnostic, LintFix } from "../../lint/rule";
 import type { IntrinsicDef, LexiconPlugin } from "../../lexicon";
@@ -19,8 +18,8 @@ import { runPostSynthChecks } from "../../lint/post-synth";
 import { rule } from "../../lint/declarative";
 import { watchDirectory, formatTimestamp, formatChangedFiles } from "../watch";
 import { formatError, formatInfo } from "../format";
-import { GENERATED_MARKER, hasSkipMarker, compileDiscoveryFilter } from "../../discovery/files";
-import { dirProbe, warnDiscoveryChanges } from "../../discovery/convergence";
+import { hasDiscoveryMarkerSync, isSourceFileName } from "../../discovery/files";
+import { walkDiscovery, workspaceMemberDirs } from "../../discovery/walk";
 import { buildParamValues, resolveBuildParams } from "../../build-params";
 import { setBuildParams } from "../../params";
 import { isNoLexiconDetected } from "../../detectLexicon";
@@ -270,80 +269,26 @@ export interface LintResult {
 }
 
 /**
- * Drop paths git ignores. Vendored trees (`vendor/`), build output (`dist/`),
- * and anything else in `.gitignore` are not authored chant source — linting
- * them surfaces EVL/COR errors in code the project never wrote, which then
- * gates `chant graph --format ir` on files outside the graph. Delegates to
- * `git check-ignore` for exact gitignore semantics (nesting, negation) in one
- * batched call; a non-git tree (or absent git) filters nothing.
+ * Every TypeScript file `chant lint` reads under `dir`, through the one
+ * discovery walk (`../../discovery/walk.ts`, #2527): git-ignored paths
+ * (vendored trees and the like, which the project never wrote), dot-directories,
+ * `dist` and, inside a project, child projects are skipped, and so is what the
+ * project's `exclude` globs (#2519) name, unless `include` re-admits it. Test
+ * and spec files, chant-generated files and skip-marked files are left out.
+ * Symlinks are followed, as lint always did.
  */
-function filterGitIgnored(files: string[], cwd: string, ignoredOut?: Set<string>): string[] {
-  if (files.length === 0) return files;
-  try {
-    const out = execFileSync("git", ["check-ignore", "--stdin"], {
-      cwd,
-      // The scan root rides along as one extra probe for #2527's warning
-      // release: whether it is itself ignored. It is never a file in `files`.
-      input: [...files, dirProbe(cwd)].join("\n"),
-      encoding: "utf-8",
-      // stdin piped (input), stdout captured, stderr silenced so a non-git tree's
-      // "fatal: not a git repository" never leaks to the lint output.
-      stdio: ["pipe", "pipe", "ignore"],
-      // Exit 1 means "nothing ignored" — execFileSync throws on non-zero, so the
-      // catch handles it; exit 128 (not a repo) lands there too and filters none.
-    });
-    const ignored = new Set(out.split(/\r?\n/).filter(Boolean));
-    for (const p of ignored) ignoredOut?.add(p);
-    return ignored.size === 0 ? files : files.filter((f) => !ignored.has(f));
-  } catch {
-    // No git, not a repo, or nothing ignored (exit 1) — keep every file.
-    return files;
-  }
-}
-
-/** What {@link getTypeScriptFiles} saw before its git-ignore filter, for #2527's warning. */
-interface TypeScriptScan {
-  raw: string[];
-  ignored: Set<string>;
-}
-
-/**
- * Get all TypeScript files recursively, skipping git-ignored paths and the
- * files `skip` (the project's `exclude` globs, #2519) names. `scanOut`, when
- * given, receives the files found before the ignore filter and the paths git
- * reported ignored.
- */
-function getTypeScriptFiles(dir: string, skip?: (file: string) => boolean, scanOut?: TypeScriptScan): string[] {
-  const files: string[] = [];
-
-  function scan(currentDir: string): void {
-    const entries = readdirSync(currentDir);
-
-    for (const entry of entries) {
-      const fullPath = join(currentDir, entry);
-      const stat = statSync(fullPath);
-
-      if (stat.isDirectory()) {
-        if (entry !== "node_modules" && !entry.startsWith(".")) {
-          scan(fullPath);
-        }
-      } else if (entry.endsWith(".ts") && !entry.endsWith(".test.ts") && !entry.endsWith(".spec.ts")) {
-        if (skip?.(fullPath)) continue;
-        // Skip chant-generated files (worker/workflow/activities bootstrap): they
-        // hold no authored source and use runtime patterns the EVL* rules forbid.
-        // A hand-written file opts out with the skip marker (#2519).
-        const head = readFileSync(fullPath, "utf-8").slice(0, 1024);
-        if (head.slice(0, 256).includes(GENERATED_MARKER) || hasSkipMarker(head)) {
-          continue;
-        }
-        files.push(fullPath);
-      }
-    }
-  }
-
-  scan(dir);
-  scanOut?.raw.push(...files);
-  return filterGitIgnored(files, dir, scanOut?.ignored);
+async function getTypeScriptFiles(dir: string): Promise<string[]> {
+  // A missing or non-directory path fails here, as lint's own walk always did;
+  // the shared walk skips an unreadable directory in silence.
+  readdirSync(dir);
+  return walkDiscovery({
+    walker: "lint",
+    root: dir,
+    globs: await resolveDiscoveryGlobs(dir),
+    excludeDirs: await workspaceMemberDirs(dir),
+    followSymlinks: true,
+    accept: (name, full) => isSourceFileName(name) && !hasDiscoveryMarkerSync(full),
+  });
 }
 
 /**
@@ -723,13 +668,8 @@ export async function lintCommand(options: LintOptions): Promise<LintResult> {
     allRules = new Map([...allRules, ...pluginRules]);
   }
 
-  // Get all TypeScript files (scan scoped to the lint arg, git-ignored trees
-  // and the project's `exclude` globs dropped)
-  const scanned: TypeScriptScan = { raw: [], ignored: new Set() };
-  const files = getTypeScriptFiles(infraPath, compileDiscoveryFilter(await resolveDiscoveryGlobs(infraPath)), scanned);
-  // #2527's warning release: which of these the converged walker reads
-  // differently. `files` is today's list, unchanged.
-  await warnDiscoveryChanges({ walker: "lint", root: infraPath, files, lintIgnored: scanned });
+  // Get all TypeScript files, through the one discovery walk (#2527)
+  const files = await getTypeScriptFiles(infraPath);
 
   // Run lint — use per-file rules when overrides are present
   let diagnostics: LintDiagnostic[];

package/src/cli/commands/update.ts

@@ -1,6 +1,6 @@
 import { lexiconModulePath, lexiconNames } from "../../lexicon-module";
 import { existsSync, mkdirSync, writeFileSync, cpSync, readdirSync, statSync, readFileSync } from "fs";
-import { join, resolve } from "path";
+import { dirname, join, resolve } from "path";
 import { createRequire } from "module";
 import { formatSuccess, formatWarning, formatError } from "../format";
 import { loadChantConfig } from "../../config";
@@ -29,6 +29,15 @@ export interface UpdateResult {
   error?: string;
 }
 
+/**
+ * Where `chant update` writes a lexicon skill, relative to the project. The
+ * workspace drift check (#2541) compares these files with what the skills
+ * render to, so both read the path from here.
+ */
+export function skillFilePath(skillName: string): string {
+  return `skills/${skillName}/SKILL.md`;
+}
+
 /**
  * Copy directory contents recursively, filtering to .ts and .d.ts files
  */
@@ -170,9 +179,9 @@ export async function updateCommand(options: UpdateOptions): Promise<UpdateResul
         const skills = plugin.skills();
         if (skills.length > 0) {
           for (const skill of skills) {
-            const skillDir = join(projectDir, "skills", skill.name);
-            mkdirSync(skillDir, { recursive: true });
-            writeFileSync(join(skillDir, "SKILL.md"), skill.content);
+            const file = join(projectDir, skillFilePath(skill.name));
+            mkdirSync(dirname(file), { recursive: true });
+            writeFileSync(file, skill.content);
           }
           synced.push(`${plugin.name} skills (${skills.length})`);
         }

package/src/cli/commands/vendor.ts

@@ -76,7 +76,7 @@ export function contentHash(files: Map<string, Buffer>): string {
 // ── Source resolution → a { relpath → bytes } file set ──────────────────────
 
 /** Walk a local directory into a relpath→bytes map (or a single file). */
-function readLocal(absPath: string): Map<string, Buffer> {
+export function readLocal(absPath: string): Map<string, Buffer> {
   const files = new Map<string, Buffer>();
   const stat = statSync(absPath);
   if (stat.isFile()) {
@@ -135,12 +135,17 @@ export function scopeArchiveFiles(
 }
 
 async function resolveSource(entry: VendorEntry, manifestDir: string): Promise<Map<string, Buffer>> {
-  if (entry.source.type === "local") {
-    const abs = resolve(manifestDir, entry.source.path);
-    if (!existsSync(abs)) throw new Error(`local source not found: ${entry.source.path}`);
+  return resolveVendorSource(entry.source, manifestDir);
+}
+
+/** Resolve a vendor source (a local path, or an archive URL) to its file set. */
+export async function resolveVendorSource(source: VendorEntry["source"], manifestDir: string): Promise<Map<string, Buffer>> {
+  if (source.type === "local") {
+    const abs = resolve(manifestDir, source.path);
+    if (!existsSync(abs)) throw new Error(`local source not found: ${source.path}`);
     return readLocal(abs);
   }
-  return readArchive(entry.source.url, entry.source.subpath);
+  return readArchive(source.url, source.subpath);
 }
 
 // ── File I/O ────────────────────────────────────────────────────────────────
@@ -154,7 +159,7 @@ function writeFiles(targetDir: string, files: Map<string, Buffer>): void {
   }
 }
 
-function readTarget(targetDir: string): Map<string, Buffer> {
+export function readTarget(targetDir: string): Map<string, Buffer> {
   if (!existsSync(targetDir)) return new Map();
   return readLocal(targetDir);
 }

package/src/cli/handlers/__snapshots__/build-member.test.ts.snap

@@ -0,0 +1,38 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`a project outside any workspace (level 0) > the pipeline is the generator's output, unchanged 1`] = `
+"name: chant-components-staging
+
+on:
+  workflow_dispatch: {}
+
+env:
+  CHANT_ENV: staging
+
+jobs:
+  shared-alb:
+    runs-on: ubuntu-latest
+    container: node:22-slim
+    steps:
+      - uses: actions/checkout@v4
+      - run: chant run --components shared-alb --env staging --dump-outputs shared-alb.outputs.json
+      - name: Upload shared-alb outputs
+        uses: actions/upload-artifact@v4
+        with:
+          name: shared-alb-outputs
+          path: shared-alb.outputs.json
+  api:
+    runs-on: ubuntu-latest
+    needs:
+      - shared-alb
+    container: node:22-slim
+    steps:
+      - uses: actions/checkout@v4
+      - name: Download shared-alb outputs
+        uses: actions/download-artifact@v4
+        with:
+          name: shared-alb-outputs
+          path: .
+      - run: chant run --components api --env staging --seed-outputs shared-alb.outputs.json
+"
+`;

package/src/cli/handlers/build-member.test.ts

@@ -0,0 +1,127 @@
+/**
+ * `chant build --components --generate` inside a workspace member (#2542).
+ * Component discovery is stubbed with a fixed graph; the github generator is
+ * the real one, so the files checked here are what a user gets. A project
+ * outside any workspace is held to its old output byte for byte, and to a
+ * snapshot, since level 0 must not move (#2525).
+ */
+
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { DriverComponent } from "../../components/driver";
+import type { ComponentPipelineOptions } from "../../lexicon";
+import type { ParsedArgs } from "../registry";
+import { generateGithubPipeline } from "@intentius/chant-lexicon-github/components/generate-pipeline";
+import { twoMemberWorkspace } from "../../workspace/__fixtures__/two-member-workspace";
+
+const components: DriverComponent[] = [
+  { name: "shared-alb", dependsOn: [], deploy: [] },
+  { name: "api", dependsOn: ["shared-alb"], deploy: [] },
+];
+
+const received: (ComponentPipelineOptions | undefined)[] = [];
+vi.mock("../../components/cli-support", () => ({
+  generateComponentsPipeline: async (_path: string, _lexicon: string, options?: ComponentPipelineOptions) => {
+    received.push(options);
+    const { yaml, stages, jobs, env } = generateGithubPipeline(components, options);
+    return { success: true, yaml, stages, jobs, env };
+  },
+}));
+vi.mock("../../config", async () => {
+  const actual = await vi.importActual<typeof import("../../config")>("../../config");
+  return { ...actual, loadChantConfigUpward: async () => ({ config: {} }) };
+});
+
+const { runBuild } = await import("./build");
+
+function args(overrides: Partial<ParsedArgs>): ParsedArgs {
+  return {
+    command: "build",
+    path: ".",
+    format: "",
+    fix: false,
+    watch: false,
+    verbose: false,
+    help: false,
+    live: false,
+    components: true,
+    generate: "github",
+    ...overrides,
+  };
+}
+
+let repo: string;
+let logs: string[];
+beforeEach(() => {
+  received.length = 0;
+  logs = [];
+  vi.spyOn(console, "error").mockImplementation(() => {});
+  vi.spyOn(console, "log").mockImplementation((s: string) => {
+    logs.push(s);
+  });
+});
+afterEach(() => {
+  vi.restoreAllMocks();
+  rmSync(repo, { recursive: true, force: true });
+});
+
+describe("a project inside a workspace member", () => {
+  beforeEach(() => {
+    repo = twoMemberWorkspace();
+  });
+
+  test("the pipeline is written to the member's file at the repository root, filtered and recorded", async () => {
+    expect(await runBuild({ args: args({ path: join(repo, "services/api"), env: "staging" }), plugins: [], serializers: [] })).toBe(0);
+
+    expect(received[0]?.member).toEqual({ name: "api", dir: "services/api", file: ".github/workflows/chant-api-staging.yml" });
+    const file = join(repo, ".github/workflows/chant-api-staging.yml");
+    const text = readFileSync(file, "utf-8");
+    const [header, ...rest] = text.split("\n");
+    expect(header).toContain("Regenerate with: chant build --components --generate github --env staging");
+    expect(rest.join("\n")).toBe(generateGithubPipeline(components, { env: "staging", member: received[0]!.member }).yaml);
+    expect(text).toContain("working-directory: services/api");
+
+    const record = JSON.parse(readFileSync(join(repo, "services/api/.chant/generated.json"), "utf-8"));
+    expect(record.files).toEqual([{ path: ".github/workflows/chant-api-staging.yml", command: "chant build --components --generate github --env staging", env: "staging" }]);
+  });
+
+  test("two members write two files and never collide", async () => {
+    await runBuild({ args: args({ path: join(repo, "services/api"), env: "prod" }), plugins: [], serializers: [] });
+    await runBuild({ args: args({ path: join(repo, "apps/web"), env: "prod" }), plugins: [], serializers: [] });
+    expect(existsSync(join(repo, ".github/workflows/chant-api-prod.yml"))).toBe(true);
+    expect(existsSync(join(repo, ".github/workflows/chant-web-prod.yml"))).toBe(true);
+  });
+
+  test("--format json names the member and the file and writes nothing", async () => {
+    expect(await runBuild({ args: args({ path: join(repo, "apps/web"), env: "prod", format: "json" }), plugins: [], serializers: [] })).toBe(0);
+    const out = JSON.parse(logs.join("\n"));
+    expect(out).toMatchObject({ member: "web", file: ".github/workflows/chant-web-prod.yml", env: "prod" });
+    expect(existsSync(join(repo, ".github/workflows/chant-web-prod.yml"))).toBe(false);
+  });
+
+  test("an example project in a group is not a member, and gets the plain pipeline", async () => {
+    expect(await runBuild({ args: args({ path: join(repo, "examples/demo") }), plugins: [], serializers: [] })).toBe(0);
+    expect(received[0]).toEqual({ env: undefined });
+    expect(logs.join("\n")).toBe(generateGithubPipeline(components, {}).yaml);
+  });
+});
+
+describe("a project outside any workspace (level 0)", () => {
+  beforeEach(() => {
+    repo = realpathSync(mkdtempSync(join(tmpdir(), "chant-build-level0-")));
+    execFileSync("git", ["init", "-q"], { cwd: repo });
+  });
+
+  test("the pipeline is the generator's output, unchanged", async () => {
+    const output = join(repo, "pipeline.yml");
+    expect(await runBuild({ args: args({ path: repo, env: "staging", output }), plugins: [], serializers: [] })).toBe(0);
+    expect(received[0]).toEqual({ env: "staging" });
+    const text = readFileSync(output, "utf-8");
+    expect(text).toBe(generateGithubPipeline(components, { env: "staging" }).yaml);
+    expect(text).toMatchSnapshot();
+    expect(existsSync(join(repo, ".chant"))).toBe(false);
+  });
+});

package/src/cli/handlers/build.ts

@@ -6,6 +6,7 @@ import type { CommandContext } from "../registry";
 import { generateComponentsPipeline } from "../../components/cli-support";
 import { loadChantConfigUpward, type ChantConfig } from "../../config";
 import { resolveCliBuildParams, parseParamFlags } from "../build-params-cli";
+import { findWorkspaceRoot } from "../../project-root";
 
 /**
  * `chant build --components --generate <lexicon>` — generate mode (#563,
@@ -44,6 +45,33 @@ async function runGenerateComponents(ctx: CommandContext): Promise<number> {
     return 1;
   }
 
+  // A project inside a workspace member gets that member's pipeline (#2542):
+  // path-filtered, run in the member's directory, written to a file named
+  // after the member and recorded as the member's generated file. The
+  // workspace module loads only when a declaration was found, so a project
+  // outside any workspace generates exactly what it did before.
+  const found = findWorkspaceRoot(resolve(args.path));
+  let plan: import("../../workspace/member-pipeline").MemberComponentPlan | undefined;
+  let memberPipeline: typeof import("../../workspace/member-pipeline") | undefined;
+  if (found) {
+    memberPipeline = await import("../../workspace/member-pipeline");
+    try {
+      plan = memberPipeline.planMemberComponentPipeline({
+        projectDir: resolve(args.path),
+        found,
+        lexicon,
+        env: args.env,
+        promoteTo: args.promoteTo,
+        output: args.output,
+        params: args.param,
+        paramsFile: args.paramsFile,
+      });
+    } catch (err) {
+      console.error(formatError({ message: memberPipeline.describeError(err) }));
+      return 1;
+    }
+  }
+
   // Which lexicons support generate mode is a property of the loaded lexicon
   // plugins (those implementing `generateComponentPipeline`, #688), not a
   // hard-coded core list — `generateComponentsPipeline` returns a descriptive
@@ -51,7 +79,7 @@ async function runGenerateComponents(ctx: CommandContext): Promise<number> {
   const result = await generateComponentsPipeline(
     args.path,
     lexicon,
-    { env: args.env, ...(args.promoteTo ? { promoteTo: args.promoteTo } : {}) },
+    { env: args.env, ...(args.promoteTo ? { promoteTo: args.promoteTo } : {}), ...(plan ? { member: plan.member } : {}) },
     args.sandbox,
     paramsResolution.provenance,
   );
@@ -73,11 +101,17 @@ async function runGenerateComponents(ctx: CommandContext): Promise<number> {
           // generator's own resolution, forwarded rather than left for a
           // consumer to re-derive by parsing the YAML back (#2060).
           ...(result.env ? { env: result.env } : {}),
+          // A workspace member's pipeline (#2542): the member and the file
+          // the pipeline belongs in, relative to the repository root.
+          ...(plan ? { member: plan.member.name, file: plan.file } : {}),
         },
         null,
         2,
       ),
     );
+  } else if (plan && memberPipeline) {
+    memberPipeline.writeMemberComponentPipeline(plan, yaml);
+    console.error(formatSuccess(`wrote ${formatBold(plan.file)} for member ${formatBold(plan.member.name)}`));
   } else if (args.output) {
     const outputPath = resolve(args.output);
     mkdirSync(dirname(outputPath), { recursive: true });