@plainconceptsplatform/workflows 0.4.34 → 0.5.1

package/dist/tui.test.js

@@ -1,246 +0,0 @@
-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", "triage", "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(13);
-        expect(state.visibleItems).toHaveLength(13);
-    });
-    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(13);
-    });
-    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(13);
-    });
-    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(13);
-    });
-});
-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(12);
-    });
-    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: 8 };
-        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

@@ -1,25 +0,0 @@
-export declare const routeNames: readonly ["refine", "implement", "direct", "triage", "apply-review", "merge-gate", "audit", "propose"];
-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", "opencode.ci.json"];
-export interface MandatoryFile {
-    readonly source: string;
-    readonly target: string;
-}
-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", "bug-report", "feature-request", "github-release", "opencode.ci.json", "visual-evidence"];
-export type TemplateName = (typeof templateNames)[number];
-export interface CatalogTemplate {
-    readonly name: TemplateName;
-    readonly file: string;
-    readonly description: string;
-    readonly target?: string;
-}
-export declare const catalogTemplates: readonly CatalogTemplate[];

package/dist/workflow-catalog.js

@@ -1,59 +0,0 @@
-export const routeNames = [
-    "refine",
-    "implement",
-    "direct",
-    "triage",
-    "apply-review",
-    "merge-gate",
-    "audit",
-    "propose",
-];
-export const workflowRoutes = [
-    { 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: "triage", worker: "agent-triage.md", description: "Triages issues opened by outside collaborators: runs 10 checks (template, security, size, danger, duplicates, clarity, reproducibility, acceptance, cross-cutting). Loops up to 3 rounds. Passes to refine or blocks.", 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",
-    ".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 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/aw/actions-lock.json",
-];
-export const templateNames = [
-    "agentics-checks",
-    "agentics-maintenance",
-    "app-ci-dotnet-next",
-    "app-ci-node-monorepo",
-    "bug-report",
-    "feature-request",
-    "github-release",
-    "opencode.ci.json",
-    "visual-evidence",
-];
-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: "bug-report", file: "bug_report.yml", description: "Bug report issue template: what happened, repro steps, expected behavior, acceptance criteria, environment, logs.", target: ".github/ISSUE_TEMPLATE/bug_report.yml" },
-    { name: "feature-request", file: "feature_request.yml", description: "Feature request issue template scoped to small, well-scoped improvements (Small/Medium only; large work belongs in a planning issue).", target: ".github/ISSUE_TEMPLATE/feature_request.yml" },
-    { name: "github-release", file: "github-release.yml", description: "Publishes or updates a GitHub Release with generated notes whenever a v* tag is pushed." },
-    { 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." },
-    { name: "visual-evidence", file: "visual-evidence.yml", description: "Visual evidence: captures screenshots of UI changes on bot-authored PRs by reading the capturePlan left by the agent in evidence.json and executing it on a runner with Docker and Chrome access." },
-];

package/dist/workflow-catalog.test.d.ts

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

package/dist/workflow-catalog.test.js

@@ -1,29 +0,0 @@
-import { describe, expect, it } from "vitest";
-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("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 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", "bug-report", "feature-request", "github-release", "opencode.ci.json", "visual-evidence"]);
-    });
-    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);
-        }
-    });
-});