@plainconceptsplatform/workflows 0.1.2 → 0.2.0

package/dist/tui.js

@@ -0,0 +1,254 @@
+import * as readline from "node:readline";
+import { formatCatalog, listCatalog } from "./catalog-listing.js";
+import { installCatalog, installMandatoryFiles, installTemplate, isTemplateName } from "./catalog-installation.js";
+const ANSI = {
+    clear: "\x1b[2J",
+    home: "\x1b[H",
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    cyan: "\x1b[36m",
+    green: "\x1b[32m",
+    grey: "\x1b[90m",
+    white: "\x1b[37m",
+    hideCursor: "\x1b[?25l",
+    showCursor: "\x1b[?25h",
+};
+export function createSelectionState(entries) {
+    const selected = new Set(entries.filter((entry) => entry.installed).map((entry) => entry.name));
+    return {
+        allItems: entries,
+        visibleItems: entries,
+        selected,
+        cursor: 0,
+        filter: "",
+        status: "selecting",
+    };
+}
+export function fuzzyMatch(text, query) {
+    if (query === "")
+        return true;
+    const haystack = text.toLowerCase();
+    const needle = query.toLowerCase();
+    let needleIndex = 0;
+    for (let i = 0; i < haystack.length && needleIndex < needle.length; i++) {
+        if (haystack[i] === needle[needleIndex])
+            needleIndex++;
+    }
+    return needleIndex === needle.length;
+}
+export function filterItems(items, filter) {
+    if (filter === "")
+        return items;
+    return items.filter((entry) => fuzzyMatch(`${entry.name} ${entry.description}`, filter));
+}
+export function applyFilter(state, filter) {
+    const visibleItems = filterItems(state.allItems, filter);
+    const cursor = visibleItems.length === 0 ? 0 : Math.min(state.cursor, visibleItems.length - 1);
+    return { ...state, visibleItems, filter, cursor };
+}
+export function clearFilter(state) {
+    return applyFilter(state, "");
+}
+export function moveCursorUp(state) {
+    if (state.visibleItems.length === 0)
+        return state;
+    const cursor = state.cursor === 0 ? state.visibleItems.length - 1 : state.cursor - 1;
+    return { ...state, cursor };
+}
+export function moveCursorDown(state) {
+    if (state.visibleItems.length === 0)
+        return state;
+    const cursor = state.cursor === state.visibleItems.length - 1 ? 0 : state.cursor + 1;
+    return { ...state, cursor };
+}
+export function toggleSelection(state) {
+    if (state.visibleItems.length === 0)
+        return state;
+    const entry = state.visibleItems[state.cursor];
+    if (entry === undefined)
+        return state;
+    const selected = new Set(state.selected);
+    if (selected.has(entry.name)) {
+        selected.delete(entry.name);
+    }
+    else {
+        selected.add(entry.name);
+    }
+    return { ...state, selected };
+}
+export function submitSelection(state) {
+    return { ...state, status: "submitting" };
+}
+export function cancelSelection(state) {
+    return { ...state, status: "cancelled" };
+}
+export function getItemsToInstall(state, force = false) {
+    return state.allItems.filter((entry) => state.selected.has(entry.name) && (force || !entry.installed));
+}
+function renderEntry(entry, highlighted, checked) {
+    const indicator = highlighted ? `${ANSI.bold}${ANSI.white}>${ANSI.reset}` : " ";
+    if (checked) {
+        const checkbox = `${ANSI.green}[x]${ANSI.reset}`;
+        const name = highlighted ? `${ANSI.white}${ANSI.bold}${entry.name}${ANSI.reset}` : entry.name;
+        const desc = `${ANSI.dim} — ${entry.description}${ANSI.reset}`;
+        return `${indicator} ${checkbox} ${name}${desc}`;
+    }
+    const checkbox = `${ANSI.grey}[ ]${ANSI.reset}`;
+    const name = highlighted ? `${ANSI.white}${ANSI.bold}${entry.name}${ANSI.reset}` : entry.name;
+    const desc = `${ANSI.dim} — ${entry.description}${ANSI.reset}`;
+    return `${indicator} ${checkbox} ${name}${desc}`;
+}
+function render(state) {
+    const lines = [];
+    lines.push(`${ANSI.cyan}${ANSI.bold}Plain Concepts Platform — Agentic Workflows${ANSI.reset}`);
+    lines.push(`${ANSI.dim}Select items to install. Already-installed items are pre-checked.${ANSI.reset}`);
+    lines.push("");
+    if (state.filter) {
+        lines.push(`${ANSI.cyan}Filter:${ANSI.reset} ${state.filter}${ANSI.grey}█${ANSI.reset}`);
+    }
+    else {
+        lines.push(`${ANSI.dim}Type to filter, arrows to navigate, space to toggle, Enter to install${ANSI.reset}`);
+    }
+    lines.push("");
+    const routes = state.visibleItems.filter((entry) => entry.kind === "route");
+    const templates = state.visibleItems.filter((entry) => entry.kind === "template");
+    let index = 0;
+    if (routes.length > 0) {
+        lines.push(`${ANSI.cyan}Workflows${ANSI.reset}`);
+        for (const entry of routes) {
+            lines.push(renderEntry(entry, index === state.cursor, state.selected.has(entry.name)));
+            index++;
+        }
+        if (templates.length > 0)
+            lines.push("");
+    }
+    if (templates.length > 0) {
+        lines.push(`${ANSI.cyan}Templates${ANSI.reset}`);
+        for (const entry of templates) {
+            lines.push(renderEntry(entry, index === state.cursor, state.selected.has(entry.name)));
+            index++;
+        }
+    }
+    if (state.visibleItems.length === 0) {
+        lines.push(`${ANSI.grey}  No items match the filter.${ANSI.reset}`);
+    }
+    lines.push("");
+    lines.push(`${ANSI.grey}↑↓ navigate  space toggle  type to filter  Enter install  Esc clear filter  q quit${ANSI.reset}`);
+    process.stdout.write(`${ANSI.clear}${ANSI.home}${lines.join("\n")}\n`);
+}
+export async function runInteractive(repositoryPath, options = {}) {
+    const force = options.force ?? false;
+    if (process.stdin.isTTY !== true) {
+        const entries = await listCatalog({ installedPath: repositoryPath });
+        console.log(formatCatalog(entries));
+        console.log("");
+        console.log("Run with a TTY for an interactive selection screen, or use: workflows add [--template <name>] [--force]");
+        return 0;
+    }
+    const entries = await listCatalog({ installedPath: repositoryPath });
+    let state = createSelectionState(entries);
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdout.write(ANSI.hideCursor);
+    render(state);
+    return new Promise((resolve) => {
+        const onKeypress = (str, key) => {
+            if (key?.ctrl && key?.name === "c") {
+                cleanup();
+                resolve(0);
+                return;
+            }
+            if (str === "q" && state.filter === "" && !key?.ctrl && !key?.meta && !key?.shift) {
+                cleanup();
+                resolve(0);
+                return;
+            }
+            if (key?.name === "escape") {
+                state = clearFilter(state);
+                render(state);
+                return;
+            }
+            if (key?.name === "up") {
+                state = moveCursorUp(state);
+                render(state);
+                return;
+            }
+            if (key?.name === "down") {
+                state = moveCursorDown(state);
+                render(state);
+                return;
+            }
+            if (key?.name === "space" || str === " ") {
+                state = toggleSelection(state);
+                render(state);
+                return;
+            }
+            if (key?.name === "return" || key?.name === "enter") {
+                cleanup();
+                void installSelected(state, repositoryPath, force).then((exitCode) => resolve(exitCode));
+                return;
+            }
+            if (key?.name === "backspace") {
+                state = applyFilter(state, state.filter.slice(0, -1));
+                render(state);
+                return;
+            }
+            if (str !== undefined &&
+                str.length === 1 &&
+                str >= " " &&
+                str <= "~" &&
+                !key?.ctrl &&
+                !key?.meta) {
+                state = applyFilter(state, state.filter + str);
+                render(state);
+            }
+        };
+        function cleanup() {
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+            process.stdout.write(`${ANSI.showCursor}${ANSI.reset}`);
+            process.stdin.removeListener("keypress", onKeypress);
+        }
+        process.stdin.on("keypress", onKeypress);
+    });
+}
+async function installSelected(state, repositoryPath, force) {
+    const items = getItemsToInstall(state, force);
+    const routes = items.filter((entry) => entry.kind === "route");
+    const templates = items.filter((entry) => entry.kind === "template");
+    const allConflicts = [];
+    const allInstalled = [];
+    if (routes.length > 0) {
+        const result = await installCatalog(repositoryPath, { force });
+        allConflicts.push(...result.conflicts);
+        allInstalled.push(...result.installed);
+    }
+    else {
+        const result = await installMandatoryFiles(repositoryPath, { force });
+        allConflicts.push(...result.conflicts);
+        allInstalled.push(...result.installed);
+    }
+    for (const template of templates) {
+        if (!isTemplateName(template.name))
+            continue;
+        const result = await installTemplate(repositoryPath, template.name, { force });
+        allConflicts.push(...result.conflicts);
+        allInstalled.push(...result.installed);
+    }
+    if (allConflicts.length > 0 && !force) {
+        console.error(`Conflicts found. Re-run with --force to overwrite:\n${allConflicts.join("\n")}`);
+        return 1;
+    }
+    if (allInstalled.length > 0) {
+        console.log(`Installed ${allInstalled.length} item(s):`);
+        for (const file of allInstalled) {
+            console.log(`  ${file}`);
+        }
+    }
+    else {
+        console.log("All selected items are already installed.");
+    }
+    return 0;
+}

