@plainconceptsplatform/workflows 0.5.1 → 0.16.0

package/dist/index.js

@@ -0,0 +1,273 @@
+#!/usr/bin/env node
+import { inspectRepository, parseVisibility, resolveVisibility } from "./repository-inspection.js";
+import { installCatalog, installedRoutes, installTemplate, isTemplateName, removeRouteFiles } from "./catalog-installation.js";
+import { formatCatalog, listCatalog, searchCatalog } from "./catalog-listing.js";
+import { packageVersion } from "./package-baseline.js";
+import { routeNames, templateNames } from "./workflow-catalog.js";
+import { runInteractive } from "./tui.js";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const HELP_TEXT = `Workflows CLI — install and update Plain Concepts Platform agentic workflows.
+
+Run with no arguments to launch the interactive TUI, the primary way to select and install
+workflows and templates:
+
+  npx @plainconceptsplatform/workflows
+
+Advanced (non-interactive) commands:
+
+Usage: workflows <command> [options]
+
+Commands:
+  (default)                                   Launch the interactive TUI for selecting and installing items.
+  init                                        Inspect the repository and report its stack and visibility.
+  add [routes] [--template <name>]            Install route workers and refresh every installed package file.
+  update                                      Alias for add: refresh what is installed to this package version.
+  remove <routes>                             Uninstall route workers and regenerate the router without them.
+  status                                      Print repository inspection as JSON.
+  list                                        List all available workflows and templates with install status.
+  search <query>                              Filter workflows and templates by name or description.
+
+Route names (positional arguments to add and remove):
+  ${routeNames.join(", ")}
+
+  add                                         Refresh installed files. In an empty repository: actions, router,
+                                              classifier, matrix, shared imports, opencode.ci.json and the compile
+                                              script, with no workers.
+  add implement refine                        Install those workers on top of the ones already installed.
+  add --template agentics-checks              Install the named template only.
+  add refine --template agentics-checks       Routes plus mandatory files plus the named template.
+  remove audit                                Uninstall the audit worker and drop it from the router.
+
+What an update does to a package-managed file:
+  The file is replaced with this version's, and its ownership header records the version.
+  In a worker (agent-*.md) the env: block at the top is yours: your values are kept, keys the
+  package added arrive with their defaults, keys only you defined stay. When the header records
+  the version you installed from, that release is fetched from npm and a value you never changed
+  follows the package when its default changes. The agent runner pool and the engine gateway URL
+  are kept as well. Everything else in the file is the package's.
+  A file whose ownership header was removed is yours and is left alone unless --force is passed.
+  Templates are yours after installation and are replaced only with --force.
+
+Options:
+  --dry-run                                   Print what add or update would change, write nothing.
+  --force                                     Also overwrite consumer-owned files and changed templates.
+  --baseline <path>                           Use this loops/ directory as the merge baseline instead of
+                                              fetching the installed version from npm. For rolling out a
+                                              version that is not published yet: without a baseline the
+                                              merge is two-way and keeps every consumer value, including
+                                              the package defaults the consumer never chose.
+  --template <name>                           Install a standalone template alongside or instead of routes.
+                                              Templates: ${templateNames.join(", ")}.
+  --visibility public|private                 Override repository visibility (init only).
+  --version                                   Print the package version.
+  -h, --help                                  Show this help text.
+
+Installed workflows are marked [x] when the corresponding .github/workflows/agent-*.md
+file exists relative to the current directory.`;
+export async function run(arguments_, repositoryPath = process.cwd()) {
+    const [command, ...options] = arguments_;
+    if (command === "--help" || command === "-h") {
+        console.log(HELP_TEXT);
+        return 0;
+    }
+    if (command === "--version" || command === "-v") {
+        console.log(await packageVersion());
+        return 0;
+    }
+    if (command === undefined) {
+        const force = options.includes("--force");
+        return runInteractive(repositoryPath, { force });
+    }
+    if (command === "list") {
+        const entries = await listCatalog({ installedPath: repositoryPath });
+        console.log(formatCatalog(entries));
+        return 0;
+    }
+    if (command === "search") {
+        if (options.length === 0 || options.length > 1)
+            return fail("search requires exactly one query argument.");
+        const allEntries = await listCatalog({ installedPath: repositoryPath });
+        const results = searchCatalog(allEntries, options[0]);
+        console.log(formatCatalog(results));
+        return 0;
+    }
+    if (command === "init") {
+        const visibility = readVisibilityOption(options);
+        if (visibility === "invalid")
+            return fail("--visibility must be public or private.");
+        const inspection = await inspectRepository(repositoryPath);
+        const resolvedVisibility = await resolveVisibility(repositoryPath, visibility);
+        console.log(JSON.stringify({ command, inspection, visibility: resolvedVisibility }, null, 2));
+        return 0;
+    }
+    if (command === "status") {
+        const inspection = await inspectRepository(repositoryPath);
+        console.log(JSON.stringify({ command, inspection }, null, 2));
+        return 0;
+    }
+    if (command === "add" || command === "update") {
+        const parsed = parseAddOptions(options);
+        if (parsed.kind === "invalid")
+            return fail(parsed.message);
+        const inspection = await inspectRepository(repositoryPath);
+        const { routes, template, force, dryRun } = parsed;
+        const baseline = localBaseline(parsed.baseline);
+        const allConflicts = [];
+        const allInstalled = [];
+        let catalog;
+        const templatesPlanned = [];
+        // The installed set is always part of the target set: adding a route never drops another,
+        // and a plain update refreshes exactly what is there.
+        if (routes.length > 0 || template === undefined) {
+            const selectedRoutes = unionRoutes(routes, await installedRoutes(repositoryPath));
+            catalog = await installCatalog(repositoryPath, { force, dryRun, selectedRoutes, inspection, baseline });
+            allConflicts.push(...catalog.conflicts);
+            allInstalled.push(...catalog.installed);
+        }
+        if (template !== undefined) {
+            if (dryRun) {
+                templatesPlanned.push(template);
+            }
+            else {
+                const result = await installTemplate(repositoryPath, template, { force, inspection });
+                allConflicts.push(...result.conflicts);
+                allInstalled.push(...result.installed);
+            }
+        }
+        if (allConflicts.length > 0 && !force) {
+            console.error(`Template conflicts found. Re-run with --force to overwrite consumer-owned copies:\n${allConflicts.join("\n")}`);
+            return 1;
+        }
+        console.log(JSON.stringify({
+            command,
+            dryRun,
+            ...(catalog === undefined ? {} : summarize(catalog)),
+            ...(templatesPlanned.length > 0 ? { templatesPlanned } : {}),
+            installed: allInstalled.sort(),
+            conflicts: allConflicts,
+        }, null, 2));
+        return 0;
+    }
+    if (command === "remove") {
+        const parsed = parseAddOptions(options);
+        if (parsed.kind === "invalid")
+            return fail(parsed.message);
+        if (parsed.template !== undefined)
+            return fail("remove does not accept --template.");
+        if (parsed.routes.length === 0)
+            return fail("remove requires at least one route.");
+        const inspection = await inspectRepository(repositoryPath);
+        const installed = await installedRoutes(repositoryPath);
+        const desiredRoutes = installed.filter((route) => !parsed.routes.includes(route));
+        const result = await installCatalog(repositoryPath, { force: parsed.force, dryRun: parsed.dryRun, selectedRoutes: desiredRoutes, inspection, baseline: localBaseline(parsed.baseline) });
+        const removed = parsed.dryRun
+            ? parsed.routes.filter((route) => installed.includes(route)).map((route) => `.github/workflows/agent-${route}.md`)
+            : await removeRouteFiles(repositoryPath, parsed.routes);
+        console.log(JSON.stringify({ command, dryRun: parsed.dryRun, ...summarize(result), installed: [...result.installed].sort(), removed, conflicts: result.conflicts }, null, 2));
+        return 0;
+    }
+    return fail(`Unknown command: ${command}`);
+}
+function summarize(result) {
+    return {
+        packageVersion: result.packageVersion,
+        installedVersions: result.installedVersions,
+        upToDate: result.upToDate,
+        baselines: result.baselines,
+        changes: result.changes.filter((change) => change.status !== "unchanged"),
+        unchanged: result.changes.filter((change) => change.status === "unchanged").length,
+    };
+}
+// A fixed baseline for every recorded version, instead of asking npm. Rolling out a version that
+// is not published yet leaves the merge two-way, which keeps every consumer value, including the
+// package defaults a consumer never chose and would rather have replaced.
+function localBaseline(path) {
+    if (path === undefined)
+        return undefined;
+    const resolved = resolve(path);
+    return async () => resolved;
+}
+function unionRoutes(requested, installed) {
+    const result = [...requested];
+    for (const route of installed) {
+        if (!result.includes(route))
+            result.push(route);
+    }
+    return result;
+}
+function readVisibilityOption(options) {
+    if (options.length === 0)
+        return undefined;
+    if (options.length !== 2 || options[0] !== "--visibility")
+        return "invalid";
+    return parseVisibility(options[1]) ?? "invalid";
+}
+const TEMPLATE_NAMES = templateNames.join("|");
+function parseAddOptions(options) {
+    const routes = [];
+    let template;
+    let templateSeen = false;
+    let force = false;
+    let dryRun = false;
+    let baseline;
+    let i = 0;
+    while (i < options.length) {
+        const token = options[i];
+        if (token === "--force") {
+            force = true;
+            i++;
+            continue;
+        }
+        if (token === "--dry-run") {
+            dryRun = true;
+            i++;
+            continue;
+        }
+        if (token === "--baseline") {
+            if (i + 1 >= options.length)
+                return invalid("--baseline requires a path.");
+            baseline = options[i + 1];
+            i += 2;
+            continue;
+        }
+        if (token === "--template") {
+            if (templateSeen)
+                return invalid("--template can only be specified once.");
+            templateSeen = true;
+            if (i + 1 >= options.length)
+                return invalid("--template requires a name.");
+            const name = options[i + 1];
+            if (!isTemplateName(name))
+                return invalid(`--template must be one of: ${TEMPLATE_NAMES}.`);
+            template = name;
+            i += 2;
+            continue;
+        }
+        if (token.startsWith("--")) {
+            return invalid(`Unknown option: ${token}`);
+        }
+        if (routeNames.includes(token)) {
+            const route = token;
+            if (routes.includes(route))
+                return invalid(`Duplicate route: ${route}.`);
+            routes.push(route);
+            i++;
+            continue;
+        }
+        return invalid(`Unknown route: ${token}. Valid routes: ${routeNames.join(", ")}.`);
+    }
+    return { kind: "ok", routes, template, force, dryRun, baseline };
+}
+function invalid(message) {
+    return { kind: "invalid", message };
+}
+function fail(message) {
+    console.error(message);
+    return 1;
+}
+if (process.argv[1] !== undefined && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    void run(process.argv.slice(2)).then((exitCode) => {
+        process.exitCode = exitCode;
+    });
+}

