@plainconceptsplatform/workflows 0.4.33 → 0.5.1

package/dist/route-processing.test.js

@@ -1,342 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { addRouteExclusion, excludedWorkerFiles, processRoutes, stripRouteFromClassifier, stripRouteFromRouter, } from "./route-processing.js";
-import { routeNames } from "./workflow-catalog.js";
-const ROUTER_YAML = `# header
-name: "All Work Router"
-
-on:
-  schedule:
-    - cron: "17 1 * * 1"
-    - cron: "43 3 * * *"
-    - cron: "0 6 * * *"
-    - cron: "*/5 * * * *"
-    - cron: "0 */2 * * *"
-    - cron: "29 7 * * *"
-
-  workflow_dispatch:
-    inputs:
-      operation:
-        description: "Operation to run"
-        required: true
-        type: choice
-        options:
-          - refine
-          - implement
-          - direct
-          - apply-review
-          - merge-gate
-          - audit
-          - propose
-          - audit-close
-          - cleanup-artifacts
-          - reconcile-bot-pr-runs
-          - stale-recovery
-          - validate
-
-jobs:
-  call-refine:
-    needs: [classify, authorize]
-    if: needs.classify.outputs.route == 'refine' && needs.authorize.outputs.trusted == 'true'
-    uses: ./.github/workflows/agent-refine.lock.yml
-    secrets:
-      OPENAI_API_KEY: \${{ secrets.OPENAI_API_KEY }}
-
-  call-implement:
-    needs: [classify, authorize]
-    if: needs.classify.outputs.route == 'implement' && needs.authorize.outputs.trusted == 'true'
-    uses: ./.github/workflows/agent-implement.lock.yml
-    secrets:
-      OPENAI_API_KEY: \${{ secrets.OPENAI_API_KEY }}
-
-  call-audit:
-    needs: classify
-    if: needs.classify.outputs.route == 'audit'
-    uses: ./.github/workflows/agent-audit.lock.yml
-    secrets:
-      OPENAI_API_KEY: \${{ secrets.OPENAI_API_KEY }}
-
-  call-propose:
-    needs: classify
-    if: needs.classify.outputs.route == 'propose'
-    uses: ./.github/workflows/agent-propose.lock.yml
-    secrets:
-      OPENAI_API_KEY: \${{ secrets.OPENAI_API_KEY }}
-
-  audit-close:
-    needs: classify
-    if: needs.classify.outputs.route == 'audit-close'
-    runs-on: ubuntu-latest
-`;
-const CLASSIFIER_SH = `#!/usr/bin/env bash
-set -euo pipefail
-
-readonly AUDIT_CRON="17 1 * * 1"
-readonly AUDIT_CLOSE_CRON="43 3 * * *"
-readonly CLEANUP_ARTIFACTS_CRON="0 6 * * *"
-readonly RECONCILE_BOT_PR_RUNS_CRON="*/5 * * * *"
-readonly STALE_RECOVERY_CRON="0 */2 * * *"
-readonly PROPOSE_CRON="29 7 * * *"
-
-classify_route() {
-  local route="none" error=""
-
-  case "\${EVENT:-}" in
-    schedule)
-      trigger_kind="scheduled"
-      case "\${SCHEDULE:-}" in
-        "\$AUDIT_CRON") route="audit" ;;
-        "\$AUDIT_CLOSE_CRON") route="audit-close" ;;
-        "\$CLEANUP_ARTIFACTS_CRON") route="cleanup-artifacts" ;;
-        "\$RECONCILE_BOT_PR_RUNS_CRON") route="reconcile-bot-pr-runs" ;;
-        "\$STALE_RECOVERY_CRON") route="stale-recovery" ;;
-        "\$PROPOSE_CRON") route="propose" ;;
-        *) error="no route for cron '\${SCHEDULE:-}'" ;;
-      esac
-      ;;
-
-    workflow_dispatch)
-      trigger_kind="manual"
-      case "\${OPERATION:-}" in
-        refine | implement | direct)
-          route="\${OPERATION}"
-          ;;
-        apply-review)
-          route="apply-review"
-          ;;
-        merge-gate)
-          route="merge-gate"
-          ;;
-        audit | propose)
-          route="\${OPERATION}"
-          trigger_kind="\${INPUT_TRIGGER_KIND:-manual}"
-          ;;
-        audit-close | cleanup-artifacts | reconcile-bot-pr-runs | stale-recovery | validate)
-          route="\${OPERATION}"
-          ;;
-        *)
-          error="unknown operation '\${OPERATION:-}'"
-          ;;
-      esac
-      ;;
-  esac
-
-  cat <<EOF
-route=\${route}
-error=\${error}
-EOF
-}
-
-if [ "\${BASH_SOURCE[0]}" = "\$0" ]; then
-  classify_route
-fi
-`;
-const MATRIX_SH = `#!/usr/bin/env bash
-set -euo pipefail
-
-echo "── Router wiring ─────────────────────────────────────────────────────────"
-for route in refine implement direct apply-review merge-gate audit propose bot-approve \\
-  audit-close cleanup-artifacts reconcile-bot-pr-runs stale-recovery validate; do
-  if grep -q "route == '\${route}'" "\$ROUTER_YML"; then
-    PASS=\$((PASS + 1))
-  else
-    FAIL=\$((FAIL + 1))
-    echo "FAIL: work-router.yml has no job for route '\${route}'" >&2
-  fi
-done
-
-while read -r operation; do
-  if grep -q "route == '\${operation}'" "\$ROUTER_YML"; then
-    PASS=\$((PASS + 1))
-  else
-    FAIL=\$((FAIL + 1))
-    echo "FAIL: dispatch operation '\${operation}' has no job in work-router.yml" >&2
-  fi
-done < <(sed -n '/^      operation:/,/^      issue-number:/p' "\$ROUTER_YML" | sed -n 's/^          - //p')
-
-echo
-if [ "\$FAIL" -eq 0 ]; then
-  echo "Route matrix: \${PASS} passed"
-else
-  echo "Route matrix: \${PASS} passed, \${FAIL} FAILED" >&2
-fi
-
-exit \$((FAIL > 0))
-`;
-describe("stripRouteFromRouter", () => {
-    it("removes the propose cron entry", () => {
-        const result = stripRouteFromRouter(ROUTER_YAML, "propose");
-        expect(result).not.toContain('cron: "29 7 * * *"');
-        expect(result).toContain('cron: "17 1 * * 1"');
-    });
-    it("removes the call-propose job block", () => {
-        const result = stripRouteFromRouter(ROUTER_YAML, "propose");
-        expect(result).not.toContain("call-propose");
-        expect(result).toContain("call-refine");
-        expect(result).toContain("call-audit");
-    });
-    it("removes propose from the dispatch options", () => {
-        const result = stripRouteFromRouter(ROUTER_YAML, "propose");
-        expect(result).not.toMatch(/^\s+- propose$/m);
-        expect(result).toMatch(/^\s+- refine$/m);
-        expect(result).toMatch(/^\s+- audit$/m);
-    });
-    it("removes the audit cron entry", () => {
-        const result = stripRouteFromRouter(ROUTER_YAML, "audit");
-        expect(result).not.toContain('cron: "17 1 * * 1"');
-        expect(result).toContain('cron: "29 7 * * *"');
-    });
-    it("removes the call-audit job block", () => {
-        const result = stripRouteFromRouter(ROUTER_YAML, "audit");
-        expect(result).not.toContain("call-audit");
-        expect(result).toContain("call-refine");
-    });
-    it("preserves the audit-close job when removing audit", () => {
-        const result = stripRouteFromRouter(ROUTER_YAML, "audit");
-        expect(result).toContain("audit-close");
-    });
-    it("does not modify the yaml when stripping a route that has no cron", () => {
-        const yamlWithoutCron = ROUTER_YAML.replace(/    - cron: "17 1 \* \* 1"\n/, "");
-        const result = stripRouteFromRouter(yamlWithoutCron, "audit");
-        expect(result).not.toContain("call-audit");
-    });
-});
-describe("stripRouteFromClassifier", () => {
-    it("removes the PROPOSE_CRON constant", () => {
-        const result = stripRouteFromClassifier(CLASSIFIER_SH, "propose");
-        expect(result).not.toContain('readonly PROPOSE_CRON');
-        expect(result).toContain('readonly AUDIT_CRON');
-    });
-    it("removes the propose schedule case", () => {
-        const result = stripRouteFromClassifier(CLASSIFIER_SH, "propose");
-        expect(result).not.toContain('"$PROPOSE_CRON") route="propose"');
-        expect(result).toContain('"$AUDIT_CRON") route="audit"');
-    });
-    it("removes the AUDIT_CRON constant", () => {
-        const result = stripRouteFromClassifier(CLASSIFIER_SH, "audit");
-        expect(result).not.toContain('readonly AUDIT_CRON');
-        expect(result).toContain('readonly PROPOSE_CRON');
-    });
-    it("removes the audit schedule case", () => {
-        const result = stripRouteFromClassifier(CLASSIFIER_SH, "audit");
-        expect(result).not.toContain('"$AUDIT_CRON") route="audit"');
-        expect(result).toContain('"$PROPOSE_CRON") route="propose"');
-    });
-    it("removes propose from the dispatch case union", () => {
-        const result = stripRouteFromClassifier(CLASSIFIER_SH, "propose");
-        expect(result).not.toContain("audit | propose)");
-        expect(result).toContain("audit)");
-    });
-});
-describe("addRouteExclusion", () => {
-    it("adds an exclusion assertion for the route", () => {
-        const result = addRouteExclusion(MATRIX_SH, "propose");
-        expect(result).toContain("excluded route 'propose'");
-        expect(result).toContain("propose correctly excluded from work-router.yml");
-    });
-    it("does not add the exclusion twice", () => {
-        const once = addRouteExclusion(MATRIX_SH, "propose");
-        const twice = addRouteExclusion(once, "propose");
-        const matchCount = (twice.match(/excluded route 'propose'/g) ?? []).length;
-        expect(matchCount).toBe(1);
-    });
-});
-describe("processRoutes", () => {
-    it("returns the same map when all routes are selected", () => {
-        const files = new Map([
-            ["work-router.yml", ROUTER_YAML],
-            ["classify-route.sh", CLASSIFIER_SH],
-            ["verify-route-matrix.sh", MATRIX_SH],
-        ]);
-        const result = processRoutes(files, [...routeNames]);
-        expect(result).toBe(files);
-    });
-    it("strips every worker route when no routes are selected", () => {
-        const files = new Map([
-            [".github/workflows/work-router.yml", ROUTER_YAML],
-            [".github/actions/classify-route/classify-route.sh", CLASSIFIER_SH],
-            [".github/actions/verify-route-matrix/verify-route-matrix.sh", MATRIX_SH],
-        ]);
-        const result = processRoutes(files, []);
-        const router = result.get(".github/workflows/work-router.yml");
-        expect(router).not.toContain("call-propose");
-        expect(router).not.toContain("call-audit");
-        expect(router).not.toContain("- propose");
-        expect(router).not.toContain("- refine");
-        const classifier = result.get(".github/actions/classify-route/classify-route.sh");
-        expect(classifier).toBe(CLASSIFIER_SH);
-        const matrix = result.get(".github/actions/verify-route-matrix/verify-route-matrix.sh");
-        expect(matrix).toContain("Route matrix: selected routes valid");
-        expect(matrix).toContain("for route in refine implement direct apply-review merge-gate audit propose");
-    });
-    it("strips propose from all three files when unselected", () => {
-        const files = new Map([
-            [".github/workflows/work-router.yml", ROUTER_YAML],
-            [".github/actions/classify-route/classify-route.sh", CLASSIFIER_SH],
-            [".github/actions/verify-route-matrix/verify-route-matrix.sh", MATRIX_SH],
-        ]);
-        const selectedRoutes = routeNames.filter((r) => r !== "propose");
-        const result = processRoutes(files, selectedRoutes);
-        const router = result.get(".github/workflows/work-router.yml");
-        expect(router).not.toContain("call-propose");
-        expect(router).not.toContain('cron: "29 7 * * *"');
-        expect(router).not.toMatch(/^\s+- propose$/m);
-        const classifier = result.get(".github/actions/classify-route/classify-route.sh");
-        expect(classifier).toBe(CLASSIFIER_SH);
-        const matrix = result.get(".github/actions/verify-route-matrix/verify-route-matrix.sh");
-        expect(matrix).toContain("for route in refine implement direct apply-review merge-gate audit");
-        expect(matrix).toContain("for route in propose");
-    });
-    it("strips audit from all three files when unselected", () => {
-        const files = new Map([
-            ["work-router.yml", ROUTER_YAML],
-            ["classify-route.sh", CLASSIFIER_SH],
-            ["verify-route-matrix.sh", MATRIX_SH],
-        ]);
-        const selectedRoutes = routeNames.filter((r) => r !== "audit");
-        const result = processRoutes(files, selectedRoutes);
-        const router = result.get("work-router.yml");
-        expect(router).not.toContain("call-audit");
-        expect(router).not.toContain('cron: "17 1 * * 1"');
-        const classifier = result.get("classify-route.sh");
-        expect(classifier).toBe(CLASSIFIER_SH);
-    });
-    it("processes multiple excluded routes at once", () => {
-        const files = new Map([
-            ["work-router.yml", ROUTER_YAML],
-            ["classify-route.sh", CLASSIFIER_SH],
-            ["verify-route-matrix.sh", MATRIX_SH],
-        ]);
-        const selectedRoutes = ["refine", "implement"];
-        const result = processRoutes(files, selectedRoutes);
-        const router = result.get("work-router.yml");
-        expect(router).toContain("call-refine");
-        expect(router).toContain("call-implement");
-        expect(router).not.toContain("call-audit");
-        expect(router).not.toContain("call-propose");
-    });
-});
-describe("excludedWorkerFiles", () => {
-    it("returns worker files for unselected routes", () => {
-        const selectedRoutes = ["refine", "implement"];
-        const excluded = excludedWorkerFiles(selectedRoutes);
-        expect(excluded.has("agent-refine.md")).toBe(false);
-        expect(excluded.has("agent-implement.md")).toBe(false);
-        expect(excluded.has("agent-audit.md")).toBe(true);
-        expect(excluded.has("agent-propose.md")).toBe(true);
-    });
-    it("returns an empty set when all routes are selected", () => {
-        const excluded = excludedWorkerFiles([...routeNames]);
-        expect(excluded.size).toBe(0);
-    });
-    it("returns all worker files when no routes are selected", () => {
-        const excluded = excludedWorkerFiles([]);
-        expect(excluded.size).toBe(7);
-        expect(excluded.has("agent-refine.md")).toBe(true);
-        expect(excluded.has("agent-implement.md")).toBe(true);
-        expect(excluded.has("agent-direct.md")).toBe(true);
-        expect(excluded.has("agent-apply-review.md")).toBe(true);
-        expect(excluded.has("agent-merge-gate.md")).toBe(true);
-        expect(excluded.has("agent-audit.md")).toBe(true);
-        expect(excluded.has("agent-propose.md")).toBe(true);
-    });
-});