package/dist/tui.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tui.test.js

@@ -0,0 +1,246 @@
+import { describe, expect, it } from "vitest";
+import { applyFilter, cancelSelection, clearFilter, createSelectionState, filterItems, fuzzyMatch, getItemsToInstall, moveCursorDown, moveCursorUp, submitSelection, toggleSelection, } from "./tui.js";
+function makeEntry(name, kind, installed = false) {
+    return {
+        kind,
+        name,
+        description: `${name} description`,
+        file: `${name}.md`,
+        installed,
+    };
+}
+function makeEntries(installed = []) {
+    const routes = ["refine", "implement", "direct", "apply-review", "merge-gate", "audit", "propose"];
+    const templates = ["agentics-checks", "agentics-maintenance", "app-ci-dotnet-next", "app-ci-node-monorepo", "opencode.ci.json"];
+    return [
+        ...routes.map((name) => makeEntry(name, "route", installed.includes(name))),
+        ...templates.map((name) => makeEntry(name, "template", installed.includes(name))),
+    ];
+}
+describe("createSelectionState", () => {
+    it("returns all items as visible initially", () => {
+        const entries = makeEntries();
+        const state = createSelectionState(entries);
+        expect(state.allItems).toHaveLength(12);
+        expect(state.visibleItems).toHaveLength(12);
+    });
+    it("pre-selects installed items", () => {
+        const entries = makeEntries(["refine", "agentics-checks"]);
+        const state = createSelectionState(entries);
+        expect(state.selected.has("refine")).toBe(true);
+        expect(state.selected.has("agentics-checks")).toBe(true);
+        expect(state.selected.has("implement")).toBe(false);
+    });
+    it("starts with no filter and cursor at 0", () => {
+        const state = createSelectionState(makeEntries());
+        expect(state.filter).toBe("");
+        expect(state.cursor).toBe(0);
+        expect(state.status).toBe("selecting");
+    });
+    it("pre-selects nothing when nothing is installed", () => {
+        const state = createSelectionState(makeEntries());
+        expect(state.selected.size).toBe(0);
+    });
+});
+describe("fuzzyMatch", () => {
+    it("returns true for empty query", () => {
+        expect(fuzzyMatch("anything", "")).toBe(true);
+    });
+    it("matches exact string", () => {
+        expect(fuzzyMatch("refine", "refine")).toBe(true);
+    });
+    it("matches subsequence characters", () => {
+        expect(fuzzyMatch("refine", "rfe")).toBe(true);
+    });
+    it("matches non-contiguous characters", () => {
+        expect(fuzzyMatch("app-ci-dotnet-next", "acdn")).toBe(true);
+    });
+    it("is case-insensitive", () => {
+        expect(fuzzyMatch("Refine", "REFINE")).toBe(true);
+        expect(fuzzyMatch("REFINE", "refine")).toBe(true);
+    });
+    it("returns false when characters are not in order", () => {
+        expect(fuzzyMatch("refine", "efinr")).toBe(false);
+    });
+    it("returns false when query has characters not in text", () => {
+        expect(fuzzyMatch("refine", "xyz")).toBe(false);
+    });
+    it("matches against full name + description with combined filter", () => {
+        const text = "agentics-checks Agentics checks: verifies generated agent lockfiles";
+        expect(fuzzyMatch(text, "acch")).toBe(true);
+    });
+});
+describe("filterItems", () => {
+    const entries = makeEntries();
+    it("returns all items when filter is empty", () => {
+        expect(filterItems(entries, "")).toHaveLength(12);
+    });
+    it("filters by name", () => {
+        const result = filterItems(entries, "refine");
+        expect(result).toHaveLength(1);
+        expect(result[0].name).toBe("refine");
+    });
+    it("filters by description", () => {
+        const result = filterItems(entries, "description");
+        expect(result).toHaveLength(12);
+    });
+    it("filters by fuzzy subsequence over name and description", () => {
+        const result = filterItems(entries, "acdn");
+        const names = result.map((e) => e.name);
+        expect(names).toContain("app-ci-dotnet-next");
+    });
+    it("returns empty when nothing matches", () => {
+        expect(filterItems(entries, "zzzzz")).toHaveLength(0);
+    });
+});
+describe("applyFilter", () => {
+    it("updates the filter and visibleItems", () => {
+        const state = createSelectionState(makeEntries());
+        const next = applyFilter(state, "refine");
+        expect(next.filter).toBe("refine");
+        expect(next.visibleItems.length).toBe(1);
+        expect(next.visibleItems[0].name).toBe("refine");
+    });
+    it("clamps cursor when result shrinks", () => {
+        const entries = makeEntries();
+        let state = createSelectionState(entries);
+        state = { ...state, cursor: 10 };
+        state = applyFilter(state, "ci");
+        expect(state.cursor).toBeLessThanOrEqual(Math.max(0, state.visibleItems.length - 1));
+        expect(state.cursor).toBeLessThan(state.visibleItems.length);
+    });
+    it("sets cursor to 0 when no results match", () => {
+        const state = applyFilter(createSelectionState(makeEntries()), "zzz");
+        expect(state.visibleItems).toHaveLength(0);
+        expect(state.cursor).toBe(0);
+    });
+    it("preserves selected set when filtering", () => {
+        const entries = makeEntries(["refine"]);
+        const state = applyFilter(createSelectionState(entries), "ref");
+        expect(state.selected.has("refine")).toBe(true);
+    });
+});
+describe("clearFilter", () => {
+    it("resets filter to empty and restores all items", () => {
+        let state = applyFilter(createSelectionState(makeEntries()), "ref");
+        state = clearFilter(state);
+        expect(state.filter).toBe("");
+        expect(state.visibleItems).toHaveLength(12);
+    });
+});
+describe("moveCursorUp / moveCursorDown", () => {
+    it("moves cursor down by one", () => {
+        const state = createSelectionState(makeEntries());
+        const next = moveCursorDown(state);
+        expect(next.cursor).toBe(1);
+    });
+    it("wraps cursor to top from bottom", () => {
+        const entries = makeEntries();
+        let state = createSelectionState(entries);
+        state = { ...state, cursor: entries.length - 1 };
+        state = moveCursorDown(state);
+        expect(state.cursor).toBe(0);
+    });
+    it("moves cursor up by one", () => {
+        const entries = makeEntries();
+        let state = createSelectionState(entries);
+        state = { ...state, cursor: 3 };
+        state = moveCursorUp(state);
+        expect(state.cursor).toBe(2);
+    });
+    it("wraps cursor to bottom from top", () => {
+        const state = moveCursorUp(createSelectionState(makeEntries()));
+        expect(state.cursor).toBe(11);
+    });
+    it("does not move when list is empty", () => {
+        const entries = [];
+        const state = createSelectionState(entries);
+        expect(moveCursorUp(state).cursor).toBe(0);
+        expect(moveCursorDown(state).cursor).toBe(0);
+    });
+    it("navigates within filtered results", () => {
+        let state = createSelectionState(makeEntries());
+        state = applyFilter(state, "ci");
+        state = moveCursorDown(state);
+        expect(state.cursor).toBe(1);
+        expect(state.cursor).toBeLessThan(state.visibleItems.length);
+    });
+});
+describe("toggleSelection", () => {
+    it("selects an unselected item at cursor", () => {
+        const state = createSelectionState(makeEntries());
+        expect(state.selected.has("refine")).toBe(false);
+        const next = toggleSelection(state);
+        expect(next.selected.has("refine")).toBe(true);
+    });
+    it("deselects a selected item at cursor", () => {
+        const entries = makeEntries(["refine"]);
+        const state = createSelectionState(entries);
+        expect(state.selected.has("refine")).toBe(true);
+        const next = toggleSelection(state);
+        expect(next.selected.has("refine")).toBe(false);
+    });
+    it("toggles the item at cursor position within filtered list", () => {
+        let state = createSelectionState(makeEntries());
+        state = applyFilter(state, "ci");
+        state = moveCursorDown(state);
+        const entryAtCursor = state.visibleItems[state.cursor];
+        const next = toggleSelection(state);
+        expect(next.selected.has(entryAtCursor.name)).toBe(true);
+    });
+    it("does nothing when list is empty", () => {
+        const state = createSelectionState([]);
+        const next = toggleSelection(state);
+        expect(next.selected.size).toBe(0);
+    });
+    it("does not change other selections", () => {
+        const entries = makeEntries(["refine", "audit"]);
+        const state = createSelectionState(entries);
+        const next = toggleSelection(state);
+        expect(next.selected.has("refine")).toBe(false);
+        expect(next.selected.has("audit")).toBe(true);
+    });
+});
+describe("submitSelection / cancelSelection", () => {
+    it("sets status to submitting", () => {
+        const state = submitSelection(createSelectionState(makeEntries()));
+        expect(state.status).toBe("submitting");
+    });
+    it("sets status to cancelled", () => {
+        const state = cancelSelection(createSelectionState(makeEntries()));
+        expect(state.status).toBe("cancelled");
+    });
+});
+describe("getItemsToInstall", () => {
+    it("returns empty when nothing is selected", () => {
+        const state = createSelectionState(makeEntries());
+        expect(getItemsToInstall(state)).toHaveLength(0);
+    });
+    it("returns only selected items that are not already installed", () => {
+        const entries = makeEntries(["refine"]);
+        let state = createSelectionState(entries);
+        state = { ...state, cursor: 1 };
+        state = toggleSelection(state);
+        const items = getItemsToInstall(state);
+        const names = items.map((e) => e.name);
+        expect(names).toContain("implement");
+        expect(names).not.toContain("refine");
+    });
+    it("returns already-installed items when force is true", () => {
+        const entries = makeEntries(["refine"]);
+        let state = createSelectionState(entries);
+        const items = getItemsToInstall(state, true);
+        const names = items.map((e) => e.name);
+        expect(names).toContain("refine");
+    });
+    it("includes both routes and templates", () => {
+        let state = createSelectionState(makeEntries());
+        state = toggleSelection(state);
+        state = { ...state, cursor: 7 };
+        state = toggleSelection(state);
+        const items = getItemsToInstall(state);
+        const kinds = items.map((e) => e.kind);
+        expect(kinds).toContain("route");
+        expect(kinds).toContain("template");
+    });
+});

