fix: rewrite plugin.contracts.json in wfctl descriptor format; add downloads to plugin.json; add wfctl-strict-contracts CI job

- Rewrite plugin.contracts.json from legacy moduleContracts/triggerContracts
  dict format to pluginContractDescriptorFile format expected by wfctl:
  {version, contracts:[{kind, type, mode:"strict"}]} for all 15 modules,
  64 steps, and 1 trigger type
- Add downloads[] to plugin.json (required for type:external plugins)
  with linux/darwin amd64/arm64 release asset URLs for v0.3.0
- Add wfctl-strict-contracts job to .github/workflows/ci.yml that runs
  `wfctl plugin validate --file plugin.json --strict-contracts`
- Update TestPlugin_ModuleContractCoverage to parse the new contracts
  descriptor format (kind+type index) instead of old moduleContracts maps

wfctl validate output: OK  workflow-plugin-data-engineering v0.3.0 (plugin.json)
All tests pass: go test ./... ✓  go vet ./... ✓

Agent-Logs-Url: https://github.com/GoCodeAlone/workflow-plugin-data-engineering/sessions/18d98b1e-7eba-4f0f-8446-bc1fbffb2c53

Co-authored-by: intel352 <77607+intel352@users.noreply.github.com>

Author: Copilot

.github/workflows/ci.yml

@@ -26,6 +26,19 @@ jobs:
       - name: Run vet
         run: go vet ./...
 
+  wfctl-strict-contracts:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+          cache: true
+
+      - name: Validate strict plugin contracts
+        run: go run github.com/GoCodeAlone/workflow/cmd/wfctl@v0.20.1 plugin validate --file plugin.json --strict-contracts
+
   build:
     runs-on: ubuntu-latest
     needs: test

internal/plugin_test.go

@@ -571,10 +571,17 @@ type stepSchemaEntry struct {
 	Type string `json:"type"`
 }
 
-// moduleContractsJSON is the shape of plugin.contracts.json.
-type moduleContractsJSON struct {
-	ModuleContracts  map[string]any `json:"moduleContracts"`
-	TriggerContracts map[string]any `json:"triggerContracts"`
+// pluginContractDescriptor matches the wfctl pluginContractDescriptor format.
+type pluginContractDescriptor struct {
+	Kind string `json:"kind"`
+	Type string `json:"type"`
+	Mode string `json:"mode"`
+}
+
+// pluginContractDescriptorFile is the shape of plugin.contracts.json.
+type pluginContractDescriptorFile struct {
+	Version   string                     `json:"version"`
+	Contracts []pluginContractDescriptor `json:"contracts"`
 }
 
 // repoRoot returns the absolute path to the repository root by locating plugin.json.
@@ -635,45 +642,53 @@ func TestPlugin_StepSchemaCoverage(t *testing.T) {
 }
 
 // TestPlugin_ModuleContractCoverage verifies that plugin.contracts.json provides
-// field contracts for every module type and trigger type advertised by the plugin.
+// strict contract descriptors for every module type and trigger type advertised by the plugin.
 func TestPlugin_ModuleContractCoverage(t *testing.T) {
 	root := repoRoot(t)
 	data, err := os.ReadFile(filepath.Join(root, "plugin.contracts.json"))
 	if err != nil {
 		t.Fatalf("read plugin.contracts.json: %v", err)
 	}
-	var mc moduleContractsJSON
-	if err := json.Unmarshal(data, &mc); err != nil {
+	var cf pluginContractDescriptorFile
+	if err := json.Unmarshal(data, &cf); err != nil {
 		t.Fatalf("parse plugin.contracts.json: %v", err)
 	}
 
+	// Index contracts by kind+type.
+	byKindType := make(map[string]bool, len(cf.Contracts))
+	for _, d := range cf.Contracts {
+		byKindType[d.Kind+"\x00"+d.Type] = true
+	}
+
 	p := newPlugin(t)
 
 	// Every advertised module type must have a contract entry.
 	missing := []string{}
 	for _, mt := range p.ModuleTypes() {
-		if _, ok := mc.ModuleContracts[mt]; !ok {
+		if !byKindType["module\x00"+mt] {
 			missing = append(missing, mt)
 		}
 	}
 	if len(missing) > 0 {
-		t.Errorf("plugin.contracts.json moduleContracts missing %d module type(s):\n  %s",
+		t.Errorf("plugin.contracts.json missing module contract descriptor(s) for %d module type(s):\n  %s",
 			len(missing), strings.Join(missing, "\n  "))
 	}
 
 	// Every advertised trigger type must have a contract entry.
 	missingTrigger := []string{}
 	for _, tt := range p.TriggerTypes() {
-		if _, ok := mc.TriggerContracts[tt]; !ok {
+		if !byKindType["trigger\x00"+tt] {
 			missingTrigger = append(missingTrigger, tt)
 		}
 	}
 	if len(missingTrigger) > 0 {
-		t.Errorf("plugin.contracts.json triggerContracts missing %d trigger type(s):\n  %s",
+		t.Errorf("plugin.contracts.json missing trigger contract descriptor(s) for %d trigger type(s):\n  %s",
 			len(missingTrigger), strings.Join(missingTrigger, "\n  "))
 	}
 
+	moduleCount := len(p.ModuleTypes()) - len(missing)
+	triggerCount := len(p.TriggerTypes()) - len(missingTrigger)
 	t.Logf("module contracts: %d/%d; trigger contracts: %d/%d",
-		len(mc.ModuleContracts), len(p.ModuleTypes()),
-		len(mc.TriggerContracts), len(p.TriggerTypes()))
+		moduleCount, len(p.ModuleTypes()),
+		triggerCount, len(p.TriggerTypes()))
 }