@plainconceptsplatform/workflows 0.6.1 → 0.16.2

package/dist/route-processing.test.js

@@ -1,283 +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 * * *"
-
-  workflow_dispatch:
-    inputs:
-      operation:
-        description: "Operation to run"
-        required: true
-        type: choice
-        options:
-          - refine
-          - implement
-          - triage
-          - apply-review
-          - merge-gate
-          - audit
-          - 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-triage:
-    needs: [classify, authorize]
-    if: needs.classify.outputs.route == 'triage' && needs.authorize.outputs.is_outside_collaborator == 'true'
-    uses: ./.github/workflows/agent-triage.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 }}
-
-  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 * * *"
-
-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" ;;
-        *) error="no route for cron '\${SCHEDULE:-}'" ;;
-      esac
-      ;;
-
-    workflow_dispatch)
-      trigger_kind="manual"
-      case "\${OPERATION:-}" in
-        refine | implement)
-          route="\${OPERATION}"
-          ;;
-        apply-review)
-          route="apply-review"
-          ;;
-        merge-gate)
-          route="merge-gate"
-          ;;
-        audit)
-          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 triage apply-review merge-gate audit 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 audit cron entry", () => {
-        const result = stripRouteFromRouter(ROUTER_YAML, "audit");
-        expect(result).not.toContain('cron: "17 1 * * 1"');
-        expect(result).toContain('cron: "43 3 * * *"');
-    });
-    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 AUDIT_CRON constant", () => {
-        const result = stripRouteFromClassifier(CLASSIFIER_SH, "audit");
-        expect(result).not.toContain('readonly AUDIT_CRON');
-        expect(result).toContain('readonly AUDIT_CLOSE_CRON');
-    });
-    it("removes the audit schedule case", () => {
-        const result = stripRouteFromClassifier(CLASSIFIER_SH, "audit");
-        expect(result).not.toContain('"$AUDIT_CRON") route="audit"');
-        expect(result).toContain('"$AUDIT_CLOSE_CRON") route="audit-close"');
-    });
-});
-describe("addRouteExclusion", () => {
-    it("adds an exclusion assertion for the route", () => {
-        const result = addRouteExclusion(MATRIX_SH, "audit");
-        expect(result).toContain("excluded route 'audit'");
-        expect(result).toContain("audit correctly excluded from work-router.yml");
-    });
-    it("does not add the exclusion twice", () => {
-        const once = addRouteExclusion(MATRIX_SH, "audit");
-        const twice = addRouteExclusion(once, "audit");
-        const matchCount = (twice.match(/excluded route 'audit'/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-audit");
-        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 triage apply-review merge-gate audit");
-    });
-    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");
-    });
-});
-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);
-    });
-    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(6);
-        expect(excluded.has("agent-refine.md")).toBe(true);
-        expect(excluded.has("agent-implement.md")).toBe(true);
-        expect(excluded.has("agent-triage.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);
-    });
-});

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

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

package/dist/stack-defaults.test.js