package/dist/workflow-catalog.d.ts

@@ -3,15 +3,22 @@ export type RouteName = (typeof routeNames)[number];
 export interface WorkflowRoute {
     readonly name: RouteName;
     readonly worker: string;
+    readonly description: string;
     readonly defaultEnabled: boolean;
 }
 export declare const workflowRoutes: readonly WorkflowRoute[];
-export declare const packageOwnedTargets: readonly [".github/actions", ".github/workflows/agent-*.md", ".github/workflows/shared/platform-defaults.md", ".github/workflows/shared/opencode-ci.md", ".github/workflows/work-router.yml", "scripts/compile-agent-workflows.mjs"];
-export declare const consumerOwnedTargets: readonly [".github/workflows/shared/repo-config.md"];
-export declare const generatedConsumerTargets: readonly [".github/workflows/agent-*.lock.yml", ".github/workflows/agentics-maintenance.yml", ".github/aw/actions-lock.json"];
-export interface RepositoryConfigTemplate {
-    readonly repositoryVisibility: "private" | "public";
-    readonly verificationCommands: readonly string[];
-    readonly repositoryRules: readonly string[];
+export declare const packageOwnedTargets: readonly [".github/actions", ".github/workflows/agent-*.md", ".github/workflows/shared/platform-defaults.md", ".github/workflows/shared/opencode-ci.md", ".github/workflows/work-router.yml", "scripts/compile-agent-workflows.mjs", "opencode.ci.json"];
+export interface MandatoryFile {
+    readonly source: string;
+    readonly target: string;
 }
-export declare const defaultRepositoryConfig: RepositoryConfigTemplate;
+export declare const mandatoryFiles: readonly MandatoryFile[];
+export declare const generatedConsumerTargets: readonly [".github/workflows/agent-*.lock.yml", ".github/aw/actions-lock.json"];
+export declare const templateNames: readonly ["agentics-checks", "agentics-maintenance", "app-ci-dotnet-next", "app-ci-node-monorepo", "opencode.ci.json"];
+export type TemplateName = (typeof templateNames)[number];
+export interface CatalogTemplate {
+    readonly name: TemplateName;
+    readonly file: string;
+    readonly description: string;
+}
+export declare const catalogTemplates: readonly CatalogTemplate[];

package/dist/workflow-catalog.js

@@ -8,13 +8,13 @@ export const routeNames = [
     "propose",
 ];
 export const workflowRoutes = [
-    { name: "refine", worker: "agent-refine.md", defaultEnabled: true },
-    { name: "implement", worker: "agent-implement.md", defaultEnabled: true },
-    { name: "direct", worker: "agent-direct.md", defaultEnabled: true },
-    { name: "apply-review", worker: "agent-apply-review.md", defaultEnabled: true },
-    { name: "merge-gate", worker: "agent-merge-gate.md", defaultEnabled: true },
-    { name: "audit", worker: "agent-audit.md", defaultEnabled: true },
-    { name: "propose", worker: "agent-propose.md", defaultEnabled: false },
+    { name: "refine", worker: "agent-refine.md", description: "Refines an issue into a user story, on a first pass or after the author has answered the bot's questions.", defaultEnabled: true },
+    { name: "implement", worker: "agent-implement.md", description: "Implements an issue and opens a pull request. Stops there: the merge decision belongs to the merge gate.", defaultEnabled: true },
+    { name: "direct", worker: "agent-direct.md", description: "Executes a free-form instruction from an issue body and posts the results back on the same issue.", defaultEnabled: true },
+    { name: "apply-review", worker: "agent-apply-review.md", description: "Applies reviewer feedback to an open pull request the bot authored, then pushes the fixes to the same branch.", defaultEnabled: true },
+    { name: "merge-gate", worker: "agent-merge-gate.md", description: "Decides what happens to a bot-authored pull request once CI has reported: merge, hand to a human, or fix CI.", defaultEnabled: true },
+    { name: "audit", worker: "agent-audit.md", description: "Read-only repository audit. Finds 5-7 problems, scores each 1-10, files a single issue with the top 3 refined as actionable user stories.", defaultEnabled: true },
+    { name: "propose", worker: "agent-propose.md", description: "Proposes the next feature. Reads the manifesto, recent history, and comparable tools, scores candidates, and files the winner as a single issue.", defaultEnabled: false },
 ];
 export const packageOwnedTargets = [
     ".github/actions",
@@ -23,17 +23,27 @@ export const packageOwnedTargets = [
     ".github/workflows/shared/opencode-ci.md",
     ".github/workflows/work-router.yml",
     "scripts/compile-agent-workflows.mjs",
+    "opencode.ci.json",
 ];
-export const consumerOwnedTargets = [
-    ".github/workflows/shared/repo-config.md",
+export const mandatoryFiles = [
+    { source: "templates/opencode/opencode.ci.json", target: "opencode.ci.json" },
+    { source: "scripts/compile-agent-workflows.mjs", target: "scripts/compile-agent-workflows.mjs" },
 ];
 export const generatedConsumerTargets = [
     ".github/workflows/agent-*.lock.yml",
-    ".github/workflows/agentics-maintenance.yml",
     ".github/aw/actions-lock.json",
 ];
-export const defaultRepositoryConfig = {
-    repositoryVisibility: "private",
-    verificationCommands: [],
-    repositoryRules: [],
-};
+export const templateNames = [
+    "agentics-checks",
+    "agentics-maintenance",
+    "app-ci-dotnet-next",
+    "app-ci-node-monorepo",
+    "opencode.ci.json",
+];
+export const catalogTemplates = [
+    { name: "agentics-checks", file: "agentics-checks.yml", description: "Agentics checks: verifies generated agent lockfiles, actionlint, and compile on PRs touching workflow files." },
+    { name: "agentics-maintenance", file: "agentics-maintenance.yml", description: "Agentic maintenance: scheduled daily maintenance workflow for keeping workflows and actions up to date." },
+    { name: "app-ci-dotnet-next", file: "app-ci-dotnet-next.yml", description: "App CI pipeline for a .NET + Next.js monorepo: build, test, and lint on PRs and schedule." },
+    { name: "app-ci-node-monorepo", file: "app-ci-node-monorepo.yml", description: "App CI pipeline for a Node monorepo: build, test, and lint on PRs and schedule." },
+    { name: "opencode.ci.json", file: "opencode.ci.json", description: "Standalone OpenCode CI config: plainconcepts provider, GLM model registration, ci-workflow-agent, and LSP defaults for consumer repositories." },
+];

package/dist/workflow-catalog.test.js

@@ -1,14 +1,29 @@
 import { describe, expect, it } from "vitest";
-import { consumerOwnedTargets, generatedConsumerTargets, packageOwnedTargets, routeNames, workflowRoutes, } from "./workflow-catalog.js";
+import { catalogTemplates, generatedConsumerTargets, packageOwnedTargets, routeNames, templateNames, workflowRoutes, } from "./workflow-catalog.js";
 describe("workflow catalog", () => {
     it("assigns one worker to each route", () => {
         expect(workflowRoutes.map((route) => route.name)).toEqual(routeNames);
         expect(new Set(workflowRoutes.map((route) => route.worker)).size).toBe(workflowRoutes.length);
     });
-    it("keeps generated and consumer-owned files outside package ownership", () => {
+    it("gives every route a non-empty description", () => {
+        for (const route of workflowRoutes) {
+            expect(route.description.length).toBeGreaterThan(0);
+        }
+    });
+    it("keeps generated files outside package ownership", () => {
         const packageTargets = new Set(packageOwnedTargets);
-        for (const target of [...consumerOwnedTargets, ...generatedConsumerTargets]) {
+        for (const target of generatedConsumerTargets) {
             expect(packageTargets.has(target)).toBe(false);
         }
     });
+    it("lists supported optional templates", () => {
+        expect(templateNames).toEqual(["agentics-checks", "agentics-maintenance", "app-ci-dotnet-next", "app-ci-node-monorepo", "opencode.ci.json"]);
+    });
+    it("gives every catalog template a non-empty description and file", () => {
+        expect(catalogTemplates.map((template) => template.name)).toEqual([...templateNames]);
+        expect(new Set(catalogTemplates.map((template) => template.file)).size).toBe(catalogTemplates.length);
+        for (const template of catalogTemplates) {
+            expect(template.description.length).toBeGreaterThan(0);
+        }
+    });
 });