package/dist/package-baseline.d.ts

@@ -0,0 +1,25 @@
+export declare const PACKAGE_NAME = "@plainconceptsplatform/workflows";
+export declare function packageVersion(): Promise<string>;
+export declare function isValidVersion(version: string): boolean;
+export declare function hasOwnershipHeader(content: string): boolean;
+/** The version recorded in a file's ownership header, or undefined for an unstamped file. */
+export declare function installedVersion(content: string): string | undefined;
+/** Write the version into the ownership header. Re-stamping replaces the previous version. */
+export declare function stampVersion(content: string, version: string): string;
+export type BaselineFetcher = (version: string) => Promise<string | undefined>;
+export interface FetchBaselineOptions {
+    /** Where fetched releases are kept between runs. Defaults to the OS temp directory. */
+    readonly cacheRoot?: string;
+    /** Runs a shell command. Injected by tests. */
+    readonly run?: (command: string) => Promise<void>;
+}
+/**
+ * The `loops/` directory of a published release, or undefined when it cannot be had
+ * (offline, unpublished version). The caller falls back to a two-way merge.
+ */
+export declare function fetchBaseline(version: string, options?: FetchBaselineOptions): Promise<string | undefined>;
+/**
+ * Unpack a gzipped ustar/pax archive (what `npm pack` produces) into a directory. Regular files
+ * and directories only; anything that would escape the destination is skipped.
+ */
+export declare function extractTarball(archive: Buffer, destination: string): void;