@@ -1,266 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { generateOpencodeCi, generateOpencodeConfig, generateStackDefaults, injectStackEnv, } from "./stack-defaults.js";
-function makeInspection(overrides = {}) {
-    return {
-        repositoryPath: "/repo",
-        existingAgentWorkflows: [],
-        stackHints: {
-            packageJson: false,
-            pnpmLockfile: false,
-            solutionFiles: [],
-            openSpec: false,
-            ...overrides,
-        },
-    };
-}
-describe("generateStackDefaults", () => {
-    it("returns .NET verify commands when .slnx is found", () => {
-        const defaults = generateStackDefaults(makeInspection({
-            solutionFiles: ["app.slnx"],
-        }));
-        expect(defaults.verifyCommands).toBe("dotnet restore && dotnet build -c Release --no-restore && dotnet test");
-        expect(defaults.hasDotnet).toBe(true);
-        expect(defaults.hasNodeOnly).toBe(false);
-    });
-    it("returns pnpm verify when pnpm-lock.yaml is found without .slnx", () => {
-        const defaults = generateStackDefaults(makeInspection({
-            pnpmLockfile: true,
-        }));
-        expect(defaults.verifyCommands).toBe("pnpm verify");
-        expect(defaults.hasDotnet).toBe(false);
-        expect(defaults.hasNodeOnly).toBe(true);
-    });
-    it("returns both .NET and Web verify commands for a full-stack repo", () => {
-        const defaults = generateStackDefaults(makeInspection({
-            solutionFiles: ["app.slnx"],
-            pnpmLockfile: true,
-        }));
-        expect(defaults.verifyCommands).toContain(".NET");
-        expect(defaults.verifyCommands).toContain("dotnet restore");
-        expect(defaults.verifyCommands).toContain("dotnet build -c Release");
-        expect(defaults.verifyCommands).toContain("dotnet test");
-        expect(defaults.verifyCommands).toContain("Web");
-        expect(defaults.verifyCommands).toContain("pnpm lint");
-        expect(defaults.verifyCommands).toContain("pnpm test");
-        expect(defaults.verifyCommands).toContain("pnpm build");
-        expect(defaults.hasDotnet).toBe(true);
-        expect(defaults.hasNodeOnly).toBe(false);
-    });
-    it("returns pnpm verify when neither .slnx nor pnpm-lock.yaml is present", () => {
-        const defaults = generateStackDefaults(makeInspection());
-        expect(defaults.verifyCommands).toBe("pnpm verify");
-        expect(defaults.hasDotnet).toBe(false);
-        expect(defaults.hasNodeOnly).toBe(false);
-    });
-    it("includes a repo rules base string with architecture context", () => {
-        const dotnetDefaults = generateStackDefaults(makeInspection({
-            solutionFiles: ["app.slnx"],
-        }));
-        expect(dotnetDefaults.repoRulesBase).toContain("Clean Architecture");
-        const nodeDefaults = generateStackDefaults(makeInspection({
-            pnpmLockfile: true,
-        }));
-        expect(nodeDefaults.repoRulesBase).toContain("Node.js");
-    });
-});
-describe("injectStackEnv", () => {
-    it("injects VERIFY_COMMANDS into a worker that has an env block", () => {
-        const content = `---
-env:
-  REPO_RULES: "some rules"
-description: test
----`;
-        const defaults = generateStackDefaults(makeInspection({
-            solutionFiles: ["app.slnx"],
-        }));
-        const result = injectStackEnv(content, defaults);
-        expect(result).toContain('VERIFY_COMMANDS: "dotnet restore && dotnet build -c Release --no-restore && dotnet test"');
-    });
-    it("injects pnpm verification when no .slnx is present", () => {
-        const content = `---
-env:
-  REPO_RULES: "some rules"
----`;
-        const defaults = generateStackDefaults(makeInspection({
-            pnpmLockfile: true,
-        }));
-        const result = injectStackEnv(content, defaults);
-        expect(result).toContain('VERIFY_COMMANDS: "pnpm verify"');
-    });
-});
-const OPENCODE_CI_MD = `---
-env:
-  AGENTMEMORY_VERSION: "0.9.28"
-  CODEGRAPH_VERSION: "1.5.0"
-description: Shared CI setup.
-
-pre-agent-steps:
-  - name: Install RTK
-    run: |
-      rtk --version
-      rtk init -g --opencode --auto-patch
-  - name: Install opencode plugin dependencies
-    run: |
-      set -euo pipefail
-      if [ ! -f .opencode/package.json ]; then
-        echo "No .opencode/package.json, nothing to install"
-        exit 0
-      fi
-  - name: Install workspace dependencies
-    run: pnpm install --frozen-lockfile
-  - name: Merge the CI-only OpenCode provider into opencode.jsonc
-    run: |
-      jq -e . "$FRAGMENT" > /dev/null
----`;
-describe("generateOpencodeCi", () => {
-    it("adds NuGet cache and restores detected solution when .slnx is found", () => {
-        const result = generateOpencodeCi(OPENCODE_CI_MD, makeInspection({
-            solutionFiles: ["apps/api/Contoso.slnx"],
-        }));
-        expect(result).toContain("Cache NuGet packages");
-        expect(result).toContain("Restore .NET dependencies");
-        expect(result).toContain("dotnet restore apps/api/Contoso.slnx");
-        expect(result).toContain("\n  - name: Restore .NET dependencies\n");
-        expect(result).not.toContain("\n    - name: Restore .NET dependencies\n");
-    });
-    it("uses POSIX separators for .NET restore commands", () => {
-        const result = generateOpencodeCi(OPENCODE_CI_MD, makeInspection({
-            solutionFiles: ["apps\\api\\Contoso.slnx"],
-        }));
-        expect(result).toContain("dotnet restore apps/api/Contoso.slnx");
-        expect(result).not.toContain("dotnet restore apps\\api\\Contoso.slnx");
-    });
-    it("adds the pinned OpenSpec CLI install step when openspec/ directory exists", () => {
-        const result = generateOpencodeCi(OPENCODE_CI_MD, makeInspection({
-            openSpec: true,
-        }));
-        expect(result).toContain("Install OpenSpec CLI");
-        expect(result).toContain("@fission-ai/openspec@1.8.0");
-    });
-    it("adds both NuGet and OpenSpec steps when both are detected", () => {
-        const result = generateOpencodeCi(OPENCODE_CI_MD, makeInspection({
-            solutionFiles: ["app.slnx"],
-            openSpec: true,
-        }));
-        expect(result).toContain("Cache NuGet packages");
-        expect(result).toContain("Install OpenSpec CLI");
-    });
-    it("does not add NuGet steps when no .slnx is present", () => {
-        const result = generateOpencodeCi(OPENCODE_CI_MD, makeInspection({
-            pnpmLockfile: true,
-        }));
-        expect(result).not.toContain("Cache NuGet packages");
-        expect(result).not.toContain("Restore .NET dependencies");
-    });
-    it("preserves the original merge step", () => {
-        const result = generateOpencodeCi(OPENCODE_CI_MD, makeInspection({
-            solutionFiles: ["app.slnx"],
-            openSpec: true,
-        }));
-        expect(result).toContain("Merge the CI-only OpenCode provider");
-    });
-});
-const OPENCODE_CI_JSON = `{
-  "$schema": "https://opencode.ai/config.json",
-  "model": "plainconcepts/glm-5-3",
-  "plugin": [],
-  "default_agent": "ci-workflow-agent",
-  "agent": {
-    "ci-workflow-agent": {
-      "description": "Executes GitHub Agentic Workflow tasks in CI.",
-      "mode": "primary",
-      "prompt": "You execute the GitHub Agentic Workflow task in the user prompt."
-    }
-  },
-  "permission": {
-    "read": "allow"
-  },
-  "lsp": {
-    "csharp": {
-      "disabled": true
-    },
-    "fsharp": {
-      "disabled": true
-    },
-    "razor": {
-      "disabled": true
-    }
-  },
-  "provider": {
-    "plainconcepts": {
-      "api": "http://172.30.0.30:10000",
-      "options": {
-        "apiKey": "awf-openai-proxy"
-      },
-      "models": {
-        "glm-5-3": {
-          "name": "GLM 5.3"
-        },
-        "glm-5-2": {
-          "name": "GLM 5.2"
-        }
-      }
-    }
-  }
-}
-`;
-describe("generateOpencodeConfig", () => {
-    it("keeps LSP section when .slnx is present", () => {
-        const result = generateOpencodeConfig(OPENCODE_CI_JSON, makeInspection({
-            solutionFiles: ["app.slnx"],
-        }));
-        const parsed = JSON.parse(result);
-        expect(parsed.lsp).toBeDefined();
-        expect(parsed.lsp.csharp.disabled).toBe(true);
-        expect(parsed.lsp.fsharp.disabled).toBe(true);
-        expect(parsed.lsp.razor.disabled).toBe(true);
-    });
-    it("removes LSP section when no .slnx is present", () => {
-        const result = generateOpencodeConfig(OPENCODE_CI_JSON, makeInspection({
-            pnpmLockfile: true,
-        }));
-        const parsed = JSON.parse(result);
-        expect(parsed.lsp).toBeUndefined();
-    });
-    it("adds .NET guardrails to agent prompt when .slnx is present and prompt lacks them", () => {
-        const result = generateOpencodeConfig(OPENCODE_CI_JSON, makeInspection({
-            solutionFiles: ["app.slnx"],
-        }));
-        const parsed = JSON.parse(result);
-        expect(parsed.agent["ci-workflow-agent"].prompt).toContain(".NET guardrails");
-        expect(parsed.agent["ci-workflow-agent"].prompt).toContain("Clean Architecture");
-    });
-    it("adds Node/React rules to agent prompt when no .slnx", () => {
-        const result = generateOpencodeConfig(OPENCODE_CI_JSON, makeInspection({
-            pnpmLockfile: true,
-        }));
-        const parsed = JSON.parse(result);
-        expect(parsed.agent["ci-workflow-agent"].prompt).toContain("Node/React rules");
-        expect(parsed.agent["ci-workflow-agent"].prompt).toContain("Feature-Sliced Design");
-    });
-    it("preserves both models in the provider", () => {
-        const result = generateOpencodeConfig(OPENCODE_CI_JSON, makeInspection({
-            solutionFiles: ["app.slnx"],
-        }));
-        const parsed = JSON.parse(result);
-        expect(parsed.provider.plainconcepts.models["glm-5-3"]).toBeDefined();
-        expect(parsed.provider.plainconcepts.models["glm-5-2"]).toBeDefined();
-    });
-    it("preserves the plainconcepts provider and its API URL", () => {
-        const result = generateOpencodeConfig(OPENCODE_CI_JSON, makeInspection({
-            solutionFiles: ["app.slnx"],
-        }));
-        const parsed = JSON.parse(result);
-        expect(parsed.provider.plainconcepts.api).toBe("http://172.30.0.30:10000");
-        expect(parsed.provider.plainconcepts.options.apiKey).toBe("awf-openai-proxy");
-    });
-    it("does not add .NET guardrails twice when already present", () => {
-        const withGuardrails = OPENCODE_CI_JSON.replace('"You execute the GitHub Agentic Workflow task in the user prompt."', '"You execute the GitHub Agentic Workflow task in the user prompt.\\n\\n# .NET guardrails\\nFollow Clean Architecture."');
-        const result = generateOpencodeConfig(withGuardrails, makeInspection({
-            solutionFiles: ["app.slnx"],
-        }));
-        const parsed = JSON.parse(result);
-        const guardrailsCount = (parsed.agent["ci-workflow-agent"].prompt.match(/\.NET guardrails/g) ?? []).length;
-        expect(guardrailsCount).toBe(1);
-    });
-});

package/dist/tui.test.d.ts

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