package/dist/stack-defaults.d.ts

@@ -1,11 +0,0 @@
-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;

package/dist/stack-defaults.js

@@ -1,104 +0,0 @@
-export function generateStackDefaults(inspection) {
-    const hasDotnet = inspection.stackHints.solutionFiles.length > 0;
-    const hasNode = inspection.stackHints.pnpmLockfile;
-    const hasNodeOnly = hasNode && !hasDotnet;
-    let verifyCommands;
-    let repoRulesBase;
-    if (hasDotnet && hasNode) {
-        verifyCommands = ".NET: dotnet restore && dotnet build -c Release && dotnet test | Web: pnpm lint && pnpm test && pnpm build";
-        repoRulesBase = "Full-stack .NET + React/Next.js repository. Follow Clean Architecture layering: API → Application → Domain. Infrastructure implements Application ports. Do not reference EF Core or ASP.NET from Application. Frontend communicates exclusively via HTTP endpoints. Run both .NET and frontend verification.";
-    }
-    else if (hasDotnet) {
-        verifyCommands = "dotnet restore && dotnet build -c Release --no-restore && dotnet test";
-        repoRulesBase = ".NET repository using Clean Architecture. Follow layering: API → Application → Domain. Infrastructure implements Application ports. Do not reference EF Core or ASP.NET from Application.";
-    }
-    else {
-        verifyCommands = "pnpm verify";
-        repoRulesBase = "Node.js repository. Follow existing project conventions and import boundaries.";
-    }
-    return { verifyCommands, repoRulesBase, hasDotnet, hasNodeOnly };
-}
-export function injectStackEnv(content, defaults) {
-    let result = content;
-    if (result.includes("VERIFY_COMMANDS:")) {
-        result = result.replace(/  VERIFY_COMMANDS: ".*"/, `  VERIFY_COMMANDS: "${defaults.verifyCommands}"`);
-    }
-    else if (/^env:\n/m.test(result)) {
-        result = result.replace(/^env:\n/m, `env:\n  VERIFY_COMMANDS: "${defaults.verifyCommands}"\n`);
-    }
-    return result;
-}
-export function generateOpencodeCi(baseContent, inspection) {
-    let result = baseContent;
-    if (inspection.stackHints.solutionFiles.length > 0) {
-        const solutionPath = inspection.stackHints.solutionFiles[0].replaceAll("\\", "/");
-        const nugetSteps = `  - name: Cache NuGet packages
-    uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
-    with:
-      path: ~/.nuget/packages
-      key: nuget-\${{ runner.os }}-\${{ hashFiles('**/*.slnx', '**/Directory.Packages.props') }}
-      restore-keys: nuget-\${{ runner.os }}-
-
-  - name: Restore .NET dependencies
-    run: dotnet restore ${solutionPath}
-`;
-        result = insertBeforeMarker(result, nugetSteps, "  - name: Install workspace dependencies");
-    }
-    if (inspection.stackHints.openSpec) {
-        const openspecStep = `  - name: Install OpenSpec CLI
-    run: |
-      set -euo pipefail
-      npm install -g "@fission-ai/openspec@1.8.0"
-      openspec --version
-`;
-        result = insertBeforeMarker(result, openspecStep, "  - name: Install workspace dependencies");
-    }
-    if (inspection.stackHints.packageJson && !result.includes("--legacy-peer-deps")) {
-        result = result.replace(`      if ! npm install --prefix .opencode; then\n        echo "No plugin deps, skipping."\n        exit 0\n      fi`, `      if ! npm install --prefix .opencode; then\n        echo "::warning::Strict npm install failed on a peer conflict. Retrying with --legacy-peer-deps; check .opencode/package.json."\n        npm install --prefix .opencode --legacy-peer-deps\n      fi`);
-    }
-    return result;
-}
-function insertBeforeMarker(content, steps, marker) {
-    if (content.includes(marker)) {
-        return content.replace(marker, steps + marker);
-    }
-    return content + "\n" + steps;
-}
-export function generateOpencodeConfig(baseContent, inspection) {
-    try {
-        const config = JSON.parse(baseContent);
-        const hasDotnet = inspection.stackHints.solutionFiles.length > 0;
-        if (!hasDotnet && config.lsp !== undefined) {
-            delete config.lsp;
-        }
-        else if (hasDotnet && config.lsp === undefined) {
-            config.lsp = {
-                csharp: { disabled: true },
-                fsharp: { disabled: true },
-                razor: { disabled: true },
-            };
-        }
-        const agent = config.agent;
-        if (agent !== undefined) {
-            const agentEntry = agent["ci-workflow-agent"];
-            if (agentEntry !== undefined) {
-                let prompt = agentEntry.prompt ?? "";
-                if (hasDotnet) {
-                    if (!prompt.includes(".NET guardrails")) {
-                        prompt += "\n\n# .NET guardrails\nFollow Clean Architecture layering: API → Application → Domain. Infrastructure implements Application ports. Application must not reference EF Core or ASP.NET. Use Central Package Management (Directory.Packages.props). Build in Release mode for CI.";
-                    }
-                }
-                else {
-                    if (!prompt.includes("Node/React rules")) {
-                        prompt += "\n\n# Node/React rules\nFollow Feature-Sliced Design import boundaries. Use pnpm, never npm or yarn. All user-facing text must be i18n messages. TypeScript strict mode.";
-                    }
-                }
-                agentEntry.prompt = prompt;
-            }
-        }
-        return JSON.stringify(config, null, 2) + "\n";
-    }
-    catch {
-        return baseContent;
-    }
-}

package/dist/stack-defaults.test.d.ts

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