package/dist/package-baseline.js

@@ -0,0 +1,138 @@
+// Every installed file carries the package version in its ownership header, stamped at
+// install time. That version is the baseline an update merges against: the CLI fetches that
+// exact release from npm and reads the file as it was when the consumer installed it.
+import { exec as execCallback } from "node:child_process";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { access, mkdir, readdir, readFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { gunzipSync } from "node:zlib";
+const exec = promisify(execCallback);
+export const PACKAGE_NAME = "@plainconceptsplatform/workflows";
+const HEADER = `Managed by ${PACKAGE_NAME}`;
+const VERSION = "\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z.-]+)?";
+const STAMPED = new RegExp(`${escapeRegex(HEADER)}@(${VERSION})\\.`);
+const UNSTAMPED = new RegExp(`${escapeRegex(HEADER)}\\.`);
+export async function packageVersion() {
+    const manifest = fileURLToPath(new URL("../package.json", import.meta.url));
+    const { version } = JSON.parse(await readFile(manifest, "utf8"));
+    return version;
+}
+export function isValidVersion(version) {
+    return new RegExp(`^${VERSION}$`).test(version);
+}
+export function hasOwnershipHeader(content) {
+    return content.includes(HEADER);
+}
+/** The version recorded in a file's ownership header, or undefined for an unstamped file. */
+export function installedVersion(content) {
+    return STAMPED.exec(content)?.[1];
+}
+/** Write the version into the ownership header. Re-stamping replaces the previous version. */
+export function stampVersion(content, version) {
+    if (STAMPED.test(content))
+        return content.replace(STAMPED, `${HEADER}@${version}.`);
+    return content.replace(UNSTAMPED, `${HEADER}@${version}.`);
+}
+/**
+ * The `loops/` directory of a published release, or undefined when it cannot be had
+ * (offline, unpublished version). The caller falls back to a two-way merge.
+ */
+export async function fetchBaseline(version, options = {}) {
+    if (!isValidVersion(version))
+        return undefined;
+    const root = options.cacheRoot ?? join(tmpdir(), "plainconceptsplatform-workflows");
+    const directory = join(root, version);
+    const loops = join(directory, "package", "loops");
+    if (await exists(loops))
+        return loops;
+    const run = options.run ?? (async (command) => { await exec(command, { windowsHide: true }); });
+    try {
+        await mkdir(directory, { recursive: true });
+        // npm honours the user's registry configuration, which a direct download would not.
+        let tarball = await findTarball(directory);
+        if (tarball === undefined) {
+            await run(`npm pack "${PACKAGE_NAME}@${version}" --pack-destination "${directory}" --silent`);
+            tarball = await findTarball(directory);
+        }
+        if (tarball === undefined)
+            return undefined;
+        // Extracted here rather than by a `tar` binary: the one on PATH may be GNU tar under
+        // MSYS, which reads `C:\...` as a remote host, or missing altogether.
+        extractTarball(await readFile(join(directory, tarball)), directory);
+        return (await exists(loops)) ? loops : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function findTarball(directory) {
+    return (await readdir(directory)).find((file) => file.endsWith(".tgz"));
+}
+/**
+ * Unpack a gzipped ustar/pax archive (what `npm pack` produces) into a directory. Regular files
+ * and directories only; anything that would escape the destination is skipped.
+ */
+export function extractTarball(archive, destination) {
+    const data = gunzipSync(archive);
+    const field = (block, start, length) => {
+        const raw = block.subarray(start, start + length);
+        const end = raw.indexOf(0);
+        return raw.subarray(0, end === -1 ? raw.length : end).toString("utf8");
+    };
+    let offset = 0;
+    let longName;
+    while (offset + 512 <= data.length) {
+        const header = data.subarray(offset, offset + 512);
+        offset += 512;
+        if (header.every((byte) => byte === 0))
+            break;
+        const size = Number.parseInt(field(header, 124, 12).trim() || "0", 8);
+        const type = field(header, 156, 1) || "0";
+        const body = data.subarray(offset, offset + size);
+        offset += Math.ceil(size / 512) * 512;
+        if (type === "x" || type === "g") {
+            // pax extended header: records of the form "<length> key=value\n"; `path` names the next entry.
+            for (const record of body.toString("utf8").split("\n")) {
+                const match = /^\d+ path=(.*)$/.exec(record);
+                if (match !== null && type === "x")
+                    longName = match[1];
+            }
+            continue;
+        }
+        if (type === "L") {
+            longName = body.toString("utf8").replace(/\0+$/, "");
+            continue;
+        }
+        const prefix = field(header, 345, 155);
+        const shortName = field(header, 0, 100);
+        const name = longName ?? (prefix === "" ? shortName : `${prefix}/${shortName}`);
+        longName = undefined;
+        const parts = name.split("/").filter((part) => part !== "" && part !== ".");
+        if (parts.length === 0 || parts.includes(".."))
+            continue;
+        const target = join(destination, ...parts);
+        if (type === "5") {
+            mkdirSync(target, { recursive: true });
+        }
+        else if (type === "0") {
+            mkdirSync(dirname(target), { recursive: true });
+            writeFileSync(target, body);
+        }
+    }
+}
+async function exists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/repository-inspection.d.ts

@@ -0,0 +1,23 @@
+export type RepositoryVisibility = "public" | "private";
+export type VisibilitySource = "argument" | "environment" | "github" | "fallback";
+export interface StackHints {
+    readonly packageJson: boolean;
+    readonly pnpmLockfile: boolean;
+    readonly solutionFiles: readonly string[];
+    readonly openSpec: boolean;
+}
+export interface RepositoryInspection {
+    readonly repositoryPath: string;
+    readonly existingAgentWorkflows: readonly string[];
+    readonly stackHints: StackHints;
+}
+export interface VisibilityResolution {
+    readonly value: RepositoryVisibility;
+    readonly source: VisibilitySource;
+}
+export interface CommandRunner {
+    readonly run: (command: string, arguments_: readonly string[], cwd: string) => Promise<string>;
+}
+export declare function inspectRepository(repositoryPath: string): Promise<RepositoryInspection>;
+export declare function resolveVisibility(repositoryPath: string, override: RepositoryVisibility | undefined, environment?: NodeJS.ProcessEnv, commandRunner?: CommandRunner): Promise<VisibilityResolution>;
+export declare function parseVisibility(value: string | undefined): RepositoryVisibility | undefined;

package/dist/repository-inspection.js

@@ -0,0 +1,113 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { access, readdir, stat } from "node:fs/promises";
+import { constants } from "node:fs";
+import { join } from "node:path";
+const execFileAsync = promisify(execFile);
+const defaultCommandRunner = {
+    async run(command, arguments_, cwd) {
+        const { stdout } = await execFileAsync(command, arguments_, { cwd, windowsHide: true });
+        return stdout;
+    },
+};
+export async function inspectRepository(repositoryPath) {
+    const workflowsPath = join(repositoryPath, ".github", "workflows");
+    const workflowEntries = await readDirectoryNames(workflowsPath);
+    const solutionFiles = await findSolutionFiles(repositoryPath);
+    return {
+        repositoryPath,
+        existingAgentWorkflows: workflowEntries.filter((entry) => /^agent-.*\.md$/i.test(entry)).sort(),
+        stackHints: {
+            packageJson: await pathExists(join(repositoryPath, "package.json")),
+            pnpmLockfile: await pathExists(join(repositoryPath, "pnpm-lock.yaml")),
+            solutionFiles,
+            openSpec: await isDirectory(join(repositoryPath, "openspec")),
+        },
+    };
+}
+export async function resolveVisibility(repositoryPath, override, environment = process.env, commandRunner = defaultCommandRunner) {
+    if (override !== undefined)
+        return { value: override, source: "argument" };
+    const environmentOverride = parseVisibility(environment.PLATFORM_WORKFLOWS_VISIBILITY);
+    if (environmentOverride !== undefined)
+        return { value: environmentOverride, source: "environment" };
+    try {
+        const output = await commandRunner.run("gh", ["repo", "view", "--json", "visibility"], repositoryPath);
+        const visibility = parseVisibilityFromGitHub(output);
+        if (visibility !== undefined)
+            return { value: visibility, source: "github" };
+    }
+    catch {
+        // GitHub CLI is optional. Initializing a local repository must still work offline.
+    }
+    return { value: "private", source: "fallback" };
+}
+export function parseVisibility(value) {
+    return value === "public" || value === "private" ? value : undefined;
+}
+async function findSolutionFiles(repositoryPath) {
+    const results = [];
+    await scanForSlnx(repositoryPath, "", results, 0);
+    return results.sort();
+}
+const MAX_DEPTH = 5;
+const SKIP_DIRS = new Set(["node_modules", ".git", ".next", "dist", "out", "build", ".turbo", ".cache"]);
+async function scanForSlnx(root, relativePath, results, depth) {
+    if (depth >= MAX_DEPTH)
+        return;
+    const currentPath = join(root, relativePath);
+    let entries;
+    try {
+        entries = await readdir(currentPath, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            if (SKIP_DIRS.has(entry.name))
+                continue;
+            await scanForSlnx(root, join(relativePath, entry.name), results, depth + 1);
+        }
+        else if (entry.isFile() && entry.name.endsWith(".slnx")) {
+            results.push(relativePath === "" ? entry.name : join(relativePath, entry.name));
+        }
+    }
+}
+async function pathExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function isDirectory(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function readDirectoryNames(path) {
+    try {
+        return await readdir(path);
+    }
+    catch {
+        return [];
+    }
+}
+function parseVisibilityFromGitHub(output) {
+    try {
+        const parsed = JSON.parse(output);
+        if (typeof parsed !== "object" || parsed === null || !("visibility" in parsed))
+            return undefined;
+        const { visibility } = parsed;
+        return typeof visibility === "string" ? parseVisibility(visibility.toLowerCase()) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/route-processing.d.ts

@@ -0,0 +1,4 @@
+import { type RouteName } from "./workflow-catalog.js";
+export declare function stripRouteFromRouter(yaml: string, route: RouteName): string;
+export declare function processRoutes(files: Map<string, string>, selectedRoutes: readonly RouteName[]): Map<string, string>;
+export declare function excludedWorkerFiles(selectedRoutes: readonly RouteName[]): Set<string>;

package/dist/route-processing.js

@@ -0,0 +1,80 @@
+import { routeNames, workflowRoutes } from "./workflow-catalog.js";
+// The router is the one derived file: its content is a function of the installed route set.
+// The classifier stays the complete pure function (a route with no job is a no-op run), and the
+// route matrix reads the installed worker files, so neither is rewritten here.
+const routeCrons = {
+    audit: "17 1 * * 1",
+};
+// Deterministic router jobs that exist only to serve one worker route. They leave with it, or
+// the route matrix finds a `route == 'implement'` guard in a router with no implement worker.
+const routeHelperJobs = {
+    implement: ["check-implement-pr"],
+    triage: ["dispatch-triage"],
+};
+export function stripRouteFromRouter(yaml, route) {
+    let result = yaml;
+    const cron = routeCrons[route];
+    if (cron !== undefined) {
+        result = result.replace(new RegExp(`^    - cron: "${escapeRegex(cron)}"\\n`, "gm"), "");
+    }
+    for (const job of [`call-${route}`, ...(routeHelperJobs[route] ?? [])]) {
+        result = removeJobBlock(result, job);
+    }
+    result = result.replace(new RegExp(`^          - ${escapeRegex(route)}\\n`, "gm"), "");
+    return result;
+}
+export function processRoutes(files, selectedRoutes) {
+    const excludedRoutes = routeNames.filter((r) => !selectedRoutes.includes(r));
+    if (excludedRoutes.length === 0)
+        return files;
+    const result = new Map(files);
+    const routerKey = findFileKey(result, "work-router.yml");
+    if (routerKey === undefined)
+        return result;
+    let router = result.get(routerKey);
+    for (const route of excludedRoutes) {
+        router = stripRouteFromRouter(router, route);
+    }
+    result.set(routerKey, router);
+    return result;
+}
+export function excludedWorkerFiles(selectedRoutes) {
+    return new Set(workflowRoutes
+        .filter((route) => !selectedRoutes.includes(route.name))
+        .map((route) => route.worker));
+}
+// Remove a top-level job (two-space indent) together with the comment lines that introduce it.
+// A job's comment describes that job; left behind it describes nothing.
+function removeJobBlock(yaml, jobName) {
+    const lines = yaml.split("\n");
+    const startPattern = new RegExp(`^  ${escapeRegex(jobName)}:`);
+    const result = [];
+    let skipping = false;
+    for (const line of lines) {
+        if (skipping) {
+            if (/^  \S/.test(line) || /^[^\s]/.test(line)) {
+                skipping = false;
+                result.push(line);
+            }
+        }
+        else if (startPattern.test(line)) {
+            while (result.length > 0 && /^  #/.test(result[result.length - 1]))
+                result.pop();
+            skipping = true;
+        }
+        else {
+            result.push(line);
+        }
+    }
+    return result.join("\n");
+}
+function findFileKey(files, endsWith) {
+    for (const key of files.keys()) {
+        if (key.endsWith(endsWith))
+            return key;
+    }
+    return undefined;
+}
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/stack-defaults.d.ts

@@ -0,0 +1,11 @@
+import type { RepositoryInspection } from "./repository-inspection.js";
+export interface StackDefaults {
+    readonly verifyCommands: string;
+    readonly repoRulesBase: string;
+    readonly hasDotnet: boolean;
+    readonly hasNodeOnly: boolean;
+}
+export declare function generateStackDefaults(inspection: RepositoryInspection): StackDefaults;
+export declare function injectStackEnv(content: string, defaults: StackDefaults): string;
+export declare function generateOpencodeCi(baseContent: string, inspection: RepositoryInspection): string;
+export declare function generateOpencodeConfig(baseContent: string, inspection: RepositoryInspection): string;